ethagent 2.1.1 → 2.3.0

package/src/providers/openai-responses-format.ts

@@ -0,0 +1,156 @@
+import type { Message, MessageContentBlock } from './contracts.js'
+import { messageTextContent } from '../utils/messages.js'
+import type { OpenAIToolDefinition } from './openai-chat.js'
+
+export type ResponsesInputContent =
+  | { type: 'input_text'; text: string }
+  | { type: 'output_text'; text: string }
+
+export type ResponsesInputItem =
+  | { type: 'message'; role: 'user' | 'assistant'; content: ResponsesInputContent[] }
+  | { type: 'function_call'; id?: string; call_id: string; name: string; arguments: string }
+  | { type: 'function_call_output'; call_id: string; output: string }
+
+export type ResponsesTool = {
+  type: 'function'
+  name: string
+  description: string
+  parameters: Record<string, unknown>
+}
+
+export type ResponsesRequestBody = {
+  model: string
+  input: ResponsesInputItem[]
+  instructions?: string
+  tools?: ResponsesTool[]
+  tool_choice?: 'auto' | 'none' | 'required'
+  parallel_tool_calls?: boolean
+  stream: true
+  store: false
+  max_output_tokens?: number
+}
+
+export function buildResponsesBody(args: {
+  model: string
+  messages: Message[]
+  tools: OpenAIToolDefinition[]
+  maxOutputTokens?: number
+}): ResponsesRequestBody {
+  const { instructions, items } = splitMessages(args.messages)
+  const body: ResponsesRequestBody = {
+    model: args.model,
+    input: items,
+    stream: true,
+    store: false,
+  }
+  if (instructions) body.instructions = instructions
+  if (args.tools.length > 0) {
+    body.tools = args.tools.map(tool => ({
+      type: 'function' as const,
+      name: tool.function.name,
+      description: tool.function.description,
+      parameters: tool.function.parameters as Record<string, unknown>,
+    }))
+    body.parallel_tool_calls = true
+    body.tool_choice = 'auto'
+  }
+  if (args.maxOutputTokens !== undefined) {
+    body.max_output_tokens = args.maxOutputTokens
+  }
+  return body
+}
+
+function splitMessages(messages: Message[]): {
+  instructions?: string
+  items: ResponsesInputItem[]
+} {
+  const instructions: string[] = []
+  const items: ResponsesInputItem[] = []
+
+  for (const message of messages) {
+    if (message.role === 'system') {
+      const text = typeof message.content === 'string'
+        ? message.content
+        : messageTextContent(message)
+      if (text) instructions.push(text)
+      continue
+    }
+
+    if (message.role === 'user') {
+      const blocks = normalizeBlocks(message.content)
+      const toolResults = blocks.filter(isToolResultBlock)
+      if (toolResults.length > 0) {
+        for (const block of toolResults) {
+          items.push({
+            type: 'function_call_output',
+            call_id: block.toolUseId,
+            output: block.content,
+          })
+        }
+        const remainingText = blocks
+          .filter(isTextBlock)
+          .map(block => block.text)
+          .join('')
+        if (remainingText) {
+          items.push({
+            type: 'message',
+            role: 'user',
+            content: [{ type: 'input_text', text: remainingText }],
+          })
+        }
+        continue
+      }
+      const text = blocks.filter(isTextBlock).map(block => block.text).join('')
+      if (text) {
+        items.push({
+          type: 'message',
+          role: 'user',
+          content: [{ type: 'input_text', text }],
+        })
+      }
+      continue
+    }
+
+    const blocks = normalizeBlocks(message.content)
+    const text = blocks.filter(isTextBlock).map(block => block.text).join('')
+    if (text) {
+      items.push({
+        type: 'message',
+        role: 'assistant',
+        content: [{ type: 'output_text', text }],
+      })
+    }
+    for (const block of blocks.filter(isToolUseBlock)) {
+      items.push({
+        type: 'function_call',
+        call_id: block.id,
+        name: block.name,
+        arguments: JSON.stringify(block.input),
+      })
+    }
+  }
+
+  return {
+    instructions: instructions.length > 0 ? instructions.join('\n\n') : undefined,
+    items,
+  }
+}
+
+function normalizeBlocks(content: Message['content']): MessageContentBlock[] {
+  if (typeof content === 'string') {
+    return content ? [{ type: 'text', text: content }] : []
+  }
+  return content
+}
+
+function isTextBlock(block: MessageContentBlock): block is Extract<MessageContentBlock, { type: 'text' }> {
+  return block.type === 'text'
+}
+
+function isToolUseBlock(block: MessageContentBlock): block is Extract<MessageContentBlock, { type: 'tool_use' }> {
+  return block.type === 'tool_use'
+}
+
+function isToolResultBlock(block: MessageContentBlock): block is Extract<MessageContentBlock, { type: 'tool_result' }> {
+  return block.type === 'tool_result'
+}

package/src/providers/openai-responses.ts

@@ -0,0 +1,276 @@
+import type { ProviderId } from '../storage/config.js'
+import type { Message, Provider, ProviderCompleteOptions, StreamEvent } from './contracts.js'
+import { ProviderError } from './contracts.js'
+import { providerErrorFromResponse } from './errors.js'
+import { fetchWithRetryStreamEvents } from './retry.js'
+import { iterSseEvents } from './sse.js'
+import { buildResponsesBody } from './openai-responses-format.js'
+import type { OpenAIToolDefinition } from './openai-chat.js'
+
+const READ_TIMEOUT_MS = 45_000
+
+type DoneStopReason = 'end_turn' | 'tool_use' | 'max_tokens' | 'stop_sequence' | 'unknown'
+
+export type OpenAIResponsesProviderOptions = {
+  model: string
+  baseUrl: string
+  accessToken: string
+  accountId?: string
+  originator?: string
+  tools?: OpenAIToolDefinition[]
+  maxRetries?: number
+  refresh?: () => Promise<string>
+}
+
+type StreamingToolCall = {
+  callId: string
+  name: string
+  inputJson: string
+  started: boolean
+}
+
+export class OpenAIResponsesProvider implements Provider {
+  readonly id: ProviderId = 'openai'
+  readonly model: string
+  readonly supportsTools: boolean
+  private accessToken: string
+  private readonly baseUrl: string
+  private readonly accountId?: string
+  private readonly originator: string
+  private readonly tools: OpenAIToolDefinition[]
+  private readonly maxRetries?: number
+  private readonly refresh?: () => Promise<string>
+
+  constructor(opts: OpenAIResponsesProviderOptions) {
+    this.model = opts.model
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, '')
+    this.accessToken = opts.accessToken
+    this.accountId = opts.accountId
+    this.originator = opts.originator ?? 'codex_cli_rs'
+    this.tools = opts.tools ?? []
+    this.maxRetries = opts.maxRetries
+    this.refresh = opts.refresh
+    this.supportsTools = this.tools.length > 0
+  }
+
+  async *complete(
+    messages: Message[],
+    signal: AbortSignal,
+    options: ProviderCompleteOptions = {},
+  ): AsyncIterable<StreamEvent> {
+    if (!this.accessToken) {
+      const error = new ProviderError('missing OAuth access token for openai (sign in again via the model picker)')
+      yield { type: 'error', message: error.message }
+      return
+    }
+
+    let attempt = 0
+    while (true) {
+      attempt += 1
+      const body = JSON.stringify(buildResponsesBody({
+        model: this.model,
+        messages,
+        tools: this.tools,
+        maxOutputTokens: options.maxTokens,
+      }))
+
+      let response: Response
+      try {
+        response = yield* fetchWithRetryStreamEvents(`${this.baseUrl}/responses`, {
+          method: 'POST',
+          headers: this.requestHeaders(),
+          body,
+        }, { signal, maxRetries: this.maxRetries, rateLimitResetProvider: 'openai-compatible' })
+      } catch (err: unknown) {
+        if (signal.aborted) return
+        yield { type: 'error', message: networkErrorMessage(this.baseUrl, err) }
+        return
+      }
+
+      if (response.status === 401 && this.refresh && attempt === 1) {
+        try {
+          this.accessToken = await this.refresh()
+          continue
+        } catch (refreshErr) {
+          const message = refreshErr instanceof Error ? refreshErr.message : String(refreshErr)
+          yield { type: 'error', message: `OpenAI sign-in expired and refresh failed: ${message}` }
+          return
+        }
+      }
+
+      if (!response.ok) {
+        const error = await providerErrorFromResponse('openai', response)
+        yield { type: 'error', message: error.message }
+        return
+      }
+      if (!response.body) {
+        yield { type: 'error', message: 'empty response body' }
+        return
+      }
+
+      yield* this.parseStream(response.body, signal)
+      return
+    }
+  }
+
+  private requestHeaders(): Record<string, string> {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      Accept: 'text/event-stream',
+      Authorization: `Bearer ${this.accessToken}`,
+      originator: this.originator,
+    }
+    if (this.accountId) headers['chatgpt-account-id'] = this.accountId
+    return headers
+  }
+
+  private async *parseStream(body: ReadableStream<Uint8Array>, signal: AbortSignal): AsyncIterable<StreamEvent> {
+    const toolCalls = new Map<string, StreamingToolCall>()
+    let inputTokens: number | undefined
+    let outputTokens: number | undefined
+    let stopReason: DoneStopReason = 'unknown'
+
+    try {
+      for await (const frame of iterSseEvents(body, signal, READ_TIMEOUT_MS)) {
+        const eventName = frame.event ?? ''
+        if (!frame.data || frame.data === '[DONE]') continue
+        let parsed: Record<string, unknown>
+        try {
+          parsed = JSON.parse(frame.data) as Record<string, unknown>
+        } catch {
+          continue
+        }
+
+        switch (eventName) {
+          case 'response.output_text.delta': {
+            const delta = typeof parsed.delta === 'string' ? parsed.delta : ''
+            if (delta) yield { type: 'text', delta }
+            break
+          }
+          case 'response.reasoning_summary_text.delta':
+          case 'response.reasoning.delta':
+          case 'response.reasoning_text.delta': {
+            const delta = typeof parsed.delta === 'string' ? parsed.delta : ''
+            if (delta) yield { type: 'thinking', delta }
+            break
+          }
+          case 'response.output_item.added': {
+            const item = (parsed.item ?? {}) as Record<string, unknown>
+            if (item.type === 'function_call') {
+              const callId = pickString(item.call_id) ?? pickString(item.id) ?? `tool-${toolCalls.size}`
+              const name = pickString(item.name) ?? ''
+              toolCalls.set(callId, { callId, name, inputJson: '', started: false })
+              if (name) {
+                toolCalls.get(callId)!.started = true
+                yield { type: 'tool_use_start', id: callId, name }
+              }
+            }
+            break
+          }
+          case 'response.function_call_arguments.delta': {
+            const callId = resolveCallId(parsed, toolCalls)
+            const delta = typeof parsed.delta === 'string' ? parsed.delta : ''
+            if (!callId || !delta) break
+            const existing = toolCalls.get(callId)
+            if (!existing) break
+            existing.inputJson += delta
+            yield { type: 'tool_use_delta', id: callId, delta }
+            break
+          }
+          case 'response.output_item.done': {
+            const item = (parsed.item ?? {}) as Record<string, unknown>
+            if (item.type === 'function_call') {
+              const callId = pickString(item.call_id) ?? pickString(item.id)
+              if (!callId) break
+              const existing = toolCalls.get(callId)
+              const name = pickString(item.name) ?? existing?.name ?? ''
+              const argsJson = pickString(item.arguments) ?? existing?.inputJson ?? ''
+              stopReason = 'tool_use'
+              yield {
+                type: 'tool_use_stop',
+                id: callId,
+                name,
+                input: parseToolArguments(argsJson),
+              }
+              toolCalls.delete(callId)
+            }
+            break
+          }
+          case 'response.completed': {
+            const usage = (parsed.response as { usage?: Record<string, unknown> } | undefined)?.usage
+            const tokens = readUsage(usage)
+            if (tokens.input !== undefined) inputTokens = tokens.input
+            if (tokens.output !== undefined) outputTokens = tokens.output
+            if (stopReason !== 'tool_use') stopReason = 'end_turn'
+            break
+          }
+          case 'response.failed':
+          case 'response.error':
+          case 'error': {
+            const error = parsed.error as { message?: string } | undefined
+            const message = error?.message ?? 'Responses API error'
+            yield { type: 'error', message }
+            return
+          }
+          case 'response.incomplete': {
+            const reason = pickString((parsed.response as { incomplete_details?: { reason?: string } } | undefined)?.incomplete_details?.reason)
+            if (reason === 'max_output_tokens') stopReason = 'max_tokens'
+            break
+          }
+          default:
+            break
+        }
+      }
+    } catch (err: unknown) {
+      if (signal.aborted) return
+      yield { type: 'error', message: networkErrorMessage(this.baseUrl, err, 'stream error') }
+      return
+    }
+
+    if (signal.aborted) return
+    yield { type: 'done', inputTokens, outputTokens, stopReason }
+  }
+}
+
+function pickString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.length > 0 ? value : undefined
+}
+
+function resolveCallId(parsed: Record<string, unknown>, calls: Map<string, StreamingToolCall>): string | undefined {
+  return (
+    pickString(parsed.call_id)
+    ?? pickString(parsed.item_id)
+    ?? pickString((parsed.item as Record<string, unknown> | undefined)?.call_id)
+    ?? pickString((parsed.item as Record<string, unknown> | undefined)?.id)
+    ?? (calls.size === 1 ? Array.from(calls.keys())[0] : undefined)
+  )
+}
+
+function readUsage(usage: Record<string, unknown> | undefined): { input?: number; output?: number } {
+  if (!usage) return {}
+  const input = typeof usage.input_tokens === 'number'
+    ? usage.input_tokens
+    : typeof usage.prompt_tokens === 'number' ? usage.prompt_tokens : undefined
+  const output = typeof usage.output_tokens === 'number'
+    ? usage.output_tokens
+    : typeof usage.completion_tokens === 'number' ? usage.completion_tokens : undefined
+  return { input, output }
+}
+
+function parseToolArguments(input: string): Record<string, unknown> {
+  const trimmed = input.trim()
+  if (!trimmed) return {}
+  try {
+    const parsed = JSON.parse(trimmed) as unknown
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : {}
+  } catch {
+    return {}
+  }
+}
+
+function networkErrorMessage(baseUrl: string, err: unknown, fallback = 'network error'): string {
+  const message = (err as Error).message || fallback
+  return `openai request failed at ${baseUrl}: ${message}`
+}

package/src/providers/registry.ts

@@ -6,10 +6,19 @@ import type { SessionMode } from '../runtime/sessionMode.js'
 import { AnthropicProvider } from './anthropic.js'
 import { GeminiProvider } from './gemini.js'
 import { OpenAIChatProvider } from './openai-chat.js'
+import { OpenAIResponsesProvider } from './openai-responses.js'
 import { anthropicTools, geminiTools, openAITools } from '../tools/registry.js'
-import { openAIBaseUrlFor } from '../models/catalog.js'
+import { openAIBaseUrlFor, OPENAI_OAUTH_DEFAULT_MODEL, isOpenAIOAuthAllowedModel } from '../models/catalog.js'
+import {
+  getOpenAIOAuthCredentials,
+  setOpenAIOAuthCredentials,
+  type OpenAIOAuthCredentials,
+} from '../auth/openaiOAuth/credentials.js'
+import { refreshOpenAIAccessToken, shouldRefresh } from '../auth/openaiOAuth/refresh.js'
 import type { Tool } from '../tools/contracts.js'
 
+export const OPENAI_CHATGPT_BACKEND_URL = 'https://chatgpt.com/backend-api/codex'
+
 export function isLocalProvider(provider: string): boolean {
   return provider === 'llamacpp'
 }
@@ -27,16 +36,84 @@ export function createProvider(config: EthagentConfig, options: { mode?: Session
         tools: openAITools(mode, toolContext),
       })
     case 'openai':
-      return new OpenAIChatProvider({
-        id: 'openai',
-        model: config.model,
-        baseUrl: openAIBaseUrlFor(config),
-        loadApiKey: () => getKey('openai'),
-        tools: openAITools(mode, toolContext),
-      })
+      return createOpenAIProvider(config, openAITools(mode, toolContext))
     case 'anthropic':
       return new AnthropicProvider({ model: config.model, tools: anthropicTools(mode, toolContext) })
     case 'gemini':
       return new GeminiProvider({ model: config.model, tools: geminiTools(mode, toolContext) })
   }
 }
+
+function createOpenAIProvider(config: EthagentConfig, tools: ReturnType<typeof openAITools>): Provider {
+  return new OpenAIRoutingProvider(config, tools)
+}
+
+class OpenAIRoutingProvider implements Provider {
+  readonly id = 'openai' as const
+  readonly model: string
+  readonly supportsTools: boolean
+  private delegate: Provider | null = null
+  private readonly config: EthagentConfig
+  private readonly tools: ReturnType<typeof openAITools>
+
+  constructor(config: EthagentConfig, tools: ReturnType<typeof openAITools>) {
+    this.config = config
+    this.tools = tools
+    this.model = config.model
+    this.supportsTools = tools.length > 0
+  }
+
+  async *complete(...args: Parameters<Provider['complete']>): ReturnType<Provider['complete']> {
+    if (!this.delegate) this.delegate = await this.resolveDelegate()
+    yield* this.delegate.complete(...args)
+  }
+
+  private async resolveDelegate(): Promise<Provider> {
+    const oauth = await loadFreshOAuthCredentials()
+    if (oauth) {
+      const oauthModel = isOpenAIOAuthAllowedModel(this.model) ? this.model : OPENAI_OAUTH_DEFAULT_MODEL
+      return new OpenAIResponsesProvider({
+        model: oauthModel,
+        baseUrl: OPENAI_CHATGPT_BACKEND_URL,
+        accessToken: oauth.accessToken,
+        accountId: oauth.accountId,
+        tools: this.tools,
+        refresh: async () => {
+          const next = await loadFreshOAuthCredentials({ force: true })
+          if (!next) throw new Error('No OAuth credentials available')
+          return next.accessToken
+        },
+      })
+    }
+    return new OpenAIChatProvider({
+      id: 'openai',
+      model: this.model,
+      baseUrl: openAIBaseUrlFor(this.config),
+      loadApiKey: () => getKey('openai'),
+      tools: this.tools,
+    })
+  }
+}
+
+async function loadFreshOAuthCredentials(options: { force?: boolean } = {}): Promise<OpenAIOAuthCredentials | null> {
+  const current = await getOpenAIOAuthCredentials()
+  if (!current) return null
+  if (!options.force && !shouldRefresh(current)) return current
+
+  try {
+    const refreshed = await refreshOpenAIAccessToken(current.refreshToken)
+    const now = Date.now()
+    const next: OpenAIOAuthCredentials = {
+      accessToken: refreshed.accessToken,
+      refreshToken: refreshed.refreshToken,
+      idToken: refreshed.idToken ?? current.idToken,
+      accountId: refreshed.accountId ?? current.accountId,
+      expiresAt: now + refreshed.expiresIn * 1000,
+      lastRefreshAt: now,
+    }
+    await setOpenAIOAuthCredentials(next)
+    return next
+  } catch {
+    return current
+  }
+}

package/src/runtime/sessionMode.ts

@@ -24,7 +24,7 @@ export function nextSessionMode(mode: SessionMode): SessionMode {
 }
 
 export function sessionModeLabel(mode: SessionMode): string {
-  return mode === 'plan' ? 'Plan mode' : mode === 'accept-edits' ? 'Accept edits on' : ''
+  return mode === 'plan' ? 'plan mode' : mode === 'accept-edits' ? 'accept edits on' : ''
 }
 
 export function modePolicy(mode: PolicyMode): ModePolicy {

package/src/runtime/systemPrompt.ts

@@ -76,7 +76,7 @@ function buildToolEnabledPrompt(ctx: SystemPromptContext): string {
         '**DIRECT REQUESTS**: If the user asks to change directory, list files, or read a file, respond with exactly one matching native tool call. Do not substitute prose or claim the action was taken.',
         '**EVIDENCE REQUIRED**: Do not claim a path is missing, a directory does not exist, or a file is absent unless you have a `list_directory` or `read_file` result from this conversation that confirms it.',
         '**TOOL TYPING**: Tool names are NOT shell commands. NEVER pass `list_directory`, `read_file`, `edit_file`, or `change_directory` directly to `run_bash`. Call the matching native tool.',
-        'Prefer targeted `read_file` and `edit_file` calls over general `run_bash` operations when both solve the task.',
+        '**PREFER NATIVE TOOLS**: If a request can be answered by `list_directory`, `read_file`, `edit_file`, `write_file`, `delete_file`, or `change_directory`, use that tool. Treat reaching for `run_bash` as a flag that you may be doing it wrong — only proceed if the action genuinely needs a real shell.',
         ...(ctx.mode === 'plan'
           ? [
               'Only read/list tools and permission-gated private continuity reads are available in plan mode.',
@@ -93,11 +93,14 @@ function buildToolEnabledPrompt(ctx: SystemPromptContext): string {
                     'When exact private continuity text is needed for surgical removal or targeted replacement, call `read_private_continuity_file` with `file: "MEMORY.md"` or `file: "SOUL.md"` first.',
                     'When the user wants memory, persona, preferences, or private identity continuity changed, call `propose_private_continuity_edit`; do NOT create, overwrite, or patch SOUL.md/MEMORY.md with `write_file` or `edit_file`.',
                     'For private continuity, edit the existing scaffold and build on top of it: prefer `appendToSection`+`appendText` for new notes or use `oldText`+`newText` for targeted replacement. Never omit the edit anchor, never create a new file, and never replace the whole file.',
+                    'Never call `propose_private_continuity_edit` with `{}` or only `file`. Send exactly one edit mode: either `appendToSection` + non-empty `appendText`, or `oldText` + `newText`. Omit the fields you are not using — do not pass empty strings for `oldText`/`newText` alongside an append, or empty `appendToSection`/`appendText` alongside a targeted edit.',
                     'If the user asks to remember preferences or facts, call exactly one private continuity append such as `{"file":"MEMORY.md","appendToSection":"Durable User Preferences","appendText":"- User preference or durable memory."}`.',
                     'If the user asks to change persona or standing behavior, call exactly one private continuity append such as `{"file":"SOUL.md","appendToSection":"Persona","appendText":"- Persona or standing behavior."}`.',
                   ]
                 : ['No agent identity is linked in this session. Do not attempt private identity continuity edits; ask the user to create or load an agent first.']),
               'Use `run_bash` **only** when true shell execution is necessary.',
+              '**NO BASH EXPLORATION**: Never use `run_bash` to inspect the workspace. That means no `node -e`, no heredocs (`<<EOF`, `<<\'NODE\'`), no `find`, `grep`, `cat`, `head`, `tail`, `ls`, `dir`, `type`, `tree`, or shell loops to read or walk files. Use `list_directory` for directories and `read_file` for files. `run_bash` is reserved for actions that require a real shell: running tests, builds, git operations, launching processes. If you catch yourself writing a one-liner to read or list something, stop and call the native tool instead.',
+              '**DISCOVERY BUDGET**: For exploratory or "tell me about" questions, target ≤5 tool calls total. If 5 calls of the same kind have not given you enough to answer, the question does not need more depth — answer from what you have. Do not recursively scan, walk every subdirectory, or write deeper scripts to be more thorough than the user asked for. Stop and reply.',
               'Never use `run_bash` to produce conversational text. Do not call `echo`, `printf`, or similar to emit your reply — write it as your assistant text. Bash is for actions that need a real shell, not for generating words.',
               '**CWD CONTINUITY**: The working directory below is authoritative. After `change_directory` succeeds, use the new path as the base for subsequent actions.',
               'Do not lag behind the CWD. Edit/read relative to the *current* working directory.',
@@ -120,7 +123,6 @@ function buildToolEnabledPrompt(ctx: SystemPromptContext): string {
               ? [
                   'For private SOUL.md or MEMORY.md inspection, do not search project folders. Call `read_private_continuity_file` with `file: "SOUL.md"` or `file: "MEMORY.md"`.',
                   'For private SOUL.md or MEMORY.md changes, call `propose_private_continuity_edit` with `file: "SOUL.md"` or `file: "MEMORY.md"` and an in-place append/replacement payload.',
-                  'Never call `propose_private_continuity_edit` with `{}` or only `file`. For memory/preferences include `appendToSection: "Durable User Preferences"` and a non-empty `appendText`; for persona include `appendToSection: "Persona"` and a non-empty `appendText`.',
                 ]
               : []),
             'For targeted private continuity edits with `oldText`, copy the text verbatim from the most recent `read_private_continuity_file` output. For workspace targeted edits, copy from the most recent `read_file` output.',

package/src/runtime/toolExecution.ts

@@ -17,10 +17,7 @@ import type {
 import { setCwd as setRuntimeCwd } from './cwd.js'
 import type { EthagentConfig } from '../storage/config.js'
 import type { SessionMessage } from '../storage/sessions.js'
-import {
-  summarizeToolInput,
-  toolResultContentForRow,
-} from '../chat/chatScreenUtils.js'
+import { toolResultContentForRow, toolResultDiffForRow } from '../chat/chatScreenUtils.js'
 import type { MessageRow } from '../chat/MessageList.js'
 import { modePolicy, toPermissionMode, type SessionMode } from './sessionMode.js'
 
@@ -239,7 +236,7 @@ export async function runPendingToolUses(args: {
         id: rowId,
         name: toolUse.name,
         summary: toolUse.name,
-        input: summarizeToolInput(toolUse.input),
+        input: toolUse.input,
       },
     ])
     await args.persistTurnMessage({
@@ -282,9 +279,15 @@ async function recordToolResult(
 ): Promise<void> {
   const isError = !result.ok
   const resultContent = toolResultContentForRow(toolUse.name, result.content, isError)
+  const diff = toolResultDiffForRow(result.content, isError)
   args.updateRows(prev => prev.map(row =>
     row.role === 'tool_call' && row.id === rowId
-      ? { ...row, result: { content: resultContent, summary: result.summary, isError } }
+      ? {
+          ...row,
+          result: diff
+            ? { content: resultContent, summary: result.summary, isError, diff }
+            : { content: resultContent, summary: result.summary, isError },
+        }
       : row,
   ))
   await args.persistTurnMessage({