tinker-agent 1.0.65 → 1.2.0

package/src/model/openai-chat-stream.ts

@@ -0,0 +1,272 @@
+type ProviderContext = { provider: string; model: string };
+
+type ToolCallAccumulator = {
+  id?: string;
+  type?: "function";
+  name?: string;
+  arguments: string;
+};
+
+/**
+ * Reassembles OpenAI chat completion stream chunks into a non-streaming
+ * chat.completion-shaped object so the result can be validated and mapped by
+ * fromOpenAIChatCompletion exactly like a non-streaming response.
+ */
+export function accumulateOpenAIChatCompletionChunks(
+  chunks: readonly unknown[],
+  options: ProviderContext,
+): Record<string, unknown> {
+  if (chunks.length === 0) {
+    throw providerStreamError(options, "chunks", "must not be empty");
+  }
+
+  let role: "assistant" | undefined;
+  let content: string | undefined;
+  let reasoningContent: string | undefined;
+  let finishReason: string | undefined;
+  let resolvedModel: string | undefined;
+  let usage: Record<string, unknown> | undefined;
+  const toolCalls: ToolCallAccumulator[] = [];
+
+  chunks.forEach((chunk, chunkIndex) => {
+    const path = `chunk[${chunkIndex}]`;
+    const record = requireRecord(chunk, path, options);
+
+    if (record.model !== undefined && record.model !== null) {
+      if (typeof record.model !== "string" || record.model.trim() === "") {
+        throw providerStreamError(options, `${path}.model`, "must be a string");
+      }
+      if (resolvedModel !== undefined && resolvedModel !== record.model) {
+        throw providerStreamError(
+          options,
+          `${path}.model`,
+          `conflicts with previously streamed model ${JSON.stringify(resolvedModel)}`,
+        );
+      }
+      resolvedModel = record.model;
+    }
+
+    if (record.usage !== undefined && record.usage !== null) {
+      usage = requireRecord(record.usage, `${path}.usage`, options);
+    }
+
+    if (record.choices === undefined || record.choices === null) {
+      return;
+    }
+    if (!Array.isArray(record.choices)) {
+      throw providerStreamError(options, `${path}.choices`, "must be an array");
+    }
+    // The usage-only final chunk from stream_options.include_usage has empty choices.
+    for (const [choiceIndex, rawChoice] of record.choices.entries()) {
+      const choicePath = `${path}.choices[${choiceIndex}]`;
+      const choice = requireRecord(rawChoice, choicePath, options);
+      if (choice.index !== 0) {
+        throw providerStreamError(options, `${choicePath}.index`, "must be 0");
+      }
+      if (typeof choice.finish_reason === "string") {
+        finishReason = choice.finish_reason;
+      } else if (choice.finish_reason !== undefined && choice.finish_reason !== null) {
+        throw providerStreamError(
+          options,
+          `${choicePath}.finish_reason`,
+          "must be a string or null",
+        );
+      }
+
+      if (choice.delta === undefined || choice.delta === null) {
+        continue;
+      }
+      const deltaPath = `${choicePath}.delta`;
+      const delta = asRecord(choice.delta, deltaPath, options);
+      if (delta.role !== undefined && delta.role !== null) {
+        if (delta.role !== "assistant") {
+          throw providerStreamError(
+            options,
+            `${deltaPath}.role`,
+            'must be "assistant"',
+          );
+        }
+        role = delta.role;
+      }
+      content = appendOptionalText(
+        content,
+        delta.content,
+        `${deltaPath}.content`,
+        options,
+      );
+      reasoningContent = appendOptionalText(
+        reasoningContent,
+        delta.reasoning_content,
+        `${deltaPath}.reasoning_content`,
+        options,
+      );
+      if (delta.tool_calls === undefined || delta.tool_calls === null) {
+        continue;
+      }
+      if (!Array.isArray(delta.tool_calls)) {
+        throw providerStreamError(
+          options,
+          `${deltaPath}.tool_calls`,
+          "must be an array",
+        );
+      }
+      for (const [fragmentIndex, rawFragment] of delta.tool_calls.entries()) {
+        mergeToolCallFragment(
+          toolCalls,
+          rawFragment,
+          `${deltaPath}.tool_calls[${fragmentIndex}]`,
+          options,
+        );
+      }
+    }
+  });
+
+  // Only fields the provider actually streamed are emitted; the strict
+  // non-streaming mapper rejects a missing role, id, type, or name.
+  const message: Record<string, unknown> = {
+    ...(role === undefined ? {} : { role }),
+    content: content ?? null,
+    ...(reasoningContent === undefined ? {} : { reasoning_content: reasoningContent }),
+    ...(toolCalls.length === 0
+      ? {}
+      : {
+          tool_calls: toolCalls.map((call) => ({
+            ...(call.id === undefined ? {} : { id: call.id }),
+            ...(call.type === undefined ? {} : { type: call.type }),
+            function: {
+              ...(call.name === undefined ? {} : { name: call.name }),
+              arguments: call.arguments,
+            },
+          })),
+        }),
+  };
+
+  return {
+    object: "chat.completion",
+    choices: [
+      {
+        index: 0,
+        message,
+        finish_reason: finishReason ?? null,
+      },
+    ],
+    ...(usage === undefined ? {} : { usage }),
+    ...(resolvedModel === undefined ? {} : { model: resolvedModel }),
+  };
+}
+
+function mergeToolCallFragment(
+  toolCalls: ToolCallAccumulator[],
+  rawFragment: unknown,
+  path: string,
+  options: ProviderContext,
+): void {
+  const fragment = requireRecord(rawFragment, path, options);
+  const index = fragment.index;
+  if (!Number.isSafeInteger(index) || (index as number) < 0) {
+    throw providerStreamError(
+      options,
+      `${path}.index`,
+      "must be a non-negative integer",
+    );
+  }
+  if ((index as number) > toolCalls.length) {
+    throw providerStreamError(
+      options,
+      `${path}.index`,
+      `skips tool call index ${toolCalls.length}`,
+    );
+  }
+  const entry =
+    toolCalls[index as number] ?? (toolCalls[index as number] = { arguments: "" });
+
+  if (fragment.type !== undefined && fragment.type !== null) {
+    if (fragment.type !== "function") {
+      throw providerStreamError(options, `${path}.type`, 'must be "function"');
+    }
+    entry.type = fragment.type;
+  }
+  if (fragment.id !== undefined && fragment.id !== null) {
+    if (typeof fragment.id !== "string" || fragment.id === "") {
+      throw providerStreamError(options, `${path}.id`, "must be a non-empty string");
+    }
+    if (entry.id !== undefined && entry.id !== fragment.id) {
+      throw providerStreamError(
+        options,
+        `${path}.id`,
+        `conflicts with previously streamed id ${JSON.stringify(entry.id)}`,
+      );
+    }
+    entry.id = fragment.id;
+  }
+  if (fragment.function === undefined || fragment.function === null) {
+    return;
+  }
+  const fn = asRecord(fragment.function, `${path}.function`, options);
+  if (fn.name !== undefined && fn.name !== null) {
+    if (typeof fn.name !== "string") {
+      throw providerStreamError(options, `${path}.function.name`, "must be a string");
+    }
+    // Later name fragments replace the value (OpenAI aggregation semantics);
+    // only arguments accumulate.
+    entry.name = fn.name;
+  }
+  if (fn.arguments !== undefined && fn.arguments !== null) {
+    if (typeof fn.arguments !== "string") {
+      throw providerStreamError(
+        options,
+        `${path}.function.arguments`,
+        "must be a string",
+      );
+    }
+    entry.arguments += fn.arguments;
+  }
+}
+
+function appendOptionalText(
+  current: string | undefined,
+  value: unknown,
+  path: string,
+  options: ProviderContext,
+): string | undefined {
+  if (value === undefined || value === null) {
+    return current;
+  }
+  if (typeof value !== "string") {
+    throw providerStreamError(options, path, "must be a string or null");
+  }
+  return (current ?? "") + value;
+}
+
+function asRecord(
+  value: unknown,
+  path: string,
+  options: ProviderContext,
+): Record<string, unknown> {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw providerStreamError(options, path, "must be an object");
+  }
+  return value as Record<string, unknown>;
+}
+
+function requireRecord(
+  value: unknown,
+  path: string,
+  options: ProviderContext,
+): Record<string, unknown> {
+  const record = asRecord(value, path, options);
+  if (Object.keys(record).length === 0) {
+    throw providerStreamError(options, path, "must be a non-empty object");
+  }
+  return record;
+}
+
+function providerStreamError(
+  options: ProviderContext,
+  path: string,
+  detail: string,
+): Error {
+  return new Error(
+    `Invalid provider stream (provider=${options.provider}, model=${options.model}): ${path} ${detail}.`,
+  );
+}

package/src/model/prompt-prefix-hash.ts

@@ -1,5 +1,5 @@
 import type { PreparedModelRequest, PreparedPromptSegment } from "./model-client";
-import { sha256 } from "./model-request-preflight";
+import { sha256, stableJsonStringify } from "./model-request-preflight";
 
 export type PromptPrefixFingerprint = {
   readonly requestConfigHash: string;
@@ -18,9 +18,7 @@ export function promptPrefixHashes(
     if (previous === undefined) {
       throw new Error("Prompt prefix hash chain has no seed.");
     }
-    hashes.push(
-      sha256(`${previous}\u0000${segment.kind}\u0000${segment.normalizedText}`),
-    );
+    hashes.push(sha256(`${previous}\u0000${stableJsonStringify(segment)}`));
   }
   return Object.freeze(hashes);
 }

package/src/model/token-estimator.ts

@@ -40,6 +40,10 @@ export function estimatePromptSegments(
 
   for (const segment of segments) {
     exact[breakdownKey(segment.kind)] += estimateText(segment.normalizedText);
+    exact[breakdownKey(segment.kind)] += (segment.media ?? []).reduce(
+      (total, media) => total + media.planningTokens,
+      0,
+    );
   }
 
   const totalTokens = Math.ceil(

package/src/observation/observation-builder.ts

@@ -8,6 +8,7 @@ import type {
   McpToolRawResult,
   ReadFileRawResult,
   RecallRawResult,
+  SkillRawResult,
   TaskListRawResult,
   TaskOutputRawResult,
   TaskStopRawResult,
@@ -32,6 +33,8 @@ export class ObservationBuilder {
         return { content: renderReadObservation(input.raw) };
       case "recall":
         return { content: renderRecallObservation(input.raw) };
+      case "skill":
+        return { content: renderSkillObservation(input.raw) };
       case "write":
         return { content: renderWriteObservation(input.raw) };
       case "edit":
@@ -224,6 +227,32 @@ function renderRecallObservation(raw: RecallRawResult): string {
   return [header, ...hits].join("\n\n");
 }
 
+export function renderSkillObservation(raw: SkillRawResult): string {
+  if (!raw.ok) {
+    return `Skill failed for ${raw.name || "(unknown skill)"} (${raw.errorCode}): ${raw.error}`;
+  }
+  if (raw.status === "already_loaded") {
+    return `Agent Skill ${raw.name} is already loaded for this turn (lifecycle=${raw.lifecycle}).`;
+  }
+  if (raw.status === "already_active") {
+    return `Agent Skill ${raw.name} is already active in the current system surface.`;
+  }
+
+  const content = raw.content + (raw.content.endsWith("\n") ? "" : "\n");
+  return `<agent_skill name=${JSON.stringify(raw.name)} scope=${JSON.stringify(raw.scope)}>
+Skill directory: ${raw.directory}
+Relative paths in this skill resolve from that directory.
+Do not modify the skill itself unless the user explicitly asks.
+
+<skill_file>
+${content}</skill_file>
+
+<skill_resources truncated=${JSON.stringify(String(raw.resourcesTruncated))}>
+${raw.resources.length === 0 ? "(no listed resources)" : raw.resources.join("\n")}
+</skill_resources>
+</agent_skill>`;
+}
+
 function renderWriteObservation(raw: WriteFileRawResult): string {
   if (!raw.ok) {
     const guidance = raw.requiredReadBeforeWrite

package/src/session/resume-projection.ts

@@ -4,8 +4,8 @@ import { Database } from "bun:sqlite";
 import type { ToolCall } from "../agent/types";
 import type { SessionId } from "../ids/runtime-id";
 import {
-  assertMatchingContextBudget,
   createModelContextProfile,
+  deriveModelContextBudget,
   type ModelContextBudget,
   type ModelContextProfile,
 } from "../model/model-context-profile";
@@ -25,6 +25,20 @@ import {
 import { SessionError } from "./session-errors";
 import { verifySessionSchema } from "./session-schema";
 import { decodeStoredToolCalls, decodeStoredToolRawResult } from "./session-store";
+import {
+  MAX_TIMELINE_PROMPT_CODE_POINTS,
+  projectUserMessage,
+  truncateUserPromptProjection,
+  type UserPromptProjection,
+} from "../agent/user-prompt-projection";
+import {
+  parseImageAssetId,
+  parseImageAttachmentId,
+  validateUserMessage,
+  type UserImageAttachment,
+  type UserMessage,
+} from "../image/image-types";
+import { userMessageHash } from "../context/protocol-frame";
 
 export class ResumeProjectionReader {
   static async read(input: {
@@ -78,7 +92,7 @@ export class ResumeProjectionReader {
       const recentTurns = turns.map((turn) => projectTurn(database, turn, policy));
       const last = recentTurns.at(-1);
       const terminal = terminalProjection(last);
-      const context = decodeContextContract(meta.runtime_contract_json);
+      const context = decodeContextCompatibility(meta.session_compatibility_json);
       return {
         status: terminal.status,
         sessionId: input.sessionId,
@@ -100,20 +114,19 @@ export class ResumeProjectionReader {
   }
 }
 
-function decodeContextContract(value: unknown): {
+function decodeContextCompatibility(value: unknown): {
   profile: ModelContextProfile;
   budget: ModelContextBudget;
 } {
   if (typeof value !== "string") {
-    throw new Error("Session runtime contract is missing.");
+    throw new Error("Session compatibility contract is missing.");
   }
   const parsed = JSON.parse(value) as unknown;
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new Error("Session runtime contract must be an object.");
+    throw new Error("Session compatibility contract must be an object.");
   }
   const record = parsed as Record<string, unknown>;
   const profileRecord = objectValue(record.contextProfile, "contextProfile");
-  const budgetRecord = objectValue(record.contextBudget, "contextBudget");
   const profile = createModelContextProfile({
     contextWindowTokens: positiveInteger(
       profileRecord.contextWindowTokens,
@@ -124,31 +137,7 @@ function decodeContextContract(value: unknown): {
       "maxSupportedOutputTokens",
     ),
   });
-  const budget: ModelContextBudget = {
-    contextWindowTokens: positiveInteger(
-      budgetRecord.contextWindowTokens,
-      "budget.contextWindowTokens",
-    ),
-    maxSupportedOutputTokens: positiveInteger(
-      budgetRecord.maxSupportedOutputTokens,
-      "budget.maxSupportedOutputTokens",
-    ),
-    requestMaxOutputTokens: positiveInteger(
-      budgetRecord.requestMaxOutputTokens,
-      "requestMaxOutputTokens",
-    ),
-    inputBudgetTokens: positiveInteger(
-      budgetRecord.inputBudgetTokens,
-      "inputBudgetTokens",
-    ),
-    triggerRatio: 0.8,
-    triggerTokens: positiveInteger(budgetRecord.triggerTokens, "triggerTokens"),
-  };
-  if (budgetRecord.triggerRatio !== 0.8) {
-    throw new Error("Session context triggerRatio must be 0.8.");
-  }
-  assertMatchingContextBudget(profile, budget);
-  return { profile, budget };
+  return { profile, budget: deriveModelContextBudget(profile) };
 }
 
 function projectTurn(
@@ -178,11 +167,16 @@ function projectTurn(
   if (prompt === undefined) {
     throw new Error(`Turn ${turnId} user message disappeared.`);
   }
+  const userPrompt = truncateUserPromptProjection(
+    readUserPromptProjection(database, prompt),
+    MAX_TIMELINE_PROMPT_CODE_POINTS,
+  );
   const allItems: TimelineItem[] = [
     {
       id: `resume-${requireString(prompt.message_id, "message_id")}`,
       label: "prompt",
-      text: boundedText(requireString(prompt.content, "user content")),
+      text: userPrompt.text,
+      userPrompt,
       status: "text",
     },
   ];
@@ -269,6 +263,71 @@ function projectTurn(
   };
 }
 
+function readUserPromptProjection(
+  database: Database,
+  prompt: Record<string, unknown>,
+): UserPromptProjection {
+  const messageId = requireString(prompt.message_id, "message_id");
+  const text = requireString(prompt.content, "user content");
+  const chars = [...text];
+  const rows = database
+    .query(
+      `SELECT 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 = ? ORDER BY mia.position`,
+    )
+    .all(messageId) as Array<Record<string, unknown>>;
+  const attachments = rows.map((row, position): UserImageAttachment => {
+    if (safeNumber(row.position, "image position") !== position) {
+      throw new Error(`Image positions for message ${messageId} are not continuous.`);
+    }
+    const start = safeNumber(row.range_start, "image range_start");
+    const end = safeNumber(row.range_end, "image range_end");
+    const label = requireString(row.label, "image label");
+    if (
+      start < 0 ||
+      end <= start ||
+      end > chars.length ||
+      chars.slice(start, end).join("") !== label
+    ) {
+      throw new Error(`Image range for message ${messageId} is invalid.`);
+    }
+    return Object.freeze({
+      attachmentId: parseImageAttachmentId(
+        requireString(row.attachment_id, "image attachment_id"),
+      ),
+      assetId: parseImageAssetId(requireString(row.asset_id, "image asset_id")),
+      label,
+      range: Object.freeze({ start, end }),
+      mimeType: enumValue(
+        row.mime_type,
+        ["image/png", "image/jpeg", "image/webp"] as const,
+        "image mime_type",
+      ),
+      byteLength: positiveInteger(row.byte_length, "image byte_length"),
+      width: positiveInteger(row.width, "image width"),
+      height: positiveInteger(row.height, "image height"),
+      originalName: requireString(row.original_name, "image original_name"),
+    });
+  });
+  const message: UserMessage = Object.freeze({
+    role: "user",
+    content: text,
+    ...(attachments.length === 0 ? {} : { attachments: Object.freeze(attachments) }),
+  });
+  validateUserMessage(message);
+  if (
+    userMessageHash(message) !==
+    requireString(prompt.content_sha256, "user content_sha256")
+  ) {
+    throw new Error(`User message ${messageId} failed its integrity check.`);
+  }
+  return projectUserMessage(message);
+}
+
 function projectIteration(
   row: Record<string, unknown>,
   turnId: string,
@@ -586,10 +645,11 @@ function objectValue(value: unknown, name: string): Record<string, unknown> {
 }
 
 function positiveInteger(value: unknown, name: string): number {
-  if (!Number.isSafeInteger(value) || (value as number) < 1) {
+  const number = typeof value === "bigint" ? Number(value) : value;
+  if (typeof number !== "number" || !Number.isSafeInteger(number) || number < 1) {
     throw new Error(`${name} must be a positive integer.`);
   }
-  return value as number;
+  return number;
 }
 
 function timestamp(value: unknown, name: string): string {

package/src/session/session-catalog.ts

@@ -178,7 +178,7 @@ async function readSummary(
     return {
       sessionId,
       modelName: requireString(row.model_name, "model_name"),
-      ...profileNameFromRuntimeContract(row.runtime_contract_json),
+      ...profileNameFromCompatibility(row.session_compatibility_json),
       createdAt: requireTimestamp(row.created_at, "created_at"),
       updatedAt: requireTimestamp(row.updated_at, "updated_at"),
       turnCount,
@@ -206,16 +206,16 @@ async function readSummary(
   }
 }
 
-function profileNameFromRuntimeContract(value: unknown): { profileName?: string } {
+function profileNameFromCompatibility(value: unknown): { profileName?: string } {
   if (value === null) {
     return {};
   }
   if (typeof value !== "string") {
-    throw new Error("Session runtime contract must be JSON text.");
+    throw new Error("Session compatibility contract must be JSON text.");
   }
   const parsed = JSON.parse(value) as unknown;
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new Error("Session runtime contract must be an object.");
+    throw new Error("Session compatibility contract must be an object.");
   }
   const profileName = (parsed as Record<string, unknown>).profileName;
   if (profileName === undefined) {

package/src/session/session-errors.ts

@@ -16,7 +16,7 @@ export type SessionErrorCode =
   | "SESSION_SCHEMA_INVALID"
   | "SESSION_INTEGRITY_FAILED"
   | "SESSION_WORKSPACE_MISMATCH"
-  | "SESSION_RUNTIME_MISMATCH"
+  | "SESSION_COMPATIBILITY_MISMATCH"
   | "SESSION_PROTOCOL_INVALID"
   | "SESSION_RECALL_INDEX_INVALID"
   | "SESSION_READ_FAILED"