@ouro.bot/cli 0.1.0-alpha.16 → 0.1.0-alpha.18

package/dist/repertoire/tools-base.js

@@ -46,6 +46,25 @@ const tasks_1 = require("./tasks");
 const tools_1 = require("./coding/tools");
 const memory_1 = require("../mind/memory");
 const postIt = (msg) => `post-it from past you:\n${msg}`;
+function normalizeOptionalText(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function buildTaskCreateInput(args) {
+    return {
+        title: args.title,
+        type: args.type,
+        category: args.category,
+        body: args.body,
+        status: normalizeOptionalText(args.status) ?? undefined,
+        validator: normalizeOptionalText(args.validator),
+        requester: normalizeOptionalText(args.requester),
+        cadence: normalizeOptionalText(args.cadence),
+        scheduledAt: normalizeOptionalText(args.scheduledAt),
+    };
+}
 exports.baseToolDefinitions = [
     {
         tool: {
@@ -75,7 +94,11 @@ exports.baseToolDefinitions = [
                 },
             },
         },
-        handler: (a) => (fs.writeFileSync(a.path, a.content, "utf-8"), "ok"),
+        handler: (a) => {
+            fs.mkdirSync(path.dirname(a.path), { recursive: true });
+            fs.writeFileSync(a.path, a.content, "utf-8");
+            return "ok";
+        },
     },
     {
         tool: {
@@ -235,7 +258,7 @@ exports.baseToolDefinitions = [
         },
         handler: (a) => {
             try {
-                const result = (0, child_process_1.spawnSync)("claude", ["-p", "--dangerously-skip-permissions", "--add-dir", "."], {
+                const result = (0, child_process_1.spawnSync)("claude", ["-p", "--no-session-persistence", "--dangerously-skip-permissions", "--add-dir", "."], {
                     input: a.prompt,
                     encoding: "utf-8",
                     timeout: 60000,
@@ -394,7 +417,7 @@ exports.baseToolDefinitions = [
             type: "function",
             function: {
                 name: "task_create",
-                description: "create a new task in the bundle task system",
+                description: "create a new task in the bundle task system. optionally set `scheduledAt` for a one-time reminder or `cadence` for recurring daemon-scheduled work.",
                 parameters: {
                     type: "object",
                     properties: {
@@ -402,18 +425,59 @@ exports.baseToolDefinitions = [
                         type: { type: "string", enum: ["one-shot", "ongoing", "habit"] },
                         category: { type: "string" },
                         body: { type: "string" },
+                        status: { type: "string" },
+                        validator: { type: "string" },
+                        requester: { type: "string" },
+                        scheduledAt: { type: "string", description: "ISO timestamp for a one-time scheduled run/reminder" },
+                        cadence: { type: "string", description: "recurrence like 30m, 1h, 1d, or cron" },
                     },
                     required: ["title", "type", "category", "body"],
                 },
             },
         },
         handler: (a) => {
+            try {
+                const created = (0, tasks_1.getTaskModule)().createTask(buildTaskCreateInput(a));
+                return `created: ${created}`;
+            }
+            catch (error) {
+                return `error: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "schedule_reminder",
+                description: "create a scheduled reminder or recurring daemon job. use `scheduledAt` for one-time reminders and `cadence` for recurring reminders. this writes canonical task fields that the daemon reconciles into OS-level jobs.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        title: { type: "string" },
+                        body: { type: "string" },
+                        category: { type: "string" },
+                        scheduledAt: { type: "string", description: "ISO timestamp for a one-time reminder" },
+                        cadence: { type: "string", description: "recurrence like 30m, 1h, 1d, or cron" },
+                    },
+                    required: ["title", "body"],
+                },
+            },
+        },
+        handler: (a) => {
+            const scheduledAt = normalizeOptionalText(a.scheduledAt);
+            const cadence = normalizeOptionalText(a.cadence);
+            if (!scheduledAt && !cadence) {
+                return "error: provide scheduledAt or cadence";
+            }
             try {
                 const created = (0, tasks_1.getTaskModule)().createTask({
                     title: a.title,
-                    type: a.type,
-                    category: a.category,
+                    type: cadence ? "habit" : "one-shot",
+                    category: normalizeOptionalText(a.category) ?? "reminder",
                     body: a.body,
+                    scheduledAt,
+                    cadence,
                 });
                 return `created: ${created}`;
             }

package/dist/repertoire/tools.js

@@ -19,9 +19,29 @@ Object.defineProperty(exports, "teamsTools", { enumerable: true, get: function (
 // All tool definitions in a single registry
 const allDefinitions = [...tools_base_1.baseToolDefinitions, ...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions];
 const REMOTE_BLOCKED_LOCAL_TOOLS = new Set(["shell", "read_file", "write_file", "git_commit", "gh_cli"]);
-function baseToolsForCapabilities(capabilities) {
-    const isRemoteChannel = capabilities?.channel === "teams" || capabilities?.channel === "bluebubbles";
-    if (!isRemoteChannel)
+function isRemoteChannel(capabilities) {
+    return capabilities?.channel === "teams" || capabilities?.channel === "bluebubbles";
+}
+function isSharedRemoteContext(friend) {
+    const externalIds = friend.externalIds ?? [];
+    return externalIds.some((externalId) => externalId.externalId.startsWith("group:") || externalId.provider === "teams-conversation");
+}
+function isTrustedRemoteContext(context) {
+    if (!context?.friend || !isRemoteChannel(context.channel))
+        return false;
+    const trustLevel = context.friend.trustLevel ?? "stranger";
+    return trustLevel !== "stranger" && !isSharedRemoteContext(context.friend);
+}
+function shouldBlockLocalTools(capabilities, context) {
+    if (!isRemoteChannel(capabilities))
+        return false;
+    return !isTrustedRemoteContext(context);
+}
+function blockedLocalToolMessage() {
+    return "I can't do that from here because I'm talking to multiple people in a shared remote channel, and local shell/file/git/gh operations could let conversations interfere with each other. Ask me for a remote-safe alternative (Graph/ADO/web), or run that operation from CLI.";
+}
+function baseToolsForCapabilities(capabilities, context) {
+    if (!shouldBlockLocalTools(capabilities, context))
         return tools_base_1.tools;
     return tools_base_1.tools.filter((tool) => !REMOTE_BLOCKED_LOCAL_TOOLS.has(tool.function.name));
 }
@@ -39,8 +59,8 @@ function applyPreference(tool, pref) {
 // Base tools (no integration) are always included.
 // Teams/integration tools are included only if their integration is in availableIntegrations.
 // When toolPreferences is provided, matching preferences are appended to tool descriptions.
-function getToolsForChannel(capabilities, toolPreferences) {
-    const baseTools = baseToolsForCapabilities(capabilities);
+function getToolsForChannel(capabilities, toolPreferences, context) {
+    const baseTools = baseToolsForCapabilities(capabilities, context);
     if (!capabilities || capabilities.availableIntegrations.length === 0) {
         return baseTools;
     }
@@ -89,9 +109,8 @@ async function execTool(name, args, ctx) {
         });
         return `unknown: ${name}`;
     }
-    const isRemoteChannel = ctx?.context?.channel?.channel === "teams" || ctx?.context?.channel?.channel === "bluebubbles";
-    if (isRemoteChannel && REMOTE_BLOCKED_LOCAL_TOOLS.has(name)) {
-        const message = "I can't do that from here because I'm talking to multiple people in a shared remote channel, and local shell/file/git/gh operations could let conversations interfere with each other. Ask me for a remote-safe alternative (Graph/ADO/web), or run that operation from CLI.";
+    if (shouldBlockLocalTools(ctx?.context?.channel, ctx?.context) && REMOTE_BLOCKED_LOCAL_TOOLS.has(name)) {
+        const message = blockedLocalToolMessage();
         (0, runtime_1.emitNervesEvent)({
             level: "warn",
             event: "tool.error",
@@ -165,7 +184,9 @@ function summarizeArgs(name, args) {
     if (name === "load_skill")
         return summarizeKeyValues(args, ["name"]);
     if (name === "task_create")
-        return summarizeKeyValues(args, ["title", "type", "category"]);
+        return summarizeKeyValues(args, ["title", "type", "category", "scheduledAt", "cadence"]);
+    if (name === "schedule_reminder")
+        return summarizeKeyValues(args, ["title", "scheduledAt", "cadence"]);
     if (name === "task_update_status")
         return summarizeKeyValues(args, ["name", "status"]);
     if (name === "task_board_status")
@@ -178,6 +199,8 @@ function summarizeArgs(name, args) {
         return summarizeKeyValues(args, ["runner", "workdir", "taskRef"]);
     if (name === "coding_status")
         return summarizeKeyValues(args, ["sessionId"]);
+    if (name === "coding_tail")
+        return summarizeKeyValues(args, ["sessionId"]);
     if (name === "coding_send_input")
         return summarizeKeyValues(args, ["sessionId", "input"]);
     if (name === "coding_kill")

package/dist/senses/bluebubbles-client.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBlueBubblesClient = createBlueBubblesClient;
 const node_crypto_1 = require("node:crypto");
 const config_1 = require("../heart/config");
+const identity_1 = require("../heart/identity");
 const runtime_1 = require("../nerves/runtime");
 const bluebubbles_model_1 = require("./bluebubbles-model");
+const bluebubbles_media_1 = require("./bluebubbles-media");
 function buildBlueBubblesApiUrl(baseUrl, endpoint, password) {
     const root = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
     const url = new URL(endpoint.replace(/^\//, ""), root);
@@ -16,6 +18,10 @@ function asRecord(value) {
         ? value
         : null;
 }
+function readString(record, key) {
+    const value = record[key];
+    return typeof value === "string" ? value : undefined;
+}
 function extractMessageGuid(payload) {
     if (!payload || typeof payload !== "object")
         return undefined;
@@ -55,6 +61,75 @@ function buildRepairUrl(baseUrl, messageGuid, password) {
     parsed.searchParams.set("with", "attachments,payloadData,chats,messageSummaryInfo");
     return parsed.toString();
 }
+function extractChatIdentifierFromGuid(chatGuid) {
+    const parts = chatGuid.split(";");
+    return parts.length >= 3 ? parts[2]?.trim() || undefined : undefined;
+}
+function extractChatGuid(value) {
+    const record = asRecord(value);
+    const candidates = [
+        record?.chatGuid,
+        record?.guid,
+        record?.chat_guid,
+        record?.identifier,
+        record?.chatIdentifier,
+        record?.chat_identifier,
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === "string" && candidate.trim()) {
+            return candidate.trim();
+        }
+    }
+    return undefined;
+}
+function extractQueriedChatIdentifier(chat, chatGuid) {
+    const explicitIdentifier = readString(chat, "chatIdentifier")
+        ?? readString(chat, "identifier")
+        ?? readString(chat, "chat_identifier");
+    if (explicitIdentifier) {
+        return explicitIdentifier;
+    }
+    return extractChatIdentifierFromGuid(chatGuid);
+}
+function extractChatQueryRows(payload) {
+    const record = asRecord(payload);
+    const data = Array.isArray(record?.data) ? record.data : payload;
+    if (!Array.isArray(data)) {
+        return [];
+    }
+    return data.map((entry) => asRecord(entry)).filter((entry) => entry !== null);
+}
+async function resolveChatGuidForIdentifier(config, channelConfig, chatIdentifier) {
+    const trimmedIdentifier = chatIdentifier.trim();
+    if (!trimmedIdentifier)
+        return undefined;
+    const url = buildBlueBubblesApiUrl(config.serverUrl, "/api/v1/chat/query", config.password);
+    const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            limit: 500,
+            offset: 0,
+            with: ["participants"],
+        }),
+        signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
+    });
+    if (!response.ok) {
+        return undefined;
+    }
+    const payload = await parseJsonBody(response);
+    const rows = extractChatQueryRows(payload);
+    for (const row of rows) {
+        const guid = extractChatGuid(row);
+        if (!guid)
+            continue;
+        const identifier = extractQueriedChatIdentifier(row, guid);
+        if (identifier === trimmedIdentifier || guid === trimmedIdentifier) {
+            return guid;
+        }
+    }
+    return undefined;
+}
 function collectPreviewStrings(value, out, depth = 0) {
     if (depth > 4 || out.length >= 4)
         return;
@@ -120,6 +195,13 @@ function extractRepairData(payload) {
     const record = asRecord(payload);
     return asRecord(record?.data) ?? record;
 }
+function providerSupportsAudioInput(provider) {
+    return provider === "azure" || provider === "openai-codex";
+}
+async function resolveChatGuid(chat, config, channelConfig) {
+    return chat.chatGuid
+        ?? await resolveChatGuidForIdentifier(config, channelConfig, chat.chatIdentifier ?? "");
+}
 function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(), channelConfig = (0, config_1.getBlueBubblesChannelConfig)()) {
     return {
         async sendText(params) {
@@ -127,12 +209,13 @@ function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(),
             if (!trimmedText) {
                 throw new Error("BlueBubbles send requires non-empty text.");
             }
-            if (!params.chat.chatGuid) {
+            const resolvedChatGuid = await resolveChatGuid(params.chat, config, channelConfig);
+            if (!resolvedChatGuid) {
                 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,
+                chatGuid: resolvedChatGuid,
                 tempGuid: (0, node_crypto_1.randomUUID)(),
                 message: trimmedText,
             };
@@ -146,7 +229,7 @@ function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(),
                 event: "senses.bluebubbles_send_start",
                 message: "sending bluebubbles message",
                 meta: {
-                    chatGuid: params.chat.chatGuid,
+                    chatGuid: resolvedChatGuid,
                     hasReplyTarget: Boolean(params.replyToMessageGuid?.trim()),
                 },
             });
@@ -177,12 +260,68 @@ function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(),
                 event: "senses.bluebubbles_send_end",
                 message: "bluebubbles message sent",
                 meta: {
-                    chatGuid: params.chat.chatGuid,
+                    chatGuid: resolvedChatGuid,
                     messageGuid: messageGuid ?? null,
                 },
             });
             return { messageGuid };
         },
+        async editMessage(params) {
+            const messageGuid = params.messageGuid.trim();
+            const text = params.text.trim();
+            if (!messageGuid) {
+                throw new Error("BlueBubbles edit requires messageGuid.");
+            }
+            if (!text) {
+                throw new Error("BlueBubbles edit requires non-empty text.");
+            }
+            const editTimeoutMs = Math.max(channelConfig.requestTimeoutMs, 120000);
+            const url = buildBlueBubblesApiUrl(config.serverUrl, `/api/v1/message/${encodeURIComponent(messageGuid)}/edit`, config.password);
+            const response = await fetch(url, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    editedMessage: text,
+                    backwardsCompatibilityMessage: params.backwardsCompatibilityMessage ?? `Edited to: ${text}`,
+                    partIndex: typeof params.partIndex === "number" ? params.partIndex : 0,
+                }),
+                signal: AbortSignal.timeout(editTimeoutMs),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => "");
+                throw new Error(`BlueBubbles edit failed (${response.status}): ${errorText || "unknown"}`);
+            }
+        },
+        async setTyping(chat, typing) {
+            const resolvedChatGuid = await resolveChatGuid(chat, config, channelConfig);
+            if (!resolvedChatGuid) {
+                return;
+            }
+            const url = buildBlueBubblesApiUrl(config.serverUrl, `/api/v1/chat/${encodeURIComponent(resolvedChatGuid)}/typing`, config.password);
+            const response = await fetch(url, {
+                method: typing ? "POST" : "DELETE",
+                signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => "");
+                throw new Error(`BlueBubbles typing failed (${response.status}): ${errorText || "unknown"}`);
+            }
+        },
+        async markChatRead(chat) {
+            const resolvedChatGuid = await resolveChatGuid(chat, config, channelConfig);
+            if (!resolvedChatGuid) {
+                return;
+            }
+            const url = buildBlueBubblesApiUrl(config.serverUrl, `/api/v1/chat/${encodeURIComponent(resolvedChatGuid)}/read`, config.password);
+            const response = await fetch(url, {
+                method: "POST",
+                signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => "");
+                throw new Error(`BlueBubbles read failed (${response.status}): ${errorText || "unknown"}`);
+            }
+        },
         async repairEvent(event) {
             if (!event.requiresRepair) {
                 (0, runtime_1.emitNervesEvent)({
@@ -247,7 +386,22 @@ function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(),
                     type: event.eventType,
                     data,
                 });
-                const hydrated = hydrateTextForAgent(normalized, data);
+                let hydrated = hydrateTextForAgent(normalized, data);
+                if (hydrated.kind === "message" &&
+                    hydrated.balloonBundleId !== "com.apple.messages.URLBalloonProvider" &&
+                    hydrated.attachments.length > 0) {
+                    const media = await (0, bluebubbles_media_1.hydrateBlueBubblesAttachments)(hydrated.attachments, config, channelConfig, {
+                        preferAudioInput: providerSupportsAudioInput((0, identity_1.loadAgentConfig)().provider),
+                    });
+                    const transcriptSuffix = media.transcriptAdditions.map((entry) => `[${entry}]`).join("\n");
+                    const noticeSuffix = media.notices.map((entry) => `[${entry}]`).join("\n");
+                    const combinedSuffix = [transcriptSuffix, noticeSuffix].filter(Boolean).join("\n");
+                    hydrated = {
+                        ...hydrated,
+                        inputPartsForAgent: media.inputParts.length > 0 ? media.inputParts : undefined,
+                        textForAgent: [hydrated.textForAgent, combinedSuffix].filter(Boolean).join("\n"),
+                    };
+                }
                 (0, runtime_1.emitNervesEvent)({
                     component: "senses",
                     event: "senses.bluebubbles_repair_end",

package/dist/senses/bluebubbles-media.js

@@ -0,0 +1,244 @@
+"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.hydrateBlueBubblesAttachments = hydrateBlueBubblesAttachments;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs/promises"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../nerves/runtime");
+const MAX_ATTACHMENT_BYTES = 8 * 1024 * 1024;
+const AUDIO_EXTENSIONS = new Set([".mp3", ".wav", ".m4a", ".caf", ".ogg"]);
+const IMAGE_EXTENSIONS = new Set([".jpg", ".jpeg", ".png", ".gif", ".webp", ".heic", ".heif"]);
+const AUDIO_EXTENSION_BY_CONTENT_TYPE = {
+    "audio/wav": ".wav",
+    "audio/x-wav": ".wav",
+    "audio/mp3": ".mp3",
+    "audio/mpeg": ".mp3",
+    "audio/x-caf": ".caf",
+    "audio/caf": ".caf",
+    "audio/mp4": ".m4a",
+    "audio/x-m4a": ".m4a",
+};
+const AUDIO_INPUT_FORMAT_BY_CONTENT_TYPE = {
+    "audio/wav": "wav",
+    "audio/x-wav": "wav",
+    "audio/mp3": "mp3",
+    "audio/mpeg": "mp3",
+};
+const AUDIO_INPUT_FORMAT_BY_EXTENSION = {
+    ".wav": "wav",
+    ".mp3": "mp3",
+};
+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 describeAttachment(attachment) {
+    return attachment.transferName?.trim() || attachment.guid?.trim() || "attachment";
+}
+function inferContentType(attachment, responseType) {
+    const normalizedResponseType = responseType?.split(";")[0]?.trim().toLowerCase();
+    if (normalizedResponseType) {
+        return normalizedResponseType;
+    }
+    return attachment.mimeType?.trim().toLowerCase() || undefined;
+}
+function isImageAttachment(attachment, contentType) {
+    if (contentType?.startsWith("image/"))
+        return true;
+    const extension = path.extname(attachment.transferName ?? "").toLowerCase();
+    return IMAGE_EXTENSIONS.has(extension);
+}
+function isAudioAttachment(attachment, contentType) {
+    if (contentType?.startsWith("audio/"))
+        return true;
+    const extension = path.extname(attachment.transferName ?? "").toLowerCase();
+    return AUDIO_EXTENSIONS.has(extension);
+}
+function sanitizeFilename(name) {
+    return path.basename(name).replace(/[\r\n"\\]/g, "_");
+}
+function fileExtensionForAudio(attachment, contentType) {
+    const transferExt = path.extname(attachment.transferName ?? "").toLowerCase();
+    if (transferExt) {
+        return transferExt;
+    }
+    if (contentType && AUDIO_EXTENSION_BY_CONTENT_TYPE[contentType]) {
+        return AUDIO_EXTENSION_BY_CONTENT_TYPE[contentType];
+    }
+    return ".audio";
+}
+function audioFormatForInput(contentType, attachment) {
+    const extension = path.extname(attachment?.transferName ?? "").toLowerCase();
+    return AUDIO_INPUT_FORMAT_BY_CONTENT_TYPE[contentType ?? ""] ?? AUDIO_INPUT_FORMAT_BY_EXTENSION[extension];
+}
+async function transcribeAudioWithWhisper(params) {
+    const workDir = await fs.mkdtemp(path.join(os.tmpdir(), "ouro-bb-audio-"));
+    const filename = sanitizeFilename(describeAttachment(params.attachment));
+    const extension = fileExtensionForAudio(params.attachment, params.contentType);
+    const audioPath = path.join(workDir, `${path.parse(filename).name}${extension}`);
+    try {
+        await fs.writeFile(audioPath, params.buffer);
+        await new Promise((resolve, reject) => {
+            (0, node_child_process_1.execFile)("whisper", [
+                audioPath,
+                "--model",
+                "turbo",
+                "--output_dir",
+                workDir,
+                "--output_format",
+                "json",
+                "--verbose",
+                "False",
+            ], { timeout: Math.max(params.timeoutMs, 120000) }, (error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+        const transcriptPath = path.join(workDir, `${path.parse(audioPath).name}.json`);
+        const raw = await fs.readFile(transcriptPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.text === "string" ? parsed.text.trim() : "";
+    }
+    finally {
+        await fs.rm(workDir, { recursive: true, force: true }).catch(() => undefined);
+    }
+}
+async function downloadAttachment(attachment, config, channelConfig, fetchImpl) {
+    const guid = attachment.guid?.trim();
+    if (!guid) {
+        throw new Error("attachment guid missing");
+    }
+    if (typeof attachment.totalBytes === "number" && attachment.totalBytes > MAX_ATTACHMENT_BYTES) {
+        throw new Error(`attachment exceeds ${MAX_ATTACHMENT_BYTES} byte limit`);
+    }
+    const url = buildBlueBubblesApiUrl(config.serverUrl, `/api/v1/attachment/${encodeURIComponent(guid)}/download`, config.password);
+    const response = await fetchImpl(url, {
+        method: "GET",
+        signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
+    });
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    if (buffer.length > MAX_ATTACHMENT_BYTES) {
+        throw new Error(`attachment exceeds ${MAX_ATTACHMENT_BYTES} byte limit`);
+    }
+    return {
+        buffer,
+        contentType: inferContentType(attachment, response.headers.get("content-type")),
+    };
+}
+async function hydrateBlueBubblesAttachments(attachments, config, channelConfig, deps = {}) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_media_hydrate",
+        message: "hydrating bluebubbles attachments",
+        meta: {
+            attachmentCount: attachments.length,
+            preferAudioInput: deps.preferAudioInput ?? false,
+        },
+    });
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const transcribeAudio = deps.transcribeAudio ?? transcribeAudioWithWhisper;
+    const preferAudioInput = deps.preferAudioInput ?? false;
+    const inputParts = [];
+    const transcriptAdditions = [];
+    const notices = [];
+    for (const attachment of attachments) {
+        const name = describeAttachment(attachment);
+        try {
+            const downloaded = await downloadAttachment(attachment, config, channelConfig, fetchImpl);
+            const base64 = downloaded.buffer.toString("base64");
+            if (isImageAttachment(attachment, downloaded.contentType)) {
+                inputParts.push({
+                    type: "image_url",
+                    image_url: {
+                        url: `data:${downloaded.contentType ?? "application/octet-stream"};base64,${base64}`,
+                        detail: "auto",
+                    },
+                });
+                continue;
+            }
+            if (isAudioAttachment(attachment, downloaded.contentType)) {
+                const audioFormat = audioFormatForInput(downloaded.contentType, attachment);
+                if (preferAudioInput && audioFormat) {
+                    inputParts.push({
+                        type: "input_audio",
+                        input_audio: {
+                            data: base64,
+                            format: audioFormat,
+                        },
+                    });
+                    continue;
+                }
+                const transcript = (await transcribeAudio({
+                    attachment,
+                    buffer: downloaded.buffer,
+                    contentType: downloaded.contentType,
+                    timeoutMs: channelConfig.requestTimeoutMs,
+                })).trim();
+                if (!transcript) {
+                    notices.push(`attachment hydration failed for ${name}: empty audio transcript`);
+                    continue;
+                }
+                transcriptAdditions.push(`voice note transcript: ${transcript}`);
+                continue;
+            }
+            inputParts.push({
+                type: "file",
+                file: {
+                    file_data: base64,
+                    filename: sanitizeFilename(name),
+                },
+            });
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            notices.push(`attachment hydration failed for ${name}: ${reason}`);
+        }
+    }
+    return {
+        inputParts,
+        transcriptAdditions,
+        notices,
+    };
+}