tinker-agent 1.5.0 → 1.6.0

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

@@ -226,12 +226,24 @@ export class FakeModelClient implements ModelClient {
     if (this.mode === "pty-echo-history") {
       return this.ptyEchoHistory(input, prepared);
     }
+    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);
+    }
     if (this.mode === "pty-cancel-then-echo") {
       return this.ptyCancelThenEcho(input, prepared, options);
     }
     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);
     }
@@ -307,6 +319,130 @@ export class FakeModelClient implements ModelClient {
     throw new Error(`Unexpected pty-echo-history prompt: ${JSON.stringify(prompt)}.`);
   }
 
+  private async ptyStaticHistory(
+    input: ModelRequestInput,
+    prepared: PreparedModelRequest,
+    options: ModelRequestOptions,
+  ): Promise<ModelRequestOutput> {
+    const prompt = lastUserMessage(input.messages);
+    const historyMatch = /^PTY_STATIC_HISTORY_([1-4])$/u.exec(prompt);
+    if (historyMatch !== null) {
+      const turn = historyMatch[1];
+      return textOutput(
+        prepared,
+        [
+          turn === "1"
+            ? "PTY_STATIC_HISTORY_EARLY_SENTINEL"
+            : `PTY_STATIC_HISTORY_${turn}`,
+          ...Array.from(
+            { length: 8 },
+            (_, index) => `- settled PTY history ${turn}.${index + 1}`,
+          ),
+          `PTY_STATIC_HISTORY_${turn}_DONE`,
+        ].join("\n"),
+      );
+    }
+    if (prompt !== "PTY_STATIC_LIVE") {
+      throw new Error(
+        `Unexpected pty-static-history prompt: ${JSON.stringify(prompt)}.`,
+      );
+    }
+
+    requireTools(input, ["Bash"]);
+    const bash = toolMessagesAfterLastUser(input.messages).find(
+      (message) => message.name === "Bash",
+    );
+    await Bun.sleep(200);
+    options.signal.throwIfAborted();
+    if (bash === undefined) {
+      return toolCallOutput(prepared, options, "Bash", {
+        command:
+          'index=1; while [ "$index" -le 20 ]; do printf \'PTY_STATIC_LIVE_LINE_%s\\n\' "$index"; index=$((index + 1)); done; sleep 0.2',
+        description: "Exercise static history live tail",
+      });
+    }
+    if (!bash.content.includes("PTY_STATIC_LIVE_LINE_20")) {
+      throw new Error("PTY static-history Bash output was incomplete.");
+    }
+    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,
+    options: ModelRequestOptions,
+  ): ModelRequestOutput {
+    const prompt = lastUserMessage(input.messages);
+    if (/^PTY_RESUME_LAYOUT_PAD_\d+$/u.test(prompt)) {
+      return textOutput(prepared, `${prompt}_DONE`);
+    }
+    const match = /^PTY_RESUME_LAYOUT_([1-3])$/u.exec(prompt);
+    if (match === null) {
+      throw new Error(
+        `Unexpected pty-resume-layout prompt: ${JSON.stringify(prompt)}.`,
+      );
+    }
+
+    requireTools(input, ["Read"]);
+    const turn = Number(match[1]);
+    const targetToolCount = [8, 17, 4][turn - 1];
+    const finalLineCount = [31, 47, 8][turn - 1];
+    if (targetToolCount === undefined || finalLineCount === undefined) {
+      throw new Error(`Invalid pty-resume-layout turn: ${turn}.`);
+    }
+
+    const completedReads = toolMessagesAfterLastUser(input.messages).filter(
+      (message) => message.name === "Read",
+    ).length;
+    if (completedReads < targetToolCount) {
+      return toolCallOutput(prepared, options, "Read", {
+        file_path: "resume-layout.txt",
+      });
+    }
+
+    return textOutput(
+      prepared,
+      Array.from(
+        { length: finalLineCount },
+        (_, index) =>
+          `PTY_RESUME_LAYOUT_${turn}_FINAL_${String(index + 1).padStart(2, "0")}`,
+      ).join("\n"),
+    );
+  }
+
   private ptyCancelThenEcho(
     input: ModelRequestInput,
     prepared: PreparedModelRequest,
@@ -407,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",