fix: respect tool_call: false capability flag at runtime

Gate tool resolution, LiteLLM noop injection, activeTools, tools, and
toolChoice behind input.model.capabilities.toolcall. Without this fix,
tool_call: false in opencode.json is parsed and stored but never checked,
causing Bedrock models that don't support streaming + tool use to fail.

Adds regression test verifying body.tools is not sent when toolcall: false.

Cherry-picked from lgarceau768#1 and rebased onto v1.4.0.

Author: lgarceau768

packages/opencode/src/session/llm.ts

@@ -193,7 +193,8 @@ export namespace LLM {
           },
         )
 
-        const tools = resolveTools(input)
+        const canTool = input.model.capabilities.toolcall
+        const tools = canTool ? 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.
@@ -211,6 +212,7 @@ export namespace LLM {
         // during compaction), inject a stub tool to satisfy the validation requirement.
         // The stub description explicitly tells the model not to call it.
         if (
+          canTool &&
           (isLiteLLMProxy || input.model.providerID.includes("github-copilot")) &&
           Object.keys(tools).length === 0 &&
           hasToolCalls(input.messages)
@@ -350,9 +352,13 @@ export namespace LLM {
           topP: params.topP,
           topK: params.topK,
           providerOptions: ProviderTransform.providerOptions(input.model, params.options),
-          activeTools: Object.keys(tools).filter((x) => x !== "invalid"),
-          tools,
-          toolChoice: input.toolChoice,
+          ...(canTool
+            ? {
+                activeTools: Object.keys(tools).filter((x) => x !== "invalid"),
+                tools,
+              }
+            : {}),
+          ...(canTool ? { toolChoice: input.toolChoice } : {}),
           maxOutputTokens: params.maxOutputTokens,
           abortSignal: input.abort,
           headers: {

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

@@ -561,6 +561,95 @@ describe("session.llm.stream", () => {
     })
   })
 
+  test("does not send tools when model toolcall is disabled", async () => {
+    const server = state.server
+    if (!server) {
+      throw new Error("Server not initialized")
+    }
+
+    const providerID = "alibaba"
+    const modelID = "qwen-plus"
+    const fixture = await loadFixture(providerID, modelID)
+    const model = fixture.model
+
+    const request = waitRequest(
+      "/chat/completions",
+      new Response(createChatStream("Hello"), {
+        status: 200,
+        headers: { "Content-Type": "text/event-stream" },
+      }),
+    )
+
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(
+          path.join(dir, "opencode.json"),
+          JSON.stringify({
+            $schema: "https://opencode.ai/config.json",
+            enabled_providers: [providerID],
+            provider: {
+              [providerID]: {
+                options: {
+                  apiKey: "test-key",
+                  baseURL: `${server.url.origin}/v1`,
+                },
+              },
+            },
+          }),
+        )
+      },
+    })
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const resolved = await getModel(ProviderID.make(providerID), ModelID.make(model.id))
+        const sessionID = SessionID.make("session-test-no-tools")
+        const agent = {
+          name: "test",
+          mode: "primary",
+          options: {},
+          permission: [{ permission: "*", pattern: "*", action: "allow" }],
+        } satisfies Agent.Info
+
+        const user = {
+          id: MessageID.make("user-no-tools"),
+          sessionID,
+          role: "user",
+          time: { created: Date.now() },
+          agent: agent.name,
+          model: { providerID: ProviderID.make(providerID), modelID: resolved.id },
+        } satisfies MessageV2.User
+
+        await drain({
+          user,
+          sessionID,
+          model: {
+            ...resolved,
+            capabilities: {
+              ...resolved.capabilities,
+              toolcall: false,
+            },
+          },
+          agent,
+          system: ["You are a helpful assistant."],
+          messages: [{ role: "user", content: "Hello" }],
+          tools: {
+            question: tool({
+              description: "Ask a question",
+              inputSchema: z.object({}),
+              execute: async () => ({ output: "" }),
+            }),
+          },
+        })
+
+        const capture = await request
+        expect(capture.body.tools).toBeUndefined()
+        expect(capture.body.tool_choice).toBeUndefined()
+      },
+    })
+  })
+
   test("sends responses API payload for OpenAI models", async () => {
     const server = state.server
     if (!server) {