tinker-agent 1.5.1 → 1.7.0

package/src/events/observation-text-log.ts

@@ -39,6 +39,27 @@ export function renderObservationLogEvent(event: AgentEvent): string | undefined
       return renderAssistantProgress(event);
     case "tool.observation":
       return renderToolObservation(event);
+    case "tool.confirmation.requested":
+      return [
+        "## Bash confirmation requested",
+        "",
+        `Reason: ${event.data.reason}`,
+        "",
+        event.data.command,
+        "",
+        "---",
+        "",
+      ].join("\n");
+    case "tool.confirmation.resolved":
+      return [
+        "## Bash confirmation resolved",
+        "",
+        `Decision: ${event.data.decision}`,
+        `Duration: ${event.data.durationMs} ms`,
+        "",
+        "---",
+        "",
+      ].join("\n");
     case "turn.finished":
       return renderTurnFinished(event.data);
     case "turn.cancelled":
@@ -158,7 +179,11 @@ function toolCallSummary(call: ToolCall): string {
       .join("\n");
   }
 
-  if (call.name === "TaskOutput" || call.name === "TaskStop") {
+  if (
+    call.name === "TaskOutput" ||
+    call.name === "TaskInput" ||
+    call.name === "TaskStop"
+  ) {
     const taskId = stringProperty(args, "task_id");
     return [
       `Call ID: ${call.toolCallId}`,

package/src/events/stdout-event-printer.ts

@@ -117,6 +117,16 @@ export class StdoutEventPrinter implements EventSink {
           `${formatToolLine("tool.finished", event.data.call).trimEnd()} ok=${event.data.ok}\n`,
         );
         break;
+      case "tool.confirmation.requested":
+        this.stdout.write(
+          `tool.confirmation.requested toolCallId=${event.toolCallId} reason=${JSON.stringify(event.data.reason)} command=${JSON.stringify(event.data.command)}\n`,
+        );
+        break;
+      case "tool.confirmation.resolved":
+        this.stdout.write(
+          `tool.confirmation.resolved toolCallId=${event.toolCallId} decision=${event.data.decision} durationMs=${event.data.durationMs}\n`,
+        );
+        break;
       case "mcp.server.connected":
         this.stdout.write(
           `mcp.server.connected name=${event.data.serverName} tools=${event.data.toolCount}\n`,
@@ -192,6 +202,7 @@ function formatToolRawResult(call: ToolCall, raw: ToolRawResult): string[] {
       return optionalLine(formatDiff(call, raw));
     case "bash":
     case "task_output":
+    case "task_input":
       return optionalLine(formatBashResult(call, raw));
     case "task_list":
     case "task_stop":
@@ -199,6 +210,7 @@ function formatToolRawResult(call: ToolCall, raw: ToolRawResult): string[] {
     case "skill":
       return [formatSkillResult(raw)];
     case "read":
+    case "delete":
     case "glob":
     case "grep":
     case "web_search":
@@ -267,7 +279,7 @@ function formatDiff(call: ToolCall, raw: ToolRawResult): string | undefined {
 }
 
 function formatBashResult(_call: ToolCall, raw: ToolRawResult): string | undefined {
-  if (raw.kind !== "bash" && raw.kind !== "task_output") {
+  if (raw.kind !== "bash" && raw.kind !== "task_output" && raw.kind !== "task_input") {
     return undefined;
   }
 
@@ -337,7 +349,11 @@ function formatToolLine(prefix: string, call: ToolCall): string {
     return `${prefix} name=${call.name}\n`;
   }
 
-  if (call.name === "TaskOutput" || call.name === "TaskStop") {
+  if (
+    call.name === "TaskOutput" ||
+    call.name === "TaskInput" ||
+    call.name === "TaskStop"
+  ) {
     const taskId = toolTaskId(call);
     return `${prefix} name=${call.name}${taskId === undefined ? "" : ` task=${taskId}`}\n`;
   }

package/src/events/types.ts

@@ -285,8 +285,8 @@ export type TurnFinishedData = {
 };
 
 export type ModelRequestAttemptData = {
-  attemptNumber: 1 | 2;
-  maxAttempts: 2;
+  attemptNumber: number;
+  maxAttempts: number;
 };
 
 export type ModelRequestFailureCode = ProviderResponseErrorCode;
@@ -294,6 +294,7 @@ export type ModelRequestFailureCode = ProviderResponseErrorCode;
 export type ModelRequestFailedData = ModelRequestAttemptData & {
   code: ModelRequestFailureCode;
   retryDisposition: "scheduled" | "not_retryable" | "exhausted";
+  retryDelayMs?: number;
   provider: string;
   model: string;
   error: string;
@@ -328,6 +329,16 @@ export type AgentEventDataMap = {
   "tool.raw_result": { call: ToolCall; raw: ToolRawResult };
   "tool.finished": { call: ToolCall; ok: boolean };
   "tool.observation": { call: ToolCall; observation: ToolObservation };
+  "tool.confirmation.requested": {
+    command: string;
+    reason: string;
+  };
+  "tool.confirmation.resolved": {
+    command: string;
+    reason: string;
+    decision: "allow" | "deny" | "cancelled";
+    durationMs: number;
+  };
   "agent.iteration.finished": {
     outcome: "continue" | "completed";
     toolCallCount: number;
@@ -419,6 +430,7 @@ export type AgentEventInput =
   | ToolEventInput<
       "tool.started" | "tool.raw_result" | "tool.finished" | "tool.observation"
     >
+  | ToolEventInput<"tool.confirmation.requested" | "tool.confirmation.resolved">
   | ToolEventInput<
       "bash.task.backgrounded" | "bash.task.stopping" | "bash.task.finished"
     >;

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

@@ -229,6 +229,9 @@ export class FakeModelClient implements ModelClient {
     if (this.mode === "pty-static-history") {
       return this.ptyStaticHistory(input, prepared, options);
     }
+    if (this.mode === "pty-incremental-output") {
+      return this.ptyIncrementalOutput(input, prepared, options);
+    }
     if (this.mode === "pty-resume-layout") {
       return this.ptyResumeLayout(input, prepared, options);
     }
@@ -238,9 +241,15 @@ export class FakeModelClient implements ModelClient {
     if (this.mode === "pty-tool-chain") {
       return this.ptyToolChain(input, prepared, options);
     }
+    if (this.mode === "pty-turn-undo") {
+      return this.ptyTurnUndo(input, prepared, options);
+    }
     if (this.mode === "pty-background-task") {
       return this.ptyBackgroundTask(input, prepared, options);
     }
+    if (this.mode === "pty-interactive-terminal") {
+      return this.ptyInteractiveTerminal(input, prepared, options);
+    }
     if (this.mode === "pty-resume") {
       return this.ptyResume(input, prepared, options);
     }
@@ -361,6 +370,39 @@ export class FakeModelClient implements ModelClient {
     return textOutput(prepared, "PTY_STATIC_LIVE_DONE");
   }
 
+  private async ptyIncrementalOutput(
+    input: ModelRequestInput,
+    prepared: PreparedModelRequest,
+    options: ModelRequestOptions,
+  ): Promise<ModelRequestOutput> {
+    const prompt = lastUserMessage(input.messages);
+    if (prompt !== "PTY_INCREMENTAL_OUTPUT") {
+      throw new Error(
+        `Unexpected pty-incremental-output prompt: ${JSON.stringify(prompt)}.`,
+      );
+    }
+
+    const chunks = [
+      "## PTY incremental first\nPTY_INCREMENTAL_EARLY_SENTINEL\n\n## PTY incre",
+      "mental second\n",
+      "PTY_INCREMENTAL_SECOND_BODY\n\n## PTY incremental final\n",
+      "PTY_INCREMENTAL_FINAL_SENTINEL",
+    ] as const;
+    options.onTextDelta?.(chunks[0]);
+    await Bun.sleep(50);
+    options.signal.throwIfAborted();
+    options.onTextDelta?.(chunks[1]);
+    await Bun.sleep(700);
+    options.signal.throwIfAborted();
+    options.onTextDelta?.(chunks[2]);
+    await Bun.sleep(100);
+    options.signal.throwIfAborted();
+    options.onTextDelta?.(chunks[3]);
+    await Bun.sleep(100);
+    options.signal.throwIfAborted();
+    return textOutput(prepared, chunks.join(""));
+  }
+
   private ptyResumeLayout(
     input: ModelRequestInput,
     prepared: PreparedModelRequest,
@@ -504,6 +546,60 @@ export class FakeModelClient implements ModelClient {
     return textOutput(prepared, "PTY_TOOL_CHAIN_DONE");
   }
 
+  private ptyTurnUndo(
+    input: ModelRequestInput,
+    prepared: PreparedModelRequest,
+    options: ModelRequestOptions,
+  ): ModelRequestOutput {
+    requireTools(input, ["Read", "Write", "Delete"]);
+    const prompt = lastUserMessage(input.messages);
+    if (prompt !== "PTY_UNDO_MUTATE") {
+      throw new Error(`Unexpected pty-turn-undo prompt: ${JSON.stringify(prompt)}.`);
+    }
+
+    const tools = toolMessagesAfterLastUser(input.messages);
+    const read = tools.find((message) => message.name === "Read");
+    if (read === undefined) {
+      return toolCallOutput(prepared, options, "Read", {
+        file_path: "pty-undo-modified.txt",
+      });
+    }
+    if (!read.content.includes("Read succeeded")) {
+      throw new Error("PTY undo Read tool did not succeed.");
+    }
+
+    const writes = tools.filter((message) => message.name === "Write");
+    if (writes.length === 0) {
+      return toolCallOutput(prepared, options, "Write", {
+        file_path: "pty-undo-modified.txt",
+        content: "after undo turn\n",
+      });
+    }
+    if (!writes[0]?.content.includes("Write succeeded")) {
+      throw new Error("PTY undo modifying Write did not succeed.");
+    }
+    if (writes.length === 1) {
+      return toolCallOutput(prepared, options, "Write", {
+        file_path: "pty-undo-created/nested.txt",
+        content: "created by undo turn\n",
+      });
+    }
+    if (!writes[1]?.content.includes("Write succeeded")) {
+      throw new Error("PTY undo creating Write did not succeed.");
+    }
+
+    const deletion = tools.find((message) => message.name === "Delete");
+    if (deletion === undefined) {
+      return toolCallOutput(prepared, options, "Delete", {
+        file_path: "pty-undo-deleted.bin",
+      });
+    }
+    if (!deletion.content.includes("Delete succeeded")) {
+      throw new Error("PTY undo Delete tool did not succeed.");
+    }
+    return textOutput(prepared, "PTY_UNDO_MUTATIONS_DONE");
+  }
+
   private ptyBackgroundTask(
     input: ModelRequestInput,
     prepared: PreparedModelRequest,
@@ -565,6 +661,87 @@ export class FakeModelClient implements ModelClient {
     return textOutput(prepared, "PTY_BACKGROUND_STOPPED");
   }
 
+  private ptyInteractiveTerminal(
+    input: ModelRequestInput,
+    prepared: PreparedModelRequest,
+    options: ModelRequestOptions,
+  ): ModelRequestOutput {
+    requireTools(input, ["Bash", "TaskOutput", "TaskInput"]);
+    const prompt = lastUserMessage(input.messages);
+    if (prompt === "PTY_INTERACTIVE_FOLLOWUP") {
+      requireMessage(input.messages, "assistant", "PTY_INTERACTIVE_DONE");
+      return textOutput(prepared, "PTY_INTERACTIVE_FOLLOWUP_DONE");
+    }
+    if (prompt !== "PTY_INTERACTIVE_TERMINAL" && prompt !== "PTY_INTERACTIVE_QUIT") {
+      throw new Error(
+        `Unexpected pty-interactive-terminal prompt: ${JSON.stringify(prompt)}.`,
+      );
+    }
+
+    const tools = toolMessagesAfterLastUser(input.messages);
+    const bash = tools.find((message) => message.name === "Bash");
+    if (bash === undefined) {
+      return toolCallOutput(prepared, options, "Bash", {
+        command: "python3 -q",
+        description: "Start interactive Python fixture",
+        tty: true,
+        timeout: 25,
+      });
+    }
+    if (!bash.content.includes("taskId=") || !bash.content.includes("tty=true")) {
+      throw new Error("PTY Bash task did not return an interactive task ID.");
+    }
+    const taskId = requireObservationValue(bash.content, "taskId");
+
+    const outputs = tools.filter((message) => message.name === "TaskOutput");
+    const output = outputs.at(-1);
+    if (output === undefined || !output.content.includes(">>>")) {
+      if (outputs.length >= 20) {
+        throw new Error("Interactive Python fixture did not show its prompt.");
+      }
+      return toolCallOutput(prepared, options, "TaskOutput", {
+        task_id: taskId,
+      });
+    }
+
+    const inputs = tools.filter((message) => message.name === "TaskInput");
+    if (inputs.length === 0) {
+      return toolCallOutput(prepared, options, "TaskInput", {
+        task_id: taskId,
+        chars:
+          prompt === "PTY_INTERACTIVE_QUIT"
+            ? "import os; print('PTY_INTERACTIVE_PID=' + str(os.getpid()))\n"
+            : "print(6 * 7)\n",
+        wait_ms: 250,
+      });
+    }
+
+    const latestInput = inputs.at(-1);
+    const expected = prompt === "PTY_INTERACTIVE_QUIT" ? "PTY_INTERACTIVE_PID=" : "42";
+    if (!latestInput?.content.includes(expected)) {
+      if (inputs.length >= 20) {
+        throw new Error(`Interactive Python fixture did not show ${expected}.`);
+      }
+      return toolCallOutput(prepared, options, "TaskInput", {
+        task_id: taskId,
+        chars: "",
+        wait_ms: 250,
+      });
+    }
+
+    if (prompt === "PTY_INTERACTIVE_QUIT") {
+      return textOutput(prepared, "PTY_INTERACTIVE_RUNNING");
+    }
+    if (!inputs.some((message) => message.content.includes("status=completed"))) {
+      return toolCallOutput(prepared, options, "TaskInput", {
+        task_id: taskId,
+        chars: "exit()\n",
+        wait_ms: 500,
+      });
+    }
+    return textOutput(prepared, "PTY_INTERACTIVE_DONE");
+  }
+
   private ptyResume(
     input: ModelRequestInput,
     prepared: PreparedModelRequest,

package/src/model/model-client.ts

@@ -36,6 +36,7 @@ export type ModelMessageProtocol = {
 
 export type ModelRequestOptions = {
   signal: AbortSignal;
+  onTextDelta?: (content: string) => void;
   identity?: {
     iteration: IterationIdentity;
     runtimeSession: RuntimeSessionContext;
@@ -127,6 +128,8 @@ export type ProviderResponseErrorCode =
   | "reasoning_only_assistant"
   | "invalid_provider_response"
   | "invalid_provider_stream"
+  | "provider_rate_limited"
+  | "provider_unavailable"
   | "provider_request_error";
 
 export type ProviderResponseDiagnostics = {

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

@@ -11,7 +11,11 @@ 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, ProviderResponseError } from "./model-client";
+import {
+  ModelRequestMediaAggregateError,
+  ProviderResponseError,
+  type ProviderResponseErrorCode,
+} from "./model-client";
 import type {
   MaterializedModelRequest,
   ModelClient,
@@ -30,7 +34,7 @@ import {
   toOpenAIChatMessages,
   toOpenAIChatTools,
 } from "./openai-chat-mapping";
-import { accumulateOpenAIChatCompletionChunks } from "./openai-chat-stream";
+import { OpenAIChatCompletionStreamAccumulator } from "./openai-chat-stream";
 import { MoonshotInputTokenEstimator } from "./moonshot-input-token-estimator";
 import { sha256, stableJsonStringify } from "./model-request-preflight";
 
@@ -86,7 +90,9 @@ export class OpenAIChatModelClient implements ModelClient {
       apiKey: options.apiKey,
       baseURL: options.baseURL,
       timeout: options.timeoutMs ?? OPENAI_CHAT_TIMEOUT_MS,
-      ...(supportsImages ? { maxRetries: 0 } : {}),
+      // Retries are orchestrated by the agent loop so they surface as
+      // cancellable, observable runtime events instead of hidden SDK waits.
+      maxRetries: 0,
       fetch: options.fetch,
     });
     if (options.tokenEstimator !== undefined) {
@@ -235,10 +241,7 @@ export class OpenAIChatModelClient implements ModelClient {
     }
 
     const response = this.stream
-      ? accumulateOpenAIChatCompletionChunks(
-          await this.collectStreamingChunks(prepared, options.signal),
-          { provider: this.provider, model: this.options.model },
-        )
+      ? await this.requestStreaming(prepared, options)
       : await this.requestNonStreaming(prepared, options.signal);
 
     return fromOpenAIChatCompletion(response, {
@@ -248,21 +251,30 @@ export class OpenAIChatModelClient implements ModelClient {
     });
   }
 
-  private async collectStreamingChunks(
+  private async requestStreaming(
     prepared: PreparedModelRequest,
-    signal: AbortSignal,
-  ): Promise<unknown[]> {
+    options: ModelRequestOptions,
+  ): Promise<Record<string, unknown>> {
+    const accumulator = new OpenAIChatCompletionStreamAccumulator({
+      provider: this.provider,
+      model: this.options.model,
+    });
     try {
       const stream = await this.client.chat.completions.create(
         prepared.payload as ChatCompletionCreateParamsStreaming,
-        { signal },
+        { signal: options.signal },
       );
-      const chunks: unknown[] = [];
       for await (const chunk of stream) {
-        chunks.push(chunk);
+        const content = accumulator.push(chunk);
+        if (content !== undefined && content !== "") {
+          options.onTextDelta?.(content);
+        }
       }
-      return chunks;
+      return accumulator.finish();
     } catch (error) {
+      if (error instanceof ProviderResponseError) {
+        throw error;
+      }
       throw sanitizedProviderError(error, this.provider, this.options.model);
     }
   }
@@ -531,9 +543,36 @@ function sanitizedProviderError(
     )
     .replace(/Bearer\s+[A-Za-z0-9._~+/-]+/giu, "Bearer [redacted]");
   return new ProviderResponseError(
-    "provider_request_error",
+    providerErrorCode(error),
     sanitized,
     { provider, model },
     { cause: error },
   );
 }
+
+function providerErrorCode(error: unknown): ProviderResponseErrorCode {
+  const status = providerErrorStatus(error);
+  if (status === 429) {
+    return "provider_rate_limited";
+  }
+  if (status === 500 || status === 502 || status === 503 || status === 504) {
+    return "provider_unavailable";
+  }
+  if (status === undefined && isProviderConnectionError(error)) {
+    return "provider_unavailable";
+  }
+  return "provider_request_error";
+}
+
+function providerErrorStatus(error: unknown): number | undefined {
+  if (typeof error !== "object" || error === null || !("status" in error)) {
+    return undefined;
+  }
+  const status = (error as { status?: unknown }).status;
+  return typeof status === "number" ? status : undefined;
+}
+
+function isProviderConnectionError(error: unknown): boolean {
+  // APIConnectionTimeoutError extends APIConnectionError in the SDK.
+  return error instanceof OpenAI.APIConnectionError;
+}