@ouro.bot/cli 0.1.0-alpha.7 → 0.1.0-alpha.700

package/dist/senses/bluebubbles-client.js

@@ -1,279 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createBlueBubblesClient = createBlueBubblesClient;
-const node_crypto_1 = require("node:crypto");
-const config_1 = require("../heart/config");
-const runtime_1 = require("../nerves/runtime");
-const bluebubbles_model_1 = require("./bluebubbles-model");
-function buildBlueBubblesApiUrl(baseUrl, endpoint, password) {
-    const root = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-    const url = new URL(endpoint.replace(/^\//, ""), root);
-    url.searchParams.set("password", password);
-    return url.toString();
-}
-function asRecord(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
-function extractMessageGuid(payload) {
-    if (!payload || typeof payload !== "object")
-        return undefined;
-    const record = payload;
-    const data = record.data && typeof record.data === "object" && !Array.isArray(record.data)
-        ? record.data
-        : null;
-    const candidates = [
-        record.messageGuid,
-        record.messageId,
-        record.guid,
-        data?.messageGuid,
-        data?.messageId,
-        data?.guid,
-    ];
-    for (const candidate of candidates) {
-        if (typeof candidate === "string" && candidate.trim()) {
-            return candidate.trim();
-        }
-    }
-    return undefined;
-}
-async function parseJsonBody(response) {
-    const raw = await response.text();
-    if (!raw.trim())
-        return null;
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-function buildRepairUrl(baseUrl, messageGuid, password) {
-    const url = buildBlueBubblesApiUrl(baseUrl, `/api/v1/message/${encodeURIComponent(messageGuid)}`, password);
-    const parsed = new URL(url);
-    parsed.searchParams.set("with", "attachments,payloadData,chats,messageSummaryInfo");
-    return parsed.toString();
-}
-function collectPreviewStrings(value, out, depth = 0) {
-    if (depth > 4 || out.length >= 4)
-        return;
-    if (typeof value === "string") {
-        const trimmed = value.trim();
-        if (trimmed)
-            out.push(trimmed);
-        return;
-    }
-    if (Array.isArray(value)) {
-        for (const entry of value)
-            collectPreviewStrings(entry, out, depth + 1);
-        return;
-    }
-    const record = asRecord(value);
-    if (!record)
-        return;
-    const preferredKeys = ["title", "summary", "subtitle", "previewText", "siteName", "host", "url"];
-    for (const key of preferredKeys) {
-        if (out.length >= 4)
-            break;
-        collectPreviewStrings(record[key], out, depth + 1);
-    }
-}
-function extractLinkPreviewText(data) {
-    const values = [];
-    collectPreviewStrings(data.payloadData, values);
-    collectPreviewStrings(data.messageSummaryInfo, values);
-    const unique = [...new Set(values.map((value) => value.trim()).filter(Boolean))];
-    if (unique.length === 0)
-        return undefined;
-    return unique.slice(0, 2).join(" — ");
-}
-function applyRepairNotice(event, notice) {
-    return {
-        ...event,
-        requiresRepair: false,
-        repairNotice: notice,
-    };
-}
-function hydrateTextForAgent(event, rawData) {
-    if (event.kind !== "message") {
-        return { ...event, requiresRepair: false };
-    }
-    if (event.balloonBundleId !== "com.apple.messages.URLBalloonProvider") {
-        return { ...event, requiresRepair: false };
-    }
-    const previewText = extractLinkPreviewText(rawData);
-    if (!previewText) {
-        return { ...event, requiresRepair: false };
-    }
-    const base = event.text.trim();
-    const textForAgent = base
-        ? `${base}\n[link preview: ${previewText}]`
-        : `[link preview: ${previewText}]`;
-    return {
-        ...event,
-        textForAgent,
-        requiresRepair: false,
-    };
-}
-function extractRepairData(payload) {
-    const record = asRecord(payload);
-    return asRecord(record?.data) ?? record;
-}
-function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(), channelConfig = (0, config_1.getBlueBubblesChannelConfig)()) {
-    return {
-        async sendText(params) {
-            const trimmedText = params.text.trim();
-            if (!trimmedText) {
-                throw new Error("BlueBubbles send requires non-empty text.");
-            }
-            if (!params.chat.chatGuid) {
-                throw new Error("BlueBubbles send currently requires chat.chatGuid from the inbound event.");
-            }
-            const url = buildBlueBubblesApiUrl(config.serverUrl, "/api/v1/message/text", config.password);
-            const body = {
-                chatGuid: params.chat.chatGuid,
-                tempGuid: (0, node_crypto_1.randomUUID)(),
-                message: trimmedText,
-            };
-            if (params.replyToMessageGuid?.trim()) {
-                body.method = "private-api";
-                body.selectedMessageGuid = params.replyToMessageGuid.trim();
-                body.partIndex = 0;
-            }
-            (0, runtime_1.emitNervesEvent)({
-                component: "senses",
-                event: "senses.bluebubbles_send_start",
-                message: "sending bluebubbles message",
-                meta: {
-                    chatGuid: params.chat.chatGuid,
-                    hasReplyTarget: Boolean(params.replyToMessageGuid?.trim()),
-                },
-            });
-            const response = await fetch(url, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(body),
-                signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
-            });
-            if (!response.ok) {
-                const errorText = await response.text().catch(() => "");
-                (0, runtime_1.emitNervesEvent)({
-                    level: "error",
-                    component: "senses",
-                    event: "senses.bluebubbles_send_error",
-                    message: "bluebubbles send failed",
-                    meta: {
-                        status: response.status,
-                        reason: errorText || "unknown",
-                    },
-                });
-                throw new Error(`BlueBubbles send failed (${response.status}): ${errorText || "unknown"}`);
-            }
-            const payload = await parseJsonBody(response);
-            const messageGuid = extractMessageGuid(payload);
-            (0, runtime_1.emitNervesEvent)({
-                component: "senses",
-                event: "senses.bluebubbles_send_end",
-                message: "bluebubbles message sent",
-                meta: {
-                    chatGuid: params.chat.chatGuid,
-                    messageGuid: messageGuid ?? null,
-                },
-            });
-            return { messageGuid };
-        },
-        async repairEvent(event) {
-            if (!event.requiresRepair) {
-                (0, runtime_1.emitNervesEvent)({
-                    component: "senses",
-                    event: "senses.bluebubbles_repair_skipped",
-                    message: "bluebubbles event repair skipped",
-                    meta: {
-                        kind: event.kind,
-                        messageGuid: event.messageGuid,
-                    },
-                });
-                return event;
-            }
-            (0, runtime_1.emitNervesEvent)({
-                component: "senses",
-                event: "senses.bluebubbles_repair_start",
-                message: "repairing bluebubbles event by guid",
-                meta: {
-                    kind: event.kind,
-                    messageGuid: event.messageGuid,
-                    eventType: event.eventType,
-                },
-            });
-            const url = buildRepairUrl(config.serverUrl, event.messageGuid, config.password);
-            try {
-                const response = await fetch(url, {
-                    method: "GET",
-                    signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
-                });
-                if (!response.ok) {
-                    const errorText = await response.text().catch(() => "");
-                    const repaired = applyRepairNotice(event, `BlueBubbles repair failed: ${errorText || `HTTP ${response.status}`}`);
-                    (0, runtime_1.emitNervesEvent)({
-                        level: "warn",
-                        component: "senses",
-                        event: "senses.bluebubbles_repair_error",
-                        message: "bluebubbles repair request failed",
-                        meta: {
-                            messageGuid: event.messageGuid,
-                            status: response.status,
-                            reason: errorText || "unknown",
-                        },
-                    });
-                    return repaired;
-                }
-                const payload = await parseJsonBody(response);
-                const data = extractRepairData(payload);
-                if (!data || typeof data.guid !== "string") {
-                    const repaired = applyRepairNotice(event, "BlueBubbles repair failed: invalid message payload");
-                    (0, runtime_1.emitNervesEvent)({
-                        level: "warn",
-                        component: "senses",
-                        event: "senses.bluebubbles_repair_error",
-                        message: "bluebubbles repair returned unusable payload",
-                        meta: {
-                            messageGuid: event.messageGuid,
-                        },
-                    });
-                    return repaired;
-                }
-                const normalized = (0, bluebubbles_model_1.normalizeBlueBubblesEvent)({
-                    type: event.eventType,
-                    data,
-                });
-                const hydrated = hydrateTextForAgent(normalized, data);
-                (0, runtime_1.emitNervesEvent)({
-                    component: "senses",
-                    event: "senses.bluebubbles_repair_end",
-                    message: "bluebubbles event repaired",
-                    meta: {
-                        kind: hydrated.kind,
-                        messageGuid: hydrated.messageGuid,
-                        repairedFrom: event.kind,
-                    },
-                });
-                return hydrated;
-            }
-            catch (error) {
-                const reason = error instanceof Error ? error.message : String(error);
-                (0, runtime_1.emitNervesEvent)({
-                    level: "warn",
-                    component: "senses",
-                    event: "senses.bluebubbles_repair_error",
-                    message: "bluebubbles repair threw",
-                    meta: {
-                        messageGuid: event.messageGuid,
-                        reason,
-                    },
-                });
-                return applyRepairNotice(event, `BlueBubbles repair failed: ${reason}`);
-            }
-        },
-    };
-}

package/dist/senses/bluebubbles-entry.js

@@ -1,11 +0,0 @@
-"use strict";
-// Thin entrypoint for `npm run bluebubbles` / `node dist/senses/bluebubbles-entry.js --agent <name>`.
-// Separated from bluebubbles.ts so the BlueBubbles adapter stays testable.
-Object.defineProperty(exports, "__esModule", { value: true });
-if (!process.argv.includes("--agent")) {
-    // eslint-disable-next-line no-console -- pre-boot guard: --agent check before imports
-    console.error("Missing required --agent <name> argument.\nUsage: node dist/senses/bluebubbles-entry.js --agent ouroboros");
-    process.exit(1);
-}
-const bluebubbles_1 = require("./bluebubbles");
-(0, bluebubbles_1.startBlueBubblesApp)();

package/dist/senses/bluebubbles.js

@@ -1,332 +0,0 @@
-"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.handleBlueBubblesEvent = handleBlueBubblesEvent;
-exports.createBlueBubblesWebhookHandler = createBlueBubblesWebhookHandler;
-exports.startBlueBubblesApp = startBlueBubblesApp;
-const http = __importStar(require("node:http"));
-const path = __importStar(require("node:path"));
-const core_1 = require("../heart/core");
-const config_1 = require("../heart/config");
-const identity_1 = require("../heart/identity");
-const context_1 = require("../mind/context");
-const tokens_1 = require("../mind/friends/tokens");
-const resolver_1 = require("../mind/friends/resolver");
-const store_file_1 = require("../mind/friends/store-file");
-const prompt_1 = require("../mind/prompt");
-const runtime_1 = require("../nerves/runtime");
-const bluebubbles_model_1 = require("./bluebubbles-model");
-const bluebubbles_client_1 = require("./bluebubbles-client");
-const bluebubbles_mutation_log_1 = require("./bluebubbles-mutation-log");
-const defaultDeps = {
-    getAgentName: identity_1.getAgentName,
-    buildSystem: prompt_1.buildSystem,
-    runAgent: core_1.runAgent,
-    loadSession: context_1.loadSession,
-    postTurn: context_1.postTurn,
-    sessionPath: config_1.sessionPath,
-    accumulateFriendTokens: tokens_1.accumulateFriendTokens,
-    createClient: () => (0, bluebubbles_client_1.createBlueBubblesClient)(),
-    recordMutation: bluebubbles_mutation_log_1.recordBlueBubblesMutation,
-    createFriendStore: () => new store_file_1.FileFriendStore(path.join((0, identity_1.getAgentRoot)(), "friends")),
-    createFriendResolver: (store, params) => new resolver_1.FriendResolver(store, params),
-    createServer: http.createServer,
-};
-function resolveFriendParams(event) {
-    if (event.chat.isGroup) {
-        const groupKey = event.chat.chatGuid ?? event.chat.chatIdentifier ?? event.sender.externalId;
-        return {
-            provider: "imessage-handle",
-            externalId: `group:${groupKey}`,
-            displayName: event.chat.displayName ?? "Unknown Group",
-            channel: "bluebubbles",
-        };
-    }
-    return {
-        provider: "imessage-handle",
-        externalId: event.sender.externalId || event.sender.rawId,
-        displayName: event.sender.displayName || "Unknown",
-        channel: "bluebubbles",
-    };
-}
-function buildInboundText(event) {
-    const baseText = event.repairNotice?.trim()
-        ? `${event.textForAgent}\n[${event.repairNotice.trim()}]`
-        : event.textForAgent;
-    if (!event.chat.isGroup)
-        return baseText;
-    if (event.kind === "mutation") {
-        return `${event.sender.displayName} ${baseText}`;
-    }
-    return `${event.sender.displayName}: ${baseText}`;
-}
-function createBlueBubblesCallbacks(client, chat, replyToMessageGuid) {
-    let textBuffer = "";
-    return {
-        onModelStart() {
-            (0, runtime_1.emitNervesEvent)({
-                component: "senses",
-                event: "senses.bluebubbles_turn_start",
-                message: "bluebubbles turn started",
-                meta: { chatGuid: chat.chatGuid ?? null },
-            });
-        },
-        onModelStreamStart() {
-            (0, runtime_1.emitNervesEvent)({
-                component: "senses",
-                event: "senses.bluebubbles_stream_start",
-                message: "bluebubbles non-streaming response started",
-                meta: {},
-            });
-        },
-        onTextChunk(text) {
-            textBuffer += text;
-        },
-        onReasoningChunk(_text) { },
-        onToolStart(name, _args) {
-            (0, runtime_1.emitNervesEvent)({
-                component: "senses",
-                event: "senses.bluebubbles_tool_start",
-                message: "bluebubbles tool execution started",
-                meta: { name },
-            });
-        },
-        onToolEnd(name, summary, success) {
-            (0, runtime_1.emitNervesEvent)({
-                component: "senses",
-                event: "senses.bluebubbles_tool_end",
-                message: "bluebubbles tool execution completed",
-                meta: { name, success, summary },
-            });
-        },
-        onError(error, severity) {
-            (0, runtime_1.emitNervesEvent)({
-                level: severity === "terminal" ? "error" : "warn",
-                component: "senses",
-                event: "senses.bluebubbles_turn_error",
-                message: "bluebubbles turn callback error",
-                meta: { severity, reason: error.message },
-            });
-        },
-        onClearText() {
-            textBuffer = "";
-        },
-        async flush() {
-            const trimmed = textBuffer.trim();
-            if (!trimmed) {
-                return;
-            }
-            textBuffer = "";
-            await client.sendText({
-                chat,
-                text: trimmed,
-                replyToMessageGuid,
-            });
-        },
-    };
-}
-async function readRequestBody(req) {
-    let body = "";
-    for await (const chunk of req) {
-        body += chunk.toString();
-    }
-    return body;
-}
-function writeJson(res, statusCode, payload) {
-    res.statusCode = statusCode;
-    res.setHeader("Content-Type", "application/json; charset=utf-8");
-    res.end(JSON.stringify(payload));
-}
-function isWebhookPasswordValid(url, expectedPassword) {
-    const provided = url.searchParams.get("password");
-    return !provided || provided === expectedPassword;
-}
-async function handleBlueBubblesEvent(payload, deps = {}) {
-    const resolvedDeps = { ...defaultDeps, ...deps };
-    const client = resolvedDeps.createClient();
-    const event = await client.repairEvent((0, bluebubbles_model_1.normalizeBlueBubblesEvent)(payload));
-    if (event.fromMe) {
-        (0, runtime_1.emitNervesEvent)({
-            component: "senses",
-            event: "senses.bluebubbles_from_me_ignored",
-            message: "ignored from-me bluebubbles event",
-            meta: {
-                messageGuid: event.messageGuid,
-                kind: event.kind,
-            },
-        });
-        return { handled: true, notifiedAgent: false, kind: event.kind, reason: "from_me" };
-    }
-    if (event.kind === "mutation") {
-        try {
-            resolvedDeps.recordMutation(resolvedDeps.getAgentName(), event);
-        }
-        catch (error) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                component: "senses",
-                event: "senses.bluebubbles_mutation_log_error",
-                message: "failed recording bluebubbles mutation sidecar",
-                meta: {
-                    messageGuid: event.messageGuid,
-                    mutationType: event.mutationType,
-                    reason: error instanceof Error ? error.message : String(error),
-                },
-            });
-        }
-    }
-    if (event.kind === "mutation" && !event.shouldNotifyAgent) {
-        (0, runtime_1.emitNervesEvent)({
-            component: "senses",
-            event: "senses.bluebubbles_state_mutation_recorded",
-            message: "recorded non-notify bluebubbles mutation",
-            meta: {
-                messageGuid: event.messageGuid,
-                mutationType: event.mutationType,
-            },
-        });
-        return { handled: true, notifiedAgent: false, kind: event.kind, reason: "mutation_state_only" };
-    }
-    const store = resolvedDeps.createFriendStore();
-    const resolver = resolvedDeps.createFriendResolver(store, resolveFriendParams(event));
-    const context = await resolver.resolve();
-    const toolContext = {
-        signin: async () => undefined,
-        friendStore: store,
-        summarize: (0, core_1.createSummarize)(),
-        context,
-    };
-    const friendId = context.friend.id;
-    const sessPath = resolvedDeps.sessionPath(friendId, "bluebubbles", event.chat.sessionKey);
-    const existing = resolvedDeps.loadSession(sessPath);
-    const messages = existing?.messages && existing.messages.length > 0
-        ? existing.messages
-        : [{ role: "system", content: await resolvedDeps.buildSystem("bluebubbles", undefined, context) }];
-    messages.push({ role: "user", content: buildInboundText(event) });
-    const callbacks = createBlueBubblesCallbacks(client, event.chat, event.kind === "message" ? event.messageGuid : undefined);
-    const controller = new AbortController();
-    const agentOptions = {
-        toolContext,
-    };
-    const result = await resolvedDeps.runAgent(messages, callbacks, "bluebubbles", controller.signal, agentOptions);
-    await callbacks.flush();
-    resolvedDeps.postTurn(messages, sessPath, result.usage);
-    await resolvedDeps.accumulateFriendTokens(store, friendId, result.usage);
-    (0, runtime_1.emitNervesEvent)({
-        component: "senses",
-        event: "senses.bluebubbles_turn_end",
-        message: "bluebubbles event handled",
-        meta: {
-            messageGuid: event.messageGuid,
-            kind: event.kind,
-            sessionKey: event.chat.sessionKey,
-        },
-    });
-    return {
-        handled: true,
-        notifiedAgent: true,
-        kind: event.kind,
-    };
-}
-function createBlueBubblesWebhookHandler(deps = {}) {
-    return async (req, res) => {
-        const url = new URL(req.url ?? "/", "http://127.0.0.1");
-        const channelConfig = (0, config_1.getBlueBubblesChannelConfig)();
-        const runtimeConfig = (0, config_1.getBlueBubblesConfig)();
-        if (url.pathname !== channelConfig.webhookPath) {
-            writeJson(res, 404, { error: "Not found" });
-            return;
-        }
-        if (req.method !== "POST") {
-            writeJson(res, 405, { error: "Method not allowed" });
-            return;
-        }
-        if (!isWebhookPasswordValid(url, runtimeConfig.password)) {
-            writeJson(res, 401, { error: "Unauthorized" });
-            return;
-        }
-        let payload;
-        try {
-            const rawBody = await readRequestBody(req);
-            payload = JSON.parse(rawBody);
-        }
-        catch (error) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "warn",
-                component: "senses",
-                event: "senses.bluebubbles_webhook_bad_json",
-                message: "failed to parse bluebubbles webhook body",
-                meta: {
-                    reason: error instanceof Error ? error.message : String(error),
-                },
-            });
-            writeJson(res, 400, { error: "Invalid JSON body" });
-            return;
-        }
-        try {
-            const result = await handleBlueBubblesEvent(payload, deps);
-            writeJson(res, 200, result);
-        }
-        catch (error) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                component: "senses",
-                event: "senses.bluebubbles_webhook_error",
-                message: "bluebubbles webhook handling failed",
-                meta: {
-                    reason: error instanceof Error ? error.message : String(error),
-                },
-            });
-            writeJson(res, 500, {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    };
-}
-function startBlueBubblesApp(deps = {}) {
-    const resolvedDeps = { ...defaultDeps, ...deps };
-    resolvedDeps.createClient();
-    const channelConfig = (0, config_1.getBlueBubblesChannelConfig)();
-    const server = resolvedDeps.createServer(createBlueBubblesWebhookHandler(deps));
-    server.listen(channelConfig.port, () => {
-        (0, runtime_1.emitNervesEvent)({
-            component: "channels",
-            event: "channel.app_started",
-            message: "BlueBubbles sense started",
-            meta: { port: channelConfig.port, webhookPath: channelConfig.webhookPath },
-        });
-    });
-    return server;
-}

package/dist/senses/inner-dialog-worker.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createInnerDialogWorker = createInnerDialogWorker;
-exports.startInnerDialogWorker = startInnerDialogWorker;
-const inner_dialog_1 = require("./inner-dialog");
-const runtime_1 = require("../nerves/runtime");
-function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runInnerDialogTurn)(options)) {
-    let running = false;
-    async function run(reason) {
-        if (running)
-            return;
-        running = true;
-        try {
-            await runTurn({ reason });
-        }
-        catch (error) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                component: "senses",
-                event: "senses.inner_dialog_worker_error",
-                message: "inner dialog worker turn failed",
-                meta: {
-                    reason,
-                    error: error instanceof Error ? error.message : String(error),
-                },
-            });
-        }
-        finally {
-            running = false;
-        }
-    }
-    async function handleMessage(message) {
-        if (!message || typeof message !== "object")
-            return;
-        const maybeMessage = message;
-        if (maybeMessage.type === "heartbeat") {
-            await run("heartbeat");
-            return;
-        }
-        if (maybeMessage.type === "poke" ||
-            maybeMessage.type === "chat" ||
-            maybeMessage.type === "message") {
-            await run("instinct");
-            return;
-        }
-        if (maybeMessage.type === "shutdown") {
-            process.exit(0);
-        }
-    }
-    return { run, handleMessage };
-}
-async function startInnerDialogWorker() {
-    const worker = createInnerDialogWorker();
-    process.on("message", (message) => {
-        void worker.handleMessage(message);
-    });
-    process.on("disconnect", () => {
-        process.exit(0);
-    });
-    await worker.run("boot");
-}