@pipedog/core 0.0.0 → 0.1.0

package/dist/workers/llm/index.d.ts

@@ -0,0 +1,6 @@
+/** LLM worker package -- `LLMWorker`, `LLMContextWorker`, `BackendLLMWorker`, and the `tool` decorator. */
+export { BackendLLMWorker, BackendOutput } from "./backend_llm_worker.ts";
+export { LLMContextWorker } from "./llm_context_worker.ts";
+export { LLMWorker, LLMWorkerActivationArgs } from "./llm_worker.ts";
+export { tool } from "./tool_decorator.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/workers/llm/index.js

@@ -0,0 +1,11 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/workers/llm/__init__.py
+/** LLM worker package -- `LLMWorker`, `LLMContextWorker`, `BackendLLMWorker`, and the `tool` decorator. */
+export { BackendLLMWorker, BackendOutput } from "./backend_llm_worker.js";
+export { LLMContextWorker } from "./llm_context_worker.js";
+export { LLMWorker, LLMWorkerActivationArgs } from "./llm_worker.js";
+export { tool } from "./tool_decorator.js";
+//# sourceMappingURL=index.js.map

package/dist/workers/llm/llm_context_worker.d.ts

@@ -0,0 +1,66 @@
+import { LLMContext } from "../../processors/aggregators/llm_context.ts";
+import { type LLMAssistantAggregator, type LLMAssistantAggregatorParams, LLMContextAggregatorPair, type LLMUserAggregator, type LLMUserAggregatorParams } from "../../processors/aggregators/llm_response_universal.ts";
+import type { LLMService } from "../../services/llm_service.ts";
+import { LLMWorker } from "./llm_worker.ts";
+export interface LLMContextWorkerOptions {
+    /**
+     * Unique name for this worker on the bus. Auto-generated when omitted; give
+     * one when other workers address this one by name, as they must when it
+     * runs in another process.
+     */
+    name?: string | null;
+    /** The LLM service. */
+    llm: LLMService;
+    /** Whether the worker starts active. Defaults to false. */
+    active?: boolean;
+    /**
+     * Bridge configuration forwarded to `PipelineWorker`. Pass `[]` to wrap the
+     * pipeline with bus edges so it can exchange frames with another bridged
+     * worker.
+     */
+    bridged?: readonly string[] | null;
+    /**
+     * Whether to defer frames queued during tool execution until all tools
+     * complete. Defaults to true.
+     */
+    deferToolFrames?: boolean;
+    /** Optional pre-built `LLMContext`. When omitted, a fresh empty context is created. */
+    context?: LLMContext | null;
+    /** Optional parameters for the user aggregator. */
+    userParams?: LLMUserAggregatorParams | null;
+    /** Optional parameters for the assistant aggregator. */
+    assistantParams?: LLMAssistantAggregatorParams | null;
+}
+/**
+ * LLM worker that owns an `LLMContext` and a context aggregator pair.
+ *
+ * Useful for workers that need to track their own conversation history,
+ * typically workers that run their own LLM pipeline outside of a shared
+ * transport pipeline. Subclasses do not need to instantiate the context or
+ * aggregators themselves; the pipeline is built as
+ * `[userAggregator, llm, assistantAggregator]` automatically.
+ *
+ * @example
+ * const worker = new LLMContextWorker({
+ *   name: "worker",
+ *   llm: new OpenAILLMService({ ... }),
+ * });
+ *
+ * worker.assistantAggregator.addEventHandler(
+ *   "on_assistant_turn_stopped",
+ *   async (aggregator, message) => { ... },
+ * );
+ */
+export declare class LLMContextWorker extends LLMWorker {
+    protected _context: LLMContext;
+    protected _aggregators: LLMContextAggregatorPair;
+    /** Initialize the LLMContextWorker. */
+    constructor(options: LLMContextWorkerOptions);
+    /** The `LLMContext` owned by this worker. */
+    get context(): LLMContext;
+    /** The user-side context aggregator. */
+    get userAggregator(): LLMUserAggregator;
+    /** The assistant-side context aggregator. */
+    get assistantAggregator(): LLMAssistantAggregator;
+}
+//# sourceMappingURL=llm_context_worker.d.ts.map

package/dist/workers/llm/llm_context_worker.js

@@ -0,0 +1,72 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/workers/llm/llm_context_worker.py
+/**
+ * LLM worker with a built-in `LLMContext` and aggregator pair.
+ *
+ * Provides the `LLMContextWorker` class that extends `LLMWorker` with a
+ * self-contained conversation context, removing the need for subclasses to
+ * manually wire `LLMContextAggregatorPair`.
+ */
+import { Pipeline } from "../../pipeline/pipeline.js";
+import { LLMContext } from "../../processors/aggregators/llm_context.js";
+import { LLMContextAggregatorPair, } from "../../processors/aggregators/llm_response_universal.js";
+import { LLMWorker } from "./llm_worker.js";
+/**
+ * LLM worker that owns an `LLMContext` and a context aggregator pair.
+ *
+ * Useful for workers that need to track their own conversation history,
+ * typically workers that run their own LLM pipeline outside of a shared
+ * transport pipeline. Subclasses do not need to instantiate the context or
+ * aggregators themselves; the pipeline is built as
+ * `[userAggregator, llm, assistantAggregator]` automatically.
+ *
+ * @example
+ * const worker = new LLMContextWorker({
+ *   name: "worker",
+ *   llm: new OpenAILLMService({ ... }),
+ * });
+ *
+ * worker.assistantAggregator.addEventHandler(
+ *   "on_assistant_turn_stopped",
+ *   async (aggregator, message) => { ... },
+ * );
+ */
+export class LLMContextWorker extends LLMWorker {
+    _context;
+    _aggregators;
+    /** Initialize the LLMContextWorker. */
+    constructor(options) {
+        const context = options.context || new LLMContext();
+        const aggregators = new LLMContextAggregatorPair(context, {
+            userParams: options.userParams ?? null,
+            assistantParams: options.assistantParams ?? null,
+        });
+        const pipeline = new Pipeline([aggregators.user(), options.llm, aggregators.assistant()]);
+        super({
+            name: options.name ?? null,
+            llm: options.llm,
+            pipeline,
+            active: options.active ?? false,
+            bridged: options.bridged ?? null,
+            deferToolFrames: options.deferToolFrames ?? true,
+        });
+        this._context = context;
+        this._aggregators = aggregators;
+    }
+    /** The `LLMContext` owned by this worker. */
+    get context() {
+        return this._context;
+    }
+    /** The user-side context aggregator. */
+    get userAggregator() {
+        return this._aggregators.user();
+    }
+    /** The assistant-side context aggregator. */
+    get assistantAggregator() {
+        return this._aggregators.assistant();
+    }
+}
+//# sourceMappingURL=llm_context_worker.js.map

package/dist/workers/llm/llm_worker.d.ts

@@ -0,0 +1,180 @@
+import { type Frame } from "../../frames/frames.ts";
+import { Pipeline } from "../../pipeline/pipeline.ts";
+import { PipelineWorker } from "../../pipeline/worker.ts";
+import type { LLMContextMessage } from "../../processors/aggregators/llm_context.ts";
+import { FrameDirection } from "../../processors/frame_processor.ts";
+import type { FunctionCallParams, LLMService } from "../../services/llm_service.ts";
+import { WorkerActivationArgs, type WorkerActivationArgsOptions } from "../base_worker.ts";
+import { type LLMTool } from "./tool_decorator.ts";
+type Dict = Record<string, unknown>;
+export interface LLMWorkerActivationArgsOptions extends WorkerActivationArgsOptions {
+    /** LLM context messages to inject on activation. */
+    messages?: LLMContextMessage[] | null;
+    /**
+     * Whether to run the LLM after appending messages. Defaults to true when
+     * `messages` is set.
+     */
+    runLlm?: boolean | null;
+}
+/**
+ * Activation arguments for LLM workers.
+ *
+ * - `messages`: LLM context messages to inject on activation.
+ * - `runLlm`: whether to run the LLM after appending messages. Defaults to
+ *   true when `messages` is set.
+ */
+export declare class LLMWorkerActivationArgs extends WorkerActivationArgs {
+    messages: LLMContextMessage[] | null;
+    runLlm: boolean | null;
+    constructor(options?: LLMWorkerActivationArgsOptions);
+}
+export interface LLMWorkerOptions {
+    /**
+     * Unique name for this worker on the bus. Auto-generated when omitted; give
+     * one when other workers address this one by name, as they must when it
+     * runs in another process.
+     */
+    name?: string | null;
+    /** The LLM service. `tool` decorated methods are automatically registered on it. */
+    llm: LLMService;
+    /**
+     * Optional pipeline override. When null, defaults to `new Pipeline([llm])`.
+     * Subclasses can pass a custom pipeline that wraps the LLM with additional
+     * processors.
+     */
+    pipeline?: Pipeline | null;
+    /** Whether the worker starts active. Defaults to false. */
+    active?: boolean;
+    /**
+     * Bridge configuration forwarded to `PipelineWorker`. Pass `[]` to wrap the
+     * LLM pipeline with bus edge processors so it can exchange frames with
+     * another bridged worker.
+     */
+    bridged?: readonly string[] | null;
+    /**
+     * Whether to defer frames queued during tool execution until all tools
+     * complete. Defaults to true.
+     */
+    deferToolFrames?: boolean;
+}
+/**
+ * Worker with an LLM pipeline and automatic tool registration.
+ *
+ * Methods decorated with `tool` are registered as direct functions on the LLM
+ * and tracked so that frames queued during tool execution can be deferred
+ * until all tools complete.
+ *
+ * @example
+ * class MyTask extends LLMWorker {
+ *   async my_function(params: FunctionCallParams, arg: string) { ... }
+ *   static {
+ *     tool(this.prototype.my_function);
+ *   }
+ * }
+ *
+ * const worker = new MyTask({ name: "worker", llm: new OpenAILLMService({ apiKey: "..." }) });
+ */
+export declare class LLMWorker extends PipelineWorker {
+    protected _deferToolFrames: boolean;
+    protected _toolCallInflight: number;
+    protected _deferredFrames: [Frame, FrameDirection][];
+    protected _pendingHandover: (() => Promise<void>) | null;
+    protected _closing: boolean;
+    protected _llm: LLMService;
+    /** Initialize the LLMWorker. */
+    constructor(options: LLMWorkerOptions);
+    /** The LLM service this worker wraps. */
+    get llm(): LLMService;
+    /** True when one or more `tool` methods are executing. */
+    get toolCallActive(): boolean;
+    /**
+     * Configure the LLM with tools and activation messages.
+     *
+     * @param args Optional activation arguments with messages to append.
+     */
+    onActivated(args: Dict | null): Promise<void>;
+    /**
+     * Queue a frame, holding it if a tool handler queued it.
+     *
+     * A frame queued from inside one of this worker's `tool` handlers, or from
+     * anything that handler awaits, is held and delivered once the last tool
+     * finishes. Frames from anywhere else are queued immediately: the worker's
+     * own traffic and frames arriving over the bus, which run outside any
+     * handler's context, and frames a handler on a different worker queues
+     * here, which this worker would never release.
+     *
+     * @param frame Any `Frame` to deliver.
+     * @param direction Direction the frame should travel. Defaults to
+     *   `FrameDirection.DOWNSTREAM`.
+     */
+    queueFrame(frame: Frame, direction?: FrameDirection): Promise<void>;
+    /**
+     * Return the tools for this worker's LLM.
+     *
+     * By default, returns all methods decorated with `tool`. Override to
+     * provide additional or different tools.
+     *
+     * @returns List of tool functions.
+     */
+    buildTools(): LLMTool[];
+    /**
+     * Request a graceful end of the session.
+     *
+     * When called from a `tool` handler, deliver the function call result first
+     * with `await params.resultCallback(result)`: the LLM output it triggers is
+     * delivered before the session ends.
+     *
+     * @param options.reason Optional human-readable reason for ending.
+     */
+    end(options?: {
+        reason?: string | null;
+    }): Promise<void>;
+    /**
+     * Activate another worker, draining this worker's pipeline to hand over.
+     *
+     * When called from a `tool` handler, deliver the function call result first
+     * with `await params.resultCallback(result)`: the output it triggers is
+     * delivered before the target is activated. The handover itself waits
+     * until the tool call asking for it has finished.
+     *
+     * @param workerName The name of the worker to activate.
+     * @param options.args Optional `WorkerActivationArgs` forwarded to the
+     *   target worker's `onActivated` handler.
+     * @param options.deactivateSelf Whether to deactivate this worker before
+     *   activating the target. Deactivating this worker drains its pipeline
+     *   first; staying active does not. A worker that stays active and wants to
+     *   drain anyway can call `flushPipeline` before this.
+     */
+    activateWorker(workerName: string, options?: {
+        args?: WorkerActivationArgs | null;
+        deactivateSelf?: boolean;
+    }): Promise<void>;
+    /**
+     * Process deferred frames before they are flushed.
+     *
+     * Called after all in-flight tools complete, before the deferred frames are
+     * queued into the pipeline. Override to inspect, modify, reorder, or filter
+     * the frames.
+     *
+     * @param frames The deferred frames collected during tool execution.
+     * @returns The frames to queue. Return the list as-is for default behavior.
+     */
+    processDeferredToolFrames(frames: [Frame, FrameDirection][]): Promise<[Frame, FrameDirection][]>;
+    /** Register `tool` methods on the LLM in place. */
+    protected _registerTools(llm: LLMService): void;
+    /**
+     * Run a handover once no tool call is in flight.
+     *
+     * A tool asking to end or hand over is still running when it asks, and
+     * deactivating a worker mid-call leaves the rest of that call to a worker
+     * nobody is listening to. Held here and run once the last call finishes;
+     * outside a call there is nothing to wait for, so it runs now.
+     *
+     * @param handover What to do once the calls are done.
+     */
+    protected _afterToolCalls(handover: () => Promise<void>): Promise<void>;
+    protected _trackToolCall(method: LLMTool): (params: FunctionCallParams) => Promise<void>;
+    protected _flushDeferredFrames(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=llm_worker.d.ts.map

package/dist/workers/llm/llm_worker.js

@@ -0,0 +1,323 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/workers/llm/llm_worker.py
+/**
+ * LLM worker with tool registration.
+ *
+ * Provides the `LLMWorker` class that extends `PipelineWorker` with an LLM
+ * pipeline and automatic tool registration.
+ *
+ * Porting notes:
+ * - The deprecated `messages` / `resultCallback` arguments of `end()` and
+ *   `activateWorker()` are not ported, nor is `_finishFunctionCall`, which
+ *   only they used. Call `params.resultCallback(result)` before `end()` /
+ *   `activateWorker()` instead.
+ * - `_IN_TOOL_CALL` is a context variable upstream. JavaScript has no
+ *   context variables in core (no `node:async_hooks` outside
+ *   `@pipedog/asyncio`), so the worker running a tool is recorded per
+ *   asyncio-style task instead. DIVERGENCE: a task the tool handler spawns
+ *   (e.g. with `gather` or `createTask`) does not inherit it, so frames
+ *   queued from such a task are not held.
+ * - Tools are registered with `llm.registerFunction` and a bound direct
+ *   function wrapper, rather than upstream's private
+ *   `_register_direct_function`, because a bound (or wrapping) function no
+ *   longer exposes the parameter list its direct-function schema is read
+ *   from. The registration is explicit either way, so the advertised tools
+ *   never auto-register over it.
+ */
+import { currentTask } from "@pipedog/asyncio";
+import { DirectFunctionWrapper } from "../../adapters/schemas/direct_function.js";
+import { ToolsSchema } from "../../adapters/schemas/tools_schema.js";
+import { LLMMessagesAppendFrame, LLMSetToolsFrame } from "../../frames/frames.js";
+import { Pipeline } from "../../pipeline/pipeline.js";
+import { PipelineParams, PipelineWorker } from "../../pipeline/worker.js";
+import { FrameDirection } from "../../processors/frame_processor.js";
+import { WorkerActivationArgs } from "../base_worker.js";
+import { _collectTools } from "./tool_decorator.js";
+/**
+ * Activation arguments for LLM workers.
+ *
+ * - `messages`: LLM context messages to inject on activation.
+ * - `runLlm`: whether to run the LLM after appending messages. Defaults to
+ *   true when `messages` is set.
+ */
+export class LLMWorkerActivationArgs extends WorkerActivationArgs {
+    messages;
+    runLlm;
+    constructor(options = {}) {
+        super(options);
+        this.messages = options.messages ?? null;
+        this.runLlm = options.runLlm ?? null;
+    }
+}
+/**
+ * The worker whose `tool` handler is running, for the duration of that
+ * handler. Upstream this is a context variable rather than a counter so it
+ * answers "did this come from a tool", not "is a tool running somewhere": the
+ * bus dispatch tasks were created before any tool and carry a context where
+ * this is unset, so their frames are never mistaken for a handler's. It holds
+ * the worker rather than a flag because a handler can reach another worker,
+ * and only the worker running the tool will release what it holds.
+ *
+ * Here it is kept per task (see the module notes).
+ */
+const IN_TOOL_CALL = new WeakMap();
+function getInToolCall() {
+    const task = currentTask();
+    return task ? (IN_TOOL_CALL.get(task) ?? null) : null;
+}
+/** Set the current task's value; returns a token to restore the previous one. */
+function setInToolCall(worker) {
+    const task = currentTask();
+    const previous = task ? (IN_TOOL_CALL.get(task) ?? null) : null;
+    if (task) {
+        IN_TOOL_CALL.set(task, worker);
+    }
+    return { task, previous };
+}
+function resetInToolCall(token) {
+    if (!token.task)
+        return;
+    if (token.previous === null) {
+        IN_TOOL_CALL.delete(token.task);
+    }
+    else {
+        IN_TOOL_CALL.set(token.task, token.previous);
+    }
+}
+/**
+ * A direct function wrapper that invokes the function with `this` bound to
+ * its owner, so a tool method keeps both its parameter list (read from its
+ * source) and its worker.
+ */
+class _BoundDirectFunctionWrapper extends DirectFunctionWrapper {
+    #thisArg;
+    constructor(fn, thisArg) {
+        super(fn);
+        this.#thisArg = thisArg;
+    }
+    async invoke(args, params) {
+        const positional = this._argumentNames().map((name) => args[name]);
+        return await this.function.call(this.#thisArg, params, ...positional);
+    }
+}
+/**
+ * Worker with an LLM pipeline and automatic tool registration.
+ *
+ * Methods decorated with `tool` are registered as direct functions on the LLM
+ * and tracked so that frames queued during tool execution can be deferred
+ * until all tools complete.
+ *
+ * @example
+ * class MyTask extends LLMWorker {
+ *   async my_function(params: FunctionCallParams, arg: string) { ... }
+ *   static {
+ *     tool(this.prototype.my_function);
+ *   }
+ * }
+ *
+ * const worker = new MyTask({ name: "worker", llm: new OpenAILLMService({ apiKey: "..." }) });
+ */
+export class LLMWorker extends PipelineWorker {
+    // State referenced by tool wrapper closures.
+    _deferToolFrames;
+    _toolCallInflight = 0;
+    _deferredFrames = [];
+    // A handover or ending a tool asked for, held until its call is done.
+    _pendingHandover = null;
+    _closing = false;
+    _llm;
+    /** Initialize the LLMWorker. */
+    constructor(options) {
+        const pipeline = options.pipeline ?? new Pipeline([options.llm]);
+        super(pipeline, {
+            name: options.name ?? null,
+            bridged: options.bridged ?? null,
+            idleTimeoutSecs: null,
+            params: new PipelineParams({
+                enableMetrics: true,
+                enableUsageMetrics: true,
+            }),
+            active: options.active ?? false,
+        });
+        this._deferToolFrames = options.deferToolFrames ?? true;
+        this._llm = options.llm;
+        this._registerTools(this._llm);
+    }
+    /** The LLM service this worker wraps. */
+    get llm() {
+        return this._llm;
+    }
+    /** True when one or more `tool` methods are executing. */
+    get toolCallActive() {
+        return this._toolCallInflight > 0;
+    }
+    /**
+     * Configure the LLM with tools and activation messages.
+     *
+     * @param args Optional activation arguments with messages to append.
+     */
+    async onActivated(args) {
+        await super.onActivated(args);
+        const activation = args
+            ? LLMWorkerActivationArgs.fromDict(args)
+            : new LLMWorkerActivationArgs();
+        const tools = this.buildTools();
+        if (tools.length > 0) {
+            await this.queueFrame(new LLMSetToolsFrame({ tools: new ToolsSchema({ standardTools: tools }) }));
+        }
+        if (activation.messages && activation.messages.length > 0) {
+            const runLlm = activation.runLlm !== null ? activation.runLlm : true;
+            await this.queueFrame(new LLMMessagesAppendFrame({ messages: activation.messages, runLlm }));
+        }
+    }
+    /**
+     * Queue a frame, holding it if a tool handler queued it.
+     *
+     * A frame queued from inside one of this worker's `tool` handlers, or from
+     * anything that handler awaits, is held and delivered once the last tool
+     * finishes. Frames from anywhere else are queued immediately: the worker's
+     * own traffic and frames arriving over the bus, which run outside any
+     * handler's context, and frames a handler on a different worker queues
+     * here, which this worker would never release.
+     *
+     * @param frame Any `Frame` to deliver.
+     * @param direction Direction the frame should travel. Defaults to
+     *   `FrameDirection.DOWNSTREAM`.
+     */
+    async queueFrame(frame, direction = FrameDirection.DOWNSTREAM) {
+        if (this._deferToolFrames && getInToolCall() === this && !this._closing) {
+            this._deferredFrames.push([frame, direction]);
+        }
+        else {
+            await super.queueFrame(frame, direction);
+        }
+    }
+    /**
+     * Return the tools for this worker's LLM.
+     *
+     * By default, returns all methods decorated with `tool`. Override to
+     * provide additional or different tools.
+     *
+     * @returns List of tool functions.
+     */
+    buildTools() {
+        return _collectTools(this);
+    }
+    /**
+     * Request a graceful end of the session.
+     *
+     * When called from a `tool` handler, deliver the function call result first
+     * with `await params.resultCallback(result)`: the LLM output it triggers is
+     * delivered before the session ends.
+     *
+     * @param options.reason Optional human-readable reason for ending.
+     */
+    async end(options = {}) {
+        this._closing = true;
+        await this._afterToolCalls(() => super.end({ reason: options.reason ?? null }));
+    }
+    /**
+     * Activate another worker, draining this worker's pipeline to hand over.
+     *
+     * When called from a `tool` handler, deliver the function call result first
+     * with `await params.resultCallback(result)`: the output it triggers is
+     * delivered before the target is activated. The handover itself waits
+     * until the tool call asking for it has finished.
+     *
+     * @param workerName The name of the worker to activate.
+     * @param options.args Optional `WorkerActivationArgs` forwarded to the
+     *   target worker's `onActivated` handler.
+     * @param options.deactivateSelf Whether to deactivate this worker before
+     *   activating the target. Deactivating this worker drains its pipeline
+     *   first; staying active does not. A worker that stays active and wants to
+     *   drain anyway can call `flushPipeline` before this.
+     */
+    async activateWorker(workerName, options = {}) {
+        await this._afterToolCalls(() => super.activateWorker(workerName, {
+            args: options.args ?? null,
+            deactivateSelf: options.deactivateSelf ?? false,
+        }));
+    }
+    /**
+     * Process deferred frames before they are flushed.
+     *
+     * Called after all in-flight tools complete, before the deferred frames are
+     * queued into the pipeline. Override to inspect, modify, reorder, or filter
+     * the frames.
+     *
+     * @param frames The deferred frames collected during tool execution.
+     * @returns The frames to queue. Return the list as-is for default behavior.
+     */
+    async processDeferredToolFrames(frames) {
+        return frames;
+    }
+    /** Register `tool` methods on the LLM in place. */
+    _registerTools(llm) {
+        for (const method of _collectTools(this)) {
+            const tracked = this._trackToolCall(method);
+            llm.registerFunction(method.name, tracked, {
+                cancelOnInterruption: method._pipecatCancelOnInterruption ?? true,
+                timeoutSecs: method._pipecatTimeoutSecs ?? null,
+            });
+        }
+    }
+    /**
+     * Run a handover once no tool call is in flight.
+     *
+     * A tool asking to end or hand over is still running when it asks, and
+     * deactivating a worker mid-call leaves the rest of that call to a worker
+     * nobody is listening to. Held here and run once the last call finishes;
+     * outside a call there is nothing to wait for, so it runs now.
+     *
+     * @param handover What to do once the calls are done.
+     */
+    async _afterToolCalls(handover) {
+        if (this._toolCallInflight) {
+            this._pendingHandover = handover;
+        }
+        else {
+            await handover();
+        }
+    }
+    _trackToolCall(method) {
+        const wrapper = new _BoundDirectFunctionWrapper(method, this);
+        return async (params) => {
+            this._toolCallInflight += 1;
+            const token = setInToolCall(this);
+            try {
+                await wrapper.invoke(params.arguments, params);
+            }
+            finally {
+                resetInToolCall(token);
+                this._toolCallInflight = Math.max(0, this._toolCallInflight - 1);
+                if (this._toolCallInflight === 0) {
+                    if (!this._closing) {
+                        await this._flushDeferredFrames();
+                    }
+                    const handover = this._pendingHandover;
+                    this._pendingHandover = null;
+                    if (handover) {
+                        await handover();
+                    }
+                }
+            }
+        };
+    }
+    async _flushDeferredFrames() {
+        const frames = [...this._deferredFrames];
+        this._deferredFrames.length = 0;
+        // Held frames go back in behind the function call result, so wait for
+        // that to be processed first. With nothing held there is nothing to
+        // order, and the round-trip would buy nothing.
+        if (frames.length > 0) {
+            await this.flushPipeline();
+        }
+        for (const [frame, direction] of await this.processDeferredToolFrames(frames)) {
+            await this.queueFrame(frame, direction);
+        }
+    }
+}
+//# sourceMappingURL=llm_worker.js.map