fix: [AI-678] add stub tool definitions for historical tool_use blocks

The Anthropic API requires every `tool_use` block in message history to
have a matching tool definition. When agents switch (Plan→Builder), MCP
tools disconnect, or tools are filtered by permissions, the history may
reference tools absent from the current set — causing a 400 error:
"Requests with 'tool_use' and 'tool_result' blocks must include tool
definition."

Replace the LiteLLM-only `_noop` workaround with a general fix:
- Extract all tool names from `tool-call` blocks in message history
- Add stub definitions for any names missing from the active tools set
- Stubs return "tool no longer available" if the model attempts to call them

Closes #678

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: anandgupta42

packages/opencode/src/session/llm.ts

@@ -149,25 +149,27 @@ export namespace LLM {
 
     const tools = await resolveTools(input)
 
-    // LiteLLM and some Anthropic proxies require the tools parameter to be present
-    // when message history contains tool calls, even if no tools are being used.
-    // Add a dummy tool that is never called to satisfy this validation.
-    // This is enabled for:
-    // 1. Providers with "litellm" in their ID or API ID (auto-detected)
-    // 2. Providers with explicit "litellmProxy: true" option (opt-in for custom gateways)
-    const isLiteLLMProxy =
-      provider.options?.["litellmProxy"] === true ||
-      input.model.providerID.toLowerCase().includes("litellm") ||
-      input.model.api.id.toLowerCase().includes("litellm")
-
-    if (isLiteLLMProxy && Object.keys(tools).length === 0 && hasToolCalls(input.messages)) {
-      tools["_noop"] = tool({
-        description:
-          "Placeholder for LiteLLM/Anthropic proxy compatibility - required when message history contains tool calls but no active tools are needed",
-        inputSchema: jsonSchema({ type: "object", properties: {} }),
-        execute: async () => ({ output: "", title: "", metadata: {} }),
-      })
+    // altimate_change start — ensure tool definitions exist for all tool_use blocks in history
+    // The Anthropic API (and proxies like LiteLLM) require every tool_use block in
+    // message history to have a matching tool definition. When agents switch (Plan→Builder),
+    // MCP tools disconnect, or tools are filtered by permissions, the history may reference
+    // tools absent from the current set. Add stub definitions for any missing tools.
+    // Fixes: https://github.com/AltimateAI/altimate-code/issues/678
+    const referencedTools = toolNamesFromMessages(input.messages)
+    for (const name of referencedTools) {
+      if (!tools[name]) {
+        tools[name] = tool({
+          description: `[Historical] Tool no longer available in this session`,
+          inputSchema: jsonSchema({ type: "object", properties: {} }),
+          execute: async () => ({
+            output: "This tool is no longer available. Please use an alternative approach.",
+            title: "",
+            metadata: {},
+          }),
+        })
+      }
     }
+    // altimate_change end
 
     return streamText({
       onError(error) {
@@ -276,4 +278,21 @@ export namespace LLM {
     }
     return false
   }
+
+  // altimate_change start — collect tool names from message history to prevent API validation errors
+  // Anthropic API requires every tool_use block in message history to have a matching tool
+  // definition. When agents switch (e.g. Plan→Builder) or MCP tools disconnect, the history
+  // may reference tools no longer in the active set. This function extracts those names so
+  // stub definitions can be added. Fixes #678.
+  export function toolNamesFromMessages(messages: ModelMessage[]): Set<string> {
+    const names = new Set<string>()
+    for (const msg of messages) {
+      if (!Array.isArray(msg.content)) continue
+      for (const part of msg.content) {
+        if (part.type === "tool-call") names.add(part.toolName)
+      }
+    }
+    return names
+  }
+  // altimate_change end
 }

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

@@ -14,6 +14,57 @@ import type { Agent } from "../../src/agent/agent"
 import type { MessageV2 } from "../../src/session/message-v2"
 import { SessionID, MessageID } from "../../src/session/schema"
 
+describe("session.llm.toolNamesFromMessages", () => {
+  test("returns empty set for empty messages", () => {
+    expect(LLM.toolNamesFromMessages([])).toEqual(new Set())
+  })
+
+  test("returns empty set for messages with no tool calls", () => {
+    const messages: ModelMessage[] = [
+      { role: "user", content: [{ type: "text", text: "Hello" }] },
+      { role: "assistant", content: [{ type: "text", text: "Hi" }] },
+    ]
+    expect(LLM.toolNamesFromMessages(messages)).toEqual(new Set())
+  })
+
+  test("extracts tool names from tool-call blocks", () => {
+    const messages = [
+      {
+        role: "assistant",
+        content: [
+          { type: "tool-call", toolCallId: "call-1", toolName: "bash" },
+          { type: "tool-call", toolCallId: "call-2", toolName: "read" },
+        ],
+      },
+    ] as ModelMessage[]
+    expect(LLM.toolNamesFromMessages(messages)).toEqual(new Set(["bash", "read"]))
+  })
+
+  test("deduplicates tool names across messages", () => {
+    const messages = [
+      {
+        role: "assistant",
+        content: [{ type: "tool-call", toolCallId: "call-1", toolName: "bash" }],
+      },
+      {
+        role: "assistant",
+        content: [{ type: "tool-call", toolCallId: "call-2", toolName: "bash" }],
+      },
+    ] as ModelMessage[]
+    expect(LLM.toolNamesFromMessages(messages)).toEqual(new Set(["bash"]))
+  })
+
+  test("ignores tool-result blocks (only extracts from tool-call)", () => {
+    const messages = [
+      {
+        role: "tool",
+        content: [{ type: "tool-result", toolCallId: "call-1", toolName: "bash" }],
+      },
+    ] as ModelMessage[]
+    expect(LLM.toolNamesFromMessages(messages)).toEqual(new Set())
+  })
+})
+
 describe("session.llm.hasToolCalls", () => {
   test("returns false for empty messages array", () => {
     expect(LLM.hasToolCalls([])).toBe(false)