@pipedog/core 0.0.0 → 0.1.0

package/dist/audio/vad/vad_controller.js

@@ -0,0 +1,228 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/audio/vad/vad_controller.py
+/**
+ * Voice Activity Detection controller for managing speech state transitions.
+ *
+ * Provides a controller that wraps a VADAnalyzer to track speech state and
+ * emit events when speech starts, stops, or is actively detected.
+ */
+import { monotonic, sleep, time } from "@pipedog/asyncio";
+import { InputAudioRawFrame, SpeechControlParamsFrame, VADParamsUpdateFrame, } from "../../frames/frames.js";
+import { FrameDirection } from "../../processors/frame_processor.js";
+import { BaseObject } from "../../utils/base_object.js";
+import { logger } from "../../utils/logger.js";
+import { VADState } from "./vad_analyzer.js";
+/**
+ * Manages voice activity detection state and emits speech events.
+ *
+ * Wraps a `VADAnalyzer` to process audio and trigger events based on speech
+ * state transitions. Tracks whether the user is speaking, quiet, or
+ * transitioning between states.
+ *
+ * Event handlers available:
+ *
+ * - on_speech_started: Called when speech begins.
+ * - on_speech_stopped: Called when speech ends, including forced stop when
+ *   the audio stream goes idle (no frames received while speaking).
+ * - on_speech_activity: Called periodically while speech is detected.
+ * - on_push_frame: Called when the controller wants to push a frame.
+ * - on_broadcast_frame: Called when the controller wants to broadcast a frame.
+ *
+ * @example
+ * vadController.eventHandler("on_speech_started", async (controller) => { ... });
+ * vadController.eventHandler("on_speech_stopped", async (controller) => { ... });
+ * vadController.eventHandler("on_speech_activity", async (controller) => { ... });
+ * vadController.eventHandler("on_push_frame", async (controller, frame, direction) => { ... });
+ * vadController.eventHandler("on_broadcast_frame", async (controller, frameCls, options) => { ... });
+ */
+export class VADController extends BaseObject {
+    _vadAnalyzer;
+    _vadState = VADState.QUIET;
+    // Last time a on_speech_activity was triggered.
+    _speechActivityTime = 0;
+    // How often a on_speech_activity event should be triggered (value should
+    // be greater than the audio chunks to have any effect).
+    _speechActivityPeriod;
+    // Audio idle detection: force speech stop when no audio arrives while in
+    // SPEAKING state (e.g. user mutes mic mid-speech).
+    _lastAudioTime = 0.0;
+    _audioIdleTimeout;
+    _audioIdleTask = null;
+    /**
+     * Initialize the VAD controller.
+     *
+     * @param vadAnalyzer The `VADAnalyzer` instance for processing audio.
+     * @param options Speech activity period and audio idle timeout.
+     */
+    constructor(vadAnalyzer, options = {}) {
+        super();
+        this._vadAnalyzer = vadAnalyzer;
+        this._taskManager = null;
+        this._speechActivityPeriod = options.speechActivityPeriod ?? 0.2;
+        this._audioIdleTimeout = options.audioIdleTimeout ?? 1.0;
+        this._registerEventHandler("on_speech_started", true);
+        this._registerEventHandler("on_speech_stopped", true);
+        this._registerEventHandler("on_speech_activity", true);
+        this._registerEventHandler("on_push_frame", true);
+        this._registerEventHandler("on_broadcast_frame", true);
+    }
+    /**
+     * Set up the controller.
+     *
+     * @param setup Configuration object containing setup parameters.
+     */
+    async setup(setup) {
+        await super.setup(setup.taskManager);
+        this._lastAudioTime = monotonic();
+        this._vadAnalyzer.setSampleRate(setup.audioInSampleRate);
+    }
+    /**
+     * Process a frame and handle VAD-related events.
+     *
+     * Handles `InputAudioRawFrame` to analyze audio for voice activity, and
+     * `VADParamsUpdateFrame` to reconfigure the analyzer.
+     *
+     * @param frame The frame to process.
+     */
+    async processFrame(frame) {
+        if (frame instanceof InputAudioRawFrame) {
+            await this._handleAudio(frame);
+        }
+        else if (frame instanceof VADParamsUpdateFrame) {
+            this._vadAnalyzer.setParams(frame.params);
+            await this.broadcastFrame(SpeechControlParamsFrame, { vadParams: frame.params });
+        }
+    }
+    /**
+     * Announce the analyzer's params and start the idle timer.
+     *
+     * Paired with `stop()`.
+     */
+    async start() {
+        // Broadcast initial VAD params so other services (e.g. STT) can use them
+        await this.broadcastFrame(SpeechControlParamsFrame, { vadParams: this._vadAnalyzer.params });
+        if (this._audioIdleTimeout > 0 && !this._audioIdleTask) {
+            this._audioIdleTask = this.createTask(() => this._audioIdleHandler(), "_audioIdleHandler");
+        }
+    }
+    /**
+     * Stop the idle timer, leaving the analyzer alone.
+     *
+     * Called at session end so the timer can't report silence that only means
+     * the session is over. The analyzer may be shared, so releasing it waits
+     * for `cleanup()`.
+     */
+    async stop() {
+        if (this._audioIdleTask && this._taskManager) {
+            await this._taskManager.cancelTask(this._audioIdleTask);
+            this._audioIdleTask = null;
+        }
+    }
+    /**
+     * Clean up resources.
+     *
+     * This method should be called when the object is no longer needed. It
+     * waits for all currently executing event handler tasks to finish before
+     * returning.
+     */
+    async cleanup() {
+        await super.cleanup();
+        await this.stop();
+        if (this._vadAnalyzer) {
+            await this._vadAnalyzer.cleanup();
+        }
+    }
+    /**
+     * Process an audio chunk and emit speech events as needed.
+     *
+     * Analyzes the audio for voice activity and triggers `on_speech_started`,
+     * `on_speech_stopped`, or `on_speech_activity` events based on state
+     * changes.
+     *
+     * @param frame Audio frame to process.
+     */
+    async _handleAudio(frame) {
+        this._lastAudioTime = monotonic();
+        this._vadState = await this._handleVad(frame.audio, this._vadState);
+        if (this._vadState === VADState.SPEAKING) {
+            await this._maybeSpeechActivity();
+        }
+    }
+    /** Handle Voice Activity Detection results and trigger appropriate events. */
+    async _handleVad(audio, vadState) {
+        const newVadState = await this._vadAnalyzer.analyzeAudio(audio);
+        if (newVadState !== vadState &&
+            newVadState !== VADState.STARTING &&
+            newVadState !== VADState.STOPPING) {
+            if (newVadState === VADState.SPEAKING) {
+                await this._callEventHandler("on_speech_started");
+            }
+            else if (newVadState === VADState.QUIET) {
+                await this._callEventHandler("on_speech_stopped");
+            }
+            vadState = newVadState;
+        }
+        return vadState;
+    }
+    /**
+     * Monitor for an idle audio stream while in SPEAKING state.
+     *
+     * When no audio frames arrive for `audioIdleTimeout` seconds (e.g. user
+     * mutes mic mid-speech), forces a transition to QUIET and emits
+     * `on_speech_stopped`.
+     */
+    async _audioIdleHandler() {
+        while (true) {
+            const deadline = this._lastAudioTime + this._audioIdleTimeout;
+            const remaining = deadline - monotonic();
+            if (remaining > 0) {
+                // Audio is still recent; sleep only for the remaining window.
+                await sleep(remaining);
+                continue;
+            }
+            if (this._vadState === VADState.SPEAKING) {
+                logger.warning(`${this}: no audio received while speaking, forcing speech stop`);
+                this._vadState = VADState.QUIET;
+                await this._callEventHandler("on_speech_stopped");
+            }
+            // Wait for the next potential idle window.
+            await sleep(this._audioIdleTimeout);
+        }
+    }
+    /** Handle user speaking frame. */
+    async _maybeSpeechActivity() {
+        const diffTime = time() - this._speechActivityTime;
+        if (diffTime >= this._speechActivityPeriod) {
+            this._speechActivityTime = time();
+            await this._callEventHandler("on_speech_activity");
+        }
+    }
+    /**
+     * Request a frame to be pushed through the pipeline.
+     *
+     * This emits an on_push_frame event that must be handled by a processor to
+     * actually push the frame into the pipeline.
+     *
+     * @param frame The frame to push.
+     * @param direction The direction to push the frame.
+     */
+    async pushFrame(frame, direction = FrameDirection.DOWNSTREAM) {
+        await this._callEventHandler("on_push_frame", frame, direction);
+    }
+    /**
+     * Request a frame to be broadcast upstream and downstream.
+     *
+     * This emits an on_broadcast_frame event that must be handled by a
+     * processor to actually broadcast the frame in the pipeline.
+     *
+     * @param frameCls The class of the frame to broadcast.
+     * @param options Arguments to pass to the frame constructor.
+     */
+    async broadcastFrame(frameCls, options) {
+        await this._callEventHandler("on_broadcast_frame", frameCls, options);
+    }
+}
+//# sourceMappingURL=vad_controller.js.map

package/dist/audio/volume.d.ts

@@ -0,0 +1,38 @@
+export declare const VOLUME_WINDOW_SECS = 0.4;
+/**
+ * Tracks the volume of an audio stream over a rolling window.
+ *
+ * Audio is fed in chunks of any size with `update()`, which retains the most
+ * recent `VOLUME_WINDOW_SECS` of it, and `volume` measures that window. Volume
+ * reads 0 until the window holds enough audio for loudness to be measurable,
+ * and the window is discarded if the sample rate changes.
+ *
+ * Measuring costs a few hundred microseconds and grows with the sample rate,
+ * so it happens on read and the result is cached until more audio arrives.
+ * Callers that report volume less often than they receive audio pay only for
+ * the reads.
+ *
+ * Audio is expected to be mono; interleaved channels would be measured as if
+ * they were consecutive samples.
+ */
+export declare class AudioVolumeTracker {
+    protected _sampleRate: number;
+    protected _windowNumBytes: number;
+    protected _buffer: Uint8Array;
+    protected _volume: number | null;
+    /**
+     * The volume of the audio in the rolling window, between 0 (quiet) and 1
+     * (loud). Reads 0 until the window holds a measurable amount of audio.
+     */
+    get volume(): number;
+    /**
+     * Add audio to the rolling window.
+     *
+     * @param audio Audio data as raw bytes (16-bit signed integers, mono).
+     * @param sampleRate Sample rate of the audio in Hz.
+     */
+    update(audio: Uint8Array, sampleRate: number): void;
+    /** Clear the rolling window and the tracked volume. */
+    reset(): void;
+}
+//# sourceMappingURL=volume.d.ts.map

package/dist/audio/volume.js

@@ -0,0 +1,75 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/audio/volume.py
+/** Audio volume tracking over a rolling window of recent audio. */
+import { calculateAudioVolume } from "./utils.js";
+// Loudness is measured over a BS.1770 gating block, which is 400ms. The audio
+// chunks flowing through a pipeline are shorter than that, so they accumulate
+// into a rolling window of this size.
+export const VOLUME_WINDOW_SECS = 0.4;
+/**
+ * Tracks the volume of an audio stream over a rolling window.
+ *
+ * Audio is fed in chunks of any size with `update()`, which retains the most
+ * recent `VOLUME_WINDOW_SECS` of it, and `volume` measures that window. Volume
+ * reads 0 until the window holds enough audio for loudness to be measurable,
+ * and the window is discarded if the sample rate changes.
+ *
+ * Measuring costs a few hundred microseconds and grows with the sample rate,
+ * so it happens on read and the result is cached until more audio arrives.
+ * Callers that report volume less often than they receive audio pay only for
+ * the reads.
+ *
+ * Audio is expected to be mono; interleaved channels would be measured as if
+ * they were consecutive samples.
+ */
+export class AudioVolumeTracker {
+    _sampleRate = 0;
+    _windowNumBytes = 0;
+    _buffer = new Uint8Array(0);
+    // null once the window holds audio that hasn't been measured yet.
+    _volume = 0.0;
+    /**
+     * The volume of the audio in the rolling window, between 0 (quiet) and 1
+     * (loud). Reads 0 until the window holds a measurable amount of audio.
+     */
+    get volume() {
+        if (this._volume === null) {
+            this._volume = calculateAudioVolume(this._buffer, this._sampleRate);
+        }
+        return this._volume;
+    }
+    /**
+     * Add audio to the rolling window.
+     *
+     * @param audio Audio data as raw bytes (16-bit signed integers, mono).
+     * @param sampleRate Sample rate of the audio in Hz.
+     */
+    update(audio, sampleRate) {
+        if (sampleRate !== this._sampleRate) {
+            this._sampleRate = sampleRate;
+            // Rounded up so the window is never a sample short of a gating block,
+            // which loudness rejects.
+            this._windowNumBytes = Math.ceil(VOLUME_WINDOW_SECS * sampleRate) * 2;
+            this.reset();
+        }
+        const combined = new Uint8Array(this._buffer.length + audio.length);
+        combined.set(this._buffer, 0);
+        combined.set(audio, this._buffer.length);
+        this._buffer =
+            combined.length > this._windowNumBytes
+                ? combined.slice(combined.length - this._windowNumBytes)
+                : combined;
+        if (this._buffer.length === this._windowNumBytes) {
+            this._volume = null;
+        }
+    }
+    /** Clear the rolling window and the tracked volume. */
+    reset() {
+        this._buffer = new Uint8Array(0);
+        this._volume = 0.0;
+    }
+}
+//# sourceMappingURL=volume.js.map

package/dist/bus/adapters/base.d.ts

@@ -0,0 +1,35 @@
+/** Abstract base class for type adapters used by message serializers. */
+import type { Ctor } from "../../utils/mixin.ts";
+export type SerializeFunc = (value: unknown) => unknown;
+export type DeserializeFunc = (value: unknown) => unknown;
+/**
+ * Serialize and deserialize instances of a specific type for network transport.
+ *
+ * Each adapter handles one or more types, converting them to/from a
+ * JSON-compatible dict. Register adapters on a `JSONMessageSerializer` to
+ * handle non-JSON-native field values (e.g. `LLMContext`, `ToolsSchema`).
+ *
+ * Adapters receive `serializeValue` and `deserializeValue` callbacks from the
+ * serializer so they can recursively serialize nested fields without
+ * importing the serializer itself.
+ */
+export declare abstract class TypeAdapter {
+    /**
+     * Convert an object to a JSON-compatible dict.
+     *
+     * @param obj The object to serialize.
+     * @param serializeValue Callback to recursively serialize nested values.
+     * @returns A dict representation of the object.
+     */
+    abstract serialize(obj: unknown, serializeValue: SerializeFunc): Record<string, unknown>;
+    /**
+     * Reconstruct an object from a dict.
+     *
+     * @param data The dict representation produced by `serialize()`.
+     * @param deserializeValue Callback to recursively deserialize nested values.
+     * @param targetType The resolved target class. Defaults to null.
+     * @returns The reconstructed object.
+     */
+    abstract deserialize(data: Record<string, unknown>, deserializeValue: DeserializeFunc, targetType?: Ctor | null): unknown;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/bus/adapters/base.js

@@ -0,0 +1,19 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/bus/adapters/base.py
+/**
+ * Serialize and deserialize instances of a specific type for network transport.
+ *
+ * Each adapter handles one or more types, converting them to/from a
+ * JSON-compatible dict. Register adapters on a `JSONMessageSerializer` to
+ * handle non-JSON-native field values (e.g. `LLMContext`, `ToolsSchema`).
+ *
+ * Adapters receive `serializeValue` and `deserializeValue` callbacks from the
+ * serializer so they can recursively serialize nested fields without
+ * importing the serializer itself.
+ */
+export class TypeAdapter {
+}
+//# sourceMappingURL=base.js.map

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

@@ -0,0 +1,10 @@
+/**
+ * Type adapters for bus message serialization.
+ *
+ * Provides ready-made `TypeAdapter` implementations for common Pipecat types
+ * (`LLMContext`, `ToolsSchema`) used in bus messages.
+ */
+export { TypeAdapter } from "./base.ts";
+export { LLMContextAdapter } from "./llm_context_adapter.ts";
+export { ToolsSchemaAdapter } from "./tools_schema_adapter.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/bus/adapters/index.js

@@ -0,0 +1,15 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/bus/adapters/__init__.py
+/**
+ * Type adapters for bus message serialization.
+ *
+ * Provides ready-made `TypeAdapter` implementations for common Pipecat types
+ * (`LLMContext`, `ToolsSchema`) used in bus messages.
+ */
+export { TypeAdapter } from "./base.js";
+export { LLMContextAdapter } from "./llm_context_adapter.js";
+export { ToolsSchemaAdapter } from "./tools_schema_adapter.js";
+//# sourceMappingURL=index.js.map

package/dist/bus/adapters/llm_context_adapter.d.ts

@@ -0,0 +1,36 @@
+import { type LLMContextMessage } from "../../processors/aggregators/llm_context.ts";
+import type { Ctor } from "../../utils/mixin.ts";
+import { type DeserializeFunc, type SerializeFunc, TypeAdapter } from "./base.ts";
+import { ToolsSchemaAdapter } from "./tools_schema_adapter.ts";
+/**
+ * Serialize and deserialize `LLMContext` instances.
+ *
+ * The `NOT_GIVEN` sentinel is preserved across serialization: missing keys
+ * are restored as `NOT_GIVEN` on deserialization.
+ */
+export declare class LLMContextAdapter extends TypeAdapter {
+    protected _toolsSchemaAdapter: ToolsSchemaAdapter;
+    /**
+     * Serialize an `LLMContext` to a JSON-compatible dict.
+     *
+     * @param obj An `LLMContext` instance.
+     * @param serializeValue Callback to recursively serialize nested values.
+     * @returns A dict with `messages` and, optionally, `tools` and
+     *   `tool_choice` keys.
+     */
+    serialize(obj: unknown, serializeValue: SerializeFunc): Record<string, unknown>;
+    /**
+     * Reconstruct an `LLMContext` from a serialized dict.
+     *
+     * Missing `tools` and `tool_choice` keys are restored as `NOT_GIVEN`.
+     *
+     * @param data A dict produced by `serialize()`.
+     * @param deserializeValue Callback to recursively deserialize nested values.
+     * @param _targetType Unused. `LLMContext` is always the target.
+     * @returns A new `LLMContext` instance.
+     */
+    deserialize(data: Record<string, unknown>, deserializeValue: DeserializeFunc, _targetType?: Ctor | null): unknown;
+    protected _serializeMessage(msg: unknown, serializeValue: SerializeFunc): unknown;
+    protected _deserializeMessage(data: unknown, deserializeValue: DeserializeFunc): LLMContextMessage;
+}
+//# sourceMappingURL=llm_context_adapter.d.ts.map

package/dist/bus/adapters/llm_context_adapter.js

@@ -0,0 +1,82 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/bus/adapters/llm_context_adapter.py
+import { LLMContext, LLMSpecificMessage, NOT_GIVEN, } from "../../processors/aggregators/llm_context.js";
+import { isGiven } from "../../utils/types.js";
+import { TypeAdapter } from "./base.js";
+import { ToolsSchemaAdapter } from "./tools_schema_adapter.js";
+function isDict(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Serialize and deserialize `LLMContext` instances.
+ *
+ * The `NOT_GIVEN` sentinel is preserved across serialization: missing keys
+ * are restored as `NOT_GIVEN` on deserialization.
+ */
+export class LLMContextAdapter extends TypeAdapter {
+    _toolsSchemaAdapter = new ToolsSchemaAdapter();
+    /**
+     * Serialize an `LLMContext` to a JSON-compatible dict.
+     *
+     * @param obj An `LLMContext` instance.
+     * @param serializeValue Callback to recursively serialize nested values.
+     * @returns A dict with `messages` and, optionally, `tools` and
+     *   `tool_choice` keys.
+     */
+    serialize(obj, serializeValue) {
+        const context = obj;
+        const result = {
+            messages: context.messages.map((m) => this._serializeMessage(m, serializeValue)),
+        };
+        if (isGiven(context.tools)) {
+            result.tools = this._toolsSchemaAdapter.serialize(context.tools, serializeValue);
+        }
+        if (isGiven(context.toolChoice)) {
+            result.tool_choice = serializeValue(context.toolChoice);
+        }
+        return result;
+    }
+    /**
+     * Reconstruct an `LLMContext` from a serialized dict.
+     *
+     * Missing `tools` and `tool_choice` keys are restored as `NOT_GIVEN`.
+     *
+     * @param data A dict produced by `serialize()`.
+     * @param deserializeValue Callback to recursively deserialize nested values.
+     * @param _targetType Unused. `LLMContext` is always the target.
+     * @returns A new `LLMContext` instance.
+     */
+    deserialize(data, deserializeValue, _targetType = null) {
+        const messages = data.messages.map((m) => this._deserializeMessage(m, deserializeValue));
+        const tools = "tools" in data
+            ? this._toolsSchemaAdapter.deserialize(data.tools, deserializeValue)
+            : NOT_GIVEN;
+        const toolChoice = "tool_choice" in data
+            ? deserializeValue(data.tool_choice)
+            : NOT_GIVEN;
+        return new LLMContext({ messages, tools, toolChoice });
+    }
+    _serializeMessage(msg, serializeValue) {
+        if (msg instanceof LLMSpecificMessage) {
+            return {
+                __specific__: true,
+                llm: msg.llm,
+                message: serializeValue(msg.message),
+            };
+        }
+        return serializeValue(msg);
+    }
+    _deserializeMessage(data, deserializeValue) {
+        if (isDict(data) && data.__specific__) {
+            return new LLMSpecificMessage({
+                llm: data.llm,
+                message: deserializeValue(data.message),
+            });
+        }
+        return deserializeValue(data);
+    }
+}
+//# sourceMappingURL=llm_context_adapter.js.map

package/dist/bus/adapters/tools_schema_adapter.d.ts

@@ -0,0 +1,25 @@
+import type { Ctor } from "../../utils/mixin.ts";
+import { type DeserializeFunc, type SerializeFunc, TypeAdapter } from "./base.ts";
+/** Serialize and deserialize `ToolsSchema` instances for network transport. */
+export declare class ToolsSchemaAdapter extends TypeAdapter {
+    /**
+     * Serialize a `ToolsSchema` to a JSON-compatible dict.
+     *
+     * @param obj A `ToolsSchema` instance.
+     * @param _serializeValue Callback to recursively serialize nested values.
+     * @returns A dict with a `standard_tools` list and, if present, a
+     *   `custom_tools` mapping.
+     */
+    serialize(obj: unknown, _serializeValue: SerializeFunc): Record<string, unknown>;
+    /**
+     * Reconstruct a `ToolsSchema` from a serialized dict.
+     *
+     * @param data A dict produced by `serialize()`.
+     * @param _deserializeValue Callback to recursively deserialize nested values.
+     * @param _targetType Unused. `ToolsSchema` is always the target.
+     * @returns A new `ToolsSchema` instance, including `customTools` if present
+     *   in `data`.
+     */
+    deserialize(data: Record<string, unknown>, _deserializeValue: DeserializeFunc, _targetType?: Ctor | null): unknown;
+}
+//# sourceMappingURL=tools_schema_adapter.d.ts.map

package/dist/bus/adapters/tools_schema_adapter.js

@@ -0,0 +1,70 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/bus/adapters/tools_schema_adapter.py
+/** Type adapter for ToolsSchema serialization. */
+import { FunctionSchema } from "../../adapters/schemas/function_schema.js";
+import { AdapterType, ToolsSchema } from "../../adapters/schemas/tools_schema.js";
+import { TypeAdapter } from "./base.js";
+const ADAPTER_TYPES = Object.values(AdapterType);
+/** Python's `AdapterType(value)`: the adapter type with this value, or a ValueError. */
+function toAdapterType(value) {
+    if (!ADAPTER_TYPES.includes(value)) {
+        throw new Error(`'${value}' is not a valid AdapterType`);
+    }
+    return value;
+}
+/** Serialize and deserialize `ToolsSchema` instances for network transport. */
+export class ToolsSchemaAdapter extends TypeAdapter {
+    /**
+     * Serialize a `ToolsSchema` to a JSON-compatible dict.
+     *
+     * @param obj A `ToolsSchema` instance.
+     * @param _serializeValue Callback to recursively serialize nested values.
+     * @returns A dict with a `standard_tools` list and, if present, a
+     *   `custom_tools` mapping.
+     */
+    serialize(obj, _serializeValue) {
+        const schema = obj;
+        const result = {
+            standard_tools: schema.standardTools.map((tool) => tool.toDefaultDict()),
+        };
+        const customTools = schema.customTools;
+        if (customTools && Object.keys(customTools).length > 0) {
+            // AdapterType values are the wire keys already.
+            result.custom_tools = { ...customTools };
+        }
+        return result;
+    }
+    /**
+     * Reconstruct a `ToolsSchema` from a serialized dict.
+     *
+     * @param data A dict produced by `serialize()`.
+     * @param _deserializeValue Callback to recursively deserialize nested values.
+     * @param _targetType Unused. `ToolsSchema` is always the target.
+     * @returns A new `ToolsSchema` instance, including `customTools` if present
+     *   in `data`.
+     */
+    deserialize(data, _deserializeValue, _targetType = null) {
+        const tools = [];
+        for (const item of data.standard_tools) {
+            const params = (item.parameters ?? {});
+            tools.push(new FunctionSchema({
+                name: item.name,
+                description: (item.description ?? ""),
+                properties: (params.properties ?? {}),
+                required: (params.required ?? []),
+            }));
+        }
+        let customTools = null;
+        if ("custom_tools" in data) {
+            customTools = {};
+            for (const [key, value] of Object.entries(data.custom_tools)) {
+                customTools[toAdapterType(key)] = value;
+            }
+        }
+        return new ToolsSchema({ standardTools: tools, customTools });
+    }
+}
+//# sourceMappingURL=tools_schema_adapter.js.map