@fonoster/autopilot 0.27.0 → 0.30.0

package/dist/session/llm.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryLlmResolver = exports.LlmResolutionError = exports.OPENAI_COMPATIBLE = exports.LayeredCredentials = exports.ConfigCredentials = void 0;
+const community_1 = require("@fonoster/community");
+const openai_1 = require("@fonoster/community/openai");
+Object.defineProperty(exports, "OPENAI_COMPATIBLE", { enumerable: true, get: function () { return openai_1.OPENAI_COMPATIBLE; } });
+/**
+ * Platform credentials from operator config: `{ "<credentialRef>": { env } | { value } }`. The
+ * variable names are operator choices; Autopilot never reads a vendor variable by itself.
+ */
+class ConfigCredentials {
+    constructor(refs) {
+        this.refs = refs;
+    }
+    get(ref) {
+        const c = this.refs[ref];
+        return c?.value ?? (c?.env ? process.env[c.env] : undefined);
+    }
+}
+exports.ConfigCredentials = ConfigCredentials;
+/** Workspace Secrets (BYOK) in front of platform credentials. */
+class LayeredCredentials {
+    constructor(sources) {
+        this.sources = sources;
+    }
+    async get(ref, scope) {
+        for (const s of this.sources) {
+            const v = await s.get(ref, scope);
+            if (v)
+                return v;
+        }
+        return undefined;
+    }
+}
+exports.LayeredCredentials = LayeredCredentials;
+class LlmResolutionError extends Error {
+}
+exports.LlmResolutionError = LlmResolutionError;
+class RegistryLlmResolver {
+    constructor(options) {
+        this.options = options;
+    }
+    async resolve(catalogId, settings, scope = {}) {
+        const { registry } = this.options;
+        const resolution = registry.resolve(catalogId);
+        const id = resolution.id;
+        const entries = registry.list();
+        const model = entries.find((e) => e.id === id);
+        if (!model || model.kind !== "model" || model.type !== "llm")
+            throw new LlmResolutionError(`${catalogId} is not a language model in the catalog`);
+        const providerId = id.slice(0, id.indexOf("/"));
+        const provider = entries.find((e) => e.id === providerId);
+        if (!provider || provider.kind !== "provider")
+            throw new LlmResolutionError(`no provider ${providerId} for ${id}`);
+        if (provider.state === "retired")
+            throw new LlmResolutionError(`provider ${providerId} is retired`);
+        const llm = (0, community_1.adapterFor)(provider.adapter)?.llm;
+        if (!llm)
+            throw new LlmResolutionError(`adapter ${provider.adapter} has no language model implementation in Autopilot yet`);
+        const baseUrl = this.options.endpoints?.[provider.id] ??
+            this.options.endpoints?.[provider.adapter] ??
+            llm.defaultEndpoint;
+        if (!baseUrl)
+            throw new LlmResolutionError(`no endpoint for provider ${provider.id} (adapter ${provider.adapter})`);
+        const apiKey = await this.options.credentials.get(provider.credentialRef, scope);
+        if (!apiKey && !(0, community_1.adapterFor)(provider.adapter)?.keyless)
+            throw new LlmResolutionError(`no credential ${provider.credentialRef} for provider ${provider.id}`);
+        return {
+            id,
+            think: llm.create({ baseUrl, apiKey }, id.slice(providerId.length + 1), settings),
+            ...(resolution.event
+                ? {
+                    event: {
+                        type: resolution.event,
+                        id: catalogId,
+                        replacement: resolution.replacement
+                    }
+                }
+                : {})
+        };
+    }
+}
+exports.RegistryLlmResolver = RegistryLlmResolver;

package/dist/session/machine.d.ts

@@ -0,0 +1,206 @@
+import { Agent, AgentEvent } from "./Agent";
+/**
+ * Autopilot's states (rework-autopilot A4). The machine decides; the Agent acts on the session.
+ * The idle clock runs only in listening.
+ */
+export declare const autopilotMachine: import("xstate").StateMachine<{
+    agent: Agent;
+}, AgentEvent, {}, never, import("xstate").Values<{
+    transfer: {
+        type: "transfer";
+        params: unknown;
+    };
+    stop: {
+        type: "stop";
+        params: unknown;
+    };
+    prepare: {
+        type: "prepare";
+        params: unknown;
+    };
+    greet: {
+        type: "greet";
+        params: unknown;
+    };
+    armIdle: {
+        type: "armIdle";
+        params: unknown;
+    };
+    disarmIdle: {
+        type: "disarmIdle";
+        params: unknown;
+    };
+    sayIdle: {
+        type: "sayIdle";
+        params: unknown;
+    };
+    resumed: {
+        type: "resumed";
+        params: unknown;
+    };
+    answer: {
+        type: "answer";
+        params: unknown;
+    };
+    abortReply: {
+        type: "abortReply";
+        params: unknown;
+    };
+    clear: {
+        type: "clear";
+        params: unknown;
+    };
+    goodbye: {
+        type: "goodbye";
+        params: unknown;
+    };
+}>, import("xstate").Values<{
+    spokenFrom: {
+        type: "spokenFrom";
+        params: string[];
+    };
+    bargeIn: {
+        type: "bargeIn";
+        params: unknown;
+    };
+    idleExhausted: {
+        type: "idleExhausted";
+        params: unknown;
+    };
+}>, never, "greeting" | "listening" | "thinking" | "ending" | "speaking" | "transferring" | "ended", string, {
+    agent: Agent;
+}, {}, import("xstate").EventObject, import("xstate").MetaObject, {
+    readonly id: "autopilot";
+    readonly initial: "greeting";
+    readonly context: ({ input }: {
+        spawn: {
+            <TSrc extends never>(logic: TSrc, ...[options]: never): import("xstate").ActorRefFromLogic<never>;
+            <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, options?: {
+                id?: never;
+                systemId?: string;
+                input?: import("xstate").InputFrom<TLogic>;
+                syncSnapshot?: boolean;
+            }): import("xstate").ActorRefFromLogic<TLogic>;
+        };
+        input: {
+            agent: Agent;
+        };
+        self: import("xstate").ActorRef<import("xstate").MachineSnapshot<{
+            agent: Agent;
+        }, AgentEvent, Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, AgentEvent, import("xstate").AnyEventObject>;
+    }) => {
+        agent: Agent;
+    };
+    readonly on: {
+        readonly SESSION_END: ".ended";
+        readonly MAX_DURATION: ".ending";
+        readonly HANGUP_REQUESTED: ".ending";
+        readonly TRANSFER_REQUESTED: ".transferring";
+        readonly TURN_BACKCHANNEL: {};
+    };
+    readonly states: {
+        readonly greeting: {
+            readonly entry: "greet";
+            readonly on: {
+                readonly SPOKEN: {
+                    readonly guard: {
+                        readonly type: "spokenFrom";
+                        readonly params: ["greeting"];
+                    };
+                    readonly target: "listening";
+                };
+                readonly TURN_USER_STARTED: {
+                    readonly guard: "bargeIn";
+                    readonly actions: "clear";
+                };
+                readonly TURN_LIKELY_ENDED: {
+                    readonly actions: "prepare";
+                };
+                readonly TURN_RESUMED: {
+                    readonly actions: "resumed";
+                };
+                readonly TURN_ENDED: "thinking";
+            };
+        };
+        readonly listening: {
+            readonly entry: "armIdle";
+            readonly exit: "disarmIdle";
+            readonly on: {
+                readonly TURN_LIKELY_ENDED: {
+                    readonly actions: "prepare";
+                };
+                readonly TURN_RESUMED: {
+                    readonly actions: "resumed";
+                };
+                readonly TURN_ENDED: "thinking";
+                readonly IDLE: readonly [{
+                    readonly guard: "idleExhausted";
+                    readonly target: "ending";
+                }, {
+                    readonly target: "speaking";
+                    readonly actions: "sayIdle";
+                }];
+            };
+        };
+        readonly thinking: {
+            readonly entry: "answer";
+            readonly on: {
+                readonly REPLY_SPEAKING: "speaking";
+                readonly SPOKEN: {
+                    readonly guard: {
+                        readonly type: "spokenFrom";
+                        readonly params: ["reply", "error"];
+                    };
+                    readonly target: "listening";
+                };
+                readonly TURN_USER_STARTED: {
+                    readonly guard: "bargeIn";
+                    readonly actions: "clear";
+                };
+                readonly TURN_ENDED: {
+                    readonly target: "thinking";
+                    readonly reenter: true;
+                    readonly actions: "abortReply";
+                };
+            };
+        };
+        readonly speaking: {
+            readonly on: {
+                readonly SPOKEN: {
+                    readonly guard: {
+                        readonly type: "spokenFrom";
+                        readonly params: ["reply", "idle", "error"];
+                    };
+                    readonly target: "listening";
+                };
+                readonly TURN_USER_STARTED: {
+                    readonly guard: "bargeIn";
+                    readonly actions: "clear";
+                };
+                readonly TURN_ENDED: {
+                    readonly target: "thinking";
+                    readonly actions: "abortReply";
+                };
+            };
+        };
+        readonly transferring: {
+            readonly entry: "transfer";
+            readonly on: {
+                readonly SPOKEN: {
+                    readonly guard: {
+                        readonly type: "spokenFrom";
+                        readonly params: ["error"];
+                    };
+                    readonly target: "listening";
+                };
+            };
+        };
+        readonly ending: {
+            readonly entry: "goodbye";
+        };
+        readonly ended: {
+            readonly type: "final";
+            readonly entry: "stop";
+        };
+    };
+}>;

package/dist/session/machine.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autopilotMachine = void 0;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const xstate_1 = require("xstate");
+/**
+ * Autopilot's states (rework-autopilot A4). The machine decides; the Agent acts on the session.
+ * The idle clock runs only in listening.
+ */
+exports.autopilotMachine = (0, xstate_1.setup)({
+    types: {
+        context: {},
+        input: {},
+        events: {}
+    },
+    guards: {
+        spokenFrom: ({ event }, sources) => event.type === "SPOKEN" && sources.includes(event.source),
+        bargeIn: ({ context }) => context.agent.settings.allowUserBargeIn,
+        idleExhausted: ({ context }) => context.agent.idleExhausted()
+    },
+    actions: {
+        greet: ({ context }) => void context.agent.greet(),
+        armIdle: ({ context }) => context.agent.armIdle(),
+        disarmIdle: ({ context }) => context.agent.disarmIdle(),
+        sayIdle: ({ context }) => void context.agent.sayIdle(),
+        prepare: ({ context, event }) => context.agent.prepare(event.text),
+        resumed: ({ context }) => context.agent.resumed(),
+        answer: ({ context, event }) => void context.agent.answer(event.text),
+        abortReply: ({ context }) => context.agent.abortReply(),
+        clear: ({ context }) => void context.agent.clear(),
+        goodbye: ({ context }) => void context.agent.goodbye(),
+        transfer: ({ context }) => void context.agent.transfer(),
+        stop: ({ context }) => context.agent.stop()
+    }
+}).createMachine({
+    id: "autopilot",
+    initial: "greeting",
+    context: ({ input }) => ({ agent: input.agent }),
+    on: {
+        SESSION_END: ".ended",
+        MAX_DURATION: ".ending",
+        HANGUP_REQUESTED: ".ending",
+        TRANSFER_REQUESTED: ".transferring",
+        // Backchannels are not interruptions: nothing happens in any state.
+        TURN_BACKCHANNEL: {}
+    },
+    states: {
+        greeting: {
+            entry: "greet",
+            on: {
+                SPOKEN: {
+                    guard: { type: "spokenFrom", params: ["greeting"] },
+                    target: "listening"
+                },
+                TURN_USER_STARTED: { guard: "bargeIn", actions: "clear" },
+                TURN_LIKELY_ENDED: { actions: "prepare" },
+                TURN_RESUMED: { actions: "resumed" },
+                TURN_ENDED: "thinking"
+            }
+        },
+        listening: {
+            entry: "armIdle",
+            exit: "disarmIdle",
+            on: {
+                TURN_LIKELY_ENDED: { actions: "prepare" },
+                TURN_RESUMED: { actions: "resumed" },
+                TURN_ENDED: "thinking",
+                IDLE: [
+                    { guard: "idleExhausted", target: "ending" },
+                    { target: "speaking", actions: "sayIdle" }
+                ]
+            }
+        },
+        thinking: {
+            entry: "answer",
+            on: {
+                REPLY_SPEAKING: "speaking",
+                SPOKEN: {
+                    guard: { type: "spokenFrom", params: ["reply", "error"] },
+                    target: "listening"
+                },
+                TURN_USER_STARTED: { guard: "bargeIn", actions: "clear" },
+                // A new turn cancels the reply in flight; its user text stays in the history.
+                TURN_ENDED: { target: "thinking", reenter: true, actions: "abortReply" }
+            }
+        },
+        speaking: {
+            on: {
+                SPOKEN: {
+                    guard: { type: "spokenFrom", params: ["reply", "idle", "error"] },
+                    target: "listening"
+                },
+                TURN_USER_STARTED: { guard: "bargeIn", actions: "clear" },
+                TURN_ENDED: { target: "thinking", actions: "abortReply" }
+            }
+        },
+        transferring: {
+            entry: "transfer",
+            on: {
+                SPOKEN: {
+                    guard: { type: "spokenFrom", params: ["error"] },
+                    target: "listening"
+                }
+            }
+        },
+        ending: { entry: "goodbye" },
+        ended: { type: "final", entry: "stop" }
+    }
+});

package/dist/session/main.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Autopilot's entry point (rework-autopilot task 4.3; the only engine since cleanbreak CB-B5):
+//
+//   node dist/session/main.js --config /config/autopilot.yaml
+const common_1 = require("@fonoster/common");
+const logger_1 = require("@fonoster/logger");
+const hosted_1 = require("./hosted");
+const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
+(0, common_1.logUnhandledRejections)(logger);
+// --config, AUTOPILOT_SESSION_CONFIG, else /config/autopilot.yaml (or an older location).
+const at = process.argv.indexOf("--config");
+const file = at >= 0
+    ? process.argv[at + 1]
+    : (process.env.AUTOPILOT_SESSION_CONFIG ?? (0, hosted_1.findHostedConfig)());
+if (!file) {
+    logger.error("no Autopilot config file: mount /config/autopilot.yaml or pass --config <file>");
+    process.exit(1);
+}
+const config = (0, hosted_1.loadHostedConfig)(file);
+// Off unless an OTLP endpoint is configured (telemetry.otlpEndpoint or OTEL_EXPORTER_OTLP_*).
+(0, common_1.initTelemetry)("fonoster-autopilot", undefined, (0, common_1.telemetryEnv)(config.telemetry));
+(0, hosted_1.startHostedAutopilot)(config).catch((e) => {
+    logger.error(`hosted autopilot failed to start: ${e.message}`);
+    process.exit(1);
+});

package/dist/session/sentences.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Groups streamed tokens into sentence-sized pieces, so each speak piece is a natural unit for TTS
+ * while the first sentence still starts before the reply is complete (rework-autopilot A5).
+ */
+export declare function sentences(tokens: AsyncIterable<string>): AsyncIterable<string>;

package/dist/session/sentences.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sentences = sentences;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const SENTENCE_END = /[.!?](["')\]]*)\s+/;
+const MAX_PIECE = 160;
+/**
+ * Groups streamed tokens into sentence-sized pieces, so each speak piece is a natural unit for TTS
+ * while the first sentence still starts before the reply is complete (rework-autopilot A5).
+ */
+async function* sentences(tokens) {
+    let buffer = "";
+    for await (const token of tokens) {
+        buffer += token;
+        for (;;) {
+            const m = SENTENCE_END.exec(buffer);
+            if (m) {
+                const end = m.index + m[0].length;
+                yield buffer.slice(0, end);
+                buffer = buffer.slice(end);
+                continue;
+            }
+            if (buffer.length > MAX_PIECE) {
+                const cut = buffer.lastIndexOf(" ", MAX_PIECE);
+                if (cut > 0) {
+                    yield buffer.slice(0, cut + 1);
+                    buffer = buffer.slice(cut + 1);
+                    continue;
+                }
+            }
+            break;
+        }
+    }
+    if (buffer.trim())
+        yield buffer;
+}

package/dist/{machine/actors/index.d.ts → session/think.d.ts}

@@ -16,6 +16,5 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export * from "./doProcessUserRequest";
-export * from "./doGreetUser";
-export * from "./doAnnounceIdleTimeout";
+export { ChatMessage, Think, ThinkChunk, ThinkError, ThinkProvider, ToolCall, ToolSpec } from "@fonoster/community";
+export { OpenAiCompatibleThink, resolveThink } from "@fonoster/community/openai";

package/dist/{machine/actions/announceSystemError.js → session/think.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.announceSystemError = void 0;
+exports.resolveThink = exports.OpenAiCompatibleThink = exports.ThinkError = void 0;
 /**
  * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
  * http://github.com/fonoster/fonoster
@@ -19,12 +19,10 @@ exports.announceSystemError = void 0;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const logger_1 = require("@fonoster/logger");
-const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
-const announceSystemError = async ({ context }) => {
-    logger.verbose("called the announceSystemError action", {
-        systemErrorMessage: context.systemErrorMessage
-    });
-    await context.voice.say(context.systemErrorMessage);
-};
-exports.announceSystemError = announceSystemError;
+// The LLM adapter interface and the OpenAI-compatible adapter live in @fonoster/community with
+// the other vendor adapters (registry 3.1).
+var community_1 = require("@fonoster/community");
+Object.defineProperty(exports, "ThinkError", { enumerable: true, get: function () { return community_1.ThinkError; } });
+var openai_1 = require("@fonoster/community/openai");
+Object.defineProperty(exports, "OpenAiCompatibleThink", { enumerable: true, get: function () { return openai_1.OpenAiCompatibleThink; } });
+Object.defineProperty(exports, "resolveThink", { enumerable: true, get: function () { return openai_1.resolveThink; } });

package/dist/session/tools.d.ts

@@ -0,0 +1,22 @@
+import { DestinationPolicy } from "@fonoster/common";
+import { ToolDefinition } from "./config";
+export type ToolOutcome = {
+    ok: boolean;
+    result?: unknown;
+    error?: string;
+};
+/** The tool port (rework-autopilot A7): one operation, run a tool with inputs. */
+export interface ToolPort {
+    run(name: string, args: Record<string, unknown>, signal: AbortSignal): Promise<ToolOutcome>;
+}
+/**
+ * HTTP tools from the assistant config (`operation.method`, `url`, `headers`). Tool URLs are
+ * tenant input: they go through safeFetch (public destinations only, redirects re-checked,
+ * 10 s timeout; RV-B2).
+ */
+export declare class HttpToolPort implements ToolPort {
+    private readonly tools;
+    private readonly policy?;
+    constructor(tools: ToolDefinition[], policy?: DestinationPolicy);
+    run(name: string, args: Record<string, unknown>, signal: AbortSignal): Promise<ToolOutcome>;
+}

package/dist/session/tools.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpToolPort = void 0;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const url_1 = require("url");
+const common_1 = require("@fonoster/common");
+/**
+ * HTTP tools from the assistant config (`operation.method`, `url`, `headers`). Tool URLs are
+ * tenant input: they go through safeFetch (public destinations only, redirects re-checked,
+ * 10 s timeout; RV-B2).
+ */
+class HttpToolPort {
+    constructor(tools, policy) {
+        this.tools = tools;
+        this.policy = policy;
+    }
+    async run(name, args, signal) {
+        const tool = this.tools.find((t) => t.name === name);
+        if (!tool)
+            return { ok: false, error: `unknown tool ${name}` };
+        const method = String(tool.operation.method ?? "get").toUpperCase();
+        const url = new url_1.URL(tool.operation.url);
+        let body;
+        if (method === "GET") {
+            for (const [k, v] of Object.entries(args))
+                url.searchParams.set(k, String(v));
+        }
+        else {
+            body = JSON.stringify(args);
+        }
+        try {
+            const request = (0, common_1.safeFetch)(url, {
+                method,
+                headers: {
+                    accept: "application/json",
+                    "content-type": "application/json",
+                    ...(tool.operation.headers ?? {})
+                },
+                body,
+                signal,
+                policy: this.policy?.allow ? this.policy : undefined
+            });
+            if (tool.operation.waitForResponse === false) {
+                request.catch(() => undefined);
+                return { ok: true, result: { status: "sent" } };
+            }
+            const res = await request;
+            const text = await res.text();
+            if (!res.ok)
+                return {
+                    ok: false,
+                    error: `HTTP ${res.status}: ${text.slice(0, 200)}`
+                };
+            try {
+                return { ok: true, result: JSON.parse(text) };
+            }
+            catch {
+                return { ok: true, result: text };
+            }
+        }
+        catch (e) {
+            return { ok: false, error: e.message };
+        }
+    }
+}
+exports.HttpToolPort = HttpToolPort;

package/dist/tools/builtin/transferToolDefinition.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transferToolDefinition = void 0;
 const transferToolDefinition = {
     name: "transfer",
-    description: "Transfer the call to a live agent",
+    description: "Transfer the call to an operator (a person)",
     parameters: {
         type: "object",
         properties: {

package/dist/voice/index.d.ts

@@ -16,5 +16,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export * from "./Voice";
 export * from "./types";