@openape/ape-agent 2.3.0 → 2.5.0

package/dist/bridge.mjs

@@ -1366,6 +1366,19 @@ var ChatApi = class {
     });
     return result;
   }
+  /**
+   * Fetch the most recent `limit` messages in a thread, oldest-first.
+   * Used by ThreadSession to seed `history` so the agent has the
+   * full conversation context after a bridge restart — otherwise it
+   * only sees messages that arrived via WS since the process boot.
+   */
+  async listMessages(roomId, threadId, limit = 50) {
+    const url = `${this.endpoint}/api/rooms/${encodeURIComponent(roomId)}/messages?thread_id=${encodeURIComponent(threadId)}&limit=${limit}`;
+    return await ofetch5(url, {
+      method: "GET",
+      headers: { Authorization: await this.bearer() }
+    });
+  }
   async requestContact(peerEmail) {
     const url = `${this.endpoint}/api/contacts`;
     return await ofetch5(url, {
@@ -4041,14 +4054,22 @@ var PATCH_INTERVAL_MS = 300;
 var ThreadSession = class {
   constructor(deps) {
     this.deps = deps;
-    this.resolvedTools = taskTools(deps.tools);
   }
   active;
   queue = [];
   history = [];
-  resolvedTools;
-  /** No-op placeholder kept for API compatibility with the previous
-   *  RPC-listener model where dispose() detached the listener. */
+  /**
+   * Whether we've already backfilled history from the chat server.
+   * Done lazily on the first turn so a freshly-created ThreadSession
+   * (e.g. after a bridge restart) sees the full conversation context,
+   * not just the message that woke it up. We skip the message that
+   * triggered the turn — runLoop adds it via `userMessage`.
+   */
+  backfilled = false;
+  /**
+   * No-op placeholder kept for API compatibility with the previous
+   *  RPC-listener model where dispose() detached the listener.
+   */
   dispose() {
   }
   /** Forward an inbound chat message to the runtime. Queues if a turn is in flight. */
@@ -4088,12 +4109,14 @@ var ThreadSession = class {
         this.deps.log(`status patch failed: ${err instanceof Error ? err.message : String(err)}`);
       }
     };
+    const { systemPrompt, tools } = this.deps.resolveConfig();
+    await this.backfillHistoryOnce(replyToMessageId, body);
     try {
       const result = await runLoop({
         config: this.deps.runtimeConfig,
-        systemPrompt: this.deps.systemPrompt,
+        systemPrompt,
         userMessage: body,
-        tools: this.resolvedTools,
+        tools: taskTools(tools),
         maxSteps: this.deps.maxSteps,
         history: this.history,
         handlers: {
@@ -4130,6 +4153,33 @@ var ThreadSession = class {
       await this.failTurn(`(runtime error: ${message})`);
     }
   }
+  /**
+   * Fetch recent chat history for this thread and seed `this.history`.
+   * Idempotent — only runs once per ThreadSession instance. Skips the
+   * placeholder we just posted plus the inbound message that triggered
+   * this turn (runLoop's `userMessage` handles that one).
+   *
+   * Failures are non-fatal: we log and continue with empty history.
+   * That preserves the pre-backfill behaviour rather than failing the
+   * turn over a transient chat-server hiccup.
+   */
+  async backfillHistoryOnce(currentMessageId, currentBody) {
+    if (this.backfilled) return;
+    this.backfilled = true;
+    try {
+      const rows = await this.deps.chat.listMessages(this.deps.roomId, this.deps.threadId, 50);
+      for (const row of rows) {
+        if (row.id === currentMessageId) continue;
+        if (!row.body || row.body.length === 0) continue;
+        if (row.body === currentBody && row.senderEmail !== this.deps.selfEmail) continue;
+        const role = row.senderEmail === this.deps.selfEmail ? "assistant" : "user";
+        this.history.push({ role, content: row.body });
+      }
+      this.deps.log(`[${this.deps.roomId}/${this.deps.threadId.slice(0, 8)}] backfilled ${this.history.length} message(s) from chat history`);
+    } catch (err) {
+      this.deps.log(`[${this.deps.roomId}/${this.deps.threadId.slice(0, 8)}] backfill failed (continuing with empty history): ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
   /**
    * Stream-end: flush any pending throttled body PATCH, then mark the
    * message as no-longer-streaming. The combined call also triggers
@@ -4365,16 +4415,22 @@ var Bridge = class {
       threadId,
       chat: this.chat,
       runtimeConfig: this.runtimeConfig(),
-      // Tools resolve from agent.json (latest sync from troop) on
-      // every new thread, so owner edits in the troop UI take
-      // effect after the next sync without a bridge restart.
-      // SOUL.md + skills are merged into the system prompt the same
-      // way — picked up per-thread without restart.
-      tools: resolveTools(this.cfg.tools),
-      systemPrompt: composeSystemPrompt({
-        base: resolveSystemPrompt(this.cfg.systemPrompt),
-        enabledTools: resolveTools(this.cfg.tools)
-      }),
+      // Resolve tools + systemPrompt on every turn from agent.json
+      // (latest sync from troop). Owner edits in the troop UI thus
+      // take effect on the very next message in an existing thread —
+      // not just on a freshly-opened one. SOUL.md + skills get merged
+      // into the system prompt the same way.
+      resolveConfig: () => {
+        const tools = resolveTools(this.cfg.tools);
+        return {
+          tools,
+          systemPrompt: composeSystemPrompt({
+            base: resolveSystemPrompt(this.cfg.systemPrompt),
+            enabledTools: tools
+          })
+        };
+      },
+      selfEmail: this.selfEmail,
       maxSteps: this.cfg.maxSteps,
       log
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openape/ape-agent",
-  "version": "2.3.0",
+  "version": "2.5.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",