@animalabs/agent-framework 0.23.3 → 0.24.1

package/src/modules/history/index.ts

@@ -49,7 +49,7 @@ import type { ToolDefinition, ToolCall, ToolResult, ProcessEvent } from '../../t
 import type { EventResponse, ProcessState } from '../../types/module.js';
 import type { SearchWorkerMessage, SearchWorkerMatch } from './search-regex-worker.js';
 import type { ChannelRegistry } from '../../mcpl/channel-registry.js';
-import { EmbedServiceError, SemanticIndexClient, SemanticIndexer, messageIndexText, type SearchResponse, type SemanticIndexConfig, type SyncReport, type PendingChanges } from './semantic.js';
+import { EmbedServiceError, SemanticIndexClient, SemanticIndexer, messageIndexText, summaryIndexText, type SearchResponse, type SemanticIndexConfig, type SyncReport, type PendingChanges } from './semantic.js';
 import { unknownToolMessage } from '../unknown-tool.js';
 import { safeSlice } from '../../safe-slice.js';
 
@@ -1614,6 +1614,9 @@ export class HistoryModule implements Module {
       try { sync = await this.indexer.catchUp(this.semanticCfg.maxSyncBeforeSearch ?? 256); } catch { /* reported via indexer.lastError */ }
     }
 
+    // A message's or summary's snippet is built here, from the local text.
+    // `snippet` still bounds what a service that keeps text sends with each
+    // hit, since what it sends without one isn't specified here.
     const runSearch = (k: number) => this.semanticClient!.search({
       query: input.query, k,
       ts_from: fromMs === undefined ? undefined : fromMs / 1000,
@@ -1667,7 +1670,10 @@ export class HistoryModule implements Module {
     // /newtopic keeps its id (a new message gets a fresh one) and stays
     // indexed. Check every hit against the CURRENT branch before it goes back
     // to the model — getMessage/getSummary rebuild on branch switch, so an
-    // undone message or a summary minted on another branch answers null.
+    // undone message, or a summary this branch doesn't hold, answers null.
+    // A branch made from an earlier point, as an undo makes one, can mint a
+    // summary id another branch already used, so a summary hit's score,
+    // timestamp and date filtering can still be that other summary's.
     // k is small, so this is at most `limit` local lookups.
     // A message hit whose current text has nothing left to index (edited
     // blank, delete not yet applied) is dropped too, so its stale snippet is
@@ -1679,6 +1685,10 @@ export class HistoryModule implements Module {
     // A message hit's snippet is rebuilt from the CURRENT local text, never
     // the remote copy: an edit not yet synced (or one the index never got)
     // must not leak a passage the edit removed. Only the ranking can be stale.
+    // A summary hit's snippet is rebuilt from the local summary too: a
+    // service that keeps only vectors and ids (no text) still yields one, and
+    // a summary whose id another branch also minted shows this branch's text
+    // in its snippet and chars.
     const currentText = new Map<string, string>();
     const keep = (h: { id: string }): 'ok' | 'offBranch' | 'stale' => {
       const msgId = /^msg:(.+)$/.exec(h.id)?.[1];
@@ -1691,7 +1701,19 @@ export class HistoryModule implements Module {
         currentText.set(h.id, text);
         return 'ok';
       }
-      if (sumId !== undefined) return cm.getSummary(sumId) !== null ? 'ok' : 'offBranch';
+      if (sumId !== undefined) {
+        const s = cm.getSummary(sumId);
+        if (!s) return 'offBranch';
+        const text = summaryIndexText(s, this.semanticCfg!);
+        // An empty text here is mostly defensive: context-manager drops a
+        // summary that's empty after trimming when it loads, and refuses to
+        // store one. Short of that, only a maxChars that cuts the text to
+        // nothing gives one. The hit is dropped rather than show the index's
+        // text.
+        if (!text) return 'stale';
+        currentText.set(h.id, text);
+        return 'ok';
+      }
       return 'ok';
     };
     let k = limit;

package/src/modules/history/semantic.ts

@@ -17,8 +17,12 @@
  * What gets embedded per message: text blocks verbatim, plus the string
  * arguments of the agent's private-prose tools (think / journal / skip_reply
  * / private_note) labelled `[think] …` — that is the resident's own diary and
- * is exactly what "what did I think about X" should find. tool_result
- * payloads, other tool arguments, thinking blocks and media are skipped.
+ * is exactly what "what did I think about X" should find. The message
+ * argument of the send tools and edit_message, labelled by tool, such as
+ * `[send_message] …`, since with prose routing disabled the resident speaks
+ * through them.
+ * tool_result payloads, other tool arguments, thinking blocks and media are
+ * skipped.
  *
  * Failure posture: the service being down never breaks the module. Sync ticks
  * log and back off; `semantic_search` returns a clean tool error.
@@ -27,6 +31,7 @@
 import type { ContextManager, StoredMessage } from '@animalabs/context-manager';
 import type { ContentBlock } from '@animalabs/membrane';
 import { safeSlice } from '../../safe-slice.js';
+import { SEND_TOOLS, bareToolName } from '../../send-tools.js';
 
 export interface SemanticIndexConfig {
   /** Base URL of the embed-service, e.g. `http://100.90.161.34:8804`. */
@@ -80,8 +85,10 @@ export interface SearchHit {
   kind: string;
   level: number | null;
   meta: Record<string, unknown>;
+  /** The text the service sends for the hit, where it keeps text; a service that keeps none leaves it out. */
   text?: string;
-  chars: number;
+  /** The length of the text the service holds for the hit; a service that keeps no text may leave it out too. */
+  chars?: number;
 }
 
 export interface SearchRequest {
@@ -104,6 +111,12 @@ export interface SearchResponse {
 }
 
 const PRIVATE_PROSE_TOOLS = new Set(['think', 'journal', 'skip_reply', 'private_note']);
+/**
+ * Tools whose message argument is what the resident said: the send tools,
+ * and edit_message, whose argument is the new text of a message it sent.
+ * With prose routing disabled the resident speaks through these.
+ */
+const SPEECH_TOOLS = new Set([...SEND_TOOLS, 'edit_message']);
 
 /**
  * The semantic index service's failure, said of the service alone: it didn't
@@ -269,6 +282,12 @@ export function messageIndexText(msg: StoredMessage, includePrivateTools = true)
       for (const v of Object.values(input)) {
         if (typeof v === 'string' && v.trim().length > 0) parts.push(`[${block.name}] ${v}`);
       }
+    } else if (block.type === 'tool_use' && SPEECH_TOOLS.has(bareToolName(block.name))) {
+      // Only the message: the other arguments are ids, topics and names.
+      // channel_publish still takes `text` from older callers.
+      const input = (block as { input?: { content?: unknown; text?: unknown } }).input ?? {};
+      const v = input.content ?? input.text;
+      if (typeof v === 'string' && v.trim().length > 0) parts.push(`[${bareToolName(block.name)}] ${v}`);
     }
   }
   return parts.join('\n').trim();
@@ -315,12 +334,16 @@ export interface SummaryLike {
   parentId?: string;
 }
 
+/** The text a summary is indexed by: its content trimmed, and cut at `maxChars` at a whole character. */
+export function summaryIndexText(s: { content: string }, cfg: { maxChars?: number }): string {
+  return safeSlice(s.content.trim(), 0, cfg.maxChars ?? 32_000);
+}
+
 export function summaryToItem(s: SummaryLike, cfg: { maxChars?: number }): IndexItem | null {
-  const text = s.content.trim();
-  if (!text) return null;
+  if (!s.content.trim()) return null;
   return {
     id: `sum:${s.id}`,
-    text: safeSlice(text, 0, cfg.maxChars ?? 32_000),
+    text: summaryIndexText(s, cfg),
     ts: s.startMs / 1000,
     kind: 'summary',
     level: s.level,

package/src/modules/index.ts

@@ -21,6 +21,7 @@ export type {
   ReadInput,
   WriteInput,
   EditInput,
+  EditManyInput,
   DeleteInput,
   LsInput,
   GlobInput,

package/src/modules/unknown-tool.ts

@@ -5,7 +5,10 @@ import type { ToolDefinition } from '../types/events.js';
  * tool, so nothing ran, and which tools the module has, read from its own
  * getTools() so the list can't drift. The registry hands every `module--name`
  * to its module, even one the module doesn't declare, since some modules route
- * undeclared names on purpose, so this answer is the module's to give.
+ * undeclared names on purpose, so this answer is the module's to give. On the
+ * dispatcher's path it comes after the call has opened (RFC-007), and an
+ * in-process route opens none, so either way its result is a failure whose
+ * text says nothing ran, not a refusal (ToolResult.refused).
  */
 export function unknownToolMessage(module: string, name: string, tools: readonly Pick<ToolDefinition, 'name'>[]): string {
   const missing = `There's no tool "${module}--${name}", so nothing ran.`;

package/src/modules/workspace/branch-intent.ts

@@ -6,7 +6,9 @@
  *
  *  - tombstone: the workspace deleted the path while disk kept a copy (no
  *    autoMaterialize, or a refused unlink). The hash is the deleted entry's,
- *    so even a legacy entry with no disk evidence keeps a durable intent.
+ *    so even a legacy entry with no disk evidence keeps a durable intent. A
+ *    tombstone beside an entry that's still there, left by a change that
+ *    stopped partway (commitToolChanges), is no deletion, and guards nothing.
  *  - origin 'store': the entry was created through workspace tools and disk
  *    has never agreed with it.
  *  - conflict: disk and workspace diverged in a way no rule may resolve