@pipedog/core 0.0.0 → 0.2.0

package/dist/adapters/schemas/tools_schema.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Tools schema definitions for function calling adapters.
+ *
+ * Provides schemas for managing both standardized function tools and custom
+ * adapter-specific tools in the Pipecat framework.
+ */
+import { type DirectFunction, DirectFunctionWrapper } from "./direct_function.ts";
+import { FunctionSchema } from "./function_schema.ts";
+/**
+ * Supported adapter types for custom tools.
+ *
+ * - GEMINI: Google Gemini adapter.
+ * - OPENAI: OpenAI adapter (Chat Completions, Responses, and Realtime API).
+ */
+export declare const AdapterType: {
+    readonly GEMINI: "gemini";
+    readonly OPENAI: "openai";
+};
+export type AdapterType = (typeof AdapterType)[keyof typeof AdapterType];
+/** Custom tool definitions keyed by adapter type. */
+export type CustomTools = Partial<Record<AdapterType, Record<string, unknown>[]>>;
+export interface ToolsSchemaOptions {
+    /** List of tools following the standardized FunctionSchema format (or direct functions). */
+    standardTools: readonly (FunctionSchema | DirectFunction)[];
+    /**
+     * Object mapping adapter types to their custom tool definitions. These
+     * tools may not follow the FunctionSchema format (e.g., search_tool).
+     */
+    customTools?: CustomTools | null;
+}
+/**
+ * Schema for managing both standard and custom function calling tools.
+ *
+ * Provides a unified interface for handling standardized function schemas
+ * alongside custom tools that may not follow the standard format, such as
+ * adapter-specific search tools.
+ */
+export declare class ToolsSchema {
+    protected _standardTools: FunctionSchema[];
+    protected _directFunctions: DirectFunctionWrapper[];
+    protected _customTools: CustomTools | null;
+    constructor(options: ToolsSchemaOptions);
+    /** The list of tools following the FunctionSchema format. */
+    get standardTools(): FunctionSchema[];
+    /**
+     * The wrappers for standard tools that were given as direct functions.
+     *
+     * These retain a reference to the original function, allowing the LLM
+     * service to register their handlers automatically. Standard tools given as
+     * `FunctionSchema` objects (advertise-only) are not included.
+     */
+    get directFunctions(): DirectFunctionWrapper[];
+    /** Object mapping adapter types to their custom tool definitions. */
+    get customTools(): CustomTools | null;
+    set customTools(value: CustomTools | null);
+}
+//# sourceMappingURL=tools_schema.d.ts.map

package/dist/adapters/schemas/tools_schema.js

@@ -0,0 +1,79 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/adapters/schemas/tools_schema.py
+/**
+ * Tools schema definitions for function calling adapters.
+ *
+ * Provides schemas for managing both standardized function tools and custom
+ * adapter-specific tools in the Pipecat framework.
+ */
+import { DirectFunctionWrapper } from "./direct_function.js";
+import { FunctionSchema } from "./function_schema.js";
+/**
+ * Supported adapter types for custom tools.
+ *
+ * - GEMINI: Google Gemini adapter.
+ * - OPENAI: OpenAI adapter (Chat Completions, Responses, and Realtime API).
+ */
+export const AdapterType = {
+    GEMINI: "gemini",
+    OPENAI: "openai",
+};
+/**
+ * Schema for managing both standard and custom function calling tools.
+ *
+ * Provides a unified interface for handling standardized function schemas
+ * alongside custom tools that may not follow the standard format, such as
+ * adapter-specific search tools.
+ */
+export class ToolsSchema {
+    _standardTools;
+    _directFunctions;
+    _customTools;
+    constructor(options) {
+        const mapStandardTools = (tools) => {
+            const schemas = [];
+            const directFunctions = [];
+            for (const tool of tools) {
+                if (tool instanceof FunctionSchema) {
+                    schemas.push(tool);
+                }
+                else if (typeof tool === "function") {
+                    const wrapper = new DirectFunctionWrapper(tool);
+                    schemas.push(wrapper.toFunctionSchema());
+                    directFunctions.push(wrapper);
+                }
+                else {
+                    throw new TypeError(`Unsupported tool type: ${typeof tool}`);
+                }
+            }
+            return [schemas, directFunctions];
+        };
+        [this._standardTools, this._directFunctions] = mapStandardTools(options.standardTools);
+        this._customTools = options.customTools ?? null;
+    }
+    /** The list of tools following the FunctionSchema format. */
+    get standardTools() {
+        return this._standardTools;
+    }
+    /**
+     * The wrappers for standard tools that were given as direct functions.
+     *
+     * These retain a reference to the original function, allowing the LLM
+     * service to register their handlers automatically. Standard tools given as
+     * `FunctionSchema` objects (advertise-only) are not included.
+     */
+    get directFunctions() {
+        return this._directFunctions;
+    }
+    /** Object mapping adapter types to their custom tool definitions. */
+    get customTools() {
+        return this._customTools;
+    }
+    set customTools(value) {
+        this._customTools = value;
+    }
+}
+//# sourceMappingURL=tools_schema.js.map

package/dist/adapters/services/index.d.ts

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

package/dist/adapters/services/index.js

@@ -0,0 +1,8 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/adapters/services/__init__.py
+// Upstream's `__init__.py` is empty: import the package's modules directly.
+export {};
+//# sourceMappingURL=index.js.map

package/dist/adapters/services/open_ai_adapter.d.ts

@@ -0,0 +1,147 @@
+import type { LLMContext, LLMContextMessage, LLMContextToolChoice, LLMStandardMessage, NotGiven } from "../../processors/aggregators/llm_context.ts";
+import { BaseLLMAdapter } from "../base_llm_adapter.ts";
+import { type ToolsSchema } from "../schemas/tools_schema.ts";
+type Dict = Record<string, any>;
+/** An OpenAI Chat Completions message (`ChatCompletionMessageParam`). */
+export type ChatCompletionMessageParam = Dict;
+/** An OpenAI Chat Completions tool (`ChatCompletionToolParam`). */
+export type ChatCompletionToolParam = {
+    type: "function";
+    function: Dict;
+} | Dict;
+/** An OpenAI Chat Completions tool choice (`ChatCompletionToolChoiceOptionParam`). */
+export type ChatCompletionToolChoiceOptionParam = "none" | "auto" | "required" | {
+    type: "function";
+    function: {
+        name: string;
+    };
+} | Dict;
+/** The OpenAI SDK's "not given" value: an omitted (undefined) field. */
+export type OpenAINotGiven = undefined;
+/** The OpenAI SDK's "not given" sentinel. */
+export declare const OPENAI_NOT_GIVEN: OpenAINotGiven;
+/**
+ * Reinterpret an LLMContext `toolChoice` as OpenAI's type.
+ *
+ * The value types are aliased — `LLMContextToolChoice` is
+ * `ChatCompletionToolChoiceOptionParam` — so only the "not provided" sentinel
+ * needs translating: LLMContext has its own, and the SDK recognizes only its
+ * own.
+ *
+ * @param toolChoice A context's tool choice, or its "not provided" sentinel.
+ * @returns The tool choice unchanged, with LLMContext's sentinel replaced by
+ *   the SDK's.
+ */
+export declare function openaiFromLlmContextToolChoice(toolChoice: LLMContextToolChoice | NotGiven): ChatCompletionToolChoiceOptionParam | OpenAINotGiven;
+/**
+ * Reinterpret converted LLMContext tools as OpenAI's type.
+ *
+ * Same boundary as `openaiFromLlmContextToolChoice()`: the tool entries are
+ * already in OpenAI's format by this point, so only the absence of tools has
+ * to be respelled. The SDK's sentinel is the one that omits `tools` from the
+ * request body, so both of the ways absence arrives here — LLMContext's
+ * sentinel and `null` — map onto it.
+ *
+ * Generic over the tool entry type so that every OpenAI surface can share one
+ * translation: the Chat Completions and Responses APIs each have their own.
+ *
+ * @param tools Converted tools, or a value meaning no tools were provided.
+ * @returns The tools unchanged, or the SDK's sentinel if there are none.
+ */
+export declare function openaiFromLlmContextTools<T>(tools: T[] | NotGiven | null | undefined): T[] | OpenAINotGiven;
+/**
+ * Reinterpret an LLMContext standard message as OpenAI's type.
+ *
+ * Same rationale as `openaiFromLlmContextToolChoice()`: the aliased types
+ * make this a no-op today, but the boundary is preserved for future
+ * divergence.
+ *
+ * @param message A context's standard message.
+ * @returns The message unchanged, typed as OpenAI's.
+ */
+export declare function openaiFromLlmStandardMessage(message: LLMStandardMessage): ChatCompletionMessageParam;
+/**
+ * Check whether a value was explicitly provided to the OpenAI SDK.
+ *
+ * Asks about the SDK's sentinel, not Pipecat's — use `isGiven` from
+ * `utils/types` for values that are still Pipecat's.
+ *
+ * Also acts as a type guard: inside a true branch, the value is narrowed to
+ * exclude `OpenAINotGiven`.
+ *
+ * @example
+ * if (openaiIsGiven(toolChoice)) { ... }
+ *
+ * @param value The value to check.
+ * @returns True if `value` is anything other than the SDK's `NOT_GIVEN`.
+ */
+export declare function openaiIsGiven<T>(value: T | OpenAINotGiven): value is T;
+/** Context-based parameters for invoking OpenAI ChatCompletion API. */
+export interface OpenAILLMInvocationParams {
+    messages: ChatCompletionMessageParam[];
+    tools: ChatCompletionToolParam[] | OpenAINotGiven;
+    tool_choice: ChatCompletionToolChoiceOptionParam | OpenAINotGiven;
+}
+export interface OpenAILLMInvocationParamsOptions {
+    /**
+     * Optional system instruction from service settings or `runInference`. If
+     * provided, prepended as a system message.
+     */
+    systemInstruction?: string | null;
+    /**
+     * If true, convert "developer"-role messages to "user"-role messages. Used
+     * by OpenAI-compatible services that don't support the "developer" role.
+     */
+    convertDeveloperToUser: boolean;
+}
+/**
+ * OpenAI-specific adapter for Pipecat.
+ *
+ * Handles:
+ *
+ * - Extracting parameters for OpenAI's ChatCompletion API from a universal
+ *   LLM context
+ * - Converting Pipecat's standardized tools schema to OpenAI's
+ *   function-calling format.
+ * - Extracting and sanitizing messages from the LLM context for logging
+ *   about OpenAI.
+ */
+export declare class OpenAILLMAdapter extends BaseLLMAdapter<OpenAILLMInvocationParams> {
+    /** The identifier used in LLMSpecificMessage instances for OpenAI. */
+    get idForLlmSpecificMessages(): string;
+    /**
+     * Get OpenAI-specific LLM invocation parameters from a universal LLM context.
+     *
+     * @param context The LLM context containing messages, tools, etc.
+     * @returns Object of parameters for OpenAI's ChatCompletion API.
+     */
+    getLlmInvocationParams(context: LLMContext, options: OpenAILLMInvocationParamsOptions): Promise<OpenAILLMInvocationParams>;
+    /**
+     * Convert function schemas to OpenAI's function-calling format.
+     *
+     * @param toolsSchema The Pipecat tools schema to convert.
+     * @returns List of OpenAI formatted function call definitions ready for use
+     *   with ChatCompletion API.
+     */
+    toProviderToolsFormat(toolsSchema: ToolsSchema): ChatCompletionToolParam[];
+    /**
+     * Get messages from a universal LLM context in a format ready for logging
+     * about OpenAI.
+     *
+     * 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 about OpenAI.
+     */
+    getMessagesForLogging(context: LLMContext): Record<string, unknown>[];
+    /** OpenAI Chat Completions fetches image URLs itself; other files must be inlined. */
+    supportsFileUrl(url: string, mimeType: string): boolean;
+    protected _fromUniversalContextMessages(messages: LLMContextMessage[], options: {
+        convertDeveloperToUser: boolean;
+    }): ChatCompletionMessageParam[];
+    /** Build the ChatCompletion content item for an inline (base64) file. */
+    protected _inlineFileItem(fileDataUrl: string, filename: string, mimeType: string): Dict;
+    protected _fromStandardToolChoice(toolChoice: LLMContextToolChoice | NotGiven): ChatCompletionToolChoiceOptionParam | OpenAINotGiven;
+}
+export {};
+//# sourceMappingURL=open_ai_adapter.d.ts.map

package/dist/adapters/services/open_ai_adapter.js

@@ -0,0 +1,250 @@
+// 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_adapter.py
+/**
+ * OpenAI LLM adapter for Pipecat.
+ *
+ * Porting note: core does not depend on the `openai` SDK. The Chat
+ * Completions types are declared structurally here, and the SDK's
+ * `NOT_GIVEN` sentinel is `undefined` (how the JS SDK omits a field).
+ */
+import { rethrowIfCancelled } from "@pipedog/asyncio";
+import { LLMSpecificMessage } from "../../processors/aggregators/llm_context.js";
+import { isGiven } from "../../utils/types.js";
+import { BaseLLMAdapter, LLMContextConversionError } from "../base_llm_adapter.js";
+import { AdapterType } from "../schemas/tools_schema.js";
+/** The OpenAI SDK's "not given" sentinel. */
+export const OPENAI_NOT_GIVEN = undefined;
+/**
+ * Reinterpret an LLMContext `toolChoice` as OpenAI's type.
+ *
+ * The value types are aliased — `LLMContextToolChoice` is
+ * `ChatCompletionToolChoiceOptionParam` — so only the "not provided" sentinel
+ * needs translating: LLMContext has its own, and the SDK recognizes only its
+ * own.
+ *
+ * @param toolChoice A context's tool choice, or its "not provided" sentinel.
+ * @returns The tool choice unchanged, with LLMContext's sentinel replaced by
+ *   the SDK's.
+ */
+export function openaiFromLlmContextToolChoice(toolChoice) {
+    if (!isGiven(toolChoice)) {
+        return OPENAI_NOT_GIVEN;
+    }
+    return toolChoice;
+}
+/**
+ * Reinterpret converted LLMContext tools as OpenAI's type.
+ *
+ * Same boundary as `openaiFromLlmContextToolChoice()`: the tool entries are
+ * already in OpenAI's format by this point, so only the absence of tools has
+ * to be respelled. The SDK's sentinel is the one that omits `tools` from the
+ * request body, so both of the ways absence arrives here — LLMContext's
+ * sentinel and `null` — map onto it.
+ *
+ * Generic over the tool entry type so that every OpenAI surface can share one
+ * translation: the Chat Completions and Responses APIs each have their own.
+ *
+ * @param tools Converted tools, or a value meaning no tools were provided.
+ * @returns The tools unchanged, or the SDK's sentinel if there are none.
+ */
+export function openaiFromLlmContextTools(tools) {
+    if (tools == null || !isGiven(tools)) {
+        return OPENAI_NOT_GIVEN;
+    }
+    return tools;
+}
+/**
+ * Reinterpret an LLMContext standard message as OpenAI's type.
+ *
+ * Same rationale as `openaiFromLlmContextToolChoice()`: the aliased types
+ * make this a no-op today, but the boundary is preserved for future
+ * divergence.
+ *
+ * @param message A context's standard message.
+ * @returns The message unchanged, typed as OpenAI's.
+ */
+export function openaiFromLlmStandardMessage(message) {
+    return message;
+}
+/**
+ * Check whether a value was explicitly provided to the OpenAI SDK.
+ *
+ * Asks about the SDK's sentinel, not Pipecat's — use `isGiven` from
+ * `utils/types` for values that are still Pipecat's.
+ *
+ * Also acts as a type guard: inside a true branch, the value is narrowed to
+ * exclude `OpenAINotGiven`.
+ *
+ * @example
+ * if (openaiIsGiven(toolChoice)) { ... }
+ *
+ * @param value The value to check.
+ * @returns True if `value` is anything other than the SDK's `NOT_GIVEN`.
+ */
+export function openaiIsGiven(value) {
+    return value !== OPENAI_NOT_GIVEN;
+}
+/**
+ * OpenAI-specific adapter for Pipecat.
+ *
+ * Handles:
+ *
+ * - Extracting parameters for OpenAI's ChatCompletion API from a universal
+ *   LLM context
+ * - Converting Pipecat's standardized tools schema to OpenAI's
+ *   function-calling format.
+ * - Extracting and sanitizing messages from the LLM context for logging
+ *   about OpenAI.
+ */
+export class OpenAILLMAdapter extends BaseLLMAdapter {
+    /** The identifier used in LLMSpecificMessage instances for OpenAI. */
+    get idForLlmSpecificMessages() {
+        return "openai";
+    }
+    /**
+     * Get OpenAI-specific LLM invocation parameters from a universal LLM context.
+     *
+     * @param context The LLM context containing messages, tools, etc.
+     * @returns Object of parameters for OpenAI's ChatCompletion API.
+     */
+    async getLlmInvocationParams(context, options) {
+        const systemInstruction = options.systemInstruction ?? null;
+        await this.prepareFileContent(context);
+        let messages = this._fromUniversalContextMessages(this.getMessages(context), {
+            convertDeveloperToUser: options.convertDeveloperToUser,
+        });
+        // Detect initial system message for warning purposes (don't extract).
+        // The content is `string | parts[]`; we only forward it for warning
+        // purposes, so coerce non-strings to null — the resolver handles null.
+        let initialContent = null;
+        if (messages.length > 0 && messages[0].role === "system") {
+            this._warnContextSystemMessage();
+            const rawContent = messages[0].content ?? "";
+            if (typeof rawContent === "string") {
+                initialContent = rawContent;
+            }
+        }
+        if (systemInstruction) {
+            this._resolveSystemInstruction(initialContent, systemInstruction, {
+                discardContextSystem: false,
+            });
+            messages = [{ role: "system", content: systemInstruction }, ...messages];
+        }
+        return {
+            messages,
+            // NOTE: LLMContext's tools are guaranteed to be a ToolsSchema (or NOT_GIVEN)
+            tools: openaiFromLlmContextTools(this.fromStandardTools(context.tools)),
+            tool_choice: openaiFromLlmContextToolChoice(context.toolChoice),
+        };
+    }
+    /**
+     * Convert function schemas to OpenAI's function-calling format.
+     *
+     * @param toolsSchema The Pipecat tools schema to convert.
+     * @returns List of OpenAI formatted function call definitions ready for use
+     *   with ChatCompletion API.
+     */
+    toProviderToolsFormat(toolsSchema) {
+        const functionsSchema = toolsSchema.standardTools;
+        const formattedStandardTools = functionsSchema.map((func) => ({
+            type: "function",
+            function: func.toDefaultDict(),
+        }));
+        let customOpenaiTools = [];
+        if (toolsSchema.customTools) {
+            customOpenaiTools = (toolsSchema.customTools[AdapterType.OPENAI] ??
+                []);
+        }
+        return [...formattedStandardTools, ...customOpenaiTools];
+    }
+    /**
+     * Get messages from a universal LLM context in a format ready for logging
+     * about OpenAI.
+     *
+     * 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 about OpenAI.
+     */
+    getMessagesForLogging(context) {
+        return this.getMessages(context, { truncateLargeValues: true });
+    }
+    /** OpenAI Chat Completions fetches image URLs itself; other files must be inlined. */
+    supportsFileUrl(url, mimeType) {
+        return (mimeType.startsWith("image/") && (url.startsWith("http://") || url.startsWith("https://")));
+    }
+    _fromUniversalContextMessages(messages, options) {
+        let result = [];
+        for (const message of messages) {
+            if (message instanceof LLMSpecificMessage) {
+                result.push(message.message);
+            }
+            else {
+                const msg = { ...openaiFromLlmStandardMessage(message) };
+                const content = msg.content;
+                if (Array.isArray(content)) {
+                    const newContent = [];
+                    for (let item of content) {
+                        if (item.type === "file_base64") {
+                            const fData = item.file;
+                            item = this._inlineFileItem(fData.file_data, fData.filename, fData.mime_type);
+                        }
+                        else if (item.type === "file_url") {
+                            const fData = item.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);
+                                if (e instanceof LLMContextConversionError || !(e instanceof Error))
+                                    throw e;
+                                throw new LLMContextConversionError(e);
+                            }
+                            if (resolved === null) {
+                                // Pass-through: only image URLs, per supportsFileUrl.
+                                item = {
+                                    type: "image_url",
+                                    image_url: { url: fData.url },
+                                };
+                            }
+                            else {
+                                // Non-raw adapters always cache the data-URL form.
+                                item = this._inlineFileItem(resolved, fData.filename ?? "", fData.mime_type);
+                            }
+                        }
+                        newContent.push(item);
+                    }
+                    msg.content = newContent;
+                }
+                result.push(msg);
+            }
+        }
+        if (options.convertDeveloperToUser) {
+            // Copy rather than mutate: the message objects are shared with the
+            // source LLMContext.
+            result = result.map((msg) => (msg.role === "developer" ? { ...msg, role: "user" } : msg));
+        }
+        return result;
+    }
+    /** Build the ChatCompletion content item for an inline (base64) file. */
+    _inlineFileItem(fileDataUrl, filename, mimeType) {
+        if (mimeType.startsWith("image/")) {
+            return { type: "image_url", image_url: { url: fileDataUrl } };
+        }
+        if (mimeType === "application/pdf") {
+            return { type: "file", file: { filename, file_data: fileDataUrl } };
+        }
+        throw new LLMContextConversionError(new Error(`Unsupported 'file' MIME type for OpenAI: ${mimeType}`));
+    }
+    _fromStandardToolChoice(toolChoice) {
+        return openaiFromLlmContextToolChoice(toolChoice);
+    }
+}
+//# sourceMappingURL=open_ai_adapter.js.map

package/dist/audio/dtmf/dtmf_data.d.ts

@@ -0,0 +1,3 @@
+/** The bundled DTMF WAV files, base64-encoded, keyed by file name. @internal */
+export declare const DTMF_WAV_FILES: Record<string, string>;
+//# sourceMappingURL=dtmf_data.d.ts.map