tinker-agent 1.5.1 → 1.6.0

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,6 +241,9 @@ 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);
     }
@@ -361,6 +367,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 +543,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,

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;
+}

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

@@ -14,62 +14,61 @@ type ToolCallAccumulator = {
  * chat.completion-shaped object so the result can be validated and mapped by
  * fromOpenAIChatCompletion exactly like a non-streaming response.
  */
-export function accumulateOpenAIChatCompletionChunks(
-  chunks: readonly unknown[],
-  options: ProviderContext,
-): Record<string, unknown> {
-  if (chunks.length === 0) {
-    throw providerStreamError(options, "chunks", "must not be empty");
-  }
+export class OpenAIChatCompletionStreamAccumulator {
+  private chunkCount = 0;
+  private role: "assistant" | undefined;
+  private content: string | undefined;
+  private reasoningContent: string | undefined;
+  private finishReason: string | undefined;
+  private resolvedModel: string | undefined;
+  private usage: Record<string, unknown> | undefined;
+  private readonly toolCalls: ToolCallAccumulator[] = [];
 
-  let role: "assistant" | undefined;
-  let content: string | undefined;
-  let reasoningContent: string | undefined;
-  let finishReason: string | undefined;
-  let resolvedModel: string | undefined;
-  let usage: Record<string, unknown> | undefined;
-  const toolCalls: ToolCallAccumulator[] = [];
+  constructor(private readonly options: ProviderContext) {}
 
-  chunks.forEach((chunk, chunkIndex) => {
+  push(chunk: unknown): string | undefined {
+    const chunkIndex = this.chunkCount;
+    this.chunkCount += 1;
     const path = `chunk[${chunkIndex}]`;
-    const record = requireRecord(chunk, path, options);
+    const record = requireRecord(chunk, path, this.options);
+    let chunkContent: string | undefined;
 
     if (record.model !== undefined && record.model !== null) {
       if (typeof record.model !== "string" || record.model.trim() === "") {
-        throw providerStreamError(options, `${path}.model`, "must be a string");
+        throw providerStreamError(this.options, `${path}.model`, "must be a string");
       }
-      if (resolvedModel !== undefined && resolvedModel !== record.model) {
+      if (this.resolvedModel !== undefined && this.resolvedModel !== record.model) {
         throw providerStreamError(
-          options,
+          this.options,
           `${path}.model`,
-          `conflicts with previously streamed model ${JSON.stringify(resolvedModel)}`,
+          `conflicts with previously streamed model ${JSON.stringify(this.resolvedModel)}`,
         );
       }
-      resolvedModel = record.model;
+      this.resolvedModel = record.model;
     }
 
     if (record.usage !== undefined && record.usage !== null) {
-      usage = requireRecord(record.usage, `${path}.usage`, options);
+      this.usage = requireRecord(record.usage, `${path}.usage`, this.options);
     }
 
     if (record.choices === undefined || record.choices === null) {
-      return;
+      return chunkContent;
     }
     if (!Array.isArray(record.choices)) {
-      throw providerStreamError(options, `${path}.choices`, "must be an array");
+      throw providerStreamError(this.options, `${path}.choices`, "must be an array");
     }
     // The usage-only final chunk from stream_options.include_usage has empty choices.
     for (const [choiceIndex, rawChoice] of record.choices.entries()) {
       const choicePath = `${path}.choices[${choiceIndex}]`;
-      const choice = requireRecord(rawChoice, choicePath, options);
+      const choice = requireRecord(rawChoice, choicePath, this.options);
       if (choice.index !== 0) {
-        throw providerStreamError(options, `${choicePath}.index`, "must be 0");
+        throw providerStreamError(this.options, `${choicePath}.index`, "must be 0");
       }
       if (typeof choice.finish_reason === "string") {
-        finishReason = choice.finish_reason;
+        this.finishReason = choice.finish_reason;
       } else if (choice.finish_reason !== undefined && choice.finish_reason !== null) {
         throw providerStreamError(
-          options,
+          this.options,
           `${choicePath}.finish_reason`,
           "must be a string or null",
         );
@@ -79,82 +78,106 @@ export function accumulateOpenAIChatCompletionChunks(
         continue;
       }
       const deltaPath = `${choicePath}.delta`;
-      const delta = asRecord(choice.delta, deltaPath, options);
+      const delta = asRecord(choice.delta, deltaPath, this.options);
       if (delta.role !== undefined && delta.role !== null) {
         if (delta.role !== "assistant") {
           throw providerStreamError(
-            options,
+            this.options,
             `${deltaPath}.role`,
             'must be "assistant"',
           );
         }
-        role = delta.role;
+        this.role = delta.role;
       }
-      content = appendOptionalText(
-        content,
+      const contentDelta = appendOptionalText(
+        undefined,
         delta.content,
         `${deltaPath}.content`,
-        options,
+        this.options,
       );
-      reasoningContent = appendOptionalText(
-        reasoningContent,
+      if (contentDelta !== undefined) {
+        this.content = (this.content ?? "") + contentDelta;
+        chunkContent = (chunkContent ?? "") + contentDelta;
+      }
+      this.reasoningContent = appendOptionalText(
+        this.reasoningContent,
         delta.reasoning_content,
         `${deltaPath}.reasoning_content`,
-        options,
+        this.options,
       );
       if (delta.tool_calls === undefined || delta.tool_calls === null) {
         continue;
       }
       if (!Array.isArray(delta.tool_calls)) {
         throw providerStreamError(
-          options,
+          this.options,
           `${deltaPath}.tool_calls`,
           "must be an array",
         );
       }
       for (const [fragmentIndex, rawFragment] of delta.tool_calls.entries()) {
         mergeToolCallFragment(
-          toolCalls,
+          this.toolCalls,
           rawFragment,
           `${deltaPath}.tool_calls[${fragmentIndex}]`,
-          options,
+          this.options,
         );
       }
     }
-  });
+    return chunkContent;
+  }
 
-  // Only fields the provider actually streamed are emitted; the strict
-  // non-streaming mapper rejects a missing role, id, type, or name.
-  const message: Record<string, unknown> = {
-    ...(role === undefined ? {} : { role }),
-    content: content ?? null,
-    ...(reasoningContent === undefined ? {} : { reasoning_content: reasoningContent }),
-    ...(toolCalls.length === 0
-      ? {}
-      : {
-          tool_calls: toolCalls.map((call) => ({
-            ...(call.id === undefined ? {} : { id: call.id }),
-            ...(call.type === undefined ? {} : { type: call.type }),
-            function: {
-              ...(call.name === undefined ? {} : { name: call.name }),
-              arguments: call.arguments,
-            },
-          })),
-        }),
-  };
+  finish(): Record<string, unknown> {
+    if (this.chunkCount === 0) {
+      throw providerStreamError(this.options, "chunks", "must not be empty");
+    }
 
-  return {
-    object: "chat.completion",
-    choices: [
-      {
-        index: 0,
-        message,
-        finish_reason: finishReason ?? null,
-      },
-    ],
-    ...(usage === undefined ? {} : { usage }),
-    ...(resolvedModel === undefined ? {} : { model: resolvedModel }),
-  };
+    // Only fields the provider actually streamed are emitted; the strict
+    // non-streaming mapper rejects a missing role, id, type, or name.
+    const message: Record<string, unknown> = {
+      ...(this.role === undefined ? {} : { role: this.role }),
+      content: this.content ?? null,
+      ...(this.reasoningContent === undefined
+        ? {}
+        : { reasoning_content: this.reasoningContent }),
+      ...(this.toolCalls.length === 0
+        ? {}
+        : {
+            tool_calls: this.toolCalls.map((call) => ({
+              ...(call.id === undefined ? {} : { id: call.id }),
+              ...(call.type === undefined ? {} : { type: call.type }),
+              function: {
+                ...(call.name === undefined ? {} : { name: call.name }),
+                arguments: call.arguments,
+              },
+            })),
+          }),
+    };
+
+    return {
+      object: "chat.completion",
+      choices: [
+        {
+          index: 0,
+          message,
+          finish_reason: this.finishReason ?? null,
+        },
+      ],
+      ...(this.usage === undefined ? {} : { usage: this.usage }),
+      ...(this.resolvedModel === undefined ? {} : { model: this.resolvedModel }),
+    };
+  }
+}
+
+export function accumulateOpenAIChatCompletionChunks(
+  chunks: readonly unknown[],
+  options: ProviderContext,
+): Record<string, unknown> {
+  const accumulator = new OpenAIChatCompletionStreamAccumulator(options);
+  for (const chunk of chunks) {
+    accumulator.push(chunk);
+  }
+  return accumulator.finish();
 }
 
 function mergeToolCallFragment(

package/src/observation/observation-builder.ts

@@ -1,6 +1,7 @@
 import type { ToolCall } from "../agent/types";
 import type {
   BashRawResult,
+  DeleteFileRawResult,
   EditFileRawResult,
   GenericToolRawResult,
   GlobRawResult,
@@ -42,6 +43,8 @@ export class ObservationBuilder {
         return { content: renderWriteObservation(input.raw) };
       case "edit":
         return { content: renderEditObservation(input.raw) };
+      case "delete":
+        return { content: renderDeleteObservation(input.raw) };
       case "bash":
         return { content: renderBashObservation(input.raw) };
       case "task_list":
@@ -308,6 +311,14 @@ function renderEditObservation(raw: EditFileRawResult): string {
   ].join("\n");
 }
 
+function renderDeleteObservation(raw: DeleteFileRawResult): string {
+  if (!raw.ok) {
+    return `Delete failed for ${raw.filePath || "(unknown path)"}: ${raw.error ?? "Unknown error."}`;
+  }
+
+  return `Delete succeeded for ${raw.filePath}.`;
+}
+
 function renderBashObservation(raw: BashRawResult): string {
   if (raw.taskId === "" && !raw.ok) {
     return `Bash failed: ${raw.error ?? "Unknown error."}`;

package/src/session/session-store.ts

@@ -4838,6 +4838,7 @@ export function decodeStoredToolRawResult(value: unknown): ToolRawResult {
       "read",
       "write",
       "edit",
+      "delete",
       "glob",
       "grep",
       "bash",

package/src/tools/bash-guard.ts

@@ -0,0 +1,131 @@
+import path from "node:path";
+
+export type BashRisk =
+  | { readonly dangerous: false }
+  | { readonly dangerous: true; readonly reason: string };
+
+export type BashRiskContext = {
+  readonly workspaceRoot?: string;
+};
+
+const SAFE: BashRisk = Object.freeze({ dangerous: false });
+
+export function classifyBashRisk(
+  command: string,
+  context: BashRiskContext = {},
+): BashRisk {
+  const normalized = command.trim();
+  if (normalized === "") {
+    return SAFE;
+  }
+
+  if (/:\s*\(\s*\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;\s*:/.test(normalized)) {
+    return dangerous("fork bomb");
+  }
+
+  for (const segment of shellSegments(normalized)) {
+    const words = shellWords(segment);
+    const commandIndex = commandWordIndex(words);
+    if (commandIndex === -1) {
+      continue;
+    }
+    const name = basename(words[commandIndex] ?? "");
+    const args = words.slice(commandIndex + 1);
+
+    if (["shutdown", "reboot", "halt", "poweroff"].includes(name)) {
+      return dangerous(`system power command ${name}`);
+    }
+    if (name === "wipefs" || name.startsWith("mkfs.")) {
+      return dangerous(`block-device command ${name}`);
+    }
+    if (name === "dd" && args.some((word) => /^of=\/dev\/[^/]/.test(word))) {
+      return dangerous("dd writes directly to a device");
+    }
+    if ((name === "chmod" || name === "chown") && hasRecursiveFlag(args)) {
+      const operands = args.filter((word) => !word.startsWith("-"));
+      if (operands.at(-1) === "/") {
+        return dangerous(`${name} recursively targets the filesystem root`);
+      }
+    }
+    if (name === "rm" && hasRecursiveFlag(args) && hasForceFlag(args)) {
+      const operands = args.filter((word) => !word.startsWith("-"));
+      if (
+        operands.some((target) => isDestructiveRmTarget(target, context.workspaceRoot))
+      ) {
+        return dangerous("recursive forced removal targets a protected root");
+      }
+    }
+  }
+
+  return SAFE;
+}
+
+function dangerous(reason: string): BashRisk {
+  return Object.freeze({ dangerous: true, reason });
+}
+
+function shellSegments(command: string): string[] {
+  return command.split(/(?:&&|\|\||[;|\n])/);
+}
+
+function shellWords(segment: string): string[] {
+  return segment.match(/"(?:\\.|[^"])*"|'[^']*'|[^\s]+/g)?.map(unquote) ?? [];
+}
+
+function unquote(word: string): string {
+  if (
+    (word.startsWith('"') && word.endsWith('"')) ||
+    (word.startsWith("'") && word.endsWith("'"))
+  ) {
+    return word.slice(1, -1);
+  }
+  return word;
+}
+
+function commandWordIndex(words: readonly string[]): number {
+  let index = 0;
+  while (index < words.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(words[index] ?? "")) {
+    index += 1;
+  }
+  if (basename(words[index] ?? "") === "sudo") {
+    index += 1;
+    while ((words[index] ?? "").startsWith("-")) {
+      index += 1;
+    }
+  }
+  return index < words.length ? index : -1;
+}
+
+function basename(word: string): string {
+  return word.slice(word.lastIndexOf("/") + 1);
+}
+
+function hasRecursiveFlag(args: readonly string[]): boolean {
+  return args.some((word) => /^-[^-]*[rR]/.test(word) || word === "--recursive");
+}
+
+function hasForceFlag(args: readonly string[]): boolean {
+  return args.some((word) => /^-[^-]*f/.test(word) || word === "--force");
+}
+
+function isDestructiveRmTarget(
+  target: string,
+  workspaceRoot: string | undefined,
+): boolean {
+  if (target === "/" || target === "/*" || target === "~" || target === "~/*") {
+    return true;
+  }
+  if (
+    target === "$HOME" ||
+    target === "${HOME}" ||
+    target === "$HOME/*" ||
+    target === "${HOME}/*"
+  ) {
+    return true;
+  }
+  if (workspaceRoot === undefined || !path.isAbsolute(target)) {
+    return false;
+  }
+  const normalizedTarget = path.resolve(target.replace(/\/\*$/, ""));
+  return normalizedTarget === path.resolve(workspaceRoot);
+}