tinker-agent 1.2.1 → 1.4.0

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

@@ -11,7 +11,7 @@ import {
 import type { ImageAssetId, ImageAssetRef } from "../image/image-types";
 import type { ModelContextBudget } from "./model-context-profile";
 import type { InputTokenEstimator } from "./input-token-estimator";
-import { ModelRequestMediaAggregateError } from "./model-client";
+import { ModelRequestMediaAggregateError, ProviderResponseError } from "./model-client";
 import type {
   MaterializedModelRequest,
   ModelClient,
@@ -234,17 +234,12 @@ export class OpenAIChatModelClient implements ModelClient {
       throw new Error("Image request must be materialized before provider dispatch.");
     }
 
-    let response;
-    try {
-      response = this.stream
-        ? await this.requestStreaming(prepared, options.signal)
-        : await this.client.chat.completions.create(
-            prepared.payload as ChatCompletionCreateParamsNonStreaming,
-            { signal: options.signal },
-          );
-    } catch (error) {
-      throw sanitizedProviderError(error);
-    }
+    const response = this.stream
+      ? accumulateOpenAIChatCompletionChunks(
+          await this.collectStreamingChunks(prepared, options.signal),
+          { provider: this.provider, model: this.options.model },
+        )
+      : await this.requestNonStreaming(prepared, options.signal);
 
     return fromOpenAIChatCompletion(response, {
       identity: options.identity,
@@ -253,22 +248,37 @@ export class OpenAIChatModelClient implements ModelClient {
     });
   }
 
-  private async requestStreaming(
+  private async collectStreamingChunks(
     prepared: PreparedModelRequest,
     signal: AbortSignal,
-  ): Promise<Record<string, unknown>> {
-    const stream = await this.client.chat.completions.create(
-      prepared.payload as ChatCompletionCreateParamsStreaming,
-      { signal },
-    );
-    const chunks: unknown[] = [];
-    for await (const chunk of stream) {
-      chunks.push(chunk);
+  ): Promise<unknown[]> {
+    try {
+      const stream = await this.client.chat.completions.create(
+        prepared.payload as ChatCompletionCreateParamsStreaming,
+        { signal },
+      );
+      const chunks: unknown[] = [];
+      for await (const chunk of stream) {
+        chunks.push(chunk);
+      }
+      return chunks;
+    } catch (error) {
+      throw sanitizedProviderError(error, this.provider, this.options.model);
+    }
+  }
+
+  private async requestNonStreaming(
+    prepared: PreparedModelRequest,
+    signal: AbortSignal,
+  ) {
+    try {
+      return await this.client.chat.completions.create(
+        prepared.payload as ChatCompletionCreateParamsNonStreaming,
+        { signal },
+      );
+    } catch (error) {
+      throw sanitizedProviderError(error, this.provider, this.options.model);
     }
-    return accumulateOpenAIChatCompletionChunks(chunks, {
-      provider: this.provider,
-      model: this.options.model,
-    });
   }
 
   private assistantReplaySegments(message: AssistantMessage): PreparedPromptSegment[] {
@@ -508,7 +518,11 @@ function deepFreeze<T>(value: T): T {
   return Object.freeze(value);
 }
 
-function sanitizedProviderError(error: unknown): Error {
+function sanitizedProviderError(
+  error: unknown,
+  provider: string,
+  model: string,
+): ProviderResponseError {
   const message = error instanceof Error ? error.message : String(error);
   const sanitized = message
     .replace(
@@ -516,5 +530,10 @@ function sanitizedProviderError(error: unknown): Error {
       "[redacted image data]",
     )
     .replace(/Bearer\s+[A-Za-z0-9._~+/-]+/giu, "Bearer [redacted]");
-  return new Error(sanitized, { cause: error });
+  return new ProviderResponseError(
+    "provider_request_error",
+    sanitized,
+    { provider, model },
+    { cause: error },
+  );
 }

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

@@ -1,3 +1,5 @@
+import { ProviderResponseError } from "./model-client";
+
 type ProviderContext = { provider: string; model: string };
 
 type ToolCallAccumulator = {
@@ -265,8 +267,10 @@ function providerStreamError(
   options: ProviderContext,
   path: string,
   detail: string,
-): Error {
-  return new Error(
+): ProviderResponseError {
+  return new ProviderResponseError(
+    "invalid_provider_stream",
     `Invalid provider stream (provider=${options.provider}, model=${options.model}): ${path} ${detail}.`,
+    { provider: options.provider, model: options.model, path },
   );
 }

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,12 @@ export function createDefaultTooling(options: {
   taskStopGraceMs?: number;
   skillCatalog?: SkillCatalogSnapshot;
   skillCoordinator?: SkillActivationCoordinator;
+  toolingConfig?: PublicToolingConfig;
 }): 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 +155,11 @@ export function createDefaultTooling(options: {
     createGrepToolExecutor({
       workspaceRoot: options.workspaceRoot,
       cwdState,
+      ripgrep: {
+        command: toolingConfig.ripgrepPath,
+        timeoutMs: toolingConfig.grepTimeoutMs,
+        maxBufferBytes: toolingConfig.grepMaxBufferBytes,
+      },
     }),
   );
   registry.register(
@@ -192,13 +203,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 +222,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/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);
 }

package/src/tui/app.tsx

@@ -42,12 +42,14 @@ import type { SessionSummary } from "../session/session-catalog";
 import type { ModelProfile, ModelProfiles } from "../cli/model-profiles";
 import { loadViewFile, type ViewFile } from "./view-file";
 import { writeClipboardText } from "./clipboard";
+import type { WorkspaceFileLister } from "./workspace-file-search";
 
 export type AppProps = {
   sessionController: TuiSessionController;
   readGitBranch?: (workspaceRoot: string) => Promise<string | undefined>;
   history?: PromptHistory;
   projectSlashCommands?: readonly ProjectSlashCommand[];
+  fileLister?: WorkspaceFileLister;
   profiles?: ModelProfiles;
   persistDefaultProfile?: (profileName: string) => Promise<void>;
   readViewFile?: (workspaceRoot: string, filePath: string) => Promise<ViewFile>;
@@ -647,6 +649,7 @@ export function App(props: AppProps) {
                 isDisabled={isRunning || isSessionOperation || isCopying}
                 history={props.history}
                 commands={availableCommands}
+                fileLister={props.fileLister}
                 importImage={binding.importImage}
                 verifyImageAssets={binding.verifyImageAssets}
                 onSubmit={onSubmit}

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

@@ -222,7 +222,8 @@ export function PromptInput(props: PromptInputProps) {
     if (mention === undefined || locked) {
       return;
     }
-    if (props.importImage === undefined) {
+    const importImage = props.importImage;
+    if (importImage === undefined) {
       insertFilePath(filePath);
       return;
     }
@@ -236,8 +237,10 @@ export function PromptInput(props: PromptInputProps) {
       phase: { kind: "attaching", operationId },
       error: undefined,
     }));
-    void props
-      .importImage(filePath, controller.signal, captured.attachments.length + 1)
+    void Promise.resolve()
+      .then(() =>
+        importImage(filePath, controller.signal, captured.attachments.length + 1),
+      )
       .then((imported) => {
         setState((current) => {
           if (

package/src/tui/event-store.ts

@@ -153,13 +153,21 @@ export function reduceTuiProjection(
     }
     case "model.request.started":
       return updateActiveTurn(state, event, policy, (turn) =>
-        appendTurnItem(turn, {
-          id: `model-${event.iterationId}`,
-          ref: modelRequestRef(event.iterationId),
-          text: `model iteration ${event.iterationNumber}`,
-          status: "running",
-        }),
+        event.data.attemptNumber === 1
+          ? appendTurnItem(turn, {
+              id: `model-${event.iterationId}`,
+              ref: modelRequestRef(event.iterationId),
+              text: `model iteration ${event.iterationNumber}`,
+              status: "running",
+            })
+          : updateTurnItem(turn, modelRequestRef(event.iterationId), (item) => ({
+              ...item,
+              text: `model iteration ${event.iterationNumber} · retrying`,
+              status: "running",
+            })),
       );
+    case "model.request.failed":
+      return state;
     case "model.request.finished":
       return updateActiveTurn(state, event, policy, (turn) =>
         updateTurnItem(turn, modelRequestRef(event.iterationId), (item) => ({
@@ -333,7 +341,7 @@ export function reduceTuiProjection(
     }
     case "turn.failed": {
       const active = requireActiveTurn(state, event);
-      const failed = appendTurnItem(active, {
+      const failed = appendTurnItem(markRunningItemsFailed(active), {
         id: `turn-${active.turnId}-failed-${event.eventSequence}`,
         label: "error",
         text: event.data.error,
@@ -467,6 +475,15 @@ function appendTurnItem(
   return { ...turn, items: [...turn.items, item] };
 }
 
+function markRunningItemsFailed(turn: TuiTurnProjection): TuiTurnProjection {
+  return {
+    ...turn,
+    items: turn.items.map((item) =>
+      item.status === "running" ? { ...item, status: "failed" } : item,
+    ),
+  };
+}
+
 function updateTurnItem(
   turn: TuiTurnProjection,
   ref: string,