@ouro.bot/cli 0.1.0-alpha.563 → 0.1.0-alpha.565

package/changelog.json

@@ -1,6 +1,22 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.565",
+      "changes": [
+        "Voice shared-turn readback now recovers tool-required `settle` and `speak` deliveries from acknowledged tool calls instead of treating null assistant content as an empty response.",
+        "Twilio phone calls now start a real agent voice turn for the call-connected greeting, so the agent greets through the voice channel rather than a hardcoded transport prompt.",
+        "Twilio phone no-speech transcripts such as `[BLANK_AUDIO]` now become agent-authored voice reprompts instead of being passed through as caller speech."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.564",
+      "changes": [
+        "Voice now keeps Twilio phone as a transport under the canonical `voice` sense, with configurable agent-scoped webhook paths such as `/voice/agents/slugger/twilio/incoming`.",
+        "The managed Voice entrypoint now starts the Twilio phone bridge when this machine has a public voice URL, sharing the same Whisper.cpp STT, voice session, and ElevenLabs TTS code as the standalone local smoke bridge.",
+        "Voice setup docs, daemon status, connect guidance, and tests now cover managed Twilio transport readiness while keeping the one-off standalone Twilio bridge available for local smoke testing."
+      ]
+    },
     {
       "version": "0.1.0-alpha.563",
       "changes": [

package/dist/heart/daemon/cli-exec.js

@@ -4274,6 +4274,7 @@ function connectMenuTarget(answer) {
     return "cancel";
 }
 async function executeConnectVoice(agent, deps) {
+    const agentPathSegment = agent.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
     const message = [
         `Voice foundation for ${agent}`,
         "Configure portable ElevenLabs settings with:",
@@ -4282,15 +4283,16 @@ async function executeConnectVoice(agent, deps) {
         "Configure this machine's Whisper.cpp attachment with:",
         `  ouro vault config set --agent ${agent} --scope machine --key voice.whisperCliPath`,
         `  ouro vault config set --agent ${agent} --scope machine --key voice.whisperModelPath`,
-        "Optional Twilio phone testing setup:",
+        "Optional managed Twilio phone transport setup:",
         `  ouro vault config set --agent ${agent} --key voice.twilioAccountSid`,
         `  ouro vault config set --agent ${agent} --key voice.twilioAuthToken`,
         `  ouro vault config set --agent ${agent} --scope machine --key voice.twilioPublicUrl`,
+        `  ouro vault config set --agent ${agent} --scope machine --key voice.twilioBasePath --value /voice/agents/${agentPathSegment}/twilio`,
         `  ouro vault config set --agent ${agent} --scope machine --key voice.twilioPort --value 18910`,
         `  ouro vault config set --agent ${agent} --scope machine --key voice.twilioDefaultFriendId --value ari`,
-        `  node dist/senses/voice-twilio-entry.js --agent ${agent} --port 18910 --public-url https://<cloudflare-tunnel>`,
-        `Set the Twilio number's Voice webhook to POST https://<cloudflare-tunnel>/voice/twilio/incoming.`,
         "Then enable agent.json: senses.voice.enabled = true and restart with `ouro up`.",
+        `The managed Voice entrypoint will listen at POST <public-url>/voice/agents/${agentPathSegment}/twilio/incoming.`,
+        `Standalone local smoke remains available with: node dist/senses/voice-twilio-entry.js --agent ${agent} --port 18910 --public-url https://<cloudflare-tunnel>.`,
         "Meeting links use URL intake plus BlackHole/Multi-Output readiness checks. Phone testing uses Twilio Record -> Whisper.cpp -> voice session -> ElevenLabs -> Twilio Play.",
     ].join("\n");
     deps.writeStdout(message);

package/dist/heart/daemon/sense-manager.js

@@ -204,8 +204,14 @@ function senseFactsFromRuntimeConfig(agent, senses, runtimeConfig, machineRuntim
             missing.push("voice.whisperCliPath");
         if (!textField(voice, "whisperModelPath"))
             missing.push("voice.whisperModelPath");
+        const twilioPublicUrl = textField(voice, "twilioPublicUrl");
         base.voice = missing.length === 0
-            ? { configured: true, detail: "local Whisper.cpp STT + ElevenLabs TTS" }
+            ? {
+                configured: true,
+                detail: twilioPublicUrl
+                    ? "local Whisper.cpp STT + ElevenLabs TTS; Twilio phone transport attached"
+                    : "local Whisper.cpp STT + ElevenLabs TTS",
+            }
             : {
                 configured: false,
                 optional: !machineRuntimeConfig.ok && machineRuntimeConfig.reason === "missing",

package/dist/senses/shared-turn.js

@@ -61,6 +61,10 @@ const pipeline_1 = require("./pipeline");
 const mcp_manager_1 = require("../repertoire/mcp-manager");
 const runtime_1 = require("../nerves/runtime");
 const RESPONSE_CAP = 50_000;
+const DELIVERY_TOOL_ACKS = new Map([
+    ["settle", "(delivered)"],
+    ["speak", "(spoken)"],
+]);
 /**
  * Strip MiniMax-style `<think>...</think>` reasoning blocks from a response
  * string. Handles unclosed open tags (treats everything from `<think>` to
@@ -84,6 +88,78 @@ function stripThinkBlocks(input) {
     }
     return out.trim();
 }
+function assistantContentText(content) {
+    if (typeof content !== "string")
+        return null;
+    const trimmed = content.trim();
+    return trimmed ? trimmed : null;
+}
+function parseToolStringArg(toolCall, toolName, argName) {
+    if (!toolCall || typeof toolCall !== "object")
+        return null;
+    const fn = toolCall.function;
+    if (fn?.name !== toolName || typeof fn.arguments !== "string")
+        return null;
+    try {
+        const parsed = JSON.parse(fn.arguments);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return null;
+        const value = parsed[argName];
+        if (typeof value !== "string")
+            return null;
+        const trimmed = value.trim();
+        return trimmed ? trimmed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function hasDeliveredToolResult(messages, assistantIndex, toolCallId, toolName) {
+    if (typeof toolCallId !== "string" || !toolCallId.trim())
+        return false;
+    const expectedAck = DELIVERY_TOOL_ACKS.get(toolName);
+    for (let index = assistantIndex + 1; index < messages.length; index++) {
+        const message = messages[index];
+        if (message.role !== "tool")
+            return false;
+        if (message.tool_call_id === toolCallId
+            && typeof message.content === "string"
+            && message.content.trim() === expectedAck) {
+            return true;
+        }
+    }
+    return false;
+}
+function deliveredTextFromAssistantTools(messages, assistantIndex) {
+    const assistant = messages[assistantIndex];
+    if (!Array.isArray(assistant.tool_calls))
+        return null;
+    const delivered = [];
+    for (let index = 0; index < assistant.tool_calls.length; index++) {
+        const toolCall = assistant.tool_calls[index];
+        const toolCallId = toolCall && typeof toolCall === "object"
+            ? toolCall.id
+            : undefined;
+        const settleAnswer = parseToolStringArg(toolCall, "settle", "answer");
+        if (settleAnswer && hasDeliveredToolResult(messages, assistantIndex, toolCallId, "settle")) {
+            delivered.push(settleAnswer);
+            continue;
+        }
+        const spokenMessage = parseToolStringArg(toolCall, "speak", "message");
+        if (spokenMessage && hasDeliveredToolResult(messages, assistantIndex, toolCallId, "speak")) {
+            delivered.push(spokenMessage);
+        }
+    }
+    return delivered.length > 0 ? delivered.join("\n") : null;
+}
+function responseFromSessionMessages(messages) {
+    const assistantIndex = messages.findLastIndex((message) => message.role === "assistant");
+    if (assistantIndex < 0)
+        return null;
+    const assistant = messages[assistantIndex];
+    return assistantContentText(assistant.content)
+        ?? deliveredTextFromAssistantTools(messages, assistantIndex);
+}
 /**
  * Run a single agent turn through the inbound pipeline.
  * Caller provides channel, session key, friend, and message;
@@ -203,13 +279,8 @@ async function runSenseTurn(options) {
             await persistPromise;
         const postTurnSession = (0, context_1.loadSession)(sessPath);
         if (postTurnSession?.messages) {
-            const lastAssistant = [...postTurnSession.messages].reverse().find(m => m.role === "assistant");
-            if (lastAssistant && typeof lastAssistant.content === "string" && lastAssistant.content.trim()) {
-                finalResponse = lastAssistant.content;
-            }
-            else {
-                finalResponse = "(agent responded but response was empty)";
-            }
+            finalResponse = responseFromSessionMessages(postTurnSession.messages)
+                ?? "(agent responded but response was empty)";
         }
         else {
             finalResponse = "(agent responded but response was empty)";

package/dist/senses/voice/index.js

@@ -25,3 +25,4 @@ __exportStar(require("./audio-routing"), exports);
 __exportStar(require("./playback"), exports);
 __exportStar(require("./golden-path"), exports);
 __exportStar(require("./twilio-phone"), exports);
+__exportStar(require("./twilio-phone-runtime"), exports);

package/dist/senses/voice/twilio-phone-runtime.js

@@ -0,0 +1,282 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentScopedTwilioPhoneBasePath = agentScopedTwilioPhoneBasePath;
+exports.resolveTwilioPhoneTransportRuntime = resolveTwilioPhoneTransportRuntime;
+exports.startConfiguredTwilioPhoneTransport = startConfiguredTwilioPhoneTransport;
+exports.closeTwilioPhoneBridgeServer = closeTwilioPhoneBridgeServer;
+const path = __importStar(require("path"));
+const identity_1 = require("../../heart/identity");
+const machine_identity_1 = require("../../heart/machine-identity");
+const provider_credentials_1 = require("../../heart/provider-credentials");
+const runtime_credentials_1 = require("../../heart/runtime-credentials");
+const runtime_1 = require("../../nerves/runtime");
+const elevenlabs_1 = require("./elevenlabs");
+const twilio_phone_1 = require("./twilio-phone");
+const whisper_1 = require("./whisper");
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function configString(config, dottedPath) {
+    let cursor = config;
+    for (const segment of dottedPath.split(".")) {
+        const record = asRecord(cursor);
+        if (!record)
+            return undefined;
+        cursor = record[segment];
+    }
+    return typeof cursor === "string" && cursor.trim() ? cursor.trim() : undefined;
+}
+function configNumber(config, dottedPath) {
+    let cursor = config;
+    for (const segment of dottedPath.split(".")) {
+        const record = asRecord(cursor);
+        if (!record)
+            return undefined;
+        cursor = record[segment];
+    }
+    if (typeof cursor === "number" && Number.isFinite(cursor))
+        return cursor;
+    if (typeof cursor === "string" && cursor.trim()) {
+        const parsed = Number(cursor);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+}
+function configBoolean(config, dottedPath) {
+    let cursor = config;
+    for (const segment of dottedPath.split(".")) {
+        const record = asRecord(cursor);
+        if (!record)
+            return undefined;
+        cursor = record[segment];
+    }
+    if (typeof cursor === "boolean")
+        return cursor;
+    if (typeof cursor === "string") {
+        const normalized = cursor.trim().toLowerCase();
+        if (normalized === "true")
+            return true;
+        if (normalized === "false")
+            return false;
+    }
+    return undefined;
+}
+function requireConfig(result, label) {
+    if (result.ok)
+        return result.config;
+    throw new Error(`${label} unavailable: ${result.error}`);
+}
+function required(value, guidance) {
+    if (value)
+        return value;
+    throw new Error(guidance);
+}
+function selectedAgentProviders(config) {
+    const providers = new Set();
+    providers.add(config.humanFacing.provider);
+    providers.add(config.agentFacing.provider);
+    if (config.provider)
+        providers.add(config.provider);
+    return [...providers];
+}
+async function cacheSelectedProviderCredentials(agentName) {
+    const providers = selectedAgentProviders((0, identity_1.loadAgentConfig)());
+    const pool = await (0, provider_credentials_1.refreshProviderCredentialPool)(agentName, { providers });
+    if (!pool.ok) {
+        throw new Error(`provider credentials unavailable for phone voice: ${pool.error}`);
+    }
+    const missing = providers.filter((provider) => !pool.pool.providers[provider]);
+    if (missing.length > 0) {
+        throw new Error(`missing provider credentials for phone voice: ${missing.join(", ")}`);
+    }
+}
+function agentPathSegment(agentName) {
+    return agentName.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
+}
+function trimOptional(value) {
+    return value?.trim() || undefined;
+}
+function agentScopedTwilioPhoneBasePath(agentName) {
+    return `/voice/agents/${agentPathSegment(agentName)}/twilio`;
+}
+function resolveTwilioPhoneTransportRuntime(options) {
+    const overrides = options.overrides ?? {};
+    const configuredPublicBaseUrl = trimOptional(overrides.publicBaseUrl)
+        ?? configString(options.machineConfig, "voice.twilioPublicUrl");
+    const explicitEnabled = overrides.enabled ?? configBoolean(options.machineConfig, "voice.twilioEnabled");
+    if (!configuredPublicBaseUrl && options.requirePublicUrl) {
+        throw new Error("missing voice.twilioPublicUrl in this machine's runtime config");
+    }
+    const enabled = explicitEnabled ?? !!configuredPublicBaseUrl;
+    if (!enabled) {
+        return { status: "disabled", reason: "voice.twilioPublicUrl is not configured" };
+    }
+    if (!configuredPublicBaseUrl) {
+        throw new Error("missing voice.twilioPublicUrl in this machine's runtime config");
+    }
+    const publicUrl = new URL(configuredPublicBaseUrl);
+    if (publicUrl.protocol !== "https:") {
+        throw new Error("voice.twilioPublicUrl must be an https URL");
+    }
+    const publicBaseUrl = publicUrl.toString();
+    const basePath = (0, twilio_phone_1.normalizeTwilioPhoneBasePath)(overrides.basePath
+        ?? configString(options.machineConfig, "voice.twilioBasePath")
+        ?? options.defaultBasePath
+        ?? twilio_phone_1.TWILIO_PHONE_WEBHOOK_BASE_PATH);
+    const elevenLabsApiKey = required(configString(options.runtimeConfig, "integrations.elevenLabsApiKey"), "missing integrations.elevenLabsApiKey; run 'ouro connect voice --agent <agent>' for setup guidance");
+    const elevenLabsVoiceId = required(trimOptional(overrides.elevenLabsVoiceId)
+        ?? configString(options.runtimeConfig, "integrations.elevenLabsVoiceId")
+        ?? configString(options.runtimeConfig, "voice.elevenLabsVoiceId"), "missing integrations.elevenLabsVoiceId; save the ElevenLabs voice ID before starting phone voice");
+    const whisperCliPath = required(trimOptional(overrides.whisperCliPath)
+        ?? configString(options.machineConfig, "voice.whisperCliPath"), "missing voice.whisperCliPath in this machine's runtime config");
+    const whisperModelPath = required(trimOptional(overrides.whisperModelPath)
+        ?? configString(options.machineConfig, "voice.whisperModelPath"), "missing voice.whisperModelPath in this machine's runtime config");
+    const outputDir = trimOptional(overrides.outputDir)
+        ?? configString(options.machineConfig, "voice.twilioOutputDir")
+        ?? path.join((0, identity_1.getAgentRoot)(options.agentName), "state", "voice", "twilio-phone");
+    const settings = {
+        agentName: options.agentName,
+        publicBaseUrl,
+        basePath,
+        webhookUrl: (0, twilio_phone_1.twilioPhoneWebhookUrl)(publicBaseUrl, basePath),
+        outputDir,
+        port: overrides.port
+            ?? configNumber(options.machineConfig, "voice.twilioPort")
+            ?? twilio_phone_1.DEFAULT_TWILIO_PHONE_PORT,
+        host: trimOptional(overrides.host)
+            ?? configString(options.machineConfig, "voice.twilioHost")
+            ?? "127.0.0.1",
+        elevenLabsApiKey,
+        elevenLabsVoiceId,
+        whisperCliPath,
+        whisperModelPath,
+        twilioAccountSid: configString(options.runtimeConfig, "voice.twilioAccountSid"),
+        twilioAuthToken: configString(options.runtimeConfig, "voice.twilioAuthToken"),
+        defaultFriendId: trimOptional(overrides.defaultFriendId)
+            ?? configString(options.machineConfig, "voice.twilioDefaultFriendId"),
+        recordTimeoutSeconds: overrides.recordTimeoutSeconds
+            ?? configNumber(options.machineConfig, "voice.twilioRecordTimeoutSeconds")
+            ?? twilio_phone_1.DEFAULT_TWILIO_RECORD_TIMEOUT_SECONDS,
+        recordMaxLengthSeconds: overrides.recordMaxLengthSeconds
+            ?? configNumber(options.machineConfig, "voice.twilioRecordMaxLengthSeconds")
+            ?? twilio_phone_1.DEFAULT_TWILIO_RECORD_MAX_LENGTH_SECONDS,
+    };
+    return { status: "configured", settings };
+}
+const defaultTwilioPhoneTransportRuntimeDeps = {
+    waitForRuntimeCredentialBootstrap: runtime_credentials_1.waitForRuntimeCredentialBootstrap,
+    loadMachineIdentity: machine_identity_1.loadOrCreateMachineIdentity,
+    refreshRuntimeConfig: runtime_credentials_1.refreshRuntimeCredentialConfig,
+    refreshMachineRuntimeConfig: runtime_credentials_1.refreshMachineRuntimeCredentialConfig,
+    readRuntimeConfig: runtime_credentials_1.readRuntimeCredentialConfig,
+    readMachineRuntimeConfig: runtime_credentials_1.readMachineRuntimeCredentialConfig,
+    cacheSelectedProviderCredentials,
+    createTranscriber: whisper_1.createWhisperCppTranscriber,
+    createTts: elevenlabs_1.createElevenLabsTtsClient,
+    startBridgeServer: twilio_phone_1.startTwilioPhoneBridgeServer,
+};
+async function startConfiguredTwilioPhoneTransport(options, deps = defaultTwilioPhoneTransportRuntimeDeps) {
+    await deps.waitForRuntimeCredentialBootstrap(options.agentName);
+    const machine = deps.loadMachineIdentity();
+    await Promise.all([
+        deps.refreshRuntimeConfig(options.agentName, { preserveCachedOnFailure: true }).catch(() => undefined),
+        deps.refreshMachineRuntimeConfig(options.agentName, machine.machineId, { preserveCachedOnFailure: true }).catch(() => undefined),
+    ]);
+    const runtimeConfig = requireConfig(deps.readRuntimeConfig(options.agentName), "portable runtime/config");
+    const machineConfig = requireConfig(deps.readMachineRuntimeConfig(options.agentName), "machine runtime config");
+    const resolution = resolveTwilioPhoneTransportRuntime({
+        agentName: options.agentName,
+        runtimeConfig,
+        machineConfig,
+        overrides: options.overrides,
+        defaultBasePath: options.defaultBasePath,
+        requirePublicUrl: options.requirePublicUrl,
+    });
+    if (resolution.status === "disabled") {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_twilio_transport_disabled",
+            message: "Twilio phone voice transport is not attached on this machine",
+            meta: { agentName: options.agentName, reason: resolution.reason },
+        });
+        return resolution;
+    }
+    await deps.cacheSelectedProviderCredentials(options.agentName);
+    const settings = resolution.settings;
+    const transcriber = deps.createTranscriber({
+        whisperCliPath: settings.whisperCliPath,
+        modelPath: settings.whisperModelPath,
+    });
+    const tts = deps.createTts({
+        apiKey: settings.elevenLabsApiKey,
+        voiceId: settings.elevenLabsVoiceId,
+        outputFormat: "mp3_44100_128",
+    });
+    const bridge = await deps.startBridgeServer({
+        agentName: settings.agentName,
+        publicBaseUrl: settings.publicBaseUrl,
+        basePath: settings.basePath,
+        outputDir: settings.outputDir,
+        transcriber,
+        tts,
+        port: settings.port,
+        host: settings.host,
+        twilioAccountSid: settings.twilioAccountSid,
+        twilioAuthToken: settings.twilioAuthToken,
+        defaultFriendId: settings.defaultFriendId,
+        recordTimeoutSeconds: settings.recordTimeoutSeconds,
+        recordMaxLengthSeconds: settings.recordMaxLengthSeconds,
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_twilio_transport_ready",
+        message: "Twilio phone voice transport is ready",
+        meta: {
+            agentName: settings.agentName,
+            localUrl: bridge.localUrl,
+            publicBaseUrl: settings.publicBaseUrl,
+            basePath: settings.basePath,
+            webhookUrl: settings.webhookUrl,
+        },
+    });
+    return { status: "started", settings, bridge };
+}
+function closeTwilioPhoneBridgeServer(server) {
+    return new Promise((resolve, reject) => {
+        ;
+        server.server.close((error) => error ? reject(error) : resolve());
+    });
+}

package/dist/senses/voice/twilio-phone.js

@@ -34,6 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TWILIO_PHONE_WEBHOOK_BASE_PATH = exports.DEFAULT_TWILIO_RECORD_MAX_LENGTH_SECONDS = exports.DEFAULT_TWILIO_RECORD_TIMEOUT_SECONDS = exports.DEFAULT_TWILIO_PHONE_PORT = void 0;
+exports.normalizeTwilioPhoneBasePath = normalizeTwilioPhoneBasePath;
+exports.twilioPhoneWebhookUrl = twilioPhoneWebhookUrl;
 exports.computeTwilioSignature = computeTwilioSignature;
 exports.validateTwilioSignature = validateTwilioSignature;
 exports.twilioRecordingMediaUrl = twilioRecordingMediaUrl;
@@ -46,6 +48,7 @@ const http = __importStar(require("http"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
 const playback_1 = require("./playback");
+const transcript_1 = require("./transcript");
 const turn_1 = require("./turn");
 exports.DEFAULT_TWILIO_PHONE_PORT = 18910;
 exports.DEFAULT_TWILIO_RECORD_TIMEOUT_SECONDS = 2;
@@ -112,14 +115,29 @@ function escapeXml(input) {
 function routeUrl(publicBaseUrl, route) {
     return new URL(route, publicBaseUrl).toString();
 }
+function normalizeTwilioPhoneBasePath(value = exports.TWILIO_PHONE_WEBHOOK_BASE_PATH) {
+    const trimmed = value.trim();
+    const withLeadingSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+    const withoutTrailingSlash = withLeadingSlash.replace(/\/+$/, "");
+    if (!withoutTrailingSlash || withoutTrailingSlash === "/") {
+        throw new Error("Twilio phone webhook base path is empty");
+    }
+    if (!/^\/[A-Za-z0-9._~/-]+$/.test(withoutTrailingSlash) || withoutTrailingSlash.includes("//")) {
+        throw new Error(`invalid Twilio phone webhook base path: ${value}`);
+    }
+    return withoutTrailingSlash;
+}
+function twilioPhoneWebhookUrl(publicBaseUrl, basePath = exports.TWILIO_PHONE_WEBHOOK_BASE_PATH) {
+    return routeUrl(publicBaseUrl, `${normalizeTwilioPhoneBasePath(basePath)}/incoming`);
+}
 function requestPublicUrl(publicBaseUrl, requestPath) {
     return routeUrl(publicBaseUrl, requestPath);
 }
 function recordTwiml(options) {
-    return `<Record action="${escapeXml(routeUrl(options.publicBaseUrl, `${exports.TWILIO_PHONE_WEBHOOK_BASE_PATH}/recording`))}" method="POST" playBeep="false" timeout="${options.timeoutSeconds}" maxLength="${options.maxLengthSeconds}" trim="trim-silence" />`;
+    return `<Record action="${escapeXml(routeUrl(options.publicBaseUrl, `${options.basePath}/recording`))}" method="POST" playBeep="false" timeout="${options.timeoutSeconds}" maxLength="${options.maxLengthSeconds}" trim="trim-silence" />`;
 }
-function redirectTwiml(publicBaseUrl) {
-    return `<Redirect method="POST">${escapeXml(routeUrl(publicBaseUrl, `${exports.TWILIO_PHONE_WEBHOOK_BASE_PATH}/listen`))}</Redirect>`;
+function redirectTwiml(publicBaseUrl, basePath) {
+    return `<Redirect method="POST">${escapeXml(routeUrl(publicBaseUrl, `${basePath}/listen`))}</Redirect>`;
 }
 function sayTwiml(message) {
     return `<Say>${escapeXml(message)}</Say>`;
@@ -158,6 +176,34 @@ function friendIdFromCaller(from, callSid) {
     const phoneish = from.replace(/[^0-9A-Za-z]+/g, "");
     return phoneish ? `twilio-${phoneish}` : `twilio-${safeSegment(callSid)}`;
 }
+function voiceFriendId(options, from, callSid) {
+    return options.defaultFriendId?.trim() || friendIdFromCaller(from, callSid);
+}
+function callConnectedPrompt(params) {
+    const from = params.From?.trim();
+    const to = params.To?.trim();
+    return [
+        "A Twilio phone voice call just connected.",
+        "This is the first audible turn in the call.",
+        from ? `Twilio caller ID: ${from}.` : "Twilio did not provide caller ID.",
+        to ? `Dialed line: ${to}.` : "Twilio did not provide the dialed line.",
+        "Respond through the voice channel as yourself. Greet the caller naturally and briefly, then invite them to speak.",
+    ].join("\n");
+}
+function noSpeechPrompt() {
+    return [
+        "The last Twilio phone recording contained no intelligible speech.",
+        "The caller is still on the line.",
+        "Respond through the voice channel as yourself. Briefly ask them to try again or check whether they are there.",
+    ].join("\n");
+}
+function isNoSpeechTranscript(text) {
+    const normalized = text.trim().replace(/[.!?]+$/g, "").toUpperCase();
+    return normalized === "[BLANK_AUDIO]"
+        || normalized === "BLANK_AUDIO"
+        || normalized === "[NO_SPEECH]"
+        || normalized === "NO_SPEECH";
+}
 function parseRecordingParams(params) {
     const callSid = params.CallSid?.trim();
     const recordingSid = params.RecordingSid?.trim();
@@ -171,16 +217,53 @@ function parseRecordingParams(params) {
         from: params.From?.trim() ?? "",
     };
 }
-function recordAgainResponse(publicBaseUrl, message) {
+function recordAgainResponse(options, basePath, message) {
     return xmlResponse(`${sayTwiml(message)}${recordTwiml({
-        publicBaseUrl,
-        timeoutSeconds: exports.DEFAULT_TWILIO_RECORD_TIMEOUT_SECONDS,
-        maxLengthSeconds: exports.DEFAULT_TWILIO_RECORD_MAX_LENGTH_SECONDS,
+        publicBaseUrl: options.publicBaseUrl,
+        basePath,
+        timeoutSeconds: options.recordTimeoutSeconds ?? exports.DEFAULT_TWILIO_RECORD_TIMEOUT_SECONDS,
+        maxLengthSeconds: options.recordMaxLengthSeconds ?? exports.DEFAULT_TWILIO_RECORD_MAX_LENGTH_SECONDS,
     })}`);
 }
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function nextInputTwiml(options, basePath, mode) {
+    if (mode === "redirect")
+        return redirectTwiml(options.publicBaseUrl, basePath);
+    return recordTwiml({
+        publicBaseUrl: options.publicBaseUrl,
+        basePath,
+        timeoutSeconds: options.recordTimeoutSeconds ?? exports.DEFAULT_TWILIO_RECORD_TIMEOUT_SECONDS,
+        maxLengthSeconds: options.recordMaxLengthSeconds ?? exports.DEFAULT_TWILIO_RECORD_MAX_LENGTH_SECONDS,
+    });
+}
+async function runPhonePromptTurn(options) {
+    const transcript = (0, transcript_1.buildVoiceTranscript)({
+        utteranceId: options.utteranceId,
+        text: options.promptText,
+        source: "loopback",
+    });
+    const turn = await (0, turn_1.runVoiceLoopbackTurn)({
+        agentName: options.bridgeOptions.agentName,
+        friendId: options.friendId,
+        sessionKey: options.sessionKey,
+        transcript,
+        tts: options.bridgeOptions.tts,
+        runSenseTurn: options.bridgeOptions.runSenseTurn,
+    });
+    const after = nextInputTwiml(options.bridgeOptions, options.basePath, options.afterPlayback);
+    if (turn.tts.status !== "delivered") {
+        return xmlResponse(`${sayTwiml("voice output failed after the text response was captured.")}${after}`);
+    }
+    const playback = await (0, playback_1.writeVoicePlaybackArtifact)({
+        utteranceId: options.utteranceId,
+        delivery: turn.tts,
+        outputDir: options.callDir,
+    });
+    const audioUrl = routeUrl(options.bridgeOptions.publicBaseUrl, `${options.basePath}/audio/${encodeURIComponent(options.safeCallSid)}/${encodeURIComponent(path.basename(playback.audioPath))}`);
+    return xmlResponse(`${playTwiml(audioUrl)}${after}`);
+}
 function computeTwilioSignature(input) {
     const payload = input.url + Object.keys(input.params)
         .sort()
@@ -226,28 +309,56 @@ function verifyRequest(options, request, params) {
         signature: headerValue(request.headers, "x-twilio-signature"),
     });
 }
-async function handleIncoming(options) {
-    const greeting = options.greetingText ?? "Connected to Ouro voice. Speak after the prompt.";
+async function handleIncoming(options, basePath, params) {
+    const callSid = params.CallSid?.trim() || "incoming";
+    const safeCallSid = safeSegment(callSid);
+    const callDir = path.join(options.outputDir, safeCallSid);
+    const utteranceId = `twilio-${safeCallSid}-connected`;
     (0, runtime_1.emitNervesEvent)({
         component: "senses",
         event: "senses.voice_twilio_incoming",
         message: "Twilio voice call connected",
-        meta: { agentName: options.agentName },
+        meta: { agentName: options.agentName, callSid: safeCallSid },
     });
-    return xmlResponse(`${sayTwiml(greeting)}${recordTwiml({
-        publicBaseUrl: options.publicBaseUrl,
-        timeoutSeconds: options.recordTimeoutSeconds ?? exports.DEFAULT_TWILIO_RECORD_TIMEOUT_SECONDS,
-        maxLengthSeconds: options.recordMaxLengthSeconds ?? exports.DEFAULT_TWILIO_RECORD_MAX_LENGTH_SECONDS,
-    })}`);
+    try {
+        await fs.mkdir(callDir, { recursive: true });
+        return await runPhonePromptTurn({
+            bridgeOptions: options,
+            basePath,
+            callDir,
+            safeCallSid,
+            utteranceId,
+            friendId: voiceFriendId(options, params.From?.trim() ?? "", callSid),
+            sessionKey: `twilio-${safeCallSid}`,
+            promptText: callConnectedPrompt(params),
+            afterPlayback: "record",
+        });
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_twilio_incoming_error",
+            message: "Twilio incoming voice greeting turn failed",
+            meta: { agentName: options.agentName, callSid: safeCallSid, error: errorMessage(error) },
+        });
+        return xmlResponse(recordTwiml({
+            publicBaseUrl: options.publicBaseUrl,
+            basePath,
+            timeoutSeconds: options.recordTimeoutSeconds ?? exports.DEFAULT_TWILIO_RECORD_TIMEOUT_SECONDS,
+            maxLengthSeconds: options.recordMaxLengthSeconds ?? exports.DEFAULT_TWILIO_RECORD_MAX_LENGTH_SECONDS,
+        }));
+    }
 }
-async function handleListen(options) {
+async function handleListen(options, basePath) {
     return xmlResponse(recordTwiml({
         publicBaseUrl: options.publicBaseUrl,
+        basePath,
         timeoutSeconds: options.recordTimeoutSeconds ?? exports.DEFAULT_TWILIO_RECORD_TIMEOUT_SECONDS,
         maxLengthSeconds: options.recordMaxLengthSeconds ?? exports.DEFAULT_TWILIO_RECORD_MAX_LENGTH_SECONDS,
     }));
 }
-async function handleRecording(options, params) {
+async function handleRecording(options, basePath, params) {
     const recording = parseRecordingParams(params);
     if (!recording) {
         (0, runtime_1.emitNervesEvent)({
@@ -257,7 +368,7 @@ async function handleRecording(options, params) {
             message: "Twilio recording callback was missing required fields",
             meta: { agentName: options.agentName },
         });
-        return recordAgainResponse(options.publicBaseUrl, "I did not receive audio. Please try again.");
+        return recordAgainResponse(options, basePath, "I did not receive audio. Please try again.");
     }
     const safeCallSid = safeSegment(recording.callSid);
     const safeRecordingSid = safeSegment(recording.recordingSid);
@@ -284,30 +395,43 @@ async function handleRecording(options, params) {
             utteranceId,
             audioPath: inputPath,
         });
+        if (isNoSpeechTranscript(transcript.text)) {
+            return await runPhonePromptTurn({
+                bridgeOptions: options,
+                basePath,
+                callDir,
+                safeCallSid,
+                utteranceId: `${utteranceId}-nospeech`,
+                friendId: voiceFriendId(options, recording.from, recording.callSid),
+                sessionKey: `twilio-${safeCallSid}`,
+                promptText: noSpeechPrompt(),
+                afterPlayback: "redirect",
+            });
+        }
         const turn = await (0, turn_1.runVoiceLoopbackTurn)({
             agentName: options.agentName,
-            friendId: options.defaultFriendId?.trim() || friendIdFromCaller(recording.from, recording.callSid),
+            friendId: voiceFriendId(options, recording.from, recording.callSid),
             sessionKey: `twilio-${safeCallSid}`,
             transcript,
             tts: options.tts,
             runSenseTurn: options.runSenseTurn,
         });
         if (turn.tts.status !== "delivered") {
-            return xmlResponse(`${sayTwiml("voice output failed after the text response was captured.")}${redirectTwiml(options.publicBaseUrl)}`);
+            return xmlResponse(`${sayTwiml("voice output failed after the text response was captured.")}${redirectTwiml(options.publicBaseUrl, basePath)}`);
         }
         const playback = await (0, playback_1.writeVoicePlaybackArtifact)({
             utteranceId,
             delivery: turn.tts,
             outputDir: callDir,
         });
-        const audioUrl = routeUrl(options.publicBaseUrl, `${exports.TWILIO_PHONE_WEBHOOK_BASE_PATH}/audio/${encodeURIComponent(safeCallSid)}/${encodeURIComponent(path.basename(playback.audioPath))}`);
+        const audioUrl = routeUrl(options.publicBaseUrl, `${basePath}/audio/${encodeURIComponent(safeCallSid)}/${encodeURIComponent(path.basename(playback.audioPath))}`);
         (0, runtime_1.emitNervesEvent)({
             component: "senses",
             event: "senses.voice_twilio_turn_end",
             message: "finished Twilio voice turn",
             meta: { agentName: options.agentName, callSid: safeCallSid, recordingSid: safeRecordingSid, audioPath: playback.audioPath },
         });
-        return xmlResponse(`${playTwiml(audioUrl)}${redirectTwiml(options.publicBaseUrl)}`);
+        return xmlResponse(`${playTwiml(audioUrl)}${redirectTwiml(options.publicBaseUrl, basePath)}`);
     }
     catch (error) {
         (0, runtime_1.emitNervesEvent)({
@@ -322,11 +446,11 @@ async function handleRecording(options, params) {
                 error: errorMessage(error),
             },
         });
-        return xmlResponse(`${sayTwiml("I could not process that audio. Please try again.")}${redirectTwiml(options.publicBaseUrl)}`);
+        return xmlResponse(`${sayTwiml("I could not process that audio. Please try again.")}${redirectTwiml(options.publicBaseUrl, basePath)}`);
     }
 }
-async function handleAudio(options, requestPath) {
-    const prefix = `${exports.TWILIO_PHONE_WEBHOOK_BASE_PATH}/audio/`;
+async function handleAudio(options, basePath, requestPath) {
+    const prefix = `${basePath}/audio/`;
     const pathOnly = requestPath.split("?")[0];
     const rest = pathOnly.slice(prefix.length);
     const parts = rest.split("/");
@@ -355,15 +479,16 @@ async function handleAudio(options, requestPath) {
 }
 function createTwilioPhoneBridge(options) {
     new URL(options.publicBaseUrl);
+    const basePath = normalizeTwilioPhoneBasePath(options.basePath);
     return {
         async handle(request) {
             const method = request.method.toUpperCase();
             const requestPath = request.path.startsWith("/") ? request.path : `/${request.path}`;
             const routePath = requestPath.split("?")[0];
-            if (method === "GET" && requestPath.startsWith(`${exports.TWILIO_PHONE_WEBHOOK_BASE_PATH}/audio/`)) {
-                return handleAudio(options, requestPath);
+            if (method === "GET" && requestPath.startsWith(`${basePath}/audio/`)) {
+                return handleAudio(options, basePath, requestPath);
             }
-            if (method === "GET" && routePath === `${exports.TWILIO_PHONE_WEBHOOK_BASE_PATH}/health`) {
+            if (method === "GET" && routePath === `${basePath}/health`) {
                 return textResponse(200, "ok");
             }
             if (method !== "POST")
@@ -379,12 +504,12 @@ function createTwilioPhoneBridge(options) {
                 });
                 return textResponse(403, "invalid Twilio signature");
             }
-            if (routePath === `${exports.TWILIO_PHONE_WEBHOOK_BASE_PATH}/incoming`)
-                return handleIncoming(options);
-            if (routePath === `${exports.TWILIO_PHONE_WEBHOOK_BASE_PATH}/listen`)
-                return handleListen(options);
-            if (routePath === `${exports.TWILIO_PHONE_WEBHOOK_BASE_PATH}/recording`)
-                return handleRecording(options, params);
+            if (routePath === `${basePath}/incoming`)
+                return handleIncoming(options, basePath, params);
+            if (routePath === `${basePath}/listen`)
+                return handleListen(options, basePath);
+            if (routePath === `${basePath}/recording`)
+                return handleRecording(options, basePath, params);
             return textResponse(404, "not found");
         },
     };

package/dist/senses/voice-entry.js

@@ -49,20 +49,21 @@ const runtime_1 = require("../nerves/runtime");
     message: "booting Voice entrypoint",
     meta: { entry: "voice", agentName },
 });
-Promise.resolve().then(() => __importStar(require("../heart/runtime-credentials"))).then(async ({ readMachineRuntimeCredentialConfig, refreshMachineRuntimeCredentialConfig, refreshRuntimeCredentialConfig, waitForRuntimeCredentialBootstrap, }) => {
-    await waitForRuntimeCredentialBootstrap(agentName);
-    const { loadOrCreateMachineIdentity } = await Promise.resolve().then(() => __importStar(require("../heart/machine-identity")));
-    const machine = loadOrCreateMachineIdentity();
-    const machineConfig = readMachineRuntimeCredentialConfig(agentName);
-    if (!machineConfig.ok) {
-        await refreshMachineRuntimeCredentialConfig(agentName, machine.machineId, { preserveCachedOnFailure: true }).catch(() => undefined);
-    }
-    void refreshRuntimeCredentialConfig(agentName, { preserveCachedOnFailure: true }).catch(() => undefined);
+Promise.resolve().then(() => __importStar(require("./voice/twilio-phone-runtime"))).then(async ({ agentScopedTwilioPhoneBasePath, startConfiguredTwilioPhoneTransport, }) => {
+    const twilioPhone = await startConfiguredTwilioPhoneTransport({
+        agentName,
+        defaultBasePath: agentScopedTwilioPhoneBasePath(agentName),
+    });
     (0, runtime_1.emitNervesEvent)({
         component: "senses",
         event: "senses.voice_entry_ready",
         message: "Voice entrypoint is ready for managed voice turns",
-        meta: { entry: "voice", agentName, machineId: machine.machineId },
+        meta: {
+            entry: "voice",
+            agentName,
+            twilioPhone: twilioPhone.status,
+            webhookUrl: twilioPhone.status === "started" ? twilioPhone.settings.webhookUrl : undefined,
+        },
     });
     setInterval(() => undefined, 60_000);
 })

package/dist/senses/voice-twilio-entry.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 function readRequiredAgentName() {
     const agentArgIndex = process.argv.indexOf("--agent");
@@ -42,16 +9,9 @@ function readRequiredAgentName() {
     process.exit(1);
 }
 const agentName = readRequiredAgentName();
-const path = __importStar(require("path"));
-const identity_1 = require("../heart/identity");
-const machine_identity_1 = require("../heart/machine-identity");
 const runtime_logging_1 = require("../heart/daemon/runtime-logging");
-const provider_credentials_1 = require("../heart/provider-credentials");
-const runtime_credentials_1 = require("../heart/runtime-credentials");
 const runtime_1 = require("../nerves/runtime");
-const elevenlabs_1 = require("./voice/elevenlabs");
-const whisper_1 = require("./voice/whisper");
-const twilio_phone_1 = require("./voice/twilio-phone");
+const voice_1 = require("./voice");
 function argValue(name) {
     const index = process.argv.indexOf(name);
     if (index < 0)
@@ -59,45 +19,6 @@ function argValue(name) {
     const value = process.argv[index + 1];
     return value && !value.startsWith("--") ? value : undefined;
 }
-function asRecord(value) {
-    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
-}
-function configString(config, dottedPath) {
-    let cursor = config;
-    for (const segment of dottedPath.split(".")) {
-        const record = asRecord(cursor);
-        if (!record)
-            return undefined;
-        cursor = record[segment];
-    }
-    return typeof cursor === "string" && cursor.trim() ? cursor.trim() : undefined;
-}
-function configNumber(config, dottedPath) {
-    let cursor = config;
-    for (const segment of dottedPath.split(".")) {
-        const record = asRecord(cursor);
-        if (!record)
-            return undefined;
-        cursor = record[segment];
-    }
-    if (typeof cursor === "number" && Number.isFinite(cursor))
-        return cursor;
-    if (typeof cursor === "string" && cursor.trim()) {
-        const parsed = Number(cursor);
-        return Number.isFinite(parsed) ? parsed : undefined;
-    }
-    return undefined;
-}
-function requireConfig(result, label) {
-    if (result.ok)
-        return result.config;
-    throw new Error(`${label} unavailable: ${result.error}`);
-}
-function required(value, guidance) {
-    if (value)
-        return value;
-    throw new Error(guidance);
-}
 function numberArg(name) {
     const raw = argValue(name);
     if (!raw)
@@ -107,31 +28,27 @@ function numberArg(name) {
         throw new Error(`${name} must be a number`);
     return parsed;
 }
-function selectedAgentProviders(config) {
-    const providers = new Set();
-    providers.add(config.humanFacing.provider);
-    providers.add(config.agentFacing.provider);
-    if (config.provider)
-        providers.add(config.provider);
-    return [...providers];
-}
-async function cacheSelectedProviderCredentials(agentName) {
-    const providers = selectedAgentProviders((0, identity_1.loadAgentConfig)());
-    const pool = await (0, provider_credentials_1.refreshProviderCredentialPool)(agentName, { providers });
-    if (!pool.ok) {
-        throw new Error(`provider credentials unavailable for phone voice: ${pool.error}`);
-    }
-    const missing = providers.filter((provider) => !pool.pool.providers[provider]);
-    if (missing.length > 0) {
-        throw new Error(`missing provider credentials for phone voice: ${missing.join(", ")}`);
-    }
+function standaloneOverrides() {
+    return {
+        publicBaseUrl: argValue("--public-url"),
+        basePath: argValue("--base-path"),
+        port: numberArg("--port"),
+        host: argValue("--host"),
+        outputDir: argValue("--output-dir"),
+        defaultFriendId: argValue("--friend"),
+        elevenLabsVoiceId: argValue("--elevenlabs-voice-id"),
+        whisperCliPath: argValue("--whisper-cli-path"),
+        whisperModelPath: argValue("--whisper-model-path"),
+        recordTimeoutSeconds: numberArg("--record-timeout"),
+        recordMaxLengthSeconds: numberArg("--record-max-length"),
+    };
 }
-function writeReadyInstructions(localUrl, publicBaseUrl) {
+function writeReadyInstructions(localUrl, publicBaseUrl, webhookUrl) {
     process.stdout.write([
         "Twilio phone voice bridge ready.",
         `local: ${localUrl}`,
         `public: ${publicBaseUrl}`,
-        `Twilio Voice webhook: POST ${new URL(`${twilio_phone_1.TWILIO_PHONE_WEBHOOK_BASE_PATH}/incoming`, publicBaseUrl).toString()}`,
+        `Twilio Voice webhook: POST ${webhookUrl}`,
         "",
     ].join("\n"));
 }
@@ -143,65 +60,16 @@ function writeReadyInstructions(localUrl, publicBaseUrl) {
     meta: { entry: "voice-twilio", agentName },
 });
 async function main() {
-    await (0, runtime_credentials_1.waitForRuntimeCredentialBootstrap)(agentName);
-    const machine = (0, machine_identity_1.loadOrCreateMachineIdentity)();
-    await Promise.all([
-        (0, runtime_credentials_1.refreshRuntimeCredentialConfig)(agentName, { preserveCachedOnFailure: true }).catch(() => undefined),
-        (0, runtime_credentials_1.refreshMachineRuntimeCredentialConfig)(agentName, machine.machineId, { preserveCachedOnFailure: true }).catch(() => undefined),
-    ]);
-    await cacheSelectedProviderCredentials(agentName);
-    const runtimeConfig = requireConfig((0, runtime_credentials_1.readRuntimeCredentialConfig)(agentName), "portable runtime/config");
-    const machineConfig = requireConfig((0, runtime_credentials_1.readMachineRuntimeCredentialConfig)(agentName), "machine runtime config");
-    const port = numberArg("--port")
-        ?? configNumber(machineConfig, "voice.twilioPort")
-        ?? twilio_phone_1.DEFAULT_TWILIO_PHONE_PORT;
-    const host = argValue("--host")
-        ?? configString(machineConfig, "voice.twilioHost")
-        ?? "127.0.0.1";
-    const publicBaseUrl = required(argValue("--public-url") ?? configString(machineConfig, "voice.twilioPublicUrl"), `missing public URL; run 'cloudflared tunnel --url http://127.0.0.1:${port}' and restart with --public-url https://<tunnel>`);
-    const elevenLabsApiKey = required(configString(runtimeConfig, "integrations.elevenLabsApiKey"), "missing integrations.elevenLabsApiKey; run 'ouro connect voice --agent <agent>' for setup guidance");
-    const elevenLabsVoiceId = required(argValue("--elevenlabs-voice-id")
-        ?? configString(runtimeConfig, "integrations.elevenLabsVoiceId")
-        ?? configString(runtimeConfig, "voice.elevenLabsVoiceId"), "missing integrations.elevenLabsVoiceId; save the ElevenLabs voice ID before starting phone voice");
-    const whisperCliPath = required(configString(machineConfig, "voice.whisperCliPath"), "missing voice.whisperCliPath in this machine's runtime config");
-    const whisperModelPath = required(configString(machineConfig, "voice.whisperModelPath"), "missing voice.whisperModelPath in this machine's runtime config");
-    const outputDir = argValue("--output-dir")
-        ?? configString(machineConfig, "voice.twilioOutputDir")
-        ?? path.join((0, identity_1.getAgentRoot)(agentName), "state", "voice", "twilio-phone");
-    const defaultFriendId = argValue("--friend")
-        ?? configString(machineConfig, "voice.twilioDefaultFriendId");
-    const twilioAccountSid = configString(runtimeConfig, "voice.twilioAccountSid");
-    const twilioAuthToken = configString(runtimeConfig, "voice.twilioAuthToken");
-    const recordTimeoutSeconds = numberArg("--record-timeout")
-        ?? configNumber(machineConfig, "voice.twilioRecordTimeoutSeconds")
-        ?? twilio_phone_1.DEFAULT_TWILIO_RECORD_TIMEOUT_SECONDS;
-    const recordMaxLengthSeconds = numberArg("--record-max-length")
-        ?? configNumber(machineConfig, "voice.twilioRecordMaxLengthSeconds")
-        ?? twilio_phone_1.DEFAULT_TWILIO_RECORD_MAX_LENGTH_SECONDS;
-    const transcriber = (0, whisper_1.createWhisperCppTranscriber)({
-        whisperCliPath,
-        modelPath: whisperModelPath,
-    });
-    const tts = (0, elevenlabs_1.createElevenLabsTtsClient)({
-        apiKey: elevenLabsApiKey,
-        voiceId: elevenLabsVoiceId,
-        outputFormat: "mp3_44100_128",
-    });
-    const bridge = await (0, twilio_phone_1.startTwilioPhoneBridgeServer)({
+    const transport = await (0, voice_1.startConfiguredTwilioPhoneTransport)({
         agentName,
-        publicBaseUrl,
-        outputDir,
-        transcriber,
-        tts,
-        port,
-        host,
-        twilioAccountSid,
-        twilioAuthToken,
-        defaultFriendId,
-        recordTimeoutSeconds,
-        recordMaxLengthSeconds,
+        overrides: standaloneOverrides(),
+        defaultBasePath: voice_1.TWILIO_PHONE_WEBHOOK_BASE_PATH,
+        requirePublicUrl: true,
     });
-    writeReadyInstructions(bridge.localUrl, publicBaseUrl);
+    if (transport.status !== "started") {
+        throw new Error(`Twilio phone voice transport did not start: ${transport.reason}`);
+    }
+    writeReadyInstructions(transport.bridge.localUrl, transport.settings.publicBaseUrl, transport.settings.webhookUrl);
 }
 main().catch((error) => {
     (0, runtime_1.emitNervesEvent)({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.563",
+  "version": "0.1.0-alpha.565",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",