allow temperature to be configured per mode

.opencode/agent/example-driven-docs-writer.md

@@ -0,0 +1,44 @@
+---
+description: >-
+  Use this agent when you need to create or improve documentation that requires
+  concrete examples to illustrate every concept. Examples include:
+  <example>Context: User has written a new API endpoint and needs documentation.
+  user: 'I just created a POST /users endpoint that accepts name and email
+  fields. Can you document this?' assistant: 'I'll use the
+  example-driven-docs-writer agent to create documentation with practical
+  examples for your API endpoint.' <commentary>Since the user needs
+  documentation with examples, use the example-driven-docs-writer agent to
+  create comprehensive docs with code samples.</commentary></example>
+  <example>Context: User has a complex configuration file that needs
+  documentation. user: 'This config file has multiple sections and I need docs
+  that show how each option works' assistant: 'Let me use the
+  example-driven-docs-writer agent to create documentation that breaks down each
+  configuration option with practical examples.' <commentary>The user needs
+  documentation that demonstrates configuration options, perfect for the
+  example-driven-docs-writer agent.</commentary></example>
+---
+You are an expert technical documentation writer who specializes in creating clear, example-rich documentation that never leaves readers guessing. Your core principle is that every concept must be immediately illustrated with concrete examples, code samples, or practical demonstrations.
+
+Your documentation approach:
+- Never write more than one sentence in any section without providing an example, code snippet, diagram, or practical illustration
+- Break up longer explanations with multiple examples showing different scenarios or use cases
+- Use concrete, realistic examples rather than abstract or placeholder content
+- Include both basic and advanced examples when covering complex topics
+- Show expected inputs, outputs, and results for all examples
+- Use code blocks, bullet points, tables, or other formatting to visually separate examples from explanatory text
+
+Structural requirements:
+- Start each section with a brief one-sentence explanation followed immediately by an example
+- For multi-step processes, provide an example after each step
+- Include error examples and edge cases alongside success scenarios
+- Use consistent formatting and naming conventions throughout examples
+- Ensure examples are copy-pasteable and functional when applicable
+
+Quality standards:
+- Verify that no paragraph exceeds one sentence without an accompanying example
+- Test that examples are accurate and would work in real scenarios
+- Ensure examples progress logically from simple to complex
+- Include context for when and why to use different approaches shown in examples
+- Provide troubleshooting examples for common issues
+
+When you receive a documentation request, immediately identify what needs examples and plan to illustrate every single concept, feature, or instruction with concrete demonstrations. Ask for clarification if you need more context to create realistic, useful examples.

STATS.md

@@ -26,3 +26,4 @@
 | 2025-07-22 | 84,251 (+4,054)  | 118,073 (+4,536) | 202,324 (+8,590)  |
 | 2025-07-23 | 88,589 (+4,338)  | 121,436 (+3,363) | 210,025 (+7,701)  |
 | 2025-07-24 | 92,469 (+3,880)  | 124,091 (+2,655) | 216,560 (+6,535)  |
+| 2025-07-25 | 96,417 (+3,948)  | 126,985 (+2,894) | 223,402 (+6,842)  |

packages/opencode/src/agent/agent.ts

@@ -44,7 +44,10 @@ export namespace Agent {
         item = result[key] = {
           name: key,
           description: "",
-          tools: {},
+          tools: {
+            todowrite: false,
+            todoread: false,
+          },
         }
       const model = value.model ?? cfg.model
       if (model) item.model = Provider.parseModel(model)

packages/opencode/src/config/config.ts

@@ -99,6 +99,7 @@ export namespace Config {
   export const Mode = z
     .object({
       model: z.string().optional(),
+      temperature: z.number().optional(),
       prompt: z.string().optional(),
       tools: z.record(z.string(), z.boolean()).optional(),
       disable: z.boolean().optional(),

packages/opencode/src/lsp/server.ts

@@ -322,4 +322,43 @@ export namespace LSPServer {
       }
     },
   }
+
+  export const CSharp: Info = {
+    id: "csharp",
+    root: NearestRoot([".sln", ".csproj", "global.json"]),
+    extensions: [".cs"],
+    async spawn(_, root) {
+      let bin = Bun.which("csharp-ls", {
+        PATH: process.env["PATH"] + ":" + Global.Path.bin,
+      })
+      if (!bin) {
+        if (!Bun.which("dotnet")) {
+          log.error(".NET SDK is required to install csharp-ls")
+          return
+        }
+
+        log.info("installing csharp-ls via dotnet tool")
+        const proc = Bun.spawn({
+          cmd: ["dotnet", "tool", "install", "csharp-ls", "--tool-path", Global.Path.bin],
+          stdout: "pipe",
+          stderr: "pipe",
+          stdin: "pipe",
+        })
+        const exit = await proc.exited
+        if (exit !== 0) {
+          log.error("Failed to install csharp-ls")
+          return
+        }
+
+        bin = path.join(Global.Path.bin, "csharp-ls" + (process.platform === "win32" ? ".exe" : ""))
+        log.info(`installed csharp-ls`, { bin })
+      }
+
+      return {
+        process: spawn(bin, {
+          cwd: root,
+        }),
+      }
+    },
+  }
 }

packages/opencode/src/provider/provider.ts

@@ -5,22 +5,11 @@ import { mergeDeep, sortBy } from "remeda"
 import { NoSuchModelError, type LanguageModel, type Provider as SDK } from "ai"
 import { Log } from "../util/log"
 import { BunProc } from "../bun"
-import { BashTool } from "../tool/bash"
-import { EditTool } from "../tool/edit"
-import { WebFetchTool } from "../tool/webfetch"
-import { GlobTool } from "../tool/glob"
-import { GrepTool } from "../tool/grep"
-import { ListTool } from "../tool/ls"
-import { PatchTool } from "../tool/patch"
-import { ReadTool } from "../tool/read"
-import { WriteTool } from "../tool/write"
-import { TodoReadTool, TodoWriteTool } from "../tool/todo"
 import { AuthAnthropic } from "../auth/anthropic"
 import { AuthCopilot } from "../auth/copilot"
 import { ModelsDev } from "./models"
 import { NamedError } from "../util/error"
 import { Auth } from "../auth"
-import { TaskTool } from "../tool/task"
 
 export namespace Provider {
   const log = Log.create({ service: "provider" })
@@ -468,137 +457,6 @@ export namespace Provider {
     }
   }
 
-  const TOOLS = [
-    BashTool,
-    EditTool,
-    WebFetchTool,
-    GlobTool,
-    GrepTool,
-    ListTool,
-    // LspDiagnosticTool,
-    // LspHoverTool,
-    PatchTool,
-    ReadTool,
-    // MultiEditTool,
-    WriteTool,
-    TodoWriteTool,
-    TodoReadTool,
-    TaskTool,
-  ]
-
-  export async function tools(providerID: string) {
-    const result = await Promise.all(TOOLS.map((t) => t()))
-    switch (providerID) {
-      case "anthropic":
-        return result.filter((t) => t.id !== "patch")
-      case "openai":
-        return result.map((t) => ({
-          ...t,
-          parameters: optionalToNullable(t.parameters),
-        }))
-      case "azure":
-        return result.map((t) => ({
-          ...t,
-          parameters: optionalToNullable(t.parameters),
-        }))
-      case "google":
-        return result.map((t) => ({
-          ...t,
-          parameters: sanitizeGeminiParameters(t.parameters),
-        }))
-      default:
-        return result
-    }
-  }
-
-  function sanitizeGeminiParameters(schema: z.ZodTypeAny, visited = new Set()): z.ZodTypeAny {
-    if (!schema || visited.has(schema)) {
-      return schema
-    }
-    visited.add(schema)
-
-    if (schema instanceof z.ZodDefault) {
-      const innerSchema = schema.removeDefault()
-      // Handle Gemini's incompatibility with `default` on `anyOf` (unions).
-      if (innerSchema instanceof z.ZodUnion) {
-        // The schema was `z.union(...).default(...)`, which is not allowed.
-        // We strip the default and return the sanitized union.
-        return sanitizeGeminiParameters(innerSchema, visited)
-      }
-      // Otherwise, the default is on a regular type, which is allowed.
-      // We recurse on the inner type and then re-apply the default.
-      return sanitizeGeminiParameters(innerSchema, visited).default(schema._def.defaultValue())
-    }
-
-    if (schema instanceof z.ZodOptional) {
-      return z.optional(sanitizeGeminiParameters(schema.unwrap(), visited))
-    }
-
-    if (schema instanceof z.ZodObject) {
-      const newShape: Record<string, z.ZodTypeAny> = {}
-      for (const [key, value] of Object.entries(schema.shape)) {
-        newShape[key] = sanitizeGeminiParameters(value as z.ZodTypeAny, visited)
-      }
-      return z.object(newShape)
-    }
-
-    if (schema instanceof z.ZodArray) {
-      return z.array(sanitizeGeminiParameters(schema.element, visited))
-    }
-
-    if (schema instanceof z.ZodUnion) {
-      // This schema corresponds to `anyOf` in JSON Schema.
-      // We recursively sanitize each option in the union.
-      const sanitizedOptions = schema.options.map((option: z.ZodTypeAny) => sanitizeGeminiParameters(option, visited))
-      return z.union(sanitizedOptions as [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]])
-    }
-
-    if (schema instanceof z.ZodString) {
-      const newSchema = z.string({ description: schema.description })
-      const safeChecks = ["min", "max", "length", "regex", "startsWith", "endsWith", "includes", "trim"]
-      // rome-ignore lint/suspicious/noExplicitAny: <explanation>
-      ;(newSchema._def as any).checks = (schema._def as z.ZodStringDef).checks.filter((check) =>
-        safeChecks.includes(check.kind),
-      )
-      return newSchema
-    }
-
-    return schema
-  }
-  function optionalToNullable(schema: z.ZodTypeAny): z.ZodTypeAny {
-    if (schema instanceof z.ZodObject) {
-      const shape = schema.shape
-      const newShape: Record<string, z.ZodTypeAny> = {}
-
-      for (const [key, value] of Object.entries(shape)) {
-        const zodValue = value as z.ZodTypeAny
-        if (zodValue instanceof z.ZodOptional) {
-          newShape[key] = zodValue.unwrap().nullable()
-        } else {
-          newShape[key] = optionalToNullable(zodValue)
-        }
-      }
-
-      return z.object(newShape)
-    }
-
-    if (schema instanceof z.ZodArray) {
-      return z.array(optionalToNullable(schema.element))
-    }
-
-    if (schema instanceof z.ZodUnion) {
-      return z.union(
-        schema.options.map((option: z.ZodTypeAny) => optionalToNullable(option)) as [
-          z.ZodTypeAny,
-          z.ZodTypeAny,
-          ...z.ZodTypeAny[],
-        ],
-      )
-    }
-
-    return schema
-  }
-
   export const ModelNotFoundError = NamedError.create(
     "ProviderModelNotFoundError",
     z.object({

packages/opencode/src/provider/transform.ts

@@ -7,24 +7,46 @@ export namespace ProviderTransform {
       const system = msgs.filter((msg) => msg.role === "system").slice(0, 2)
       const final = msgs.filter((msg) => msg.role !== "system").slice(-2)
 
+      const providerOptions = {
+        anthropic: {
+          cacheControl: { type: "ephemeral" },
+        },
+        openrouter: {
+          cache_control: { type: "ephemeral" },
+        },
+        bedrock: {
+          cachePoint: { type: "ephemeral" },
+        },
+        openaiCompatible: {
+          cache_control: { type: "ephemeral" },
+        },
+      }
+
       for (const msg of unique([...system, ...final])) {
+        const shouldUseContentOptions = providerID !== "anthropic" && Array.isArray(msg.content) && msg.content.length > 0
+        
+        if (shouldUseContentOptions) {
+          const lastContent = msg.content[msg.content.length - 1]
+          if (lastContent && typeof lastContent === "object") {
+            lastContent.providerOptions = {
+              ...lastContent.providerOptions,
+              ...providerOptions,
+            }
+            continue
+          }
+        }
+        
         msg.providerOptions = {
           ...msg.providerOptions,
-          anthropic: {
-            cacheControl: { type: "ephemeral" },
-          },
-          openrouter: {
-            cache_control: { type: "ephemeral" },
-          },
-          bedrock: {
-            cachePoint: { type: "ephemeral" },
-          },
-          openaiCompatible: {
-            cache_control: { type: "ephemeral" },
-          },
+          ...providerOptions,
         }
       }
     }
     return msgs
   }
+
+  export function temperature(_providerID: string, modelID: string) {
+    if (modelID.includes("qwen")) return 0.55
+    return 0
+  }
 }

packages/opencode/src/session/index.ts

@@ -39,7 +39,8 @@ import { MessageV2 } from "./message-v2"
 import { Mode } from "./mode"
 import { LSP } from "../lsp"
 import { ReadTool } from "../tool/read"
-import { splitWhen } from "remeda"
+import { mergeDeep, pipe, splitWhen } from "remeda"
+import { ToolRegistry } from "../tool/registry"
 
 export namespace Session {
   const log = Log.create({ service: "session" })
@@ -430,7 +431,7 @@ export namespace Session {
                   }
                 }
                 const args = { filePath, offset, limit }
-                const result = await ReadTool().then((t) =>
+                const result = await ReadTool.init().then((t) =>
                   t.execute(args, {
                     sessionID: input.sessionID,
                     abort: new AbortController().signal,
@@ -626,7 +627,6 @@ export namespace Session {
         return SystemPrompt.provider(input.modelID)
       })(),
     )
-    system.push(...(mode.prompt ? [mode.prompt] : SystemPrompt.provider(input.modelID)))
     system.push(...(await SystemPrompt.environment()))
     system.push(...(await SystemPrompt.custom()))
     // max 2 system prompt messages for caching purposes
@@ -661,10 +661,13 @@ export namespace Session {
 
     const processor = createProcessor(assistantMsg, model.info)
 
-    for (const item of await Provider.tools(input.providerID)) {
-      if (mode.tools[item.id] === false) continue
-      if (input.tools?.[item.id] === false) continue
-      if (session.parentID && item.id === "task") continue
+    const enabledTools = pipe(
+      mode.tools,
+      mergeDeep(ToolRegistry.enabled(input.providerID, input.modelID)),
+      mergeDeep(input.tools ?? {}),
+    )
+    for (const item of await ToolRegistry.tools(input.providerID, input.modelID)) {
+      if (enabledTools[item.id] === false) continue
       tools[item.id] = tool({
         id: item.id as any,
         description: item.description,
@@ -792,7 +795,9 @@ export namespace Session {
         ),
         ...MessageV2.toModelMessage(msgs),
       ],
-      temperature: model.info.temperature ? 0 : undefined,
+      temperature: model.info.temperature
+        ? (mode.temperature ?? ProviderTransform.temperature(input.providerID, input.modelID))
+        : undefined,
       tools: model.info.tool_call === false ? undefined : tools,
       model: wrapLanguageModel({
         model: model.language,
@@ -1005,6 +1010,7 @@ export namespace Session {
                     start: Date.now(),
                     end: Date.now(),
                   }
+                  currentText.text = currentText.text.trimEnd()
                   await updatePart(currentText)
                 }
                 currentText = undefined

packages/opencode/src/session/mode.ts

@@ -7,6 +7,7 @@ export namespace Mode {
   export const Info = z
     .object({
       name: z.string(),
+      temperature: z.number().optional(),
       model: z
         .object({
           modelID: z.string(),
@@ -22,13 +23,16 @@ export namespace Mode {
   export type Info = z.infer<typeof Info>
   const state = App.state("mode", async () => {
     const cfg = await Config.get()
+    const model = cfg.model ? Provider.parseModel(cfg.model) : undefined
     const result: Record<string, Info> = {
       build: {
+        model,
         name: "build",
         tools: {},
       },
       plan: {
         name: "plan",
+        model,
         tools: {
           write: false,
           edit: false,
@@ -45,11 +49,9 @@ export namespace Mode {
           tools: {},
         }
       item.name = key
-      const model = value.model ?? cfg.model
-      if (model) {
-        item.model = Provider.parseModel(model)
-      }
+      if (value.model) item.model = Provider.parseModel(value.model)
       if (value.prompt) item.prompt = value.prompt
+      if (value.temperature) item.temperature = value.temperature
       if (value.tools)
         item.tools = {
           ...value.tools,

packages/opencode/src/tool/bash.ts

@@ -7,8 +7,7 @@ const MAX_OUTPUT_LENGTH = 30000
 const DEFAULT_TIMEOUT = 1 * 60 * 1000
 const MAX_TIMEOUT = 10 * 60 * 1000
 
-export const BashTool = Tool.define({
-  id: "bash",
+export const BashTool = Tool.define("bash", {
   description: DESCRIPTION,
   parameters: z.object({
     command: z.string().describe("The command to execute"),

packages/opencode/src/tool/edit.ts

@@ -14,8 +14,7 @@ import { File } from "../file"
 import { Bus } from "../bus"
 import { FileTime } from "../file/time"
 
-export const EditTool = Tool.define({
-  id: "edit",
+export const EditTool = Tool.define("edit", {
   description: DESCRIPTION,
   parameters: z.object({
     filePath: z.string().describe("The absolute path to the file to modify"),

packages/opencode/src/tool/glob.ts

@@ -5,8 +5,7 @@ import { App } from "../app/app"
 import DESCRIPTION from "./glob.txt"
 import { Ripgrep } from "../file/ripgrep"
 
-export const GlobTool = Tool.define({
-  id: "glob",
+export const GlobTool = Tool.define("glob", {
   description: DESCRIPTION,
   parameters: z.object({
     pattern: z.string().describe("The glob pattern to match files against"),

packages/opencode/src/tool/grep.ts

@@ -5,8 +5,7 @@ import { Ripgrep } from "../file/ripgrep"
 
 import DESCRIPTION from "./grep.txt"
 
-export const GrepTool = Tool.define({
-  id: "grep",
+export const GrepTool = Tool.define("grep", {
   description: DESCRIPTION,
   parameters: z.object({
     pattern: z.string().describe("The regex pattern to search for in file contents"),

packages/opencode/src/tool/ls.ts

@@ -33,8 +33,7 @@ export const IGNORE_PATTERNS = [
 
 const LIMIT = 100
 
-export const ListTool = Tool.define({
-  id: "list",
+export const ListTool = Tool.define("list", {
   description: DESCRIPTION,
   parameters: z.object({
     path: z.string().describe("The absolute path to the directory to list (must be absolute, not relative)").optional(),

packages/opencode/src/tool/lsp-diagnostics.ts

@@ -5,8 +5,7 @@ import { LSP } from "../lsp"
 import { App } from "../app/app"
 import DESCRIPTION from "./lsp-diagnostics.txt"
 
-export const LspDiagnosticTool = Tool.define({
-  id: "lsp_diagnostics",
+export const LspDiagnosticTool = Tool.define("lsp_diagnostics", {
   description: DESCRIPTION,
   parameters: z.object({
     path: z.string().describe("The path to the file to get diagnostics."),

packages/opencode/src/tool/lsp-hover.ts

@@ -5,8 +5,7 @@ import { LSP } from "../lsp"
 import { App } from "../app/app"
 import DESCRIPTION from "./lsp-hover.txt"
 
-export const LspHoverTool = Tool.define({
-  id: "lsp_hover",
+export const LspHoverTool = Tool.define("lsp_hover", {
   description: DESCRIPTION,
   parameters: z.object({
     file: z.string().describe("The path to the file to get diagnostics."),

packages/opencode/src/tool/multiedit.ts

@@ -5,8 +5,7 @@ import DESCRIPTION from "./multiedit.txt"
 import path from "path"
 import { App } from "../app/app"
 
-export const MultiEditTool = Tool.define({
-  id: "multiedit",
+export const MultiEditTool = Tool.define("multiedit", {
   description: DESCRIPTION,
   parameters: z.object({
     filePath: z.string().describe("The absolute path to the file to modify"),
@@ -22,7 +21,7 @@ export const MultiEditTool = Tool.define({
       .describe("Array of edit operations to perform sequentially on the file"),
   }),
   async execute(params, ctx) {
-    const tool = await EditTool()
+    const tool = await EditTool.init()
     const results = []
     for (const [, edit] of params.edits.entries()) {
       const result = await tool.execute(

packages/opencode/src/tool/patch.ts

@@ -210,8 +210,7 @@ async function applyCommit(
   }
 }
 
-export const PatchTool = Tool.define({
-  id: "patch",
+export const PatchTool = Tool.define("patch", {
   description: DESCRIPTION,
   parameters: PatchParams,
   execute: async (params, ctx) => {

packages/opencode/src/tool/read.ts

@@ -10,8 +10,7 @@ import { App } from "../app/app"
 const DEFAULT_READ_LIMIT = 2000
 const MAX_LINE_LENGTH = 2000
 
-export const ReadTool = Tool.define({
-  id: "read",
+export const ReadTool = Tool.define("read", {
   description: DESCRIPTION,
   parameters: z.object({
     filePath: z.string().describe("The path to the file to read"),

packages/opencode/src/tool/registry.ts

@@ -0,0 +1,170 @@
+import z from "zod"
+import { BashTool } from "./bash"
+import { EditTool } from "./edit"
+import { GlobTool } from "./glob"
+import { GrepTool } from "./grep"
+import { ListTool } from "./ls"
+import { PatchTool } from "./patch"
+import { ReadTool } from "./read"
+import { TaskTool } from "./task"
+import { TodoWriteTool, TodoReadTool } from "./todo"
+import { WebFetchTool } from "./webfetch"
+import { WriteTool } from "./write"
+
+export namespace ToolRegistry {
+  const ALL = [
+    BashTool,
+    EditTool,
+    WebFetchTool,
+    GlobTool,
+    GrepTool,
+    ListTool,
+    PatchTool,
+    ReadTool,
+    WriteTool,
+    TodoWriteTool,
+    TodoReadTool,
+    TaskTool,
+  ]
+
+  export function ids() {
+    return ALL.map((t) => t.id)
+  }
+
+  export async function tools(providerID: string, _modelID: string) {
+    const result = await Promise.all(
+      ALL.map(async (t) => ({
+        id: t.id,
+        ...(await t.init()),
+      })),
+    )
+
+    if (providerID === "openai") {
+      return result.map((t) => ({
+        ...t,
+        parameters: optionalToNullable(t.parameters),
+      }))
+    }
+
+    if (providerID === "azure") {
+      return result.map((t) => ({
+        ...t,
+        parameters: optionalToNullable(t.parameters),
+      }))
+    }
+
+    if (providerID === "google") {
+      return result.map((t) => ({
+        ...t,
+        parameters: sanitizeGeminiParameters(t.parameters),
+      }))
+    }
+
+    return result
+  }
+
+  export function enabled(_providerID: string, modelID: string): Record<string, boolean> {
+    if (modelID.includes("claude")) {
+      return {
+        patch: false,
+      }
+    }
+    if (modelID.includes("qwen")) {
+      return {
+        patch: false,
+        todowrite: false,
+        todoread: false,
+      }
+    }
+    return {}
+  }
+
+  function sanitizeGeminiParameters(schema: z.ZodTypeAny, visited = new Set()): z.ZodTypeAny {
+    if (!schema || visited.has(schema)) {
+      return schema
+    }
+    visited.add(schema)
+
+    if (schema instanceof z.ZodDefault) {
+      const innerSchema = schema.removeDefault()
+      // Handle Gemini's incompatibility with `default` on `anyOf` (unions).
+      if (innerSchema instanceof z.ZodUnion) {
+        // The schema was `z.union(...).default(...)`, which is not allowed.
+        // We strip the default and return the sanitized union.
+        return sanitizeGeminiParameters(innerSchema, visited)
+      }
+      // Otherwise, the default is on a regular type, which is allowed.
+      // We recurse on the inner type and then re-apply the default.
+      return sanitizeGeminiParameters(innerSchema, visited).default(schema._def.defaultValue())
+    }
+
+    if (schema instanceof z.ZodOptional) {
+      return z.optional(sanitizeGeminiParameters(schema.unwrap(), visited))
+    }
+
+    if (schema instanceof z.ZodObject) {
+      const newShape: Record<string, z.ZodTypeAny> = {}
+      for (const [key, value] of Object.entries(schema.shape)) {
+        newShape[key] = sanitizeGeminiParameters(value as z.ZodTypeAny, visited)
+      }
+      return z.object(newShape)
+    }
+
+    if (schema instanceof z.ZodArray) {
+      return z.array(sanitizeGeminiParameters(schema.element, visited))
+    }
+
+    if (schema instanceof z.ZodUnion) {
+      // This schema corresponds to `anyOf` in JSON Schema.
+      // We recursively sanitize each option in the union.
+      const sanitizedOptions = schema.options.map((option: z.ZodTypeAny) => sanitizeGeminiParameters(option, visited))
+      return z.union(sanitizedOptions as [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]])
+    }
+
+    if (schema instanceof z.ZodString) {
+      const newSchema = z.string({ description: schema.description })
+      const safeChecks = ["min", "max", "length", "regex", "startsWith", "endsWith", "includes", "trim"]
+      // rome-ignore lint/suspicious/noExplicitAny: <explanation>
+      ;(newSchema._def as any).checks = (schema._def as z.ZodStringDef).checks.filter((check) =>
+        safeChecks.includes(check.kind),
+      )
+      return newSchema
+    }
+
+    return schema
+  }
+
+  function optionalToNullable(schema: z.ZodTypeAny): z.ZodTypeAny {
+    if (schema instanceof z.ZodObject) {
+      const shape = schema.shape
+      const newShape: Record<string, z.ZodTypeAny> = {}
+
+      for (const [key, value] of Object.entries(shape)) {
+        const zodValue = value as z.ZodTypeAny
+        if (zodValue instanceof z.ZodOptional) {
+          newShape[key] = zodValue.unwrap().nullable()
+        } else {
+          newShape[key] = optionalToNullable(zodValue)
+        }
+      }
+
+      return z.object(newShape)
+    }
+
+    if (schema instanceof z.ZodArray) {
+      return z.array(optionalToNullable(schema.element))
+    }
+
+    if (schema instanceof z.ZodUnion) {
+      return z.union(
+        schema.options.map((option: z.ZodTypeAny) => optionalToNullable(option)) as [
+          z.ZodTypeAny,
+          z.ZodTypeAny,
+          ...z.ZodTypeAny[],
+        ],
+      )
+    }
+
+    return schema
+  }
+}

packages/opencode/src/tool/task.ts

@@ -7,11 +7,10 @@ import { MessageV2 } from "../session/message-v2"
 import { Identifier } from "../id/id"
 import { Agent } from "../agent/agent"
 
-export const TaskTool = Tool.define(async () => {
+export const TaskTool = Tool.define("task", async () => {
   const agents = await Agent.list()
   const description = DESCRIPTION.replace("{agents}", agents.map((a) => `- ${a.name}: ${a.description}`).join("\n"))
   return {
-    id: "task",
     description,
     parameters: z.object({
       description: z.string().describe("A short (3-5 words) description of the task"),
@@ -53,7 +52,10 @@ export const TaskTool = Tool.define(async () => {
         providerID: model.providerID,
         mode: msg.mode,
         system: agent.prompt,
-        tools: agent.tools,
+        tools: {
+          ...agent.tools,
+          task: false,
+        },
         parts: [
           {
             id: Identifier.ascending("part"),

packages/opencode/src/tool/todo.ts

@@ -18,8 +18,7 @@ const state = App.state("todo-tool", () => {
   return todos
 })
 
-export const TodoWriteTool = Tool.define({
-  id: "todowrite",
+export const TodoWriteTool = Tool.define("todowrite", {
   description: DESCRIPTION_WRITE,
   parameters: z.object({
     todos: z.array(TodoInfo).describe("The updated todo list"),
@@ -37,8 +36,7 @@ export const TodoWriteTool = Tool.define({
   },
 })
 
-export const TodoReadTool = Tool.define({
-  id: "todoread",
+export const TodoReadTool = Tool.define("todoread", {
   description: "Use this tool to read your todo list",
   parameters: z.object({}),
   async execute(_params, opts) {

packages/opencode/src/tool/tool.ts

@@ -12,21 +12,30 @@ export namespace Tool {
   }
   export interface Info<Parameters extends StandardSchemaV1 = StandardSchemaV1, M extends Metadata = Metadata> {
     id: string
-    description: string
-    parameters: Parameters
-    execute(
-      args: StandardSchemaV1.InferOutput<Parameters>,
-      ctx: Context,
-    ): Promise<{
-      title: string
-      metadata: M
-      output: string
+    init: () => Promise<{
+      description: string
+      parameters: Parameters
+      execute(
+        args: StandardSchemaV1.InferOutput<Parameters>,
+        ctx: Context,
+      ): Promise<{
+        title: string
+        metadata: M
+        output: string
+      }>
     }>
   }
 
   export function define<Parameters extends StandardSchemaV1, Result extends Metadata>(
-    input: Info<Parameters, Result> | (() => Promise<Info<Parameters, Result>>),
-  ): () => Promise<Info<Parameters, Result>> {
-    return input instanceof Function ? input : async () => input
+    id: string,
+    init: Info<Parameters, Result>["init"] | Awaited<ReturnType<Info<Parameters, Result>["init"]>>,
+  ): Info<Parameters, Result> {
+    return {
+      id,
+      init: async () => {
+        if (init instanceof Function) return init()
+        return init
+      },
+    }
   }
 }

packages/opencode/src/tool/webfetch.ts

@@ -7,8 +7,7 @@ const MAX_RESPONSE_SIZE = 5 * 1024 * 1024 // 5MB
 const DEFAULT_TIMEOUT = 30 * 1000 // 30 seconds
 const MAX_TIMEOUT = 120 * 1000 // 2 minutes
 
-export const WebFetchTool = Tool.define({
-  id: "webfetch",
+export const WebFetchTool = Tool.define("webfetch", {
   description: DESCRIPTION,
   parameters: z.object({
     url: z.string().describe("The URL to fetch content from"),

packages/opencode/src/tool/write.ts

@@ -9,8 +9,7 @@ import { Bus } from "../bus"
 import { File } from "../file"
 import { FileTime } from "../file/time"
 
-export const WriteTool = Tool.define({
-  id: "write",
+export const WriteTool = Tool.define("write", {
   description: DESCRIPTION,
   parameters: z.object({
     filePath: z.string().describe("The absolute path to the file to write (must be absolute, not relative)"),

packages/opencode/src/util/filesystem.ts

@@ -51,6 +51,7 @@ export namespace Filesystem {
           cwd: current,
           absolute: true,
           onlyFiles: true,
+          followSymlinks: true,
           dot: true,
         })) {
           result.push(match)

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

@@ -9,8 +9,8 @@ const ctx = {
   abort: AbortSignal.any([]),
   metadata: () => {},
 }
-const glob = await GlobTool()
-const list = await ListTool()
+const glob = await GlobTool.init()
+const list = await ListTool.init()
 
 describe("tool.glob", () => {
   test("truncate", async () => {

packages/tui/internal/components/chat/message.go

@@ -553,10 +553,18 @@ func renderToolTitle(
 		if filename, ok := toolArgsMap["filePath"].(string); ok {
 			title = fmt.Sprintf("%s %s", title, util.Relative(filename))
 		}
-	case "bash", "task":
+	case "bash":
 		if description, ok := toolArgsMap["description"].(string); ok {
 			title = fmt.Sprintf("%s %s", title, description)
 		}
+	case "task":
+		description := toolArgsMap["description"]
+		subagent := toolArgsMap["subagent_type"]
+		if description != nil && subagent != nil {
+			title = fmt.Sprintf("%s[%s] %s", title, subagent, description)
+		} else if description != nil {
+			title = fmt.Sprintf("%s %s", title, description)
+		}
 	case "webfetch":
 		toolArgs = renderArgs(&toolArgsMap, "url")
 		title = fmt.Sprintf("%s %s", title, toolArgs)
@@ -576,7 +584,7 @@ func renderToolTitle(
 func renderToolAction(name string) string {
 	switch name {
 	case "task":
-		return "Planning..."
+		return "Delegating..."
 	case "bash":
 		return "Writing command..."
 	case "edit":

packages/tui/internal/components/chat/messages.go

@@ -670,15 +670,21 @@ func (m *messagesComponent) renderHeader() string {
 	isSubscriptionModel := m.app.Model != nil &&
 		m.app.Model.Cost.Input == 0 && m.app.Model.Cost.Output == 0
 
+	sessionInfoText := formatTokensAndCost(tokens, contextWindow, cost, isSubscriptionModel)
 	sessionInfo = styles.NewStyle().
 		Foreground(t.TextMuted()).
 		Background(t.Background()).
-		Render(formatTokensAndCost(tokens, contextWindow, cost, isSubscriptionModel))
+		Render(sessionInfoText)
 
 	shareEnabled := m.app.Config.Share != opencode.ConfigShareDisabled
+	headerTextWidth := headerWidth
+	if !shareEnabled {
+		// +1 is to ensure there is always at least one space between header and session info
+		headerTextWidth -= len(sessionInfoText) + 1
+	}
 	headerText := util.ToMarkdown(
 		"# "+m.app.Session.Title,
-		headerWidth,
+		headerTextWidth,
 		t.Background(),
 	)
 
@@ -705,11 +711,9 @@ func (m *messagesComponent) renderHeader() string {
 		items...,
 	)
 
-	var headerLines []string
+	headerLines := []string{headerRow}
 	if shareEnabled {
 		headerLines = []string{headerText, headerRow}
-	} else {
-		headerLines = []string{headerRow}
 	}
 
 	header := strings.Join(headerLines, "\n")