@fonoster/autopilot 0.30.0 → 0.31.0

package/dist/session/llm.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RegistryLlmResolver = exports.LlmResolutionError = exports.OPENAI_COMPATIBLE = exports.LayeredCredentials = exports.ConfigCredentials = void 0;
+exports.RegistryLlmResolver = exports.LlmResolutionError = exports.OPENAI_COMPATIBLE = exports.LayeredCredentials = exports.KeyUnavailableError = exports.ConfigCredentials = void 0;
+exports.resolveCredential = resolveCredential;
 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; } });
@@ -18,21 +19,58 @@ class ConfigCredentials {
     }
 }
 exports.ConfigCredentials = ConfigCredentials;
+/**
+ * A workspace's own key could not be read (its store failed). It never falls back to the platform
+ * key (remove-platform-key-fallback): the session ends with reason key_unavailable.
+ */
+class KeyUnavailableError extends Error {
+    constructor(ref, cause) {
+        super(`the workspace's key ${ref} could not be read: ${cause?.message ?? cause}`);
+        this.ref = ref;
+        this.reason = "key_unavailable";
+    }
+}
+exports.KeyUnavailableError = KeyUnavailableError;
 /** Workspace Secrets (BYOK) in front of platform credentials. */
 class LayeredCredentials {
     constructor(sources) {
         this.sources = sources;
     }
     async get(ref, scope) {
+        return (await this.resolve(ref, scope))?.key;
+    }
+    /**
+     * The first key found and whose it is (add-usage-metering): the operator's config holds the
+     * platform keys; every other source holds the workspace's own.
+     */
+    async resolve(ref, scope) {
         for (const s of this.sources) {
-            const v = await s.get(ref, scope);
-            if (v)
-                return v;
+            let key;
+            try {
+                key = await s.get(ref, scope);
+            }
+            catch (e) {
+                if (s instanceof ConfigCredentials)
+                    throw e;
+                throw new KeyUnavailableError(ref, e);
+            }
+            if (key)
+                return {
+                    key,
+                    source: s instanceof ConfigCredentials ? "platform" : "workspace"
+                };
         }
         return undefined;
     }
 }
 exports.LayeredCredentials = LayeredCredentials;
+/** A credential and its source; a source that cannot tell is the platform's. */
+async function resolveCredential(credentials, ref, scope) {
+    if (credentials instanceof LayeredCredentials)
+        return credentials.resolve(ref, scope);
+    const key = await credentials.get(ref, scope);
+    return key ? { key, source: "platform" } : undefined;
+}
 class LlmResolutionError extends Error {
 }
 exports.LlmResolutionError = LlmResolutionError;
@@ -59,14 +97,20 @@ class RegistryLlmResolver {
             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] ??
+            provider.endpoints?.llm ??
             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)
+        // A provider without a credentialRef is keyless (local models, the fakes).
+        const credential = provider.credentialRef
+            ? await resolveCredential(this.options.credentials, provider.credentialRef, scope)
+            : undefined;
+        const apiKey = credential?.key;
+        if (provider.credentialRef && !apiKey)
             throw new LlmResolutionError(`no credential ${provider.credentialRef} for provider ${provider.id}`);
         return {
             id,
+            keySource: credential?.source ?? "platform",
             think: llm.create({ baseUrl, apiKey }, id.slice(providerId.length + 1), settings),
             ...(resolution.event
                 ? {

package/dist/session/main.js

@@ -24,6 +24,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const common_1 = require("@fonoster/common");
 const logger_1 = require("@fonoster/logger");
 const hosted_1 = require("./hosted");
+const telemetry_1 = require("./telemetry");
 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).
@@ -37,7 +38,7 @@ if (!file) {
 }
 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, telemetry_1.startTelemetry)(config.telemetry);
 (0, hosted_1.startHostedAutopilot)(config).catch((e) => {
     logger.error(`hosted autopilot failed to start: ${e.message}`);
     process.exit(1);

package/dist/session/meteredThink.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 { Usage } from "@fonoster/common";
+import { Think, TokenUsage } from "@fonoster/community";
+/** Where a model's usage goes: Autopilot sends it to the call (usage.report). */
+export type UsageSink = {
+    usage(lines: Usage.UsageLine[]): void;
+    /** A completed request whose vendor reported no usage (add-usage-metering). */
+    missing(catalogId: string): void;
+};
+export type MeteredModel = {
+    /** The catalog id (`<provider>/<model>`). */
+    catalogId: string;
+    keySource: Usage.KeySource;
+};
+/** How long an interrupted reply is read in the background for its usage report (design D6). */
+export declare const DRAIN_DEADLINE_MS = 30000;
+export declare function usageLines(model: MeteredModel, usage: TokenUsage): Usage.UsageLine[];
+/**
+ * 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.
+ */
+export declare function meteredThink(inner: Think, model: MeteredModel, sink: UsageSink, options?: {
+    drainMs?: number;
+    closed?: AbortSignal;
+}): Think;

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

@@ -10,7 +10,7 @@ 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
+ * 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).
  */

package/dist/session/tools.js

@@ -22,7 +22,7 @@ exports.HttpToolPort = void 0;
 const url_1 = require("url");
 const common_1 = require("@fonoster/common");
 /**
- * HTTP tools from the assistant config (`operation.method`, `url`, `headers`). Tool URLs are
+ * 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).
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fonoster/autopilot",
-  "version": "0.30.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,8 +14,7 @@
   "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",
+    "generate:readme": "fonoster-readme",
     "start:hosted": "node dist/session/main.js"
   },
   "files": [
@@ -34,11 +33,11 @@
   "dependencies": {
     "@aws-sdk/client-s3": "^3.958.0",
     "@dmitryrechkin/json-schema-to-zod": "^1.0.1",
-    "@fonoster/common": "^0.30.0",
-    "@fonoster/community": "^0.30.0",
-    "@fonoster/logger": "^0.30.0",
-    "@fonoster/types": "^0.30.0",
-    "@fonoster/voice": "^0.30.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",
@@ -52,10 +51,11 @@
     "js-yaml": "^4.1.1",
     "langchain": "^1.2.3",
     "pdf-parse": "^1.1.1",
+    "undici": "^7.30.1",
     "xstate": "^5.17.3",
     "zod": "^3.25.76"
   },
-  "gitHead": "b59b06a3ef325abe3f188c0fb87cc22d50ed5471",
+  "gitHead": "f0a5102dddeea0f70f659234108805bc10690f2e",
   "devDependencies": {
     "yaml": "^2.9.0"
   }

package/dist/session/convertLegacyAssistant.d.ts

@@ -1,77 +0,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.
- */
-import { SessionAssistant } from "./config";
-type Legacy = {
-    conversationSettings?: Record<string, unknown> & {
-        maxSpeechWaitTimeout?: number;
-        vad?: unknown;
-        transferOptions?: {
-            phoneNumber: string;
-            message: string;
-            timeout?: number;
-        };
-    };
-    languageModel?: Record<string, unknown> & {
-        provider?: string;
-        model?: string;
-        apiKey?: string;
-        baseUrl?: string;
-    };
-    eventsHook?: {
-        url: string;
-        events?: string[];
-        headers?: Record<string, string>;
-    };
-    audioFilters?: unknown;
-    testCases?: unknown;
-};
-/**
- * VAD-era settings → the patience knob (add-turn-taking 3.2, AP-B3). maxSpeechWaitTimeout was
- * extra waiting after the caller's speech before answering; 0 (the old default) is today's
- * behaviour, normal. Any extra wait becomes high (about 1.6 × the gateway's silence timeout, and
- * more as the gateway adapts to a caller who pauses). Nothing maps to low: the old settings had
- * no way to answer faster than the default. allowUserBargeIn keeps its meaning: it sets
- * `interruptible` on every speak and whether Autopilot sends clear on turn.user_started.
- */
-export declare function patienceFor(maxSpeechWaitTimeout?: number): "low" | "normal" | "high";
-export type AssistantConversion = {
-    assistant: SessionAssistant;
-    /**
-     * An inline key to store as the workspace's key for `providerId` (the config no longer holds
-     * it). The migration job binds it like the dashboard's Vendor keys page does (a Secret named
-     * `provider-key/<provider>` in workspace_provider_keys), which is where the registry's
-     * credentialRef lookup finds workspace keys (AP-B4, LG-B1).
-     */
-    secret?: {
-        providerId: string;
-        name: string;
-        value: string;
-    };
-    /** The retired eventsHook URL, for creating a workspace webhook endpoint. */
-    webhook?: {
-        url: string;
-    };
-    /** Audio filters that now belong in the app's configuration. */
-    appFilters?: unknown;
-    notices: string[];
-};
-export declare function convertLegacyAssistant(old: Legacy, options: {
-    assistantRef: string;
-}): AssistantConversion;
-export {};

package/dist/session/convertLegacyAssistant.js

@@ -1,118 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.patienceFor = patienceFor;
-exports.convertLegacyAssistant = convertLegacyAssistant;
-/**
- * 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 config_1 = require("./config");
-// The one-time conversion of stored assistants at cutover (owner decision, rework-autopilot 5.3).
-// It never writes anything itself: it returns the new config plus what the migration job must do
-// around it (create a workspace Secret, a webhook endpoint, app audio filters) and notices for the
-// workspace.
-const PROVIDERS = ["openai", "groq", "ollama", "google", "anthropic"];
-const PLACEHOLDER_KEYS = new Set(["", "your-api-key", "changeme", "xxx"]);
-/**
- * VAD-era settings → the patience knob (add-turn-taking 3.2, AP-B3). maxSpeechWaitTimeout was
- * extra waiting after the caller's speech before answering; 0 (the old default) is today's
- * behaviour, normal. Any extra wait becomes high (about 1.6 × the gateway's silence timeout, and
- * more as the gateway adapts to a caller who pauses). Nothing maps to low: the old settings had
- * no way to answer faster than the default. allowUserBargeIn keeps its meaning: it sets
- * `interruptible` on every speak and whether Autopilot sends clear on turn.user_started.
- */
-function patienceFor(maxSpeechWaitTimeout) {
-    return (maxSpeechWaitTimeout ?? 0) > 0 ? "high" : "normal";
-}
-const DEFAULT_VAD = {
-    activationThreshold: 0.4,
-    deactivationThreshold: 0.25,
-    debounceFrames: 4
-};
-function isDefaultVad(vad) {
-    if (!vad || typeof vad !== "object")
-        return true;
-    const v = vad;
-    return Object.keys(DEFAULT_VAD).every((k) => v[k] === undefined || v[k] === DEFAULT_VAD[k]);
-}
-function convertLegacyAssistant(old, options) {
-    const notices = [];
-    const lm = { ...(old.languageModel ?? {}) };
-    const cs = { ...(old.conversationSettings ?? {}) };
-    const result = { notices };
-    const provider = String(lm.provider ?? "");
-    if (!PROVIDERS.includes(provider))
-        throw new Error(`unknown language model provider "${provider}"`);
-    const model = `${provider}/${lm.model}`;
-    if (typeof lm.apiKey === "string" &&
-        !PLACEHOLDER_KEYS.has(lm.apiKey.trim())) {
-        void options.assistantRef;
-        result.secret = {
-            providerId: provider,
-            name: `provider-key/${provider}`,
-            value: lm.apiKey
-        };
-        notices.push(`The ${provider} key moved out of the assistant into the workspace's ${provider} vendor key (Secret "${result.secret.name}").`);
-    }
-    if (lm.baseUrl) {
-        notices.push(`The custom model endpoint ${lm.baseUrl} was removed; endpoints now come from the provider registry.`);
-    }
-    const patience = patienceFor(cs.maxSpeechWaitTimeout);
-    if (patience !== "normal") {
-        notices.push(`maxSpeechWaitTimeout (${cs.maxSpeechWaitTimeout} ms) became patience "${patience}"; turn timing now comes from the gateway.`);
-    }
-    if (cs.vad !== undefined && !isDefaultVad(cs.vad))
-        notices.push("Custom VAD settings were removed; turn detection now runs in the gateway. For noisy lines use the app's audio filters or a more patient setting.");
-    if (cs.transferOptions?.timeout !== undefined &&
-        cs.transferOptions.timeout !== 30000) {
-        notices.push(`The transfer timeout (${cs.transferOptions.timeout} ms) is no longer configurable per assistant.`);
-    }
-    if (old.eventsHook?.url) {
-        result.webhook = { url: old.eventsHook.url };
-        notices.push(`Assistant webhooks are retired; create a workspace webhook for ${old.eventsHook.url} (call.started, call.ended, call_record.sealed).`);
-    }
-    if (old.audioFilters !== undefined) {
-        result.appFilters = old.audioFilters;
-        notices.push("Audio filters moved to the app's configuration.");
-    }
-    const { maxSpeechWaitTimeout, vad, transferOptions, ...settings } = cs;
-    void vad;
-    void maxSpeechWaitTimeout;
-    const assistant = config_1.sessionAssistantSchema.parse({
-        conversationSettings: {
-            ...settings,
-            ...(transferOptions
-                ? {
-                    transferOptions: {
-                        phoneNumber: transferOptions.phoneNumber,
-                        message: transferOptions.message
-                    }
-                }
-                : {}),
-            ...(patience !== "normal" ? { patience } : {})
-        },
-        languageModel: {
-            model,
-            temperature: lm.temperature,
-            maxTokens: lm.maxTokens,
-            tools: lm.tools,
-            knowledgeBase: lm.knowledgeBase
-        },
-        ...(old.testCases !== undefined ? { testCases: old.testCases } : {})
-    });
-    return { ...result, assistant };
-}