tinker-agent 2.0.0 → 2.2.0

package/src/session/session-history-reader.ts

@@ -5,6 +5,12 @@ import {
   type MessageSource,
 } from "../context/context-source";
 import { contentHash, userMessageHash } from "../context/protocol-frame";
+import type { ToolResultContent } from "../agent/types";
+import {
+  canonicalToolResultContentHash,
+  toolResultDisplayText,
+  validateToolResultContent,
+} from "../agent/tool-result-content";
 import {
   parseImageAssetId,
   parseImageAttachmentId,
@@ -132,6 +138,18 @@ type RecallImageRow = {
   height: unknown;
 };
 
+type RecallToolBlockRow = {
+  message_id: unknown;
+  position: unknown;
+  kind: unknown;
+  text_content: unknown;
+  asset_id: unknown;
+  mime_type: unknown;
+  byte_length: unknown;
+  width: unknown;
+  height: unknown;
+};
+
 export function createSessionHistoryReader(input: {
   database: Database;
   sessionId: SessionId;
@@ -233,11 +251,15 @@ class SqliteSessionHistoryReader implements SessionHistoryReader {
       const imageAttachments = this.loadImageAttachments(
         rows.map((row) => nonEmptyString(row.message_id, "message_id") as MessageId),
       );
+      const toolBlocks = this.loadToolContentBlocks(
+        rows.map((row) => nonEmptyString(row.message_id, "message_id") as MessageId),
+      );
       decoded = rows.map((row) => {
         const metadata = decodeRecallRow(row);
         const attachments = imageAttachments.get(metadata.messageId) ?? [];
-        verifyRecallContent(metadata, attachments);
-        const content = renderRecallContent(metadata.content, attachments);
+        const blocks = toolBlocks.get(metadata.messageId);
+        verifyRecallContent(metadata, attachments, blocks);
+        const content = renderRecallContent(metadata.content, attachments, blocks);
         return {
           ...metadata,
           content,
@@ -293,14 +315,18 @@ class SqliteSessionHistoryReader implements SessionHistoryReader {
 
     let metadata: ReturnType<typeof decodeRecallRow>;
     let attachments: readonly UserImageAttachment[];
+    let toolBlocks: readonly ToolResultContent[] | undefined;
     try {
       metadata = decodeRecallRow(row);
       attachments =
         this.loadImageAttachments([metadata.messageId]).get(metadata.messageId) ?? [];
+      toolBlocks = this.loadToolContentBlocks([metadata.messageId]).get(
+        metadata.messageId,
+      );
     } catch (error) {
       throw sessionReadError("decode_recall_get", this.sessionId, error);
     }
-    const actualHash = recallContentHash(metadata, attachments);
+    const actualHash = recallContentHash(metadata, attachments, toolBlocks);
     const observationHash = row.observation_sha256;
     if (
       actualHash !== metadata.contentSha256 ||
@@ -314,7 +340,11 @@ class SqliteSessionHistoryReader implements SessionHistoryReader {
       );
     }
 
-    const renderedContent = renderRecallContent(metadata.content, attachments);
+    const renderedContent = renderRecallContent(
+      metadata.content,
+      attachments,
+      toolBlocks,
+    );
     const page = sliceUtf8Page(renderedContent, input.byteOffset, input.byteLimit);
     return Object.freeze({
       source: formatMessageSource(metadata.messageId),
@@ -428,12 +458,90 @@ class SqliteSessionHistoryReader implements SessionHistoryReader {
       ]),
     );
   }
+
+  private loadToolContentBlocks(
+    messageIds: readonly MessageId[],
+  ): ReadonlyMap<MessageId, readonly ToolResultContent[]> {
+    if (messageIds.length === 0) return new Map();
+    const unique = [...new Set(messageIds)];
+    let rows: RecallToolBlockRow[];
+    try {
+      this.requireStoreOpen();
+      rows = this.database
+        .query(
+          `SELECT tcb.message_id, tcb.position, tcb.kind, tcb.text_content,
+                  ia.asset_id, ia.mime_type, ia.byte_length, ia.width, ia.height
+           FROM tool_message_content_blocks tcb
+           LEFT JOIN image_assets ia ON ia.asset_id = tcb.asset_id
+           WHERE tcb.message_id IN (${unique.map(() => "?").join(", ")})
+           ORDER BY tcb.message_id, tcb.position`,
+        )
+        .all(...unique) as RecallToolBlockRow[];
+    } catch (error) {
+      throw sessionReadError("read_recall_tool_blocks", this.sessionId, error);
+    }
+    const grouped = new Map<MessageId, ToolResultContent[]>();
+    for (const row of rows) {
+      const messageId = nonEmptyString(row.message_id, "message_id") as MessageId;
+      const blocks = grouped.get(messageId) ?? [];
+      if (
+        nonNegativeSafeInteger(row.position, "tool block position") !== blocks.length
+      ) {
+        throw new Error("Recall tool content block positions are not contiguous.");
+      }
+      const kind = enumValue(row.kind, ["text", "image"] as const, "tool block kind");
+      blocks.push(
+        kind === "text"
+          ? Object.freeze({
+              type: "text",
+              text: nonEmptyString(row.text_content, "tool block text"),
+            })
+          : Object.freeze({
+              type: "image",
+              asset: Object.freeze({
+                assetId: parseImageAssetId(
+                  nonEmptyString(row.asset_id, "tool block asset_id"),
+                ),
+                mimeType: enumValue(
+                  row.mime_type,
+                  ["image/png", "image/jpeg", "image/webp"] as const,
+                  "tool block MIME type",
+                ),
+                byteLength: safeInteger(row.byte_length, "tool block byte length"),
+                width: safeInteger(row.width, "tool block width"),
+                height: safeInteger(row.height, "tool block height"),
+              }),
+            }),
+      );
+      grouped.set(messageId, blocks);
+    }
+    return new Map(
+      [...grouped].map(([messageId, blocks]) => {
+        validateToolResultContent(blocks);
+        return [messageId, Object.freeze(blocks)] as const;
+      }),
+    );
+  }
 }
 
 export function renderRecallContent(
   content: string,
   attachments: readonly UserImageAttachment[],
+  toolBlocks?: readonly ToolResultContent[],
 ): string {
+  if (toolBlocks !== undefined) {
+    const text = toolBlocks
+      .flatMap((block) => (block.type === "text" ? [block.text] : []))
+      .join("\n");
+    const notes = toolBlocks.flatMap((block) =>
+      block.type === "image"
+        ? [
+            `[Historical tool image omitted: ${block.asset.mimeType}, ${block.asset.width}x${block.asset.height}, asset=${block.asset.assetId.slice(0, 12)}….]`,
+          ]
+        : [],
+    );
+    return notes.length === 0 ? text : `${text}\n\n${notes.join("\n")}`;
+  }
   if (attachments.length === 0) return content;
   const notes = attachments.map(
     (attachment) =>
@@ -445,8 +553,9 @@ export function renderRecallContent(
 function verifyRecallContent(
   metadata: ReturnType<typeof decodeRecallRow>,
   attachments: readonly UserImageAttachment[],
+  toolBlocks?: readonly ToolResultContent[],
 ): void {
-  if (recallContentHash(metadata, attachments) !== metadata.contentSha256) {
+  if (recallContentHash(metadata, attachments, toolBlocks) !== metadata.contentSha256) {
     throw new Error("Canonical Recall content failed its integrity check.");
   }
 }
@@ -454,7 +563,21 @@ function verifyRecallContent(
 function recallContentHash(
   metadata: ReturnType<typeof decodeRecallRow>,
   attachments: readonly UserImageAttachment[],
+  toolBlocks?: readonly ToolResultContent[],
 ): string {
+  if (metadata.role === "tool") {
+    if (attachments.length > 0 || toolBlocks === undefined) {
+      throw new Error("Tool Recall message has invalid media relations.");
+    }
+    validateToolResultContent(toolBlocks);
+    if (toolResultDisplayText(toolBlocks) !== metadata.content) {
+      throw new Error("Tool Recall display projection does not match its blocks.");
+    }
+    return canonicalToolResultContentHash(toolBlocks);
+  }
+  if (toolBlocks !== undefined) {
+    throw new Error("Non-tool Recall message has tool content blocks.");
+  }
   if (metadata.role !== "user") {
     if (attachments.length > 0) {
       throw new Error("Non-user Recall message has image attachments.");

package/src/session/session-schema.ts

@@ -4,7 +4,7 @@ import type { SessionId } from "../ids/runtime-id";
 import { SessionError } from "./session-errors";
 
 export const SESSION_APPLICATION_ID = 0x544b5231;
-export const SESSION_SCHEMA_VERSION = 9;
+export const SESSION_SCHEMA_VERSION = 10;
 
 type SchemaDefinition = {
   type: "table" | "index" | "trigger" | "view";
@@ -27,7 +27,7 @@ const schemaDefinitions: readonly SchemaDefinition[] = [
     name: "session_meta",
     sql: `CREATE TABLE session_meta (
       singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
-      schema_version INTEGER NOT NULL CHECK (schema_version = 9),
+      schema_version INTEGER NOT NULL CHECK (schema_version = 10),
       schema_fingerprint TEXT NOT NULL,
       initialization_state TEXT NOT NULL CHECK (initialization_state IN ('creating', 'ready')),
       session_id TEXT NOT NULL UNIQUE,
@@ -231,6 +231,24 @@ const schemaDefinitions: readonly SchemaDefinition[] = [
       FOREIGN KEY (asset_id) REFERENCES image_assets(asset_id)
     ) STRICT`,
   },
+  {
+    type: "table",
+    name: "tool_message_content_blocks",
+    sql: `CREATE TABLE tool_message_content_blocks (
+      message_id TEXT NOT NULL,
+      position INTEGER NOT NULL CHECK (position >= 0),
+      kind TEXT NOT NULL CHECK (kind IN ('text', 'image')),
+      text_content TEXT,
+      asset_id TEXT,
+      PRIMARY KEY (message_id, position),
+      FOREIGN KEY (message_id) REFERENCES messages(message_id),
+      FOREIGN KEY (asset_id) REFERENCES image_assets(asset_id),
+      CHECK (
+        (kind = 'text' AND text_content IS NOT NULL AND length(text_content) > 0 AND asset_id IS NULL) OR
+        (kind = 'image' AND text_content IS NULL AND asset_id IS NOT NULL)
+      )
+    ) STRICT`,
+  },
   {
     type: "table",
     name: "context_surfaces",
@@ -334,7 +352,7 @@ const schemaDefinitions: readonly SchemaDefinition[] = [
       frame_id TEXT NOT NULL,
       ordinal INTEGER NOT NULL CHECK (ordinal >= 1),
       representation TEXT NOT NULL CHECK (representation = 'swapped'),
-      renderer_format TEXT NOT NULL CHECK (renderer_format IN ('swap-observation-v1', 'skill-activation-receipt-v1')),
+      renderer_format TEXT NOT NULL CHECK (renderer_format IN ('swap-observation-v1', 'swap-tool-image-v1', 'skill-activation-receipt-v1')),
       source TEXT NOT NULL,
       original_content_sha256 TEXT NOT NULL CHECK (length(original_content_sha256) = 64),
       rendered_content TEXT NOT NULL CHECK (length(rendered_content) > 0),
@@ -351,7 +369,7 @@ const schemaDefinitions: readonly SchemaDefinition[] = [
       FOREIGN KEY (message_id) REFERENCES messages(message_id),
       FOREIGN KEY (frame_id) REFERENCES protocol_frames(frame_id),
       CHECK (original_bytes = rendered_bytes + byte_savings),
-      CHECK (renderer_format <> 'swap-observation-v1' OR byte_savings > 0)
+      CHECK (renderer_format = 'swap-tool-image-v1' OR byte_savings > 0)
     ) STRICT`,
   },
   {
@@ -428,6 +446,11 @@ const schemaDefinitions: readonly SchemaDefinition[] = [
     name: "idx_message_image_attachments_asset",
     sql: "CREATE INDEX idx_message_image_attachments_asset ON message_image_attachments(asset_id)",
   },
+  {
+    type: "index",
+    name: "idx_tool_message_content_blocks_asset",
+    sql: "CREATE INDEX idx_tool_message_content_blocks_asset ON tool_message_content_blocks(asset_id)",
+  },
   {
     type: "index",
     name: "idx_turns_session_recent",
@@ -476,9 +499,32 @@ const schemaDefinitions: readonly SchemaDefinition[] = [
   ...immutableTriggers("tool_results"),
   ...immutableTriggers("image_assets"),
   ...immutableTriggers("message_image_attachments"),
+  ...immutableTriggers("tool_message_content_blocks"),
   ...immutableTriggers("context_surfaces"),
   ...immutableTriggers("context_revisions"),
   ...immutableTriggers("context_overrides"),
+  {
+    type: "trigger",
+    name: "tool_message_content_blocks_validate_insert",
+    sql: `CREATE TRIGGER tool_message_content_blocks_validate_insert
+      BEFORE INSERT ON tool_message_content_blocks
+      WHEN NOT (
+        EXISTS (
+          SELECT 1 FROM messages m
+          WHERE m.message_id = NEW.message_id AND m.role = 'tool'
+        ) AND
+        NEW.position = (
+          SELECT COUNT(*) FROM tool_message_content_blocks
+          WHERE message_id = NEW.message_id
+        ) AND
+        NOT (
+          NEW.kind = 'text' AND NEW.position > 0 AND
+          (SELECT kind FROM tool_message_content_blocks
+           WHERE message_id = NEW.message_id AND position = NEW.position - 1) = 'text'
+        )
+      )
+      BEGIN SELECT RAISE(ABORT, 'invalid tool message content block insert'); END`,
+  },
   {
     type: "trigger",
     name: "skill_activations_no_delete",
@@ -636,7 +682,7 @@ const schemaDefinitions: readonly SchemaDefinition[] = [
           SELECT 1 FROM context_revisions cr
           WHERE cr.revision_id = NEW.introduced_revision_id
             AND cr.session_id = NEW.session_id
-            AND ((cr.kind = 'swap_only' AND NEW.renderer_format = 'swap-observation-v1') OR
+            AND ((cr.kind = 'swap_only' AND NEW.renderer_format IN ('swap-observation-v1', 'swap-tool-image-v1')) OR
                  (cr.kind = 'skills_update' AND NEW.renderer_format = 'skill-activation-receipt-v1'))
             AND NEW.ordinal >= cr.keep_from_ordinal
             AND NEW.ordinal <= cr.source_through_ordinal
@@ -659,6 +705,10 @@ const schemaDefinitions: readonly SchemaDefinition[] = [
             AND tr.session_id = NEW.session_id
             AND tr.frame_id = NEW.frame_id
             AND tr.observation_sha256 = NEW.original_content_sha256
+            AND (NEW.renderer_format <> 'swap-tool-image-v1' OR
+                 (m.name = 'ViewImage' AND tr.completion_kind = 'returned' AND
+                  json_extract(tr.raw_json, '$.kind') = 'view_image' AND
+                  json_extract(tr.raw_json, '$.ok') = 1))
             AND (NEW.renderer_format <> 'skill-activation-receipt-v1' OR
                  (m.name = 'Skill' AND tr.completion_kind = 'returned' AND
                   json_extract(tr.raw_json, '$.kind') = 'skill' AND
@@ -845,7 +895,7 @@ const schemaDefinitions: readonly SchemaDefinition[] = [
   },
 ];
 
-export const SESSION_SCHEMA_V9_FINGERPRINT = sha256(
+export const SESSION_SCHEMA_V10_FINGERPRINT = sha256(
   stableJsonStringify({
     definitions: schemaDefinitions.map((definition) => ({
       type: definition.type,
@@ -1016,7 +1066,7 @@ export function upgradeActiveTurnRetirementContract(database: Database): boolean
        WHERE singleton = 1 AND schema_fingerprint = ?`,
     )
     .run(
-      SESSION_SCHEMA_V9_FINGERPRINT,
+      SESSION_SCHEMA_V10_FINGERPRINT,
       PRE_ACTIVE_TURN_RETIREMENT_SCHEMA_V9_FINGERPRINT,
     );
   database.exec(metadataTrigger.sql);
@@ -1092,7 +1142,7 @@ export function verifyReadableSessionSchema(
 
   let expectedDefinitions: readonly SchemaDefinition[];
   let compatibility: "current" | "migratable";
-  if (meta.schema_fingerprint === SESSION_SCHEMA_V9_FINGERPRINT) {
+  if (meta.schema_fingerprint === SESSION_SCHEMA_V10_FINGERPRINT) {
     expectedDefinitions = schemaDefinitions;
     compatibility = "current";
   } else if (
@@ -1195,7 +1245,7 @@ function verifySessionSchemaDefinitions(
     throw new SessionError(
       "SESSION_SCHEMA_INVALID",
       "verify_schema",
-      "Session FTS configuration does not match schema v9.",
+      "Session FTS configuration does not match schema v10.",
       { sessionId },
     );
   }