@pipedog/openai 0.0.0 → 0.4.0

package/dist/llm.d.ts

@@ -0,0 +1,30 @@
+/**
+ * OpenAI LLM service implementation with context aggregators.
+ *
+ * Porting note: the deprecated `model` and `params` constructor options are
+ * not ported (use `settings`), so `serviceTier` is only read from its own
+ * option.
+ */
+import { BaseOpenAILLMService, type BaseOpenAILLMServiceOptions, type OpenAILLMSettings } from "./base_llm.ts";
+export interface OpenAILLMServiceOptions extends BaseOpenAILLMServiceOptions {
+}
+/**
+ * OpenAI LLM service implementation.
+ *
+ * Provides a complete OpenAI LLM service with context aggregation support.
+ * Uses the BaseOpenAILLMService for core functionality and adds
+ * OpenAI-specific context aggregator creation.
+ */
+export declare class OpenAILLMService extends BaseOpenAILLMService {
+    static Settings: typeof OpenAILLMSettings;
+    /**
+     * Initialize OpenAI LLM service.
+     *
+     * @param options.serviceTier Service tier to use (e.g., "auto", "flex", "priority").
+     * @param options.settings Runtime-updatable settings. Its given fields
+     *   override the defaults (model "gpt-4.1").
+     *   Other options are passed to the parent BaseOpenAILLMService.
+     */
+    constructor(options?: OpenAILLMServiceOptions);
+}
+//# sourceMappingURL=llm.d.ts.map

package/dist/llm.js

@@ -0,0 +1,50 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/services/openai/llm.py
+/**
+ * OpenAI LLM service implementation with context aggregators.
+ *
+ * Porting note: the deprecated `model` and `params` constructor options are
+ * not ported (use `settings`), so `serviceTier` is only read from its own
+ * option.
+ */
+import { BaseOpenAILLMService, setOpenAINotGiven, } from "./base_llm.js";
+/**
+ * OpenAI LLM service implementation.
+ *
+ * Provides a complete OpenAI LLM service with context aggregation support.
+ * Uses the BaseOpenAILLMService for core functionality and adds
+ * OpenAI-specific context aggregator creation.
+ */
+export class OpenAILLMService extends BaseOpenAILLMService {
+    static Settings = BaseOpenAILLMService.Settings;
+    /**
+     * Initialize OpenAI LLM service.
+     *
+     * @param options.serviceTier Service tier to use (e.g., "auto", "flex", "priority").
+     * @param options.settings Runtime-updatable settings. Its given fields
+     *   override the defaults (model "gpt-4.1").
+     *   Other options are passed to the parent BaseOpenAILLMService.
+     */
+    constructor(options = {}) {
+        const cls = new.target;
+        // 1. Initialize default_settings with hardcoded defaults
+        const defaultSettings = new cls.Settings({
+            model: "gpt-4.1",
+            systemInstruction: null,
+            topK: null,
+            filterIncompleteUserTurns: false,
+            userTurnCompletionConfig: null,
+            extra: {},
+        });
+        setOpenAINotGiven(defaultSettings);
+        // 2. Apply settings delta (canonical API, always wins)
+        if (options.settings !== undefined && options.settings !== null) {
+            defaultSettings.applyUpdate(options.settings);
+        }
+        super({ ...options, serviceTier: options.serviceTier ?? null, settings: defaultSettings });
+    }
+}
+//# sourceMappingURL=llm.js.map

package/dist/open_ai_live_adapter.d.ts

@@ -0,0 +1,94 @@
+/** OpenAI Live LLM adapter for Pipecat. */
+import { BaseLLMAdapter } from "@pipedog/core/adapters/base_llm_adapter";
+import type { ToolsSchema } from "@pipedog/core/adapters/schemas/tools_schema";
+import { type LLMContext, type NotGiven } from "@pipedog/core/processors/aggregators/llm_context";
+import * as events from "./live/events.ts";
+import { OpenAIResponsesLLMAdapter } from "./open_ai_responses_adapter.ts";
+type Dict = Record<string, any>;
+/**
+ * Session configuration derived from a universal `LLMContext`.
+ *
+ * - `instructions`: System instructions for the live model, or `null`.
+ * - `input`: Prior text-only messages to seed the session with.
+ * - `tools`: Function tools in Responses API format, for the backend model.
+ * - `tool_choice`: Tool choice in Responses API format, or `null`.
+ */
+export interface OpenAILiveLLMInvocationParams {
+    instructions: string | null;
+    input: events.InputItem[];
+    tools: Record<string, unknown>[];
+    tool_choice: unknown | null;
+}
+/** Options for `OpenAILiveLLMAdapter.getLlmInvocationParams`. */
+export interface OpenAILiveLLMInvocationParamsOptions {
+    /** System instruction from the service settings. */
+    systemInstruction?: string | null;
+}
+/**
+ * Converts a universal `LLMContext` into OpenAI Live session configuration.
+ *
+ * The live model takes a system instruction and a text-only conversation
+ * history at session start; tools belong to the backend (Responses) model
+ * and use the Responses API tool format.
+ */
+export declare class OpenAILiveLLMAdapter extends BaseLLMAdapter<OpenAILiveLLMInvocationParams> {
+    protected _responsesAdapter: OpenAIResponsesLLMAdapter;
+    protected _warnedInputTruncated: boolean;
+    /** Initialize the adapter. */
+    constructor();
+    /** The identifier used in LLMSpecificMessage instances for OpenAI Live. */
+    get idForLlmSpecificMessages(): string;
+    /**
+     * Derive session configuration from a universal LLM context.
+     *
+     * A leading `system` message becomes the live model's instructions
+     * (`systemInstruction` from the service settings wins if both are set).
+     * The remaining messages become the startup `input` history.
+     *
+     * @param context The LLM context containing messages, tools, etc.
+     * @param options.systemInstruction System instruction from the service settings.
+     * @returns The session configuration values.
+     */
+    getLlmInvocationParams(context: LLMContext, options?: OpenAILiveLLMInvocationParamsOptions): Promise<OpenAILiveLLMInvocationParams>;
+    /**
+     * Get messages from a universal LLM context in a format ready for logging.
+     *
+     * Binary data (images, audio) is replaced with short placeholders.
+     *
+     * @param context The LLM context containing messages.
+     * @returns List of messages in a format ready for logging.
+     */
+    getMessagesForLogging(context: LLMContext): Record<string, unknown>[];
+    /**
+     * Convert tool schemas to the Responses API tool format used by the backend
+     * model.
+     *
+     * The Live session schema rejects the Responses-only `strict` field, so it
+     * is dropped from function tools.
+     *
+     * @param toolsSchema The tools schema containing functions to convert.
+     * @returns List of tool definitions.
+     */
+    toProviderToolsFormat(toolsSchema: ToolsSchema): Record<string, unknown>[];
+    /**
+     * Convert standard messages to the text-only startup `input` history.
+     *
+     * Tool calls, tool results and non-text content have no representation
+     * there and are skipped. System messages become developer messages, the
+     * role the startup history accepts. At most `events.MAX_INPUT_ITEMS` items
+     * are kept, dropping the oldest.
+     */
+    protected _toInputItems(messages: Dict[]): events.InputItem[];
+    /** Return a message's text content, joining text parts of list content. */
+    protected static _textContent(message: Dict): string;
+    /**
+     * Convert a context tool choice to the Responses API shape.
+     *
+     * The context stores the chat-completions form, whose named-function
+     * variant nests the name (`{"type": "function", "function": {"name": …}}`);
+     * the Responses API takes it flat (`{"type": "function", "name": …}`).
+     */
+    protected static _toToolChoice(toolChoice: unknown | NotGiven): unknown | null;
+}
+export {};
+//# sourceMappingURL=open_ai_live_adapter.d.ts.map

package/dist/open_ai_live_adapter.js

@@ -0,0 +1,192 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/adapters/services/open_ai_live_adapter.py
+/** OpenAI Live LLM adapter for Pipecat. */
+import { BaseLLMAdapter } from "@pipedog/core/adapters/base_llm_adapter";
+import { LLMSpecificMessage, } from "@pipedog/core/processors/aggregators/llm_context";
+import { logger } from "@pipedog/core/utils/logger";
+import { pyJsonDumps } from "@pipedog/core/utils/py_json";
+import { isGiven } from "@pipedog/core/utils/types";
+import * as events from "./live/events.js";
+import { OpenAIResponsesLLMAdapter } from "./open_ai_responses_adapter.js";
+/**
+ * Converts a universal `LLMContext` into OpenAI Live session configuration.
+ *
+ * The live model takes a system instruction and a text-only conversation
+ * history at session start; tools belong to the backend (Responses) model
+ * and use the Responses API tool format.
+ */
+export class OpenAILiveLLMAdapter extends BaseLLMAdapter {
+    _responsesAdapter;
+    _warnedInputTruncated;
+    /** Initialize the adapter. */
+    constructor() {
+        super();
+        this._responsesAdapter = new OpenAIResponsesLLMAdapter();
+        this._warnedInputTruncated = false;
+    }
+    /** The identifier used in LLMSpecificMessage instances for OpenAI Live. */
+    get idForLlmSpecificMessages() {
+        return "openai-live";
+    }
+    /**
+     * Derive session configuration from a universal LLM context.
+     *
+     * A leading `system` message becomes the live model's instructions
+     * (`systemInstruction` from the service settings wins if both are set).
+     * The remaining messages become the startup `input` history.
+     *
+     * @param context The LLM context containing messages, tools, etc.
+     * @param options.systemInstruction System instruction from the service settings.
+     * @returns The session configuration values.
+     */
+    async getLlmInvocationParams(context, options = {}) {
+        // LLMSpecificMessages are opaque provider payloads with no place in a
+        // text-only history.
+        const messages = this.getMessages(context).filter((m) => !(m instanceof LLMSpecificMessage));
+        let systemFromContext = null;
+        if (messages.length > 0 && messages[0].role === "system") {
+            systemFromContext = OpenAILiveLLMAdapter._textContent(messages.shift());
+        }
+        const instructions = this._resolveSystemInstruction(systemFromContext, options.systemInstruction ?? null, { discardContextSystem: true });
+        // NOTE: LLMContext's tools are guaranteed to be a ToolsSchema (or NOT_GIVEN)
+        const tools = this.fromStandardTools(context.tools);
+        return {
+            instructions,
+            input: this._toInputItems(messages),
+            // `from_standard_tools(...) or []`: NOT_GIVEN and null are falsy upstream.
+            tools: (tools != null && isGiven(tools) && tools.length > 0 ? tools : []),
+            tool_choice: OpenAILiveLLMAdapter._toToolChoice(context.toolChoice),
+        };
+    }
+    /**
+     * Get messages from a universal LLM context in a format ready for logging.
+     *
+     * Binary data (images, audio) is replaced with short placeholders.
+     *
+     * @param context The LLM context containing messages.
+     * @returns List of messages in a format ready for logging.
+     */
+    getMessagesForLogging(context) {
+        return this.getMessages(context, { truncateLargeValues: true });
+    }
+    /**
+     * Convert tool schemas to the Responses API tool format used by the backend
+     * model.
+     *
+     * The Live session schema rejects the Responses-only `strict` field, so it
+     * is dropped from function tools.
+     *
+     * @param toolsSchema The tools schema containing functions to convert.
+     * @returns List of tool definitions.
+     */
+    toProviderToolsFormat(toolsSchema) {
+        const tools = [];
+        for (const original of this._responsesAdapter.toProviderToolsFormat(toolsSchema)) {
+            const tool = { ...original };
+            if (tool.type === "function") {
+                delete tool.strict;
+            }
+            tools.push(tool);
+        }
+        return tools;
+    }
+    /**
+     * Convert standard messages to the text-only startup `input` history.
+     *
+     * Tool calls, tool results and non-text content have no representation
+     * there and are skipped. System messages become developer messages, the
+     * role the startup history accepts. At most `events.MAX_INPUT_ITEMS` items
+     * are kept, dropping the oldest.
+     */
+    _toInputItems(messages) {
+        let items = [];
+        for (const message of messages) {
+            const role = message.role;
+            const text = OpenAILiveLLMAdapter._textContent(message);
+            if ((role === "system" || role === "developer") && text) {
+                items.push(new events.InputItem({
+                    role: "developer",
+                    content: [new events.InputTextContent({ text })],
+                }));
+            }
+            else if (role === "user" && text) {
+                items.push(new events.InputItem({ role: "user", content: [new events.InputTextContent({ text })] }));
+            }
+            else if (role === "assistant" &&
+                text &&
+                !(message.tool_calls && message.tool_calls.length > 0)) {
+                items.push(new events.InputItem({
+                    role: "assistant",
+                    content: [new events.OutputTextContent({ text })],
+                }));
+            }
+            else {
+                logger.debug(`Skipping context message with no startup-history representation: role=${pyRepr(role)}`);
+            }
+        }
+        if (items.length > events.MAX_INPUT_ITEMS) {
+            if (!this._warnedInputTruncated) {
+                this._warnedInputTruncated = true;
+                logger.warning(`Context has ${items.length} text messages but the OpenAI Live API accepts ` +
+                    `at most ${events.MAX_INPUT_ITEMS} startup messages; keeping the most recent.`);
+            }
+            items = items.slice(-events.MAX_INPUT_ITEMS);
+        }
+        return items;
+    }
+    /** Return a message's text content, joining text parts of list content. */
+    static _textContent(message) {
+        const content = message.content;
+        if (typeof content === "string") {
+            return content;
+        }
+        if (Array.isArray(content)) {
+            return content
+                .filter((part) => part !== null &&
+                typeof part === "object" &&
+                !Array.isArray(part) &&
+                part.type === "text" &&
+                part.text)
+                .map((part) => part.text ?? "")
+                .join(" ");
+        }
+        return "";
+    }
+    /**
+     * Convert a context tool choice to the Responses API shape.
+     *
+     * The context stores the chat-completions form, whose named-function
+     * variant nests the name (`{"type": "function", "function": {"name": …}}`);
+     * the Responses API takes it flat (`{"type": "function", "name": …}`).
+     */
+    static _toToolChoice(toolChoice) {
+        if (!isGiven(toolChoice) || toolChoice == null) {
+            return null;
+        }
+        if (typeof toolChoice === "object" &&
+            !Array.isArray(toolChoice) &&
+            toolChoice.function !== null &&
+            typeof toolChoice.function === "object" &&
+            !Array.isArray(toolChoice.function)) {
+            return { type: "function", name: toolChoice.function.name ?? null };
+        }
+        return toolChoice;
+    }
+}
+/** Python's `repr()` for the values a message role can hold (a string or None). */
+function pyRepr(value) {
+    if (value === undefined || value === null)
+        return "None";
+    if (typeof value === "string") {
+        // Python picks double quotes when the string has a ' and no ".
+        const escaped = value.replace(/\\/g, "\\\\");
+        if (value.includes("'") && !value.includes('"'))
+            return `"${escaped}"`;
+        return `'${escaped.replace(/'/g, "\\'")}'`;
+    }
+    return pyJsonDumps(value);
+}
+//# sourceMappingURL=open_ai_live_adapter.js.map

package/dist/open_ai_realtime_adapter.d.ts

@@ -0,0 +1,95 @@
+/** OpenAI Realtime LLM adapter for Pipecat. */
+import { BaseLLMAdapter } from "@pipedog/core/adapters/base_llm_adapter";
+import type { FunctionSchema } from "@pipedog/core/adapters/schemas/function_schema";
+import { type ToolsSchema } from "@pipedog/core/adapters/schemas/tools_schema";
+import { type LLMContext, type LLMContextMessage } from "@pipedog/core/processors/aggregators/llm_context";
+import * as events from "./realtime/events.ts";
+/**
+ * Context-based parameters for invoking OpenAI Realtime API.
+ *
+ * This is a placeholder until support for universal LLMContext machinery is
+ * added for OpenAI Realtime.
+ */
+export interface OpenAIRealtimeLLMInvocationParams {
+    system_instruction: string | null;
+    messages: events.ConversationItem[];
+    tools: Record<string, unknown>[];
+}
+/** Options for `OpenAIRealtimeLLMAdapter.getLlmInvocationParams`. */
+export interface OpenAIRealtimeLLMInvocationParamsOptions {
+    /** Optional system instruction from service settings. */
+    systemInstruction?: string | null;
+    /**
+     * The service's init-provided tools, as `_serviceTools()` returns them: a
+     * `ToolsSchema` or a provider-native tool list, or `null`.
+     */
+    serviceTools?: unknown;
+}
+/** Container for OpenAI-formatted messages converted from universal context. */
+export declare class ConvertedMessages {
+    messages: events.ConversationItem[];
+    systemInstruction: string | null;
+    constructor(options: {
+        messages: events.ConversationItem[];
+        systemInstruction?: string | null;
+    });
+}
+/**
+ * LLM adapter for OpenAI Realtime API function calling.
+ *
+ * Converts Pipecat's tool schemas into the specific format required by
+ * OpenAI's Realtime API for function calling capabilities.
+ */
+export declare class OpenAIRealtimeLLMAdapter extends BaseLLMAdapter<OpenAIRealtimeLLMInvocationParams> {
+    /** Container for OpenAI-formatted messages converted from universal context. */
+    static ConvertedMessages: typeof ConvertedMessages;
+    /** The identifier used in LLMSpecificMessage instances for OpenAI Realtime. */
+    get idForLlmSpecificMessages(): string;
+    /**
+     * Get OpenAI Realtime-specific LLM invocation parameters from a universal
+     * LLM context.
+     *
+     * The `tools` returned are the set the session should carry: the context's
+     * own when it has any, else the init-provided ones. Built-in tools ride
+     * along with whichever set is in use, and are the set when there is
+     * neither.
+     *
+     * @param context The LLM context containing messages, tools, etc.
+     * @param options.systemInstruction Optional system instruction from service settings.
+     * @param options.serviceTools The service's init-provided tools, as
+     *   `_serviceTools()` returns them: a `ToolsSchema` or a provider-native
+     *   tool list, or `null`.
+     * @returns Dictionary of parameters for invoking OpenAI Realtime's API.
+     */
+    getLlmInvocationParams(context: LLMContext, options?: OpenAIRealtimeLLMInvocationParamsOptions): Promise<OpenAIRealtimeLLMInvocationParams>;
+    /**
+     * Get messages from a universal LLM context in a format ready for logging
+     * about OpenAI Realtime.
+     *
+     * Binary data (images, audio) is replaced with short placeholders.
+     *
+     * This is a placeholder until support for universal LLMContext machinery is
+     * added for OpenAI Realtime.
+     *
+     * @param context The LLM context containing messages.
+     * @returns List of messages in a format ready for logging about OpenAI Realtime.
+     */
+    getMessagesForLogging(context: LLMContext): Record<string, unknown>[];
+    protected _fromUniversalContextMessages(universalContextMessages: LLMContextMessage[]): ConvertedMessages;
+    protected _fromUniversalContextMessage(message: LLMContextMessage): events.ConversationItem;
+    /**
+     * Convert a function schema to OpenAI Realtime format.
+     *
+     * @param func The function schema to convert.
+     * @returns Dictionary in OpenAI Realtime function format.
+     */
+    protected static _toOpenaiRealtimeFunctionFormat(func: FunctionSchema): Record<string, unknown>;
+    /**
+     * Convert tool schemas to OpenAI Realtime function-calling format.
+     *
+     * @param toolsSchema The tools schema containing functions to convert.
+     * @returns List of function definitions in OpenAI Realtime format.
+     */
+    toProviderToolsFormat(toolsSchema: ToolsSchema): Record<string, unknown>[];
+}
+//# sourceMappingURL=open_ai_realtime_adapter.d.ts.map