tinker-agent 1.4.0 → 1.5.1

package/src/observation/observation-builder.ts

@@ -5,6 +5,7 @@ import type {
   GenericToolRawResult,
   GlobRawResult,
   GrepRawResult,
+  MemorySearchRawResult,
   McpToolRawResult,
   ReadFileRawResult,
   RecallRawResult,
@@ -33,6 +34,8 @@ export class ObservationBuilder {
         return { content: renderReadObservation(input.raw) };
       case "recall":
         return { content: renderRecallObservation(input.raw) };
+      case "memory_search":
+        return { content: renderMemorySearchObservation(input.raw) };
       case "skill":
         return { content: renderSkillObservation(input.raw) };
       case "write":
@@ -227,6 +230,23 @@ function renderRecallObservation(raw: RecallRawResult): string {
   return [header, ...hits].join("\n\n");
 }
 
+function renderMemorySearchObservation(raw: MemorySearchRawResult): string {
+  if (!raw.ok) {
+    return `MemorySearch unavailable: ${raw.error}`;
+  }
+  if (raw.matches.length === 0) {
+    return "MemorySearch found no stored memories.";
+  }
+  const header = `MemorySearch returned ${raw.matches.length} derived memories. They may be stale or wrong; verify current workspace facts.`;
+  return [
+    header,
+    ...raw.matches.map(
+      (match, index) =>
+        `${index + 1}. score=${match.score.toFixed(3)} created_at=${match.createdAt} workspace=${match.sourceWorkspace}\n   ${match.text}`,
+    ),
+  ].join("\n\n");
+}
+
 export function renderSkillObservation(raw: SkillRawResult): string {
   if (!raw.ok) {
     return `Skill failed for ${raw.name || "(unknown skill)"} (${raw.errorCode}): ${raw.error}`;

package/src/session/session-store.ts

@@ -144,6 +144,29 @@ export type SessionImageInputCompatibility = {
   readonly tokenEstimator?: InputTokenEstimatorCompatibility;
 };
 
+export type CompletedTurnMessageSnapshot =
+  | {
+      readonly ordinal: number;
+      readonly role: "user";
+      readonly content: string;
+    }
+  | {
+      readonly ordinal: number;
+      readonly role: "assistant";
+      readonly content: string | null;
+      readonly reasoningContent?: string | null;
+    }
+  | {
+      readonly ordinal: number;
+      readonly role: "tool";
+      readonly name: string;
+      readonly content: string;
+    };
+
+export type CompletedTurnSnapshot = {
+  readonly messages: readonly CompletedTurnMessageSnapshot[];
+};
+
 export type SessionCompatibilityContract = {
   modelName: string;
   profileName?: string;
@@ -2082,6 +2105,105 @@ export class SessionStore implements SessionLedgerCommitter {
     });
   }
 
+  readCompletedTurnSnapshot(turnId: TurnId): CompletedTurnSnapshot {
+    this.requireOpen();
+    const turnRow = this.database
+      .query("SELECT status FROM turns WHERE turn_id = ?")
+      .get(turnId);
+    const status = enumFromSql(
+      recordFromSql(turnRow, "completed turn").status,
+      ["open", "completed", "failed", "cancelled", "interrupted"] as const,
+      "turn status",
+    );
+    if (status !== "completed") {
+      throw new Error(`Turn ${turnId} is not completed.`);
+    }
+
+    const rows = this.database
+      .query(
+        `SELECT ordinal, role, content, reasoning_content,
+                reasoning_content_present, name
+         FROM messages
+         WHERE turn_id = ?
+         ORDER BY ordinal`,
+      )
+      .all(turnId);
+    if (rows.length === 0) {
+      throw new Error(`Completed turn ${turnId} has no messages.`);
+    }
+
+    let previousOrdinal = 0;
+    const messages = rows.map((value): CompletedTurnMessageSnapshot => {
+      const row = recordFromSql(value, "completed turn message");
+      const ordinal = numberFromSql(row.ordinal, "completed turn ordinal");
+      if (ordinal < 1 || ordinal <= previousOrdinal) {
+        throw new Error("Completed turn message ordinals are invalid.");
+      }
+      previousOrdinal = ordinal;
+      const role = enumFromSql(
+        row.role,
+        ["user", "assistant", "tool"] as const,
+        "completed turn message role",
+      );
+      if (role === "user") {
+        if (
+          row.reasoning_content !== null ||
+          numberFromSql(row.reasoning_content_present, "reasoning_content_present") !==
+            0 ||
+          row.name !== null
+        ) {
+          throw new Error("Completed user message fields are invalid.");
+        }
+        return Object.freeze({
+          ordinal,
+          role,
+          content: stringFromSql(row.content, "completed user content"),
+        });
+      }
+      if (role === "assistant") {
+        if (row.name !== null) {
+          throw new Error("Completed assistant message name must be null.");
+        }
+        const reasoningPresent = numberFromSql(
+          row.reasoning_content_present,
+          "reasoning_content_present",
+        );
+        if (reasoningPresent !== 0 && reasoningPresent !== 1) {
+          throw new Error("reasoning_content_present must be 0 or 1.");
+        }
+        if (reasoningPresent === 0 && row.reasoning_content !== null) {
+          throw new Error("Absent assistant reasoning content must be null.");
+        }
+        return Object.freeze({
+          ordinal,
+          role,
+          content: nullableTextFromSql(row.content, "completed assistant content"),
+          ...(reasoningPresent === 0
+            ? {}
+            : {
+                reasoningContent: nullableTextFromSql(
+                  row.reasoning_content,
+                  "completed assistant reasoning content",
+                ),
+              }),
+        });
+      }
+      if (
+        row.reasoning_content !== null ||
+        numberFromSql(row.reasoning_content_present, "reasoning_content_present") !== 0
+      ) {
+        throw new Error("Completed tool message reasoning fields are invalid.");
+      }
+      return Object.freeze({
+        ordinal,
+        role,
+        name: stringFromSql(row.name, "completed tool name"),
+        content: stringFromSql(row.content, "completed tool content"),
+      });
+    });
+    return Object.freeze({ messages: Object.freeze(messages) });
+  }
+
   loadProtocolView(): ProtocolContextView {
     this.requireOpen();
     const imageAttachments = loadMessageImageAttachments(this.database);
@@ -4725,6 +4847,7 @@ export function decodeStoredToolRawResult(value: unknown): ToolRawResult {
       "web_search",
       "web_fetch",
       "recall",
+      "memory_search",
       "skill",
       "mcp",
       "generic",

package/src/tools/registry.ts

@@ -133,6 +133,7 @@ export function createDefaultTooling(options: {
   skillCatalog?: SkillCatalogSnapshot;
   skillCoordinator?: SkillActivationCoordinator;
   toolingConfig?: PublicToolingConfig;
+  memorySearch?: ToolExecutor;
 }): DefaultTooling {
   const snapshots: FileSnapshotStore = new Map();
   const registry = new ToolRegistry();
@@ -170,6 +171,9 @@ export function createDefaultTooling(options: {
     }),
   );
   registry.register(createRecallToolExecutor({ historyReader: options.historyReader }));
+  if (options.memorySearch !== undefined) {
+    registry.register(options.memorySearch);
+  }
   if (options.skillCatalog !== undefined) {
     if (options.skillCatalog.skills.size === 0) {
       throw new Error("An empty Agent Skill catalog must not register tooling.");

package/src/tools/types.ts

@@ -245,6 +245,21 @@ export type RecallGetRawResult =
 
 export type RecallRawResult = RecallSearchRawResult | RecallGetRawResult;
 
+export type MemorySearchRawResult =
+  | {
+      ok: true;
+      matches: readonly {
+        text: string;
+        score: number;
+        sourceWorkspace: string;
+        createdAt: string;
+      }[];
+    }
+  | {
+      ok: false;
+      error: string;
+    };
+
 export type SkillRawResult =
   | {
       ok: true;
@@ -307,6 +322,7 @@ export type ToolRawResultByKind = {
   web_search: WebSearchRawResult;
   web_fetch: WebFetchRawResult;
   recall: RecallRawResult;
+  memory_search: MemorySearchRawResult;
   skill: SkillRawResult;
   mcp: McpToolRawResult;
   generic: GenericToolRawResult;