Secure context: This feature is available only in secure contexts (HTTPS), in some or all supporting browsers.
The promptStreaming() method of the LanguageModel interface sends input to the language model and returns a ReadableStream that delivers the model's response incrementally as it is generated.
This is useful for displaying responses to users incrementally for outputs that take a long time to complete, or for any scenario where perceived latency should be minimized. Consume the stream using for await...of or by attaching a reader via ReadableStream.getReader().
promptStreaming(input)
promptStreaming(input, options)inputThe content to prompt the model with. This is either:
roleA string indicating the point of view the message is phrased from. Must be one of:
systemA system-level instruction that guides the model's overall behavior. This must be the first instruction passed to the model.
userA message from the user, which the API should respond to.
assistantAn input that provides context for the AI assistant, such as its persona or the format of its responses. Such messages mainly serve to provide context/history, and further shape how the model responds.
contentA string representing a textual prompt, or an array of objects. Each object includes the following properties:
typeAn enumerated value representing the type of content. This can be one of:
audioAudio content.
imageImage content.
textTextual content.
tool-callA tool invocation issued by the model.
tool-responseThe result of a tool invocation.
valueThe content of the message. If the type is text, this is always a string. If the type is audio or image, the value can be one of several different object types; see What data types are accepted?.
prefix OptionalA boolean, defaulting to false. When true, the message is treated as a prefix for the model's next generated response rather than a complete turn.
options OptionalOptions for creating a prompt. Properties include:
responseConstraintAn object following the structure defined by JSON Schema defining the precise format the model's output should be delivered in. When provided and omitResponseConstraintInput is false, any implementation-defined constraint-description message is included in the measurement.
omitResponseConstraintInputA boolean; when true, the automatic constraint-description message is excluded from the measurement.
signalAn AbortSignal to cancel the operation.
A ReadableStream of String chunks. Each chunk represents a piece of the model's response as it is generated. The stream closes when generation completes.
Errors are surfaced as stream errors rather than as rejected promises. Consumers should handle errors using a stream's standard error-handling mechanisms.
AbortError DOMExceptionThrown if the operation was cancelled via the signal option.
NotAllowedError DOMExceptionThrown if usage of the method is blocked by a language-model Permissions-Policy.
NotSupportedError DOMExceptionThrown if:
role is assistant and its type is anything other than text.type is text and its value is not a string.type is image or audio but the type was not listed in expectedInputs, or the value is not an accepted data type.OperationError DOMExceptionThrown if the prompt fails for any other reason not listed in the other exception types.
QuotaExceededError DOMExceptionThrown if the prompt would cause the session's context usage to exceed the model's LanguageModel.contextWindow.
SyntaxError DOMExceptionThrown if:
prefix property is set to true and:role is not assistant.TypeErrorThrown if:
omitResponseConstraintInput is true but responseConstraint is not provided.role is system but it was not the first message passed to the context.The promptStreaming() method adds the provided input to the context window and generates a response. The entire response is receives incrementally as a ReadableStream.
To receive the response as one complete string, use LanguageModel.prompt() instead. To add content to the context window without generating a response, use LanguageModel.append().
Each call to promptStreaming() adds to the session's context. To branch from a given state without affecting the original session, call LanguageModel.clone().
This example writes out chunks from a promptStreaming() call's ReadableStream as they arrive.
const session = await LanguageModel.create();
const output = document.querySelector("#output");
const stream = session.promptStreaming("Write a short poem about the ocean.");
for await (const chunk of stream) {
output.textContent += chunk;
}See also Using the Prompt API > Complete streaming example.
This example shows how to use an AbortController with promptStreaming().
const controller = new AbortController();
document
.querySelector("#stop")
.addEventListener("click", () => controller.abort());
const stream = session.promptStreaming("Tell me a long story.", {
signal: controller.signal,
});
try {
for await (const chunk of stream) {
output.textContent += chunk;
}
} catch (err) {
if (err.name === "AbortError") {
console.log("Streaming was stopped by the user.");
}
}In this example, chunks from a ReadableStream are collected before the whole stream is written out.
const session = await LanguageModel.create();
const stream = session.promptStreaming("Explain quantum entanglement.");
const chunks = [];
for await (const chunk of stream) {
chunks.push(chunk);
}
const fullResponse = chunks.join("");
console.log(fullResponse);