owpenwork 0.1.13 → 0.1.14

package/dist/bridge.js

@@ -19,6 +19,11 @@ const TOOL_LABELS = {
     task: "agent",
     webfetch: "webfetch",
 };
+const CHANNEL_LABELS = {
+    whatsapp: "WhatsApp",
+    telegram: "Telegram",
+};
+const TYPING_INTERVAL_MS = 6000;
 export async function startBridge(config, logger, reporter) {
     const reportStatus = reporter?.onStatus;
     const client = createClient(config);
@@ -43,6 +48,67 @@ export async function startBridge(config, logger, reporter) {
     }
     const sessionQueue = new Map();
     const activeRuns = new Map();
+    const sessionModels = new Map();
+    const typingLoops = new Map();
+    const formatPeer = (channel, peerId) => channel === "whatsapp" ? normalizeWhatsAppId(peerId) : peerId;
+    const formatModelLabel = (model) => model ? `${model.providerID}/${model.modelID}` : null;
+    const extractModelRef = (info) => {
+        if (!info || typeof info !== "object")
+            return null;
+        const record = info;
+        if (record.role !== "user")
+            return null;
+        if (!record.model || typeof record.model !== "object")
+            return null;
+        const model = record.model;
+        if (typeof model.providerID !== "string" || typeof model.modelID !== "string")
+            return null;
+        return { providerID: model.providerID, modelID: model.modelID };
+    };
+    const reportThinking = (run) => {
+        if (!reportStatus)
+            return;
+        const modelLabel = formatModelLabel(sessionModels.get(run.sessionID));
+        const nextLabel = modelLabel ? `Thinking (${modelLabel})` : "Thinking...";
+        if (run.thinkingLabel === nextLabel && run.thinkingActive)
+            return;
+        run.thinkingLabel = nextLabel;
+        run.thinkingActive = true;
+        reportStatus(`[${CHANNEL_LABELS[run.channel]}] ${formatPeer(run.channel, run.peerId)} ${nextLabel}`);
+    };
+    const reportDone = (run) => {
+        if (!reportStatus || !run.thinkingActive)
+            return;
+        const modelLabel = formatModelLabel(sessionModels.get(run.sessionID));
+        const suffix = modelLabel ? ` (${modelLabel})` : "";
+        reportStatus(`[${CHANNEL_LABELS[run.channel]}] ${formatPeer(run.channel, run.peerId)} Done${suffix}`);
+        run.thinkingActive = false;
+    };
+    const startTyping = (run) => {
+        const adapter = adapters.get(run.channel);
+        if (!adapter?.sendTyping)
+            return;
+        if (typingLoops.has(run.sessionID))
+            return;
+        const sendTyping = async () => {
+            try {
+                await adapter.sendTyping?.(run.peerId);
+            }
+            catch (error) {
+                logger.warn({ error, channel: run.channel }, "typing update failed");
+            }
+        };
+        void sendTyping();
+        const timer = setInterval(sendTyping, TYPING_INTERVAL_MS);
+        typingLoops.set(run.sessionID, timer);
+    };
+    const stopTyping = (sessionID) => {
+        const timer = typingLoops.get(sessionID);
+        if (!timer)
+            return;
+        clearInterval(timer);
+        typingLoops.delete(sessionID);
+    };
     let opencodeHealthy = false;
     let opencodeVersion;
     async function refreshHealth() {
@@ -80,6 +146,46 @@ export async function startBridge(config, logger, reporter) {
             const event = normalizeEvent(raw);
             if (!event)
                 continue;
+            if (event.type === "message.updated") {
+                if (event.properties && typeof event.properties === "object") {
+                    const record = event.properties;
+                    const info = record.info;
+                    const sessionID = typeof info?.sessionID === "string" ? info.sessionID : null;
+                    const model = extractModelRef(info);
+                    if (sessionID && model) {
+                        sessionModels.set(sessionID, model);
+                        const run = activeRuns.get(sessionID);
+                        if (run)
+                            reportThinking(run);
+                    }
+                }
+            }
+            if (event.type === "session.status") {
+                if (event.properties && typeof event.properties === "object") {
+                    const record = event.properties;
+                    const sessionID = typeof record.sessionID === "string" ? record.sessionID : null;
+                    const status = record.status;
+                    if (sessionID && (status?.type === "busy" || status?.type === "retry")) {
+                        const run = activeRuns.get(sessionID);
+                        if (run) {
+                            reportThinking(run);
+                            startTyping(run);
+                        }
+                    }
+                }
+            }
+            if (event.type === "session.idle") {
+                if (event.properties && typeof event.properties === "object") {
+                    const record = event.properties;
+                    const sessionID = typeof record.sessionID === "string" ? record.sessionID : null;
+                    if (sessionID) {
+                        stopTyping(sessionID);
+                        const run = activeRuns.get(sessionID);
+                        if (run)
+                            reportDone(run);
+                    }
+                }
+            }
             if (event.type === "message.part.updated") {
                 const part = event.properties?.part;
                 if (!part?.sessionID)
@@ -201,6 +307,8 @@ export async function startBridge(config, logger, reporter) {
                 seenToolStates: new Map(),
             };
             activeRuns.set(sessionID, runState);
+            reportThinking(runState);
+            startTyping(runState);
             try {
                 const response = await client.session.prompt({
                     sessionID,
@@ -228,6 +336,8 @@ export async function startBridge(config, logger, reporter) {
                 });
             }
             finally {
+                stopTyping(sessionID);
+                reportDone(runState);
                 activeRuns.delete(sessionID);
             }
         });
@@ -243,6 +353,8 @@ export async function startBridge(config, logger, reporter) {
             throw new Error("Failed to create session");
         store.upsertSession(message.channel, message.peerId, sessionID);
         logger.info({ sessionID, channel: message.channel, peerId: message.peerId }, "session created");
+        reportStatus?.(`${CHANNEL_LABELS[message.channel]} session created for ${formatPeer(message.channel, message.peerId)} (ID: ${sessionID}).`);
+        await sendText(message.channel, message.peerId, "🧭 Session started.", { kind: "system" });
         return sessionID;
     }
     function enqueue(sessionID, task) {
@@ -271,6 +383,10 @@ export async function startBridge(config, logger, reporter) {
             clearInterval(healthTimer);
             if (stopHealthServer)
                 stopHealthServer();
+            for (const timer of typingLoops.values()) {
+                clearInterval(timer);
+            }
+            typingLoops.clear();
             for (const adapter of adapters.values()) {
                 await adapter.stop();
             }

package/dist/cli.js

@@ -10,7 +10,7 @@ import { createLogger } from "./logger.js";
 import { createClient } from "./opencode.js";
 import { truncateText } from "./text.js";
 import { loginWhatsApp, unpairWhatsApp } from "./whatsapp.js";
-const VERSION = "0.1.13";
+const VERSION = "0.1.14";
 const STEP_OPTIONS = [
     {
         value: "config",

package/dist/whatsapp.js

@@ -171,6 +171,16 @@ export function createWhatsAppAdapter(config, logger, onMessage, opts = {}) {
             const sent = await socket.sendMessage(peerId, { text });
             recordSentMessage(sent?.key?.id);
         },
+        async sendTyping(peerId) {
+            if (!socket)
+                return;
+            try {
+                await socket.sendPresenceUpdate("composing", peerId);
+            }
+            catch (error) {
+                log.warn({ error, peerId }, "whatsapp typing update failed");
+            }
+        },
     };
 }
 export async function loginWhatsApp(config, logger, options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "owpenwork",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "WhatsApp bridge for a running OpenCode server",
   "private": false,
   "type": "module",