Prompt API

1. Return the result of creating an AI model object given options , " language-model ", validate and canonicalize language model options , compute language model options availability , download the language model , initialize the language model , create a language model object , and false.

1. If options [" samplingMode "] exists and either options [" topK "] exists or options [" temperature "] exists , then throw a TypeError .

2. If options [" expectedInputs "] exists , then for each expected of options [" expectedInputs "]:

   1. If expected [" languages "] exists , then Validate validate and canonicalize language tags given expected and " languages ".

3. Let hasToolCallInExpectedOutputs be false.

4. If options [" expectedOutputs "] exists , then for each expected of options [" expectedOutputs "]:

   1. If expected [" type "] is " tool-call ", then set hasToolCallInExpectedOutputs to true.

   2. If expected [" languages "] exists , then Validate validate and canonicalize language tags given expected and " languages ".

5. If options [" tools "] is not empty , then:

   1. If hasToolCallInExpectedOutputs is false, then throw a TypeError .

   2. Let toolNames be an empty ordered set of strings .

   3. For each tool of options [" tools "]:

      1. If tool [" name "] is the empty string , then throw a TypeError .

      2. If toolNames contains tool [" name "], then throw a TypeError .

      3. Append tool [" name "] to toolNames .

      4. If tool [" description "] is the empty string , then throw a TypeError .

      5. Let schema be tool [" inputSchema "].

      6. Let typeValue be ? Get \( schema , "type").

      7. If typeValue is not " object ", then throw a TypeError .

      8. Let propertiesValue be ? Get \( schema , "properties").

      9. If propertiesValue is not undefined and propertiesValue is not an Object , then throw a TypeError .

      10. Let requiredValue be ? Get \( schema , "required").

      11. If requiredValue is not undefined and ? IsArray ( requiredValue ) is false, then throw a TypeError .

      12. Perform ? serialize a JavaScript value to a JSON string given schema .

6. If options [" initialPrompts "] exists and is not empty , then:

   1. Let expectedInputs be options [" expectedInputs "] if it exists ; otherwise an empty list .

   2. Let expectedInputTypes be the result of get the expected content types given expectedInputs .

   3. Perform validating and canonicalizing a prompt given options [" initialPrompts "], expectedInputTypes , and false.

1. Assert : these steps are running in parallel .

2. Initiate the download process for everything the user agent needs to prompt a language model according to options . This could include a base AI model, fine-tunings for specific languages or option values, or other resources.

3. If the download process cannot be started for any reason, then return false.

4. Return true.

1. Assert : these steps are running in parallel .

2. Let availability be the result of compute language model options availability given options .

   1. If availability is null or unavailable , then return a DOMException error information whose name is " NotSupportedError " and whose details contain appropriate detail.

3. Perform any necessary initialization operations for the AI model backing the user agent’s prompting capabilities.

   This could include loading the appropriate model and any fine-tunings necessary to support options into memory.

   1. If options [" initialPrompts "] exists is not empty , then:

      1. Let expectedInputs be options [" expectedInputs "] if it exists ; otherwise an empty list .

      2. Let expectedInputTypes be the result of get the expected content types given expectedInputs .

      3. Let initialMessages be the result of validating and canonicalizing a prompt given options [" initialPrompts "], expectedInputTypes , and false.

      4. Load initialMessages into the model’s context window.

   2. If options [" tools "] exists is not empty , then load options [" tools "] into the model’s context window.

4. If initialization failed because the process of loading options resulted in using up all of the model’s context window, then:

   1. Let requested be the amount of context window needed to encode options . The encoding of options as input is implementation-defined .

   2. Let maximum be the maximum context window size that the user agent supports.

   3. Assert : requested is greater than maximum . (That is how we reached this error branch.)

   4. Return a quota exceeded error information whose requested is requested and quota is maximum .

5. If initialization failed for any other reason, then return a DOMException error information whose name is " OperationError " and whose details contain appropriate detail.

6. Return null.

1. Assert : these steps are running on realm ’s surrounding agent ’s event loop .

2. Let contextWindowSize be the amount of context window that is available to the user agent for this model. (This value is implementation-defined , and may be +∞ if there are no specific limits beyond, e.g., the user’s memory, or the limits of JavaScript strings.)

3. Let initialMessages be an empty list of LanguageModelMessage s.

4. Let initialMessagesUsage tools be options [" tools "].

5. Let initialContextUsage be 0.

6. If options [" initialPrompts "] exists and is not empty , then:

   1. Let expectedInputs be options [" expectedInputs "] if it exists ; otherwise an empty list .

   2. Let expectedInputTypes be the result of get the expected content types given expectedInputs .

   3. Set initialMessages to the result of validating and canonicalizing a prompt given options [" initialPrompts "], expectedInputTypes , and false.

7. If initialMessages is not empty or tools is not empty , then:

   1. Set initialMessagesUsage initialContextUsage to the result amount of measure language model context usage given window used to encode initialMessages , and options [" signal "]. tools .

8. Return a new LanguageModel object, created in realm , with

   initial messages

   initialMessages

   top K

   options [" topK "] if it exists ; otherwise an implementation-defined value

   temperature

   options [" temperature "] if it exists ; otherwise an implementation-defined value

   sampling mode

   options [" samplingMode "] if it exists ; otherwise null if options [" topK "] exists or options [" temperature "] exists ; otherwise " balanced "

   expected inputs

   options [" expectedInputs "] if it exists ; otherwise an empty list

   expected outputs

   options [" expectedOutputs "] if it exists ; otherwise an empty list

   tools

   options [" tools "] if it exists ; otherwise an empty list

   context window size

   contextWindowSize

   current context usage

   initialMessagesUsage initialContextUsage

1. Return the result of computing AI model availability given options , " language-model ", validate and canonicalize language model options , and compute language model options availability .

1. Assert : this algorithm is running in parallel .

2. Let availability be the language model non-options availability .

3. If availability is null, then return null.

4. Let availabilities be a list containing availability .

5. Let inputPartition be the result of getting the language availabilities partition given the purpose of prompting a language model with text in that language.

6. Let outputPartition be the result of getting the language availabilities partition given the purpose of producing language model output in that language.

7. If options [" expectedInputs "] exists , then for each expected of options [" expectedInputs "]:

   1. If expected [" languages "] exists , then:

      1. Let inputLanguageAvailability be the result of computing language availability given expected [" languages "] and inputPartition .

      2. Append inputLanguageAvailability to availabilities .

   2. Let inputTypeAvailability be the language model content type availability given expected [" type "] and true.

   3. Append inputTypeAvailability to availabilities .

8. If options [" expectedOutputs "] exists , then for each expected of options [" expectedOutputs "]:

   1. If expected [" languages "] exists , then:

      1. Let outputLanguageAvailability be the result of computing language availability given expected [" languages "] and outputPartition .

      2. Append outputLanguageAvailability to availabilities .

   2. Let outputTypeAvailability be the language model content type availability given expected [" type "] and false.

   3. Append outputTypeAvailability to availabilities .

9. Return the minimum availability given availabilities .

1. Assert : this algorithm is running in parallel .

2. If there is some error attempting to determine whether the user agent can support prompting a language model, which the user agent believes to be transient (such that re-querying could stop producing such an error), then return null.

3. If the user agent currently supports prompting a language model, then return " available ".

4. If the user agent believes it will be able to support prompting a language model, but only after finishing a download that is already ongoing, then return " downloading ".

5. If the user agent believes it will be able to support prompting a language model, but only after performing a not-currently-ongoing download, then return " downloadable ".

6. Otherwise, return " unavailable ".

1. Assert : this algorithm is running in parallel .

2. If the user agent currently supports type as an input if isInput is true, or as an output if isInput is false, then return " available ".

3. If the user agent believes it will be able to support type as such, but only after finishing a download that is already ongoing, then return " downloading ".

4. If the user agent believes it will be able to support type as such, but only after performing a not-currently-ongoing download, then return " downloadable ".

5. Otherwise, return " unavailable ".

1. Let responseConstraint be options [" responseConstraint "] if it exists ; otherwise null.

2. Let omitResponseConstraintInput be options [" omitResponseConstraintInput "].

3. Let hasNonTextExpectedOutput be false.

4. For each expected of this ’s expected outputs :

   1. If expected [" type "] is not " text ", then set hasNonTextExpectedOutput to true.

5. Let contents be an empty list of LanguageModelMessageContent s.

6. Let text be the empty string .

7. Let operation be an algorithm step which takes arguments chunkProduced , done , error , and stopProducing , and performs the following steps:

   1. Let prefillSuccess be the result of prefilling given this , input , omitResponseConstraintInput , responseConstraint , error , and stopProducing .

   2. If prefillSuccess is true, false, then return.

   3. If hasNonTextExpectedOutput is false:

      1. generate Generate given this , responseConstraint , chunkProduced , done , error , and stopProducing .

      2. Return.

   4. Return Let onChunk be an algorithm step which takes argument chunk and performs the following steps:

      1. If chunk is a string :

         1. Set text to the concatenation of text and chunk .

      2. Otherwise:

         1. Assert : chunk is a LanguageModelMessageContent .

         2. If text is not the empty string :

            1. Append «[ " type " → " text ", " value " → text ]» to contents .

            2. Set text to the empty string .

         3. Append chunk to contents .

   5. Let onDone be an algorithm step which takes no arguments and performs the following steps:

      1. If text is not the empty string or contents is empty :

         1. Append «[ " type " → " text ", " value " → text ]» to contents .

      2. If done is not null, then perform done .

   6. Generate given this , responseConstraint , onChunk , onDone , error , and stopProducing .

8. Let promise be the result of getting an aggregated AI model result given this , options , and operation .

9. If hasNonTextExpectedOutput is false, then return promise .

10. Return the result of reacting to promise with a fulfillment handler that returns contents .

1. Let responseConstraint be options [" responseConstraint "] if it exists ; otherwise null.

2. Let omitResponseConstraintInput be options [" omitResponseConstraintInput "].

3. Let operation be an algorithm step which takes arguments chunkProduced , done , error , and stopProducing , and performs the following steps:

   1. Let prefillSuccess be the result of prefilling given this , input , omitResponseConstraintInput , responseConstraint , error , and stopProducing .

   2. If prefillSuccess is true, then generate given this , responseConstraint , chunkProduced , done , error , and stopProducing .

4. Return the result of getting a streaming AI model result given this , options , and operation .

1. Let operation be an algorithm step which takes arguments chunkProduced , done , error , and stopProducing , and performs the following steps:

   chunkProduced is never called because the prefilling algorithm does not generate chunks.

   1. Let prefillSuccess be the result of prefilling given this , input , false, null, error , and stopProducing .

   2. If prefillSuccess is true and done is not null, then perform done .

2. Return the result of getting an aggregated AI model result given this , options , and operation .

1. If options [" omitResponseConstraintInput "] is true and options [" responseConstraint "] does not exist , then throw a " TypeError " DOMException .

2. Let expectedInputTypes be the result of get the expected content types given this ’s expected inputs .

3. Let messages be the result of validating and canonicalizing a prompt given input , expectedInputTypes , and false.

4. If options [" responseConstraint "] exists and is not null and options [" omitResponseConstraintInput "] is false, then implementations may insert an implementation-defined LanguageModelMessage to messages to guide the model’s behavior.

5. Let measureUsage be an algorithm step which takes argument stopMeasuring , and returns the result of measuring language model context usage given messages , and stopMeasuring .

6. Return the result of measuring AI model input usage given this , options , and measureUsage .

1. Return the result of running the measureContextUsage() method steps given input and options .

1. Return the result of cloning a language model given this and options .

• a LanguageModel model ,

• a LanguageModelPrompt input ,

• a boolean omitResponseConstraintInput ,

• an object-or-null responseConstraint ,

• an algorithm-or-null error that takes error information and returns nothing, and

• an algorithm-or-null stopPrefilling that takes no arguments and returns a boolean,

perform the following steps:

1. Assert : this algorithm is running in parallel .

2. Let expectedInputTypes be the result of get the expected content types given model ’s expected inputs .

3. Let messages be the result of validating and canonicalizing a prompt given input , expectedInputTypes , and true if model ’s current context usage is greater than 0, otherwise false.

   If this throws an exception e , then:

   1. If error is not null, perform error given a DOMException error information whose name is e ’s name and whose details contain appropriate detail.

   2. Return false.

4. If responseConstraint is not null and omitResponseConstraintInput is false, then implementations may insert an implementation-defined LanguageModelMessage to messages to guide the model’s behavior.

5. Let requested be the result of measuring language model context usage given messages , and stopPrefilling .

6. If requested is null, then return false.

7. If requested is an error information , then:

   1. If error is not null, perform error given requested .

   2. Return false.

8. Assert : requested is a number.

9. If model ’s current context usage + requested is greater than model ’s context window size , then:

   1. If error is not null, then:

      1. Let errorInfo be a quota exceeded error information with a requested of model ’s current context usage + requested and a quota of model ’s context window size .

      2. Perform error given errorInfo .

   2. Return false.

10. Let expectedInputTypes be the result of get the expected content types given model ’s expected inputs . In an implementation-defined manner, update the underlying model’s internal state to include messages .

    The process should use model ’s initial messages , model ’s sampling mode , model ’s top K , model ’s temperature , model ’s expected inputs , model ’s expected outputs , and model ’s tools to guide how the state is updated.

    The process must conform to the guidance given in § 4 Privacy considerations and § 5 Security considerations .

    If during this process stopPrefilling returns true, then return false.

    If an error occurred during prefilling:

    1. Let the error be represented as error information errorInfo according to the guidance in § 3.3.4 Errors .

    2. If error is not null, perform error given errorInfo .

    3. Return false.

11. Set model ’s current context usage to model ’s current context usage + requested .

12. Return true.

• a LanguageModel model ,

• an object-or-null responseConstraint ,

• an algorithm-or-null chunkProduced that takes a string or a LanguageModelMessageContent and returns nothing,

• an algorithm-or-null done that takes no arguments and returns nothing,

• an algorithm-or-null error that takes error information and returns nothing, and

• an algorithm-or-null stopProducing that takes no arguments and returns a boolean,

perform the following steps:

1. Assert : this algorithm is running in parallel .

2. In an implementation-defined manner, subject to the following guidelines, begin the process of producing a response from the language model based on its current internal state.

   The process should use model ’s initial messages , model ’s sampling mode , model ’s top K , model ’s temperature , model ’s expected inputs , model ’s expected outputs , model ’s tools , and responseConstraint to guide the model’s behavior.

   The prompting process must conform to the guidance given in § 4 Privacy considerations and § 5 Security considerations .

   If model ’s tools is not empty, empty , the model may use produce one or more tool calls based on the provided declared tools by calling their in execute model functions. ’s tools , in addition to or instead of text.

3. While true:

   1. Wait for the next chunk of response data (text or a tool call) to be produced, for the process to finish, or for the result of calling stopProducing to become true.

   2. If such a text chunk is successfully produced:

      1. Let it be represented as a string chunk .

      2. If chunkProduced is not null, perform chunkProduced given chunk .

   3. Otherwise, if a tool call is successfully produced:

      1. Let callId be an implementation-defined non-empty string identifying the tool call.

      2. Let name be a string representing the name of the tool being called.

      3. Let arguments be an Object representing the JSON object of arguments for the tool call, created in model ’s relevant realm .

      4. Let toolCall be a new LanguageModelToolCall created in model ’s relevant realm with call ID set to callId , name set to name , and arguments set to arguments .

      5. Let toolCallContent be a LanguageModelMessageContent initialized with «[ " type " → " tool-call ", " value " → toolCall ]» .

      6. If chunkProduced is not null, perform chunkProduced given toolCallContent .

   4. Otherwise, if the process has finished:

      1. In an implementation-defined manner, update the underlying model’s internal state and model ’s current context usage to include the generated response (both text and any tool calls).

      2. If done is not null, perform done .

      3. Break .

   5. Otherwise, if stopProducing returns true, then break .

   6. Otherwise, if an error occurred during prompting:

      1. Let the error be represented as error information errorInfo according to the guidance in § 3.3.4 Errors .

      2. If error is not null, perform error given errorInfo .

      3. Break .

• a list of LanguageModelMessage messages ,

• an algorithm stopMeasuring that takes no arguments and returns a boolean,

perform the following steps:

1. Assert : this algorithm is running in parallel .

2. Let inputToModel be the implementation-defined input that would be sent to the underlying model in order to prefill given messages .

   This will generally consist of the encoding of all of the inputs, possibly with prompt engineering or other implementation-defined wrappers.

   If during this process stopMeasuring starts returning true, then return null.

   If an error occurs during this process, then return an appropriate DOMException error information according to the guidance in § 3.3.4 Errors .

3. Return the amount of context usage needed to represent inputToModel when given to the underlying model. The exact calculation procedure is implementation-defined , subject to the following constraints.

   The returned context usage must be nonnegative and finite. It should be roughly proportional to the amount of data in inputToModel .

   This might be the number of tokens needed to represent the input in a language model tokenization scheme , or it might be related to the size of the data in bytes.

   If during this process stopMeasuring starts returning true, then instead return null.

   If an error occurs during this process, then instead return an appropriate DOMException error information according to the guidance in § 3.3.4 Errors .

1. Let expectedTypes be an empty list of LanguageModelMessageType s.

2. For each expected of expectedContents :

   1. If expectedTypes does not contain expected [" type "], then append expected [" type "] to expectedTypes .

3. If expectedTypes does not contain " text ", then append " text " to expectedTypes .

4. Return expectedTypes .

1. Assert : expectedTypes contains " text ".

2. If input is a string , then return « «[ " role " → " user ", " content " → « «[ " type " → " text ", " value " → input ]» », " prefix " → false ]» » .

3. Assert : input is a list of LanguageModelMessage s.

4. If input is an empty list , then return « «[ " role " → " user ", " content " → « «[ " type " → " text ", " value " → "" ]» », " prefix " → false ]» » .

5. Let messages be an empty list of LanguageModelMessage s.

6. For each message of input :

   1. If message [" content "] is a string , then set message to «[ " role " → message [" role "], " content " → « «[ " type " → " text ", " value " → message [" content "] ]» », " prefix " → message [" prefix "] ]» .

   2. If message [" prefix "] is true, then:

      1. If message [" role "] is not " assistant ", then throw a " SyntaxError " DOMException .

      2. If message is not the last item in messages input , then throw a " SyntaxError " DOMException .

   3. If message [" role "] is " system ", then:

      1. If hasAppendedInput is true, then throw a " TypeError " DOMException .

   4. If message [" content "] is an empty list , then:

      1. Let emptyContent be a new LanguageModelMessageContent initialized with «[ " type " → " text ", " value " → "" ]» .

      2. append Append emptyContent to message [" content "].

   5. For each content of message [" content "]:

      1. If content [" type "] is " tool-call " and message [" role "] is not " assistant ", then throw a TypeError .

      2. If content [" type "] is " tool-response " and message [" role "] is not " user ", then throw a TypeError .

      3. If message [" role "] is " assistant " and content [" type "] is not " text image " or " audio ", then throw a " NotSupportedError " DOMException .

      4. If content [" type "] is " text " and content [" value "] is not a string , then throw a " TypeError " DOMException .

      5. If content [" type "] is " image ", then:

         1. If expectedTypes does not contain " image ", then throw a " NotSupportedError " DOMException .

         2. If content [" value "] is not an ImageBitmapSource or BufferSource , then throw a TypeError .

      6. If content [" type "] is " audio ", then:

         1. If expectedTypes does not contain " audio ", then throw a " NotSupportedError " DOMException .

         2. If content [" value "] is not an AudioBuffer , BufferSource , or Blob , then throw a TypeError .

      7. If content [" type "] is " tool-call ", then:

         1. If expectedTypes does not contain " tool-call ", then throw a " NotSupportedError " DOMException .

         2. If content [" value "] is not a LanguageModelToolCall , then throw a TypeError .

         3. Let arguments be content [" value "]'s arguments .

         4. If arguments is not null, then:

            1. If ? IsArray ( arguments ) is true, or arguments is a platform object , or arguments cannot be serialized to a JSON object (for example, due to circular references or non-JSON-serializable values such as functions or BigInts), then throw a " DataError " DOMException .

      8. If content [" type "] is " audio tool-response ", then:

         1. If expectedTypes does not contain " audio tool-response ", then throw a " NotSupportedError " DOMException .

         2. If content [" value "] is not a LanguageModelToolResponse , then throw a TypeError .

         3. If content [" value "] is a LanguageModelToolSuccess , then for each resultItem of content [" value "]'s result :

            1. If resultItem [" type "] is " image " or " audio " and the user agent does not support multimodal tool result content, then throw a " NotSupportedError " DOMException .

            2. If resultItem [" type "] is " text " and resultItem [" value "] is not a string , then throw a TypeError .

            3. If resultItem [" type "] is " image " and resultItem [" value "] is not an ImageBitmapSource or BufferSource , then throw a TypeError .

            4. If resultItem [" type "] is " audio " and resultItem [" value "] is not an AudioBuffer , BufferSource , or Blob , then throw a TypeError .

            5. If resultItem [" type "] is " object ", then:

               1. If resultItem [" value "] is not an Object , then throw a TypeError .

               2. If resultItem [" value "] is a platform object , or cannot be serialized to JSON (for example, due to circular references or non-JSON-serializable values such as functions or BigInts), then throw a " DataError " DOMException .

   6. Let contentWithContiguousTextCollapsed be an empty list of LanguageModelMessageContent s.

   7. Let lastTextContent be null.

   8. For each content of message [" content "]:

      1. If content [" type "] is " text ":

         1. If lastTextContent is null:

            1. Append content to contentWithContiguousTextCollapsed .

            2. Set lastTextContent to content .

         2. Otherwise, set lastTextContent [" value "] to the concatenation of lastTextContent [" value "] and content [" value "].

            No space or other character is added. Thus, « «[ " type " → " text ", " foo " ]», «[ " type " → " text ", " bar " ]» » is canonicalized to « «[ " type " → " text ", " foobar " ]».

      2. Otherwise:

         1. Append content to contentWithContiguousTextCollapsed .

         2. Set lastTextContent to null.

      3. Set message [" content "] to contentWithContiguousTextCollapsed .

   9. Append message to messages .

   10. Set hasAppendedInput to true.

7. If messages is empty , then throw a " SyntaxError " DOMException .

8. Return messages .

1. Let global be model ’s relevant global object .

2. Assert : global is a Window object.

3. If global ’s associated Document is not fully active , then return a promise rejected with an " InvalidStateError " DOMException .

4. Let signals be « model ’s destruction abort controller ’s signal ».

5. If options [" signal "] exists , then append it to signals .

6. Let compositeSignal be the result of creating a dependent abort signal given signals using AbortSignal and model ’s relevant realm .

7. If compositeSignal is aborted , then return a promise rejected with compositeSignal ’s abort reason .

8. Let signal be options [" signal "] if it exists ; otherwise null.

9. If signal is not null and is aborted , then return a promise rejected with signal ’s abort reason .

10. Let promise be a new promise created in model ’s relevant realm .

11. Let abortedDuringOperation be false.

    This variable will be written to from the event loop , but read from in parallel .

12. Add the following abort steps to compositeSignal :

    1. Set abortedDuringOperation to true.

    2. Reject promise with compositeSignal ’s abort reason .

13. In parallel :

    1. Queue a global task on the AI task source to perform the following steps:

       1. If abortedDuringOperation is true, then return.

       2. Let clonedModel be a new LanguageModel object with:

          • initial messages set to model ’s initial messages .

          • top K set to model ’s top K .

          • temperature set to model ’s temperature .

          • sampling mode set to model ’s sampling mode .

          • expected inputs set to model ’s expected inputs .

          • expected outputs set to model ’s expected outputs .

          • tools set to model ’s tools .

          • context window size set to model ’s context window size .

          • current context usage set to model ’s current context usage .

       3. In an implementation-defined manner, copy any other state from model to clonedModel .

       4. If the copy operation fails:

          1. Reject promise with a " OperationError " DOMException .

          2. Return.

       5. Resolve promise with clonedModel .

14. Return promise .

1. Set this ’s call ID to init [" callId "].

2. Set this ’s name to init [" name "].

3. Set this ’s arguments to init [" arguments "] if it exists ; otherwise null.

1. Set this ’s call ID to init [" callId "].

2. Set this ’s name to init [" name "].

3. Set this ’s result to the result of creating a frozen array from init [" result "].

1. Set this ’s call ID to init [" callId "].

2. Set this ’s name to init [" name "].

3. Set this ’s error message to init [" errorMessage "].