@livekit/agents-plugin-openai 1.0.49 → 1.0.51

package/dist/ws/llm.d.cts

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

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