tinker-agent 1.3.0 → 1.5.0

package/src/model/model-context-profile.ts

@@ -14,21 +14,6 @@ export type ModelContextBudget = ModelContextProfile & {
   triggerTokens: number;
 };
 
-export function readModelContextProfileFromEnv(
-  env: NodeJS.ProcessEnv = process.env,
-): ModelContextProfile {
-  return createModelContextProfile({
-    contextWindowTokens: parseRequiredTokenCount(
-      env.TINKER_CONTEXT_WINDOW_TOKENS,
-      "TINKER_CONTEXT_WINDOW_TOKENS",
-    ),
-    maxSupportedOutputTokens: parseRequiredTokenCount(
-      env.TINKER_MAX_SUPPORTED_OUTPUT_TOKENS,
-      "TINKER_MAX_SUPPORTED_OUTPUT_TOKENS",
-    ),
-  });
-}
-
 export function createModelContextProfile(
   input: ModelContextProfile,
 ): ModelContextProfile {
@@ -102,21 +87,6 @@ export function assertMatchingContextBudget(
   }
 }
 
-function parseRequiredTokenCount(value: string | undefined, name: string): number {
-  if (value === undefined || value.trim() === "") {
-    throw new Error(`${name} is required; received ${displayValue(value)}.`);
-  }
-  if (!/^\d+$/.test(value)) {
-    throw new Error(
-      `${name} must be a positive safe integer token count; received ${displayValue(value)}.`,
-    );
-  }
-
-  const parsed = Number(value);
-  requirePositiveSafeInteger(parsed, name, value);
-  return parsed;
-}
-
 function requirePositiveSafeInteger(
   value: number,
   name: string,

package/src/observation/observation-builder.ts

@@ -5,6 +5,7 @@ import type {
   GenericToolRawResult,
   GlobRawResult,
   GrepRawResult,
+  MemorySearchRawResult,
   McpToolRawResult,
   ReadFileRawResult,
   RecallRawResult,
@@ -33,6 +34,8 @@ export class ObservationBuilder {
         return { content: renderReadObservation(input.raw) };
       case "recall":
         return { content: renderRecallObservation(input.raw) };
+      case "memory_search":
+        return { content: renderMemorySearchObservation(input.raw) };
       case "skill":
         return { content: renderSkillObservation(input.raw) };
       case "write":
@@ -227,6 +230,23 @@ function renderRecallObservation(raw: RecallRawResult): string {
   return [header, ...hits].join("\n\n");
 }
 
+function renderMemorySearchObservation(raw: MemorySearchRawResult): string {
+  if (!raw.ok) {
+    return `MemorySearch unavailable: ${raw.error}`;
+  }
+  if (raw.matches.length === 0) {
+    return "MemorySearch found no stored memories.";
+  }
+  const header = `MemorySearch returned ${raw.matches.length} derived memories. They may be stale or wrong; verify current workspace facts.`;
+  return [
+    header,
+    ...raw.matches.map(
+      (match, index) =>
+        `${index + 1}. score=${match.score.toFixed(3)} created_at=${match.createdAt} workspace=${match.sourceWorkspace}\n   ${match.text}`,
+    ),
+  ].join("\n\n");
+}
+
 export function renderSkillObservation(raw: SkillRawResult): string {
   if (!raw.ok) {
     return `Skill failed for ${raw.name || "(unknown skill)"} (${raw.errorCode}): ${raw.error}`;

package/src/session/session-store.ts

@@ -144,6 +144,29 @@ export type SessionImageInputCompatibility = {
   readonly tokenEstimator?: InputTokenEstimatorCompatibility;
 };
 
+export type CompletedTurnMessageSnapshot =
+  | {
+      readonly ordinal: number;
+      readonly role: "user";
+      readonly content: string;
+    }
+  | {
+      readonly ordinal: number;
+      readonly role: "assistant";
+      readonly content: string | null;
+      readonly reasoningContent?: string | null;
+    }
+  | {
+      readonly ordinal: number;
+      readonly role: "tool";
+      readonly name: string;
+      readonly content: string;
+    };
+
+export type CompletedTurnSnapshot = {
+  readonly messages: readonly CompletedTurnMessageSnapshot[];
+};
+
 export type SessionCompatibilityContract = {
   modelName: string;
   profileName?: string;
@@ -2082,6 +2105,105 @@ export class SessionStore implements SessionLedgerCommitter {
     });
   }
 
+  readCompletedTurnSnapshot(turnId: TurnId): CompletedTurnSnapshot {
+    this.requireOpen();
+    const turnRow = this.database
+      .query("SELECT status FROM turns WHERE turn_id = ?")
+      .get(turnId);
+    const status = enumFromSql(
+      recordFromSql(turnRow, "completed turn").status,
+      ["open", "completed", "failed", "cancelled", "interrupted"] as const,
+      "turn status",
+    );
+    if (status !== "completed") {
+      throw new Error(`Turn ${turnId} is not completed.`);
+    }
+
+    const rows = this.database
+      .query(
+        `SELECT ordinal, role, content, reasoning_content,
+                reasoning_content_present, name
+         FROM messages
+         WHERE turn_id = ?
+         ORDER BY ordinal`,
+      )
+      .all(turnId);
+    if (rows.length === 0) {
+      throw new Error(`Completed turn ${turnId} has no messages.`);
+    }
+
+    let previousOrdinal = 0;
+    const messages = rows.map((value): CompletedTurnMessageSnapshot => {
+      const row = recordFromSql(value, "completed turn message");
+      const ordinal = numberFromSql(row.ordinal, "completed turn ordinal");
+      if (ordinal < 1 || ordinal <= previousOrdinal) {
+        throw new Error("Completed turn message ordinals are invalid.");
+      }
+      previousOrdinal = ordinal;
+      const role = enumFromSql(
+        row.role,
+        ["user", "assistant", "tool"] as const,
+        "completed turn message role",
+      );
+      if (role === "user") {
+        if (
+          row.reasoning_content !== null ||
+          numberFromSql(row.reasoning_content_present, "reasoning_content_present") !==
+            0 ||
+          row.name !== null
+        ) {
+          throw new Error("Completed user message fields are invalid.");
+        }
+        return Object.freeze({
+          ordinal,
+          role,
+          content: stringFromSql(row.content, "completed user content"),
+        });
+      }
+      if (role === "assistant") {
+        if (row.name !== null) {
+          throw new Error("Completed assistant message name must be null.");
+        }
+        const reasoningPresent = numberFromSql(
+          row.reasoning_content_present,
+          "reasoning_content_present",
+        );
+        if (reasoningPresent !== 0 && reasoningPresent !== 1) {
+          throw new Error("reasoning_content_present must be 0 or 1.");
+        }
+        if (reasoningPresent === 0 && row.reasoning_content !== null) {
+          throw new Error("Absent assistant reasoning content must be null.");
+        }
+        return Object.freeze({
+          ordinal,
+          role,
+          content: nullableTextFromSql(row.content, "completed assistant content"),
+          ...(reasoningPresent === 0
+            ? {}
+            : {
+                reasoningContent: nullableTextFromSql(
+                  row.reasoning_content,
+                  "completed assistant reasoning content",
+                ),
+              }),
+        });
+      }
+      if (
+        row.reasoning_content !== null ||
+        numberFromSql(row.reasoning_content_present, "reasoning_content_present") !== 0
+      ) {
+        throw new Error("Completed tool message reasoning fields are invalid.");
+      }
+      return Object.freeze({
+        ordinal,
+        role,
+        name: stringFromSql(row.name, "completed tool name"),
+        content: stringFromSql(row.content, "completed tool content"),
+      });
+    });
+    return Object.freeze({ messages: Object.freeze(messages) });
+  }
+
   loadProtocolView(): ProtocolContextView {
     this.requireOpen();
     const imageAttachments = loadMessageImageAttachments(this.database);
@@ -4725,6 +4847,7 @@ export function decodeStoredToolRawResult(value: unknown): ToolRawResult {
       "web_search",
       "web_fetch",
       "recall",
+      "memory_search",
       "skill",
       "mcp",
       "generic",

package/src/tools/bash.ts

@@ -11,6 +11,7 @@ import { buildOutputSnapshotFromText } from "./task-output-snapshot";
 import { defineToolExecutor } from "./types";
 import type { TaskOutputSnapshot } from "./task-output";
 import type { BashRawResult, ToolExecutionContext, ToolExecutor } from "./types";
+import { DEFAULT_PUBLIC_TOOLING_CONFIG } from "../cli/public-config-contract";
 
 type BashArgs = {
   command: string;
@@ -27,25 +28,16 @@ export type BashToolOptions = {
   maxTimeoutMs?: number;
 };
 
-const defaultForegroundTimeoutMs = 5_000;
-const defaultMaxForegroundTimeoutMs = 600_000;
-
 export function createBashToolExecutor(options: BashToolOptions): ToolExecutor {
   const maxTimeoutMs =
-    options.maxTimeoutMs ??
-    parsePositiveInteger(
-      process.env.TINKER_BASH_MAX_TIMEOUT_MS,
-      defaultMaxForegroundTimeoutMs,
-    );
+    options.maxTimeoutMs ?? DEFAULT_PUBLIC_TOOLING_CONFIG.bashMaxTimeoutMs;
   const defaultTimeoutMs =
-    options.defaultTimeoutMs ??
-    Math.min(
-      parsePositiveInteger(
-        process.env.TINKER_BASH_DEFAULT_TIMEOUT_MS,
-        defaultForegroundTimeoutMs,
-      ),
-      maxTimeoutMs,
+    options.defaultTimeoutMs ?? DEFAULT_PUBLIC_TOOLING_CONFIG.bashDefaultTimeoutMs;
+  if (defaultTimeoutMs > maxTimeoutMs) {
+    throw new Error(
+      `Bash default timeout must not exceed max timeout; received ${defaultTimeoutMs} > ${maxTimeoutMs}.`,
     );
+  }
 
   return defineToolExecutor("bash", {
     definition: {
@@ -161,7 +153,7 @@ export function createBashToolExecutor(options: BashToolOptions): ToolExecutor {
 
 export function parseBashArgs(
   args: unknown,
-  maxTimeoutMs = defaultMaxForegroundTimeoutMs,
+  maxTimeoutMs = DEFAULT_PUBLIC_TOOLING_CONFIG.bashMaxTimeoutMs,
 ): { ok: true; value: BashArgs } | { ok: false; error: string } {
   if (!isRecord(args)) {
     return { ok: false, error: "Bash arguments must be an object." };
@@ -401,15 +393,6 @@ function parseOptionalTimeout(
   return { ok: true, value };
 }
 
-function parsePositiveInteger(value: string | undefined, fallback: number): number {
-  if (value === undefined) {
-    return fallback;
-  }
-
-  const parsed = Number(value);
-  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
-}
-
 function lastPipelineCommandName(command: string): string | undefined {
   const segments = command.split("|");
   const lastSegment = segments.at(-1)?.trim();

package/src/tools/grep.ts

@@ -32,6 +32,11 @@ type GrepArgs = {
 export type GrepToolOptions = {
   workspaceRoot: string;
   cwdState: CwdState;
+  ripgrep?: {
+    command?: string;
+    timeoutMs?: number;
+    maxBufferBytes?: number;
+  };
 };
 
 const ignoredDirectories = [
@@ -174,7 +179,10 @@ export function createGrepToolExecutor(options: GrepToolOptions): ToolExecutor {
       }
 
       const rgArgs = buildRipgrepArgs(input, mode, absoluteSearchPath);
-      const rg = await ripGrep(rgArgs, { signal: context.signal });
+      const rg = await ripGrep(rgArgs, {
+        signal: context.signal,
+        ...options.ripgrep,
+      });
 
       if (!rg.ok) {
         return grepFailure({

package/src/tools/registry.ts

@@ -31,6 +31,10 @@ import { ToolExecutionFatalError } from "./types";
 import type { SkillCatalogSnapshot } from "../skills/skill-loader";
 import type { SkillActivationCoordinator } from "../skills/skill-context";
 import { createSkillToolExecutor } from "../skills/skill-tool";
+import {
+  DEFAULT_PUBLIC_TOOLING_CONFIG,
+  type PublicToolingConfig,
+} from "../cli/public-config-contract";
 
 export class ToolRegistry {
   private readonly tools = new Map<string, ToolExecutor>();
@@ -128,10 +132,13 @@ export function createDefaultTooling(options: {
   taskStopGraceMs?: number;
   skillCatalog?: SkillCatalogSnapshot;
   skillCoordinator?: SkillActivationCoordinator;
+  toolingConfig?: PublicToolingConfig;
+  memorySearch?: ToolExecutor;
 }): DefaultTooling {
   const snapshots: FileSnapshotStore = new Map();
   const registry = new ToolRegistry();
   const runtimeSession = options.runtimeSession;
+  const toolingConfig = options.toolingConfig ?? DEFAULT_PUBLIC_TOOLING_CONFIG;
   const cwdState = createCwdState(options.workspaceRoot);
   const taskManager = new ShellTaskManager({
     workspaceRoot: options.workspaceRoot,
@@ -149,6 +156,11 @@ export function createDefaultTooling(options: {
     createGrepToolExecutor({
       workspaceRoot: options.workspaceRoot,
       cwdState,
+      ripgrep: {
+        command: toolingConfig.ripgrepPath,
+        timeoutMs: toolingConfig.grepTimeoutMs,
+        maxBufferBytes: toolingConfig.grepMaxBufferBytes,
+      },
     }),
   );
   registry.register(
@@ -159,6 +171,9 @@ export function createDefaultTooling(options: {
     }),
   );
   registry.register(createRecallToolExecutor({ historyReader: options.historyReader }));
+  if (options.memorySearch !== undefined) {
+    registry.register(options.memorySearch);
+  }
   if (options.skillCatalog !== undefined) {
     if (options.skillCatalog.skills.size === 0) {
       throw new Error("An empty Agent Skill catalog must not register tooling.");
@@ -192,13 +207,15 @@ export function createDefaultTooling(options: {
       workspaceRoot: options.workspaceRoot,
       cwdState,
       taskManager,
+      defaultTimeoutMs: toolingConfig.bashDefaultTimeoutMs,
+      maxTimeoutMs: toolingConfig.bashMaxTimeoutMs,
     }),
   );
   registry.register(createTaskListToolExecutor({ taskManager }));
   registry.register(createTaskOutputToolExecutor({ taskManager }));
   registry.register(createTaskStopToolExecutor({ taskManager }));
 
-  const exaApiKey = options.exaApiKey ?? process.env.EXA_API_KEY;
+  const exaApiKey = options.exaApiKey ?? toolingConfig.exaApiKey;
   const hasExaKey = exaApiKey !== undefined && exaApiKey.trim() !== "";
 
   if (hasExaKey) {
@@ -209,6 +226,7 @@ export function createDefaultTooling(options: {
     createWebFetchToolExecutor({
       exaApiKey: hasExaKey ? exaApiKey : undefined,
       refiner: options.webFetchRefiner,
+      refineThreshold: toolingConfig.webFetchRefineThreshold,
     }),
   );
 

package/src/tools/ripgrep.ts

@@ -1,13 +1,10 @@
 import { execFile } from "node:child_process";
-import { rgPath } from "@vscode/ripgrep";
 import { cancellationError, throwIfTurnCancelled } from "../agent/turn-cancellation";
+import { DEFAULT_PUBLIC_TOOLING_CONFIG } from "../cli/public-config-contract";
 
 export const RIPGREP_MISSING_ERROR =
   "Tinker's bundled ripgrep executable is unavailable. Reinstall tinker-agent.";
 
-const defaultTimeoutMs = 20_000;
-const defaultMaxBufferBytes = 20_000_000;
-
 export type RipgrepResult = {
   ok: boolean;
   lines: string[];
@@ -18,12 +15,13 @@ export type RipgrepResult = {
 
 export type RipgrepOptions = {
   signal: AbortSignal;
+  command?: string;
   timeoutMs?: number;
   maxBufferBytes?: number;
 };
 
-export function findRipgrepCommand(): string {
-  return process.env.TINKER_RIPGREP_PATH ?? rgPath;
+export function findRipgrepCommand(command?: string): string {
+  return command ?? DEFAULT_PUBLIC_TOOLING_CONFIG.ripgrepPath;
 }
 
 export async function ripGrep(
@@ -31,21 +29,28 @@ export async function ripGrep(
   options: RipgrepOptions,
 ): Promise<RipgrepResult> {
   throwIfTurnCancelled(options.signal);
-  const timeoutMs =
-    options.timeoutMs ??
-    parsePositiveInteger(process.env.TINKER_GREP_TIMEOUT_MS, defaultTimeoutMs);
+  const timeoutMs = options.timeoutMs ?? DEFAULT_PUBLIC_TOOLING_CONFIG.grepTimeoutMs;
   const maxBufferBytes =
-    options.maxBufferBytes ??
-    parsePositiveInteger(
-      process.env.TINKER_GREP_MAX_BUFFER_BYTES,
-      defaultMaxBufferBytes,
-    );
-
-  const first = await runRipgrep(args, timeoutMs, maxBufferBytes, options.signal);
+    options.maxBufferBytes ?? DEFAULT_PUBLIC_TOOLING_CONFIG.grepMaxBufferBytes;
+  const command = findRipgrepCommand(options.command);
+
+  const first = await runRipgrep(
+    command,
+    args,
+    timeoutMs,
+    maxBufferBytes,
+    options.signal,
+  );
   if (first.retryWithSingleThread) {
     throwIfTurnCancelled(options.signal);
     return finalizeResult(
-      await runRipgrep(["-j", "1", ...args], timeoutMs, maxBufferBytes, options.signal),
+      await runRipgrep(
+        command,
+        ["-j", "1", ...args],
+        timeoutMs,
+        maxBufferBytes,
+        options.signal,
+      ),
     );
   }
 
@@ -62,6 +67,7 @@ type RipgrepAttempt = {
 };
 
 function runRipgrep(
+  command: string,
   args: string[],
   timeoutMs: number,
   maxBufferBytes: number,
@@ -74,7 +80,7 @@ function runRipgrep(
     }
 
     execFile(
-      findRipgrepCommand(),
+      command,
       args,
       { timeout: timeoutMs, maxBuffer: maxBufferBytes, signal },
       (error, stdout, stderr) => {
@@ -210,12 +216,3 @@ function isEagainError(
     stderr.includes("Resource temporarily unavailable")
   );
 }
-
-function parsePositiveInteger(value: string | undefined, fallback: number): number {
-  if (value === undefined || value.trim() === "") {
-    return fallback;
-  }
-
-  const parsed = Number(value);
-  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
-}

package/src/tools/types.ts

@@ -245,6 +245,21 @@ export type RecallGetRawResult =
 
 export type RecallRawResult = RecallSearchRawResult | RecallGetRawResult;
 
+export type MemorySearchRawResult =
+  | {
+      ok: true;
+      matches: readonly {
+        text: string;
+        score: number;
+        sourceWorkspace: string;
+        createdAt: string;
+      }[];
+    }
+  | {
+      ok: false;
+      error: string;
+    };
+
 export type SkillRawResult =
   | {
       ok: true;
@@ -307,6 +322,7 @@ export type ToolRawResultByKind = {
   web_search: WebSearchRawResult;
   web_fetch: WebFetchRawResult;
   recall: RecallRawResult;
+  memory_search: MemorySearchRawResult;
   skill: SkillRawResult;
   mcp: McpToolRawResult;
   generic: GenericToolRawResult;

package/src/tools/web-fetch/index.ts

@@ -1,4 +1,5 @@
 import { cancellationError, throwIfTurnCancelled } from "../../agent/turn-cancellation";
+import { DEFAULT_PUBLIC_TOOLING_CONFIG } from "../../cli/public-config-contract";
 import { defineToolExecutor } from "../types";
 import type { ToolExecutionContext, ToolExecutor, WebFetchRawResult } from "../types";
 import type { WebFetchBackend, WebFetchBackendResult, WebFetchRoute } from "./backend";
@@ -25,7 +26,6 @@ export type WebFetchToolOptions = {
   browserBackend?: WebFetchBackend | false;
 };
 
-export const WEB_FETCH_DEFAULT_REFINE_THRESHOLD = 2000;
 export const WEB_FETCH_DEFAULT_CACHE_TTL_MS = 15 * 60 * 1000;
 
 type CacheEntry = {
@@ -50,11 +50,7 @@ export function createWebFetchToolExecutor(
       : (options.browserBackend ??
         (isBrowserBackendAvailable() ? createBrowserWebFetchBackend() : undefined));
   const refineThreshold =
-    options.refineThreshold ??
-    parsePositiveInteger(
-      process.env.TINKER_WEBFETCH_REFINE_THRESHOLD,
-      WEB_FETCH_DEFAULT_REFINE_THRESHOLD,
-    );
+    options.refineThreshold ?? DEFAULT_PUBLIC_TOOLING_CONFIG.webFetchRefineThreshold;
   const cacheTtlMs = options.cacheTtlMs ?? WEB_FETCH_DEFAULT_CACHE_TTL_MS;
   const cache = new Map<string, CacheEntry>();
 
@@ -284,15 +280,6 @@ function pruneCache(cache: Map<string, CacheEntry>): void {
   }
 }
 
-function parsePositiveInteger(value: string | undefined, fallback: number): number {
-  if (value === undefined || value.trim() === "") {
-    return fallback;
-  }
-
-  const parsed = Number(value);
-  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
-}
-
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }