tinker-agent 1.0.65 → 1.2.0

package/package.json

@@ -1,45 +1,69 @@
 {
   "name": "tinker-agent",
-  "version": "1.0.65",
+  "version": "1.2.0",
   "description": "A personal coding agent with an interactive TUI and one-shot CLI.",
-  "license": "UNLICENSED",
+  "license": "Apache-2.0",
   "type": "module",
   "bin": {
-    "tinker": "src/cli/index.ts",
-    "tinker-agent": "src/cli/index.ts"
+    "tinker": "bin/tinker.js"
   },
   "files": [
+    "bin",
+    "LICENSE",
+    "NOTICE",
+    "CHANGELOG.md",
     "src/agent",
     "src/cli",
     "src/context",
     "src/events",
     "src/ids",
+    "src/image",
     "src/instructions",
     "src/mcp",
     "src/model",
     "src/observation",
     "src/session",
+    "src/skills",
     "src/tools",
     "src/tui",
-    "patches",
-    "README.md"
+    "patches"
   ],
   "engines": {
-    "bun": ">=1.3.0"
+    "node": ">=20.0.0"
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ishowshao/tinker.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ishowshao/tinker/issues"
+  },
+  "homepage": "https://github.com/ishowshao/tinker#readme",
   "publishConfig": {
     "access": "public"
   },
+  "bundledDependencies": [
+    "markdansi"
+  ],
   "scripts": {
     "bench:long-session": "bun scripts/bench-long-session-memory.ts",
+    "bench:i3-provider-smoke": "bun scripts/bench-i3-provider-smoke.ts",
+    "bench:k3-image-live": "bun scripts/k3-image-live-smoke.ts",
+    "bench:i4-active-recall": "bun scripts/bench-i4-active-recall.ts",
+    "qualify:i4-active-recall": "bun scripts/qualify-i4-active-recall.ts",
+    "release:verify": "bun scripts/verify-release-package.ts",
     "bench:recall": "bun scripts/bench-recall.ts",
     "bench:smoke": "bun scripts/bench-smoke.ts",
+    "chrome:build": "bun packages/tinker-chrome/scripts/build.ts",
+    "chrome:diagnose": "bun packages/tinker-chrome/src/cli.ts diagnose",
+    "chrome:install-host": "bun packages/tinker-chrome/src/cli.ts install-host",
+    "chrome:mcp": "bun packages/tinker-chrome/src/cli.ts mcp",
     "tinker": "bun src/cli/index.ts",
     "check": "bun run typecheck && bun run format:check && bun run lint && bun test && bun run bench:smoke",
     "format": "biome format --write .",
     "format:check": "biome format .",
-    "lint": "eslint \"src/**/*.{ts,tsx}\" \"scripts/**/*.ts\" --max-warnings=0",
-    "lint:fix": "eslint \"src/**/*.{ts,tsx}\" \"scripts/**/*.ts\" --fix",
+    "lint": "eslint \"bin/**/*.js\" \"src/**/*.{ts,tsx}\" \"scripts/**/*.ts\" \"packages/**/*.ts\" --max-warnings=0",
+    "lint:fix": "eslint \"bin/**/*.js\" \"src/**/*.{ts,tsx}\" \"scripts/**/*.ts\" \"packages/**/*.ts\" --fix",
     "test": "bun test",
     "typecheck": "tsc --noEmit"
   },
@@ -49,20 +73,27 @@
     "@inkjs/ui": "^2.0.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@mozilla/readability": "^0.6.0",
+    "@vscode/ripgrep": "1.18.0",
+    "bun": "1.3.14",
+    "clipboardy": "^5.3.1",
     "diff": "^9.0.0",
     "glob": "^13.0.6",
     "ink": "^7.1.0",
     "linkedom": "^0.18.13",
+    "markdansi": "0.3.2",
     "openai": "^6.45.0",
     "react": "^19.2.7",
+    "sharp": "^0.35.3",
     "shiki": "^4.3.1",
     "turndown": "^7.2.4",
-    "uuid": "^14.0.1"
+    "uuid": "^14.0.1",
+    "yaml": "^2.9.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.2",
     "@eslint/js": "^10.0.1",
     "@types/bun": "^1.3.14",
+    "@types/chrome": "^0.2.2",
     "@types/react": "^19.2.17",
     "@types/turndown": "^5.0.6",
     "eslint": "^10.6.0",

package/patches/markdansi@0.3.2.patch

@@ -1,5 +1,5 @@
 diff --git a/dist/render.js b/dist/render.js
-index 5de3a5d5c1e0c8bfe8dec992ca3d57987f2ba6ee..53237b86315dc56fdb2e6295aea698ee033350ce 100644
+index 5de3a5d5c1e0c8bfe8dec992ca3d57987f2ba6ee..9aff5e7c5553e53c92d3f1b8295e3a5995650767 100644
 --- a/dist/render.js
 +++ b/dist/render.js
 @@ -572,7 +572,7 @@ function renderTable(node, ctx) {
@@ -11,7 +11,27 @@ index 5de3a5d5c1e0c8bfe8dec992ca3d57987f2ba6ee..53237b86315dc56fdb2e6295aea698ee
              return wrapped.map((l) => {
                  const aligned = padCell(l, target, aligns[idx] ?? "left");
                  const padded = `${padStr}${aligned}${padStr}`;
-@@ -627,6 +627,23 @@ function sliceCellContent(text, width) {
+@@ -595,8 +595,8 @@ function renderTable(node, ctx) {
+     };
+     const headerRows = renderRow(header.children.map((c) => renderInline(c.children, ctx)), true);
+-    const bodyRows = rows.flatMap((r) => renderRow(r.children.map((c) => renderInline(c.children, ctx))));
++    const bodyRows = rows.map((r) => renderRow(r.children.map((c) => renderInline(c.children, ctx))));
+     if (ctx.options.tableBorder === "none") {
+-        const lines = [...headerRows, ...bodyRows].map((row) => row.join(" | ")).join("\n");
++        const lines = [...headerRows, ...bodyRows.flat()].map((row) => row.join(" | ")).join("\n");
+         return [`${lines}\n\n`];
+     }
+     const box = TABLE_BOX[ctx.options.tableBorder] || TABLE_BOX.unicode;
+@@ -607,6 +607,7 @@ function renderTable(node, ctx) {
+     const renderFlat = (rowsArr) => rowsArr.map((r) => `${box.vSep}${r.map((c) => c).join(box.vSep)}${box.vSep}\n`).join("");
+     const dense = ctx.options.tableDense;
+-    const out = [top, renderFlat(headerRows), dense ? "" : mid, renderFlat(bodyRows), bottom, "\n"];
++    const renderedBody = bodyRows.map((row) => renderFlat(row)).join(dense ? "" : mid);
++    const out = [top, renderFlat(headerRows), dense ? "" : mid, renderedBody, bottom, "\n"];
+     return out;
+ }
+ function truncateCell(text, width, ellipsis) {
+@@ -627,6 +628,23 @@ function sliceCellContent(text, width) {
      }
      return sliced;
  }

package/src/agent/context-builder.ts

@@ -2,42 +2,56 @@ import type { ToolDefinition } from "../tools/types";
 import type {
   BuiltContextRequest,
   CompiledRevisionContext,
-  StoredContextRevisionV5,
+  StoredContextRevisionV8,
   SwapOverride,
 } from "../context/context-revision";
 import type { ProtocolContextView } from "../context/protocol-frame";
+import type { StoredContextSurfaceV8 } from "../context/context-surface";
+import { stableJsonStringify } from "../model/model-request-preflight";
+import { validateUserMessage, type UserMessage } from "../image/image-types";
 
 export class ContextBuilder {
   build(input: {
     canonical: ProtocolContextView;
-    revision: StoredContextRevisionV5;
+    revision: StoredContextRevisionV8;
     activeOverrides: readonly SwapOverride[];
     compiled: CompiledRevisionContext;
+    surface: StoredContextSurfaceV8;
     tools: readonly ToolDefinition[];
-    candidateUserPrompt?: string;
+    candidateUserMessage?: UserMessage;
   }): BuiltContextRequest {
     if (input.canonical.sessionId !== input.compiled.sessionId) {
       throw new Error(
         "Compiled context and canonical history belong to different sessions.",
       );
     }
+    if (
+      input.surface.sessionId !== input.canonical.sessionId ||
+      input.surface.surfaceId !== input.revision.surfaceId ||
+      input.surface.surfaceSha256 !== input.revision.surfaceSha256 ||
+      stableJsonStringify(input.tools) !==
+        stableJsonStringify(input.surface.toolDefinitions)
+    ) {
+      throw new Error(
+        "Executable tool definitions do not match the active context surface.",
+      );
+    }
     const messages = input.compiled.entries.map((entry) => entry.message);
-    if (input.candidateUserPrompt !== undefined) {
-      if (input.candidateUserPrompt.trim() === "") {
-        throw new Error("Cannot build a candidate context with an empty prompt.");
-      }
-      messages.push({ role: "user", content: input.candidateUserPrompt });
+    if (input.candidateUserMessage !== undefined) {
+      validateUserMessage(input.candidateUserMessage);
+      messages.push(input.candidateUserMessage);
     }
     return Object.freeze({
       canonical: input.canonical,
       revision: input.revision,
+      surface: input.surface,
       activeOverrides: input.activeOverrides,
       compiled: input.compiled,
       request: {
         messages,
-        tools: [...input.tools],
+        tools: [...input.surface.toolDefinitions],
       },
-      candidateUserPromptIncluded: input.candidateUserPrompt !== undefined,
+      candidateUserPromptIncluded: input.candidateUserMessage !== undefined,
     });
   }
 }

package/src/agent/context-meter.ts

@@ -2,8 +2,13 @@ import type { ModelContextBudget } from "../model/model-context-profile";
 import type {
   ModelRequestOutput,
   ModelUsage,
+  MaterializedModelRequest,
   PreparedModelRequest,
 } from "../model/model-client";
+import type {
+  InputTokenEstimate,
+  InputTokenEstimator,
+} from "../model/input-token-estimator";
 import {
   assertContextBudget,
   contextPressure,
@@ -63,6 +68,7 @@ export class ContextMeter {
   private anchor?: MeasuredContextAnchor;
   private lastProviderUsage?: ModelUsage;
   private calibrationIdentity?: string;
+  private readonly providerEstimateCache = new Map<string, InputTokenEstimate>();
 
   constructor(
     private readonly budget: ModelContextBudget,
@@ -166,10 +172,12 @@ export class ContextMeter {
       throw new Error("Cannot record provider usage before measuring the request.");
     }
 
-    this.calibration.record(
-      output.usage.promptTokens,
-      measurement.rawFullEstimate.totalTokens,
-    );
+    if (prepared.mediaOccurrenceCount === 0) {
+      this.calibration.record(
+        output.usage.promptTokens,
+        measurement.rawFullEstimate.totalTokens,
+      );
+    }
     this.lastProviderUsage = { ...output.usage };
     const replaySegments = prepared.assistantReplaySegments(output.message);
     const anchoredSegments = [...prepared.promptSegments, ...replaySegments];
@@ -209,6 +217,62 @@ export class ContextMeter {
     };
   }
 
+  applyProviderEstimate(
+    prepared: PreparedModelRequest,
+    estimate: {
+      inputTokens: number;
+      coverage: "messages" | "full_request";
+    },
+  ): ContextUsageSnapshot {
+    if (!Number.isSafeInteger(estimate.inputTokens) || estimate.inputTokens < 0) {
+      throw new Error("Provider input estimate must be a non-negative safe integer.");
+    }
+    const local = this.measure(prepared);
+    const measurement = this.measurements.get(prepared)!;
+    const guardedTools =
+      estimate.coverage === "messages"
+        ? Math.ceil(
+            measurement.rawFullEstimate.toolSchemaTokens * local.correctionFactor,
+          )
+        : 0;
+    const providerGuarded = estimate.inputTokens + guardedTools;
+    if (providerGuarded <= local.usedInputTokens) {
+      return local;
+    }
+    const snapshot: ContextUsageSnapshot = {
+      ...local,
+      usedInputTokens: providerGuarded,
+      source: "provider_estimated",
+      pressure: contextPressure(providerGuarded, this.budget),
+    };
+    this.measurements.set(prepared, {
+      rawFullEstimate: measurement.rawFullEstimate,
+      snapshot,
+    });
+    return snapshot;
+  }
+
+  async estimateProviderInput(
+    prepared: MaterializedModelRequest,
+    estimator: InputTokenEstimator,
+    options: { signal: AbortSignal },
+  ): Promise<InputTokenEstimate> {
+    options.signal.throwIfAborted();
+    const key = providerEstimateCacheKey(
+      prepared,
+      estimator.compatibility.coverageVersion,
+    );
+    const cached = this.providerEstimateCache.get(key);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const estimate = await estimator.estimate(prepared, options);
+    options.signal.throwIfAborted();
+    const frozen = Object.freeze({ ...estimate });
+    this.providerEstimateCache.set(key, frozen);
+    return frozen;
+  }
+
   assertWithinBudget(snapshot: ContextUsageSnapshot): void {
     assertContextBudget({
       usedInputTokens: snapshot.usedInputTokens,
@@ -231,6 +295,7 @@ export class ContextMeter {
       this.lastProviderUsage = undefined;
       this.measurements = new WeakMap();
       this.calibration.clear();
+      this.providerEstimateCache.clear();
       this.calibrationIdentity = nextIdentity;
       throw new Error(
         "Context revision changed the request configuration or tool schema.",
@@ -239,6 +304,7 @@ export class ContextMeter {
     this.anchor = undefined;
     this.lastProviderUsage = undefined;
     this.measurements = new WeakMap();
+    this.providerEstimateCache.clear();
     this.calibrationIdentity = nextIdentity;
   }
 
@@ -249,6 +315,7 @@ export class ContextMeter {
     this.measurements = new WeakMap();
     this.calibration.clear();
     this.calibrationIdentity = undefined;
+    this.providerEstimateCache.clear();
   }
 
   private usableAnchor(
@@ -263,7 +330,10 @@ export class ContextMeter {
       anchor.requestConfigHash !== prepared.requestConfigHash ||
       anchor.toolSchemaHash !== prepared.toolSchemaHash ||
       anchor.segmentCount > prepared.promptSegments.length ||
-      prefixHashes[anchor.segmentCount] !== anchor.prefixHash
+      prefixHashes[anchor.segmentCount] !== anchor.prefixHash ||
+      prepared.promptSegments
+        .slice(anchor.segmentCount)
+        .some((segment) => (segment.media?.length ?? 0) > 0)
     ) {
       this.anchor = undefined;
       return undefined;
@@ -289,6 +359,20 @@ export class ContextMeter {
   }
 }
 
+function providerEstimateCacheKey(
+  prepared: PreparedModelRequest,
+  coverageVersion: string,
+): string {
+  return [
+    prepared.requestConfigHash,
+    prepared.toolSchemaHash,
+    lastPromptPrefixHash(
+      promptPrefixHashes(prepared.requestConfigHash, prepared.promptSegments),
+    ),
+    coverageVersion,
+  ].join(":");
+}
+
 function assertMeasuredContextAnchor(anchor: MeasuredContextAnchor): void {
   for (const [name, value] of [
     ["promptTokens", anchor.promptTokens],

package/src/agent/loop.ts

@@ -1,4 +1,10 @@
-import type { ModelClient, PreparedModelRequest } from "../model/model-client";
+import {
+  materializeModelRequest,
+  type MaterializedModelRequest,
+  type ModelClient,
+  type PreparedModelRequest,
+} from "../model/model-client";
+import type { ImageAssetStore } from "../image/image-asset-store";
 import {
   CommittedPrefixAuditError,
   CommittedPrefixAuditor,
@@ -6,7 +12,7 @@ import {
 import type { ObservationBuilder } from "../observation/observation-builder";
 import type { ToolRegistry, ToolRuntime } from "../tools/registry";
 import { ToolExecutionFatalError } from "../tools/types";
-import type { ContextMeter } from "./context-meter";
+import type { ContextMeter, ContextUsageSnapshot } from "./context-meter";
 import type { RuntimeSessionContext } from "./runtime-session";
 import type { AgentTurnLedger } from "./session-ledger";
 import { ContextProtocolError } from "../context/context-protocol-validator";
@@ -21,6 +27,7 @@ import {
   type SwapPlanner,
 } from "../context/swap-planner";
 import { SessionError } from "../session/session-errors";
+import { stableJsonStringify } from "../model/model-request-preflight";
 import {
   normalizeSyntheticDetail,
   type SyntheticToolCompletionInput,
@@ -59,6 +66,11 @@ export type RunAgentInput = {
   runtimeSession: RuntimeSessionContext;
   turn: TurnIdentity;
   signal: AbortSignal;
+  assetStore?: ImageAssetStore;
+  initialRequest?: {
+    prepared: MaterializedModelRequest;
+    usage: ContextUsageSnapshot;
+  };
 };
 
 export class FatalAgentTurnError extends Error {
@@ -97,14 +109,20 @@ export async function runAgent(input: RunAgentInput): Promise<RunAgentResult> {
     }
 
     let prepared: PreparedModelRequest;
+    let request: PreparedModelRequest;
     let built: BuiltContextRequest;
     let preflight;
     try {
       throwIfTurnCancelled(input.signal);
       built = input.ledger.buildModelRequest(input.tools.definitions());
-      prepared = input.model.prepare(built.request);
+      const admission = iterationNumber === 1 ? input.initialRequest : undefined;
+      const candidate = input.model.prepare(built.request);
+      if (admission !== undefined && !samePreparedPlan(candidate, admission.prepared)) {
+        throw new Error("Accepted request no longer matches the first dispatch plan.");
+      }
+      prepared = admission?.prepared ?? candidate;
       committedPrefixAuditor.audit(built.compiled.revisionId, prepared);
-      preflight = input.contextMeter.measure(prepared);
+      preflight = admission?.usage ?? input.contextMeter.measure(prepared);
     } catch (error) {
       if (input.signal.aborted) {
         return cancelledResult(
@@ -135,6 +153,52 @@ export async function runAgent(input: RunAgentInput): Promise<RunAgentResult> {
       return failedResult(error, iteration);
     }
 
+    try {
+      if (prepared.mediaOccurrenceCount > 0) {
+        if (input.initialRequest?.prepared === prepared) {
+          request = prepared;
+        } else {
+          if (input.assetStore === undefined) {
+            throw new Error("Image model request has no asset store.");
+          }
+          request = await materializeModelRequest(input.model, prepared, {
+            assetStore: input.assetStore,
+            signal: input.signal,
+          });
+          if (preflight.source === "measured_plus_estimated_delta") {
+            preflight = input.contextMeter.measure(request);
+          } else {
+            const estimator = input.model.inputTokenEstimator;
+            if (estimator === undefined) {
+              throw new Error("Image model request has no input token estimator.");
+            }
+            const estimate = await input.contextMeter.estimateProviderInput(
+              request as MaterializedModelRequest,
+              estimator,
+              { signal: input.signal },
+            );
+            preflight = input.contextMeter.applyProviderEstimate(request, estimate);
+          }
+          input.contextMeter.assertWithinBudget(preflight);
+          await input.runtimeSession.append({
+            type: "context.usage.updated",
+            ...iteration,
+            data: { phase: "preflight", snapshot: preflight },
+          });
+        }
+      } else {
+        request = prepared;
+      }
+    } catch (error) {
+      if (input.signal.aborted) {
+        return cancelledResult(
+          cancellation(input.signal, iteration, "model_request"),
+          iteration,
+        );
+      }
+      return failedResult(error, iteration);
+    }
+
     await input.runtimeSession.append({
       type: "model.request.started",
       ...iteration,
@@ -144,7 +208,8 @@ export async function runAgent(input: RunAgentInput): Promise<RunAgentResult> {
     let modelOutput;
     try {
       throwIfTurnCancelled(input.signal);
-      modelOutput = await input.model.request(prepared, {
+      input.runtimeSession.prepareModelDispatch?.({ iteration, built });
+      modelOutput = await input.model.request(request, {
         signal: input.signal,
         identity: {
           iteration,
@@ -167,8 +232,8 @@ export async function runAgent(input: RunAgentInput): Promise<RunAgentResult> {
       input.ledger.appendAssistant({
         iteration,
         message: modelOutput.message,
-        provider: prepared.provider,
-        model: prepared.model,
+        provider: request.provider,
+        model: request.model,
       });
     } catch (error) {
       if (error instanceof ContextProtocolError) {
@@ -182,7 +247,7 @@ export async function runAgent(input: RunAgentInput): Promise<RunAgentResult> {
       ...iteration,
       data: { output: modelOutput },
     });
-    const measured = input.contextMeter.recordProviderUsage(prepared, modelOutput);
+    const measured = input.contextMeter.recordProviderUsage(request, modelOutput);
     await input.runtimeSession.append({
       type: "context.usage.updated",
       ...iteration,
@@ -259,14 +324,29 @@ export async function runAgent(input: RunAgentInput): Promise<RunAgentResult> {
       }
 
       const observation = input.observationBuilder.build({ call, raw });
-      input.ledger.commitToolCompletions([
+      const completions = [
         {
           call,
           kind: "returned",
           raw,
           observation: observation.content,
         },
-      ]);
+      ] as const;
+      const committed = input.ledger.commitToolCompletions(completions);
+      if (
+        raw.kind === "skill" &&
+        raw.ok &&
+        raw.status === "loaded" &&
+        input.runtimeSession.onToolCompletionsCommitted === undefined
+      ) {
+        throw new Error(
+          "Loaded Agent Skill completion has no runtime activation coordinator.",
+        );
+      }
+      input.runtimeSession.onToolCompletionsCommitted?.({
+        completions,
+        committed,
+      });
 
       await input.runtimeSession.append({
         type: "tool.raw_result",
@@ -342,6 +422,7 @@ async function runShadowPlanning(input: {
     result = shadowPlanning.planner.plan({
       active: input.built.compiled,
       revision: input.built.revision,
+      surface: input.built.surface,
       activeOverrides: input.built.activeOverrides,
       canonical: input.built.canonical,
       activePrepared: input.prepared,
@@ -418,6 +499,22 @@ function isCanonicalContextFailure(error: unknown): boolean {
   );
 }
 
+function samePreparedPlan(
+  candidate: PreparedModelRequest,
+  accepted: PreparedModelRequest,
+): boolean {
+  return (
+    candidate.provider === accepted.provider &&
+    candidate.model === accepted.model &&
+    candidate.requestConfigHash === accepted.requestConfigHash &&
+    candidate.toolSchemaHash === accepted.toolSchemaHash &&
+    candidate.requestMaxOutputTokens === accepted.requestMaxOutputTokens &&
+    candidate.mediaOccurrenceCount === accepted.mediaOccurrenceCount &&
+    stableJsonStringify(candidate.promptSegments) ===
+      stableJsonStringify(accepted.promptSegments)
+  );
+}
+
 function cancelledToolCompletions(
   toolCalls: readonly ToolCall[],
   startIndex: number,