tinker-agent 2.9.0 → 2.11.0

package/src/cli/connect-runner.tsx

@@ -0,0 +1,26 @@
+import { render } from "ink";
+import { RemoteClient, loadRemoteClientConfig } from "../remote/client";
+import { RemoteApp } from "../tui/remote-app";
+import type { CliOutputWriter } from "./output";
+
+export async function runConnect(input: {
+  configPath: string;
+  env: NodeJS.ProcessEnv;
+  stdout: CliOutputWriter;
+}): Promise<number> {
+  if (!process.stdin.isTTY)
+    throw new Error("tinker connect requires an interactive terminal.");
+  const client = new RemoteClient(await loadRemoteClientConfig(input.configPath));
+  let instance: ReturnType<typeof render> | undefined;
+  try {
+    await client.initialize();
+    instance = render(<RemoteApp client={client} />, { incrementalRendering: true });
+    await instance.waitUntilExit();
+    return 0;
+  } finally {
+    instance?.unmount();
+    await client.close();
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    process.stdin.pause();
+  }
+}

package/src/cli/main.ts

@@ -1,4 +1,5 @@
 import type { SessionId } from "../ids/runtime-id";
+import path from "node:path";
 import { createUuidV7 } from "../ids/uuid-v7";
 import { parseCommandLine, type CommandLineResult } from "./command-line";
 import type {
@@ -91,6 +92,8 @@ export type MainDependencies = {
   readonly loadTuiRunner: () => Promise<TuiRunner>;
   readonly loadOneShotRunner: () => Promise<OneShotRunner>;
   readonly loadUpdateRunner: () => Promise<UpdateRunner>;
+  readonly loadServeRunner: () => Promise<typeof import("./serve-runner")>;
+  readonly loadConnectRunner: () => Promise<typeof import("./connect-runner")>;
 };
 
 const DEFAULT_DEPENDENCIES: MainDependencies = {
@@ -102,6 +105,8 @@ const DEFAULT_DEPENDENCIES: MainDependencies = {
   loadTuiRunner: () => import("./tui-runner"),
   loadOneShotRunner: () => import("./run-runner"),
   loadUpdateRunner: () => import("./update-runner"),
+  loadServeRunner: () => import("./serve-runner"),
+  loadConnectRunner: () => import("./connect-runner"),
 };
 
 export async function main(
@@ -160,6 +165,27 @@ export async function main(
       }
     }
 
+    if (parsed.command.type === "serve" || parsed.command.type === "connect") {
+      const options = {
+        configPath: path.resolve(cwd, parsed.command.configPath),
+        env,
+        stdout: input.stdout,
+      };
+      try {
+        const exitCode =
+          parsed.command.type === "serve"
+            ? await (await dependencies.loadServeRunner()).runServe(options)
+            : await (await dependencies.loadConnectRunner()).runConnect(options);
+        return finish(exitCode);
+      } catch (error) {
+        await writeCliOutput(
+          input.stderr,
+          renderCliFailure("Remote operation failed", error),
+        );
+        return finish(1);
+      }
+    }
+
     let configBoundary: ConfigBoundary;
     let publicConfig: ResolvedPublicConfig;
     let runnerConfig: RunnerConfig;

package/src/cli/output.ts

@@ -4,7 +4,7 @@ const TRUNCATION_MARKER = "...[truncated]";
 const ESCAPE = String.fromCharCode(27);
 const ANSI_CSI_PATTERN = new RegExp(`${ESCAPE}\\[[0-?]*[ -/]*[@-~]`, "g");
 
-export type CliCommandScope = "root" | "run" | "update";
+export type CliCommandScope = "root" | "run" | "update" | "serve" | "connect";
 
 export interface CliOutputWriter {
   write(chunk: string): boolean | void;

package/src/cli/public-cli-contract.ts

@@ -47,6 +47,24 @@ export const PUBLIC_CLI_CONTRACT = Object.freeze({
     description: "Start the interactive terminal interface.",
     profileOption: PROFILE_OPTION,
   }),
+  serve: Object.freeze({
+    command: "serve",
+    description: "Run the local daemon for paired remote clients.",
+    configOption: Object.freeze({
+      flags: "--config <path>",
+      description: "Read the service JSON configuration.",
+      valueName: "path",
+    } satisfies PublicCliOption),
+  }),
+  connect: Object.freeze({
+    command: "connect",
+    description: "Attach a terminal client to a service; exiting detaches only.",
+    configOption: Object.freeze({
+      flags: "--config <path>",
+      description: "Read the paired client JSON configuration.",
+      valueName: "path",
+    } satisfies PublicCliOption),
+  }),
   run: Object.freeze({
     command: "run [prompt]",
     description: "Run one prompt non-interactively.",

package/src/cli/public-config-contract.ts

@@ -174,7 +174,7 @@ export const PUBLIC_CONFIG_FIELDS = Object.freeze([
     valueKind: "positive-integer",
     requiredIn: "never",
     appliesIn: "always",
-    defaultValue: 5_000,
+    defaultValue: 60_000,
     secret: false,
     section: "tooling",
     description: "Default Bash foreground timeout in milliseconds.",

package/src/cli/serve-runner.ts

@@ -0,0 +1,45 @@
+import { loadRemoteConfig } from "../remote/config";
+import { startRemoteHttpServer } from "../remote/http-server";
+import { RemoteService } from "../remote/service";
+import { RemoteServiceStore } from "../remote/service-store";
+import { defaultHomeRoot } from "../session/workspace-storage";
+import { createHostedRuntimeFactory } from "./serve-runtime";
+import { writeCliOutput, type CliOutputWriter } from "./output";
+
+export async function runServe(input: {
+  configPath: string;
+  env: NodeJS.ProcessEnv;
+  stdout: CliOutputWriter;
+}): Promise<number> {
+  const config = await loadRemoteConfig(input.configPath);
+  const homeRoot = defaultHomeRoot(input.env);
+  const store = await RemoteServiceStore.open(config.stateDirectory);
+  const service = new RemoteService(
+    store,
+    config.workspaces,
+    createHostedRuntimeFactory(config.workspaces, input.env, homeRoot),
+    homeRoot,
+  );
+  let transport: ReturnType<typeof startRemoteHttpServer> | undefined;
+  try {
+    await service.initialize();
+    transport = startRemoteHttpServer(service, config);
+    await writeCliOutput(
+      input.stdout,
+      `Tinker service listening on https://${config.hostname}:${transport.port}; ${config.workspaces.length} workspace(s).\nClient disconnects detach only. Stop the process to shut down hosted sessions.\n`,
+    );
+    await new Promise<void>((resolve) => {
+      const stop = () => {
+        process.off("SIGINT", stop);
+        process.off("SIGTERM", stop);
+        resolve();
+      };
+      process.once("SIGINT", stop);
+      process.once("SIGTERM", stop);
+    });
+    return 0;
+  } finally {
+    await transport?.stopTransport();
+    await service.close();
+  }
+}

package/src/cli/serve-runtime.ts

@@ -0,0 +1,100 @@
+import { createRuntimeSession } from "../agent/runtime-session";
+import { parseSessionId } from "../ids/runtime-id";
+import {
+  buildSystemPrompt,
+  loadProjectInstructions,
+  projectInstructionManifest,
+} from "../instructions/project-instructions";
+import { createReasoningEffortController } from "../model/reasoning-effort";
+import { resolveSessionDatabasePath } from "../session/session-store";
+import { SessionCatalog } from "../session/session-catalog";
+import { loadSkillCatalog } from "../skills/skill-loader";
+import type { RemoteWorkspaceConfig } from "../remote/config";
+import type { HostedRuntimeFactory } from "../agent/runtime-hosted-session";
+import { deriveRunnerConfig, resolvePublicConfig } from "./config";
+import { resolveSessionProfileName } from "./model-profiles";
+import {
+  createRunnerModelClient,
+  createWebFetchRefiner,
+  RUNTIME_INSTRUCTIONS,
+} from "./runner-dependencies";
+
+/** Service composition reuses the existing configuration/provider/runtime contracts. */
+export function createHostedRuntimeFactory(
+  workspaces: readonly RemoteWorkspaceConfig[],
+  env: NodeJS.ProcessEnv,
+  homeRoot?: string,
+): HostedRuntimeFactory {
+  return async ({ record, sink }) => {
+    const workspace = workspaces.find((entry) => entry.id === record.workspaceId);
+    if (!workspace || workspace.path !== record.workspacePath)
+      throw new Error("Managed workspace configuration changed.");
+    const sessionId = parseSessionId(record.id);
+    const publicConfig = await resolvePublicConfig({
+      env: { ...env, TINKER_WORKSPACE: workspace.path },
+      cwd: workspace.path,
+    });
+    let profileName = workspace.profile;
+    if (record.initialized && publicConfig.mode === "profile") {
+      const summary = await new SessionCatalog({
+        workspaceRoot: workspace.path,
+        homeRoot,
+      }).get(sessionId);
+      profileName = resolveSessionProfileName(publicConfig.profiles, summary);
+    }
+    const config = deriveRunnerConfig(publicConfig, {
+      sessionId,
+      ...(profileName ? { profileName } : {}),
+    });
+    const reasoning = createReasoningEffortController(config.reasoning);
+    const projectInstructions = await loadProjectInstructions(workspace.path);
+    const runtime = await createRuntimeSession({
+      workspaceRoot: workspace.path,
+      ...(homeRoot === undefined ? {} : { homeRoot }),
+      ...(record.initialized
+        ? { selection: { mode: "resume" as const, sessionId } }
+        : { selection: { mode: "new" as const, sessionId } }),
+      modelName: config.modelName,
+      profileName: config.profileName,
+      maxIterations: config.maxIterations,
+      includeReasoningContent: config.includeReasoningContent,
+      contextProfile: config.contextProfile,
+      contextBudget: config.contextBudget,
+      modelClient: createRunnerModelClient(config, undefined, env, reasoning),
+      systemPrompt: buildSystemPrompt({
+        workspaceRoot: workspace.path,
+        runtimeInstructions: RUNTIME_INSTRUCTIONS(workspace.path),
+        projectInstructions,
+      }),
+      projectInstruction: projectInstructionManifest(projectInstructions),
+      skillCatalog: await loadSkillCatalog({ workspaceRoot: workspace.path }),
+      presentationSinks: [sink],
+      assistantTextDeltaSink: sink,
+      toolingConfig: publicConfig.tooling,
+      webFetchRefiner: createWebFetchRefiner(config, env, reasoning),
+      enableAskUser: true,
+      bashGuard: {
+        mode: config.bashGuardMode,
+        source: config.bashGuardSource,
+        surface: "tui",
+      },
+    });
+    try {
+      return {
+        runtime,
+        databasePath: await resolveSessionDatabasePath(
+          workspace.path,
+          sessionId,
+          homeRoot,
+        ),
+        modelName: config.modelName,
+      };
+    } catch (error) {
+      await runtime.dispose({
+        type: "initialization_failed",
+        error: "Cannot open remote history reader.",
+      });
+      throw error;
+    }
+  };
+}

package/src/cli/tui-runner.tsx

@@ -119,6 +119,7 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
         toolingConfig: options.publicConfig.tooling,
         enableTurnUndo: true,
         enableAskUser: true,
+        enableProviderRetryPrompt: true,
         bashGuard: {
           mode: sessionConfig.bashGuardMode,
           source: sessionConfig.bashGuardSource,

package/src/context/context-swap-renderer.ts

@@ -193,6 +193,11 @@ function metadataEntries(
         ["pattern", raw.pattern],
         ["searchPath", raw.searchPath],
         ["matchCount", raw.matchCount],
+        ["totalMatches", raw.totalMatches],
+        ["returnedCount", raw.returnedCount],
+        ["appliedOffset", raw.appliedOffset],
+        ["hasMore", raw.hasMore],
+        ["nextOffset", raw.nextOffset],
       ];
     case "grep":
       return [
@@ -200,6 +205,15 @@ function metadataEntries(
         ["searchPath", raw.searchPath],
         ["mode", raw.mode],
         ["numMatches", raw.numMatches],
+        ["numLines", raw.numLines],
+        ["paginationUnit", raw.paginationUnit],
+        ["totalResults", raw.totalResults],
+        ["returnedResults", raw.returnedResults],
+        ["appliedOffset", raw.appliedOffset],
+        ["hasMore", raw.hasMore],
+        ["nextOffset", raw.nextOffset],
+        ["searchIncomplete", raw.searchIncomplete],
+        ["contextMayBeIncomplete", raw.contextMayBeIncomplete],
         ["truncated", raw.truncated],
       ];
     case "bash":

package/src/events/types.ts

@@ -337,6 +337,12 @@ export type AgentEventDataMap = {
   "agent.iteration.started": { iterationNumber: number };
   "model.request.started": ModelRequestAttemptData;
   "model.request.failed": ModelRequestFailedData;
+  "model.retry.requested": ModelRequestFailedData;
+  "model.retry.resolved": {
+    attemptNumber: number;
+    decision: "retry" | "stop" | "cancelled";
+    durationMs: number;
+  };
   "model.request.finished": ModelRequestAttemptData & {
     output: ModelRequestOutput;
   };
@@ -457,6 +463,8 @@ export type AgentEventInput =
       | "agent.iteration.started"
       | "model.request.started"
       | "model.request.failed"
+      | "model.retry.requested"
+      | "model.retry.resolved"
       | "model.request.finished"
       | "context.usage.updated"
       | "context.shadow.planned"

package/src/image/abortable-file-open.ts

@@ -0,0 +1,54 @@
+import type { FileHandle } from "node:fs/promises";
+
+// An OS permission prompt can leave open() pending without accepting a signal.
+// Cancellation releases the caller; ownership of a late handle stays here.
+export function abortableFileOpen(
+  openFile: () => Promise<FileHandle>,
+  signal?: AbortSignal,
+  onWarning?: (message: string) => void,
+): Promise<FileHandle> {
+  signal?.throwIfAborted();
+  if (signal === undefined) return openFile();
+
+  return new Promise<FileHandle>((resolve, reject) => {
+    let cancelled = false;
+    const onAbort = () => {
+      cancelled = true;
+      signal.removeEventListener("abort", onAbort);
+      reject(asError(signal.reason));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    // Also handle a synchronous failure from the opener without leaking a listener.
+    Promise.resolve()
+      .then(() => {
+        signal.throwIfAborted();
+        return openFile();
+      })
+      .then(async (handle) => {
+        signal.removeEventListener("abort", onAbort);
+        if (cancelled) {
+          try {
+            await handle.close();
+          } catch (error) {
+            onWarning?.(
+              `Failed to close cancelled image file: ${error instanceof Error ? error.message : String(error)}.`,
+            );
+          }
+        } else {
+          resolve(handle);
+        }
+      })
+      .catch((error: unknown) => {
+        signal.removeEventListener("abort", onAbort);
+        if (cancelled) {
+          // Late open failures must not become unhandled rejections.
+          return;
+        }
+        reject(asError(error));
+      });
+  });
+}
+
+function asError(error: unknown): Error {
+  return error instanceof Error ? error : new Error(String(error), { cause: error });
+}

package/src/image/image-asset-store.ts

@@ -13,6 +13,7 @@ import {
 import path from "node:path";
 import { createUuidV7 } from "../ids/uuid-v7";
 import { IMAGE_INPUT_POLICY } from "./image-input-policy";
+import { abortableFileOpen } from "./abortable-file-open";
 import { probeImageBytes } from "./image-probe";
 import {
   normalizeOriginalImageName,
@@ -116,9 +117,14 @@ export class ImageAssetStore {
       assertContained(this.workspaceRoot, canonicalSource, "Image source realpath");
     }
 
-    const handle = await open(canonicalSource, constants.O_RDONLY | noFollowFlag());
+    const handle = await abortableFileOpen(
+      () => open(canonicalSource, constants.O_RDONLY | noFollowFlag()),
+      options.signal,
+      this.onWarning,
+    );
     let bytes: Buffer;
     try {
+      throwIfAborted(options.signal);
       const handleStat = await handle.stat();
       if (
         !handleStat.isFile() ||

package/src/model/fake-model-client.ts

@@ -25,7 +25,7 @@ import type {
   PreparedModelRequest,
   PreparedPromptSegment,
 } from "./model-client";
-import { validateModelModalities } from "./model-client";
+import { ProviderResponseError, validateModelModalities } from "./model-client";
 import { sha256, stableJsonStringify } from "./model-request-preflight";
 import { estimatePromptSegments } from "./token-estimator";
 
@@ -212,6 +212,25 @@ export class FakeModelClient implements ModelClient {
       );
     }
 
+    if (this.mode === "pty-provider-retry") {
+      if (lastUserMessage(input.messages) === "PTY_RETRY_NEXT") {
+        return textOutput(prepared, "PTY_RETRY_NEXT_DONE");
+      }
+      if (this.steps <= 4) {
+        options.onTextDelta?.(
+          `## Attempt ${this.steps}\nPartial response\n\n## Unfinished\nDRAFT_ONLY`,
+        );
+        throw new ProviderResponseError(
+          "reasoning_only_assistant",
+          "PTY_PROVIDER_FAILURE",
+          {
+            provider: prepared.provider,
+            model: prepared.model,
+          },
+        );
+      }
+      return textOutput(prepared, "PTY_RETRY_DONE");
+    }
     if (this.mode === "write-notes") {
       return this.writeNotes(input, prepared, options);
     }

package/src/model/openai-model-utils.ts

@@ -358,12 +358,56 @@ function providerErrorCode(error: unknown): ProviderResponseErrorCode {
   if (status === 500 || status === 502 || status === 503 || status === 504) {
     return "provider_unavailable";
   }
-  if (status === undefined && error instanceof OpenAI.APIConnectionError) {
+  // Explicit HTTP failures take precedence over payload or transport hints.
+  if (status !== undefined) return "provider_request_error";
+  const code = errorField(error, "code");
+  if (code === "server_error") return "provider_unavailable";
+  if (code === "rate_limit_exceeded") return "provider_rate_limited";
+  if (error instanceof OpenAI.APIConnectionError || isTransportFailure(error)) {
     return "provider_unavailable";
   }
   return "provider_request_error";
 }
 
+const TRANSIENT_TRANSPORT_CODES = new Set([
+  "ECONNRESET",
+  "EPIPE",
+  "ETIMEDOUT",
+  "ERR_STREAM_PREMATURE_CLOSE",
+  "UND_ERR_SOCKET",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_BODY_TIMEOUT",
+]);
+
+function isTransportFailure(error: unknown): boolean {
+  const seen = new Set<unknown>();
+  // Fetch may wrap a socket error in TypeError.cause after headers arrive.
+  for (let depth = 0; error !== undefined && depth < 8; depth += 1) {
+    if (seen.has(error)) return false;
+    seen.add(error);
+    if (
+      errorField(error, "name") === "AbortError" ||
+      error instanceof OpenAI.APIUserAbortError ||
+      providerErrorStatus(error) !== undefined
+    ) {
+      return false;
+    }
+    const code = errorField(error, "code");
+    if (code !== undefined) {
+      return typeof code === "string" && TRANSIENT_TRANSPORT_CODES.has(code);
+    }
+    error = errorField(error, "cause");
+  }
+  return false;
+}
+
+function errorField(error: unknown, key: string): unknown {
+  return typeof error === "object" && error !== null
+    ? (error as Record<string, unknown>)[key]
+    : undefined;
+}
+
 function providerErrorStatus(error: unknown): number | undefined {
   if (typeof error !== "object" || error === null || !("status" in error)) {
     return undefined;

package/src/model/openai-responses-mapping.ts

@@ -28,6 +28,7 @@ import {
   type ProviderResponseDiagnostics,
 } from "./model-client";
 import { imageAssetUrlMarker } from "./openai-image-mapping";
+import { sanitizedProviderError } from "./openai-model-utils";
 
 export type OpenAIResponsesMappingOptions = {
   materializedImages?: ReadonlyMap<ImageAssetId, string>;
@@ -160,6 +161,16 @@ export function fromOpenAIResponse(
 ): ModelRequestOutput {
   const root = requireRecord(response, "response", options);
   const status = requireString(root.status, "status", options);
+  if (status === "failed") {
+    const error = requireRecord(root.error, "error", options);
+    const code = requireString(error.code, "error.code", options);
+    const message = requireString(error.message, "error.message", options);
+    throw sanitizedProviderError(
+      Object.assign(new Error(message), { code }),
+      options.provider,
+      options.model,
+    );
+  }
   if (status !== "completed" && status !== "incomplete") {
     throw providerResponseError(
       options,

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

@@ -2,6 +2,7 @@ import {
   ProviderResponseError,
   type ProviderResponseDiagnostics,
 } from "./model-client";
+import { sanitizedProviderError } from "./openai-model-utils";
 
 export class OpenAIResponsesStreamAccumulator {
   private eventCount = 0;
@@ -20,6 +21,19 @@ export class OpenAIResponsesStreamAccumulator {
     const type = requireString(record.type, `${path}.type`, this.options);
     this.eventCount += 1;
 
+    if (type === "error") {
+      const message = requireString(record.message, `${path}.message`, this.options);
+      const code =
+        record.code === null
+          ? null
+          : requireString(record.code, `${path}.code`, this.options);
+      throw sanitizedProviderError(
+        Object.assign(new Error(message), { code }),
+        this.options.provider,
+        this.options.model,
+      );
+    }
+
     if (type === "response.output_text.delta") {
       return requireString(record.delta, `${path}.delta`, this.options);
     }