@openape/ape-agent 2.2.0 → 2.3.0

package/dist/bridge.mjs

@@ -1353,11 +1353,12 @@ var ChatApi = class {
     this.bearer = bearer;
   }
   async postMessage(roomId, body, opts = {}) {
-    const trimmed = clamp(body, MAX_BODY);
+    const bodyForServer = opts.streaming ? body : clamp(body, MAX_BODY);
     const url = `${this.endpoint}/api/rooms/${encodeURIComponent(roomId)}/messages`;
-    const payload = { body: trimmed };
+    const payload = { body: bodyForServer };
     if (opts.replyTo) payload.reply_to = opts.replyTo;
     if (opts.threadId) payload.thread_id = opts.threadId;
+    if (opts.streaming) payload.streaming = true;
     const result = await ofetch5(url, {
       method: "POST",
       headers: { Authorization: await this.bearer() },
@@ -1401,13 +1402,32 @@ var ChatApi = class {
       body: { name: name.slice(0, 100) }
     });
   }
-  async patchMessage(messageId, body) {
-    const trimmed = clamp(body, MAX_BODY);
+  /**
+   * Update an in-flight or completed message. The server differentiates
+   * three modes via the message's current `streaming` state and the
+   * `streaming` field in this call:
+   *
+   *   - Stream tick: pass `body` only (current accumulated text).
+   *     Server keeps streaming=true and does NOT bump edited_at.
+   *   - Stream end: pass `body` + `streaming: false`. Server clears
+   *     the streaming flag and triggers the user-facing push.
+   *   - Tool-call status: pass `streamingStatus` only (no body).
+   *     Renders as "🔧 time.now" in the typing-subtitle.
+   *   - Tool-call cleared: pass `streamingStatus: null`.
+   */
+  async patchMessage(messageId, opts = {}) {
     const url = `${this.endpoint}/api/messages/${encodeURIComponent(messageId)}`;
+    const payload = {};
+    if (opts.body !== void 0) {
+      payload.body = opts.streaming === false && opts.body.trim().length === 0 ? clamp(opts.body, MAX_BODY) : opts.body.length <= MAX_BODY ? opts.body : `${opts.body.slice(0, MAX_BODY - 1)}\u2026`;
+    }
+    if (opts.streaming !== void 0) payload.streaming = opts.streaming;
+    if (opts.streamingStatus !== void 0) payload.streaming_status = opts.streamingStatus;
+    if (Object.keys(payload).length === 0) return;
     await ofetch5(url, {
       method: "PATCH",
       headers: { Authorization: await this.bearer() },
-      body: { body: trimmed }
+      body: payload
     });
   }
 };
@@ -4040,9 +4060,10 @@ var ThreadSession = class {
     void this.startTurn(body, replyToMessageId);
   }
   async startTurn(body, replyToMessageId) {
-    const placeholder = await this.deps.chat.postMessage(this.deps.roomId, "\u2026", {
+    const placeholder = await this.deps.chat.postMessage(this.deps.roomId, "", {
       replyTo: replyToMessageId,
-      threadId: this.deps.threadId
+      threadId: this.deps.threadId,
+      streaming: true
     });
     const turn = {
       placeholderId: placeholder.id,
@@ -4050,15 +4071,23 @@ var ThreadSession = class {
       replyToMessageId,
       throttle: createThrottle(async () => {
         if (!this.active || this.active.placeholderId !== placeholder.id) return;
-        const text = this.active.accumulated || "\u2026";
+        const text = this.active.accumulated;
+        if (text.length === 0) return;
         try {
-          await this.deps.chat.patchMessage(placeholder.id, text);
+          await this.deps.chat.patchMessage(placeholder.id, { body: text });
         } catch (err) {
           this.deps.log(`patch failed (room=${this.deps.roomId} thread=${this.deps.threadId}): ${err instanceof Error ? err.message : String(err)}`);
         }
       }, PATCH_INTERVAL_MS)
     };
     this.active = turn;
+    const setStatus = async (status) => {
+      try {
+        await this.deps.chat.patchMessage(placeholder.id, { streamingStatus: status });
+      } catch (err) {
+        this.deps.log(`status patch failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    };
     try {
       const result = await runLoop({
         config: this.deps.runtimeConfig,
@@ -4075,12 +4104,15 @@ var ThreadSession = class {
           },
           onToolCall: ({ name }) => {
             this.deps.log(`[${this.deps.roomId}/${this.deps.threadId.slice(0, 8)}] tool_call: ${name}`);
+            void setStatus(`\u{1F527} ${name}`);
           },
           onToolResult: ({ name }) => {
             this.deps.log(`[${this.deps.roomId}/${this.deps.threadId.slice(0, 8)}] tool_result: ${name}`);
+            void setStatus(null);
           },
           onToolError: ({ name, error }) => {
             this.deps.log(`[${this.deps.roomId}/${this.deps.threadId.slice(0, 8)}] tool_error: ${name} \u2192 ${error}`);
+            void setStatus(null);
           }
         }
       });
@@ -4091,28 +4123,51 @@ var ThreadSession = class {
       if (result.status === "error") {
         this.deps.log(`runtime done with status=error (room=${this.deps.roomId} thread=${this.deps.threadId})`);
       }
-      this.endTurn();
+      await this.endTurn();
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       this.deps.log(`runtime error (room=${this.deps.roomId} thread=${this.deps.threadId}): ${message}`);
-      this.failTurn(`(runtime error: ${message})`);
+      await this.failTurn(`(runtime error: ${message})`);
     }
   }
-  endTurn() {
+  /**
+   * Stream-end: flush any pending throttled body PATCH, then mark the
+   * message as no-longer-streaming. The combined call also triggers
+   * the user-facing push (the placeholder POST suppressed it).
+   */
+  async endTurn() {
     const turn = this.active;
     if (!turn) return;
     turn.throttle.flush();
+    try {
+      await this.deps.chat.patchMessage(turn.placeholderId, {
+        body: turn.accumulated || "(empty response)",
+        streaming: false,
+        streamingStatus: null
+      });
+    } catch (err) {
+      this.deps.log(`stream-end patch failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     this.active = void 0;
     const next = this.queue.shift();
     if (next) {
       void this.startTurn(next.body, next.replyToMessageId);
     }
   }
-  failTurn(message) {
+  async failTurn(message) {
     const turn = this.active;
     if (!turn) return;
     turn.accumulated = message;
     turn.throttle.flush();
+    try {
+      await this.deps.chat.patchMessage(turn.placeholderId, {
+        body: message,
+        streaming: false,
+        streamingStatus: null
+      });
+    } catch (err) {
+      this.deps.log(`fail-turn patch failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     this.active = void 0;
     const next = this.queue.shift();
     if (next) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openape/ape-agent",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "OpenApe agent runtime: per-agent process that connects to chat.openape.ai, runs the LLM loop with tools + cron tasks, and streams replies back to owners.",
   "type": "module",
   "license": "MIT",