@pipedog/openai 0.0.0 → 0.3.0

package/dist/open_ai_realtime_adapter.js

@@ -0,0 +1,221 @@
+// 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_realtime_adapter.py
+/** OpenAI Realtime LLM adapter for Pipecat. */
+import { BaseLLMAdapter } from "@pipedog/core/adapters/base_llm_adapter";
+import { AdapterType } from "@pipedog/core/adapters/schemas/tools_schema";
+import { LLMSpecificMessage, } from "@pipedog/core/processors/aggregators/llm_context";
+import { logger } from "@pipedog/core/utils/logger";
+import * as events from "./realtime/events.js";
+/** Container for OpenAI-formatted messages converted from universal context. */
+export class ConvertedMessages {
+    messages;
+    systemInstruction;
+    constructor(options) {
+        this.messages = options.messages;
+        this.systemInstruction = options.systemInstruction ?? 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 class OpenAIRealtimeLLMAdapter extends BaseLLMAdapter {
+    /** Container for OpenAI-formatted messages converted from universal context. */
+    static ConvertedMessages = ConvertedMessages;
+    /** The identifier used in LLMSpecificMessage instances for OpenAI Realtime. */
+    get idForLlmSpecificMessages() {
+        return "openai-realtime";
+    }
+    /**
+     * 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.
+     */
+    async getLlmInvocationParams(context, options = {}) {
+        const messages = this._fromUniversalContextMessages(this.getMessages(context));
+        const effectiveSystem = this._resolveSystemInstruction(messages.systemInstruction, options.systemInstruction ?? null, { discardContextSystem: true });
+        return {
+            system_instruction: effectiveSystem,
+            messages: messages.messages,
+            tools: (this._realtimeSessionTools(context.tools, options.serviceTools ?? null) ??
+                []),
+        };
+    }
+    /**
+     * 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) {
+        return this.getMessages(context, { truncateLargeValues: true });
+    }
+    _fromUniversalContextMessages(universalContextMessages) {
+        // We can't load a long conversation history into the openai realtime api yet. (The API/model
+        // forgets that it can do audio, if you do a series of `conversation.item.create` calls.) So
+        // our general strategy until this is fixed is just to put everything into a first "user"
+        // message as a single input.
+        if (universalContextMessages.length === 0) {
+            return new ConvertedMessages({ messages: [] });
+        }
+        // NOTE: This adapter does not yet handle `LLMSpecificMessage` — those
+        // are filtered out below. Other adapters (e.g. Anthropic) dispatch
+        // LLMSpecific items through a per-provider passthrough. For OpenAI
+        // Realtime, the strategy here packs a multi-message history into a
+        // single text message (see comment further down), which doesn't
+        // compose with opaque per-provider payloads. If/when this adapter
+        // adopts the per-message strategy, LLMSpecific items can flow
+        // through `_fromUniversalContextMessage` like in other adapters.
+        const messages = universalContextMessages
+            .filter((m) => !(m instanceof LLMSpecificMessage))
+            .map((m) => structuredClone(m));
+        let systemInstruction = null;
+        // If we have a "system" message as our first message,
+        // pull that out into session "instructions"
+        if (messages.length > 0 && messages[0].role === "system") {
+            this._warnContextSystemMessage();
+            const system = messages.shift();
+            const content = system.content;
+            if (typeof content === "string") {
+                systemInstruction = content;
+            }
+            else if (Array.isArray(content)) {
+                systemInstruction = content[0].text ?? null;
+            }
+            if (messages.length === 0) {
+                return new ConvertedMessages({ messages: [], systemInstruction });
+            }
+        }
+        // Convert any remaining "system"/"developer" messages to "user"
+        for (const msg of messages) {
+            if (msg.role === "system" || msg.role === "developer") {
+                msg.role = "user";
+            }
+        }
+        // If we have just a single "user" item, we can just send it normally
+        if (messages.length === 1 && messages[0].role === "user") {
+            return new ConvertedMessages({
+                messages: [this._fromUniversalContextMessage(messages[0])],
+                systemInstruction,
+            });
+        }
+        // Otherwise, let's pack everything into a single "user" message with a bit of
+        // explanation for the LLM
+        const introText = `
+        This is a previously saved conversation. Please treat this conversation history as a
+        starting point for the current conversation.`;
+        const trailingText = `
+        This is the end of the previously saved conversation. Please continue the conversation
+        from here. If the last message is a user instruction or question, act on that instruction
+        or answer the question. If the last message is an assistant response, simple say that you
+        are ready to continue the conversation.`;
+        return new ConvertedMessages({
+            messages: [
+                new events.ConversationItem({
+                    role: "user",
+                    type: "message",
+                    content: [
+                        new events.ItemContent({
+                            type: "input_text",
+                            // `json.dumps(messages, indent=2, ensure_ascii=False)`.
+                            // `pyJsonDumps` has no `indent`; `JSON.stringify` matches it for
+                            // context messages except for integral floats (`1.0` → `1`).
+                            text: [introText, JSON.stringify(messages, null, 2), trailingText].join("\n\n"),
+                        }),
+                    ],
+                }),
+            ],
+            systemInstruction,
+        });
+    }
+    _fromUniversalContextMessage(message) {
+        // NOTE: `LLMSpecificMessage` is not yet handled here — see the
+        // corresponding note in `_fromUniversalContextMessages`.
+        const msg = message;
+        if (msg.role === "user") {
+            let content = msg.content;
+            if (Array.isArray(content)) {
+                content = "";
+                for (const c of (msg.content ?? [])) {
+                    if (c.type === "text") {
+                        content += ` ${c.text}`;
+                    }
+                    else {
+                        logger.error(`Unhandled content type in context message: ${c.type} - ${JSON.stringify(msg)}`);
+                    }
+                }
+            }
+            return new events.ConversationItem({
+                role: "user",
+                type: "message",
+                content: [new events.ItemContent({ type: "input_text", text: content })],
+            });
+        }
+        if (msg.role === "assistant" && msg.tool_calls && msg.tool_calls.length > 0) {
+            const tc = msg.tool_calls[0];
+            return new events.ConversationItem({
+                type: "function_call",
+                callId: tc.id,
+                name: tc.function.name,
+                arguments: tc.function.arguments,
+            });
+        }
+        throw new Error(`Unhandled message type in _fromUniversalContextMessage: ${JSON.stringify(msg)}`);
+    }
+    /**
+     * Convert a function schema to OpenAI Realtime format.
+     *
+     * @param func The function schema to convert.
+     * @returns Dictionary in OpenAI Realtime function format.
+     */
+    static _toOpenaiRealtimeFunctionFormat(func) {
+        return {
+            type: "function",
+            name: func.name,
+            description: func.description,
+            parameters: {
+                type: "object",
+                properties: func.properties,
+                required: func.required,
+            },
+        };
+    }
+    /**
+     * 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) {
+        const functionsSchema = toolsSchema.standardTools;
+        const formattedStandardTools = functionsSchema.map((func) => OpenAIRealtimeLLMAdapter._toOpenaiRealtimeFunctionFormat(func));
+        let customOpenaiTools = [];
+        if (toolsSchema.customTools) {
+            customOpenaiTools = toolsSchema.customTools[AdapterType.OPENAI] ?? [];
+        }
+        return [...formattedStandardTools, ...customOpenaiTools];
+    }
+}
+//# sourceMappingURL=open_ai_realtime_adapter.js.map

package/dist/open_ai_responses_adapter.d.ts

@@ -0,0 +1,95 @@
+import { BaseLLMAdapter } from "@pipedog/core/adapters/base_llm_adapter";
+import { type ToolsSchema } from "@pipedog/core/adapters/schemas/tools_schema";
+import { type OpenAINotGiven } from "@pipedog/core/adapters/services/open_ai_adapter";
+import { type LLMContext, type LLMContextMessage, LLMSpecificMessage } from "@pipedog/core/processors/aggregators/llm_context";
+type Dict = Record<string, any>;
+/** A Responses API input item (`ResponseInputItemParam`). */
+export type ResponseInputItemParam = Dict;
+/** A Responses API tool (`ToolParam`). */
+export type ToolParam = Dict;
+/** A Responses API function tool (`FunctionToolParam`). */
+export interface FunctionToolParam {
+    type: "function";
+    name: string;
+    parameters: Dict | null;
+    strict: boolean | null;
+    description?: string | null;
+}
+/** Context-based parameters for invoking OpenAI Responses API. */
+export interface OpenAIResponsesLLMInvocationParams {
+    input: ResponseInputItemParam[];
+    tools: ToolParam[] | OpenAINotGiven;
+    instructions?: string;
+}
+/** Options for `OpenAIResponsesLLMAdapter.getLlmInvocationParams`. */
+export interface OpenAIResponsesLLMInvocationParamsOptions {
+    /** Optional system instruction from service settings. */
+    systemInstruction?: string | null;
+}
+/**
+ * OpenAI Responses API adapter for Pipecat.
+ *
+ * Handles:
+ *
+ * - Converting LLMContext messages to Responses API input items
+ * - Converting Pipecat's standardized tools schema to Responses API function tool format
+ * - Extracting and sanitizing messages from the LLM context for logging
+ */
+export declare class OpenAIResponsesLLMAdapter extends BaseLLMAdapter<OpenAIResponsesLLMInvocationParams> {
+    /** The identifier used in LLMSpecificMessage instances. */
+    get idForLlmSpecificMessages(): string;
+    /**
+     * Get Responses API invocation parameters from a universal LLM context.
+     *
+     * @param context The LLM context containing messages, tools, etc.
+     * @param options.systemInstruction Optional system instruction from service settings.
+     * @returns Dictionary of parameters for the Responses API.
+     */
+    getLlmInvocationParams(context: LLMContext, options?: OpenAIResponsesLLMInvocationParamsOptions): Promise<OpenAIResponsesLLMInvocationParams>;
+    /**
+     * Convert function schemas to Responses API function tool format.
+     *
+     * @param toolsSchema The Pipecat tools schema to convert.
+     * @returns List of Responses API function tool definitions.
+     */
+    toProviderToolsFormat(toolsSchema: ToolsSchema): ToolParam[];
+    /**
+     * Get messages from context in a format ready for logging.
+     *
+     * Binary data (images, audio) is replaced with short placeholders, and
+     * reasoning messages' encrypted payloads are elided.
+     *
+     * @param context The LLM context containing messages.
+     * @returns List of messages in a format ready for logging.
+     */
+    getMessagesForLogging(context: LLMContext): Record<string, unknown>[];
+    /**
+     * Convert LLMContext messages to Responses API input items.
+     *
+     * @param messages Messages from the LLMContext.
+     * @returns List of Responses API input items.
+     */
+    protected _convertMessagesToInput(messages: LLMContextMessage[]): ResponseInputItemParam[];
+    /**
+     * Convert an OpenAI-Responses-specific message to an input item.
+     *
+     * Reasoning messages — persisted so the model's prior reasoning round-trips
+     * on later turns — become Responses `reasoning` input items. Anything
+     * else is assumed to already be in Responses input shape.
+     *
+     * @param message The LLM-specific message from the context.
+     * @returns A Responses API input item.
+     */
+    protected _fromSpecificMessage(message: LLMSpecificMessage): ResponseInputItemParam;
+    /** The Responses API fetches image and file URLs itself. */
+    supportsFileUrl(url: string, _mimeType: string): boolean;
+    /**
+     * Convert multimodal content parts to Responses API format.
+     *
+     * @param content List of content parts from the LLMContext message.
+     * @returns List of content parts in Responses API format.
+     */
+    protected _convertMultimodalContent(content: Dict[]): Dict[];
+}
+export {};
+//# sourceMappingURL=open_ai_responses_adapter.d.ts.map

package/dist/open_ai_responses_adapter.js

@@ -0,0 +1,358 @@
+// 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_responses_adapter.py
+/**
+ * OpenAI Responses API adapter for Pipecat.
+ *
+ * Porting note: like `open_ai_adapter.ts` in core, this module does not
+ * depend on the `openai` SDK. The Responses API types are declared
+ * structurally, and the SDK's `NOT_GIVEN` sentinel is `undefined`.
+ */
+import { rethrowIfCancelled } from "@pipedog/asyncio";
+import { BaseLLMAdapter, LLMContextConversionError } from "@pipedog/core/adapters/base_llm_adapter";
+import { AdapterType } from "@pipedog/core/adapters/schemas/tools_schema";
+import { openaiFromLlmContextTools, } from "@pipedog/core/adapters/services/open_ai_adapter";
+import { LLMSpecificMessage, } from "@pipedog/core/processors/aggregators/llm_context";
+import { pyJsonDumps } from "@pipedog/core/utils/py_json";
+/**
+ * OpenAI Responses API adapter for Pipecat.
+ *
+ * Handles:
+ *
+ * - Converting LLMContext messages to Responses API input items
+ * - Converting Pipecat's standardized tools schema to Responses API function tool format
+ * - Extracting and sanitizing messages from the LLM context for logging
+ */
+export class OpenAIResponsesLLMAdapter extends BaseLLMAdapter {
+    /** The identifier used in LLMSpecificMessage instances. */
+    get idForLlmSpecificMessages() {
+        return "openai_responses";
+    }
+    /**
+     * Get Responses API invocation parameters from a universal LLM context.
+     *
+     * @param context The LLM context containing messages, tools, etc.
+     * @param options.systemInstruction Optional system instruction from service settings.
+     * @returns Dictionary of parameters for the Responses API.
+     */
+    async getLlmInvocationParams(context, options = {}) {
+        const systemInstruction = options.systemInstruction ?? null;
+        await this.prepareFileContent(context);
+        const messages = this.getMessages(context);
+        if (messages.length > 0) {
+            const firstMsg = messages[0] instanceof LLMSpecificMessage ? null : messages[0];
+            if (firstMsg && firstMsg.role === "system") {
+                this._warnContextSystemMessage();
+                // Check for conflict: systemInstruction + initial system message.
+                // `content` is `string | Iterable<...>`; we only forward it for
+                // warning purposes. Coerce non-strings to null.
+                const firstContent = firstMsg.content ?? "";
+                if (systemInstruction) {
+                    this._resolveSystemInstruction(typeof firstContent === "string" ? firstContent : null, systemInstruction, { discardContextSystem: false });
+                }
+            }
+        }
+        const inputItems = this._convertMessagesToInput(messages);
+        const params = {
+            input: inputItems,
+            // NOTE: LLMContext's tools are guaranteed to be a ToolsSchema (or NOT_GIVEN)
+            tools: openaiFromLlmContextTools(this.fromStandardTools(context.tools)),
+        };
+        if (systemInstruction) {
+            // Compatibility: The Responses API requires at least one input
+            // message when instructions are provided. Contexts that worked with
+            // OpenAILLMService (systemInstruction + empty messages) need the
+            // instructions converted to an initial developer message.
+            //
+            // NOTE: The service layer (OpenAIResponsesLLMService) internally
+            // manages `previous_response_id` for incremental context delivery
+            // over WebSocket. This runs post-adapter — the adapter always
+            // produces the full input list and the service determines what
+            // subset to send. This empty-input fallback is therefore only
+            // relevant for one-shot or initial calls.
+            //
+            // If we added support for user-provided explicit
+            // `previous_response_id` and/or `conversation_id` (overriding
+            // internal management), we'd need to revisit this logic, as it'd
+            // be legit to provide instructions without input items. Note that
+            // over HTTP, `previous_response_id` requires `store=True` (30-day
+            // OpenAI-side storage), which is why the HTTP variant doesn't use
+            // it. The WebSocket variant avoids this via a connection-local
+            // in-memory cache — see the class docstrings in llm.ts.
+            if (inputItems.length === 0) {
+                params.input = [{ role: "developer", content: systemInstruction }];
+            }
+            else {
+                params.instructions = systemInstruction;
+            }
+        }
+        return params;
+    }
+    /**
+     * Convert function schemas to Responses API function tool format.
+     *
+     * @param toolsSchema The Pipecat tools schema to convert.
+     * @returns List of Responses API function tool definitions.
+     */
+    toProviderToolsFormat(toolsSchema) {
+        const functionsSchema = toolsSchema.standardTools;
+        const result = [];
+        for (const func of functionsSchema) {
+            const d = func.toDefaultDict();
+            const tool = {
+                type: "function",
+                name: d.name,
+                parameters: pyGet(d, "parameters", {}),
+                strict: d.strict ?? null,
+            };
+            if ("description" in d) {
+                tool.description = d.description;
+            }
+            result.push(tool);
+        }
+        let customOpenaiTools = [];
+        if (toolsSchema.customTools) {
+            customOpenaiTools = toolsSchema.customTools[AdapterType.OPENAI] ?? [];
+        }
+        return [...result, ...customOpenaiTools];
+    }
+    /**
+     * Get messages from context in a format ready for logging.
+     *
+     * Binary data (images, audio) is replaced with short placeholders, and
+     * reasoning messages' encrypted payloads are elided.
+     *
+     * @param context The LLM context containing messages.
+     * @returns List of messages in a format ready for logging.
+     */
+    getMessagesForLogging(context) {
+        // Sanitize messages for logging
+        const messagesForLogging = [];
+        for (const message of this.getMessages(context, { truncateLargeValues: true })) {
+            if (message instanceof LLMSpecificMessage) {
+                // Responses-specific messages are reasoning items (see
+                // _BaseOpenAIResponsesLLMService._appendReasoningMessage).
+                // Elide the encrypted payload, which is opaque noise in logs.
+                const msg = structuredClone(message.message);
+                if (isDict(msg) && msg.encrypted_content) {
+                    msg.encrypted_content = "...";
+                }
+                messagesForLogging.push(msg);
+            }
+            else {
+                messagesForLogging.push(message);
+            }
+        }
+        return messagesForLogging;
+    }
+    /**
+     * Convert LLMContext messages to Responses API input items.
+     *
+     * @param messages Messages from the LLMContext.
+     * @returns List of Responses API input items.
+     */
+    _convertMessagesToInput(messages) {
+        const result = [];
+        for (const message of messages) {
+            if (message instanceof LLMSpecificMessage) {
+                result.push(this._fromSpecificMessage(message));
+                continue;
+            }
+            const role = message.role;
+            if (role === "system" || role === "developer") {
+                let content = pyGet(message, "content", "");
+                if (Array.isArray(content)) {
+                    content = this._convertMultimodalContent(content);
+                }
+                result.push({ role: "developer", content });
+            }
+            else if (role === "user") {
+                let content = pyGet(message, "content", "");
+                if (Array.isArray(content)) {
+                    content = this._convertMultimodalContent(content);
+                }
+                result.push({ role: "user", content });
+            }
+            else if (role === "assistant") {
+                const toolCalls = message.tool_calls;
+                if (toolCalls && toolCalls.length > 0) {
+                    for (const tc of toolCalls) {
+                        const func = pyGet(tc, "function", {});
+                        result.push({
+                            type: "function_call",
+                            call_id: pyGet(tc, "id", ""),
+                            name: pyGet(func, "name", ""),
+                            arguments: pyGet(func, "arguments", ""),
+                        });
+                    }
+                }
+                else {
+                    let content = pyGet(message, "content", "");
+                    if (Array.isArray(content)) {
+                        content = this._convertMultimodalContent(content);
+                    }
+                    result.push({ role: "assistant", content });
+                }
+            }
+            else if (role === "tool") {
+                let content = pyGet(message, "content", "");
+                if (typeof content !== "string") {
+                    // DIVERGENCE: upstream uses Python's `str(content)` (a Python repr
+                    // for lists/dicts); we write JSON for objects instead.
+                    content =
+                        content === null
+                            ? "None"
+                            : typeof content === "boolean"
+                                ? content
+                                    ? "True"
+                                    : "False"
+                                : typeof content === "object"
+                                    ? pyJsonDumps(content)
+                                    : String(content);
+                }
+                result.push({
+                    type: "function_call_output",
+                    call_id: pyGet(message, "tool_call_id", ""),
+                    output: content,
+                });
+            }
+        }
+        return result;
+    }
+    /**
+     * Convert an OpenAI-Responses-specific message to an input item.
+     *
+     * Reasoning messages — persisted so the model's prior reasoning round-trips
+     * on later turns — become Responses `reasoning` input items. Anything
+     * else is assumed to already be in Responses input shape.
+     *
+     * @param message The LLM-specific message from the context.
+     * @returns A Responses API input item.
+     */
+    _fromSpecificMessage(message) {
+        const payload = message.message;
+        if (isDict(payload) && payload.type === "reasoning") {
+            const item = {
+                type: "reasoning",
+                id: payload.id ?? null,
+                summary: pyGet(payload, "summary", []),
+            };
+            const encrypted = payload.encrypted_content;
+            if (encrypted) {
+                item.encrypted_content = encrypted;
+            }
+            return item;
+        }
+        return payload;
+    }
+    /** The Responses API fetches image and file URLs itself. */
+    supportsFileUrl(url, _mimeType) {
+        return url.startsWith("http://") || url.startsWith("https://");
+    }
+    /**
+     * Convert multimodal content parts to Responses API format.
+     *
+     * @param content List of content parts from the LLMContext message.
+     * @returns List of content parts in Responses API format.
+     */
+    _convertMultimodalContent(content) {
+        const result = [];
+        for (const part of content) {
+            const partType = part.type;
+            if (partType === "text") {
+                result.push({ type: "input_text", text: pyGet(part, "text", "") });
+            }
+            else if (partType === "image_url") {
+                const imageUrlObj = pyGet(part, "image_url", {});
+                result.push({
+                    type: "input_image",
+                    image_url: pyGet(imageUrlObj, "url", ""),
+                    detail: pyGet(imageUrlObj, "detail", "auto"),
+                });
+            }
+            else if (partType === "file_base64") {
+                const fData = part.file;
+                if (fData.mime_type.startsWith("image/")) {
+                    result.push({
+                        type: "input_image",
+                        image_url: fData.file_data,
+                    });
+                }
+                else {
+                    result.push({
+                        type: "input_file",
+                        filename: fData.filename,
+                        file_data: fData.file_data,
+                    });
+                }
+            }
+            else if (partType === "file_url") {
+                const fData = part.file;
+                // inlinedFileContent throws a plain Error so adapters with a
+                // message-level wrapper don't double-wrap; this adapter has no such
+                // wrapper, so wrap here.
+                let resolved;
+                try {
+                    resolved = this.inlinedFileContent(fData);
+                }
+                catch (e) {
+                    rethrowIfCancelled(e);
+                    throw new LLMContextConversionError(e);
+                }
+                if (resolved === null) {
+                    if (fData.mime_type.startsWith("image/")) {
+                        result.push({
+                            type: "input_image",
+                            image_url: fData.url,
+                        });
+                    }
+                    else {
+                        result.push({
+                            type: "input_file",
+                            file_url: fData.url,
+                        });
+                    }
+                }
+                else {
+                    // Non-raw adapters always cache the data-URL form.
+                    const dataUrl = resolved;
+                    if (fData.mime_type.startsWith("image/")) {
+                        result.push({
+                            type: "input_image",
+                            image_url: dataUrl,
+                        });
+                    }
+                    else {
+                        result.push({
+                            type: "input_file",
+                            filename: pyGet(fData, "filename", ""),
+                            file_data: dataUrl,
+                        });
+                    }
+                }
+            }
+            else {
+                // Pass through other types as-is. Note: "input_audio" is not
+                // yet supported by the Responses API (coming soon per OpenAI
+                // docs) but the LLMContext format already matches the expected
+                // shape, so it should work once support is enabled.
+                result.push(part);
+            }
+        }
+        return result;
+    }
+}
+/**
+ * Python's `dict.get(key, default)`: the default only replaces a missing key
+ * (`undefined`); an explicit `null` (None) is kept.
+ */
+function pyGet(d, key, dflt) {
+    const v = d[key];
+    return v === undefined ? dflt : v;
+}
+function isDict(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+//# sourceMappingURL=open_ai_responses_adapter.js.map