tinker-agent 1.0.65 → 1.2.0

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

@@ -4,7 +4,14 @@ import {
   parseMessageSource,
   type MessageSource,
 } from "../context/context-source";
-import { contentHash } from "../context/protocol-frame";
+import { contentHash, userMessageHash } from "../context/protocol-frame";
+import {
+  parseImageAssetId,
+  parseImageAttachmentId,
+  validateUserMessage,
+  type UserImageAttachment,
+  type UserMessage,
+} from "../image/image-types";
 import type { MessageId, SessionId } from "../ids/runtime-id";
 import { SessionError, sessionReadError } from "./session-errors";
 
@@ -110,6 +117,21 @@ type RecallRow = {
   observation_sha256?: unknown;
 };
 
+type RecallImageRow = {
+  message_id: unknown;
+  attachment_id: unknown;
+  position: unknown;
+  label: unknown;
+  range_start: unknown;
+  range_end: unknown;
+  original_name: unknown;
+  asset_id: unknown;
+  mime_type: unknown;
+  byte_length: unknown;
+  width: unknown;
+  height: unknown;
+};
+
 export function createSessionHistoryReader(input: {
   database: Database;
   sessionId: SessionId;
@@ -203,11 +225,18 @@ class SqliteSessionHistoryReader implements SessionHistoryReader {
 
     let decoded: Array<RecallSearchHit & { content: string }>;
     try {
+      const imageAttachments = this.loadImageAttachments(
+        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);
         return {
           ...metadata,
-          excerpt: buildExcerpt(metadata.content, input.query),
+          content,
+          excerpt: buildExcerpt(content, input.query),
         };
       });
     } catch (error) {
@@ -258,12 +287,15 @@ class SqliteSessionHistoryReader implements SessionHistoryReader {
     }
 
     let metadata: ReturnType<typeof decodeRecallRow>;
+    let attachments: readonly UserImageAttachment[];
     try {
       metadata = decodeRecallRow(row);
+      attachments =
+        this.loadImageAttachments([metadata.messageId]).get(metadata.messageId) ?? [];
     } catch (error) {
       throw sessionReadError("decode_recall_get", this.sessionId, error);
     }
-    const actualHash = contentHash(metadata.content);
+    const actualHash = recallContentHash(metadata, attachments);
     const observationHash = row.observation_sha256;
     if (
       actualHash !== metadata.contentSha256 ||
@@ -277,7 +309,8 @@ class SqliteSessionHistoryReader implements SessionHistoryReader {
       );
     }
 
-    const page = sliceUtf8Page(metadata.content, input.byteOffset, input.byteLimit);
+    const renderedContent = renderRecallContent(metadata.content, attachments);
+    const page = sliceUtf8Page(renderedContent, input.byteOffset, input.byteLimit);
     return Object.freeze({
       source: formatMessageSource(metadata.messageId),
       messageId: metadata.messageId,
@@ -324,6 +357,112 @@ class SqliteSessionHistoryReader implements SessionHistoryReader {
     }
     return requested ?? maximum;
   }
+
+  private loadImageAttachments(
+    messageIds: readonly MessageId[],
+  ): ReadonlyMap<MessageId, readonly UserImageAttachment[]> {
+    if (messageIds.length === 0) {
+      return new Map();
+    }
+    const unique = [...new Set(messageIds)];
+    let rows: RecallImageRow[];
+    try {
+      this.requireStoreOpen();
+      rows = this.database
+        .query(
+          `SELECT
+             mia.message_id, mia.attachment_id, mia.position, mia.label,
+             mia.range_start, mia.range_end, mia.original_name,
+             ia.asset_id, ia.mime_type, ia.byte_length, ia.width, ia.height
+           FROM message_image_attachments mia
+           JOIN image_assets ia ON ia.asset_id = mia.asset_id
+           WHERE mia.message_id IN (${unique.map(() => "?").join(", ")})
+           ORDER BY mia.message_id, mia.position`,
+        )
+        .all(...unique) as RecallImageRow[];
+    } catch (error) {
+      throw sessionReadError("read_recall_images", this.sessionId, error);
+    }
+
+    const grouped = new Map<MessageId, UserImageAttachment[]>();
+    for (const row of rows) {
+      const messageId = nonEmptyString(row.message_id, "message_id") as MessageId;
+      const attachments = grouped.get(messageId) ?? [];
+      const position = nonNegativeSafeInteger(row.position, "image position");
+      if (position !== attachments.length) {
+        throw new Error("Recall image positions are not contiguous.");
+      }
+      attachments.push(
+        Object.freeze({
+          attachmentId: parseImageAttachmentId(
+            nonEmptyString(row.attachment_id, "attachment_id"),
+          ),
+          assetId: parseImageAssetId(nonEmptyString(row.asset_id, "asset_id")),
+          label: nonEmptyString(row.label, "image label"),
+          range: Object.freeze({
+            start: nonNegativeSafeInteger(row.range_start, "image range start"),
+            end: safeInteger(row.range_end, "image range end"),
+          }),
+          mimeType: enumValue(
+            row.mime_type,
+            ["image/png", "image/jpeg", "image/webp"] as const,
+            "image MIME type",
+          ),
+          byteLength: safeInteger(row.byte_length, "image byte length"),
+          width: safeInteger(row.width, "image width"),
+          height: safeInteger(row.height, "image height"),
+          originalName: nonEmptyString(row.original_name, "original image name"),
+        }),
+      );
+      grouped.set(messageId, attachments);
+    }
+    return new Map(
+      [...grouped].map(([messageId, attachments]) => [
+        messageId,
+        Object.freeze(attachments),
+      ]),
+    );
+  }
+}
+
+export function renderRecallContent(
+  content: string,
+  attachments: readonly UserImageAttachment[],
+): string {
+  if (attachments.length === 0) return content;
+  const notes = attachments.map(
+    (attachment) =>
+      `[Historical image omitted: label=${attachment.label}, originalName=${JSON.stringify(attachment.originalName)}. Ask the user to reattach it.]`,
+  );
+  return `${content}\n\n${notes.join("\n")}`;
+}
+
+function verifyRecallContent(
+  metadata: ReturnType<typeof decodeRecallRow>,
+  attachments: readonly UserImageAttachment[],
+): void {
+  if (recallContentHash(metadata, attachments) !== metadata.contentSha256) {
+    throw new Error("Canonical Recall content failed its integrity check.");
+  }
+}
+
+function recallContentHash(
+  metadata: ReturnType<typeof decodeRecallRow>,
+  attachments: readonly UserImageAttachment[],
+): string {
+  if (metadata.role !== "user") {
+    if (attachments.length > 0) {
+      throw new Error("Non-user Recall message has image attachments.");
+    }
+    return contentHash(metadata.content);
+  }
+  const message: UserMessage = Object.freeze({
+    role: "user",
+    content: metadata.content,
+    ...(attachments.length === 0 ? {} : { attachments }),
+  });
+  validateUserMessage(message);
+  return userMessageHash(message);
 }
 
 function searchPredicates(
@@ -523,6 +662,14 @@ function safeInteger(value: unknown, name: string): number {
   return number;
 }
 
+function nonNegativeSafeInteger(value: unknown, name: string): number {
+  const number = typeof value === "bigint" ? Number(value) : value;
+  if (typeof number !== "number" || !Number.isSafeInteger(number) || number < 0) {
+    throw new Error(`${name} must be a non-negative safe integer.`);
+  }
+  return number;
+}
+
 function enumValue<const TValues extends readonly string[]>(
   value: unknown,
   values: TValues,

package/src/session/session-last-response-reader.ts

@@ -0,0 +1,189 @@
+import { Database } from "bun:sqlite";
+import { realpath } from "node:fs/promises";
+import { contentHash } from "../context/protocol-frame";
+import type { SessionId } from "../ids/runtime-id";
+import { SessionError, sessionOpenError, sessionReadError } from "./session-errors";
+import { verifySessionSchema } from "./session-schema";
+import { decodeStoredToolCalls, sessionDatabasePath } from "./session-store";
+
+const OPERATION = "read_last_assistant_response";
+
+export async function readLastAssistantResponse(input: {
+  workspaceRoot: string;
+  sessionId: SessionId;
+}): Promise<string | undefined> {
+  const workspaceRoot = await realpath(input.workspaceRoot);
+  let database: Database;
+  try {
+    database = new Database(sessionDatabasePath(workspaceRoot, input.sessionId), {
+      readonly: true,
+      strict: true,
+      safeIntegers: true,
+    });
+  } catch (error) {
+    throw sessionOpenError(OPERATION, input.sessionId, error);
+  }
+
+  try {
+    return readResponse(database, {
+      workspaceRoot,
+      sessionId: input.sessionId,
+    });
+  } finally {
+    database.close();
+  }
+}
+
+function readResponse(
+  database: Database,
+  input: { workspaceRoot: string; sessionId: SessionId },
+): string | undefined {
+  try {
+    verifySessionSchema(database, input.sessionId);
+    const metaRows = database
+      .query("SELECT session_id, workspace_root FROM session_meta")
+      .all() as Array<Record<string, unknown>>;
+    if (
+      metaRows.length !== 1 ||
+      metaRows[0]?.session_id !== input.sessionId ||
+      metaRows[0]?.workspace_root !== input.workspaceRoot
+    ) {
+      throw integrityError(
+        input.sessionId,
+        "Session identity does not match the requested last response.",
+      );
+    }
+
+    const row = database
+      .query(
+        `SELECT
+           t.turn_id,
+           t.turn_number,
+           t.final_message_id,
+           m.message_id,
+           m.session_id AS message_session_id,
+           m.turn_id AS message_turn_id,
+           m.role,
+           m.content,
+           m.content_sha256,
+           m.tool_calls_json
+         FROM turns t
+         LEFT JOIN messages m ON m.message_id = t.final_message_id
+         WHERE t.session_id = ? AND t.status = 'completed'
+         ORDER BY t.turn_number DESC
+         LIMIT 1`,
+      )
+      .get(input.sessionId) as Record<string, unknown> | null;
+    if (row === null) {
+      return undefined;
+    }
+
+    return decodeResponse(row, input.sessionId);
+  } catch (error) {
+    throw sessionReadError(OPERATION, input.sessionId, error);
+  }
+}
+
+function decodeResponse(
+  row: Record<string, unknown>,
+  sessionId: SessionId,
+): string | undefined {
+  const turnId = requireNonEmptyString(row.turn_id, "turn ID", sessionId);
+  requirePositiveInteger(row.turn_number, "turn number", sessionId);
+  const finalMessageId = requireNonEmptyString(
+    row.final_message_id,
+    "final message ID",
+    sessionId,
+  );
+  if (
+    row.message_id !== finalMessageId ||
+    row.message_session_id !== sessionId ||
+    row.message_turn_id !== turnId
+  ) {
+    throw integrityError(
+      sessionId,
+      `Final message ${finalMessageId} does not match turn ${turnId}.`,
+    );
+  }
+  if (row.role !== "assistant") {
+    throw integrityError(
+      sessionId,
+      `Final message ${finalMessageId} is not assistant.`,
+    );
+  }
+
+  const toolCalls =
+    row.tool_calls_json === null
+      ? []
+      : decodeStoredToolCalls(
+          requireNonEmptyString(
+            row.tool_calls_json,
+            "final message tool calls",
+            sessionId,
+          ),
+        );
+  if (toolCalls.length !== 0) {
+    throw integrityError(
+      sessionId,
+      `Final message ${finalMessageId} still contains tool calls.`,
+    );
+  }
+
+  const content = requireNullableString(
+    row.content,
+    "final message content",
+    sessionId,
+  );
+  const storedHash = requireNonEmptyString(
+    row.content_sha256,
+    "final message content hash",
+    sessionId,
+  );
+  if (contentHash(content) !== storedHash) {
+    throw integrityError(
+      sessionId,
+      `Final message ${finalMessageId} content hash does not match.`,
+    );
+  }
+  return content === null || content.trim() === "" ? undefined : content;
+}
+
+function requireNonEmptyString(
+  value: unknown,
+  name: string,
+  sessionId: SessionId,
+): string {
+  if (typeof value !== "string" || value === "") {
+    throw integrityError(sessionId, `Stored ${name} must be non-empty text.`);
+  }
+  return value;
+}
+
+function requireNullableString(
+  value: unknown,
+  name: string,
+  sessionId: SessionId,
+): string | null {
+  if (value !== null && typeof value !== "string") {
+    throw integrityError(sessionId, `Stored ${name} must be text or null.`);
+  }
+  return value;
+}
+
+function requirePositiveInteger(
+  value: unknown,
+  name: string,
+  sessionId: SessionId,
+): number {
+  const number = typeof value === "bigint" ? Number(value) : value;
+  if (typeof number !== "number" || !Number.isSafeInteger(number) || number < 1) {
+    throw integrityError(sessionId, `Stored ${name} must be a positive integer.`);
+  }
+  return number;
+}
+
+function integrityError(sessionId: SessionId, message: string): SessionError {
+  return new SessionError("SESSION_INTEGRITY_FAILED", OPERATION, message, {
+    sessionId,
+  });
+}