fix(opencode): bound oversized tool errors

Author: MagMueller

packages/opencode/src/session/llm.ts

@@ -29,9 +29,37 @@ import * as OtelTracer from "@effect/opentelemetry/Tracer"
 import { LLMAISDK } from "./llm/ai-sdk"
 import { LLMNativeRuntime } from "./llm/native-runtime"
 import { LLMRequestPrep } from "./llm/request"
+import { Truncate } from "@/tool/truncate"
 
 export const OUTPUT_TOKEN_MAX = ProviderTransform.OUTPUT_TOKEN_MAX
 
+const TOOL_CALL_ERROR_MAX_CHARS = Truncate.MAX_ERROR_CHARS
+const TOOL_CALL_ERROR_CONTEXT_CHARS = Math.floor(TOOL_CALL_ERROR_MAX_CHARS / 2)
+const TOOL_CALL_NAME_MAX_CHARS = 256
+
+export function invalidToolCallInput(tool: string, message: string) {
+  const exact = JSON.stringify({ tool, error: message })
+  if (exact.length <= TOOL_CALL_ERROR_MAX_CHARS) return exact
+
+  const name = tool.length <= TOOL_CALL_NAME_MAX_CHARS ? tool : `${tool.slice(0, TOOL_CALL_NAME_MAX_CHARS - 3)}...`
+  const maximum = Math.min(TOOL_CALL_ERROR_CONTEXT_CHARS, Math.floor(message.length / 2))
+  let lower = 0
+  let upper = maximum
+  let result = JSON.stringify({ tool: name, error: `... ${message.length} characters omitted ...` })
+  while (lower <= upper) {
+    const context = Math.floor((lower + upper) / 2)
+    const error = `${message.slice(0, context)}\n... ${message.length - context * 2} characters omitted ...\n${context === 0 ? "" : message.slice(-context)}`
+    const candidate = JSON.stringify({ tool: name, error })
+    if (candidate.length > TOOL_CALL_ERROR_MAX_CHARS) {
+      upper = context - 1
+      continue
+    }
+    result = candidate
+    lower = context + 1
+  }
+  return result
+}
+
 export type StreamInput = {
   user: SessionV1.User
   sessionID: string
@@ -70,6 +98,7 @@ const live: Layer.Layer<
   | EventV2Bridge.Service
   | LLMClientService
   | RuntimeFlags.Service
+  | Truncate.Service
 > = Layer.effect(
   Service,
   Effect.gen(function* () {
@@ -81,6 +110,7 @@ const live: Layer.Layer<
     const events = yield* EventV2Bridge.Service
     const llmClient = yield* LLMClient.Service
     const flags = yield* RuntimeFlags.Service
+    const truncate = yield* Truncate.Service
 
     const run = Effect.fn("LLM.run")(function* (input: StreamRequest) {
       yield* Effect.logInfo("stream", {
@@ -142,7 +172,8 @@ const live: Layer.Layer<
               title: typeof result === "object" ? result?.title : undefined,
             }
           } catch (e: any) {
-            return { result: "", error: e.message ?? String(e) }
+            const error = await bridge.promise(truncate.error(e.message ?? String(e)))
+            return { result: "", error: error.content }
           }
         }
 
@@ -301,12 +332,10 @@ const live: Layer.Layer<
                 toolName: lower,
               }
             }
+            const error = await bridge.promise(truncate.error(failed.error.message))
             return {
               ...failed.toolCall,
-              input: JSON.stringify({
-                tool: failed.toolCall.toolName,
-                error: failed.error.message,
-              }),
+              input: invalidToolCallInput(failed.toolCall.toolName, error.content),
               toolName: "invalid",
             }
           },
@@ -398,6 +427,7 @@ export const node = LayerNode.make({
     EventV2Bridge.node,
     llmClient,
     RuntimeFlags.node,
+    Truncate.node,
   ],
 })
 

packages/opencode/src/session/session.ts

@@ -44,6 +44,7 @@ import { RuntimeFlags } from "@/effect/runtime-flags"
 import { ProviderV2 } from "@opencode-ai/core/provider"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { SessionMessage } from "@opencode-ai/schema/session-message"
+import { Truncate } from "@/tool/truncate"
 
 const parentTitlePrefix = "New session - "
 const childTitlePrefix = "Child session - "
@@ -488,7 +489,7 @@ export type Patch = Omit<Partial<Info>, "time" | "share" | "summary" | "revert"
 const layer: Layer.Layer<
   Service,
   never,
-  BackgroundJob.Service | RuntimeFlags.Service | Database.Service | EventV2Bridge.Service
+  BackgroundJob.Service | RuntimeFlags.Service | Database.Service | EventV2Bridge.Service | Truncate.Service
 > = Layer.effect(
   Service,
   Effect.gen(function* () {
@@ -497,6 +498,7 @@ const layer: Layer.Layer<
     const background = yield* BackgroundJob.Service
     const events = yield* EventV2Bridge.Service
     const flags = yield* RuntimeFlags.Service
+    const truncate = yield* Truncate.Service
 
     const createNext = Effect.fn("Session.createNext")(function* (input: {
       id?: SessionID
@@ -636,6 +638,10 @@ const layer: Layer.Layer<
 
     const updatePart = <T extends SessionV1.Part>(part: T): Effect.Effect<T> =>
       Effect.gen(function* () {
+        if (part.type === "tool" && part.state.status === "error") {
+          const bounded = yield* truncate.error(part.state.error)
+          part.state.error = bounded.content
+        }
         yield* events.publish(SessionV1.Event.PartUpdated, {
           sessionID: part.sessionID,
           part: structuredClone(part),
@@ -1012,7 +1018,7 @@ function listByProject(
 export const node = LayerNode.make({
   service: Service,
   layer: layer,
-  deps: [BackgroundJob.node, RuntimeFlags.node, Database.node, EventV2Bridge.node],
+  deps: [BackgroundJob.node, RuntimeFlags.node, Database.node, EventV2Bridge.node, Truncate.node],
 })
 
 export * as Session from "./session"

packages/opencode/src/tool/truncate.ts

@@ -14,6 +14,7 @@ const RETENTION = Duration.days(7)
 
 export const MAX_LINES = 2000
 export const MAX_BYTES = 50 * 1024
+export const MAX_ERROR_CHARS = 10_000
 export const DIR = TRUNCATION_DIR
 export const GLOB = path.join(TRUNCATION_DIR, "*")
 
@@ -33,6 +34,11 @@ function hasTaskTool(agent?: Agent.Info) {
 export interface Interface {
   readonly cleanup: () => Effect.Effect<void>
   readonly write: (text: string) => Effect.Effect<string>
+  /**
+   * Keeps short tool errors unchanged. Larger errors are written to the same
+   * retained output store and replaced with a bounded head/tail preview.
+   */
+  readonly error: (text: string) => Effect.Effect<Result>
   /**
    * Returns output unchanged when it fits within the limits, otherwise writes the full text
    * to the truncation directory and returns a preview plus a hint to inspect the saved file.
@@ -72,6 +78,21 @@ const layer = Layer.effect(
       return file
     })
 
+    const error = Effect.fn("Truncate.error")(function* (text: string) {
+      if (text.length <= MAX_ERROR_CHARS) return { content: text, truncated: false } as const
+
+      const file = yield* write(text)
+      const notice = (omitted: number) =>
+        `\n\n...${omitted} characters truncated...\n\nThe tool call failed and the full error was saved to: ${file}\nUse Grep to search the full error or Read with offset/limit to inspect specific sections.\n\n`
+      const context = Math.max(0, Math.floor((MAX_ERROR_CHARS - notice(text.length).length) / 2))
+      const omitted = text.length - context * 2
+      return {
+        content: `${text.slice(0, context)}${notice(omitted)}${context === 0 ? "" : text.slice(-context)}`,
+        truncated: true,
+        outputPath: file,
+      } as const
+    })
+
     const limits = Effect.fn("Truncate.limits")(function* () {
       const configSvc = yield* Effect.serviceOption(Config.Service)
       if (Option.isNone(configSvc)) return { maxLines: MAX_LINES, maxBytes: MAX_BYTES }
@@ -147,7 +168,7 @@ const layer = Layer.effect(
       Effect.forkScoped,
     )
 
-    return Service.of({ cleanup, write, output, limits })
+    return Service.of({ cleanup, write, error, output, limits })
   }),
 )
 

packages/opencode/test/session/llm.test.ts

@@ -3,7 +3,8 @@ import { ConfigV1 } from "@opencode-ai/core/v1/config/config"
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test"
 import { SessionV1 } from "@opencode-ai/core/v1/session"
 import path from "path"
-import { tool, type ModelMessage } from "ai"
+import { InvalidToolInputError, tool, type ModelMessage } from "ai"
+import { JSONParseError } from "@ai-sdk/provider"
 import { Cause, Effect, Exit, Fiber, Layer, Stream } from "effect"
 import { InstanceRef } from "../../src/effect/instance-ref"
 import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
@@ -27,6 +28,7 @@ import { ModelV2 } from "@opencode-ai/core/model"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { LayerNodePlatform } from "@opencode-ai/core/effect/app-node-platform"
+import { Truncate } from "@/tool/truncate"
 
 type ConfigModel = NonNullable<NonNullable<ConfigV1.Info["provider"]>[string]["models"]>[string]
 
@@ -172,6 +174,67 @@ describe("session.llm.hasToolCalls", () => {
   })
 })
 
+describe("session.llm.invalidToolCallInput", () => {
+  test("bounds JSON parsing errors stored in repaired tool calls", () => {
+    const dropped = "GIANT_MIDDLE_SHOULD_NOT_BE_STORED"
+    const malformed = `{"query":"USEFUL_PREFIX:${"x".repeat(100_000)}${dropped}${"y".repeat(100_000)}:USEFUL_INPUT_TAIL`
+    expect(malformed.length).toBeGreaterThan(200_000)
+
+    let cause: unknown
+    try {
+      JSON.parse(malformed)
+    } catch (error) {
+      cause = error
+    }
+    if (!cause) throw new Error("expected malformed input to fail JSON parsing")
+
+    const failed = new InvalidToolInputError({
+      toolName: "lookup",
+      toolInput: malformed,
+      cause: new JSONParseError({ text: malformed, cause }),
+    })
+    expect(failed.message.length).toBeGreaterThan(200_000)
+
+    const storedSchema = z.object({ tool: z.string(), error: z.string() })
+    const stored = LLM.invalidToolCallInput("lookup", failed.message)
+    const repaired = storedSchema.parse(JSON.parse(stored))
+    const omission = repaired.error.match(/\n\.\.\. (\d+) characters omitted \.\.\.\n/)
+
+    expect(stored.length).toBeLessThanOrEqual(Truncate.MAX_ERROR_CHARS)
+    expect(repaired.error.length).toBeLessThanOrEqual(Truncate.MAX_ERROR_CHARS)
+    expect(repaired.tool).toBe("lookup")
+    expect(repaired.error).toContain("USEFUL_PREFIX")
+    expect(repaired.error).toContain("USEFUL_INPUT_TAIL")
+    expect(repaired.error).toContain("JSON Parse error: Unterminated string")
+    expect(omission).not.toBeNull()
+    if (!omission) throw new Error("expected repaired error to report omitted characters")
+    expect(Number(omission[1])).toBe(failed.message.length - (repaired.error.length - omission[0].length))
+    expect(repaired.error).not.toContain(dropped)
+
+    const short = "short tool error with exact whitespace\n"
+    const unchanged = storedSchema.parse(JSON.parse(LLM.invalidToolCallInput("lookup", short)))
+    expect(unchanged.error).toBe(short)
+
+    const whitespaceMalformed =
+      '{"description":"Test resumed player extraction","code":"const x=1;' + "\n\t".repeat(118_000) + '"}'
+    let whitespaceCause: unknown
+    try {
+      JSON.parse(whitespaceMalformed)
+    } catch (error) {
+      whitespaceCause = error
+    }
+    if (!whitespaceCause) throw new Error("expected whitespace-heavy input to fail JSON parsing")
+    const whitespaceError = new InvalidToolInputError({
+      toolName: "browser_execute",
+      toolInput: whitespaceMalformed,
+      cause: new JSONParseError({ text: whitespaceMalformed, cause: whitespaceCause }),
+    })
+    const boundedWhitespace = LLM.invalidToolCallInput("browser_execute", whitespaceError.message)
+    expect(boundedWhitespace.length).toBeLessThanOrEqual(Truncate.MAX_ERROR_CHARS)
+    expect(JSON.parse(boundedWhitespace).error).toContain("characters omitted")
+  })
+})
+
 describe("session.llm.ai-sdk adapter", () => {
   type AISDKAdapterEvent = Parameters<typeof LLMAISDK.toLLMEvents>[1]
 

packages/opencode/test/session/session.test.ts

@@ -16,6 +16,7 @@ import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { InstanceStore } from "@/project/instance-store"
 import { InstanceBootstrap } from "@/project/bootstrap"
+import { Truncate } from "@/tool/truncate"
 
 const it = testEffect(
   AppNodeBuilder.build(
@@ -206,6 +207,51 @@ describe("step-finish token propagation via event", () => {
 })
 
 describe("Session", () => {
+  it.instance("bounds every persisted tool error and saves the full text", () =>
+    Effect.gen(function* () {
+      const session = yield* SessionNs.Service
+      const info = yield* Effect.acquireRelease(session.create({ title: "tool-error" }), (created) =>
+        session.remove(created.id).pipe(Effect.ignore),
+      )
+      const messageID = MessageID.ascending()
+      yield* session.updateMessage({
+        id: messageID,
+        sessionID: info.id,
+        role: "user",
+        time: { created: Date.now() },
+        agent: "build",
+        model: { providerID: "test", modelID: "test" },
+      } as unknown as SessionV1.Info)
+
+      const error = `ERROR_HEAD:${"e".repeat(15_000)}GIANT_MIDDLE${"r".repeat(15_000)}:ERROR_TAIL`
+      const part = yield* session.updatePart({
+        id: PartID.ascending(),
+        messageID,
+        sessionID: info.id,
+        type: "tool",
+        tool: "lookup",
+        callID: "call-1",
+        state: {
+          status: "error",
+          input: {},
+          error,
+          time: { start: Date.now(), end: Date.now() },
+        },
+      } satisfies SessionV1.ToolPart)
+
+      expect(part.state.status).toBe("error")
+      if (part.state.status !== "error") return
+      expect(part.state.error.length).toBeLessThanOrEqual(Truncate.MAX_ERROR_CHARS)
+      expect(part.state.error).toContain("ERROR_HEAD")
+      expect(part.state.error).toContain("ERROR_TAIL")
+      expect(part.state.error).not.toContain("GIANT_MIDDLE")
+      const outputPath = part.state.error.match(/full error was saved to: (.+)\n/)?.[1]
+      expect(outputPath).toBeDefined()
+      if (!outputPath) throw new Error("expected full error path")
+      expect(yield* Effect.promise(() => Bun.file(outputPath).text())).toBe(error)
+    }),
+  )
+
   it.live("remove works without an instance", () =>
     Effect.gen(function* () {
       const session = yield* SessionNs.Service

packages/opencode/test/tool/truncation.test.ts

@@ -25,6 +25,38 @@ const configuredLayer = (cfg: ConfigV1.Info) =>
 const configuredIt = (cfg: ConfigV1.Info) => testEffect(configuredLayer(cfg))
 
 describe("Truncate", () => {
+  describe("error", () => {
+    test("uses a 10,000 character model-facing limit", () => {
+      expect(Truncate.MAX_ERROR_CHARS).toBe(10_000)
+    })
+
+    it.live("keeps short errors unchanged", () =>
+      Effect.gen(function* () {
+        const content = "short tool error with exact whitespace\n"
+        const result = yield* (yield* Truncate.Service).error(content)
+
+        expect(result).toEqual({ content, truncated: false })
+      }),
+    )
+
+    it.live("saves the full error and returns a bounded head and tail", () =>
+      Effect.gen(function* () {
+        const content = `ERROR_HEAD:${"h".repeat(15_000)}GIANT_MIDDLE${"t".repeat(15_000)}:ERROR_TAIL`
+        const result = yield* (yield* Truncate.Service).error(content)
+
+        expect(result.truncated).toBe(true)
+        expect(result.content.length).toBeLessThanOrEqual(Truncate.MAX_ERROR_CHARS)
+        expect(result.content).toContain("ERROR_HEAD")
+        expect(result.content).toContain("ERROR_TAIL")
+        expect(result.content).not.toContain("GIANT_MIDDLE")
+        expect(result.content).toContain("the full error was saved to")
+        if (!result.truncated) throw new Error("expected truncated")
+        expect(result.content).toContain(result.outputPath)
+        expect(yield* (yield* FSUtil.Service).readFileString(result.outputPath)).toBe(content)
+      }),
+    )
+  })
+
   describe("output", () => {
     it.live("truncates large json file by bytes", () =>
       Effect.gen(function* () {