@openrouter/sdk 0.9.11 → 0.11.2

package/esm/lib/claude-type-guards.d.ts

@@ -1,4 +1,4 @@
-import type * as models from "../models/index.js";
+import type { ClaudeMessageParam } from "../models/claude-message.js";
 /**
  * Check if input is in Claude message format
  * Uses structural analysis to detect Claude-specific patterns
@@ -6,5 +6,5 @@ import type * as models from "../models/index.js";
  * @param input - Input to check
  * @returns True if input appears to be Claude format
  */
-export declare function isClaudeStyleMessages(input: unknown): input is models.ClaudeMessageParam[];
+export declare function isClaudeStyleMessages(input: unknown): input is ClaudeMessageParam[];
 //# sourceMappingURL=claude-type-guards.d.ts.map

package/esm/lib/config.d.ts

@@ -1,4 +1,3 @@
-import type { Hook } from "../hooks/types.js";
 import { HTTPClient } from "./http.js";
 import { Logger } from "./logger.js";
 import { RetryConfig } from "./retries.js";
@@ -19,9 +18,13 @@ export type SDKOptions = {
      */
     httpReferer?: string | undefined;
     /**
-     * Allows setting the xTitle parameter for all supported operations
+     * Allows setting the appTitle parameter for all supported operations
      */
-    xTitle?: string | undefined;
+    appTitle?: string | undefined;
+    /**
+     * Allows setting the appCategories parameter for all supported operations
+     */
+    appCategories?: string | undefined;
     httpClient?: HTTPClient;
     /**
      * Allows overriding the default server used by the SDK
@@ -41,18 +44,13 @@ export type SDKOptions = {
     retryConfig?: RetryConfig;
     timeoutMs?: number;
     debugLogger?: Logger;
-    /**
-     * Hooks for request/response lifecycle events.
-     * Can be a single hook object or an array of hooks.
-     */
-    hooks?: Hook | Hook[];
 };
 export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "0.9.11";
-    readonly genVersion: "2.788.4";
-    readonly userAgent: "speakeasy-sdk/typescript 0.9.11 2.788.4 1.0.0 @openrouter/sdk";
+    readonly sdkVersion: "0.11.2";
+    readonly genVersion: "2.879.1";
+    readonly userAgent: "speakeasy-sdk/typescript 0.11.2 2.879.1 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -26,8 +26,8 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.9.11",
-    genVersion: "2.788.4",
-    userAgent: "speakeasy-sdk/typescript 0.9.11 2.788.4 1.0.0 @openrouter/sdk",
+    sdkVersion: "0.11.2",
+    genVersion: "2.879.1",
+    userAgent: "speakeasy-sdk/typescript 0.11.2 2.879.1 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/lib/conversation-state.d.ts

@@ -18,7 +18,7 @@ export declare function updateState<TTools extends readonly Tool[] = readonly To
 /**
  * Append new items to the message history
  */
-export declare function appendToMessages(current: models.OpenResponsesInput, newItems: models.OpenResponsesInput1[]): models.OpenResponsesInput;
+export declare function appendToMessages(current: models.InputsUnion, newItems: models.BaseInputsUnion[]): models.InputsUnion;
 /**
  * Check if a tool call requires approval
  * @param toolCall - The tool call to check
@@ -49,13 +49,13 @@ export declare function createRejectedResult<TTools extends readonly Tool[] = re
 /**
  * Convert unsent tool results to API format for sending to the model
  */
-export declare function unsentResultsToAPIFormat(results: UnsentToolResult[]): models.OpenResponsesFunctionCallOutput[];
+export declare function unsentResultsToAPIFormat(results: UnsentToolResult[]): models.FunctionCallOutputItem[];
 /**
  * Extract text content from a response
  */
-export declare function extractTextFromResponse(response: models.OpenResponsesNonStreamingResponse): string;
+export declare function extractTextFromResponse(response: models.OpenResponsesResult): string;
 /**
  * Extract tool calls from a response
  */
-export declare function extractToolCallsFromResponse<TTools extends readonly Tool[]>(response: models.OpenResponsesNonStreamingResponse): ParsedToolCall<TTools[number]>[];
+export declare function extractToolCallsFromResponse<TTools extends readonly Tool[]>(response: models.OpenResponsesResult): ParsedToolCall<TTools[number]>[];
 //# sourceMappingURL=conversation-state.d.ts.map

package/esm/lib/conversation-state.js

@@ -5,10 +5,11 @@ import { normalizeInputToArray } from './turn-context.js';
 function isValidUnsentToolResult(obj) {
     if (typeof obj !== 'object' || obj === null)
         return false;
-    const candidate = obj;
-    return (typeof candidate['callId'] === 'string' &&
-        typeof candidate['name'] === 'string' &&
-        'output' in candidate);
+    return ('callId' in obj &&
+        typeof obj.callId === 'string' &&
+        'name' in obj &&
+        typeof obj.name === 'string' &&
+        'output' in obj);
 }
 /**
  * Type guard to verify an object is a valid ParsedToolCall
@@ -16,10 +17,11 @@ function isValidUnsentToolResult(obj) {
 function isValidParsedToolCall(obj) {
     if (typeof obj !== 'object' || obj === null)
         return false;
-    const candidate = obj;
-    return (typeof candidate['id'] === 'string' &&
-        typeof candidate['name'] === 'string' &&
-        'arguments' in candidate);
+    return ('id' in obj &&
+        typeof obj.id === 'string' &&
+        'name' in obj &&
+        typeof obj.name === 'string' &&
+        'arguments' in obj);
 }
 /**
  * Generate a unique ID for a conversation
@@ -156,9 +158,9 @@ export function extractTextFromResponse(response) {
     const outputs = Array.isArray(response.output) ? response.output : [response.output];
     const textParts = [];
     for (const item of outputs) {
-        if (item.type === 'message' && item.content) {
+        if (item.type === 'message' && 'content' in item && item.content) {
             for (const content of item.content) {
-                if (content.type === 'output_text' && content.text) {
+                if (content.type === 'output_text' && 'text' in content && content.text) {
                     textParts.push(content.text);
                 }
             }
@@ -176,31 +178,32 @@ export function extractToolCallsFromResponse(response) {
     const outputs = Array.isArray(response.output) ? response.output : [response.output];
     const toolCalls = [];
     for (const item of outputs) {
-        if (item.type === 'function_call') {
-            let parsedArguments;
-            if (typeof item.arguments === 'string') {
-                try {
-                    parsedArguments = JSON.parse(item.arguments);
-                }
-                catch (error) {
-                    // Log warning and skip malformed tool call, similar to stream-transformers.ts
-                    console.warn(`Failed to parse arguments for tool call "${item.name}": ${error instanceof Error ? error.message : String(error)}`);
-                    continue;
-                }
-            }
-            else {
-                parsedArguments = item.arguments;
+        if (item.type !== 'function_call' || !('arguments' in item)) {
+            continue;
+        }
+        let parsedArguments;
+        if (typeof item.arguments === 'string') {
+            try {
+                parsedArguments = JSON.parse(item.arguments);
             }
-            const toolCall = {
-                id: item.callId ?? item.id ?? '',
-                name: item.name ?? '',
-                arguments: parsedArguments,
-            };
-            if (!isValidParsedToolCall(toolCall)) {
-                throw new Error(`Invalid tool call structure for tool: ${item.name}`);
+            catch (error) {
+                // Log warning and skip malformed tool call, similar to stream-transformers.ts
+                console.warn(`Failed to parse arguments for tool call "${'name' in item ? item.name : 'unknown'}": ${error instanceof Error ? error.message : String(error)}`);
+                continue;
             }
-            toolCalls.push(toolCall);
         }
+        else {
+            parsedArguments = item.arguments;
+        }
+        const toolCall = {
+            id: ('callId' in item ? item.callId : undefined) ?? item.id ?? '',
+            name: ('name' in item ? item.name : undefined) ?? '',
+            arguments: parsedArguments,
+        };
+        if (!isValidParsedToolCall(toolCall)) {
+            throw new Error(`Invalid tool call structure for tool: ${toolCall.name}`);
+        }
+        toolCalls.push(toolCall);
     }
     return toolCalls;
 }

package/esm/lib/encodings.js

@@ -349,15 +349,30 @@ export const encodeFormQuery = queryEncoder(encodeForm);
 export const encodeSpaceDelimitedQuery = queryEncoder(encodeSpaceDelimited);
 export const encodePipeDelimitedQuery = queryEncoder(encodePipeDelimited);
 export const encodeDeepObjectQuery = queryEncoder(encodeDeepObject);
+function isBlobLike(val) {
+    if (val instanceof Blob) {
+        return true;
+    }
+    if (typeof val !== "object" || val == null || !(Symbol.toStringTag in val)) {
+        return false;
+    }
+    const tag = val[Symbol.toStringTag];
+    if (tag !== "Blob" && tag !== "File") {
+        return false;
+    }
+    return "stream" in val && typeof val.stream === "function";
+}
 export function appendForm(fd, key, value, fileName) {
     if (value == null) {
         return;
     }
-    else if (value instanceof Blob && fileName) {
-        fd.append(key, value, fileName);
-    }
-    else if (value instanceof Blob) {
-        fd.append(key, value);
+    else if (isBlobLike(value)) {
+        if (fileName) {
+            fd.append(key, value, fileName);
+        }
+        else {
+            fd.append(key, value);
+        }
     }
     else {
         fd.append(key, String(value));

package/esm/lib/env.d.ts

@@ -7,9 +7,13 @@ export interface Env {
      */
     OPENROUTER_HTTP_REFERER?: string | undefined;
     /**
-     * Sets the xTitle parameter for all supported operations
+     * Sets the appTitle parameter for all supported operations
      */
-    OPENROUTER_X_TITLE?: string | undefined;
+    OPENROUTER_APP_TITLE?: string | undefined;
+    /**
+     * Sets the appCategories parameter for all supported operations
+     */
+    OPENROUTER_APP_CATEGORIES?: string | undefined;
     OPENROUTER_DEBUG?: boolean | undefined;
 }
 export declare const envSchema: z.ZodType<Env, unknown>;

package/esm/lib/env.js

@@ -7,7 +7,8 @@ import { dlv } from "./dlv.js";
 export const envSchema = z.object({
     OPENROUTER_API_KEY: z.string().optional(),
     OPENROUTER_HTTP_REFERER: z.string().optional(),
-    OPENROUTER_X_TITLE: z.string().optional(),
+    OPENROUTER_APP_TITLE: z.string().optional(),
+    OPENROUTER_APP_CATEGORIES: z.string().optional(),
     OPENROUTER_DEBUG: z.coerce.boolean().optional(),
 });
 /**
@@ -53,8 +54,11 @@ export function fillGlobals(options) {
     if (typeof envVars.OPENROUTER_HTTP_REFERER !== "undefined") {
         clone.httpReferer ?? (clone.httpReferer = envVars.OPENROUTER_HTTP_REFERER);
     }
-    if (typeof envVars.OPENROUTER_X_TITLE !== "undefined") {
-        clone.xTitle ?? (clone.xTitle = envVars.OPENROUTER_X_TITLE);
+    if (typeof envVars.OPENROUTER_APP_TITLE !== "undefined") {
+        clone.appTitle ?? (clone.appTitle = envVars.OPENROUTER_APP_TITLE);
+    }
+    if (typeof envVars.OPENROUTER_APP_CATEGORIES !== "undefined") {
+        clone.appCategories ?? (clone.appCategories = envVars.OPENROUTER_APP_CATEGORIES);
     }
     return clone;
 }

package/esm/lib/event-streams.d.ts

@@ -1,11 +1,18 @@
+declare global {
+    interface ReadableStream<R = any> {
+        [Symbol.asyncIterator](): AsyncIterableIterator<R>;
+    }
+}
 export type SseMessage<T> = {
     data?: T | undefined;
-    event?: string | undefined;
-    id?: string | undefined;
-    retry?: number | undefined;
+    event?: string | null | undefined;
+    id?: string | null | undefined;
+    retry?: number | null | undefined;
 };
 export declare class EventStream<T> extends ReadableStream<T> {
-    constructor(responseBody: ReadableStream<Uint8Array>, parse: (x: SseMessage<string>) => IteratorResult<T, undefined>);
+    constructor(responseBody: ReadableStream<Uint8Array>, parse: (x: SseMessage<string>) => IteratorResult<T, undefined>, opts?: {
+        dataRequired?: boolean;
+    });
     [Symbol.asyncIterator](): AsyncIterableIterator<T>;
 }
 //# sourceMappingURL=event-streams.d.ts.map

package/esm/lib/event-streams.js

@@ -3,9 +3,11 @@
  * @generated-id: 3f731f808a79
  */
 export class EventStream extends ReadableStream {
-    constructor(responseBody, parse) {
+    constructor(responseBody, parse, opts) {
         const upstream = responseBody.getReader();
         let buffer = new Uint8Array();
+        const state = { eventId: undefined };
+        const dataRequired = opts?.dataRequired ?? true;
         super({
             async pull(downstream) {
                 try {
@@ -20,7 +22,7 @@ export class EventStream extends ReadableStream {
                         }
                         const message = buffer.slice(0, match.index);
                         buffer = buffer.slice(match.index + match.length);
-                        const item = parseMessage(message, parse);
+                        const item = parseMessage(message, parse, state, dataRequired);
                         if (item && !item.done)
                             return downstream.enqueue(item.value);
                         if (item?.done) {
@@ -74,25 +76,40 @@ function concatBuffer(a, b) {
     c.set(b, a.length);
     return c;
 }
-/** Finds the first (CR,LF,CR,LF) or (CR,CR) or (LF,LF) */
+const CR = 13;
+const LF = 10;
+const BOUNDARIES = [
+    [CR, LF, CR, LF], // \r\n\r\n
+    [CR, LF, CR], // \r\n\r
+    [CR, LF, LF], // \r\n\n
+    [CR, CR, LF], // \r\r\n
+    [LF, CR, LF], // \n\r\n
+    [CR, CR], // \r\r
+    [LF, CR], // \n\r
+    [LF, LF], // \n\n
+];
 function findBoundary(buf) {
     const len = buf.length;
     for (let i = 0; i < len; i++) {
-        if (i <= len - 4
-            && buf[i] === 13 && buf[i + 1] === 10 && buf[i + 2] === 13
-            && buf[i + 3] === 10) {
-            return { index: i, length: 4 };
-        }
-        if (i <= len - 2 && buf[i] === 13 && buf[i + 1] === 13) {
-            return { index: i, length: 2 };
-        }
-        if (i <= len - 2 && buf[i] === 10 && buf[i + 1] === 10) {
-            return { index: i, length: 2 };
+        if (buf[i] !== CR && buf[i] !== LF)
+            continue;
+        for (const boundary of BOUNDARIES) {
+            if (i + boundary.length > len)
+                continue;
+            let match = true;
+            for (let j = 0; j < boundary.length; j++) {
+                if (buf[i + j] !== boundary[j]) {
+                    match = false;
+                    break;
+                }
+            }
+            if (match)
+                return { index: i, length: boundary.length };
         }
     }
     return null;
 }
-function parseMessage(chunk, parse) {
+function parseMessage(chunk, parse, state, dataRequired) {
     const text = new TextDecoder().decode(chunk);
     const lines = text.split(/\r\n|\r|\n/);
     const dataLines = [];
@@ -103,24 +120,29 @@ function parseMessage(chunk, parse) {
             continue;
         ignore = false;
         const i = line.indexOf(":");
-        const field = line.slice(0, i);
-        const value = line[i + 1] === " " ? line.slice(i + 2) : line.slice(i + 1);
+        let field = line;
+        let value = "";
+        if (i > 0) {
+            field = line.slice(0, i);
+            value = line[i + 1] === " " ? line.slice(i + 2) : line.slice(i + 1);
+        }
         if (field === "data")
             dataLines.push(value);
         else if (field === "event")
             ret.event = value;
-        else if (field === "id")
-            ret.id = value;
-        else if (field === "retry") {
-            const n = Number(value);
-            if (!isNaN(n))
-                ret.retry = n;
+        else if (field === "id" && !value.includes("\0"))
+            state.eventId = value;
+        else if (field === "retry" && /^\d+$/.test(value)) {
+            ret.retry = Number(value);
         }
     }
     if (ignore)
         return;
+    ret.id = state.eventId;
     if (dataLines.length)
         ret.data = dataLines.join("\n");
+    else if (dataRequired)
+        return; // skip data-less events when data is required
     return parse(ret);
 }
 //# sourceMappingURL=event-streams.js.map

package/esm/lib/files.d.ts

@@ -10,4 +10,17 @@ export declare function readableStreamToArrayBuffer(readable: ReadableStream<Uin
  * Returns null if the extension is not recognized.
  */
 export declare function getContentTypeFromFileName(fileName: string): string | null;
+/**
+ * Creates a Blob from file content with the given MIME type.
+ *
+ * Node.js Buffers are Uint8Array subclasses that may share a pooled
+ * ArrayBuffer (byteOffset > 0, byteLength < buffer.byteLength). Passing
+ * such a Buffer directly to `new Blob([buf])` can include the entire
+ * underlying pool on some runtimes, producing a Blob with extra bytes
+ * that corrupts multipart uploads.
+ *
+ * Copying into a standalone Uint8Array ensures the Blob receives only the
+ * intended bytes regardless of runtime behaviour.
+ */
+export declare function bytesToBlob(content: Uint8Array<ArrayBufferLike> | ArrayBuffer | Blob | string, contentType: string): Blob;
 //# sourceMappingURL=files.d.ts.map

package/esm/lib/files.js

@@ -71,4 +71,22 @@ export function getContentTypeFromFileName(fileName) {
     };
     return mimeTypes[ext] || null;
 }
+/**
+ * Creates a Blob from file content with the given MIME type.
+ *
+ * Node.js Buffers are Uint8Array subclasses that may share a pooled
+ * ArrayBuffer (byteOffset > 0, byteLength < buffer.byteLength). Passing
+ * such a Buffer directly to `new Blob([buf])` can include the entire
+ * underlying pool on some runtimes, producing a Blob with extra bytes
+ * that corrupts multipart uploads.
+ *
+ * Copying into a standalone Uint8Array ensures the Blob receives only the
+ * intended bytes regardless of runtime behaviour.
+ */
+export function bytesToBlob(content, contentType) {
+    if (content instanceof Uint8Array) {
+        return new Blob([new Uint8Array(content)], { type: contentType });
+    }
+    return new Blob([content], { type: contentType });
+}
 //# sourceMappingURL=files.js.map

package/esm/lib/matchers.js

@@ -122,7 +122,6 @@ export function match(...matchers) {
                 raw = body;
                 break;
             default:
-                encoding;
                 throw new Error(`Unsupported response type: ${encoding}`);
         }
         if (matcher.enc === "fail") {

package/esm/lib/model-result.d.ts

@@ -2,15 +2,21 @@ import type { OpenRouterCore } from '../core.js';
 import type * as models from '../models/index.js';
 import type { CallModelInput } from './async-params.js';
 import type { RequestOptions } from './sdks.js';
-import type { ConversationState, ResponseStreamEvent, InferToolEventsUnion, InferToolOutputsUnion, ParsedToolCall, StateAccessor, StopWhen, Tool, ToolStreamEvent, TurnContext } from './tool-types.js';
+import type { $ZodObject, $ZodShape } from 'zod/v4/core';
+import type { ConversationState, ToolContextMapWithShared, ResponseStreamEvent, InferToolEventsUnion, InferToolOutputsUnion, ParsedToolCall, StateAccessor, StopWhen, Tool, ToolStreamEvent, TurnContext } from './tool-types.js';
+import { type ContextInput } from './tool-context.js';
 import { type StreamableOutputItem } from './stream-transformers.js';
-export interface GetResponseOptions<TTools extends readonly Tool[]> {
-    request: CallModelInput<TTools>;
+export interface GetResponseOptions<TTools extends readonly Tool[], TShared extends Record<string, unknown> = Record<string, never>> {
+    request: CallModelInput<TTools, TShared>;
     client: OpenRouterCore;
     options?: RequestOptions;
     tools?: TTools;
     stopWhen?: StopWhen<TTools>;
     state?: StateAccessor<TTools>;
+    /** Typed context data passed to tools via contextSchema. `shared` key for shared context. */
+    context?: ContextInput<ToolContextMapWithShared<TTools, TShared>>;
+    /** Zod schema for shared context validation */
+    sharedContextSchema?: $ZodObject<$ZodShape>;
     /**
      * Call-level approval check - overrides tool-level requireApproval setting
      * Receives the tool call and turn context, can be sync or async
@@ -18,6 +24,10 @@ export interface GetResponseOptions<TTools extends readonly Tool[]> {
     requireApproval?: (toolCall: ParsedToolCall<TTools[number]>, context: TurnContext) => boolean | Promise<boolean>;
     approveToolCalls?: string[];
     rejectToolCalls?: string[];
+    /** Callback invoked at the start of each tool execution turn */
+    onTurnStart?: (context: TurnContext) => void | Promise<void>;
+    /** Callback invoked at the end of each tool execution turn */
+    onTurnEnd?: (context: TurnContext, response: models.OpenResponsesResult) => void | Promise<void>;
 }
 /**
  * A wrapper around a streaming response that provides multiple consumption patterns.
@@ -26,7 +36,7 @@ export interface GetResponseOptions<TTools extends readonly Tool[]> {
  * - `await result.getText()` - Get just the text
  * - `await result.getResponse()` - Get the full response object
  * - `for await (const delta of result.getTextStream())` - Stream text deltas
- * - `for await (const msg of result.getNewMessagesStream())` - Stream incremental message updates
+ * - `for await (const msg of result.getNewMessagesStream())` - Stream cumulative message snapshots
  * - `for await (const event of result.getFullResponsesStream())` - Stream all response events
  *
  * For message format conversion, use the helper functions:
@@ -37,8 +47,9 @@ export interface GetResponseOptions<TTools extends readonly Tool[]> {
  * ReusableReadableStream implementation.
  *
  * @template TTools - The tools array type to enable typed tool calls and results
+ * @template TShared - The shape of the shared context (inferred from sharedContextSchema)
  */
-export declare class ModelResult<TTools extends readonly Tool[]> {
+export declare class ModelResult<TTools extends readonly Tool[], TShared extends Record<string, unknown> = Record<string, never>> {
     private reusableStream;
     private textPromise;
     private options;
@@ -54,13 +65,42 @@ export declare class ModelResult<TTools extends readonly Tool[]> {
     private approvedToolCalls;
     private rejectedToolCalls;
     private isResumingFromApproval;
-    constructor(options: GetResponseOptions<TTools>);
+    private turnBroadcaster;
+    private initialStreamPipeStarted;
+    private initialPipePromise;
+    private contextStore;
+    constructor(options: GetResponseOptions<TTools, TShared>);
     /**
-     * Get or create the tool event broadcaster (lazy initialization).
-     * Ensures only one broadcaster exists for the lifetime of this ModelResult.
-     * Broadcasts both preliminary results and final tool results.
+     * Get or create the unified turn broadcaster (lazy initialization).
+     * Broadcasts all API stream events, tool events, and turn delimiters across turns.
      */
-    private ensureBroadcaster;
+    private ensureTurnBroadcaster;
+    /**
+     * Start piping the initial stream into the turn broadcaster.
+     * Idempotent — only starts once even if called multiple times.
+     * Wraps the initial stream events with turn.start(0) / turn.end(0) delimiters.
+     */
+    private startInitialStreamPipe;
+    /**
+     * Pipe a follow-up stream into the turn broadcaster and capture the completed response.
+     * Emits turn.start / turn.end delimiters around the stream events.
+     */
+    private pipeAndConsumeStream;
+    /**
+     * Push a tool result event to both the legacy tool event broadcaster
+     * and the unified turn broadcaster.
+     */
+    private broadcastToolResult;
+    /**
+     * Push a preliminary result event to both the legacy tool event broadcaster
+     * and the unified turn broadcaster.
+     */
+    private broadcastPreliminaryResult;
+    /**
+     * Set up the turn broadcaster with tool execution and return the consumer.
+     * Used by stream methods that need to iterate over all turns.
+     */
+    private startTurnBroadcasterExecution;
     /**
      * Type guard to check if a value is a non-streaming response
      * Only requires 'output' field and absence of 'toReadableStream' method
@@ -162,11 +202,7 @@ export declare class ModelResult<TTools extends readonly Tool[]> {
     private applyNextTurnParams;
     /**
      * Make a follow-up API request with tool results.
-     * Continues the conversation after tool execution.
-     *
-     * @param currentResponse - The response that contained tool calls
-     * @param toolResults - The results from executing those tools
-     * @returns The new response from the API
+     * Uses streaming and pipes events through the turn broadcaster when available.
      */
     private makeFollowupRequest;
     /**
@@ -229,18 +265,19 @@ export declare class ModelResult<TTools extends readonly Tool[]> {
     /**
      * Get the complete response object including usage information.
      * This will consume the stream until completion and execute any tools.
-     * Returns the full OpenResponsesNonStreamingResponse with usage data (inputTokens, outputTokens, cachedTokens, etc.)
+     * Returns the full OpenResponsesResult with usage data (inputTokens, outputTokens, cachedTokens, etc.)
      */
-    getResponse(): Promise<models.OpenResponsesNonStreamingResponse>;
+    getResponse(): Promise<models.OpenResponsesResult>;
     /**
-     * Stream all response events as they arrive.
+     * Stream all response events as they arrive across all turns.
      * Multiple consumers can iterate over this stream concurrently.
-     * Preliminary tool results and tool results are streamed in REAL-TIME as generator tools yield.
+     * Includes API events, tool events, and turn.start/turn.end delimiters.
      */
     getFullResponsesStream(): AsyncIterableIterator<ResponseStreamEvent<InferToolEventsUnion<TTools>, InferToolOutputsUnion<TTools>>>;
     /**
-     * Stream only text deltas as they arrive.
-     * This filters the full event stream to only yield text content.
+     * Stream only text deltas as they arrive from all turns.
+     * This filters the full event stream to only yield text content,
+     * including text from follow-up responses in multi-turn tool loops.
      */
     getTextStream(): AsyncIterableIterator<string>;
     /**
@@ -263,20 +300,21 @@ export declare class ModelResult<TTools extends readonly Tool[]> {
      * while `getItemsStream()` streams all output item types (messages, function_calls,
      * reasoning, etc.) with cumulative updates.
      *
-     * Stream incremental message updates as content is added in responses format.
+     * Stream cumulative message snapshots as content is added in responses format.
      * Each iteration yields an updated version of the message with new content.
-     * Also yields function_call items and OpenResponsesFunctionCallOutput after tool execution completes.
-     * Returns ResponsesOutputMessage, ResponsesOutputItemFunctionCall, or OpenResponsesFunctionCallOutput
+     * Also yields function_call items and FunctionCallOutputItem after tool execution completes.
+     * Returns OutputMessage, OutputFunctionCallItem, or FunctionCallOutputItem
      * compatible with OpenAI Responses API format.
      */
-    getNewMessagesStream(): AsyncIterableIterator<models.ResponsesOutputMessage | models.OpenResponsesFunctionCallOutput | models.ResponsesOutputItemFunctionCall>;
+    getNewMessagesStream(): AsyncIterableIterator<models.OutputMessage | models.FunctionCallOutputItem | models.OutputFunctionCallItem>;
     /**
-     * Stream only reasoning deltas as they arrive.
-     * This filters the full event stream to only yield reasoning content.
+     * Stream only reasoning deltas as they arrive from all turns.
+     * This filters the full event stream to only yield reasoning content,
+     * including reasoning from follow-up responses in multi-turn tool loops.
      */
     getReasoningStream(): AsyncIterableIterator<string>;
     /**
-     * Stream tool call argument deltas and preliminary results.
+     * Stream tool call argument deltas and preliminary results from all turns.
      * Preliminary results are streamed in REAL-TIME as generator tools yield.
      * - Tool call argument deltas as { type: "delta", content: string }
      * - Preliminary results as { type: "preliminary_result", toolCallId, result }
@@ -294,6 +332,19 @@ export declare class ModelResult<TTools extends readonly Tool[]> {
      * Each iteration yields a complete tool call with parsed arguments.
      */
     getToolCallsStream(): AsyncIterableIterator<ParsedToolCall<TTools[number]>>;
+    /**
+     * Returns an async iterable that emits a full context snapshot every time
+     * any tool calls ctx.update(). Can be consumed concurrently with getText(),
+     * getToolStream(), etc.
+     *
+     * @example
+     * ```typescript
+     * for await (const snapshot of result.getContextUpdates()) {
+     *   console.log('Context changed:', snapshot);
+     * }
+     * ```
+     */
+    getContextUpdates(): AsyncGenerator<ToolContextMapWithShared<TTools, TShared>>;
     /**
      * Cancel the underlying stream and all consumers
      */