@fonoster/autopilot 0.27.0 → 0.31.0

package/dist/session/meteredThink.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DRAIN_DEADLINE_MS = void 0;
+exports.usageLines = usageLines;
+exports.meteredThink = meteredThink;
+/** How long an interrupted reply is read in the background for its usage report (design D6). */
+exports.DRAIN_DEADLINE_MS = 30000;
+const abortError = () => {
+    const e = new Error("aborted");
+    e.name = "AbortError";
+    return e;
+};
+/** Resolves like `p`, or rejects with an AbortError as soon as `signal` aborts. */
+function raceAbort(p, signal) {
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(abortError());
+        if (signal.aborted)
+            return onAbort();
+        signal.addEventListener("abort", onAbort, { once: true });
+        p.then((v) => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(v);
+        }, (e) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(e);
+        });
+    });
+}
+function usageLines(model, usage) {
+    const key = {
+        provider: model.catalogId.split("/")[0],
+        model: model.catalogId,
+        keySource: model.keySource
+    };
+    const lines = [
+        { meter: "llm.tokens.in", quantity: usage.inputTokens, ...key },
+        { meter: "llm.tokens.out", quantity: usage.outputTokens, ...key }
+    ];
+    if (usage.cachedTokens > 0)
+        lines.push({
+            meter: "llm.tokens.cached",
+            quantity: usage.cachedTokens,
+            ...key
+        });
+    return lines;
+}
+/**
+ * A Think that meters its model (add-usage-metering D6). Chunks pass through; the vendor's usage
+ * chunk is reported, never forwarded. When the caller stops reading (barge-in, a newer turn), the
+ * stream ends for the caller at once but keeps being read in the background, so the vendor's usage
+ * for the whole request still arrives; after the deadline, or when `closed` aborts (the session
+ * ended), the request is reported as missing usage. A request the vendor failed reports nothing.
+ */
+function meteredThink(inner, model, sink, options = {}) {
+    const settle = (usage) => usage
+        ? sink.usage(usageLines(model, usage))
+        : sink.missing(model.catalogId);
+    return {
+        async *stream(messages, tools, signal) {
+            const request = new AbortController();
+            const stopRequest = () => request.abort();
+            options.closed?.addEventListener("abort", stopRequest, { once: true });
+            const it = inner
+                .stream(messages, tools, request.signal)[Symbol.asyncIterator]();
+            let usage;
+            let pending;
+            let state = "reading";
+            const done = () => options.closed?.removeEventListener("abort", stopRequest);
+            const drain = async () => {
+                const deadline = setTimeout(stopRequest, options.drainMs ?? exports.DRAIN_DEADLINE_MS);
+                try {
+                    for (;;) {
+                        const r = await (pending ?? it.next());
+                        pending = undefined;
+                        if (r.done)
+                            break;
+                        if (r.value.type === "usage")
+                            usage = r.value.usage;
+                    }
+                }
+                catch {
+                    // Cut by the deadline or the session's end: whatever arrived is all there is.
+                }
+                finally {
+                    clearTimeout(deadline);
+                    done();
+                }
+                settle(usage);
+            };
+            try {
+                for (;;) {
+                    pending = it.next();
+                    pending.catch(() => undefined);
+                    const r = await raceAbort(pending, signal);
+                    pending = undefined;
+                    if (r.done) {
+                        state = "done";
+                        break;
+                    }
+                    if (r.value.type === "usage")
+                        usage = r.value.usage;
+                    else
+                        yield r.value;
+                }
+            }
+            catch (e) {
+                if (!signal.aborted)
+                    state = "failed";
+                throw e;
+            }
+            finally {
+                if (state === "done") {
+                    done();
+                    settle(usage);
+                }
+                else if (state === "failed") {
+                    done();
+                }
+                else {
+                    void drain();
+                }
+            }
+        }
+    };
+}

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/session/telemetry.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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.
+ */
+import { Telemetry, TelemetryConfig } from "@fonoster/common";
+/**
+ * Autopilot's telemetry: a stable handle (like AppBridge's) that delegates to what
+ * `startTelemetry`/`setTelemetry` installed. OTLP when an endpoint is configured
+ * (telemetry.otlpEndpoint or OTEL_EXPORTER_OTLP_*), a no-op otherwise.
+ *
+ * Spans: autopilot.session (child of AppBridge's call span, via session.start `traceparent`),
+ * autopilot.turn (STT final to the end of the reply) and autopilot.llm.request. Metrics:
+ * fonoster.autopilot.turns, fonoster.autopilot.llm.requests and fonoster.autopilot.llm.latency_ms
+ * (the sum of the time to the first token; divide by requests for the mean).
+ */
+export declare const telemetry: Telemetry;
+/** Installs a telemetry implementation (tests). */
+export declare function setTelemetry(t: Telemetry): void;
+/** Starts telemetry with the config's endpoint, once the config is loaded. */
+export declare function startTelemetry(config: TelemetryConfig): void;

package/dist/session/telemetry.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.telemetry = void 0;
+exports.setTelemetry = setTelemetry;
+exports.startTelemetry = startTelemetry;
+/**
+ * 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 common_1 = require("@fonoster/common");
+let impl = (0, common_1.initTelemetry)("fonoster-autopilot");
+/**
+ * Autopilot's telemetry: a stable handle (like AppBridge's) that delegates to what
+ * `startTelemetry`/`setTelemetry` installed. OTLP when an endpoint is configured
+ * (telemetry.otlpEndpoint or OTEL_EXPORTER_OTLP_*), a no-op otherwise.
+ *
+ * Spans: autopilot.session (child of AppBridge's call span, via session.start `traceparent`),
+ * autopilot.turn (STT final to the end of the reply) and autopilot.llm.request. Metrics:
+ * fonoster.autopilot.turns, fonoster.autopilot.llm.requests and fonoster.autopilot.llm.latency_ms
+ * (the sum of the time to the first token; divide by requests for the mean).
+ */
+exports.telemetry = {
+    get enabled() {
+        return impl.enabled;
+    },
+    startCall: (...a) => impl.startCall(...a),
+    startSpan: (...a) => impl.startSpan(...a),
+    traceparent: (...a) => impl.traceparent(...a),
+    log: (...a) => impl.log(...a),
+    count: (...a) => impl.count(...a),
+    gauge: (...a) => impl.gauge(...a),
+    shutdown: () => impl.shutdown()
+};
+/** Installs a telemetry implementation (tests). */
+function setTelemetry(t) {
+    impl = t;
+}
+/** Starts telemetry with the config's endpoint, once the config is loaded. */
+function startTelemetry(config) {
+    impl = (0, common_1.initTelemetry)("fonoster-autopilot", undefined, (0, common_1.telemetryEnv)(config));
+}

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 agent 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 agent 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";

package/dist/voice/index.js

@@ -32,5 +32,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-__exportStar(require("./Voice"), exports);
 __exportStar(require("./types"), exports);

package/dist/voice/types.d.ts

@@ -16,33 +16,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { AudioFilterConfig } from "@fonoster/common";
-type GatherStream = {
-    stop: () => Promise<void>;
-    onData: (cb: (payload: {
-        speech: string;
-        responseTime: number;
-    }) => void) => void;
-};
-type Stream = {
-    stop: () => Promise<void>;
-    onData: (cb: (chunk: Uint8Array) => void) => void;
-};
 type TransferOptions = {
     timeout?: number;
     record?: boolean;
 };
+/**
+ * The call controls the LangChain models' built-in tools (hangup, transfer) use. Only the
+ * evaluations (createEvaluateIntelligence) drive these models now, with a stand-in; the hosted
+ * engine in ../session talks to the session SDK instead.
+ */
 type Voice = {
-    mediaSessionRef: string;
     answer: () => Promise<void>;
-    setAudioFilters: (filters: AudioFilterConfig[]) => Promise<void>;
     hangup: () => Promise<void>;
     say: (text: string) => Promise<void>;
     playDtmf: (dtmf: string) => Promise<void>;
-    sgather: () => Promise<GatherStream>;
     transfer: (destination: string, options?: TransferOptions) => Promise<void>;
-    stream: () => Promise<Stream>;
-    stopSpeech: () => Promise<void>;
-    stopStreams: () => Promise<void>;
 };
 export { TransferOptions, Voice };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fonoster/autopilot",
-  "version": "0.27.0",
+  "version": "0.31.0",
   "description": "Voice AI for the Fonoster platform",
   "author": "Pedro Sanders <psanders@fonoster.com>",
   "homepage": "https://github.com/fonoster/fonoster#readme",
@@ -14,13 +14,11 @@
   "scripts": {
     "prebuild": "rimraf ./dist tsconfig.tsbuildinfo",
     "build": "tsc -b tsconfig.json",
-    "clean": "rimraf ./dist node_modules tsconfig.tsbuildinfo",
-    "generate:readme": "node ../../.scripts/gen-readme.cjs",
-    "start:dev": "nodemon --exec tsx --watch src src/server.ts"
+    "generate:readme": "fonoster-readme",
+    "start:hosted": "node dist/session/main.js"
   },
   "files": [
-    "dist",
-    "silero_vad.onnx"
+    "dist"
   ],
   "publishConfig": {
     "access": "public"
@@ -35,11 +33,12 @@
   "dependencies": {
     "@aws-sdk/client-s3": "^3.958.0",
     "@dmitryrechkin/json-schema-to-zod": "^1.0.1",
-    "@fonoster/common": "^0.27.0",
-    "@fonoster/logger": "^0.27.0",
-    "@fonoster/sdk": "^0.27.0",
-    "@fonoster/types": "^0.27.0",
-    "@fonoster/voice": "^0.27.0",
+    "@fonoster/common": "^0.31.0",
+    "@fonoster/community": "^0.31.0",
+    "@fonoster/logger": "^0.31.0",
+    "@fonoster/types": "^0.31.0",
+    "@fonoster/voice": "^0.31.0",
+    "@grpc/grpc-js": "~1.14.6",
     "@langchain/anthropic": "^1.3.3",
     "@langchain/community": "^1.1.1",
     "@langchain/core": "^1.1.8",
@@ -49,15 +48,15 @@
     "@langchain/openai": "^1.2.0",
     "@langchain/textsplitters": "^1.0.1",
     "cheerio": "^1.1.2",
-    "dotenv": "^16.6.1",
     "js-yaml": "^4.1.1",
     "langchain": "^1.2.3",
-    "moment": "^2.30.1",
-    "onnxruntime-node": "1.21.1",
     "pdf-parse": "^1.1.1",
-    "uuid": "^11.0.3",
+    "undici": "^7.30.1",
     "xstate": "^5.17.3",
     "zod": "^3.25.76"
   },
-  "gitHead": "1191b34677b51a36000177887ff82303ef2693e1"
+  "gitHead": "f0a5102dddeea0f70f659234108805bc10690f2e",
+  "devDependencies": {
+    "yaml": "^2.9.0"
+  }
 }

package/dist/Autopilot.d.ts

@@ -1,14 +0,0 @@
-import { AutopilotParams } from "./types";
-declare class Autopilot {
-    private readonly params;
-    private readonly actor;
-    private vad;
-    constructor(params: AutopilotParams);
-    start(): Promise<void>;
-    stop(): void;
-    private setupAudioFilters;
-    private setupVoiceStream;
-    private handleVoicePayload;
-    private setupSpeechGathering;
-}
-export { Autopilot };