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

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,
+    };
+}

package/dist/senses/bluebubbles.js

@@ -46,10 +46,12 @@ 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 phrases_1 = require("../mind/phrases");
 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 debug_activity_1 = require("./debug-activity");
 const defaultDeps = {
     getAgentName: identity_1.getAgentName,
     buildSystem: prompt_1.buildSystem,
@@ -92,10 +94,58 @@ function buildInboundText(event) {
     }
     return `${event.sender.displayName}: ${baseText}`;
 }
+function buildInboundContent(event) {
+    const text = buildInboundText(event);
+    if (event.kind !== "message" || !event.inputPartsForAgent || event.inputPartsForAgent.length === 0) {
+        return text;
+    }
+    return [
+        { type: "text", text },
+        ...event.inputPartsForAgent,
+    ];
+}
 function createBlueBubblesCallbacks(client, chat, replyToMessageGuid) {
     let textBuffer = "";
+    const phrases = (0, phrases_1.getPhrases)();
+    const activity = (0, debug_activity_1.createDebugActivityController)({
+        thinkingPhrases: phrases.thinking,
+        followupPhrases: phrases.followup,
+        transport: {
+            sendStatus: async (text) => {
+                const sent = await client.sendText({
+                    chat,
+                    text,
+                    replyToMessageGuid,
+                });
+                return sent.messageGuid;
+            },
+            editStatus: async (_messageGuid, text) => {
+                await client.sendText({
+                    chat,
+                    text,
+                    replyToMessageGuid,
+                });
+            },
+            setTyping: async (active) => {
+                await client.setTyping(chat, active);
+            },
+        },
+        onTransportError: (operation, error) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_activity_error",
+                message: "bluebubbles activity transport failed",
+                meta: {
+                    operation,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        },
+    });
     return {
         onModelStart() {
+            activity.onModelStart();
             (0, runtime_1.emitNervesEvent)({
                 component: "senses",
                 event: "senses.bluebubbles_turn_start",
@@ -112,10 +162,12 @@ function createBlueBubblesCallbacks(client, chat, replyToMessageGuid) {
             });
         },
         onTextChunk(text) {
+            activity.onTextChunk(text);
             textBuffer += text;
         },
         onReasoningChunk(_text) { },
         onToolStart(name, _args) {
+            activity.onToolStart(name, _args);
             (0, runtime_1.emitNervesEvent)({
                 component: "senses",
                 event: "senses.bluebubbles_tool_start",
@@ -124,6 +176,7 @@ function createBlueBubblesCallbacks(client, chat, replyToMessageGuid) {
             });
         },
         onToolEnd(name, summary, success) {
+            activity.onToolEnd(name, summary, success);
             (0, runtime_1.emitNervesEvent)({
                 component: "senses",
                 event: "senses.bluebubbles_tool_end",
@@ -132,6 +185,7 @@ function createBlueBubblesCallbacks(client, chat, replyToMessageGuid) {
             });
         },
         onError(error, severity) {
+            activity.onError(error);
             (0, runtime_1.emitNervesEvent)({
                 level: severity === "terminal" ? "error" : "warn",
                 component: "senses",
@@ -144,8 +198,10 @@ function createBlueBubblesCallbacks(client, chat, replyToMessageGuid) {
             textBuffer = "";
         },
         async flush() {
+            await activity.drain();
             const trimmed = textBuffer.trim();
             if (!trimmed) {
+                await activity.finish();
                 return;
             }
             textBuffer = "";
@@ -154,6 +210,10 @@ function createBlueBubblesCallbacks(client, chat, replyToMessageGuid) {
                 text: trimmed,
                 replyToMessageGuid,
             });
+            await activity.finish();
+        },
+        async finish() {
+            await activity.finish();
         },
     };
 }
@@ -227,6 +287,15 @@ async function handleBlueBubblesEvent(payload, deps = {}) {
         friendStore: store,
         summarize: (0, core_1.createSummarize)(),
         context,
+        codingFeedback: {
+            send: async (message) => {
+                await client.sendText({
+                    chat: event.chat,
+                    text: message,
+                    replyToMessageGuid: event.kind === "message" ? event.messageGuid : undefined,
+                });
+            },
+        },
     };
     const friendId = context.friend.id;
     const sessPath = resolvedDeps.sessionPath(friendId, "bluebubbles", event.chat.sessionKey);
@@ -234,31 +303,51 @@ async function handleBlueBubblesEvent(payload, deps = {}) {
     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) });
+    messages.push({ role: "user", content: buildInboundContent(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,
+    try {
+        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);
+        try {
+            await client.markChatRead(event.chat);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_mark_read_error",
+                message: "failed to mark bluebubbles chat as read",
+                meta: {
+                    chatGuid: event.chat.chatGuid ?? null,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+        (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,
-            sessionKey: event.chat.sessionKey,
-        },
-    });
-    return {
-        handled: true,
-        notifiedAgent: true,
-        kind: event.kind,
-    };
+        };
+    }
+    finally {
+        await callbacks.finish();
+    }
 }
 function createBlueBubblesWebhookHandler(deps = {}) {
     return async (req, res) => {