Prompt API

// The return type from prompt() method and those alike.
typedef (DOMString or sequence<LanguageModelMessageContent>) LanguageModelPromptResult;

[Exposed=Window, SecureContext]
interface LanguageModel : EventTarget {
  static Promise<LanguageModel> create(optional LanguageModelCreateOptions options = {});
  static Promise<Availability> availability(optional LanguageModelCreateCoreOptions options = {});
  // **EXPERIMENTAL**: Only available in extension and experimental contexts.
  static Promise<LanguageModelParams?> params();

  // These will throw a TypeError if role = "system"
  Promise<LanguageModelPromptResult> prompt(
    LanguageModelPrompt input,
    optional LanguageModelPromptOptions options = {}
  );
  ReadableStream promptStreaming(
    LanguageModelPrompt input,
    optional LanguageModelPromptOptions options = {}
  );
  Promise<undefined> append(
    LanguageModelPrompt input,
    optional LanguageModelAppendOptions options = {}
  );

  Promise<double> measureContextUsage(
    LanguageModelPrompt input,
    optional LanguageModelPromptOptions options = {}
  );
  readonly attribute double contextUsage;
  readonly attribute unrestricted double contextWindow;
  attribute EventHandler oncontextoverflow;

  // **DEPRECATED**: This method is only available in extension contexts.
  Promise<double> measureInputUsage(
    LanguageModelPrompt input,
    optional LanguageModelPromptOptions options = {}
  );
  // **DEPRECATED**: This attribute is only available in extension contexts.
  readonly attribute double inputUsage;
  // **DEPRECATED**: This attribute is only available in extension contexts.
  readonly attribute unrestricted double inputQuota;
  // **DEPRECATED**: This attribute is only available in extension contexts.
  attribute EventHandler onquotaoverflow;

  // **DEPRECATED**: This attribute is only available in extension contexts.
  readonly attribute unsigned long topK;
  // **DEPRECATED**: This attribute is only available in extension contexts.
  readonly attribute float temperature;

  // **EXPERIMENTAL**: Only available in experimental contexts.
  readonly attribute LanguageModelSamplingMode? samplingMode;

  Promise<LanguageModel> clone(optional LanguageModelCloneOptions options = {});
};
LanguageModel includes DestroyableModel;

// **DEPRECATED**: Only available in extension contexts.
[Exposed=Window, SecureContext]
interface LanguageModelParams {
  readonly attribute unsigned long defaultTopK;
  readonly attribute unsigned long maxTopK;
  readonly attribute float defaultTemperature;
  readonly attribute float maxTemperature;
};

// A description of a tool call that a language model can invoke.
// Note: When considering changes to this dictionary, authors should ensure
// general alignment with ModelContextTool from WebMCP
// (https://webmachinelearning.github.io/webmcp/#model-context-tool).
dictionary LanguageModelToolDeclaration {
  required DOMString name;
  required DOMString description;
  // JSON schema for the input parameters.
  required object inputSchema;
};

dictionary LanguageModelCreateCoreOptions {
  // Note: these two have custom out-of-range handling behavior, not in the IDL layer.
  // They are unrestricted double so as to allow +Infinity without failing.
  // **DEPRECATED**: Only available in extension contexts.
  unrestricted double topK;
  // **DEPRECATED**: Only available in extension contexts.
  unrestricted double temperature;

  // **EXPERIMENTAL**: Only available in experimental contexts.
  LanguageModelSamplingMode samplingMode;

  // The expected types and languages for the session.
  sequence<LanguageModelExpected> expectedInputs;
  sequence<LanguageModelExpected> expectedOutputs;

  // Tools that the language model can use.
  // **EXPERIMENTAL**: Only available in experimental contexts.
  sequence<LanguageModelToolDeclaration> tools = [];
};

dictionary LanguageModelCreateOptions : LanguageModelCreateCoreOptions {
  AbortSignal signal;
  CreateMonitorCallback monitor;

  sequence<LanguageModelMessage> initialPrompts = [];
};

dictionary LanguageModelPromptOptions {
  object responseConstraint;
  boolean omitResponseConstraintInput = false;
  AbortSignal signal;
};

dictionary LanguageModelAppendOptions {
  AbortSignal signal;
};

dictionary LanguageModelCloneOptions {
  AbortSignal signal;
};

dictionary LanguageModelExpected {
  required LanguageModelMessageType type;
  sequence<DOMString> languages;
};

// The argument to the prompt() method and others like it

typedef (
  sequence<LanguageModelMessage>
  // Shorthand for `[{ role: "user", content: [{ type: "text", value: providedValue }] }]`
  or DOMString
) LanguageModelPrompt;

dictionary LanguageModelMessage {
  required LanguageModelMessageRole role;

  // The DOMString branch is shorthand for `[{ type: "text", value: providedValue }]`
  required (DOMString or sequence<LanguageModelMessageContent>) content;

  boolean prefix = false;
};

dictionary LanguageModelMessageContent {
  required LanguageModelMessageType type;
  required LanguageModelMessageValue value;
};

enum LanguageModelSamplingMode { "most-predictable", "predictable", "slightly-predictable", "balanced", "slightly-creative", "creative", "most-creative" };

enum LanguageModelMessageRole { "system", "user", "assistant" };

enum LanguageModelMessageType { "text", "image", "audio", "tool-call", "tool-response" };

typedef (
  ImageBitmapSource
  or AudioBuffer
  or BufferSource
  or DOMString
  or LanguageModelToolCall
  or LanguageModelToolResponse
) LanguageModelMessageValue;

// The definitions of `LanguageModelToolCall` and `LanguageModelToolResponse` values
enum LanguageModelToolResultType { "text", "image", "audio", "object" };

dictionary LanguageModelToolResultContent {
  required LanguageModelToolResultType type;
  required any value;
};

// Represents a tool call requested by the language model.
[Exposed=Window, SecureContext]
interface LanguageModelToolCall {
  constructor(LanguageModelToolCallInit init);
  readonly attribute DOMString callId;
  readonly attribute DOMString name;
  readonly attribute object? arguments;
};

dictionary LanguageModelToolCallInit {
  required DOMString callId;
  required DOMString name;
  object arguments;
};

[Exposed=Window, SecureContext]
interface LanguageModelToolSuccess {
  constructor(LanguageModelToolSuccessInit init);
  readonly attribute DOMString callId;
  readonly attribute DOMString name;
  readonly attribute FrozenArray<LanguageModelToolResultContent> result;
};

dictionary LanguageModelToolSuccessInit {
  required DOMString callId;
  required DOMString name;
  required sequence<LanguageModelToolResultContent> result;
};

[Exposed=Window, SecureContext]
interface LanguageModelToolError {
  constructor(LanguageModelToolErrorInit init);
  readonly attribute DOMString callId;
  readonly attribute DOMString name;
  readonly attribute DOMString errorMessage;
};

dictionary LanguageModelToolErrorInit {
  required DOMString callId;
  required DOMString name;
  required DOMString errorMessage;
};

// The response from executing a tool call - either success or error.
typedef (LanguageModelToolSuccess or LanguageModelToolError) LanguageModelToolResponse;

The static create(options) method steps are:

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.

To validate and canonicalize language model options given a LanguageModelCreateCoreOptions options, perform the following steps. They mutate options in place to canonicalize and deduplicate language tags, and throw an exception if any are invalid.

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 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 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.

To download the language model, given a LanguageModelCreateCoreOptions options:

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.

To initialize the language model, given a LanguageModelCreateOptions options:

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"] 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"] 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.

To create a language model object, given a realm realm and a LanguageModelCreateOptions options:

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 LanguageModelMessages.

4. Let 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 initialContextUsage to the amount of context window used to encode initialMessages and 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

   tools

   context window size

   contextWindowSize

   current context usage

   initialContextUsage

The static availability(options) method steps are:

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.

To compute language model options availability given a LanguageModelCreateCoreOptions options, perform the following steps. They return either an Availability value or null, and they mutate options in place to update language tags to their best-fit matches.

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.

The language model non-options availability is given by the following steps. They return an Availability value or null.

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".

The language model content type availability given a LanguageModelMessageType type and a boolean isInput, is given by the following steps. They return an Availability value.

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".

The prompt(input, options) method steps are:

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 LanguageModelMessageContents.

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 false, then return.

   3. If hasNonTextExpectedOutput is false:

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

      2. Return.

   4. 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.

The promptStreaming(input, options) method steps are:

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.

The append(input, options) method steps are:

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.

The measureContextUsage(input, options) method steps are:

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.

The measureInputUsage(input, options) method steps are:

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

The clone(options) method steps are:

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

To prefill given:

• 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. 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.

To generate given:

• 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, the model may produce one or more tool calls based on the declared tools in model’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 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.

To measure language model context usage given:

• 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.

To get the expected content types given a list of LanguageModelExpecteds expectedContents:

1. Let expectedTypes be an empty list of LanguageModelMessageTypes.

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.

To validate and canonicalize a prompt given a LanguageModelPrompt input, a list of LanguageModelMessageTypes expectedTypes, and a boolean hasAppendedInput, perform the following steps. The return value will be a non-empty list of LanguageModelMessages in their "longhand" form.

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 LanguageModelMessages.

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 LanguageModelMessages.

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 input, then throw a "SyntaxError" DOMException.

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

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

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

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

      2. 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 "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.

      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 "tool-response", then:

         1. If expectedTypes does not contain "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 LanguageModelMessageContents.

   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.

To clone a language model given a LanguageModel model and a LanguageModelCloneOptions options:

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.

The new LanguageModelToolCall(init) constructor steps are:

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.

The new LanguageModelToolSuccess(init) constructor steps are:

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"].

The new LanguageModelToolError(init) constructor steps are:

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"].