@livekit/agents-plugin-openai 1.0.50 → 1.1.0

package/dist/ws/llm.d.ts

@@ -0,0 +1,74 @@
+import type { APIConnectOptions } from '@livekit/agents';
+import { ConnectionPool, llm, stream } from '@livekit/agents';
+import { WebSocket } from 'ws';
+import type { ChatModels } from '../models.js';
+import type { WsResponseCreateEvent, WsServerEvent } from './types.js';
+export declare class ResponsesWebSocket {
+    #private;
+    constructor(ws: WebSocket);
+    /**
+     * Send a response.create event.  Returns a typed `StreamChannel<WsServerEvent>`
+     * that yields validated server events until the response terminates.
+     */
+    sendRequest(payload: WsResponseCreateEvent): stream.StreamChannel<WsServerEvent>;
+    close(): void;
+}
+export interface WSLLMOptions {
+    model: string | ChatModels;
+    apiKey?: string;
+    baseURL?: string;
+    temperature?: number;
+    parallelToolCalls?: boolean;
+    toolChoice?: llm.ToolChoice;
+    store?: boolean;
+    metadata?: Record<string, string>;
+    strictToolSchema?: boolean;
+}
+export declare class WSLLM extends llm.LLM {
+    #private;
+    /**
+     * Create a new instance of the OpenAI Responses API WebSocket LLM.
+     *
+     * @remarks
+     * `apiKey` must be set to your OpenAI API key, either using the argument or
+     * by setting the `OPENAI_API_KEY` environment variable.
+     *
+     * A persistent WebSocket connection to `/v1/responses` is maintained and
+     * reused across turns, reducing per-turn continuation overhead for
+     * tool-call-heavy workflows.
+     */
+    constructor(opts?: Partial<WSLLMOptions>);
+    label(): string;
+    get model(): string;
+    prewarm(): void;
+    close(): Promise<void>;
+    aclose(): Promise<void>;
+    /** Called by LLMStream once response.created fires to atomically persist both the
+     *  response ID and its corresponding chat context for the next turn's diff. */
+    _onResponseCreated(responseId: string, chatCtx: llm.ChatContext): void;
+    _setPendingToolCalls(callIds: Set<string>): void;
+    chat({ chatCtx, toolCtx, connOptions, parallelToolCalls, toolChoice, extraKwargs, }: {
+        chatCtx: llm.ChatContext;
+        toolCtx?: llm.ToolContext;
+        connOptions?: APIConnectOptions;
+        parallelToolCalls?: boolean;
+        toolChoice?: llm.ToolChoice;
+        extraKwargs?: Record<string, unknown>;
+    }): WSLLMStream;
+}
+export declare class WSLLMStream extends llm.LLMStream {
+    #private;
+    constructor(llm: WSLLM, { pool, model, chatCtx, fullChatCtx, toolCtx, connOptions, modelOptions, prevResponseId, strictToolSchema, }: {
+        pool: ConnectionPool<ResponsesWebSocket>;
+        model: string | ChatModels;
+        chatCtx: llm.ChatContext;
+        fullChatCtx: llm.ChatContext;
+        toolCtx?: llm.ToolContext;
+        connOptions: APIConnectOptions;
+        modelOptions: Record<string, unknown>;
+        prevResponseId?: string;
+        strictToolSchema: boolean;
+    });
+    protected run(): Promise<void>;
+}
+//# sourceMappingURL=llm.d.ts.map

package/dist/ws/llm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm.d.ts","sourceRoot":"","sources":["../../src/ws/llm.ts"],"names":[],"mappings":"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"}

package/dist/ws/llm.js

@@ -0,0 +1,485 @@
+import {
+  APIConnectionError,
+  APIStatusError,
+  APITimeoutError,
+  ConnectionPool,
+  DEFAULT_API_CONNECT_OPTIONS,
+  llm,
+  stream,
+  toError
+} from "@livekit/agents";
+import { WebSocket } from "ws";
+import { wsServerEventSchema } from "./types.js";
+const OPENAI_RESPONSES_WS_URL = "wss://api.openai.com/v1/responses";
+const WS_MAX_SESSION_DURATION = 36e5;
+class ResponsesWebSocket {
+  #ws;
+  // FIFO queue: the front entry receives validated WsServerEvents for the in-flight response.
+  #outputQueue = [];
+  constructor(ws) {
+    this.#ws = ws;
+    ws.on("message", (data) => {
+      const current = this.#outputQueue[0];
+      if (!current) return;
+      let raw;
+      try {
+        raw = JSON.parse(data.toString());
+      } catch {
+        return;
+      }
+      const parsed = wsServerEventSchema.safeParse(raw);
+      if (!parsed.success) return;
+      const event = parsed.data;
+      void current.write(event);
+      if (event.type === "response.completed" || event.type === "response.failed" || event.type === "error") {
+        void current.close();
+        this.#outputQueue.shift();
+      }
+    });
+    ws.on("close", () => {
+      for (const current of this.#outputQueue) {
+        if (!current.closed) {
+          const closeError = {
+            type: "error",
+            error: {
+              code: "websocket_closed",
+              message: "OpenAI Responses WebSocket closed unexpectedly"
+            }
+          };
+          void current.write(closeError).finally(() => current.close());
+        }
+      }
+      this.#outputQueue = [];
+    });
+  }
+  /**
+   * Send a response.create event.  Returns a typed `StreamChannel<WsServerEvent>`
+   * that yields validated server events until the response terminates.
+   */
+  sendRequest(payload) {
+    if (this.#ws.readyState !== WebSocket.OPEN) {
+      throw new APIConnectionError({
+        message: `OpenAI Responses WebSocket is not open (state ${getWebSocketStateLabel(this.#ws.readyState)})`,
+        options: { retryable: true }
+      });
+    }
+    const channel = stream.createStreamChannel();
+    this.#outputQueue.push(channel);
+    this.#ws.send(JSON.stringify(payload));
+    return channel;
+  }
+  close() {
+    for (const ch of this.#outputQueue) {
+      void ch.close();
+    }
+    this.#outputQueue = [];
+    this.#ws.close();
+  }
+}
+const defaultLLMOptions = {
+  model: "gpt-4.1",
+  apiKey: process.env.OPENAI_API_KEY,
+  strictToolSchema: true
+};
+class WSLLM extends llm.LLM {
+  #opts;
+  #pool;
+  #prevResponseId = "";
+  #prevChatCtx = null;
+  #pendingToolCalls = /* @__PURE__ */ new Set();
+  /**
+   * Create a new instance of the OpenAI Responses API WebSocket LLM.
+   *
+   * @remarks
+   * `apiKey` must be set to your OpenAI API key, either using the argument or
+   * by setting the `OPENAI_API_KEY` environment variable.
+   *
+   * A persistent WebSocket connection to `/v1/responses` is maintained and
+   * reused across turns, reducing per-turn continuation overhead for
+   * tool-call-heavy workflows.
+   */
+  constructor(opts = defaultLLMOptions) {
+    super();
+    this.#opts = { ...defaultLLMOptions, ...opts };
+    if (!this.#opts.apiKey) {
+      throw new Error("OpenAI API key is required, whether as an argument or as $OPENAI_API_KEY");
+    }
+    this.#pool = new ConnectionPool({
+      maxSessionDuration: WS_MAX_SESSION_DURATION,
+      connectCb: async (timeoutMs) => {
+        const wsUrl = this.#opts.baseURL ? `${this.#opts.baseURL.replace(/^https?/, "wss").replace(/\/+$/, "")}/responses` : OPENAI_RESPONSES_WS_URL;
+        const ws = await connectWs(wsUrl, this.#opts.apiKey, timeoutMs);
+        return new ResponsesWebSocket(ws);
+      },
+      closeCb: async (conn) => {
+        conn.close();
+      }
+    });
+  }
+  label() {
+    return "openai.ws.LLM";
+  }
+  get model() {
+    return this.#opts.model;
+  }
+  prewarm() {
+    this.#pool.prewarm();
+  }
+  async close() {
+    await this.#pool.close();
+  }
+  async aclose() {
+    await this.close();
+  }
+  /** Called by LLMStream once response.created fires to atomically persist both the
+   *  response ID and its corresponding chat context for the next turn's diff. */
+  _onResponseCreated(responseId, chatCtx) {
+    this.#prevResponseId = responseId;
+    this.#prevChatCtx = chatCtx;
+  }
+  _setPendingToolCalls(callIds) {
+    this.#pendingToolCalls = callIds;
+  }
+  chat({
+    chatCtx,
+    toolCtx,
+    connOptions = DEFAULT_API_CONNECT_OPTIONS,
+    parallelToolCalls,
+    toolChoice,
+    extraKwargs
+  }) {
+    var _a;
+    const modelOptions = { ...extraKwargs ?? {} };
+    parallelToolCalls = parallelToolCalls !== void 0 ? parallelToolCalls : this.#opts.parallelToolCalls;
+    if (toolCtx && Object.keys(toolCtx).length > 0 && parallelToolCalls !== void 0) {
+      modelOptions.parallel_tool_calls = parallelToolCalls;
+    }
+    toolChoice = toolChoice !== void 0 ? toolChoice : this.#opts.toolChoice;
+    if (toolChoice) {
+      modelOptions.tool_choice = toolChoice;
+    }
+    if (this.#opts.temperature !== void 0) {
+      modelOptions.temperature = this.#opts.temperature;
+    }
+    if (this.#opts.store !== void 0) {
+      modelOptions.store = this.#opts.store;
+    }
+    if (this.#opts.metadata) {
+      modelOptions.metadata = this.#opts.metadata;
+    }
+    let inputChatCtx = chatCtx;
+    let prevResponseId;
+    const canUseStoredResponse = modelOptions.store !== false;
+    if (canUseStoredResponse && this.#prevChatCtx && this.#prevResponseId) {
+      const diff = llm.computeChatCtxDiff(this.#prevChatCtx, chatCtx);
+      const lastPrevItemId = ((_a = this.#prevChatCtx.items.at(-1)) == null ? void 0 : _a.id) ?? null;
+      if (diff.toRemove.length === 0 && diff.toCreate.length > 0 && diff.toCreate[0][0] === lastPrevItemId) {
+        const newItemIds = new Set(diff.toCreate.map(([, id]) => id));
+        const newItems = chatCtx.items.filter((item) => newItemIds.has(item.id));
+        const pendingToolCallsCompleted = this.#pendingToolCallsCompleted(newItems);
+        if (pendingToolCallsCompleted) {
+          inputChatCtx = new llm.ChatContext(newItems);
+          prevResponseId = this.#prevResponseId;
+        }
+      }
+    }
+    return new WSLLMStream(this, {
+      pool: this.#pool,
+      model: this.#opts.model,
+      chatCtx: inputChatCtx,
+      fullChatCtx: chatCtx,
+      toolCtx,
+      connOptions,
+      modelOptions,
+      prevResponseId,
+      strictToolSchema: this.#opts.strictToolSchema ?? true
+    });
+  }
+  #pendingToolCallsCompleted(items) {
+    if (this.#pendingToolCalls.size === 0) return true;
+    const completedCallIds = new Set(
+      items.filter((item) => item.type === "function_call_output").map((item) => item.callId)
+    );
+    return [...this.#pendingToolCalls].every((callId) => completedCallIds.has(callId));
+  }
+}
+class WSLLMStream extends llm.LLMStream {
+  #llm;
+  #pool;
+  #model;
+  #modelOptions;
+  #strictToolSchema;
+  #prevResponseId;
+  /** Full chat context — used as fallback when previous_response_id is stale. */
+  #fullChatCtx;
+  #responseId = "";
+  #pendingToolCalls = /* @__PURE__ */ new Set();
+  constructor(llm2, {
+    pool,
+    model,
+    chatCtx,
+    fullChatCtx,
+    toolCtx,
+    connOptions,
+    modelOptions,
+    prevResponseId,
+    strictToolSchema
+  }) {
+    super(llm2, { chatCtx, toolCtx, connOptions });
+    this.#llm = llm2;
+    this.#pool = pool;
+    this.#model = model;
+    this.#modelOptions = modelOptions;
+    this.#strictToolSchema = strictToolSchema;
+    this.#prevResponseId = prevResponseId;
+    this.#fullChatCtx = fullChatCtx;
+  }
+  async run() {
+    let retryable = true;
+    try {
+      await this.#pool.withConnection(async (conn) => {
+        const needsRetry = await this.#runWithConn(conn, this.chatCtx, this.#prevResponseId);
+        if (needsRetry) {
+          retryable = true;
+          await this.#runWithConn(conn, this.#fullChatCtx, void 0);
+        }
+      });
+    } catch (error) {
+      if (error instanceof APIStatusError || error instanceof APITimeoutError || error instanceof APIConnectionError) {
+        throw error;
+      }
+      throw new APIConnectionError({
+        message: toError(error).message,
+        options: { retryable }
+      });
+    }
+  }
+  /**
+   * Execute a single response.create round-trip on the given connection.
+   * Returns `true` when the caller should retry with the full chat context
+   * (i.e. `previous_response_not_found`), `false` otherwise.
+   */
+  async #runWithConn(conn, chatCtx, prevResponseId) {
+    const messages = await chatCtx.toProviderFormat(
+      "openai.responses"
+    );
+    const tools = this.toolCtx ? Object.entries(this.toolCtx).map(([name, func]) => {
+      const oaiParams = {
+        type: "function",
+        name,
+        description: func.description,
+        parameters: llm.toJsonSchema(
+          func.parameters,
+          true,
+          this.#strictToolSchema
+        )
+      };
+      if (this.#strictToolSchema) {
+        oaiParams.strict = true;
+      }
+      return oaiParams;
+    }) : void 0;
+    const requestOptions = { ...this.#modelOptions };
+    if (!tools) {
+      delete requestOptions.tool_choice;
+    }
+    const payload = {
+      type: "response.create",
+      model: this.#model,
+      input: messages,
+      tools: tools ?? [],
+      ...prevResponseId ? { previous_response_id: prevResponseId } : {},
+      ...requestOptions
+    };
+    let channel;
+    try {
+      channel = conn.sendRequest(payload);
+    } catch (error) {
+      if (error instanceof APIConnectionError) {
+        conn.close();
+        this.#pool.invalidate();
+      }
+      throw error;
+    }
+    const reader = channel.stream().getReader();
+    try {
+      while (true) {
+        const { done, value: event } = await reader.read();
+        if (done) break;
+        let chunk;
+        switch (event.type) {
+          case "error": {
+            const retry = this.#handleError(event, conn);
+            if (retry) return true;
+            break;
+          }
+          case "response.created":
+            this.#handleResponseCreated(event);
+            break;
+          case "response.output_item.done":
+            chunk = this.#handleOutputItemDone(event);
+            break;
+          case "response.output_text.delta":
+            chunk = this.#handleOutputTextDelta(event);
+            break;
+          case "response.completed":
+            chunk = this.#handleResponseCompleted(event);
+            break;
+          case "response.failed":
+            this.#handleResponseFailed(event);
+            break;
+          default:
+            break;
+        }
+        if (chunk) {
+          this.queue.put(chunk);
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    return false;
+  }
+  /**
+   * Returns `true` when the caller should retry with full context
+   * (`previous_response_not_found`), throws for all other errors.
+   */
+  #handleError(event, conn) {
+    var _a, _b, _c;
+    const code = (_a = event.error) == null ? void 0 : _a.code;
+    if (code === "previous_response_not_found") {
+      return true;
+    }
+    if (code === "websocket_connection_limit_reached" || code === "websocket_closed") {
+      conn.close();
+      this.#pool.invalidate();
+      throw new APIConnectionError({
+        message: ((_b = event.error) == null ? void 0 : _b.message) ?? `WebSocket closed (${code})`,
+        options: { retryable: true }
+      });
+    }
+    throw new APIStatusError({
+      message: ((_c = event.error) == null ? void 0 : _c.message) ?? event.message ?? "Unknown error from OpenAI Responses WS",
+      options: {
+        statusCode: event.status ?? -1,
+        retryable: false
+      }
+    });
+  }
+  #handleResponseCreated(event) {
+    this.#responseId = event.response.id;
+    this.#llm._onResponseCreated(event.response.id, this.#fullChatCtx);
+  }
+  #handleOutputItemDone(event) {
+    if (event.item.type === "function_call") {
+      this.#pendingToolCalls.add(event.item.call_id);
+      return {
+        id: this.#responseId,
+        delta: {
+          role: "assistant",
+          content: void 0,
+          toolCalls: [
+            llm.FunctionCall.create({
+              callId: event.item.call_id,
+              name: event.item.name,
+              args: event.item.arguments
+            })
+          ]
+        }
+      };
+    }
+    return void 0;
+  }
+  #handleOutputTextDelta(event) {
+    return {
+      id: this.#responseId,
+      delta: {
+        role: "assistant",
+        content: event.delta
+      }
+    };
+  }
+  #handleResponseCompleted(event) {
+    this.#llm._setPendingToolCalls(this.#pendingToolCalls);
+    if (event.response.usage) {
+      return {
+        id: this.#responseId,
+        usage: {
+          completionTokens: event.response.usage.output_tokens,
+          promptTokens: event.response.usage.input_tokens,
+          promptCachedTokens: event.response.usage.input_tokens_details.cached_tokens,
+          totalTokens: event.response.usage.total_tokens
+        }
+      };
+    }
+    return void 0;
+  }
+  #handleResponseFailed(event) {
+    var _a, _b;
+    throw new APIStatusError({
+      message: ((_b = (_a = event.response) == null ? void 0 : _a.error) == null ? void 0 : _b.message) ?? "Response failed",
+      options: { statusCode: -1, retryable: false }
+    });
+  }
+}
+async function connectWs(url, apiKey, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(url, {
+      headers: { Authorization: `Bearer ${apiKey}` }
+    });
+    let settled = false;
+    const timer = setTimeout(() => {
+      settled = true;
+      ws.close();
+      reject(
+        new APIConnectionError({ message: "Timeout connecting to OpenAI Responses WebSocket" })
+      );
+    }, timeoutMs);
+    ws.once("open", () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(ws);
+    });
+    ws.once("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(
+        new APIConnectionError({
+          message: `Error connecting to OpenAI Responses WebSocket: ${err.message}`
+        })
+      );
+    });
+    ws.once("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(
+        new APIConnectionError({
+          message: `OpenAI Responses WebSocket closed unexpectedly during connect (code ${code})`
+        })
+      );
+    });
+  });
+}
+function getWebSocketStateLabel(readyState) {
+  switch (readyState) {
+    case WebSocket.CONNECTING:
+      return "CONNECTING";
+    case WebSocket.OPEN:
+      return "OPEN";
+    case WebSocket.CLOSING:
+      return "CLOSING";
+    case WebSocket.CLOSED:
+      return "CLOSED";
+    default:
+      return `UNKNOWN:${readyState}`;
+  }
+}
+export {
+  ResponsesWebSocket,
+  WSLLM,
+  WSLLMStream
+};
+//# sourceMappingURL=llm.js.map

package/dist/ws/llm.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/ws/llm.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2025 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport type { APIConnectOptions } from '@livekit/agents';\nimport {\n  APIConnectionError,\n  APIStatusError,\n  APITimeoutError,\n  ConnectionPool,\n  DEFAULT_API_CONNECT_OPTIONS,\n  llm,\n  stream,\n  toError,\n} from '@livekit/agents';\nimport type OpenAI from 'openai';\nimport { WebSocket } from 'ws';\nimport type { ChatModels } from '../models.js';\nimport type {\n  WsOutputItemDoneEvent,\n  WsOutputTextDeltaEvent,\n  WsResponseCompletedEvent,\n  WsResponseCreateEvent,\n  WsResponseCreatedEvent,\n  WsResponseFailedEvent,\n  WsServerEvent,\n} from './types.js';\nimport { wsServerEventSchema } from './types.js';\n\nconst OPENAI_RESPONSES_WS_URL = 'wss://api.openai.com/v1/responses';\n\n// OpenAI enforces a 60-minute maximum duration on Responses WebSocket connections.\nconst WS_MAX_SESSION_DURATION = 3_600_000;\n\n// ============================================================================\n// Internal: ResponsesWebSocket\n//\n// Wraps a single raw WebSocket connection.  Maintains a FIFO queue of\n// StreamChannels — one per outstanding response.create request — and\n// dispatches every incoming server-event to the front of the queue.\n// A response is terminated (and its channel closed) when the service sends\n// response.completed, response.failed, or error.\n//\n// ============================================================================\n\nexport class ResponsesWebSocket {\n  #ws: WebSocket;\n  // FIFO queue: the front entry receives validated WsServerEvents for the in-flight response.\n  #outputQueue: stream.StreamChannel<WsServerEvent>[] = [];\n\n  constructor(ws: WebSocket) {\n    this.#ws = ws;\n\n    ws.on('message', (data: Buffer) => {\n      const current = this.#outputQueue[0];\n      if (!current) return;\n\n      let raw: unknown;\n      try {\n        raw = JSON.parse(data.toString());\n      } catch {\n        return;\n      }\n\n      // Validate and type-narrow with Zod at write time so readers always\n      // receive a fully-typed WsServerEvent.\n      const parsed = wsServerEventSchema.safeParse(raw);\n      if (!parsed.success) return;\n\n      const event = parsed.data;\n      void current.write(event);\n\n      // Close and dequeue on any terminal event.\n      if (\n        event.type === 'response.completed' ||\n        event.type === 'response.failed' ||\n        event.type === 'error'\n      ) {\n        void current.close();\n        this.#outputQueue.shift();\n      }\n    });\n\n    ws.on('close', () => {\n      // If the WebSocket closes while requests are still in flight, synthesise\n      // a typed error event so all readers can handle it cleanly.\n      for (const current of this.#outputQueue) {\n        if (!current.closed) {\n          const closeError: WsServerEvent = {\n            type: 'error',\n            error: {\n              code: 'websocket_closed',\n              message: 'OpenAI Responses WebSocket closed unexpectedly',\n            },\n          };\n          void current.write(closeError).finally(() => current.close());\n        }\n      }\n      this.#outputQueue = [];\n    });\n  }\n\n  /**\n   * Send a response.create event.  Returns a typed `StreamChannel<WsServerEvent>`\n   * that yields validated server events until the response terminates.\n   */\n  sendRequest(payload: WsResponseCreateEvent): stream.StreamChannel<WsServerEvent> {\n    if (this.#ws.readyState !== WebSocket.OPEN) {\n      throw new APIConnectionError({\n        message: `OpenAI Responses WebSocket is not open (state ${getWebSocketStateLabel(this.#ws.readyState)})`,\n        options: { retryable: true },\n      });\n    }\n\n    const channel = stream.createStreamChannel<WsServerEvent>();\n    this.#outputQueue.push(channel);\n    this.#ws.send(JSON.stringify(payload));\n    return channel;\n  }\n\n  close(): void {\n    // Drain pending channels before closing the socket.\n    for (const ch of this.#outputQueue) {\n      void ch.close();\n    }\n    this.#outputQueue = [];\n    this.#ws.close();\n  }\n}\n\n// ============================================================================\n// LLMOptions\n// ============================================================================\n\nexport interface WSLLMOptions {\n  model: string | ChatModels;\n  apiKey?: string;\n  baseURL?: string;\n  temperature?: number;\n  parallelToolCalls?: boolean;\n  toolChoice?: llm.ToolChoice;\n  store?: boolean;\n  metadata?: Record<string, string>;\n  strictToolSchema?: boolean;\n}\n\nconst defaultLLMOptions: WSLLMOptions = {\n  model: 'gpt-4.1',\n  apiKey: process.env.OPENAI_API_KEY,\n  strictToolSchema: true,\n};\n\n// ============================================================================\n// LLM\n// ============================================================================\n\nexport class WSLLM extends llm.LLM {\n  #opts: WSLLMOptions;\n  #pool: ConnectionPool<ResponsesWebSocket>;\n  #prevResponseId = '';\n  #prevChatCtx: llm.ChatContext | null = null;\n  #pendingToolCalls = new Set<string>();\n\n  /**\n   * Create a new instance of the OpenAI Responses API WebSocket LLM.\n   *\n   * @remarks\n   * `apiKey` must be set to your OpenAI API key, either using the argument or\n   * by setting the `OPENAI_API_KEY` environment variable.\n   *\n   * A persistent WebSocket connection to `/v1/responses` is maintained and\n   * reused across turns, reducing per-turn continuation overhead for\n   * tool-call-heavy workflows.\n   */\n  constructor(opts: Partial<WSLLMOptions> = defaultLLMOptions) {\n    super();\n\n    this.#opts = { ...defaultLLMOptions, ...opts };\n    if (!this.#opts.apiKey) {\n      throw new Error('OpenAI API key is required, whether as an argument or as $OPENAI_API_KEY');\n    }\n\n    this.#pool = new ConnectionPool<ResponsesWebSocket>({\n      maxSessionDuration: WS_MAX_SESSION_DURATION,\n      connectCb: async (timeoutMs: number) => {\n        const wsUrl = this.#opts.baseURL\n          ? `${this.#opts.baseURL.replace(/^https?/, 'wss').replace(/\\/+$/, '')}/responses`\n          : OPENAI_RESPONSES_WS_URL;\n        const ws = await connectWs(wsUrl, this.#opts.apiKey!, timeoutMs);\n        return new ResponsesWebSocket(ws);\n      },\n      closeCb: async (conn: ResponsesWebSocket) => {\n        conn.close();\n      },\n    });\n  }\n\n  label(): string {\n    return 'openai.ws.LLM';\n  }\n\n  get model(): string {\n    return this.#opts.model;\n  }\n\n  prewarm(): void {\n    this.#pool.prewarm();\n  }\n\n  async close(): Promise<void> {\n    await this.#pool.close();\n  }\n\n  override async aclose(): Promise<void> {\n    await this.close();\n  }\n\n  /** Called by LLMStream once response.created fires to atomically persist both the\n   *  response ID and its corresponding chat context for the next turn's diff. */\n  _onResponseCreated(responseId: string, chatCtx: llm.ChatContext): void {\n    this.#prevResponseId = responseId;\n    this.#prevChatCtx = chatCtx;\n  }\n\n  _setPendingToolCalls(callIds: Set<string>): void {\n    this.#pendingToolCalls = callIds;\n  }\n\n  chat({\n    chatCtx,\n    toolCtx,\n    connOptions = DEFAULT_API_CONNECT_OPTIONS,\n    parallelToolCalls,\n    toolChoice,\n    extraKwargs,\n  }: {\n    chatCtx: llm.ChatContext;\n    toolCtx?: llm.ToolContext;\n    connOptions?: APIConnectOptions;\n    parallelToolCalls?: boolean;\n    toolChoice?: llm.ToolChoice;\n    extraKwargs?: Record<string, unknown>;\n  }): WSLLMStream {\n    const modelOptions: Record<string, unknown> = { ...(extraKwargs ?? {}) };\n\n    parallelToolCalls =\n      parallelToolCalls !== undefined ? parallelToolCalls : this.#opts.parallelToolCalls;\n    if (toolCtx && Object.keys(toolCtx).length > 0 && parallelToolCalls !== undefined) {\n      modelOptions.parallel_tool_calls = parallelToolCalls;\n    }\n\n    toolChoice =\n      toolChoice !== undefined ? toolChoice : (this.#opts.toolChoice as llm.ToolChoice | undefined);\n    if (toolChoice) {\n      modelOptions.tool_choice = toolChoice;\n    }\n\n    if (this.#opts.temperature !== undefined) {\n      modelOptions.temperature = this.#opts.temperature;\n    }\n\n    if (this.#opts.store !== undefined) {\n      modelOptions.store = this.#opts.store;\n    }\n\n    if (this.#opts.metadata) {\n      modelOptions.metadata = this.#opts.metadata;\n    }\n\n    let inputChatCtx = chatCtx;\n    let prevResponseId: string | undefined;\n    const canUseStoredResponse = modelOptions.store !== false;\n\n    if (canUseStoredResponse && this.#prevChatCtx && this.#prevResponseId) {\n      const diff = llm.computeChatCtxDiff(this.#prevChatCtx, chatCtx);\n      const lastPrevItemId = this.#prevChatCtx.items.at(-1)?.id ?? null;\n\n      if (\n        diff.toRemove.length === 0 &&\n        diff.toCreate.length > 0 &&\n        diff.toCreate[0]![0] === lastPrevItemId\n      ) {\n        // All new items are appended after the tail of the previous context —\n        // safe to send only the incremental input with previous_response_id,\n        // but only if all pending tool calls from the previous response have\n        // their corresponding function_call_output in the new items.\n        const newItemIds = new Set(diff.toCreate.map(([, id]) => id));\n        const newItems = chatCtx.items.filter((item: llm.ChatItem) => newItemIds.has(item.id));\n        const pendingToolCallsCompleted = this.#pendingToolCallsCompleted(newItems);\n        if (pendingToolCallsCompleted) {\n          inputChatCtx = new llm.ChatContext(newItems);\n          prevResponseId = this.#prevResponseId;\n        }\n      }\n      // Otherwise: items were removed or inserted mid-history — fall back to\n      // sending the full context with no previous_response_id.\n    }\n\n    return new WSLLMStream(this, {\n      pool: this.#pool,\n      model: this.#opts.model,\n      chatCtx: inputChatCtx,\n      fullChatCtx: chatCtx,\n      toolCtx,\n      connOptions,\n      modelOptions,\n      prevResponseId,\n      strictToolSchema: this.#opts.strictToolSchema ?? true,\n    });\n  }\n\n  #pendingToolCallsCompleted(items: llm.ChatItem[]): boolean {\n    if (this.#pendingToolCalls.size === 0) return true;\n    const completedCallIds = new Set(\n      items\n        .filter((item): item is llm.FunctionCallOutput => item.type === 'function_call_output')\n        .map((item) => item.callId),\n    );\n    return [...this.#pendingToolCalls].every((callId) => completedCallIds.has(callId));\n  }\n}\n\n// ============================================================================\n// WsLLMStream\n// ============================================================================\n\nexport class WSLLMStream extends llm.LLMStream {\n  #llm: WSLLM;\n  #pool: ConnectionPool<ResponsesWebSocket>;\n  #model: string | ChatModels;\n  #modelOptions: Record<string, unknown>;\n  #strictToolSchema: boolean;\n  #prevResponseId?: string;\n  /** Full chat context — used as fallback when previous_response_id is stale. */\n  #fullChatCtx: llm.ChatContext;\n  #responseId = '';\n  #pendingToolCalls = new Set<string>();\n\n  constructor(\n    llm: WSLLM,\n    {\n      pool,\n      model,\n      chatCtx,\n      fullChatCtx,\n      toolCtx,\n      connOptions,\n      modelOptions,\n      prevResponseId,\n      strictToolSchema,\n    }: {\n      pool: ConnectionPool<ResponsesWebSocket>;\n      model: string | ChatModels;\n      chatCtx: llm.ChatContext;\n      fullChatCtx: llm.ChatContext;\n      toolCtx?: llm.ToolContext;\n      connOptions: APIConnectOptions;\n      modelOptions: Record<string, unknown>;\n      prevResponseId?: string;\n      strictToolSchema: boolean;\n    },\n  ) {\n    super(llm, { chatCtx, toolCtx, connOptions });\n    this.#llm = llm;\n    this.#pool = pool;\n    this.#model = model;\n    this.#modelOptions = modelOptions;\n    this.#strictToolSchema = strictToolSchema;\n    this.#prevResponseId = prevResponseId;\n    this.#fullChatCtx = fullChatCtx;\n  }\n\n  protected async run(): Promise<void> {\n    let retryable = true;\n\n    try {\n      await this.#pool.withConnection(async (conn: ResponsesWebSocket) => {\n        const needsRetry = await this.#runWithConn(conn, this.chatCtx, this.#prevResponseId);\n\n        if (needsRetry) {\n          // previous_response_id was evicted from the server-side cache.\n          // Retry once on the same connection with the full context and no ID.\n          retryable = true;\n          await this.#runWithConn(conn, this.#fullChatCtx, undefined);\n        }\n      });\n    } catch (error) {\n      if (\n        error instanceof APIStatusError ||\n        error instanceof APITimeoutError ||\n        error instanceof APIConnectionError\n      ) {\n        throw error;\n      }\n      throw new APIConnectionError({\n        message: toError(error).message,\n        options: { retryable },\n      });\n    }\n  }\n\n  /**\n   * Execute a single response.create round-trip on the given connection.\n   * Returns `true` when the caller should retry with the full chat context\n   * (i.e. `previous_response_not_found`), `false` otherwise.\n   */\n  async #runWithConn(\n    conn: ResponsesWebSocket,\n    chatCtx: llm.ChatContext,\n    prevResponseId: string | undefined,\n  ): Promise<boolean> {\n    const messages = (await chatCtx.toProviderFormat(\n      'openai.responses',\n    )) as OpenAI.Responses.ResponseInputItem[];\n\n    const tools = this.toolCtx\n      ? Object.entries(this.toolCtx).map(([name, func]) => {\n          const oaiParams = {\n            type: 'function' as const,\n            name,\n            description: func.description,\n            parameters: llm.toJsonSchema(\n              func.parameters,\n              true,\n              this.#strictToolSchema,\n            ) as unknown as OpenAI.Responses.FunctionTool['parameters'],\n          } as OpenAI.Responses.FunctionTool;\n\n          if (this.#strictToolSchema) {\n            oaiParams.strict = true;\n          }\n\n          return oaiParams;\n        })\n      : undefined;\n\n    const requestOptions: Record<string, unknown> = { ...this.#modelOptions };\n    if (!tools) {\n      delete requestOptions.tool_choice;\n    }\n\n    const payload: WsResponseCreateEvent = {\n      type: 'response.create',\n      model: this.#model as string,\n      input: messages as unknown[],\n      tools: (tools ?? []) as unknown[],\n      ...(prevResponseId ? { previous_response_id: prevResponseId } : {}),\n      ...requestOptions,\n    };\n\n    let channel: stream.StreamChannel<WsServerEvent>;\n    try {\n      channel = conn.sendRequest(payload);\n    } catch (error) {\n      if (error instanceof APIConnectionError) {\n        conn.close();\n        this.#pool.invalidate();\n      }\n      throw error;\n    }\n    const reader = channel.stream().getReader();\n\n    // Events are already Zod-validated by ResponsesWebSocket before being\n    // written to the channel, so no re-parsing is needed here.\n    try {\n      while (true) {\n        const { done, value: event } = await reader.read();\n        if (done) break;\n\n        let chunk: llm.ChatChunk | undefined;\n\n        switch (event.type) {\n          case 'error': {\n            const retry = this.#handleError(event, conn);\n            if (retry) return true;\n            break;\n          }\n          case 'response.created':\n            this.#handleResponseCreated(event);\n            break;\n          case 'response.output_item.done':\n            chunk = this.#handleOutputItemDone(event);\n            break;\n          case 'response.output_text.delta':\n            chunk = this.#handleOutputTextDelta(event);\n            break;\n          case 'response.completed':\n            chunk = this.#handleResponseCompleted(event);\n            break;\n          case 'response.failed':\n            this.#handleResponseFailed(event);\n            break;\n          default:\n            break;\n        }\n\n        if (chunk) {\n          this.queue.put(chunk);\n        }\n      }\n    } finally {\n      reader.releaseLock();\n    }\n\n    return false;\n  }\n\n  /**\n   * Returns `true` when the caller should retry with full context\n   * (`previous_response_not_found`), throws for all other errors.\n   */\n  #handleError(event: WsServerEvent & { type: 'error' }, conn: ResponsesWebSocket): boolean {\n    const code = event.error?.code;\n\n    if (code === 'previous_response_not_found') {\n      // The server-side in-memory cache was evicted (e.g. after a failed turn\n      // or reconnect). Signal the caller to retry with the full context.\n      return true;\n    }\n\n    if (code === 'websocket_connection_limit_reached' || code === 'websocket_closed') {\n      // Transient connection issue (timeout, network drop, or 60-min limit).\n      // Evict this connection so the pool opens a fresh one on retry.\n      conn.close();\n      this.#pool.invalidate();\n      throw new APIConnectionError({\n        message: event.error?.message ?? `WebSocket closed (${code})`,\n        options: { retryable: true },\n      });\n    }\n\n    throw new APIStatusError({\n      message: event.error?.message ?? event.message ?? 'Unknown error from OpenAI Responses WS',\n      options: {\n        statusCode: event.status ?? -1,\n        retryable: false,\n      },\n    });\n  }\n\n  #handleResponseCreated(event: WsResponseCreatedEvent): void {\n    this.#responseId = event.response.id;\n    this.#llm._onResponseCreated(event.response.id, this.#fullChatCtx);\n  }\n\n  #handleOutputItemDone(event: WsOutputItemDoneEvent): llm.ChatChunk | undefined {\n    if (event.item.type === 'function_call') {\n      this.#pendingToolCalls.add(event.item.call_id);\n      return {\n        id: this.#responseId,\n        delta: {\n          role: 'assistant',\n          content: undefined,\n          toolCalls: [\n            llm.FunctionCall.create({\n              callId: event.item.call_id,\n              name: event.item.name,\n              args: event.item.arguments,\n            }),\n          ],\n        },\n      };\n    }\n    return undefined;\n  }\n\n  #handleOutputTextDelta(event: WsOutputTextDeltaEvent): llm.ChatChunk {\n    return {\n      id: this.#responseId,\n      delta: {\n        role: 'assistant',\n        content: event.delta,\n      },\n    };\n  }\n\n  #handleResponseCompleted(event: WsResponseCompletedEvent): llm.ChatChunk | undefined {\n    this.#llm._setPendingToolCalls(this.#pendingToolCalls);\n\n    if (event.response.usage) {\n      return {\n        id: this.#responseId,\n        usage: {\n          completionTokens: event.response.usage.output_tokens,\n          promptTokens: event.response.usage.input_tokens,\n          promptCachedTokens: event.response.usage.input_tokens_details.cached_tokens,\n          totalTokens: event.response.usage.total_tokens,\n        },\n      };\n    }\n    return undefined;\n  }\n\n  #handleResponseFailed(event: WsResponseFailedEvent): void {\n    throw new APIStatusError({\n      message: event.response?.error?.message ?? 'Response failed',\n      options: { statusCode: -1, retryable: false },\n    });\n  }\n}\n\n// ============================================================================\n// Internal helpers\n// ============================================================================\n\nasync function connectWs(url: string, apiKey: string, timeoutMs: number): Promise<WebSocket> {\n  return new Promise<WebSocket>((resolve, reject) => {\n    const ws = new WebSocket(url, {\n      headers: { Authorization: `Bearer ${apiKey}` },\n    });\n\n    let settled = false;\n\n    const timer = setTimeout(() => {\n      settled = true;\n      ws.close();\n      reject(\n        new APIConnectionError({ message: 'Timeout connecting to OpenAI Responses WebSocket' }),\n      );\n    }, timeoutMs);\n\n    ws.once('open', () => {\n      if (settled) return;\n      settled = true;\n      clearTimeout(timer);\n      resolve(ws);\n    });\n\n    ws.once('error', (err) => {\n      if (settled) return;\n      settled = true;\n      clearTimeout(timer);\n      reject(\n        new APIConnectionError({\n          message: `Error connecting to OpenAI Responses WebSocket: ${err.message}`,\n        }),\n      );\n    });\n\n    ws.once('close', (code) => {\n      if (settled) return;\n      settled = true;\n      clearTimeout(timer);\n      reject(\n        new APIConnectionError({\n          message: `OpenAI Responses WebSocket closed unexpectedly during connect (code ${code})`,\n        }),\n      );\n    });\n  });\n}\n\nfunction getWebSocketStateLabel(readyState: number): string {\n  switch (readyState) {\n    case WebSocket.CONNECTING:\n      return 'CONNECTING';\n    case WebSocket.OPEN:\n      return 'OPEN';\n    case WebSocket.CLOSING:\n      return 'CLOSING';\n    case WebSocket.CLOSED:\n      return 'CLOSED';\n    default:\n      return `UNKNOWN:${readyState}`;\n  }\n}\n"],"mappings":"AAIA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,iBAAiB;AAW1B,SAAS,2BAA2B;AAEpC,MAAM,0BAA0B;AAGhC,MAAM,0BAA0B;AAazB,MAAM,mBAAmB;AAAA,EAC9B;AAAA;AAAA,EAEA,eAAsD,CAAC;AAAA,EAEvD,YAAY,IAAe;AACzB,SAAK,MAAM;AAEX,OAAG,GAAG,WAAW,CAAC,SAAiB;AACjC,YAAM,UAAU,KAAK,aAAa,CAAC;AACnC,UAAI,CAAC,QAAS;AAEd,UAAI;AACJ,UAAI;AACF,cAAM,KAAK,MAAM,KAAK,SAAS,CAAC;AAAA,MAClC,QAAQ;AACN;AAAA,MACF;AAIA,YAAM,SAAS,oBAAoB,UAAU,GAAG;AAChD,UAAI,CAAC,OAAO,QAAS;AAErB,YAAM,QAAQ,OAAO;AACrB,WAAK,QAAQ,MAAM,KAAK;AAGxB,UACE,MAAM,SAAS,wBACf,MAAM,SAAS,qBACf,MAAM,SAAS,SACf;AACA,aAAK,QAAQ,MAAM;AACnB,aAAK,aAAa,MAAM;AAAA,MAC1B;AAAA,IACF,CAAC;AAED,OAAG,GAAG,SAAS,MAAM;AAGnB,iBAAW,WAAW,KAAK,cAAc;AACvC,YAAI,CAAC,QAAQ,QAAQ;AACnB,gBAAM,aAA4B;AAAA,YAChC,MAAM;AAAA,YACN,OAAO;AAAA,cACL,MAAM;AAAA,cACN,SAAS;AAAA,YACX;AAAA,UACF;AACA,eAAK,QAAQ,MAAM,UAAU,EAAE,QAAQ,MAAM,QAAQ,MAAM,CAAC;AAAA,QAC9D;AAAA,MACF;AACA,WAAK,eAAe,CAAC;AAAA,IACvB,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,YAAY,SAAqE;AAC/E,QAAI,KAAK,IAAI,eAAe,UAAU,MAAM;AAC1C,YAAM,IAAI,mBAAmB;AAAA,QAC3B,SAAS,iDAAiD,uBAAuB,KAAK,IAAI,UAAU,CAAC;AAAA,QACrG,SAAS,EAAE,WAAW,KAAK;AAAA,MAC7B,CAAC;AAAA,IACH;AAEA,UAAM,UAAU,OAAO,oBAAmC;AAC1D,SAAK,aAAa,KAAK,OAAO;AAC9B,SAAK,IAAI,KAAK,KAAK,UAAU,OAAO,CAAC;AACrC,WAAO;AAAA,EACT;AAAA,EAEA,QAAc;AAEZ,eAAW,MAAM,KAAK,cAAc;AAClC,WAAK,GAAG,MAAM;AAAA,IAChB;AACA,SAAK,eAAe,CAAC;AACrB,SAAK,IAAI,MAAM;AAAA,EACjB;AACF;AAkBA,MAAM,oBAAkC;AAAA,EACtC,OAAO;AAAA,EACP,QAAQ,QAAQ,IAAI;AAAA,EACpB,kBAAkB;AACpB;AAMO,MAAM,cAAc,IAAI,IAAI;AAAA,EACjC;AAAA,EACA;AAAA,EACA,kBAAkB;AAAA,EAClB,eAAuC;AAAA,EACvC,oBAAoB,oBAAI,IAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAapC,YAAY,OAA8B,mBAAmB;AAC3D,UAAM;AAEN,SAAK,QAAQ,EAAE,GAAG,mBAAmB,GAAG,KAAK;AAC7C,QAAI,CAAC,KAAK,MAAM,QAAQ;AACtB,YAAM,IAAI,MAAM,0EAA0E;AAAA,IAC5F;AAEA,SAAK,QAAQ,IAAI,eAAmC;AAAA,MAClD,oBAAoB;AAAA,MACpB,WAAW,OAAO,cAAsB;AACtC,cAAM,QAAQ,KAAK,MAAM,UACrB,GAAG,KAAK,MAAM,QAAQ,QAAQ,WAAW,KAAK,EAAE,QAAQ,QAAQ,EAAE,CAAC,eACnE;AACJ,cAAM,KAAK,MAAM,UAAU,OAAO,KAAK,MAAM,QAAS,SAAS;AAC/D,eAAO,IAAI,mBAAmB,EAAE;AAAA,MAClC;AAAA,MACA,SAAS,OAAO,SAA6B;AAC3C,aAAK,MAAM;AAAA,MACb;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,QAAgB;AACd,WAAO;AAAA,EACT;AAAA,EAEA,IAAI,QAAgB;AAClB,WAAO,KAAK,MAAM;AAAA,EACpB;AAAA,EAEA,UAAgB;AACd,SAAK,MAAM,QAAQ;AAAA,EACrB;AAAA,EAEA,MAAM,QAAuB;AAC3B,UAAM,KAAK,MAAM,MAAM;AAAA,EACzB;AAAA,EAEA,MAAe,SAAwB;AACrC,UAAM,KAAK,MAAM;AAAA,EACnB;AAAA;AAAA;AAAA,EAIA,mBAAmB,YAAoB,SAAgC;AACrE,SAAK,kBAAkB;AACvB,SAAK,eAAe;AAAA,EACtB;AAAA,EAEA,qBAAqB,SAA4B;AAC/C,SAAK,oBAAoB;AAAA,EAC3B;AAAA,EAEA,KAAK;AAAA,IACH;AAAA,IACA;AAAA,IACA,cAAc;AAAA,IACd;AAAA,IACA;AAAA,IACA;AAAA,EACF,GAOgB;AAjPlB;AAkPI,UAAM,eAAwC,EAAE,GAAI,eAAe,CAAC,EAAG;AAEvE,wBACE,sBAAsB,SAAY,oBAAoB,KAAK,MAAM;AACnE,QAAI,WAAW,OAAO,KAAK,OAAO,EAAE,SAAS,KAAK,sBAAsB,QAAW;AACjF,mBAAa,sBAAsB;AAAA,IACrC;AAEA,iBACE,eAAe,SAAY,aAAc,KAAK,MAAM;AACtD,QAAI,YAAY;AACd,mBAAa,cAAc;AAAA,IAC7B;AAEA,QAAI,KAAK,MAAM,gBAAgB,QAAW;AACxC,mBAAa,cAAc,KAAK,MAAM;AAAA,IACxC;AAEA,QAAI,KAAK,MAAM,UAAU,QAAW;AAClC,mBAAa,QAAQ,KAAK,MAAM;AAAA,IAClC;AAEA,QAAI,KAAK,MAAM,UAAU;AACvB,mBAAa,WAAW,KAAK,MAAM;AAAA,IACrC;AAEA,QAAI,eAAe;AACnB,QAAI;AACJ,UAAM,uBAAuB,aAAa,UAAU;AAEpD,QAAI,wBAAwB,KAAK,gBAAgB,KAAK,iBAAiB;AACrE,YAAM,OAAO,IAAI,mBAAmB,KAAK,cAAc,OAAO;AAC9D,YAAM,mBAAiB,UAAK,aAAa,MAAM,GAAG,EAAE,MAA7B,mBAAgC,OAAM;AAE7D,UACE,KAAK,SAAS,WAAW,KACzB,KAAK,SAAS,SAAS,KACvB,KAAK,SAAS,CAAC,EAAG,CAAC,MAAM,gBACzB;AAKA,cAAM,aAAa,IAAI,IAAI,KAAK,SAAS,IAAI,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC;AAC5D,cAAM,WAAW,QAAQ,MAAM,OAAO,CAAC,SAAuB,WAAW,IAAI,KAAK,EAAE,CAAC;AACrF,cAAM,4BAA4B,KAAK,2BAA2B,QAAQ;AAC1E,YAAI,2BAA2B;AAC7B,yBAAe,IAAI,IAAI,YAAY,QAAQ;AAC3C,2BAAiB,KAAK;AAAA,QACxB;AAAA,MACF;AAAA,IAGF;AAEA,WAAO,IAAI,YAAY,MAAM;AAAA,MAC3B,MAAM,KAAK;AAAA,MACX,OAAO,KAAK,MAAM;AAAA,MAClB,SAAS;AAAA,MACT,aAAa;AAAA,MACb;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,kBAAkB,KAAK,MAAM,oBAAoB;AAAA,IACnD,CAAC;AAAA,EACH;AAAA,EAEA,2BAA2B,OAAgC;AACzD,QAAI,KAAK,kBAAkB,SAAS,EAAG,QAAO;AAC9C,UAAM,mBAAmB,IAAI;AAAA,MAC3B,MACG,OAAO,CAAC,SAAyC,KAAK,SAAS,sBAAsB,EACrF,IAAI,CAAC,SAAS,KAAK,MAAM;AAAA,IAC9B;AACA,WAAO,CAAC,GAAG,KAAK,iBAAiB,EAAE,MAAM,CAAC,WAAW,iBAAiB,IAAI,MAAM,CAAC;AAAA,EACnF;AACF;AAMO,MAAM,oBAAoB,IAAI,UAAU;AAAA,EAC7C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA,EACA,cAAc;AAAA,EACd,oBAAoB,oBAAI,IAAY;AAAA,EAEpC,YACEA,MACA;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,GAWA;AACA,UAAMA,MAAK,EAAE,SAAS,SAAS,YAAY,CAAC;AAC5C,SAAK,OAAOA;AACZ,SAAK,QAAQ;AACb,SAAK,SAAS;AACd,SAAK,gBAAgB;AACrB,SAAK,oBAAoB;AACzB,SAAK,kBAAkB;AACvB,SAAK,eAAe;AAAA,EACtB;AAAA,EAEA,MAAgB,MAAqB;AACnC,QAAI,YAAY;AAEhB,QAAI;AACF,YAAM,KAAK,MAAM,eAAe,OAAO,SAA6B;AAClE,cAAM,aAAa,MAAM,KAAK,aAAa,MAAM,KAAK,SAAS,KAAK,eAAe;AAEnF,YAAI,YAAY;AAGd,sBAAY;AACZ,gBAAM,KAAK,aAAa,MAAM,KAAK,cAAc,MAAS;AAAA,QAC5D;AAAA,MACF,CAAC;AAAA,IACH,SAAS,OAAO;AACd,UACE,iBAAiB,kBACjB,iBAAiB,mBACjB,iBAAiB,oBACjB;AACA,cAAM;AAAA,MACR;AACA,YAAM,IAAI,mBAAmB;AAAA,QAC3B,SAAS,QAAQ,KAAK,EAAE;AAAA,QACxB,SAAS,EAAE,UAAU;AAAA,MACvB,CAAC;AAAA,IACH;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAM,aACJ,MACA,SACA,gBACkB;AAClB,UAAM,WAAY,MAAM,QAAQ;AAAA,MAC9B;AAAA,IACF;AAEA,UAAM,QAAQ,KAAK,UACf,OAAO,QAAQ,KAAK,OAAO,EAAE,IAAI,CAAC,CAAC,MAAM,IAAI,MAAM;AACjD,YAAM,YAAY;AAAA,QAChB,MAAM;AAAA,QACN;AAAA,QACA,aAAa,KAAK;AAAA,QAClB,YAAY,IAAI;AAAA,UACd,KAAK;AAAA,UACL;AAAA,UACA,KAAK;AAAA,QACP;AAAA,MACF;AAEA,UAAI,KAAK,mBAAmB;AAC1B,kBAAU,SAAS;AAAA,MACrB;AAEA,aAAO;AAAA,IACT,CAAC,IACD;AAEJ,UAAM,iBAA0C,EAAE,GAAG,KAAK,cAAc;AACxE,QAAI,CAAC,OAAO;AACV,aAAO,eAAe;AAAA,IACxB;AAEA,UAAM,UAAiC;AAAA,MACrC,MAAM;AAAA,MACN,OAAO,KAAK;AAAA,MACZ,OAAO;AAAA,MACP,OAAQ,SAAS,CAAC;AAAA,MAClB,GAAI,iBAAiB,EAAE,sBAAsB,eAAe,IAAI,CAAC;AAAA,MACjE,GAAG;AAAA,IACL;AAEA,QAAI;AACJ,QAAI;AACF,gBAAU,KAAK,YAAY,OAAO;AAAA,IACpC,SAAS,OAAO;AACd,UAAI,iBAAiB,oBAAoB;AACvC,aAAK,MAAM;AACX,aAAK,MAAM,WAAW;AAAA,MACxB;AACA,YAAM;AAAA,IACR;AACA,UAAM,SAAS,QAAQ,OAAO,EAAE,UAAU;AAI1C,QAAI;AACF,aAAO,MAAM;AACX,cAAM,EAAE,MAAM,OAAO,MAAM,IAAI,MAAM,OAAO,KAAK;AACjD,YAAI,KAAM;AAEV,YAAI;AAEJ,gBAAQ,MAAM,MAAM;AAAA,UAClB,KAAK,SAAS;AACZ,kBAAM,QAAQ,KAAK,aAAa,OAAO,IAAI;AAC3C,gBAAI,MAAO,QAAO;AAClB;AAAA,UACF;AAAA,UACA,KAAK;AACH,iBAAK,uBAAuB,KAAK;AACjC;AAAA,UACF,KAAK;AACH,oBAAQ,KAAK,sBAAsB,KAAK;AACxC;AAAA,UACF,KAAK;AACH,oBAAQ,KAAK,uBAAuB,KAAK;AACzC;AAAA,UACF,KAAK;AACH,oBAAQ,KAAK,yBAAyB,KAAK;AAC3C;AAAA,UACF,KAAK;AACH,iBAAK,sBAAsB,KAAK;AAChC;AAAA,UACF;AACE;AAAA,QACJ;AAEA,YAAI,OAAO;AACT,eAAK,MAAM,IAAI,KAAK;AAAA,QACtB;AAAA,MACF;AAAA,IACF,UAAE;AACA,aAAO,YAAY;AAAA,IACrB;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,aAAa,OAA0C,MAAmC;AA9f5F;AA+fI,UAAM,QAAO,WAAM,UAAN,mBAAa;AAE1B,QAAI,SAAS,+BAA+B;AAG1C,aAAO;AAAA,IACT;AAEA,QAAI,SAAS,wCAAwC,SAAS,oBAAoB;AAGhF,WAAK,MAAM;AACX,WAAK,MAAM,WAAW;AACtB,YAAM,IAAI,mBAAmB;AAAA,QAC3B,WAAS,WAAM,UAAN,mBAAa,YAAW,qBAAqB,IAAI;AAAA,QAC1D,SAAS,EAAE,WAAW,KAAK;AAAA,MAC7B,CAAC;AAAA,IACH;AAEA,UAAM,IAAI,eAAe;AAAA,MACvB,WAAS,WAAM,UAAN,mBAAa,YAAW,MAAM,WAAW;AAAA,MAClD,SAAS;AAAA,QACP,YAAY,MAAM,UAAU;AAAA,QAC5B,WAAW;AAAA,MACb;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,uBAAuB,OAAqC;AAC1D,SAAK,cAAc,MAAM,SAAS;AAClC,SAAK,KAAK,mBAAmB,MAAM,SAAS,IAAI,KAAK,YAAY;AAAA,EACnE;AAAA,EAEA,sBAAsB,OAAyD;AAC7E,QAAI,MAAM,KAAK,SAAS,iBAAiB;AACvC,WAAK,kBAAkB,IAAI,MAAM,KAAK,OAAO;AAC7C,aAAO;AAAA,QACL,IAAI,KAAK;AAAA,QACT,OAAO;AAAA,UACL,MAAM;AAAA,UACN,SAAS;AAAA,UACT,WAAW;AAAA,YACT,IAAI,aAAa,OAAO;AAAA,cACtB,QAAQ,MAAM,KAAK;AAAA,cACnB,MAAM,MAAM,KAAK;AAAA,cACjB,MAAM,MAAM,KAAK;AAAA,YACnB,CAAC;AAAA,UACH;AAAA,QACF;AAAA,MACF;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA,EAEA,uBAAuB,OAA8C;AACnE,WAAO;AAAA,MACL,IAAI,KAAK;AAAA,MACT,OAAO;AAAA,QACL,MAAM;AAAA,QACN,SAAS,MAAM;AAAA,MACjB;AAAA,IACF;AAAA,EACF;AAAA,EAEA,yBAAyB,OAA4D;AACnF,SAAK,KAAK,qBAAqB,KAAK,iBAAiB;AAErD,QAAI,MAAM,SAAS,OAAO;AACxB,aAAO;AAAA,QACL,IAAI,KAAK;AAAA,QACT,OAAO;AAAA,UACL,kBAAkB,MAAM,SAAS,MAAM;AAAA,UACvC,cAAc,MAAM,SAAS,MAAM;AAAA,UACnC,oBAAoB,MAAM,SAAS,MAAM,qBAAqB;AAAA,UAC9D,aAAa,MAAM,SAAS,MAAM;AAAA,QACpC;AAAA,MACF;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA,EAEA,sBAAsB,OAAoC;AAhlB5D;AAilBI,UAAM,IAAI,eAAe;AAAA,MACvB,WAAS,iBAAM,aAAN,mBAAgB,UAAhB,mBAAuB,YAAW;AAAA,MAC3C,SAAS,EAAE,YAAY,IAAI,WAAW,MAAM;AAAA,IAC9C,CAAC;AAAA,EACH;AACF;AAMA,eAAe,UAAU,KAAa,QAAgB,WAAuC;AAC3F,SAAO,IAAI,QAAmB,CAAC,SAAS,WAAW;AACjD,UAAM,KAAK,IAAI,UAAU,KAAK;AAAA,MAC5B,SAAS,EAAE,eAAe,UAAU,MAAM,GAAG;AAAA,IAC/C,CAAC;AAED,QAAI,UAAU;AAEd,UAAM,QAAQ,WAAW,MAAM;AAC7B,gBAAU;AACV,SAAG,MAAM;AACT;AAAA,QACE,IAAI,mBAAmB,EAAE,SAAS,mDAAmD,CAAC;AAAA,MACxF;AAAA,IACF,GAAG,SAAS;AAEZ,OAAG,KAAK,QAAQ,MAAM;AACpB,UAAI,QAAS;AACb,gBAAU;AACV,mBAAa,KAAK;AAClB,cAAQ,EAAE;AAAA,IACZ,CAAC;AAED,OAAG,KAAK,SAAS,CAAC,QAAQ;AACxB,UAAI,QAAS;AACb,gBAAU;AACV,mBAAa,KAAK;AAClB;AAAA,QACE,IAAI,mBAAmB;AAAA,UACrB,SAAS,mDAAmD,IAAI,OAAO;AAAA,QACzE,CAAC;AAAA,MACH;AAAA,IACF,CAAC;AAED,OAAG,KAAK,SAAS,CAAC,SAAS;AACzB,UAAI,QAAS;AACb,gBAAU;AACV,mBAAa,KAAK;AAClB;AAAA,QACE,IAAI,mBAAmB;AAAA,UACrB,SAAS,uEAAuE,IAAI;AAAA,QACtF,CAAC;AAAA,MACH;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AACH;AAEA,SAAS,uBAAuB,YAA4B;AAC1D,UAAQ,YAAY;AAAA,IAClB,KAAK,UAAU;AACb,aAAO;AAAA,IACT,KAAK,UAAU;AACb,aAAO;AAAA,IACT,KAAK,UAAU;AACb,aAAO;AAAA,IACT,KAAK,UAAU;AACb,aAAO;AAAA,IACT;AACE,aAAO,WAAW,UAAU;AAAA,EAChC;AACF;","names":["llm"]}

package/dist/ws/llm.test.cjs

@@ -0,0 +1,26 @@
+"use strict";
+var import_agents = require("@livekit/agents");
+var import_agents_plugins_test = require("@livekit/agents-plugins-test");
+var import_vitest = require("vitest");
+var import_llm = require("../responses/llm.cjs");
+(0, import_agents.initializeLogger)({ level: "silent", pretty: false });
+(0, import_vitest.describe)("OpenAI Responses WS wrapper", async () => {
+  await (0, import_agents_plugins_test.llm)(
+    new import_llm.LLM({
+      temperature: 0,
+      strictToolSchema: false,
+      useWebSocket: true
+    }),
+    true
+  );
+});
+(0, import_vitest.describe)("OpenAI Responses WS wrapper strict tool schema", async () => {
+  await (0, import_agents_plugins_test.llmStrict)(
+    new import_llm.LLM({
+      temperature: 0,
+      strictToolSchema: true,
+      useWebSocket: true
+    })
+  );
+});
+//# sourceMappingURL=llm.test.cjs.map

package/dist/ws/llm.test.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/ws/llm.test.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2025 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport { initializeLogger } from '@livekit/agents';\nimport { llm, llmStrict } from '@livekit/agents-plugins-test';\nimport { describe } from 'vitest';\nimport { LLM } from '../responses/llm.js';\n\ninitializeLogger({ level: 'silent', pretty: false });\n\ndescribe('OpenAI Responses WS wrapper', async () => {\n  await llm(\n    new LLM({\n      temperature: 0,\n      strictToolSchema: false,\n      useWebSocket: true,\n    }),\n    true,\n  );\n});\n\ndescribe('OpenAI Responses WS wrapper strict tool schema', async () => {\n  await llmStrict(\n    new LLM({\n      temperature: 0,\n      strictToolSchema: true,\n      useWebSocket: true,\n    }),\n  );\n});\n"],"mappings":";AAGA,oBAAiC;AACjC,iCAA+B;AAC/B,oBAAyB;AACzB,iBAAoB;AAAA,IAEpB,gCAAiB,EAAE,OAAO,UAAU,QAAQ,MAAM,CAAC;AAAA,IAEnD,wBAAS,+BAA+B,YAAY;AAClD,YAAM;AAAA,IACJ,IAAI,eAAI;AAAA,MACN,aAAa;AAAA,MACb,kBAAkB;AAAA,MAClB,cAAc;AAAA,IAChB,CAAC;AAAA,IACD;AAAA,EACF;AACF,CAAC;AAAA,IAED,wBAAS,kDAAkD,YAAY;AACrE,YAAM;AAAA,IACJ,IAAI,eAAI;AAAA,MACN,aAAa;AAAA,MACb,kBAAkB;AAAA,MAClB,cAAc;AAAA,IAChB,CAAC;AAAA,EACH;AACF,CAAC;","names":[]}

package/dist/ws/llm.test.d.cts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=llm.test.d.ts.map

package/dist/ws/llm.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=llm.test.d.ts.map

package/dist/ws/llm.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm.test.d.ts","sourceRoot":"","sources":["../../src/ws/llm.test.ts"],"names":[],"mappings":""}