@pipedog/core 0.0.0 → 0.1.0

package/dist/processors/aggregators/async_tool_messages.js

@@ -0,0 +1,291 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/processors/aggregators/async_tool_messages.py
+// --- Payload shape (private; canonical source of truth) ---------------------
+// The `type` field that identifies an async-tool message payload. Both the
+// builders and the parser use this constant; do not duplicate the literal.
+const _PAYLOAD_TYPE = "async_tool";
+// Status value for started / intermediate messages (task still running).
+const _STATUS_RUNNING = "running";
+// Status value for the final message (task complete).
+const _STATUS_FINISHED = "finished";
+// Description shipped on the started message. It says only what the model has
+// to act on (wait, and don't answer from nothing) and deliberately does not
+// describe the message the result will arrive in. A model told the shape of a
+// message it should expect will try to produce one, and a function call is the
+// only structured channel it has, so it calls the tool again with the protocol
+// payload as the arguments. The payload's own fields are read by parseMessage,
+// never by the model, so describing them buys nothing either.
+const _STARTED_DESCRIPTION = "This tool is still running. You will be given its result later. Do not call it " +
+    "again and do not invent a result in the meantime.";
+// Description shipped on each intermediate-result message. Names no message
+// shape either, for the same reason as the started message above.
+const _INTERMEDIATE_DESCRIPTION = "This is a partial result and the task is still running. More may follow. Do not " +
+    "call this tool again and do not treat this as the final answer.";
+// Result shipped on the message that settles a cancelled task. It names the
+// tool call as the thing that was cancelled: a bare "CANCELLED" reads as a
+// statement about whatever the tool looks up, and a model relaying it will
+// tell the user their flight, order, or booking was cancelled.
+const _CANCELLED_RESULT = "CANCELLED: this tool call was cancelled before it returned a result";
+// Description shipped on the message that settles a cancelled task.
+const _CANCELLED_DESCRIPTION = "The asynchronous task associated with this tool_call_id was cancelled " +
+    "before it produced a result, either because it ran past its deadline or " +
+    "because cancellation was requested. No further results will arrive for " +
+    "this tool_call_id. If the user is still waiting on it, tell them it did " +
+    "not complete rather than leaving it unanswered.";
+/**
+ * Standing guidance composed into the system instruction whenever an async
+ * tool is registered. The per-result message says the same thing, but it
+ * arrives buried in a context whose most recent turn may be the user asking
+ * for something else; a model weighing the two follows the nearer, louder
+ * request. This states the policy before any result exists, so it is in force
+ * when one arrives.
+ */
+export const ASYNC_TOOL_INSTRUCTIONS = "ASYNC TOOLS:\n" +
+    "Some of your tools keep running after you have replied. Their results arrive later as " +
+    "messages in the conversation, on whatever turn happens to be in progress by then.\n" +
+    "\n" +
+    "A result that has arrived is owed to the user, whatever the conversation has moved on to. " +
+    "If the user has said something you have not answered yet, answer that first, then add the " +
+    "result at the end of that same reply — never before your answer. If you have already " +
+    "answered everything the user said, deliver just the result — do not repeat or rephrase " +
+    "your earlier reply. State a short result outright; for a long one, say what came back and " +
+    "offer the details. Say it once, and do not repeat it in later replies.";
+// Description shipped on the final-result message.
+const _FINAL_DESCRIPTION = "This is the final result for the asynchronous task associated with this " +
+    "tool_call_id. The task has completed. No further results will arrive for " +
+    "this tool_call_id. You must convey this result to the user, even if the " +
+    "conversation has moved on. Never leave it unsaid. If the user has said " +
+    "something you have not answered yet, first finish responding to that, " +
+    "then deliver the result at the end of your response; if you have already " +
+    "answered, deliver just the result and do not repeat your earlier reply. " +
+    "How you deliver it depends on its size: if the result is short, simply " +
+    "state it; if it is long or complex, name what has come back and offer " +
+    "the details. Convey it once; do not repeat it in later responses.";
+/**
+ * The structured contents of an async-tool message in an LLM context.
+ *
+ * - `kind`: which of the three async-tool message stages this is.
+ * - `toolCallId`: the id of the tool invocation this payload relates to.
+ * - `status`: `"running"` for started/intermediate, `"finished"` for the
+ *   final message.
+ * - `description`: human-readable description from the payload. May be empty.
+ * - `result`: for `intermediate` and `final` messages, the JSON-encoded result
+ *   string (or the literal `"COMPLETED"` if the function returned no value).
+ *   `null` for `started` messages.
+ */
+export class AsyncToolMessagePayload {
+    kind;
+    toolCallId;
+    status;
+    description;
+    result;
+    constructor(options) {
+        this.kind = options.kind;
+        this.toolCallId = options.toolCallId;
+        this.status = options.status;
+        this.description = options.description;
+        this.result = options.result;
+        Object.freeze(this);
+    }
+}
+// --- Internal: payload <-> on-the-wire forms ---------------------------------
+/**
+ * Serialize a payload to its on-the-wire JSON string form.
+ *
+ * Fields that don't apply to the payload's kind are omitted (notably `result`
+ * is left out of `started` payloads, since the task hasn't produced a result
+ * yet).
+ *
+ * The string matches Python's `json.dumps(obj, ensure_ascii=False)` byte for
+ * byte (`", "` and `": "` separators), so contexts are identical across ports.
+ */
+function _payloadToJson(payload) {
+    const obj = {
+        type: _PAYLOAD_TYPE,
+        status: payload.status,
+        tool_call_id: payload.toolCallId,
+        description: payload.description,
+    };
+    if (payload.result !== null) {
+        obj.result = payload.result;
+    }
+    const entries = Object.entries(obj).map(([k, v]) => `${JSON.stringify(k)}: ${JSON.stringify(v)}`);
+    return `{${entries.join(", ")}}`;
+}
+/**
+ * Wrap a payload in the LLM context message shape that matches its kind.
+ *
+ * - `started`: `role="tool"` plus `tool_call_id` at the top level (so the
+ *   message can sit alongside other regular tool-result messages).
+ * - `intermediate` / `final`: `role="developer"`; `tool_call_id` lives only
+ *   inside the JSON payload.
+ */
+function _payloadToMessage(payload) {
+    const content = _payloadToJson(payload);
+    if (payload.kind === "started") {
+        return {
+            role: "tool",
+            content,
+            tool_call_id: payload.toolCallId,
+        };
+    }
+    return {
+        role: "developer",
+        content,
+    };
+}
+// --- Builders ----------------------------------------------------------------
+/**
+ * Build a `started` async-tool message for an LLM context.
+ *
+ * Append the returned message to the LLM context immediately when an async
+ * function call (registered with `cancelOnInterruption: false`) starts
+ * running. The message lets the model know a task is in flight and that its
+ * results will arrive later in subsequent `developer`-role messages.
+ *
+ * @param toolCallId The id of the tool invocation this message is for.
+ * @returns A message ready to pass to `LLMContext.addMessage`.
+ */
+export function buildStartedMessage(toolCallId) {
+    return _payloadToMessage(new AsyncToolMessagePayload({
+        kind: "started",
+        toolCallId,
+        status: _STATUS_RUNNING,
+        description: _STARTED_DESCRIPTION,
+        result: null,
+    }));
+}
+/**
+ * Build an intermediate-result async-tool message for an LLM context.
+ *
+ * Append the returned message to the LLM context each time the running async
+ * function reports a non-final result via
+ * `resultCallback(..., new FunctionCallResultProperties({ isFinal: false }))`.
+ *
+ * @param toolCallId The id of the tool invocation the result is for.
+ * @param result The JSON-encoded result string (caller is responsible for
+ *   encoding the function's actual return value, typically via
+ *   `JSON.stringify`).
+ * @returns A message ready to pass to `LLMContext.addMessage`.
+ */
+export function buildIntermediateResultMessage(toolCallId, result) {
+    return _payloadToMessage(new AsyncToolMessagePayload({
+        kind: "intermediate",
+        toolCallId,
+        status: _STATUS_RUNNING,
+        description: _INTERMEDIATE_DESCRIPTION,
+        result,
+    }));
+}
+/**
+ * Build a final-result async-tool message for an LLM context.
+ *
+ * Append the returned message to the LLM context when the async function
+ * finishes. After this message no further async-tool messages will arrive for
+ * this `tool_call_id`.
+ *
+ * @param toolCallId The id of the tool invocation the result is for.
+ * @param result The JSON-encoded result string, or the literal `"COMPLETED"`
+ *   sentinel when the function returned nothing (matching the same convention
+ *   used for synchronous tool calls).
+ * @returns A message ready to pass to `LLMContext.addMessage`.
+ */
+export function buildFinalResultMessage(toolCallId, result) {
+    return _payloadToMessage(new AsyncToolMessagePayload({
+        kind: "final",
+        toolCallId,
+        status: _STATUS_FINISHED,
+        description: _FINAL_DESCRIPTION,
+        result,
+    }));
+}
+/**
+ * Build a message settling a cancelled async-tool call in an LLM context.
+ *
+ * Append the returned message to the LLM context when an async function call
+ * is cancelled (by a timeout or at the model's request) instead of running to
+ * completion. It settles the `tool_call_id` the same way a final result does,
+ * carrying a cancellation notice in place of a result.
+ *
+ * @param toolCallId The id of the tool invocation that was cancelled.
+ * @returns A message ready to pass to `LLMContext.addMessage`.
+ */
+export function buildCancelledMessage(toolCallId) {
+    return _payloadToMessage(new AsyncToolMessagePayload({
+        kind: "final",
+        toolCallId,
+        status: _STATUS_FINISHED,
+        description: _CANCELLED_DESCRIPTION,
+        result: _CANCELLED_RESULT,
+    }));
+}
+// --- Parsing -----------------------------------------------------------------
+/**
+ * Decode an async-tool message payload, or return null if not async-tool.
+ *
+ * @param message A standard message from the LLM context. Callers iterating
+ *   over `LLMContext.getMessages()` should filter out `LLMSpecificMessage`
+ *   entries first; only `LLMStandardMessage` values can carry async-tool
+ *   payloads.
+ * @returns An `AsyncToolMessagePayload` if the message is a recognized
+ *   async-tool payload, otherwise `null`.
+ */
+export function parseMessage(message) {
+    const role = message.role;
+    if (role !== "tool" && role !== "developer") {
+        return null;
+    }
+    const content = message.content;
+    if (typeof content !== "string") {
+        return null;
+    }
+    let payload;
+    try {
+        payload = JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+    if (typeof payload !== "object" ||
+        payload === null ||
+        Array.isArray(payload) ||
+        payload.type !== _PAYLOAD_TYPE) {
+        return null;
+    }
+    const obj = payload;
+    const toolCallId = obj.tool_call_id;
+    const status = obj.status;
+    if (typeof toolCallId !== "string" ||
+        (status !== _STATUS_RUNNING && status !== _STATUS_FINISHED)) {
+        return null;
+    }
+    let description = "description" in obj ? obj.description : "";
+    if (typeof description !== "string") {
+        description = "";
+    }
+    let result = obj.result ?? null;
+    if (result !== null && typeof result !== "string") {
+        result = null;
+    }
+    let kind;
+    if (result === null) {
+        kind = "started";
+    }
+    else if (status === _STATUS_FINISHED) {
+        kind = "final";
+    }
+    else {
+        kind = "intermediate";
+    }
+    return new AsyncToolMessagePayload({
+        kind,
+        toolCallId,
+        status,
+        description: description,
+        result: result,
+    });
+}
+//# sourceMappingURL=async_tool_messages.js.map

package/dist/processors/aggregators/dtmf_aggregator.d.ts

@@ -0,0 +1,61 @@
+/**
+ * DTMF aggregation processor for converting keypad input to transcription.
+ *
+ * This module provides a frame processor that aggregates DTMF (Dual-Tone
+ * Multi-Frequency) keypad inputs into meaningful sequences and converts them to
+ * transcription frames for downstream processing by LLM context aggregators.
+ */
+import { Event, type Task } from "@pipedog/asyncio";
+import { KeypadEntry } from "../../audio/dtmf/types.ts";
+import { type Frame, InputDTMFFrame } from "../../frames/frames.ts";
+import { type FrameDirection, FrameProcessor, type FrameProcessorOptions } from "../frame_processor.ts";
+export interface DTMFAggregatorOptions extends FrameProcessorOptions {
+    /** Idle timeout in seconds before flushing. Defaults to 2.0. */
+    timeout?: number;
+    /** Digit that triggers immediate flush. Defaults to `KeypadEntry.POUND`. */
+    terminationDigit?: KeypadEntry;
+    /** Prefix added to DTMF sequence in transcription. Defaults to "DTMF: ". */
+    prefix?: string;
+}
+/**
+ * Aggregates DTMF frames into meaningful sequences for LLM processing.
+ *
+ * The aggregator accumulates digits from InputDTMFFrame instances and flushes
+ * when:
+ *
+ * - Timeout occurs (configurable idle period)
+ * - Termination digit is received (default: '#')
+ * - EndFrame or CancelFrame is received
+ *
+ * Emits TranscriptionFrame for compatibility with existing LLM context aggregators.
+ */
+export declare class DTMFAggregator extends FrameProcessor {
+    protected _aggregation: string;
+    protected _idleTimeout: number;
+    protected _terminationDigit: KeypadEntry;
+    protected _prefix: string;
+    protected _digitEvent: Event;
+    protected _aggregationTask: Task<unknown> | null;
+    /** Initialize the DTMF aggregator. */
+    constructor(options?: DTMFAggregatorOptions);
+    /** Clean up resources. */
+    cleanup(): Promise<void>;
+    /**
+     * Process incoming frames and handle DTMF aggregation.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+    /** Handle DTMF input frame. */
+    protected _handleDtmfFrame(frame: InputDTMFFrame): Promise<void>;
+    /** Creates the aggregation task if it hasn't been created yet. */
+    protected _createAggregationTask(): void;
+    /** Stops the aggregation task. */
+    protected _stopAggregationTask(): Promise<void>;
+    /** Background task that handles timeout-based flushing. */
+    protected _aggregationTaskHandler(): Promise<void>;
+    /** Flush the current aggregation as a TranscriptionFrame. */
+    protected _flushAggregation(): Promise<void>;
+}
+//# sourceMappingURL=dtmf_aggregator.d.ts.map

package/dist/processors/aggregators/dtmf_aggregator.js

@@ -0,0 +1,144 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/processors/aggregators/dtmf_aggregator.py
+/**
+ * DTMF aggregation processor for converting keypad input to transcription.
+ *
+ * This module provides a frame processor that aggregates DTMF (Dual-Tone
+ * Multi-Frequency) keypad inputs into meaningful sequences and converts them to
+ * transcription frames for downstream processing by LLM context aggregators.
+ */
+import { Event, TimeoutError, waitFor } from "@pipedog/asyncio";
+import { KeypadEntry } from "../../audio/dtmf/types.js";
+import { CancelFrame, EndFrame, InputDTMFFrame, StartFrame, TranscriptionFrame, } from "../../frames/frames.js";
+import { timeNowIso8601 } from "../../utils/time.js";
+import { FrameProcessor, } from "../frame_processor.js";
+/**
+ * Aggregates DTMF frames into meaningful sequences for LLM processing.
+ *
+ * The aggregator accumulates digits from InputDTMFFrame instances and flushes
+ * when:
+ *
+ * - Timeout occurs (configurable idle period)
+ * - Termination digit is received (default: '#')
+ * - EndFrame or CancelFrame is received
+ *
+ * Emits TranscriptionFrame for compatibility with existing LLM context aggregators.
+ */
+export class DTMFAggregator extends FrameProcessor {
+    _aggregation = "";
+    _idleTimeout;
+    _terminationDigit;
+    _prefix;
+    _digitEvent = new Event();
+    _aggregationTask = null;
+    /** Initialize the DTMF aggregator. */
+    constructor(options = {}) {
+        super(options);
+        this._idleTimeout = options.timeout ?? 2.0;
+        this._terminationDigit = options.terminationDigit ?? KeypadEntry.POUND;
+        this._prefix = options.prefix ?? "DTMF: ";
+    }
+    /** Clean up resources. */
+    async cleanup() {
+        await super.cleanup();
+        await this._stopAggregationTask();
+    }
+    /**
+     * Process incoming frames and handle DTMF aggregation.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    async processFrame(frame, direction) {
+        await super.processFrame(frame, direction);
+        if (frame instanceof StartFrame) {
+            await this.pushFrame(frame, direction);
+            this._createAggregationTask();
+        }
+        else if (frame instanceof EndFrame || frame instanceof CancelFrame) {
+            if (this._aggregation) {
+                await this._flushAggregation();
+            }
+            await this._stopAggregationTask();
+            await this.pushFrame(frame, direction);
+        }
+        else if (frame instanceof InputDTMFFrame) {
+            // Push the DTMF frame downstream first
+            await this.pushFrame(frame, direction);
+            // Then handle it in order for the TranscriptionFrame to be emitted
+            // after the InputDTMFFrame
+            await this._handleDtmfFrame(frame);
+        }
+        else {
+            await this.pushFrame(frame, direction);
+        }
+    }
+    /** Handle DTMF input frame. */
+    async _handleDtmfFrame(frame) {
+        const isFirstDigit = !this._aggregation;
+        const digitValue = frame.button;
+        this._aggregation += digitValue;
+        // For first digit, schedule interruption.
+        if (isFirstDigit) {
+            await this.broadcastInterruption();
+        }
+        // Check for immediate flush conditions
+        if (frame.button === this._terminationDigit) {
+            await this._flushAggregation();
+        }
+        else {
+            // Signal digit received for timeout handling
+            this._digitEvent.set();
+        }
+    }
+    /** Creates the aggregation task if it hasn't been created yet. */
+    _createAggregationTask() {
+        if (!this._aggregationTask) {
+            this._aggregationTask = this.createTask(() => this._aggregationTaskHandler());
+        }
+    }
+    /** Stops the aggregation task. */
+    async _stopAggregationTask() {
+        if (this._aggregationTask) {
+            await this.cancelTask(this._aggregationTask);
+            this._aggregationTask = null;
+        }
+    }
+    /** Background task that handles timeout-based flushing. */
+    async _aggregationTaskHandler() {
+        for (;;) {
+            try {
+                await waitFor(() => this._digitEvent.wait(), this._idleTimeout);
+                this._digitEvent.clear();
+            }
+            catch (e) {
+                if (!(e instanceof TimeoutError))
+                    throw e;
+                if (this._aggregation) {
+                    await this._flushAggregation();
+                }
+            }
+        }
+    }
+    /** Flush the current aggregation as a TranscriptionFrame. */
+    async _flushAggregation() {
+        if (!this._aggregation) {
+            return;
+        }
+        const sequence = this._aggregation;
+        const transcriptionText = `${this._prefix}${sequence}`;
+        // A DTMF flush is always a complete entry, so mark it finalized.
+        const transcriptionFrame = new TranscriptionFrame({
+            text: transcriptionText,
+            userId: "",
+            timestamp: timeNowIso8601(),
+            finalized: true,
+        });
+        await this.pushFrame(transcriptionFrame);
+        this._aggregation = "";
+    }
+}
+//# sourceMappingURL=dtmf_aggregator.js.map

package/dist/processors/aggregators/gated.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Gated frame aggregator for conditional frame accumulation.
+ *
+ * This module provides a gated aggregator that accumulates frames based on
+ * custom gate open/close functions, allowing for conditional frame buffering
+ * and release in frame processing pipelines.
+ */
+import { type Frame } from "../../frames/frames.ts";
+import { FrameDirection, FrameProcessor } from "../frame_processor.ts";
+/** Predicate deciding whether a frame opens or closes the gate. */
+export type GateFn = (frame: Frame) => boolean;
+/**
+ * Accumulate frames, with custom functions to start and stop accumulation.
+ *
+ * Yields gate-opening frame before any accumulated frames, then ensuing frames
+ * until and not including the gate-closed frame. The aggregator maintains an
+ * internal gate state that controls whether frames are passed through
+ * immediately or accumulated for later release.
+ */
+export declare class GatedAggregator extends FrameProcessor {
+    protected _gateOpenFn: GateFn;
+    protected _gateCloseFn: GateFn;
+    protected _gateOpen: boolean;
+    protected _direction: FrameDirection;
+    protected _accumulator: [Frame, FrameDirection][];
+    /**
+     * Initialize the gated aggregator.
+     *
+     * @param gateOpenFn Function that returns true when a frame should open the gate.
+     * @param gateCloseFn Function that returns true when a frame should close the gate.
+     * @param startOpen Whether the gate should start in the open state.
+     * @param direction The frame direction this aggregator operates on.
+     */
+    constructor(gateOpenFn: GateFn, gateCloseFn: GateFn, startOpen: boolean, direction?: FrameDirection);
+    /**
+     * Process incoming frames with gated accumulation logic.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of the frame flow.
+     */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+}
+//# sourceMappingURL=gated.d.ts.map

package/dist/processors/aggregators/gated.js

@@ -0,0 +1,86 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/processors/aggregators/gated.py
+/**
+ * Gated frame aggregator for conditional frame accumulation.
+ *
+ * This module provides a gated aggregator that accumulates frames based on
+ * custom gate open/close functions, allowing for conditional frame buffering
+ * and release in frame processing pipelines.
+ */
+import { SystemFrame } from "../../frames/frames.js";
+import { logger } from "../../utils/logger.js";
+import { FrameDirection, FrameProcessor } from "../frame_processor.js";
+/**
+ * Accumulate frames, with custom functions to start and stop accumulation.
+ *
+ * Yields gate-opening frame before any accumulated frames, then ensuing frames
+ * until and not including the gate-closed frame. The aggregator maintains an
+ * internal gate state that controls whether frames are passed through
+ * immediately or accumulated for later release.
+ */
+export class GatedAggregator extends FrameProcessor {
+    _gateOpenFn;
+    _gateCloseFn;
+    _gateOpen;
+    _direction;
+    _accumulator = [];
+    /**
+     * Initialize the gated aggregator.
+     *
+     * @param gateOpenFn Function that returns true when a frame should open the gate.
+     * @param gateCloseFn Function that returns true when a frame should close the gate.
+     * @param startOpen Whether the gate should start in the open state.
+     * @param direction The frame direction this aggregator operates on.
+     */
+    constructor(gateOpenFn, gateCloseFn, startOpen, direction = FrameDirection.DOWNSTREAM) {
+        super();
+        this._gateOpenFn = gateOpenFn;
+        this._gateCloseFn = gateCloseFn;
+        this._gateOpen = startOpen;
+        this._direction = direction;
+    }
+    /**
+     * Process incoming frames with gated accumulation logic.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of the frame flow.
+     */
+    async processFrame(frame, direction) {
+        await super.processFrame(frame, direction);
+        // We must not block system frames.
+        if (frame instanceof SystemFrame) {
+            await this.pushFrame(frame, direction);
+            return;
+        }
+        // Ignore frames that are not following the direction of this gate.
+        if (direction !== this._direction) {
+            await this.pushFrame(frame, direction);
+            return;
+        }
+        const oldState = this._gateOpen;
+        if (this._gateOpen) {
+            this._gateOpen = !this._gateCloseFn(frame);
+        }
+        else {
+            this._gateOpen = this._gateOpenFn(frame);
+        }
+        if (oldState !== this._gateOpen) {
+            const state = this._gateOpen ? "open" : "closed";
+            logger.debug(`Gate is now ${state} because of ${frame}`);
+        }
+        if (this._gateOpen) {
+            await this.pushFrame(frame, direction);
+            for (const [f, d] of this._accumulator) {
+                await this.pushFrame(f, d);
+            }
+            this._accumulator = [];
+        }
+        else {
+            this._accumulator.push([frame, direction]);
+        }
+    }
+}
+//# sourceMappingURL=gated.js.map

package/dist/processors/aggregators/gated_llm_context.d.ts

@@ -0,0 +1,42 @@
+/** Gated LLM context aggregator for controlled message flow. */
+import type { Task } from "@pipedog/asyncio";
+import { type Frame, LLMContextFrame } from "../../frames/frames.ts";
+import type { BaseNotifier } from "../../utils/sync/base_notifier.ts";
+import { type FrameDirection, FrameProcessor, type FrameProcessorOptions } from "../frame_processor.ts";
+export interface GatedLLMContextAggregatorOptions extends FrameProcessorOptions {
+    /** The notifier that controls when frames are released. */
+    notifier: BaseNotifier;
+    /** If true, the first context frame passes through immediately. */
+    startOpen?: boolean;
+}
+/**
+ * Aggregator that gates LLM context frames until notified.
+ *
+ * This aggregator captures LLM context frames and holds them until a notifier
+ * signals that they can be released. This is useful for controlling the flow
+ * of context frames based on external conditions or timing.
+ */
+export declare class GatedLLMContextAggregator extends FrameProcessor {
+    protected _notifier: BaseNotifier;
+    protected _startOpen: boolean;
+    protected _lastContextFrame: LLMContextFrame | null;
+    protected _gateTask: Task<unknown> | null;
+    /** Initialize the gated context aggregator. */
+    constructor(options: GatedLLMContextAggregatorOptions);
+    /**
+     * Process incoming frames, gating LLM context frames.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+    /** Release resources held by the aggregator. */
+    cleanup(): Promise<void>;
+    /** Start the gate task handler. */
+    protected _start(): Promise<void>;
+    /** Stop the gate task handler. */
+    protected _stop(): Promise<void>;
+    /** Handle the gating logic by waiting for notifications and releasing frames. */
+    protected _gateTaskHandler(): Promise<void>;
+}
+//# sourceMappingURL=gated_llm_context.d.ts.map