tinker-agent 2.0.0 → 2.2.0

package/src/tools/registry.ts

@@ -12,10 +12,12 @@ import { createTaskInputToolExecutor } from "./task-input";
 import { createTaskOutputToolExecutor } from "./task-output-tool";
 import { createTaskStopToolExecutor } from "./task-stop";
 import { createUpdatePlanToolExecutor } from "./update-plan";
+import { createWaitToolExecutor } from "./wait";
 import { createWebFetchToolExecutor } from "./web-fetch";
 import type { Refiner } from "./web-fetch/refiner";
 import { createWebSearchToolExecutor } from "./web-search";
 import { createWriteToolExecutor } from "./write";
+import { createViewImageToolExecutor } from "./view-image";
 import { TurnUndoManager } from "./turn-undo-manager";
 import { cancellationError, throwIfTurnCancelled } from "../agent/turn-cancellation";
 import type {
@@ -39,6 +41,7 @@ import {
   DEFAULT_PUBLIC_TOOLING_CONFIG,
   type PublicToolingConfig,
 } from "../cli/public-config-contract";
+import type { ImageAssetStore } from "../image/image-asset-store";
 
 export class ToolRegistry {
   private readonly tools = new Map<string, ToolExecutor>();
@@ -158,7 +161,10 @@ export function createDefaultTooling(options: {
   skillCoordinator?: SkillActivationCoordinator;
   toolingConfig?: PublicToolingConfig;
   memorySearch?: ToolExecutor;
+  memoryGet?: ToolExecutor;
   enableTurnUndo?: boolean;
+  imageAssetStore?: ImageAssetStore;
+  supportsViewImage?: boolean;
   bashGuard?: {
     readonly surface: "tui" | "one-shot";
     confirm(
@@ -206,6 +212,14 @@ export function createDefaultTooling(options: {
       maxContentBytes: options.maxReadContentBytes,
     }),
   );
+  if (options.supportsViewImage === true) {
+    if (options.imageAssetStore === undefined) {
+      throw new Error("ViewImage tooling requires an image asset store.");
+    }
+    registry.register(
+      createViewImageToolExecutor({ imageAssetStore: options.imageAssetStore }),
+    );
+  }
   registry.register(
     createRecallSearchToolExecutor({ historyReader: options.historyReader }),
   );
@@ -215,6 +229,9 @@ export function createDefaultTooling(options: {
   if (options.memorySearch !== undefined) {
     registry.register(options.memorySearch);
   }
+  if (options.memoryGet !== undefined) {
+    registry.register(options.memoryGet);
+  }
   if (options.skillCatalog !== undefined) {
     if (options.skillCatalog.skills.size === 0) {
       throw new Error("An empty Agent Skill catalog must not register tooling.");
@@ -262,6 +279,7 @@ export function createDefaultTooling(options: {
     }),
   );
   registry.register(createUpdatePlanToolExecutor());
+  registry.register(createWaitToolExecutor());
   registry.register(createTaskListToolExecutor({ taskManager }));
   registry.register(createTaskOutputToolExecutor({ taskManager }));
   registry.register(createTaskInputToolExecutor({ taskManager }));

package/src/tools/types.ts

@@ -1,4 +1,5 @@
 import type { ToolCall } from "../agent/types";
+import type { ImageAssetRef } from "../image/image-types";
 import type { SessionId } from "../ids/runtime-id";
 import type {
   RecallGetPage,
@@ -38,6 +39,14 @@ export type ReadFileRawResult = {
   error?: string;
 };
 
+export type ViewImageRawResult = {
+  ok: boolean;
+  filePath: string;
+  originalName?: string;
+  asset?: ImageAssetRef;
+  error?: string;
+};
+
 export type WriteFileRawResult = {
   ok: boolean;
   filePath: string;
@@ -304,10 +313,15 @@ export type RecallRawResult = RecallSearchRawResult | RecallGetRawResult;
 export type MemorySearchRawResult =
   | {
       ok: true;
+      degraded: "vector" | "fts" | null;
       matches: readonly {
+        memoryId: string;
         text: string;
+        summary: string;
         score: number;
+        via: readonly ("vector" | "fts")[];
         sourceWorkspace: string;
+        sourceSessionId: string;
         createdAt: string;
       }[];
     }
@@ -316,6 +330,24 @@ export type MemorySearchRawResult =
       error: string;
     };
 
+export type MemoryGetRawResult =
+  | {
+      ok: true;
+      memory: {
+        memoryId: string;
+        text: string;
+        summary: string;
+        sourceWorkspace: string;
+        sourceSessionId: string;
+        sourceTurnId: string;
+        createdAt: string;
+      } | null;
+    }
+  | {
+      ok: false;
+      error: string;
+    };
+
 export type SkillRawResult =
   | {
       ok: true;
@@ -365,8 +397,20 @@ export type McpToolRawResult = {
   error?: string;
 };
 
+export type WaitRawResult =
+  | {
+      ok: true;
+      seconds: number;
+      waitedMs: number;
+    }
+  | {
+      ok: false;
+      error: string;
+    };
+
 export type ToolRawResultByKind = {
   read: ReadFileRawResult;
+  view_image: ViewImageRawResult;
   write: WriteFileRawResult;
   edit: EditFileRawResult;
   delete: DeleteFileRawResult;
@@ -382,6 +426,8 @@ export type ToolRawResultByKind = {
   web_fetch: WebFetchRawResult;
   recall: RecallRawResult;
   memory_search: MemorySearchRawResult;
+  memory_get: MemoryGetRawResult;
+  wait: WaitRawResult;
   skill: SkillRawResult;
   mcp: McpToolRawResult;
   generic: GenericToolRawResult;

package/src/tools/view-image.ts

@@ -0,0 +1,89 @@
+import type { ImageAssetStore } from "../image/image-asset-store";
+import { defineToolExecutor } from "./types";
+
+export const VIEW_IMAGE_TOOL_DEFINITION = Object.freeze({
+  name: "ViewImage",
+  description:
+    "View one local image and return it to the model. Supports PNG, JPEG, and WebP. " +
+    "Relative paths resolve within the workspace; absolute paths may point outside it. " +
+    "Symbolic links are not supported.",
+  parameters: Object.freeze({
+    type: "object",
+    additionalProperties: false,
+    properties: Object.freeze({
+      file_path: Object.freeze({
+        type: "string",
+        description: "Workspace-relative path or absolute path to one image file.",
+      }),
+    }),
+    required: Object.freeze(["file_path"]),
+  }),
+});
+
+export function createViewImageToolExecutor(input: {
+  imageAssetStore: ImageAssetStore;
+}) {
+  return defineToolExecutor("view_image", {
+    definition: VIEW_IMAGE_TOOL_DEFINITION,
+    async execute(args, _call, context) {
+      context.signal.throwIfAborted();
+      const parsed = parseArguments(args);
+      if (!parsed.ok) {
+        return {
+          ok: false,
+          filePath: parsed.filePath,
+          error: parsed.error,
+        };
+      }
+      try {
+        const imported = await input.imageAssetStore.importFile(parsed.filePath, {
+          signal: context.signal,
+        });
+        context.signal.throwIfAborted();
+        return {
+          ok: true,
+          filePath: parsed.filePath,
+          originalName: imported.originalName,
+          asset: imported.asset,
+        };
+      } catch (error) {
+        context.signal.throwIfAborted();
+        return {
+          ok: false,
+          filePath: parsed.filePath,
+          error: error instanceof Error ? error.message : String(error),
+        };
+      }
+    },
+  });
+}
+
+function parseArguments(
+  value: unknown,
+):
+  | { readonly ok: true; readonly filePath: string }
+  | { readonly ok: false; readonly filePath: string; readonly error: string } {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return {
+      ok: false,
+      filePath: "",
+      error: "Arguments must be an object containing only file_path.",
+    };
+  }
+  const record = value as Record<string, unknown>;
+  const keys = Object.keys(record);
+  const filePath = typeof record.file_path === "string" ? record.file_path : "";
+  if (
+    keys.length !== 1 ||
+    keys[0] !== "file_path" ||
+    typeof record.file_path !== "string" ||
+    record.file_path.trim() === ""
+  ) {
+    return {
+      ok: false,
+      filePath,
+      error: "file_path must be the only argument and must be a non-empty string.",
+    };
+  }
+  return { ok: true, filePath: record.file_path };
+}

package/src/tools/wait.ts

@@ -0,0 +1,85 @@
+import { cancellationError, throwIfTurnCancelled } from "../agent/turn-cancellation";
+import {
+  defineToolExecutor,
+  type ToolExecutionContext,
+  type ToolExecutor,
+  type WaitRawResult,
+} from "./types";
+
+const MIN_WAIT_SECONDS = 1;
+const MAX_WAIT_SECONDS = 3600;
+
+export function createWaitToolExecutor(): ToolExecutor {
+  return defineToolExecutor("wait", {
+    definition: {
+      name: "Wait",
+      description:
+        `Wait for a given number of integer seconds before continuing, from ${MIN_WAIT_SECONDS} to ${MAX_WAIT_SECONDS}. ` +
+        "Use this to pause between polling attempts or to give an external process time to make progress.",
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          seconds: {
+            type: "integer",
+            minimum: MIN_WAIT_SECONDS,
+            maximum: MAX_WAIT_SECONDS,
+            description: "Whole seconds to wait.",
+          },
+        },
+        required: ["seconds"],
+      },
+    },
+    async execute(args, _call, context: ToolExecutionContext): Promise<WaitRawResult> {
+      throwIfTurnCancelled(context.signal);
+      const parsed = parseWaitArgs(args);
+      if (!parsed.ok) {
+        return parsed;
+      }
+      const startedAt = Date.now();
+      await interruptibleSleep(parsed.seconds * 1_000, context.signal);
+      throwIfTurnCancelled(context.signal);
+      return { ok: true, seconds: parsed.seconds, waitedMs: Date.now() - startedAt };
+    },
+  });
+}
+
+type ParsedWaitArgs = { ok: true; seconds: number } | { ok: false; error: string };
+
+function parseWaitArgs(args: unknown): ParsedWaitArgs {
+  if (!isRecord(args)) {
+    return { ok: false, error: "Wait arguments must be an object." };
+  }
+  const unexpected = Object.keys(args).find((key) => key !== "seconds");
+  if (unexpected !== undefined) {
+    return { ok: false, error: `Wait received unexpected argument: ${unexpected}.` };
+  }
+  if (typeof args.seconds !== "number" || !Number.isInteger(args.seconds)) {
+    return { ok: false, error: "Wait seconds must be an integer." };
+  }
+  if (args.seconds < MIN_WAIT_SECONDS || args.seconds > MAX_WAIT_SECONDS) {
+    return {
+      ok: false,
+      error: `Wait seconds must be between ${MIN_WAIT_SECONDS} and ${MAX_WAIT_SECONDS}.`,
+    };
+  }
+  return { ok: true, seconds: args.seconds };
+}
+
+function interruptibleSleep(ms: number, signal: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(cancellationError(signal));
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/tui/components/memory-browser.tsx

@@ -93,6 +93,9 @@ export function MemoryBrowser(props: MemoryBrowserProps) {
                   {formatMemoryCreatedAt(memory.createdAt)} · {memory.sourceWorkspace}
                 </Text>
                 <Text>{normalizeMemoryDisplayText(memory.text)}</Text>
+                {memory.summary === "" ? null : (
+                  <Text dimColor>{normalizeMemoryDisplayText(memory.summary)}</Text>
+                )}
               </Box>
             ))}
           </Box>

package/src/tui/components/prompt-input.tsx

@@ -741,30 +741,42 @@ export function PromptInput(props: PromptInputProps) {
       </Box>
       {showSuggestions ? null : (
         <Box>
-          <Text dimColor>
-            {props.modelName}
-            {props.reasoningEffort === undefined ? null : ` ${props.reasoningEffort}`} ·{" "}
-            {formatWorkspacePath(props.workspaceRoot)}
-            {props.gitBranch === undefined ? null : ` · ${props.gitBranch}`}
-            {state.phase.kind === "idle" ? null : ` · ${phaseLabel(state.phase)}`}
+          <Text>
+            <Text color={FOOTER_COLORS.model}>{props.modelName}</Text>
+            {props.reasoningEffort === undefined ? null : (
+              <Text dimColor> {props.reasoningEffort}</Text>
+            )}
+            <Text dimColor> · </Text>
+            <Text color={FOOTER_COLORS.workspacePath}>
+              {formatWorkspacePath(props.workspaceRoot)}
+            </Text>
+            {props.gitBranch === undefined ? null : (
+              <>
+                <Text dimColor> · </Text>
+                <Text color={FOOTER_COLORS.gitBranch}>{props.gitBranch}</Text>
+              </>
+            )}
+            {state.phase.kind === "idle" ? null : (
+              <>
+                <Text dimColor> · </Text>
+                <Text dimColor>{phaseLabel(state.phase)}</Text>
+              </>
+            )}
+            {props.contextUsage === undefined ? null : (
+              <>
+                <Text dimColor> · </Text>
+                <Text color={contextColor(props.contextUsage.pressure)}>
+                  {formatContextUsageLine(props.contextUsage)}
+                </Text>
+              </>
+            )}
+            {cacheRate === undefined ? null : (
+              <>
+                <Text dimColor> · </Text>
+                <Text color={FOOTER_COLORS.cacheRate}>{cacheRate}</Text>
+              </>
+            )}
           </Text>
-          {props.contextUsage === undefined ? null : (
-            <>
-              <Text dimColor> · </Text>
-              <Text
-                color={contextColor(props.contextUsage.pressure)}
-                dimColor={props.contextUsage.pressure === "normal"}
-              >
-                {formatContextUsageLine(props.contextUsage)}
-              </Text>
-            </>
-          )}
-          {cacheRate === undefined ? null : (
-            <>
-              <Text dimColor> · </Text>
-              <Text dimColor>{cacheRate}</Text>
-            </>
-          )}
         </Box>
       )}
       {showFileSuggestions ? (
@@ -962,14 +974,25 @@ function fileMentionReplacement(
     : `${filePath} `;
 }
 
+// Decorative palette for the footer status line, kept muted so it reads
+// softly against the dim separators. Red and yellow are deliberately
+// excluded: they stay reserved for context-pressure warnings.
+const FOOTER_COLORS = {
+  model: "#7b9cc4",
+  workspacePath: "#6fa8a8",
+  gitBranch: "#a08fbd",
+  cacheRate: "#7aa37e",
+  contextUsage: "#8a9199",
+} as const;
+
 function contextColor(
   pressure: ContextUsageSnapshot["pressure"],
-): "yellow" | "red" | undefined {
+): "yellow" | "red" | typeof FOOTER_COLORS.contextUsage {
   return pressure === "blocked"
     ? "red"
     : pressure === "triggered"
       ? "yellow"
-      : undefined;
+      : FOOTER_COLORS.contextUsage;
 }
 
 function formatWorkspacePath(workspaceRoot: string): string {

package/src/tui/event-store.ts

@@ -785,8 +785,11 @@ function toolCallSummary(input: { name: string; args: unknown }): string {
   if (input.name === "Grep") {
     return `Grep ${toolPattern(input.args) ?? ""}`.trim();
   }
-  if (input.name === "WebSearch" || input.name === "MemorySearch") {
-    return `${input.name} ${toolQuery(input.args) ?? ""}`.trim();
+  if (input.name === "WebSearch") {
+    return `WebSearch ${toolQuery(input.args) ?? ""}`.trim();
+  }
+  if (input.name === "MemorySearch") {
+    return `MemorySearch ${memorySearchDetail(input.args)}`.trim();
   }
   if (input.name === "WebFetch") {
     return `WebFetch ${toolUrl(input.args) ?? ""}`.trim();
@@ -801,6 +804,9 @@ function toolCallSummary(input: { name: string; args: unknown }): string {
   if (input.name === "TaskList") {
     return "TaskList";
   }
+  if (input.name === "Wait") {
+    return `Wait ${toolSeconds(input.args) ?? ""}`.trim();
+  }
   if (input.name === "Skill") {
     return `Skill ${stringProperty(asRecord(input.args), "name") ?? ""}`.trim();
   }
@@ -816,6 +822,10 @@ function toolRawResultSummary(name: string, args: unknown, raw: ToolRawResult):
   }
 
   switch (raw.kind) {
+    case "view_image":
+      return raw.asset === undefined
+        ? base
+        : `${base} -> ${raw.asset.mimeType}, ${raw.asset.width}x${raw.asset.height}, ${raw.asset.byteLength} bytes`;
     case "glob":
       return raw.ok && raw.matchCount !== undefined
         ? `${base} -> ${raw.matchCount} match${raw.matchCount === 1 ? "" : "es"}`
@@ -878,6 +888,11 @@ function toolRawResultSummary(name: string, args: unknown, raw: ToolRawResult):
         return base;
       }
       return `${base} -> ${raw.matches.length} derived memor${raw.matches.length === 1 ? "y" : "ies"}`;
+    case "memory_get":
+      if (!raw.ok) {
+        return base;
+      }
+      return raw.memory === null ? `${base} -> not found` : `${base} -> found`;
     case "skill":
       if (!raw.ok) {
         return `${base} failed -> ${boundedToolError(raw.error)}`;
@@ -915,6 +930,8 @@ function toolRawResultSummary(name: string, args: unknown, raw: ToolRawResult):
       const completed = raw.plan.filter((step) => step.status === "completed").length;
       return `${base} -> ${completed}/${raw.plan.length} completed`;
     }
+    case "wait":
+      return raw.ok ? `${base} -> done` : base;
     case "mcp":
     case "generic":
       return base;
@@ -951,6 +968,7 @@ function toolRawResultBashDetail(raw: ToolRawResult): Pick<TimelineItem, "bash">
       return detail === undefined ? {} : { bash: detail };
     }
     case "read":
+    case "view_image":
     case "write":
     case "edit":
     case "delete":
@@ -963,6 +981,8 @@ function toolRawResultBashDetail(raw: ToolRawResult): Pick<TimelineItem, "bash">
     case "web_fetch":
     case "recall":
     case "memory_search":
+    case "memory_get":
+    case "wait":
     case "skill":
     case "mcp":
     case "generic":
@@ -988,6 +1008,7 @@ function toolRawResultDiff(
             diffTruncated: raw.patchTruncated === true,
           };
     case "read":
+    case "view_image":
     case "delete":
     case "glob":
     case "grep":
@@ -1001,6 +1022,8 @@ function toolRawResultDiff(
     case "web_fetch":
     case "recall":
     case "memory_search":
+    case "memory_get":
+    case "wait":
     case "skill":
     case "mcp":
     case "generic":
@@ -1067,10 +1090,46 @@ function toolQuery(args: unknown): string | undefined {
   return stringProperty(asRecord(args), "query");
 }
 
+function memorySearchDetail(args: unknown): string {
+  const parts: string[] = [];
+  const query = toolQuery(args);
+  if (query !== undefined) {
+    parts.push(query);
+  }
+  const keywords = toolKeywords(args);
+  if (keywords !== undefined) {
+    parts.push(`[${keywords}]`);
+  }
+  return parts.join(" ");
+}
+
+function toolKeywords(args: unknown): string | undefined {
+  const limit = 120;
+  const value = asRecord(args).keywords;
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+  const keywords = value.filter(
+    (keyword): keyword is string => typeof keyword === "string" && keyword.length > 0,
+  );
+  if (keywords.length === 0) {
+    return undefined;
+  }
+  const joined = keywords.join(", ");
+  return joined.length <= limit ? joined : `${joined.slice(0, limit)}…`;
+}
+
 function toolUrl(args: unknown): string | undefined {
   return stringProperty(asRecord(args), "url");
 }
 
+function toolSeconds(args: unknown): string | undefined {
+  const seconds = asRecord(args).seconds;
+  return typeof seconds === "number" && Number.isFinite(seconds)
+    ? `${seconds}s`
+    : undefined;
+}
+
 function toolPath(args: unknown): string | undefined {
   const record = asRecord(args);
   return stringProperty(record, "file_path");