fix(hooks): prevent session_complete hook from firing on subagent sessions (#1149)

Co-authored-by: opencode-agent[bot] <opencode-agent[bot]@users.noreply.github.com>
Co-authored-by: thdxr <thdxr@users.noreply.github.com>

.github/workflows/notify-discord.yml

@@ -0,0 +1,14 @@
+name: discord
+
+on:
+  release:
+    types: [published]   # fires only when a release is published
+
+jobs:
+  notify:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Send nicely-formatted embed to Discord
+        uses: SethCohen/github-releases-to-discord@v1
+        with:
+          webhook_url: ${{ secrets.DISCORD_WEBHOOK }}

.github/workflows/opencode.yml

@@ -17,8 +17,7 @@ jobs:
           fetch-depth: 1
 
       - name: Run opencode
-        uses: sst/opencode/sdks/github@dev
+        uses: sst/opencode/sdks/github@github-v1
-        #uses: ./github-actions
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
         with:

.github/workflows/publish-github-action.yml

@@ -0,0 +1,29 @@
+name: publish-github-action
+
+on:
+  workflow_dispatch:
+
+concurrency: ${{ github.workflow }}-${{ github.ref }}
+
+permissions:
+  contents: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - run: git fetch --force --tags
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: 1.2.17
+
+      - name: Publish
+        run: |
+          git config --global user.email "opencode@sst.dev"
+          git config --global user.name "opencode"
+          ./scripts/publish-github-action.ts

README.md

@@ -30,7 +30,23 @@ brew install sst/tap/opencode      # macOS
 paru -S opencode-bin               # Arch Linux
 ```
 
-> **Note:** Remove versions older than 0.1.x before installing
+> [!TIP]
+> Remove versions older than 0.1.x before installing.
+
+#### Installation Directory
+
+The install script respects the following priority order for the installation path:
+
+1. `$OPENCODE_INSTALL_DIR` - Custom installation directory
+2. `$XDG_BIN_DIR` - XDG Base Directory Specification compliant path
+3. `$HOME/bin` - Standard user binary directory (if exists or can be created)
+4. `$HOME/.opencode/bin` - Default fallback
+
+```bash
+# Examples
+OPENCODE_INSTALL_DIR=/usr/local/bin curl -fsSL https://opencode.ai/install | bash
+XDG_BIN_DIR=$HOME/.local/bin curl -fsSL https://opencode.ai/install | bash
+```
 
 ### Documentation
 
@@ -38,24 +54,25 @@ For more info on how to configure opencode [**head over to our docs**](https://o
 
 ### Contributing
 
-WE DO NOT ACCEPT PRs FOR CORE FEATURES
-
 opencode is an opinionated tool so any fundamental feature needs to go through a
 design process with the core team.
 
+> [!IMPORTANT]
+> We do not accept PRs for core features.
+
 However we still merge a ton of PRs - you can contribute:
 
-- bug fixes
+- Bug fixes
-- improvements to LLM performance
+- Improvements to LLM performance
-- support for new providers
+- Support for new providers
-- fixes for env specific quirks
+- Fixes for env specific quirks
-- missing standard behavior
+- Missing standard behavior
-- documentation
+- Documentation
 
 Take a look at the git history to see what kind of PRs we end up merging.
 
-> **Note**: If you do not follow the above guidelines we might close your PR
+> [!NOTE]
-> that you worked really hard on.
+> If you do not follow the above guidelines we might close your PR.
 
 To run opencode locally you need.
 

STATS.md

@@ -1,18 +1,24 @@
 # Download Stats
 
-| Date       | GitHub Downloads | npm Downloads   | Total             |
+| Date       | GitHub Downloads | npm Downloads    | Total             |
-| ---------- | ---------------- | --------------- | ----------------- |
+| ---------- | ---------------- | ---------------- | ----------------- |
-| 2025-06-29 | 18,789 (+0)      | 39,420 (+0)     | 58,209 (+0)       |
+| 2025-06-29 | 18,789 (+0)      | 39,420 (+0)      | 58,209 (+0)       |
-| 2025-06-30 | 20,127 (+1,338)  | 41,059 (+1,639) | 61,186 (+2,977)   |
+| 2025-06-30 | 20,127 (+1,338)  | 41,059 (+1,639)  | 61,186 (+2,977)   |
-| 2025-07-01 | 22,108 (+1,981)  | 43,745 (+2,686) | 65,853 (+4,667)   |
+| 2025-07-01 | 22,108 (+1,981)  | 43,745 (+2,686)  | 65,853 (+4,667)   |
-| 2025-07-02 | 24,814 (+2,706)  | 46,168 (+2,423) | 70,982 (+5,129)   |
+| 2025-07-02 | 24,814 (+2,706)  | 46,168 (+2,423)  | 70,982 (+5,129)   |
-| 2025-07-03 | 27,834 (+3,020)  | 49,955 (+3,787) | 77,789 (+6,807)   |
+| 2025-07-03 | 27,834 (+3,020)  | 49,955 (+3,787)  | 77,789 (+6,807)   |
-| 2025-07-04 | 30,608 (+2,774)  | 54,758 (+4,803) | 85,366 (+7,577)   |
+| 2025-07-04 | 30,608 (+2,774)  | 54,758 (+4,803)  | 85,366 (+7,577)   |
-| 2025-07-05 | 32,524 (+1,916)  | 58,371 (+3,613) | 90,895 (+5,529)   |
+| 2025-07-05 | 32,524 (+1,916)  | 58,371 (+3,613)  | 90,895 (+5,529)   |
-| 2025-07-06 | 33,766 (+1,242)  | 59,694 (+1,323) | 93,460 (+2,565)   |
+| 2025-07-06 | 33,766 (+1,242)  | 59,694 (+1,323)  | 93,460 (+2,565)   |
-| 2025-07-08 | 38,052 (+4,286)  | 64,468 (+4,774) | 102,520 (+9,060)  |
+| 2025-07-08 | 38,052 (+4,286)  | 64,468 (+4,774)  | 102,520 (+9,060)  |
-| 2025-07-10 | 43,796 (+5,744)  | 71,402 (+6,934) | 115,198 (+12,678) |
+| 2025-07-10 | 43,796 (+5,744)  | 71,402 (+6,934)  | 115,198 (+12,678) |
-| 2025-07-11 | 46,982 (+3,186)  | 77,462 (+6,060) | 124,444 (+9,246)  |
+| 2025-07-11 | 46,982 (+3,186)  | 77,462 (+6,060)  | 124,444 (+9,246)  |
-| 2025-07-12 | 49,302 (+2,320)  | 82,177 (+4,715) | 131,479 (+7,035)  |
+| 2025-07-12 | 49,302 (+2,320)  | 82,177 (+4,715)  | 131,479 (+7,035)  |
-| 2025-07-13 | 50,803 (+1,501)  | 86,394 (+4,217) | 137,197 (+5,718)  |
+| 2025-07-13 | 50,803 (+1,501)  | 86,394 (+4,217)  | 137,197 (+5,718)  |
-| 2025-07-14 | 53,283 (+2,480)  | 87,860 (+1,466) | 141,143 (+3,946)  |
+| 2025-07-14 | 53,283 (+2,480)  | 87,860 (+1,466)  | 141,143 (+3,946)  |
+| 2025-07-15 | 57,590 (+4,307)  | 91,036 (+3,176)  | 148,626 (+7,483)  |
+| 2025-07-16 | 62,313 (+4,723)  | 95,258 (+4,222)  | 157,571 (+8,945)  |
+| 2025-07-17 | 66,684 (+4,371)  | 100,048 (+4,790) | 166,732 (+9,161)  |
+| 2025-07-18 | 70,379 (+3,695)  | 102,587 (+2,539) | 172,966 (+6,234)  |
+| 2025-07-18 | 70,380 (+1)      | 102,587 (+0)     | 172,967 (+1)      |
+| 2025-07-19 | 73,497 (+3,117)  | 105,904 (+3,317) | 179,401 (+6,434)  |

install

@@ -186,4 +186,3 @@ if [ -n "${GITHUB_ACTIONS-}" ] && [ "${GITHUB_ACTIONS}" == "true" ]; then
     echo "$INSTALL_DIR" >> $GITHUB_PATH
     print_message info "Added $INSTALL_DIR to \$GITHUB_PATH"
 fi
-

opencode.json

@@ -1,5 +1,19 @@
 {
   "$schema": "https://opencode.ai/config.json",
+  "provider": {
+    "openrouter": {
+      "models": {
+        "moonshotai/kimi-k2": {
+          "options": {
+            "provider": {
+              "order": ["baseten"],
+              "allow_fallbacks": false
+            }
+          }
+        }
+      }
+    }
+  },
   "mcp": {
     "weather": {
       "type": "local",

package.json

@@ -18,7 +18,7 @@
       "typescript": "5.8.2",
       "@types/node": "22.13.9",
       "zod": "3.25.49",
-      "ai": "5.0.0-beta.15"
+      "ai": "5.0.0-beta.21"
     }
   },
   "devDependencies": {
@@ -39,7 +39,5 @@
     "protobufjs",
     "sharp"
   ],
-  "patchedDependencies": {
+  "patchedDependencies": {}
-    "ai@4.3.16": "patches/ai@4.3.16.patch"
-  }
 }

packages/function/src/api.ts

@@ -232,6 +232,9 @@ export default {
       )
     }
 
+    /**
+     * Used by the GitHub action to get GitHub installation access token given the OIDC token
+     */
     if (request.method === "POST" && method === "exchange_github_app_token") {
       const EXPECTED_AUDIENCE = "opencode-github-action"
       const GITHUB_ISSUER = "https://token.actions.githubusercontent.com"
@@ -285,6 +288,38 @@ export default {
       })
     }
 
+    /**
+     * Used by the opencode CLI to check if the GitHub app is installed
+     */
+    if (request.method === "GET" && method === "get_github_app_installation") {
+      const owner = url.searchParams.get("owner")
+      const repo = url.searchParams.get("repo")
+
+      const auth = createAppAuth({
+        appId: Resource.GITHUB_APP_ID.value,
+        privateKey: Resource.GITHUB_APP_PRIVATE_KEY.value,
+      })
+      const appAuth = await auth({ type: "app" })
+
+      // Lookup installation
+      const octokit = new Octokit({ auth: appAuth.token })
+      let installation
+      try {
+        const ret = await octokit.apps.getRepoInstallation({ owner, repo })
+        installation = ret.data
+      } catch (err) {
+        if (err instanceof Error && err.message.includes("Not Found")) {
+          // not installed
+        } else {
+          throw err
+        }
+      }
+
+      return new Response(JSON.stringify({ installation }), {
+        headers: { "Content-Type": "application/json" },
+      })
+    }
+
     return new Response("Not Found", { status: 404 })
   },
 }

packages/opencode/package.json

@@ -17,15 +17,18 @@
   "devDependencies": {
     "@ai-sdk/amazon-bedrock": "2.2.10",
     "@ai-sdk/anthropic": "1.2.12",
+    "@standard-schema/spec": "1.0.0",
     "@tsconfig/bun": "1.0.7",
     "@types/bun": "latest",
     "@types/turndown": "5.0.5",
     "@types/yargs": "17.0.33",
     "typescript": "catalog:",
+    "vscode-languageserver-types": "3.17.5",
     "zod-to-json-schema": "3.24.5"
   },
   "dependencies": {
     "@clack/prompts": "0.11.0",
+    "@hono/zod-validator": "0.4.2",
     "@modelcontextprotocol/sdk": "1.15.1",
     "@openauthjs/openauth": "0.4.3",
     "ai": "catalog:",
@@ -40,6 +43,7 @@
     "vscode-jsonrpc": "8.2.1",
     "xdg-basedir": "5.1.0",
     "yargs": "18.0.0",
-    "zod": "catalog:"
+    "zod": "catalog:",
+    "zod-openapi": "4.1.0"
   }
 }

packages/opencode/script/publish.ts

@@ -152,6 +152,7 @@ if (!snapshot) {
   for (const pkg of ["opencode", "opencode-bin"]) {
     await $`rm -rf ./dist/aur-${pkg}`
     await $`git clone ssh://aur@aur.archlinux.org/${pkg}.git ./dist/aur-${pkg}`
+    await $`cd ./dist/aur-${pkg} && git checkout master`
     await Bun.file(`./dist/aur-${pkg}/PKGBUILD`).write(pkgbuild.replace("${pkg}", pkg))
     await $`cd ./dist/aur-${pkg} && makepkg --printsrcinfo > .SRCINFO`
     await $`cd ./dist/aur-${pkg} && git add PKGBUILD .SRCINFO`

packages/opencode/src/auth/copilot.ts

@@ -4,11 +4,12 @@ import path from "path"
 
 export const AuthCopilot = lazy(async () => {
   const file = Bun.file(path.join(Global.Path.state, "plugin", "copilot.ts"))
+  const exists = await file.exists()
   const response = fetch("https://raw.githubusercontent.com/sst/opencode-github-copilot/refs/heads/main/auth.ts")
     .then((x) => Bun.write(file, x))
     .catch(() => {})
 
-  if (!file.exists()) {
+  if (!exists) {
     const worked = await response
     if (!worked) return
   }

packages/opencode/src/bun/index.ts

@@ -66,20 +66,18 @@ export namespace BunProc {
       return result
     })
     if (parsed.dependencies[pkg] === version) return mod
-    await BunProc.run(
+
-      [
+    // Build command arguments
-        "add",
+    const args = ["add", "--force", "--exact", "--cwd", Global.Path.cache, pkg + "@" + version]
-        "--force",
+
-        "--exact",
+    // Let Bun handle registry resolution:
-        "--cwd",
+    // - If .npmrc files exist, Bun will use them automatically
-        Global.Path.cache,
+    // - If no .npmrc files exist, Bun will default to https://registry.npmjs.org
-        "--registry=https://registry.npmjs.org",
+    log.info("installing package using Bun's default registry resolution", { pkg, version })
-        pkg + "@" + version,
+
-      ],
+    await BunProc.run(args, {
-      {
+      cwd: Global.Path.cache,
-        cwd: Global.Path.cache,
+    }).catch((e) => {
-      },
-    ).catch((e) => {
       throw new InstallFailedError(
         { pkg, version },
         {

packages/opencode/src/cli/cmd/auth.ts

@@ -78,6 +78,8 @@ export const AuthLoginCommand = cmd({
       "github-copilot": 1,
       openai: 2,
       google: 3,
+      openrouter: 4,
+      vercel: 5,
     }
     let provider = await prompts.select({
       message: "Select provider",
@@ -108,7 +110,7 @@ export const AuthLoginCommand = cmd({
     if (provider === "other") {
       provider = await prompts.text({
         message: "Enter provider id",
-        validate: (x) => (x.match(/^[a-z-]+$/) ? undefined : "a-z and hyphens only"),
+        validate: (x) => (x.match(/^[0-9a-z-]+$/) ? undefined : "a-z, 0-9 and hyphens only"),
       })
       if (prompts.isCancel(provider)) throw new UI.CancelledError()
       provider = provider.replace(/^@ai-sdk\//, "")
@@ -120,7 +122,7 @@ export const AuthLoginCommand = cmd({
 
     if (provider === "amazon-bedrock") {
       prompts.log.info(
-        "Amazon bedrock can be configured with standard AWS environment variables like AWS_PROFILE or AWS_ACCESS_KEY_ID",
+        "Amazon bedrock can be configured with standard AWS environment variables like AWS_BEARER_TOKEN_BEDROCK, AWS_PROFILE or AWS_ACCESS_KEY_ID",
       )
       prompts.outro("Done")
       return
@@ -265,6 +267,10 @@ export const AuthLoginCommand = cmd({
       return
     }
 
+    if (provider === "vercel") {
+      prompts.log.info("You can create an api key in the dashboard")
+    }
+
     const key = await prompts.password({
       message: "Enter your API key",
       validate: (x) => (x.length > 0 ? undefined : "Required"),

packages/opencode/src/cli/cmd/install-github.ts

@@ -0,0 +1,235 @@
+import { $ } from "bun"
+import path from "path"
+import { exec } from "child_process"
+import * as prompts from "@clack/prompts"
+import { map, pipe, sortBy, values } from "remeda"
+import { UI } from "../ui"
+import { cmd } from "./cmd"
+import { ModelsDev } from "../../provider/models"
+import { App } from "../../app/app"
+
+const WORKFLOW_FILE = ".github/workflows/opencode.yml"
+
+export const InstallGithubCommand = cmd({
+  command: "install-github",
+  describe: "install the GitHub agent",
+  async handler() {
+    await App.provide({ cwd: process.cwd() }, async () => {
+      UI.empty()
+      prompts.intro("Install GitHub agent")
+      const app = await getAppInfo()
+      await installGitHubApp()
+
+      const providers = await ModelsDev.get()
+      const provider = await promptProvider()
+      const model = await promptModel()
+      //const key = await promptKey()
+
+      await addWorkflowFiles()
+      printNextSteps()
+
+      function printNextSteps() {
+        let step2
+        if (provider === "amazon-bedrock") {
+          step2 =
+            "Configure OIDC in AWS - https://docs.github.com/en/actions/how-tos/security-for-github-actions/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services"
+        } else {
+          const url = `https://github.com/organizations/${app.owner}/settings/secrets/actions`
+          const env = providers[provider].env
+          const envStr =
+            env.length === 1
+              ? `\`${env[0]}\` secret`
+              : `\`${[env.slice(0, -1).join("\`, \`"), ...env.slice(-1)].join("\` and \`")}\` secrets`
+          step2 = `Add ${envStr} for ${providers[provider].name} - ${url}`
+        }
+
+        prompts.outro(
+          [
+            "Next steps:",
+            `    1. Commit "${WORKFLOW_FILE}" file and push`,
+            `    2. ${step2}`,
+            "    3. Learn how to use the GitHub agent - https://docs.opencode.ai/docs/github/getting-started",
+          ].join("\n"),
+        )
+      }
+
+      async function getAppInfo() {
+        const app = App.info()
+        if (!app.git) {
+          prompts.log.error(`Could not find git repository. Please run this command from a git repository.`)
+          throw new UI.CancelledError()
+        }
+
+        // Get repo info
+        const info = await $`git remote get-url origin`.quiet().nothrow().text()
+        // match https or git pattern
+        // ie. https://github.com/sst/opencode.git
+        // ie. git@github.com:sst/opencode.git
+        const parsed = info.match(/git@github\.com:(.*)\.git/) ?? info.match(/github\.com\/(.*)\.git/)
+        if (!parsed) {
+          prompts.log.error(`Could not find git repository. Please run this command from a git repository.`)
+          throw new UI.CancelledError()
+        }
+        const [owner, repo] = parsed[1].split("/")
+        return { owner, repo, root: app.path.root }
+      }
+
+      async function promptProvider() {
+        const priority: Record<string, number> = {
+          anthropic: 0,
+          "github-copilot": 1,
+          openai: 2,
+          google: 3,
+        }
+        let provider = await prompts.select({
+          message: "Select provider",
+          maxItems: 8,
+          options: [
+            ...pipe(
+              providers,
+              values(),
+              sortBy(
+                (x) => priority[x.id] ?? 99,
+                (x) => x.name ?? x.id,
+              ),
+              map((x) => ({
+                label: x.name,
+                value: x.id,
+                hint: priority[x.id] === 0 ? "recommended" : undefined,
+              })),
+            ),
+            {
+              value: "other",
+              label: "Other",
+            },
+          ],
+        })
+
+        if (prompts.isCancel(provider)) throw new UI.CancelledError()
+        if (provider === "other") {
+          provider = await prompts.text({
+            message: "Enter provider id",
+            validate: (x) => (x.match(/^[a-z-]+$/) ? undefined : "a-z and hyphens only"),
+          })
+          if (prompts.isCancel(provider)) throw new UI.CancelledError()
+          provider = provider.replace(/^@ai-sdk\//, "")
+          if (prompts.isCancel(provider)) throw new UI.CancelledError()
+          prompts.log.warn(
+            `This only stores a credential for ${provider} - you will need configure it in opencode.json, check the docs for examples.`,
+          )
+        }
+
+        return provider
+      }
+
+      async function promptModel() {
+        const providerData = providers[provider]!
+
+        const model = await prompts.select({
+          message: "Select model",
+          maxItems: 8,
+          options: pipe(
+            providerData.models,
+            values(),
+            sortBy((x) => x.name ?? x.id),
+            map((x) => ({
+              label: x.name ?? x.id,
+              value: x.id,
+            })),
+          ),
+        })
+
+        if (prompts.isCancel(model)) throw new UI.CancelledError()
+        return model
+      }
+
+      async function installGitHubApp() {
+        const s = prompts.spinner()
+        s.start("Installing GitHub app")
+
+        // Get installation
+        const installation = await getInstallation()
+        if (installation) return s.stop("GitHub app already installed")
+
+        // Open browser
+        const url = "https://github.com/apps/opencode-agent"
+        const command =
+          process.platform === "darwin"
+            ? `open "${url}"`
+            : process.platform === "win32"
+              ? `start "${url}"`
+              : `xdg-open "${url}"`
+
+        exec(command, (error) => {
+          if (error) {
+            prompts.log.warn(`Could not open browser. Please visit: ${url}`)
+          }
+        })
+
+        // Wait for installation
+        s.message("Waiting for GitHub app to be installed")
+        const MAX_RETRIES = 60
+        let retries = 0
+        do {
+          const installation = await getInstallation()
+          if (installation) break
+
+          if (retries > MAX_RETRIES) {
+            s.stop(
+              `Failed to detect GitHub app installation. Make sure to install the app for the \`${app.owner}/${app.repo}\` repository.`,
+            )
+            throw new UI.CancelledError()
+          }
+
+          retries++
+          await new Promise((resolve) => setTimeout(resolve, 1000))
+        } while (true)
+
+        s.stop("Installed GitHub app")
+
+        async function getInstallation() {
+          return await fetch(`https://api.opencode.ai/get_github_app_installation?owner=${app.owner}&repo=${app.repo}`)
+            .then((res) => res.json())
+            .then((data) => data.installation)
+        }
+      }
+
+      async function addWorkflowFiles() {
+        const envStr =
+          provider === "amazon-bedrock"
+            ? ""
+            : `\n        env:${providers[provider].env.map((e) => `\n          ${e}: \${{ secrets.${e} }}`).join("")}`
+
+        await Bun.write(
+          path.join(app.root, WORKFLOW_FILE),
+          `
+name: opencode
+
+on:
+  issue_comment:
+    types: [created]
+
+jobs:
+  opencode:
+    if: startsWith(github.event.comment.body, 'hey opencode')
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run opencode
+        uses: sst/opencode/sdks/github@github-v1${envStr}
+        with:
+          model: ${provider}/${model}
+`.trim(),
+        )
+
+        prompts.log.success(`Added workflow file: "${WORKFLOW_FILE}"`)
+      }
+    })
+  },
+})

packages/opencode/src/cli/cmd/run.ts

@@ -124,7 +124,9 @@ export const RunCommand = cmd({
 
         if (part.type === "tool" && part.state.status === "completed") {
           const [tool, color] = TOOL[part.tool] ?? [part.tool, UI.Style.TEXT_INFO_BOLD]
-          printEvent(color, tool, part.state.title || "Unknown")
+          const title =
+            part.state.title || Object.keys(part.state.input).length > 0 ? JSON.stringify(part.state.input) : "Unknown"
+          printEvent(color, tool, title)
         }
 
         if (part.type === "text") {
@@ -170,8 +172,6 @@ export const RunCommand = cmd({
         parts: [
           {
             id: Identifier.ascending("part"),
-            sessionID: session.id,
-            messageID: messageID,
             type: "text",
             text: message,
           },

packages/opencode/src/config/config.ts

@@ -57,6 +57,7 @@ export namespace Config {
       type: z.literal("remote").describe("Type of MCP server connection"),
       url: z.string().describe("URL of the remote MCP server"),
       enabled: z.boolean().optional().describe("Enable or disable the MCP server on startup"),
+      headers: z.record(z.string(), z.string()).optional().describe("Headers to send with the request"),
     })
     .strict()
     .openapi({
@@ -81,8 +82,10 @@ export namespace Config {
     .object({
       leader: z.string().optional().default("ctrl+x").describe("Leader key for keybind combinations"),
       app_help: z.string().optional().default("<leader>h").describe("Show help dialog"),
-      switch_mode: z.string().optional().default("tab").describe("Switch mode"),
+      switch_mode: z.string().optional().default("tab").describe("Next mode"),
+      switch_mode_reverse: z.string().optional().default("shift+tab").describe("Previous Mode"),
       editor_open: z.string().optional().default("<leader>e").describe("Open external editor"),
+      session_export: z.string().optional().default("<leader>x").describe("Export session to editor"),
       session_new: z.string().optional().default("<leader>n").describe("Create a new session"),
       session_list: z.string().optional().default("<leader>l").describe("List all sessions"),
       session_share: z.string().optional().default("<leader>s").describe("Share current session"),
@@ -123,15 +126,22 @@ export namespace Config {
       ref: "KeybindsConfig",
     })
 
+  export const Layout = z.enum(["auto", "stretch"]).openapi({
+    ref: "LayoutConfig",
+  })
+  export type Layout = z.infer<typeof Layout>
+
   export const Info = z
     .object({
       $schema: z.string().optional().describe("JSON schema reference for configuration validation"),
       theme: z.string().optional().describe("Theme name to use for the interface"),
       keybinds: Keybinds.optional().describe("Custom keybind configurations"),
       share: z
-        .enum(["auto", "disabled"])
+        .enum(["manual", "auto", "disabled"])
         .optional()
-        .describe("Control sharing behavior: 'auto' enables automatic sharing, 'disabled' disables all sharing"),
+        .describe(
+          "Control sharing behavior:'manual' allows manual sharing via commands, 'auto' enables automatic sharing, 'disabled' disables all sharing",
+        ),
       autoshare: z
         .boolean()
         .optional()
@@ -139,6 +149,12 @@ export namespace Config {
       autoupdate: z.boolean().optional().describe("Automatically update to the latest version"),
       disabled_providers: z.array(z.string()).optional().describe("Disable providers that are loaded automatically"),
       model: z.string().describe("Model to use in the format of provider/model, eg anthropic/claude-2").optional(),
+      small_model: z
+        .string()
+        .describe(
+          "Small model to use for tasks like summarization and title generation in the format of provider/model",
+        )
+        .optional(),
       username: z
         .string()
         .optional()
@@ -149,8 +165,8 @@ export namespace Config {
           plan: Mode.optional(),
         })
         .catchall(Mode)
-        .optional(),
+        .optional()
-      log_level: Log.Level.optional().describe("Minimum log level to write to log files"),
+        .describe("Modes configuration, see https://opencode.ai/docs/modes"),
       provider: z
         .record(
           ModelsDev.Provider.partial().extend({
@@ -162,6 +178,7 @@ export namespace Config {
         .describe("Custom provider configurations and model overrides"),
       mcp: z.record(z.string(), Mcp).optional().describe("MCP (Model Context Protocol) server configurations"),
       instructions: z.array(z.string()).optional().describe("Additional instruction files or patterns to include"),
+      layout: Layout.optional().describe("@deprecated Always uses stretch layout."),
       experimental: z
         .object({
           hook: z

packages/opencode/src/config/hooks.ts

@@ -31,9 +31,13 @@ export namespace ConfigHooks {
       }
     })
 
-    Bus.subscribe(Session.Event.Idle, async () => {
+    Bus.subscribe(Session.Event.Idle, async (payload) => {
       const cfg = await Config.get()
       if (cfg.experimental?.hook?.session_completed) {
+        const session = await Session.get(payload.properties.sessionID)
+        // Only fire hook for top-level sessions (not subagent sessions)
+        if (session.parentID) return
+
         for (const item of cfg.experimental.hook.session_completed) {
           log.info("session_completed", {
             command: item.command,

packages/opencode/src/format/formatter.ts

@@ -105,7 +105,29 @@ export const ruff: Info = {
   command: ["ruff", "format", "$FILE"],
   extensions: [".py", ".pyi"],
   async enabled() {
-    return Bun.which("ruff") !== null
+    if (!Bun.which("ruff")) return false
+    const app = App.info()
+    const configs = ["pyproject.toml", "ruff.toml", ".ruff.toml"]
+    for (const config of configs) {
+      const found = await Filesystem.findUp(config, app.path.cwd, app.path.root)
+      if (found.length > 0) {
+        if (config === "pyproject.toml") {
+          const content = await Bun.file(found[0]).text()
+          if (content.includes("[tool.ruff]")) return true
+        } else {
+          return true
+        }
+      }
+    }
+    const deps = ["requirements.txt", "pyproject.toml", "Pipfile"]
+    for (const dep of deps) {
+      const found = await Filesystem.findUp(dep, app.path.cwd, app.path.root)
+      if (found.length > 0) {
+        const content = await Bun.file(found[0]).text()
+        if (content.includes("ruff")) return true
+      }
+    }
+    return false
   },
 }
 

packages/opencode/src/global/index.ts

@@ -27,7 +27,7 @@ await Promise.all([
   fs.mkdir(Global.Path.state, { recursive: true }),
 ])
 
-const CACHE_VERSION = "2"
+const CACHE_VERSION = "3"
 
 const version = await Bun.file(path.join(Global.Path.cache, "version"))
   .text()

packages/opencode/src/index.ts

@@ -16,6 +16,10 @@ import { TuiCommand } from "./cli/cmd/tui"
 import { DebugCommand } from "./cli/cmd/debug"
 import { StatsCommand } from "./cli/cmd/stats"
 import { McpCommand } from "./cli/cmd/mcp"
+import { InstallGithubCommand } from "./cli/cmd/install-github"
+import { Trace } from "./trace"
+
+Trace.init()
 
 const cancel = new AbortController()
 
@@ -40,25 +44,21 @@ const cli = yargs(hideBin(process.argv))
     describe: "print logs to stderr",
     type: "boolean",
   })
-  .middleware(async () => {
+  .option("log-level", {
-    await Log.init({ print: process.argv.includes("--print-logs") })
+    describe: "log level",
-
+    type: "string",
-    try {
+    choices: ["DEBUG", "INFO", "WARN", "ERROR"],
-      const { Config } = await import("./config/config")
+  })
-      const { App } = await import("./app/app")
+  .middleware(async (opts) => {
-
+    await Log.init({
-      App.provide({ cwd: process.cwd() }, async () => {
+      print: process.argv.includes("--print-logs"),
-        const cfg = await Config.get()
+      dev: Installation.isDev(),
-        if (cfg.log_level) {
+      level: (() => {
-          Log.setLevel(cfg.log_level as Log.Level)
+        if (opts.logLevel) return opts.logLevel as Log.Level
-        } else {
+        if (Installation.isDev()) return "DEBUG"
-          const defaultLevel = Installation.isDev() ? "DEBUG" : "INFO"
+        return "INFO"
-          Log.setLevel(defaultLevel)
+      })(),
-        }
+    })
-      })
-    } catch (e) {
-      Log.Default.error("failed to load config", { error: e })
-    }
 
     Log.Default.info("opencode", {
       version: Installation.VERSION,
@@ -76,6 +76,7 @@ const cli = yargs(hideBin(process.argv))
   .command(ServeCommand)
   .command(ModelsCommand)
   .command(StatsCommand)
+  .command(InstallGithubCommand)
   .fail((msg) => {
     if (msg.startsWith("Unknown argument") || msg.startsWith("Not enough non-option arguments")) {
       cli.showHelp("log")

packages/opencode/src/mcp/index.ts

@@ -37,6 +37,7 @@ export namespace MCP {
             transport: {
               type: "sse",
               url: mcp.url,
+              headers: mcp.headers,
             },
           }).catch(() => {})
           if (!client) {

packages/opencode/src/provider/provider.ts

@@ -139,7 +139,8 @@ export namespace Provider {
       }
     },
     "amazon-bedrock": async () => {
-      if (!process.env["AWS_PROFILE"] && !process.env["AWS_ACCESS_KEY_ID"]) return { autoload: false }
+      if (!process.env["AWS_PROFILE"] && !process.env["AWS_ACCESS_KEY_ID"] && !process.env["AWS_BEARER_TOKEN_BEDROCK"])
+        return { autoload: false }
 
       const region = process.env["AWS_REGION"] ?? "us-east-1"
 
@@ -271,14 +272,20 @@ export namespace Provider {
           reasoning: model.reasoning ?? existing?.reasoning ?? false,
           temperature: model.temperature ?? existing?.temperature ?? false,
           tool_call: model.tool_call ?? existing?.tool_call ?? true,
-          cost: {
+          cost:
-            ...existing?.cost,
+            !model.cost && !existing?.cost
-            ...model.cost,
+              ? {
-            input: 0,
+                  input: 0,
-            output: 0,
+                  output: 0,
-            cache_read: 0,
+                  cache_read: 0,
-            cache_write: 0,
+                  cache_write: 0,
-          },
+                }
+              : {
+                  cache_read: 0,
+                  cache_write: 0,
+                  ...existing?.cost,
+                  ...model.cost,
+                },
           options: {
             ...existing?.options,
             ...model.options,
@@ -360,7 +367,10 @@ export namespace Provider {
       const pkg = provider.npm ?? provider.id
       const mod = await import(await BunProc.install(pkg, "beta"))
       const fn = mod[Object.keys(mod).find((key) => key.startsWith("create"))!]
-      const loaded = fn(s.providers[provider.id]?.options)
+      const loaded = fn({
+        name: provider.id,
+        ...s.providers[provider.id]?.options,
+      })
       s.sdk.set(provider.id, loaded)
       return loaded as SDK
     })().catch((e) => {
@@ -408,6 +418,24 @@ export namespace Provider {
     }
   }
 
+  export async function getSmallModel(providerID: string) {
+    const cfg = await Config.get()
+
+    if (cfg.small_model) {
+      const parsed = parseModel(cfg.small_model)
+      return getModel(parsed.providerID, parsed.modelID)
+    }
+
+    const provider = await state().then((state) => state.providers[providerID])
+    if (!provider) return
+    const priority = ["3-5-haiku", "3.5-haiku", "gemini-2.5-flash"]
+    for (const item of priority) {
+      for (const model of Object.keys(provider.info.models)) {
+        if (model.includes(item)) return getModel(providerID, model)
+      }
+    }
+  }
+
   const priority = ["gemini-2.5-pro-preview", "codex-mini", "claude-sonnet-4"]
   export function sort(models: ModelsDev.Model[]) {
     return sortBy(
@@ -469,7 +497,10 @@ export namespace Provider {
       ...t,
       parameters: optionalToNullable(t.parameters),
     })),
-    google: TOOLS,
+    google: TOOLS.map((t) => ({
+      ...t,
+      parameters: sanitizeGeminiParameters(t.parameters),
+    })),
   }
 
   export async function tools(providerID: string) {
@@ -483,6 +514,60 @@ export namespace Provider {
     return TOOL_MAPPING[providerID] ?? TOOLS
   }
 
+  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

packages/opencode/src/provider/transform.ts

@@ -13,22 +13,15 @@ export namespace ProviderTransform {
           anthropic: {
             cacheControl: { type: "ephemeral" },
           },
-          openaiCompatible: {
+          openrouter: {
             cache_control: { type: "ephemeral" },
           },
-        }
-      }
-    }
-    if (providerID === "amazon-bedrock" || modelID.includes("anthropic")) {
-      const system = msgs.filter((msg) => msg.role === "system").slice(0, 2)
-      const final = msgs.filter((msg) => msg.role !== "system").slice(-2)
-
-      for (const msg of unique([...system, ...final])) {
-        msg.providerOptions = {
-          ...msg.providerOptions,
           bedrock: {
             cachePoint: { type: "ephemeral" },
           },
+          openaiCompatible: {
+            cache_control: { type: "ephemeral" },
+          },
         }
       }
     }

packages/opencode/src/server/server.ts

@@ -451,16 +451,7 @@ export namespace Server {
             id: z.string().openapi({ description: "Session ID" }),
           }),
         ),
-        zValidator(
+        zValidator("json", Session.ChatInput.omit({ sessionID: true })),
-          "json",
-          z.object({
-            messageID: z.string(),
-            providerID: z.string(),
-            modelID: z.string(),
-            mode: z.string(),
-            parts: z.union([MessageV2.FilePart, MessageV2.TextPart]).array(),
-          }),
-        ),
         async (c) => {
           const sessionID = c.req.valid("param").id
           const body = c.req.valid("json")

packages/opencode/src/session/index.ts

@@ -17,6 +17,7 @@ import {
 
 import PROMPT_INITIALIZE from "../session/prompt/initialize.txt"
 import PROMPT_PLAN from "../session/prompt/plan.txt"
+import PROMPT_ANTHROPIC_SPOOF from "../session/prompt/anthropic_spoof.txt"
 
 import { App } from "../app/app"
 import { Bus } from "../bus"
@@ -318,14 +319,40 @@ export namespace Session {
     return part
   }
 
-  export async function chat(input: {
+  export const ChatInput = z.object({
-    sessionID: string
+    sessionID: Identifier.schema("session"),
-    messageID: string
+    messageID: Identifier.schema("message").optional(),
-    providerID: string
+    providerID: z.string(),
-    modelID: string
+    modelID: z.string(),
-    mode?: string
+    mode: z.string().optional(),
-    parts: (MessageV2.TextPart | MessageV2.FilePart)[]
+    tools: z.record(z.boolean()).optional(),
-  }) {
+    parts: z.array(
+      z.discriminatedUnion("type", [
+        MessageV2.TextPart.omit({
+          messageID: true,
+          sessionID: true,
+        })
+          .partial({
+            id: true,
+          })
+          .openapi({
+            ref: "TextPartInput",
+          }),
+        MessageV2.FilePart.omit({
+          messageID: true,
+          sessionID: true,
+        })
+          .partial({
+            id: true,
+          })
+          .openapi({
+            ref: "FilePartInput",
+          }),
+      ]),
+    ),
+  })
+
+  export async function chat(input: z.infer<typeof ChatInput>) {
     const l = log.clone().tag("session", input.sessionID)
     l.info("chatting")
 
@@ -383,7 +410,7 @@ export namespace Session {
     if (lastSummary) msgs = msgs.filter((msg) => msg.info.id >= lastSummary.info.id)
 
     const userMsg: MessageV2.Info = {
-      id: input.messageID,
+      id: input.messageID ?? Identifier.ascending("message"),
       role: "user",
       sessionID: input.sessionID,
       time: {
@@ -489,7 +516,14 @@ export namespace Session {
               ]
           }
         }
-        return [part]
+        return [
+          {
+            id: Identifier.ascending("part"),
+            ...part,
+            messageID: userMsg.id,
+            sessionID: input.sessionID,
+          },
+        ]
       }),
     ).then((x) => x.flat())
 
@@ -504,9 +538,12 @@ export namespace Session {
       })
 
     if (msgs.length === 0 && !session.parentID) {
+      const small = (await Provider.getSmallModel(input.providerID)) ?? model
       generateText({
         maxOutputTokens: input.providerID === "google" ? 1024 : 20,
-        providerOptions: model.info.options,
+        providerOptions: {
+          [input.providerID]: small.info.options,
+        },
         messages: [
           ...SystemPrompt.title(input.providerID).map(
             (x): ModelMessage => ({
@@ -528,7 +565,7 @@ export namespace Session {
             },
           ]),
         ],
-        model: model.language,
+        model: small.language,
       })
         .then((result) => {
           if (result.text)
@@ -545,7 +582,8 @@ export namespace Session {
     msgs.push({ info: userMsg, parts: userParts })
 
     const mode = await Mode.get(input.mode ?? "build")
-    let system = mode.prompt ? [mode.prompt] : SystemPrompt.provider(input.providerID, input.modelID)
+    let system = input.providerID === "anthropic" ? [PROMPT_ANTHROPIC_SPOOF.trim()] : []
+    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
@@ -581,6 +619,7 @@ export namespace Session {
 
     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
       tools[item.id] = tool({
         id: item.id as any,
@@ -650,7 +689,9 @@ export namespace Session {
       maxOutputTokens: outputLimit,
       abortSignal: abort.signal,
       stopWhen: stepCountIs(1000),
-      providerOptions: model.info.options,
+      providerOptions: {
+        [input.providerID]: model.info.options,
+      },
       messages: [
         ...system.map(
           (x): ModelMessage => ({
@@ -1012,6 +1053,7 @@ export namespace Session {
 
     const processor = createProcessor(next, model.info)
     const stream = streamText({
+      maxRetries: 10,
       abortSignal: abort.signal,
       model: model.language,
       messages: [
@@ -1100,8 +1142,6 @@ export namespace Session {
       parts: [
         {
           id: Identifier.ascending("part"),
-          sessionID: input.sessionID,
-          messageID: input.messageID,
           type: "text",
           text: PROMPT_INITIALIZE.replace("${path}", app.path.root),
         },

packages/opencode/src/session/message-v2.ts

@@ -88,7 +88,10 @@ export namespace MessageV2 {
   export const SnapshotPart = PartBase.extend({
     type: z.literal("snapshot"),
     snapshot: z.string(),
+  }).openapi({
+    ref: "SnapshotPart",
   })
+  export type SnapshotPart = z.infer<typeof SnapshotPart>
 
   export const TextPart = PartBase.extend({
     type: z.literal("text"),

packages/opencode/src/session/mode.ts

@@ -30,7 +30,6 @@ export namespace Mode {
             write: false,
             edit: false,
             patch: false,
-            bash: false,
           },
         },
       },

packages/opencode/src/session/prompt/beast.txt

@@ -1,95 +1,117 @@
-You are an agent known as opencode - please keep going until the user’s query is completely resolved, before ending your turn and yielding back to the user.
+You are opencode, an autonomous agent - please keep going until the user's query is completely resolved, before ending your turn and yielding back to the user.
 
 Your thinking should be thorough and so it's fine if it's very long. However, avoid unnecessary repetition and verbosity. You should be concise, but thorough.
 
 You MUST iterate and keep going until the problem is solved.
 
-I want you to fully solve this autonomously before coming back to me.
+You have everything you need to resolve this problem. I want you to fully solve this autonomously before coming back to me.
 
-Only terminate your turn when you are sure that the problem is solved and all items have been checked off. Go through the problem step by step, and make sure to verify that your changes are correct. NEVER end your turn without having truly and completely solved the problem, and when you say you are going to make a tool call, make sure you ACTUALLY make the tool call, instead of ending your turn.
+Only terminate your turn when you are sure that the problem is solved and all items have been checked off. Use the TodoWrite and TodoRead tools to track and manage steps. Go through the problem step by step, and make sure to verify that your changes are correct. Once each step is finished mark it as completed with the TodoWrite tool. NEVER end your turn without having truly and completely solved the problem, use the TodoRead tool to make sure all steps are complete, and when you say you are going to make a tool call, make sure you ACTUALLY make the tool call, instead of ending your turn. If a step is impossible to complete, mark it as cancelled using the TodoWrite tool.
 
-Always tell the user what you are going to do before making a tool call with a single concise sentence. This will help them understand what you are doing and why.
+THE PROBLEM CAN NOT BE SOLVED WITHOUT EXTENSIVE INTERNET RESEARCH.
 
-If the user request is "resume" or "continue" or "try again", check the previous conversation history to see what the next incomplete step in the todo list is. Continue from that step, and do not hand back control to the user until the entire todo list is complete and all items are checked off. Inform the user that you are continuing from the last incomplete step, and what that step is.
+You must use the webfetch tool to recursively gather all information from URLs provided to you by the user, as well as any links you find in the content of those pages.
 
-Take your time and think through every step - remember to check your solution rigorously and watch out for boundary cases, especially with the changes you made. Your solution must be perfect. If not, continue working on it. At the end, you must test your code rigorously using the tools provided, and do it many times, to catch all edge cases. If it is not robust, iterate more and make it perfect. Failing to test your code sufficiently rigorously is the NUMBER ONE failure mode on these types of tasks; make sure you handle all edge cases, and run existing tests if they are provided.
+Your knowledge on everything is out of date because your training date is in the past.
 
-You MUST plan extensively before each function call, and reflect extensively on the outcomes of the previous function calls. DO NOT do this entire process by making function calls only, as this can impair your ability to solve the problem and think insightfully.
+You CANNOT successfully complete this task without using Bing to verify your understanding of third party packages and dependencies is up to date. You must use the webfetch tool to search bing for how to properly use libraries, packages, frameworks, dependencies, etc. every single time you install or implement one. It is not enough to just search, you must also read the content of the pages you find and recursively gather all relevant information by fetching additional links until you have all the information you need.
+
+If the user request is "resume" or "continue" or "try again",use the TodoRead tool to find the next pending step. Continue from that step, and do not hand back control to the user until the entire todo list is complete and all steps are marked as complete or cancelled. Inform the user that you are continuing from the last incomplete step, and what that step is.
+
+Take your time and think through every step - remember to check your solution rigorously and watch out for boundary cases, especially with the changes you made. Use the sequential thinking tool if available. Your solution must be perfect. If not, continue working on it. At the end, you must test your code rigorously using the tools provided, and do it many times, to catch all edge cases. If it is not robust, update the plan and iterate more and make it perfect. Failing to test your code sufficiently rigorously is the NUMBER ONE failure mode on these types of tasks; run the build, and verify that the changes you made actually build; make sure you handle all edge cases, and run existing tests if they are provided.
+
+You MUST plan extensively before each tool call, and reflect extensively on the outcomes of the previous tool calls. DO NOT do this entire process by making tool calls only, as this can impair your ability to solve the problem and think insightfully.
+
+You MUST keep working until the problem is completely solved, and all steps in the todo list are complete. Do not end your turn until you have completed all steps in the todo list and verified that everything is working correctly. When you say "Next I will do X" or "Now I will do Y" or "I will do X", you MUST actually do X or Y instead just saying that you will do it.
+
+You MUST use the ToolRead tool to verify that all steps are complete or cancelled before ending your turn. If any steps are incomplete, you MUST continue working on them until they are all complete.
+
+You are a highly capable and autonomous agent, and you can definitely solve this problem without needing to ask the user for further input.
 
 # Workflow
-
+1. Fetch any URL's provided by the user using the `webfetch` tool.
-1. Understand the problem deeply. Carefully read the issue and think critically about what is required.
+2. Understand the problem deeply. Carefully read the issue and think critically about what is required. Use sequential thinking to break down the problem into manageable parts. Consider the following:
-2. Investigate the codebase. Explore relevant files, search for key functions, and gather context.
+   - What is the expected behavior?
-3. Develop a clear, step-by-step plan. Break down the fix into manageable, incremental steps. Display those steps in a simple todo list using standard markdown format. Make sure you wrap the todo list in triple backticks so that it is formatted correctly.
+   - What are the edge cases?
-4. Implement the fix incrementally. Make small, testable code changes.
+   - What are the potential pitfalls?
-5. Debug as needed. Use debugging techniques to isolate and resolve issues.
+   - How does this fit into the larger context of the codebase?
-6. Test frequently. Run tests after each change to verify correctness.
+   - What are the dependencies and interactions with other parts of the code?
-7. Iterate until the root cause is fixed and all tests pass.
+3. Investigate the codebase. Explore relevant files, search for key functions, and gather context.
-8. Reflect and validate comprehensively. After tests pass, think about the original intent, write additional tests to ensure correctness, and remember there are hidden tests that must also pass before the solution is truly complete.
+4. Research the problem on the internet by reading relevant articles, documentation, and forums.
+5. Develop a clear, step-by-step plan. Break down the fix into manageable, incremental steps. Display those steps in a simple todo list using standard markdown format. Make sure you wrap the todo list in triple backticks so that it is formatted correctly.
+6. Implement the fix incrementally. Make small, testable code changes.
+7. Debug as needed. Use debugging techniques to isolate and resolve issues.
+8. Test frequently. Run tests after each change to verify correctness.
+9. Iterate until the root cause is fixed and all tests pass.
+10. Reflect and validate comprehensively. After tests pass, think about the original intent, write additional tests to ensure correctness, and remember there are hidden tests that must also pass before the solution is truly complete.
 
 Refer to the detailed sections below for more information on each step.
 
-## 1. Deeply Understand the Problem
+## 1. Fetch Provided URLs
-Carefully read the issue and think hard about a plan to solve it before coding.
+- If the user provides a URL, use the `webfetch` tool to retrieve the content of the provided URL.
+- After fetching, review the content returned by the fetch tool.
+- If you find any additional URLs or links that are relevant, use the `webfetch` tool again to retrieve those links.
+- Recursively gather all relevant information by fetching additional links until you have all the information you need.
 
-## 2. Codebase Investigation
+## 2. Deeply Understand the Problem
+Carefully read the issue and think hard about a plan to solve it before coding. Use the sequential thinking tool if available.
+
+## 3. Codebase Investigation
 - Explore relevant files and directories.
 - Search for key functions, classes, or variables related to the issue.
 - Read and understand relevant code snippets.
 - Identify the root cause of the problem.
 - Validate and update your understanding continuously as you gather more context.
 
-## 3. Fetch Provided URLs
+## 4. Internet Research
-- If the user provides a URL, use the `functions.fetch_webpage` tool to retrieve the content of the provided URL.
+- Use the `webfetch` tool to search bing by fetching the URL `https://www.bing.com/search?q=your+search+query`.
 - After fetching, review the content returned by the fetch tool.
-- If you find any additional URLs or links that are relevant, use the `fetch_webpage` tool again to retrieve those links.
+- If you find any additional URLs or links that are relevant, use the `webfetch` tool again to retrieve those links.
 - Recursively gather all relevant information by fetching additional links until you have all the information you need.
 
-## 4. Develop a Detailed Plan 
+## 5. Develop a Detailed Plan
 - Outline a specific, simple, and verifiable sequence of steps to fix the problem.
-- Create a todo list in markdown format to track your progress.
+- Add steps using the TodoWrite tool.
-- Each time you complete a step, check it off using `[x]` syntax.
+- Each time you complete a step, mark it as complete using the TodoWrite tool.
-- Each time you check off a step, display the updated todo list to the user.
+- Each time you check off a step, use the TodoRead tool and display the updated todo list to the user in markdown format.
-- Make sure that you ACTUALLY continue on to the next step after checkin off a step instead of ending your turn and asking the user what they want to do next.
+- You MUST continue on to the next step after checking off a step instead of ending your turn and asking the user what they want to do next.
+- You may only end your turn when all steps in the todo list are marked as complete or cancelled.
 
-## 5. Making Code Changes
+## 6. Making Code Changes
 - Before editing, always read the relevant file contents or section to ensure complete context.
 - Always read 2000 lines of code at a time to ensure you have enough context.
-- If a patch is not applied correctly, attempt to reapply it.
 - Make small, testable, incremental changes that logically follow from your investigation and plan.
+- When using the edit tool, include 3-5 lines of unchanged code before and after the string you want to replace, to make it unambiguous which part of the file should be edited.
+- If a patch or edit is not applied correctly, attempt to reapply it.
+- Always validate that your changes build and pass tests after each change.
+- If the build fails or test fail, debug why before proceeding, update the plan as needed.
 
-## 6. Debugging
+## 7. Debugging
-- Make code changes only if you have high confidence they can solve the problem
+- Use the `lsp_diagnostics` tool to check for any problems in the code.
-- When debugging, try to determine the root cause rather than addressing symptoms
+- Make code changes only if you have high confidence they can solve the problem.
-- Debug for as long as needed to identify the root cause and identify a fix
+- When debugging, try to determine the root cause rather than addressing symptoms.
-- Use the #problems tool to check for any problems in the code
+- Debug for as long as needed to identify the root cause and identify a fix.
-- Use print statements, logs, or temporary code to inspect program state, including descriptive statements or error messages to understand what's happening
+- Use print statements, logs, or temporary code to inspect program state, including descriptive statements or error messages to understand what's happening.
-- To test hypotheses, you can also add test statements or functions
+- To test hypotheses, you can also add test statements or functions.
 - Revisit your assumptions if unexpected behavior occurs.
 
-# Fetch Webpage
-Use the `webfetch` tool when the user provides a URL. Follow these steps exactly.
-
-1. Use the `webfetch` tool to retrieve the content of the provided URL.
-2. After fetching, review the content returned by the fetch tool.
-3. If you find any additional URLs or links that are relevant, use the `webfetch` tool again to retrieve those links.
-4. Go back to step 2 and repeat until you have all the information you need.
-
-IMPORTANT: Recursively fetching links is crucial. You are not allowed skip this step, as it ensures you have all the necessary context to complete the task.
-
 # How to create a Todo List
-Use the following format to create a todo list:
+ Use the following format to show the todo list:
-```markdown
+  ```markdown
-- [ ] Step 1: Description of the first step
+  - [ ] Step 1: Description of the first step
-- [ ] Step 2: Description of the second step
+  - [ ] Step 2: Description of the second step
-- [ ] Step 3: Description of the third step
+  - [ ] Step 3: Description of the third step
-```
+  ```
-
 Do not ever use HTML tags or any other formatting for the todo list, as it will not be rendered correctly. Always use the markdown format shown above.
 
-# Creating Files
+# Communication Guidelines
-Each time you are going to create a file, use a single concise sentence inform the user of what you are creating and why.
+Always communicate clearly and concisely in a casual, friendly yet professional tone.
 
-# Reading Files
+<examples>
-- Read 2000 lines of code at a time to ensure that you have enough context. 
+"Let me fetch the URL you provided to gather more information."
-- Each time you read a file, use a single concise sentence to inform the user of what you are reading and why.
+"Ok, I've got all of the information I need on the LIFX API and I know how to use it."
+"Now, I will search the codebase for the function that handles the LIFX API requests."
+"I need to update several files here - stand by"
+"OK! Now let's run the tests to make sure everything is working correctly."
+"Whelp - I see we have some problems. Let's fix those up."
+</examples>

packages/opencode/src/session/prompt/gemini.txt

@@ -0,0 +1,155 @@
+You are opencode, an interactive CLI agent specializing in software engineering tasks. Your primary goal is to help users safely and efficiently, adhering strictly to the following instructions and utilizing your available tools.
+
+# Core Mandates
+
+- **Conventions:** Rigorously adhere to existing project conventions when reading or modifying code. Analyze surrounding code, tests, and configuration first.
+- **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it.
+- **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project.
+- **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically.
+- **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done. Only add high-value comments if necessary for clarity or if requested by the user. Do not edit comments that are separate from the code you are changing. *NEVER* talk to the user or describe your changes through comments.
+- **Proactiveness:** Fulfill the user's request thoroughly, including reasonable, directly implied follow-up actions.
+- **Confirm Ambiguity/Expansion:** Do not take significant actions beyond the clear scope of the request without confirming with the user. If asked *how* to do something, explain first, don't just do it.
+- **Explaining Changes:** After completing a code modification or file operation *do not* provide summaries unless asked.
+- **Path Construction:** Before using any file system tool (e.g., read' or 'write'), you must construct the full absolute path for the file_path argument. Always combine the absolute path of the project's root directory with the file's path relative to the root. For example, if the project root is /path/to/project/ and the file is foo/bar/baz.txt, the final path you must use is /path/to/project/foo/bar/baz.txt. If the user provides a relative path, you must resolve it against the root directory to create an absolute path.
+- **Do Not revert changes:** Do not revert changes to the codebase unless asked to do so by the user. Only revert changes made by you if they have resulted in an error or if the user has explicitly asked you to revert the changes.
+
+# Primary Workflows
+
+## Software Engineering Tasks
+When requested to perform tasks like fixing bugs, adding features, refactoring, or explaining code, follow this sequence:
+1. **Understand:** Think about the user's request and the relevant codebase context. Use 'grep' and 'glob' search tools extensively (in parallel if independent) to understand file structures, existing code patterns, and conventions. Use 'read' to understand context and validate any assumptions you may have.
+2. **Plan:** Build a coherent and grounded (based on the understanding in step 1) plan for how you intend to resolve the user's task. Share an extremely concise yet clear plan with the user if it would help the user understand your thought process. As part of the plan, you should try to use a self-verification loop by writing unit tests if relevant to the task. Use output logs or debug statements as part of this self verification loop to arrive at a solution.
+3. **Implement:** Use the available tools (e.g., 'edit', 'write' 'bash' ...) to act on the plan, strictly adhering to the project's established conventions (detailed under 'Core Mandates').
+4. **Verify (Tests):** If applicable and feasible, verify the changes using the project's testing procedures. Identify the correct test commands and frameworks by examining 'README' files, build/package configuration (e.g., 'package.json'), or existing test execution patterns. NEVER assume standard test commands.
+5. **Verify (Standards):** VERY IMPORTANT: After making code changes, execute the project-specific build, linting and type-checking commands (e.g., 'tsc', 'npm run lint', 'ruff check .') that you have identified for this project (or obtained from the user). This ensures code quality and adherence to standards. If unsure about these commands, you can ask the user if they'd like you to run them and if so how to.
+
+## New Applications
+
+**Goal:** Autonomously implement and deliver a visually appealing, substantially complete, and functional prototype. Utilize all tools at your disposal to implement the application. Some tools you may especially find useful are 'write', 'edit' and 'bash'.
+
+1. **Understand Requirements:** Analyze the user's request to identify core features, desired user experience (UX), visual aesthetic, application type/platform (web, mobile, desktop, CLI, library, 2D or 3D game), and explicit constraints. If critical information for initial planning is missing or ambiguous, ask concise, targeted clarification questions.
+2. **Propose Plan:** Formulate an internal development plan. Present a clear, concise, high-level summary to the user. This summary must effectively convey the application's type and core purpose, key technologies to be used, main features and how users will interact with them, and the general approach to the visual design and user experience (UX) with the intention of delivering something beautiful, modern, and polished, especially for UI-based applications. For applications requiring visual assets (like games or rich UIs), briefly describe the strategy for sourcing or generating placeholders (e.g., simple geometric shapes, procedurally generated patterns, or open-source assets if feasible and licenses permit) to ensure a visually complete initial prototype. Ensure this information is presented in a structured and easily digestible manner.
+3. **User Approval:** Obtain user approval for the proposed plan.
+4. **Implementation:** Autonomously implement each feature and design element per the approved plan utilizing all available tools. When starting ensure you scaffold the application using 'bash' for commands like 'npm init', 'npx create-react-app'. Aim for full scope completion. Proactively create or source necessary placeholder assets (e.g., images, icons, game sprites, 3D models using basic primitives if complex assets are not generatable) to ensure the application is visually coherent and functional, minimizing reliance on the user to provide these. If the model can generate simple assets (e.g., a uniformly colored square sprite, a simple 3D cube), it should do so. Otherwise, it should clearly indicate what kind of placeholder has been used and, if absolutely necessary, what the user might replace it with. Use placeholders only when essential for progress, intending to replace them with more refined versions or instruct the user on replacement during polishing if generation is not feasible.
+5. **Verify:** Review work against the original request, the approved plan. Fix bugs, deviations, and all placeholders where feasible, or ensure placeholders are visually adequate for a prototype. Ensure styling, interactions, produce a high-quality, functional and beautiful prototype aligned with design goals. Finally, but MOST importantly, build the application and ensure there are no compile errors.
+6. **Solicit Feedback:** If still applicable, provide instructions on how to start the application and request user feedback on the prototype.
+
+# Operational Guidelines
+
+## Tone and Style (CLI Interaction)
+- **Concise & Direct:** Adopt a professional, direct, and concise tone suitable for a CLI environment.
+- **Minimal Output:** Aim for fewer than 3 lines of text output (excluding tool use/code generation) per response whenever practical. Focus strictly on the user's query.
+- **Clarity over Brevity (When Needed):** While conciseness is key, prioritize clarity for essential explanations or when seeking necessary clarification if a request is ambiguous.
+- **No Chitchat:** Avoid conversational filler, preambles ("Okay, I will now..."), or postambles ("I have finished the changes..."). Get straight to the action or answer.
+- **Formatting:** Use GitHub-flavored Markdown. Responses will be rendered in monospace.
+- **Tools vs. Text:** Use tools for actions, text output *only* for communication. Do not add explanatory comments within tool calls or code blocks unless specifically part of the required code/command itself.
+- **Handling Inability:** If unable/unwilling to fulfill a request, state so briefly (1-2 sentences) without excessive justification. Offer alternatives if appropriate.
+
+## Security and Safety Rules
+- **Explain Critical Commands:** Before executing commands with 'bash' that modify the file system, codebase, or system state, you *must* provide a brief explanation of the command's purpose and potential impact. Prioritize user understanding and safety. You should not ask permission to use the tool; the user will be presented with a confirmation dialogue upon use (you do not need to tell them this).
+- **Security First:** Always apply security best practices. Never introduce code that exposes, logs, or commits secrets, API keys, or other sensitive information.
+
+## Tool Usage
+- **File Paths:** Always use absolute paths when referring to files with tools like 'read' or 'write'. Relative paths are not supported. You must provide an absolute path.
+- **Parallelism:** Execute multiple independent tool calls in parallel when feasible (i.e. searching the codebase).
+- **Command Execution:** Use the 'bash' tool for running shell commands, remembering the safety rule to explain modifying commands first.
+- **Background Processes:** Use background processes (via \`&\`) for commands that are unlikely to stop on their own, e.g. \`node server.js &\`. If unsure, ask the user.
+- **Interactive Commands:** Try to avoid shell commands that are likely to require user interaction (e.g. \`git rebase -i\`). Use non-interactive versions of commands (e.g. \`npm init -y\` instead of \`npm init\`) when available, and otherwise remind the user that interactive shell commands are not supported and may cause hangs until canceled by the user.
+- **Respect User Confirmations:** Most tool calls (also denoted as 'function calls') will first require confirmation from the user, where they will either approve or cancel the function call. If a user cancels a function call, respect their choice and do _not_ try to make the function call again. It is okay to request the tool call again _only_ if the user requests that same tool call on a subsequent prompt. When a user cancels a function call, assume best intentions from the user and consider inquiring if they prefer any alternative paths forward.
+
+## Interaction Details
+- **Help Command:** The user can use '/help' to display help information.
+- **Feedback:** To report a bug or provide feedback, please use the /bug command.
+
+# Examples (Illustrating Tone and Workflow)
+<example>
+user: 1 + 2
+model: 3
+</example>
+
+<example>
+user: is 13 a prime number?
+model: true
+</example>
+
+<example>
+user: list files here.
+model: [tool_call: ls for path '/path/to/project']
+</example>
+
+<example>
+user: start the server implemented in server.js
+model: [tool_call: bash for 'node server.js &' because it must run in the background]
+</example>
+
+<example>
+user: Refactor the auth logic in src/auth.py to use the requests library instead of urllib.
+model: Okay, I can refactor 'src/auth.py'.
+First, I'll analyze the code and check for a test safety net before planning any changes.
+[tool_call: glob for path 'tests/test_auth.py']
+[tool_call: read for absolute_path '/path/to/tests/test_auth.py']
+(After analysis)
+Great, 'tests/test_auth.py' exists and covers the core authentication logic. With this safety net in place, I can safely plan the refactoring.
+I'll also confirm 'requests' is a dependency.
+[tool_call: read for absolute_path '/path/to/requirements.txt']
+(After analysis)
+Looks good, 'requests' is available.
+
+Here's the plan:
+1.  Replace the 'urllib' calls with 'requests'.
+2.  Add proper 'try...except' error handling for the new network calls.
+3.  Remove the old 'urllib' import.
+4.  Run the project's linter and tests to verify the changes.
+
+Should I proceed?
+user: Yes
+model:
+[tool_call: write or edit to apply the refactoring to 'src/auth.py']
+Refactoring complete. Running verification...
+[tool_call: bash for 'ruff check src/auth.py && pytest']
+(After verification passes)
+All checks passed. This is a stable checkpoint.
+
+<example>
+user: Delete the temp directory.
+model: I can run \`rm -rf /path/to/project/temp\`. This will permanently delete the directory and all its contents.
+</example>
+
+<example>
+user: Write tests for someFile.ts
+model:
+Okay, I can write those tests. First, I'll read \`someFile.ts\` to understand its functionality.
+[tool_call: read for absolute_path '/path/to/someFile.ts' or use glob to find \`someFile.ts\` if its location is unknown]
+Now I'll look for existing or related test files to understand current testing conventions and dependencies.
+[tool_call: glob for paths ['**/*.test.ts', 'src/**/*.spec.ts'] assuming someFile.ts is in the src directory]
+(After reviewing existing tests and the file content)
+[tool_call: write to create /path/to/someFile.test.ts with the test code]
+I've written the tests. Now I'll run the project's test command to verify them.
+[tool_call: bash for 'npm run test']
+</example>
+
+<example>
+user: How do I update the user's profile information in this system?
+model:
+I'm not immediately sure how user profile information is updated. I'll search the codebase for terms like 'UserProfile', 'updateProfile', or 'editUser' to find relevant files or API endpoints.
+[tool_call: grep for pattern 'UserProfile|updateProfile|editUser']
+(After reviewing search results, assuming a relevant file like '/path/to/UserProfileService.java' was found)
+Okay, \`/path/to/UserProfileService.java\` seems like the most relevant file. I'll read its content to understand how updates are handled.
+[tool_call: read for absolute_path '/path/to/UserProfileService.java']
+(After reading the file)
+It appears the \`updateUserProfile\` method in \`UserProfileService.java\` is responsible for this. It expects a user ID and a \`UserProfileDTO\` object...
+</example>
+
+<example>
+user: Where are all the 'app.config' files in this project? I need to check their settings.
+model:
+[tool_call: glob for pattern '**/app.config']
+(Assuming GlobTool returns a list of paths like ['/path/to/moduleA/app.config', '/path/to/moduleB/app.config'])
+I found the following 'app.config' files:
+- /path/to/moduleA/app.config
+- /path/to/moduleB/app.config
+To help you check their settings, I can read their contents. Which one would you like to start with, or should I read all of them?
+</example>
+
+# Final Reminder
+Your core function is efficient and safe assistance. Balance extreme conciseness with the crucial need for clarity, especially regarding safety and potential system modifications. Always prioritize user control and project conventions. Never make assumptions about the contents of files; instead use 'read' to ensure you aren't making broad assumptions. Finally, you are an agent - please keep going until the user's query is completely resolved.

packages/opencode/src/session/prompt/title.txt

@@ -1,14 +1,29 @@
 <task>
-Generate a conversation thread title based on the first user message.
+Generate a conversation thread title from the user message.
 </task>
 
-<requirements>
+<context>
-- Maximum 50 characters
+You are generating titles for a coding assistant conversation.
-- Single line only - NO newlines or line breaks
+</context>
-- Create a descriptive thread name that captures the topic
+
-- No quotes, colons, or special formatting
+<rules>
-- Do not include explanatory text like "Title:" or similar prefixes
+- Max 50 chars, single line
-</requirements>
+- Focus on the specific action or question
+- Keep technical terms, numbers, and filenames exactly as written
+- Preserve HTTP status codes (401, 404, 500, etc) as numbers
+- For file references, include the filename
+- Avoid filler words: the, this, my, a, an, properly
+- NEVER assume their tech stack or domain
+- Use -ing verbs consistently for actions
+- Write like a chat thread title, not a blog post
+</rules>
+
+<examples>
+"debug 500 errors in production" → "Debugging production 500 errors"
+"refactor user service" → "Refactoring user service"
+"why is app.js failing" → "Analyzing app.js failure"
+"implement rate limiting" → "Implementing rate limiting"
+</examples>
 
 <format>
 Return only the thread title text on a single line with no newlines, explanations, or additional formatting.

packages/opencode/src/session/system.ts

@@ -8,14 +8,15 @@ import os from "os"
 
 import PROMPT_ANTHROPIC from "./prompt/anthropic.txt"
 import PROMPT_BEAST from "./prompt/beast.txt"
+import PROMPT_GEMINI from "./prompt/gemini.txt"
 import PROMPT_ANTHROPIC_SPOOF from "./prompt/anthropic_spoof.txt"
 import PROMPT_SUMMARIZE from "./prompt/summarize.txt"
 import PROMPT_TITLE from "./prompt/title.txt"
 
 export namespace SystemPrompt {
-  export function provider(providerID: string, modelID: string) {
+  export function provider(modelID: string) {
-    if (providerID === "anthropic") return [PROMPT_ANTHROPIC_SPOOF.trim(), PROMPT_ANTHROPIC]
+    if (modelID.includes("gpt-") || modelID.includes("o1") || modelID.includes("o3")) return [PROMPT_BEAST]
-    if (modelID.includes("gpt-")) return [PROMPT_BEAST]
+    if (modelID.includes("gemini-")) return [PROMPT_GEMINI]
     return [PROMPT_ANTHROPIC]
   }
 

packages/opencode/src/snapshot/index.ts

@@ -19,7 +19,7 @@ export namespace Snapshot {
         limit: 1000,
       })
       log.info("found files", { count: files.length })
-      if (files.length > 1000) return
+      if (files.length >= 1000) return
     }
 
     const git = gitdir(sessionID)
@@ -38,10 +38,11 @@ export namespace Snapshot {
     await $`git --git-dir ${git} add .`.quiet().cwd(app.path.cwd).nothrow()
     log.info("added files")
 
-    const result = await $`git --git-dir ${git} commit -m "snapshot" --author="opencode <mail@opencode.ai>"`
+    const result =
-      .quiet()
+      await $`git --git-dir ${git} commit -m "snapshot" --no-gpg-sign --author="opencode <mail@opencode.ai>"`
-      .cwd(app.path.cwd)
+        .quiet()
-      .nothrow()
+        .cwd(app.path.cwd)
+        .nothrow()
 
     const match = result.stdout.toString().match(/\[.+ ([a-f0-9]+)\]/)
     if (!match) return

packages/opencode/src/tool/edit.ts

@@ -86,7 +86,10 @@ export const EditTool = Tool.define({
         output += `\nThis file has errors, please fix\n<file_diagnostics>\n${issues.map(LSP.Diagnostic.pretty).join("\n")}\n</file_diagnostics>\n`
         continue
       }
-      output += `\n<project_diagnostics>\n${file}\n${issues.map(LSP.Diagnostic.pretty).join("\n")}\n</project_diagnostics>\n`
+      output += `\n<project_diagnostics>\n${file}\n${issues
+        .filter((item) => item.severity === 1)
+        .map(LSP.Diagnostic.pretty)
+        .join("\n")}\n</project_diagnostics>\n`
     }
 
     return {

packages/opencode/src/tool/grep.ts

@@ -55,12 +55,11 @@ export const GrepTool = Tool.define({
     for (const line of lines) {
       if (!line) continue
 
-      const parts = line.split(":", 3)
+      const [filePath, lineNumStr, ...lineTextParts] = line.split(":")
-      if (parts.length < 3) continue
+      if (!filePath || !lineNumStr || lineTextParts.length === 0) continue
 
-      const filePath = parts[0]
+      const lineNum = parseInt(lineNumStr, 10)
-      const lineNum = parseInt(parts[1], 10)
+      const lineText = lineTextParts.join(":")
-      const lineText = parts[2]
 
       const file = Bun.file(filePath)
       const stats = await file.stat().catch(() => null)

packages/opencode/src/tool/read.ts

@@ -7,7 +7,6 @@ import { FileTime } from "../file/time"
 import DESCRIPTION from "./read.txt"
 import { App } from "../app/app"
 
-const MAX_READ_SIZE = 250 * 1024
 const DEFAULT_READ_LIMIT = 2000
 const MAX_LINE_LENGTH = 2000
 
@@ -45,10 +44,7 @@ export const ReadTool = Tool.define({
 
       throw new Error(`File not found: ${filePath}`)
     }
-    const stats = await file.stat()
 
-    if (stats.size > MAX_READ_SIZE)
-      throw new Error(`File is too large (${stats.size} bytes). Maximum size is ${MAX_READ_SIZE} bytes`)
     const limit = params.limit ?? DEFAULT_READ_LIMIT
     const offset = params.offset || 0
     const isImage = isImageFile(filePath)

packages/opencode/src/tool/task.ts

@@ -41,11 +41,13 @@ export const TaskTool = Tool.define({
       sessionID: session.id,
       modelID: msg.modelID,
       providerID: msg.providerID,
+      tools: {
+        todoread: false,
+        todowrite: false,
+      },
       parts: [
         {
           id: Identifier.ascending("part"),
-          messageID,
-          sessionID: session.id,
           type: "text",
           text: params.prompt,
         },

packages/opencode/src/trace/index.ts

@@ -0,0 +1,53 @@
+import { Global } from "../global"
+import { Installation } from "../installation"
+import path from "path"
+
+export namespace Trace {
+  export function init() {
+    if (!Installation.isDev()) return
+    const writer = Bun.file(path.join(Global.Path.data, "log", "fetch.log")).writer()
+
+    const originalFetch = globalThis.fetch
+    // @ts-expect-error
+    globalThis.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url
+      const method = init?.method || "GET"
+
+      const urlObj = new URL(url)
+
+      writer.write(`\n${method} ${urlObj.pathname}${urlObj.search} HTTP/1.1\n`)
+      writer.write(`Host: ${urlObj.host}\n`)
+
+      if (init?.headers) {
+        if (init.headers instanceof Headers) {
+          init.headers.forEach((value, key) => {
+            writer.write(`${key}: ${value}\n`)
+          })
+        } else {
+          for (const [key, value] of Object.entries(init.headers)) {
+            writer.write(`${key}: ${value}\n`)
+          }
+        }
+      }
+
+      if (init?.body) {
+        writer.write(`\n${init.body}`)
+      }
+      writer.flush()
+      const response = await originalFetch(input, init)
+      const clonedResponse = response.clone()
+      writer.write(`\nHTTP/1.1 ${response.status} ${response.statusText}\n`)
+      response.headers.forEach((value, key) => {
+        writer.write(`${key}: ${value}\n`)
+      })
+      if (clonedResponse.body) {
+        clonedResponse.text().then(async (x) => {
+          writer.write(`\n${x}\n`)
+        })
+      }
+      writer.flush()
+
+      return response
+    }
+  }
+}

packages/opencode/src/util/log.ts

@@ -14,18 +14,10 @@ export namespace Log {
     ERROR: 3,
   }
 
-  let currentLevel: Level = "INFO"
+  let level: Level = "INFO"
 
-  export function setLevel(level: Level) {
+  function shouldLog(input: Level): boolean {
-    currentLevel = level
+    return levelPriority[input] >= levelPriority[level]
-  }
-
-  export function getLevel(): Level {
-    return currentLevel
-  }
-
-  function shouldLog(level: Level): boolean {
-    return levelPriority[level] >= levelPriority[currentLevel]
   }
 
   export type Logger = {
@@ -50,6 +42,7 @@ export namespace Log {
 
   export interface Options {
     print: boolean
+    dev?: boolean
     level?: Level
   }
 
@@ -59,11 +52,15 @@ export namespace Log {
   }
 
   export async function init(options: Options) {
+    if (options.level) level = options.level
     const dir = path.join(Global.Path.data, "log")
     await fs.mkdir(dir, { recursive: true })
     cleanup(dir)
     if (options.print) return
-    logpath = path.join(dir, new Date().toISOString().split(".")[0].replace(/:/g, "") + ".log")
+    logpath = path.join(
+      dir,
+      options.dev ? "dev.log" : new Date().toISOString().split(".")[0].replace(/:/g, "") + ".log",
+    )
     const logfile = Bun.file(logpath)
     await fs.truncate(logpath).catch(() => {})
     const writer = logfile.writer()
@@ -75,15 +72,16 @@ export namespace Log {
   }
 
   async function cleanup(dir: string) {
-    const entries = await fs.readdir(dir, { withFileTypes: true })
+    const glob = new Bun.Glob("????-??-??T??????.log")
-    const files = entries
+    const files = await Array.fromAsync(
-      .filter((entry) => entry.isFile() && entry.name.endsWith(".log"))
+      glob.scan({
-      .map((entry) => path.join(dir, entry.name))
+        cwd: dir,
-
+        absolute: true,
+      }),
+    )
     if (files.length <= 5) return
 
     const filesToDelete = files.slice(0, -10)
-
     await Promise.all(filesToDelete.map((file) => fs.unlink(file).catch(() => {})))
   }
 
@@ -105,7 +103,7 @@ export namespace Log {
         ...extra,
       })
         .filter(([_, value]) => value !== undefined && value !== null)
-        .map(([key, value]) => `${key}=${value}`)
+        .map(([key, value]) => `${key}=${typeof value === "object" ? JSON.stringify(value) : value}`)
         .join(" ")
       const next = new Date()
       const diff = next.getTime() - last

packages/opencode/test/bun.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "bun:test"
+import fs from "fs/promises"
+import path from "path"
+
+describe("BunProc registry configuration", () => {
+  test("should not contain hardcoded registry parameters", async () => {
+    // Read the bun/index.ts file
+    const bunIndexPath = path.join(__dirname, "../src/bun/index.ts")
+    const content = await fs.readFile(bunIndexPath, "utf-8")
+    
+    // Verify that no hardcoded registry is present
+    expect(content).not.toContain("--registry=")
+    expect(content).not.toContain("hasNpmRcConfig")
+    expect(content).not.toContain("NpmRc")
+  })
+
+  test("should use Bun's default registry resolution", async () => {
+    // Read the bun/index.ts file
+    const bunIndexPath = path.join(__dirname, "../src/bun/index.ts")
+    const content = await fs.readFile(bunIndexPath, "utf-8")
+    
+    // Verify that it uses Bun's default resolution
+    expect(content).toContain("Bun's default registry resolution")
+    expect(content).toContain("Bun will use them automatically")
+    expect(content).toContain("No need to pass --registry flag")
+  })
+
+  test("should have correct command structure without registry", async () => {
+    // Read the bun/index.ts file
+    const bunIndexPath = path.join(__dirname, "../src/bun/index.ts")
+    const content = await fs.readFile(bunIndexPath, "utf-8")
+    
+    // Extract the install function
+    const installFunctionMatch = content.match(/export async function install[\s\S]*?^  }/m)
+    expect(installFunctionMatch).toBeTruthy()
+    
+    if (installFunctionMatch) {
+      const installFunction = installFunctionMatch[0]
+      
+      // Verify expected arguments are present
+      expect(installFunction).toContain('"add"')
+      expect(installFunction).toContain('"--force"')
+      expect(installFunction).toContain('"--exact"')
+      expect(installFunction).toContain('"--cwd"')
+      expect(installFunction).toContain('Global.Path.cache')
+      expect(installFunction).toContain('pkg + "@" + version')
+      
+      // Verify no registry argument is added
+      expect(installFunction).not.toContain('"--registry"')
+      expect(installFunction).not.toContain('args.push("--registry')
+    }
+  })
+})

packages/tui/.gitignore

@@ -1 +1,2 @@
 opencode-test
+cmd/opencode/opencode

packages/tui/cmd/opencode/main.go

@@ -91,6 +91,9 @@ func main() {
 		stream := httpClient.Event.ListStreaming(ctx)
 		for stream.Next() {
 			evt := stream.Current().AsUnion()
+			if _, ok := evt.(opencode.EventListResponseEventStorageWrite); ok {
+				continue
+			}
 			program.Send(evt)
 		}
 		if err := stream.Err(); err != nil {

packages/tui/go.mod

@@ -5,12 +5,12 @@ go 1.24.0
 require (
 	github.com/BurntSushi/toml v1.5.0
 	github.com/alecthomas/chroma/v2 v2.18.0
+	github.com/charmbracelet/bubbles v0.21.0
 	github.com/charmbracelet/bubbles/v2 v2.0.0-beta.1
 	github.com/charmbracelet/bubbletea/v2 v2.0.0-beta.4
 	github.com/charmbracelet/glamour v0.10.0
 	github.com/charmbracelet/lipgloss/v2 v2.0.0-beta.3
 	github.com/charmbracelet/x/ansi v0.9.3
-	github.com/charmbracelet/x/input v0.3.7
 	github.com/google/uuid v1.6.0
 	github.com/lithammer/fuzzysearch v1.1.8
 	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6
@@ -34,6 +34,7 @@ require (
 	github.com/atombender/go-jsonschema v0.20.0 // indirect
 	github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834 // indirect
 	github.com/charmbracelet/x/exp/slice v0.0.0-20250327172914-2fdc97757edf // indirect
+	github.com/charmbracelet/x/input v0.3.7 // indirect
 	github.com/charmbracelet/x/windows v0.2.1 // indirect
 	github.com/dprotaso/go-yit v0.0.0-20220510233725-9ba8df137936 // indirect
 	github.com/fsnotify/fsnotify v1.8.0 // indirect

packages/tui/go.sum

@@ -20,6 +20,8 @@ github.com/aymanbagabas/go-udiff v0.2.0 h1:TK0fH4MteXUDspT88n8CKzvK0X9O2xu9yQjWp
 github.com/aymanbagabas/go-udiff v0.2.0/go.mod h1:RE4Ex0qsGkTAJoQdQQCA0uG+nAzJO/pI/QwceO5fgrA=
 github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
 github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
+github.com/charmbracelet/bubbles v0.21.0 h1:9TdC97SdRVg/1aaXNVWfFH3nnLAwOXr8Fn6u6mfQdFs=
+github.com/charmbracelet/bubbles v0.21.0/go.mod h1:HF+v6QUR4HkEpz62dx7ym2xc71/KBHg+zKwJtMw+qtg=
 github.com/charmbracelet/bubbles/v2 v2.0.0-beta.1 h1:swACzss0FjnyPz1enfX56GKkLiuKg5FlyVmOLIlU2kE=
 github.com/charmbracelet/bubbles/v2 v2.0.0-beta.1/go.mod h1:6HamsBKWqEC/FVHuQMHgQL+knPyvHH55HwJDHl/adMw=
 github.com/charmbracelet/bubbletea/v2 v2.0.0-beta.4 h1:UgUuKKvBwgqm2ZEL+sKv/OLeavrUb4gfHgdxe6oIOno=

packages/tui/input/driver.go

@@ -31,42 +31,20 @@ type win32InputState struct {
 
 // Reader represents an input event reader. It reads input events and parses
 // escape sequences from the terminal input buffer and translates them into
-// human-readable events.
+// human‑readable events.
 type Reader struct {
-	rd    cancelreader.CancelReader
+	rd         cancelreader.CancelReader
-	table map[string]Key // table is a lookup table for key sequences.
+	table      map[string]Key // table is a lookup table for key sequences.
-
+	term       string         // $TERM
-	term string // term is the terminal name $TERM.
+	paste      []byte         // bracketed paste buffer; nil when disabled
-
+	buf        [256]byte      // read buffer
-	// paste is the bracketed paste mode buffer.
+	partialSeq []byte         // holds incomplete escape sequences
-	// When nil, bracketed paste mode is disabled.
+	keyState   win32InputState
-	paste []byte
+	parser     Parser
-
+	logger     Logger
-	buf [256]byte // do we need a larger buffer?
-
-	// partialSeq holds incomplete escape sequences that need more data
-	partialSeq []byte
-
-	// keyState keeps track of the current Windows Console API key events state.
-	// It is used to decode ANSI escape sequences and utf16 sequences.
-	keyState win32InputState
-
-	parser Parser
-	logger Logger
 }
 
-// NewReader returns a new input event reader. The reader reads input events
+// NewReader returns a new input event reader.
-// from the terminal and parses escape sequences into human-readable events. It
-// supports reading Terminfo databases. See [Parser] for more information.
-//
-// Example:
-//
-//	r, _ := input.NewReader(os.Stdin, os.Getenv("TERM"), 0)
-//	defer r.Close()
-//	events, _ := r.ReadEvents()
-//	for _, ev := range events {
-//	  log.Printf("%v", ev)
-//	}
 func NewReader(r io.Reader, termType string, flags int) (*Reader, error) {
 	d := new(Reader)
 	cr, err := newCancelreader(r, flags)
@@ -82,46 +60,38 @@ func NewReader(r io.Reader, termType string, flags int) (*Reader, error) {
 }
 
 // SetLogger sets a logger for the reader.
-func (d *Reader) SetLogger(l Logger) {
+func (d *Reader) SetLogger(l Logger) { d.logger = l }
-	d.logger = l
-}
 
-// Read implements [io.Reader].
+// Read implements io.Reader.
-func (d *Reader) Read(p []byte) (int, error) {
+func (d *Reader) Read(p []byte) (int, error) { return d.rd.Read(p) }
-	return d.rd.Read(p) //nolint:wrapcheck
-}
 
 // Cancel cancels the underlying reader.
-func (d *Reader) Cancel() bool {
+func (d *Reader) Cancel() bool { return d.rd.Cancel() }
-	return d.rd.Cancel()
-}
 
 // Close closes the underlying reader.
-func (d *Reader) Close() error {
+func (d *Reader) Close() error { return d.rd.Close() }
-	return d.rd.Close() //nolint:wrapcheck
-}
 
 func (d *Reader) readEvents() ([]Event, error) {
 	nb, err := d.rd.Read(d.buf[:])
 	if err != nil {
-		return nil, err //nolint:wrapcheck
+		return nil, err
 	}
 
 	var events []Event
 
-	// Combine any partial sequence from previous read with new data
+	// Combine any partial sequence from previous read with new data.
 	var buf []byte
 	if len(d.partialSeq) > 0 {
 		buf = make([]byte, len(d.partialSeq)+nb)
 		copy(buf, d.partialSeq)
 		copy(buf[len(d.partialSeq):], d.buf[:nb])
-		d.partialSeq = nil // clear the partial sequence
+		d.partialSeq = nil
 	} else {
 		buf = d.buf[:nb]
 	}
 
-	// Lookup table first
+	// Fast path: direct lookup for simple escape sequences.
-	if bytes.HasPrefix(buf, []byte{'\x1b'}) {
+	if bytes.HasPrefix(buf, []byte{0x1b}) {
 		if k, ok := d.table[string(buf)]; ok {
 			if d.logger != nil {
 				d.logger.Printf("input: %q", buf)
@@ -133,24 +103,23 @@ func (d *Reader) readEvents() ([]Event, error) {
 
 	var i int
 	for i < len(buf) {
-		nb, ev := d.parser.parseSequence(buf[i:])
+		consumed, ev := d.parser.parseSequence(buf[i:])
-		if d.logger != nil && nb > 0 {
+		if d.logger != nil && consumed > 0 {
-			d.logger.Printf("input: %q", buf[i:i+nb])
+			d.logger.Printf("input: %q", buf[i:i+consumed])
 		}
 
-		// Handle incomplete sequences - when parseSequence returns (0, nil)
+		// Incomplete sequence – store remainder and exit.
-		// it means we need more data to complete the sequence
+		if consumed == 0 && ev == nil {
-		if nb == 0 && ev == nil {
+			rem := len(buf) - i
-			// Store the remaining data for the next read
+			if rem > 0 {
-			remaining := len(buf) - i
+				d.partialSeq = make([]byte, rem)
-			if remaining > 0 {
-				d.partialSeq = make([]byte, remaining)
 				copy(d.partialSeq, buf[i:])
 			}
 			break
 		}
 
-		// Handle bracketed-paste
+		// Handle bracketed paste specially so we don’t emit a paste event for
+		// every byte.
 		if d.paste != nil {
 			if _, ok := ev.(PasteEndEvent); !ok {
 				d.paste = append(d.paste, buf[i])
@@ -160,15 +129,9 @@ func (d *Reader) readEvents() ([]Event, error) {
 		}
 
 		switch ev.(type) {
-		// case UnknownEvent:
-		// 	// If the sequence is not recognized by the parser, try looking it up.
-		// 	if k, ok := d.table[string(buf[i:i+nb])]; ok {
-		// 		ev = KeyPressEvent(k)
-		// 	}
 		case PasteStartEvent:
 			d.paste = []byte{}
 		case PasteEndEvent:
-			// Decode the captured data into runes.
 			var paste []rune
 			for len(d.paste) > 0 {
 				r, w := utf8.DecodeRune(d.paste)
@@ -177,7 +140,7 @@ func (d *Reader) readEvents() ([]Event, error) {
 				}
 				d.paste = d.paste[w:]
 			}
-			d.paste = nil // reset the buffer
+			d.paste = nil
 			events = append(events, PasteEvent(paste))
 		case nil:
 			i++
@@ -189,8 +152,41 @@ func (d *Reader) readEvents() ([]Event, error) {
 		} else {
 			events = append(events, ev)
 		}
-		i += nb
+		i += consumed
 	}
 
+	// Collapse bursts of wheel/motion events into a single event each.
+	events = coalesceMouseEvents(events)
 	return events, nil
 }
+
+// coalesceMouseEvents reduces the volume of MouseWheelEvent and MouseMotionEvent
+// objects that arrive in rapid succession by keeping only the most recent
+// event in each contiguous run.
+func coalesceMouseEvents(in []Event) []Event {
+	if len(in) < 2 {
+		return in
+	}
+
+	out := make([]Event, 0, len(in))
+	for _, ev := range in {
+		switch ev.(type) {
+		case MouseWheelEvent:
+			if len(out) > 0 {
+				if _, ok := out[len(out)-1].(MouseWheelEvent); ok {
+					out[len(out)-1] = ev // replace previous wheel event
+					continue
+				}
+			}
+		case MouseMotionEvent:
+			if len(out) > 0 {
+				if _, ok := out[len(out)-1].(MouseMotionEvent); ok {
+					out[len(out)-1] = ev // replace previous motion event
+					continue
+				}
+			}
+		}
+		out = append(out, ev)
+	}
+	return out
+}

packages/tui/input/parse.go

@@ -303,7 +303,8 @@ func (p *Parser) parseCsi(b []byte) (int, Event) {
 		return i, CursorPositionEvent{Y: row - 1, X: col - 1}
 	case 'm' | '<'<<parser.PrefixShift, 'M' | '<'<<parser.PrefixShift:
 		// Handle SGR mouse
-		if paramsLen == 3 {
+		if paramsLen >= 3 {
+			pa = pa[:3]
 			return i, parseSGRMouseEvent(cmd, pa)
 		}
 	case 'm' | '>'<<parser.PrefixShift:

packages/tui/internal/app/app.go

@@ -50,6 +50,9 @@ type App struct {
 	IsLeaderSequence bool
 }
 
+type SessionCreatedMsg = struct {
+	Session *opencode.Session
+}
 type SessionSelectedMsg = *opencode.Session
 type SessionLoadedMsg struct{}
 type ModelSelectedMsg struct {
@@ -60,14 +63,11 @@ type SessionClearedMsg struct{}
 type CompactSessionMsg struct{}
 type SendMsg struct {
 	Text        string
-	Attachments []opencode.FilePartParam
+	Attachments []opencode.FilePartInputParam
 }
 type SetEditorContentMsg struct {
 	Text string
 }
-type OptimisticMessageAddedMsg struct {
-	Message opencode.MessageUnion
-}
 type FileRenderedMsg struct {
 	FilePath string
 }
@@ -202,10 +202,17 @@ func (a *App) SetClipboard(text string) tea.Cmd {
 	return tea.Sequence(cmds...)
 }
 
-func (a *App) SwitchMode() (*App, tea.Cmd) {
+func (a *App) cycleMode(forward bool) (*App, tea.Cmd) {
-	a.ModeIndex++
+	if forward {
-	if a.ModeIndex >= len(a.Modes) {
+		a.ModeIndex++
-		a.ModeIndex = 0
+		if a.ModeIndex >= len(a.Modes) {
+			a.ModeIndex = 0
+		}
+	} else {
+		a.ModeIndex--
+		if a.ModeIndex < 0 {
+			a.ModeIndex = len(a.Modes) - 1
+		}
 	}
 	a.Mode = &a.Modes[a.ModeIndex]
 
@@ -241,8 +248,16 @@ func (a *App) SwitchMode() (*App, tea.Cmd) {
 	}
 }
 
+func (a *App) SwitchMode() (*App, tea.Cmd) {
+	return a.cycleMode(true)
+}
+
+func (a *App) SwitchModeReverse() (*App, tea.Cmd) {
+	return a.cycleMode(false)
+}
+
 func (a *App) InitializeProvider() tea.Cmd {
-	providersResponse, err := a.Client.Config.Providers(context.Background())
+	providersResponse, err := a.Client.App.Providers(context.Background())
 	if err != nil {
 		slog.Error("Failed to list providers", "error", err)
 		// TODO: notify user
@@ -337,7 +352,7 @@ func (a *App) InitializeProvider() tea.Cmd {
 }
 
 func getDefaultModel(
-	response *opencode.ConfigProvidersResponse,
+	response *opencode.AppProvidersResponse,
 	provider opencode.Provider,
 ) *opencode.Model {
 	if match, ok := response.Default[provider.ID]; ok {
@@ -380,7 +395,7 @@ func (a *App) InitializeProject(ctx context.Context) tea.Cmd {
 	}
 
 	a.Session = session
-	cmds = append(cmds, util.CmdHandler(SessionSelectedMsg(session)))
+	cmds = append(cmds, util.CmdHandler(SessionCreatedMsg{Session: session}))
 
 	go func() {
 		_, err := a.Client.Session.Init(ctx, a.Session.ID, opencode.SessionInitParams{
@@ -447,7 +462,7 @@ func (a *App) CreateSession(ctx context.Context) (*opencode.Session, error) {
 func (a *App) SendChatMessage(
 	ctx context.Context,
 	text string,
-	attachments []opencode.FilePartParam,
+	attachments []opencode.FilePartInputParam,
 ) (*App, tea.Cmd) {
 	var cmds []tea.Cmd
 	if a.Session.ID == "" {
@@ -456,7 +471,7 @@ func (a *App) SendChatMessage(
 			return a, toast.NewErrorToast(err.Error())
 		}
 		a.Session = session
-		cmds = append(cmds, util.CmdHandler(SessionSelectedMsg(session)))
+		cmds = append(cmds, util.CmdHandler(SessionCreatedMsg{Session: session}))
 	}
 
 	message := opencode.UserMessage{
@@ -490,29 +505,24 @@ func (a *App) SendChatMessage(
 	}
 
 	a.Messages = append(a.Messages, Message{Info: message, Parts: parts})
-	cmds = append(cmds, util.CmdHandler(OptimisticMessageAddedMsg{Message: message}))
 
 	cmds = append(cmds, func() tea.Msg {
 		partsParam := []opencode.SessionChatParamsPartUnion{}
 		for _, part := range parts {
 			switch casted := part.(type) {
 			case opencode.TextPart:
-				partsParam = append(partsParam, opencode.TextPartParam{
+				partsParam = append(partsParam, opencode.TextPartInputParam{
-					ID:        opencode.F(casted.ID),
+					ID:   opencode.F(casted.ID),
-					MessageID: opencode.F(casted.MessageID),
+					Type: opencode.F(opencode.TextPartInputType(casted.Type)),
-					SessionID: opencode.F(casted.SessionID),
+					Text: opencode.F(casted.Text),
-					Type:      opencode.F(casted.Type),
-					Text:      opencode.F(casted.Text),
 				})
 			case opencode.FilePart:
-				partsParam = append(partsParam, opencode.FilePartParam{
+				partsParam = append(partsParam, opencode.FilePartInputParam{
-					ID:        opencode.F(casted.ID),
+					ID:       opencode.F(casted.ID),
-					Mime:      opencode.F(casted.Mime),
+					Mime:     opencode.F(casted.Mime),
-					MessageID: opencode.F(casted.MessageID),
+					Type:     opencode.F(opencode.FilePartInputType(casted.Type)),
-					SessionID: opencode.F(casted.SessionID),
+					URL:      opencode.F(casted.URL),
-					Type:      opencode.F(casted.Type),
+					Filename: opencode.F(casted.Filename),
-					URL:       opencode.F(casted.URL),
-					Filename:  opencode.F(casted.Filename),
 				})
 			}
 		}
@@ -600,7 +610,7 @@ func (a *App) ListMessages(ctx context.Context, sessionId string) ([]Message, er
 }
 
 func (a *App) ListProviders(ctx context.Context) ([]opencode.Provider, error) {
-	response, err := a.Client.Config.Providers(ctx)
+	response, err := a.Client.App.Providers(ctx)
 	if err != nil {
 		return nil, err
 	}

packages/tui/internal/commands/command.go

@@ -87,6 +87,7 @@ func (r CommandRegistry) Matches(msg tea.KeyPressMsg, leader bool) []Command {
 const (
 	AppHelpCommand              CommandName = "app_help"
 	SwitchModeCommand           CommandName = "switch_mode"
+	SwitchModeReverseCommand    CommandName = "switch_mode_reverse"
 	EditorOpenCommand           CommandName = "editor_open"
 	SessionNewCommand           CommandName = "session_new"
 	SessionListCommand          CommandName = "session_list"
@@ -94,6 +95,7 @@ const (
 	SessionUnshareCommand       CommandName = "session_unshare"
 	SessionInterruptCommand     CommandName = "session_interrupt"
 	SessionCompactCommand       CommandName = "session_compact"
+	SessionExportCommand        CommandName = "session_export"
 	ToolDetailsCommand          CommandName = "tool_details"
 	ModelListCommand            CommandName = "model_list"
 	ThemeListCommand            CommandName = "theme_list"
@@ -155,15 +157,26 @@ func LoadFromConfig(config *opencode.Config) CommandRegistry {
 		},
 		{
 			Name:        SwitchModeCommand,
-			Description: "switch mode",
+			Description: "next mode",
 			Keybindings: parseBindings("tab"),
 		},
+		{
+			Name:        SwitchModeReverseCommand,
+			Description: "previous mode",
+			Keybindings: parseBindings("shift+tab"),
+		},
 		{
 			Name:        EditorOpenCommand,
 			Description: "open editor",
 			Keybindings: parseBindings("<leader>e"),
 			Trigger:     []string{"editor"},
 		},
+		{
+			Name:        SessionExportCommand,
+			Description: "export conversation",
+			Keybindings: parseBindings("<leader>x"),
+			Trigger:     []string{"export"},
+		},
 		{
 			Name:        SessionNewCommand,
 			Description: "new session",
@@ -217,12 +230,12 @@ func LoadFromConfig(config *opencode.Config) CommandRegistry {
 			Keybindings: parseBindings("<leader>t"),
 			Trigger:     []string{"themes"},
 		},
-		{
+		// {
-			Name:        FileListCommand,
+		// 	Name:        FileListCommand,
-			Description: "list files",
+		// 	Description: "list files",
-			Keybindings: parseBindings("<leader>f"),
+		// 	Keybindings: parseBindings("<leader>f"),
-			Trigger:     []string{"files"},
+		// 	Trigger:     []string{"files"},
-		},
+		// },
 		{
 			Name:        FileCloseCommand,
 			Description: "close file",
@@ -323,7 +336,7 @@ func LoadFromConfig(config *opencode.Config) CommandRegistry {
 			Name:        AppExitCommand,
 			Description: "exit the app",
 			Keybindings: parseBindings("ctrl+c", "<leader>q"),
-			Trigger:     []string{"exit", "quit"},
+			Trigger:     []string{"exit", "quit", "q"},
 		},
 	}
 	registry := make(CommandRegistry)
@@ -331,6 +344,10 @@ func LoadFromConfig(config *opencode.Config) CommandRegistry {
 	marshalled, _ := json.Marshal(config.Keybinds)
 	json.Unmarshal(marshalled, &keybinds)
 	for _, command := range defaults {
+		// Remove share/unshare commands if sharing is disabled
+		if config.Share == opencode.ConfigShareDisabled && (command.Name == SessionShareCommand || command.Name == SessionUnshareCommand) {
+			continue
+		}
 		if keybind, ok := keybinds[string(command.Name)]; ok && keybind != "" {
 			command.Keybindings = parseBindings(keybind)
 		}

packages/tui/internal/completions/commands.go

@@ -8,7 +8,6 @@ import (
 	"github.com/lithammer/fuzzysearch/fuzzy"
 	"github.com/sst/opencode/internal/app"
 	"github.com/sst/opencode/internal/commands"
-	"github.com/sst/opencode/internal/components/dialog"
 	"github.com/sst/opencode/internal/styles"
 	"github.com/sst/opencode/internal/theme"
 )
@@ -17,7 +16,7 @@ type CommandCompletionProvider struct {
 	app *app.App
 }
 
-func NewCommandCompletionProvider(app *app.App) dialog.CompletionProvider {
+func NewCommandCompletionProvider(app *app.App) CompletionProvider {
 	return &CommandCompletionProvider{app: app}
 }
 
@@ -32,24 +31,28 @@ func (c *CommandCompletionProvider) GetEmptyMessage() string {
 func (c *CommandCompletionProvider) getCommandCompletionItem(
 	cmd commands.Command,
 	space int,
-	t theme.Theme,
+) CompletionSuggestion {
-) dialog.CompletionItemI {
+	displayFunc := func(s styles.Style) string {
-	spacer := strings.Repeat(" ", space)
+		t := theme.CurrentTheme()
-	title := "  /" + cmd.PrimaryTrigger() + styles.NewStyle().
+		spacer := strings.Repeat(" ", space)
-		Foreground(t.TextMuted()).
+		display := "  /" + cmd.PrimaryTrigger() + s.
-		Render(spacer+cmd.Description)
+			Foreground(t.TextMuted()).
+			Render(spacer+cmd.Description)
+		return display
+	}
+
 	value := string(cmd.Name)
-	return dialog.NewCompletionItem(dialog.CompletionItem{
+	return CompletionSuggestion{
-		Title:      title,
+		Display:    displayFunc,
 		Value:      value,
 		ProviderID: c.GetId(),
-	}, dialog.WithBackgroundColor(t.BackgroundElement()))
+		RawData:    cmd,
+	}
 }
 
 func (c *CommandCompletionProvider) GetChildEntries(
 	query string,
-) ([]dialog.CompletionItemI, error) {
+) ([]CompletionSuggestion, error) {
-	t := theme.CurrentTheme()
 	commands := c.app.Commands
 
 	space := 1
@@ -63,47 +66,42 @@ func (c *CommandCompletionProvider) GetChildEntries(
 	sorted := commands.Sorted()
 	if query == "" {
 		// If no query, return all commands
-		items := []dialog.CompletionItemI{}
+		items := []CompletionSuggestion{}
 		for _, cmd := range sorted {
 			if !cmd.HasTrigger() {
 				continue
 			}
 			space := space - lipgloss.Width(cmd.PrimaryTrigger())
-			items = append(items, c.getCommandCompletionItem(cmd, space, t))
+			items = append(items, c.getCommandCompletionItem(cmd, space))
 		}
 		return items, nil
 	}
 
-	// Use fuzzy matching for commands
 	var commandNames []string
-	commandMap := make(map[string]dialog.CompletionItemI)
+	commandMap := make(map[string]CompletionSuggestion)
 
 	for _, cmd := range sorted {
 		if !cmd.HasTrigger() {
 			continue
 		}
 		space := space - lipgloss.Width(cmd.PrimaryTrigger())
-		// Add all triggers as searchable options
 		for _, trigger := range cmd.Trigger {
 			commandNames = append(commandNames, trigger)
-			commandMap[trigger] = c.getCommandCompletionItem(cmd, space, t)
+			commandMap[trigger] = c.getCommandCompletionItem(cmd, space)
 		}
 	}
 
-	// Find fuzzy matches
 	matches := fuzzy.RankFindFold(query, commandNames)
-
-	// Sort by score (best matches first)
 	sort.Sort(matches)
 
 	// Convert matches to completion items, deduplicating by command name
-	items := []dialog.CompletionItemI{}
+	items := []CompletionSuggestion{}
 	seen := make(map[string]bool)
 	for _, match := range matches {
 		if item, ok := commandMap[match.Target]; ok {
 			// Use the command's value (name) as the deduplication key
-			if !seen[item.GetValue()] {
+			if !seen[item.Value] {
-				seen[item.GetValue()] = true
+				seen[item.Value] = true
 				items = append(items, item)
 			}
 		}

packages/tui/internal/completions/files.go

@@ -9,14 +9,13 @@ import (
 
 	"github.com/sst/opencode-sdk-go"
 	"github.com/sst/opencode/internal/app"
-	"github.com/sst/opencode/internal/components/dialog"
 	"github.com/sst/opencode/internal/styles"
 	"github.com/sst/opencode/internal/theme"
 )
 
 type filesContextGroup struct {
 	app      *app.App
-	gitFiles []dialog.CompletionItemI
+	gitFiles []CompletionSuggestion
 }
 
 func (cg *filesContextGroup) GetId() string {
@@ -27,12 +26,8 @@ func (cg *filesContextGroup) GetEmptyMessage() string {
 	return "no matching files"
 }
 
-func (cg *filesContextGroup) getGitFiles() []dialog.CompletionItemI {
+func (cg *filesContextGroup) getGitFiles() []CompletionSuggestion {
-	t := theme.CurrentTheme()
+	items := make([]CompletionSuggestion, 0)
-	items := make([]dialog.CompletionItemI, 0)
-	base := styles.NewStyle().Background(t.BackgroundElement())
-	green := base.Foreground(t.Success()).Render
-	red := base.Foreground(t.Error()).Render
 
 	status, _ := cg.app.Client.File.Status(context.Background())
 	if status != nil {
@@ -42,21 +37,25 @@ func (cg *filesContextGroup) getGitFiles() []dialog.CompletionItemI {
 		})
 
 		for _, file := range files {
-			title := file.Path
+			displayFunc := func(s styles.Style) string {
-			if file.Added > 0 {
+				t := theme.CurrentTheme()
-				title += green(" +" + strconv.Itoa(int(file.Added)))
+				green := s.Foreground(t.Success()).Render
+				red := s.Foreground(t.Error()).Render
+				display := file.Path
+				if file.Added > 0 {
+					display += green(" +" + strconv.Itoa(int(file.Added)))
+				}
+				if file.Removed > 0 {
+					display += red(" -" + strconv.Itoa(int(file.Removed)))
+				}
+				return display
 			}
-			if file.Removed > 0 {
+			item := CompletionSuggestion{
-				title += red(" -" + strconv.Itoa(int(file.Removed)))
+				Display:    displayFunc,
-			}
-			item := dialog.NewCompletionItem(dialog.CompletionItem{
-				Title:      title,
 				Value:      file.Path,
 				ProviderID: cg.GetId(),
-				Raw:        file,
+				RawData:    file,
-			},
+			}
-				dialog.WithBackgroundColor(t.BackgroundElement()),
-			)
 			items = append(items, item)
 		}
 	}
@@ -66,8 +65,8 @@ func (cg *filesContextGroup) getGitFiles() []dialog.CompletionItemI {
 
 func (cg *filesContextGroup) GetChildEntries(
 	query string,
-) ([]dialog.CompletionItemI, error) {
+) ([]CompletionSuggestion, error) {
-	items := make([]dialog.CompletionItemI, 0)
+	items := make([]CompletionSuggestion, 0)
 
 	query = strings.TrimSpace(query)
 	if query == "" {
@@ -89,7 +88,7 @@ func (cg *filesContextGroup) GetChildEntries(
 	for _, file := range *files {
 		exists := false
 		for _, existing := range cg.gitFiles {
-			if existing.GetValue() == file {
+			if existing.Value == file {
 				if query != "" {
 					items = append(items, existing)
 				}
@@ -97,14 +96,18 @@ func (cg *filesContextGroup) GetChildEntries(
 			}
 		}
 		if !exists {
-			item := dialog.NewCompletionItem(dialog.CompletionItem{
+			displayFunc := func(s styles.Style) string {
-				Title:      file,
+				// t := theme.CurrentTheme()
+				// return s.Foreground(t.Text()).Render(file)
+				return s.Render(file)
+			}
+
+			item := CompletionSuggestion{
+				Display:    displayFunc,
 				Value:      file,
 				ProviderID: cg.GetId(),
-				Raw:        file,
+				RawData:    file,
-			},
+			}
-				dialog.WithBackgroundColor(theme.CurrentTheme().BackgroundElement()),
-			)
 			items = append(items, item)
 		}
 	}
@@ -112,7 +115,7 @@ func (cg *filesContextGroup) GetChildEntries(
 	return items, nil
 }
 
-func NewFileContextGroup(app *app.App) dialog.CompletionProvider {
+func NewFileContextGroup(app *app.App) CompletionProvider {
 	cg := &filesContextGroup{
 		app: app,
 	}

packages/tui/internal/completions/provider.go

@@ -0,0 +1,8 @@
+package completions
+
+// CompletionProvider defines the interface for completion data providers
+type CompletionProvider interface {
+	GetId() string
+	GetChildEntries(query string) ([]CompletionSuggestion, error)
+	GetEmptyMessage() string
+}

packages/tui/internal/completions/suggestion.go

@@ -0,0 +1,24 @@
+package completions
+
+import "github.com/sst/opencode/internal/styles"
+
+// CompletionSuggestion represents a data-only completion suggestion
+// with no styling or rendering logic
+type CompletionSuggestion struct {
+	// The text to be displayed in the list. May contain minimal inline
+	// ANSI styling if intrinsic to the data (e.g., git diff colors).
+	Display func(styles.Style) string
+
+	// The value to be used when the item is selected (e.g., inserted into the editor).
+	Value string
+
+	// An optional, longer description to be displayed.
+	Description string
+
+	// The ID of the provider that generated this suggestion.
+	ProviderID string
+
+	// The raw, underlying data object (e.g., opencode.Symbol, commands.Command).
+	// This allows the selection handler to perform rich actions.
+	RawData any
+}

packages/tui/internal/completions/symbols.go

@@ -8,7 +8,6 @@ import (
 
 	"github.com/sst/opencode-sdk-go"
 	"github.com/sst/opencode/internal/app"
-	"github.com/sst/opencode/internal/components/dialog"
 	"github.com/sst/opencode/internal/styles"
 	"github.com/sst/opencode/internal/theme"
 )
@@ -58,8 +57,8 @@ const (
 
 func (cg *symbolsContextGroup) GetChildEntries(
 	query string,
-) ([]dialog.CompletionItemI, error) {
+) ([]CompletionSuggestion, error) {
-	items := make([]dialog.CompletionItemI, 0)
+	items := make([]CompletionSuggestion, 0)
 
 	query = strings.TrimSpace(query)
 	if query == "" {
@@ -78,40 +77,42 @@ func (cg *symbolsContextGroup) GetChildEntries(
 		return items, nil
 	}
 
-	t := theme.CurrentTheme()
-	baseStyle := styles.NewStyle().Background(t.BackgroundElement())
-	base := baseStyle.Render
-	muted := baseStyle.Foreground(t.TextMuted()).Render
-
 	for _, sym := range *symbols {
 		parts := strings.Split(sym.Name, ".")
 		lastPart := parts[len(parts)-1]
-		title := base(lastPart)
-
-		uriParts := strings.Split(sym.Location.Uri, "/")
-		lastTwoParts := uriParts[len(uriParts)-2:]
-		joined := strings.Join(lastTwoParts, "/")
-		title += muted(fmt.Sprintf(" %s", joined))
-
 		start := int(sym.Location.Range.Start.Line)
 		end := int(sym.Location.Range.End.Line)
-		title += muted(fmt.Sprintf(":L%d-%d", start, end))
+
+		displayFunc := func(s styles.Style) string {
+			t := theme.CurrentTheme()
+			base := s.Foreground(t.Text()).Render
+			muted := s.Foreground(t.TextMuted()).Render
+			display := base(lastPart)
+
+			uriParts := strings.Split(sym.Location.Uri, "/")
+			lastTwoParts := uriParts[len(uriParts)-2:]
+			joined := strings.Join(lastTwoParts, "/")
+			display += muted(fmt.Sprintf(" %s", joined))
+
+			display += muted(fmt.Sprintf(":L%d-%d", start, end))
+			return display
+		}
 
 		value := fmt.Sprintf("%s?start=%d&end=%d", sym.Location.Uri, start, end)
 
-		item := dialog.NewCompletionItem(dialog.CompletionItem{
+		item := CompletionSuggestion{
-			Title:      title,
+			Display:    displayFunc,
 			Value:      value,
 			ProviderID: cg.GetId(),
-			Raw:        sym,
+			RawData:    sym,
-		})
+		}
 		items = append(items, item)
 	}
 
 	return items, nil
 }
 
-func NewSymbolsContextGroup(app *app.App) dialog.CompletionProvider {
+func NewSymbolsContextGroup(app *app.App) CompletionProvider {
 	return &symbolsContextGroup{
 		app: app,
 	}

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

@@ -1,28 +1,28 @@
 package chat
 
 import (
-	"crypto/sha256"
 	"encoding/hex"
 	"fmt"
+	"hash/fnv"
 	"sync"
 )
 
-// MessageCache caches rendered messages to avoid re-rendering
+// PartCache caches rendered messages to avoid re-rendering
-type MessageCache struct {
+type PartCache struct {
 	mu    sync.RWMutex
 	cache map[string]string
 }
 
-// NewMessageCache creates a new message cache
+// NewPartCache creates a new message cache
-func NewMessageCache() *MessageCache {
+func NewPartCache() *PartCache {
-	return &MessageCache{
+	return &PartCache{
 		cache: make(map[string]string),
 	}
 }
 
 // generateKey creates a unique key for a message based on its content and rendering parameters
-func (c *MessageCache) GenerateKey(params ...any) string {
+func (c *PartCache) GenerateKey(params ...any) string {
-	h := sha256.New()
+	h := fnv.New64a()
 	for _, param := range params {
 		h.Write(fmt.Appendf(nil, ":%v", param))
 	}
@@ -30,7 +30,7 @@ func (c *MessageCache) GenerateKey(params ...any) string {
 }
 
 // Get retrieves a cached rendered message
-func (c *MessageCache) Get(key string) (string, bool) {
+func (c *PartCache) Get(key string) (string, bool) {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 
@@ -39,14 +39,14 @@ func (c *MessageCache) Get(key string) (string, bool) {
 }
 
 // Set stores a rendered message in the cache
-func (c *MessageCache) Set(key string, content string) {
+func (c *PartCache) Set(key string, content string) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	c.cache[key] = content
 }
 
 // Clear removes all entries from the cache
-func (c *MessageCache) Clear() {
+func (c *PartCache) Clear() {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 
@@ -54,7 +54,7 @@ func (c *MessageCache) Clear() {
 }
 
 // Size returns the number of cached entries
-func (c *MessageCache) Size() int {
+func (c *PartCache) Size() int {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 

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

@@ -27,8 +27,8 @@ import (
 
 type EditorComponent interface {
 	tea.Model
-	View(width int) string
+	tea.ViewModel
-	Content(width int) string
+	Content() string
 	Lines() int
 	Value() string
 	Length() int
@@ -40,12 +40,14 @@ type EditorComponent interface {
 	Paste() (tea.Model, tea.Cmd)
 	Newline() (tea.Model, tea.Cmd)
 	SetValue(value string)
+	SetValueWithAttachments(value string)
 	SetInterruptKeyInDebounce(inDebounce bool)
 	SetExitKeyInDebounce(inDebounce bool)
 }
 
 type editorComponent struct {
 	app                    *app.App
+	width                  int
 	textarea               textarea.Model
 	spinner                spinner.Model
 	interruptKeyInDebounce bool
@@ -61,6 +63,9 @@ func (m *editorComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	var cmd tea.Cmd
 
 	switch msg := msg.(type) {
+	case tea.WindowSizeMsg:
+		m.width = msg.Width - 4
+		return m, nil
 	case spinner.TickMsg:
 		m.spinner, cmd = m.spinner.Update(msg)
 		return m, cmd
@@ -87,51 +92,13 @@ func (m *editorComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 
 		filePath := text
-		ext := strings.ToLower(filepath.Ext(filePath))
 
-		mediaType := ""
+		attachment := m.createAttachmentFromFile(filePath)
-		switch ext {
+		if attachment == nil {
-		case ".jpg":
-			mediaType = "image/jpeg"
-		case ".png", ".jpeg", ".gif", ".webp":
-			mediaType = "image/" + ext[1:]
-		case ".pdf":
-			mediaType = "application/pdf"
-		default:
-			attachment := &textarea.Attachment{
-				ID:        uuid.NewString(),
-				Display:   "@" + filePath,
-				URL:       fmt.Sprintf("file://./%s", filePath),
-				Filename:  filePath,
-				MediaType: "text/plain",
-			}
-			m.textarea.InsertAttachment(attachment)
-			m.textarea.InsertString(" ")
-			return m, nil
-		}
-
-		fileBytes, err := os.ReadFile(filePath)
-		if err != nil {
-			slog.Error("Failed to read file", "error", err)
 			m.textarea.InsertRunesFromUserInput([]rune(msg))
 			return m, nil
 		}
-		base64EncodedFile := base64.StdEncoding.EncodeToString(fileBytes)
-		url := fmt.Sprintf("data:%s;base64,%s", mediaType, base64EncodedFile)
-		attachmentCount := len(m.textarea.GetAttachments())
-		attachmentIndex := attachmentCount + 1
-		label := "File"
-		if strings.HasPrefix(mediaType, "image/") {
-			label = "Image"
-		}
 
-		attachment := &textarea.Attachment{
-			ID:        uuid.NewString(),
-			MediaType: mediaType,
-			Display:   fmt.Sprintf("[%s #%d]", label, attachmentIndex),
-			URL:       url,
-			Filename:  filePath,
-		}
 		m.textarea.InsertAttachment(attachment)
 		m.textarea.InsertString(" ")
 	case tea.ClipboardMsg:
@@ -142,9 +109,9 @@ func (m *editorComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		m.spinner = createSpinner()
 		return m, tea.Batch(m.spinner.Tick, m.textarea.Focus())
 	case dialog.CompletionSelectedMsg:
-		switch msg.Item.GetProviderID() {
+		switch msg.Item.ProviderID {
 		case "commands":
-			commandName := strings.TrimPrefix(msg.Item.GetValue(), "/")
+			commandName := strings.TrimPrefix(msg.Item.Value, "/")
 			updated, cmd := m.Clear()
 			m = updated.(*editorComponent)
 			cmds = append(cmds, cmd)
@@ -154,7 +121,7 @@ func (m *editorComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			atIndex := m.textarea.LastRuneIndex('@')
 			if atIndex == -1 {
 				// Should not happen, but as a fallback, just insert.
-				m.textarea.InsertString(msg.Item.GetValue() + " ")
+				m.textarea.InsertString(msg.Item.Value + " ")
 				return m, nil
 			}
 
@@ -165,26 +132,8 @@ func (m *editorComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 
 			// Now, insert the attachment at the position where the '@' was.
 			// The cursor is now at `atIndex` after the replacement.
-			filePath := msg.Item.GetValue()
+			filePath := msg.Item.Value
-			extension := filepath.Ext(filePath)
+			attachment := m.createAttachmentFromPath(filePath)
-			mediaType := ""
-			switch extension {
-			case ".jpg":
-				mediaType = "image/jpeg"
-			case ".png", ".jpeg", ".gif", ".webp":
-				mediaType = "image/" + extension[1:]
-			case ".pdf":
-				mediaType = "application/pdf"
-			default:
-				mediaType = "text/plain"
-			}
-			attachment := &textarea.Attachment{
-				ID:        uuid.NewString(),
-				Display:   "@" + filePath,
-				URL:       fmt.Sprintf("file://./%s", url.PathEscape(filePath)),
-				Filename:  filePath,
-				MediaType: mediaType,
-			}
 			m.textarea.InsertAttachment(attachment)
 			m.textarea.InsertString(" ")
 			return m, nil
@@ -192,20 +141,20 @@ func (m *editorComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			atIndex := m.textarea.LastRuneIndex('@')
 			if atIndex == -1 {
 				// Should not happen, but as a fallback, just insert.
-				m.textarea.InsertString(msg.Item.GetValue() + " ")
+				m.textarea.InsertString(msg.Item.Value + " ")
 				return m, nil
 			}
 
 			cursorCol := m.textarea.CursorColumn()
 			m.textarea.ReplaceRange(atIndex, cursorCol, "")
 
-			symbol := msg.Item.GetRaw().(opencode.Symbol)
+			symbol := msg.Item.RawData.(opencode.Symbol)
 			parts := strings.Split(symbol.Name, ".")
 			lastPart := parts[len(parts)-1]
 			attachment := &textarea.Attachment{
 				ID:        uuid.NewString(),
 				Display:   "@" + lastPart,
-				URL:       msg.Item.GetValue(),
+				URL:       msg.Item.Value,
 				Filename:  lastPart,
 				MediaType: "text/plain",
 			}
@@ -213,7 +162,7 @@ func (m *editorComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			m.textarea.InsertString(" ")
 			return m, nil
 		default:
-			slog.Debug("Unknown provider", "provider", msg.Item.GetProviderID())
+			slog.Debug("Unknown provider", "provider", msg.Item.ProviderID)
 			return m, nil
 		}
 	}
@@ -227,7 +176,12 @@ func (m *editorComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	return m, tea.Batch(cmds...)
 }
 
-func (m *editorComponent) Content(width int) string {
+func (m *editorComponent) Content() string {
+	width := m.width
+	if m.app.Session.ID == "" {
+		width = min(width, 80)
+	}
+
 	t := theme.CurrentTheme()
 	base := styles.NewStyle().Foreground(t.Text()).Background(t.Background()).Render
 	muted := styles.NewStyle().Foreground(t.TextMuted()).Background(t.Background()).Render
@@ -294,7 +248,12 @@ func (m *editorComponent) Content(width int) string {
 	return content
 }
 
-func (m *editorComponent) View(width int) string {
+func (m *editorComponent) View() string {
+	width := m.width
+	if m.app.Session.ID == "" {
+		width = min(width, 80)
+	}
+
 	if m.Lines() > 1 {
 		return lipgloss.Place(
 			width,
@@ -305,7 +264,7 @@ func (m *editorComponent) View(width int) string {
 			styles.WhitespaceStyle(theme.CurrentTheme().Background()),
 		)
 	}
-	return m.Content(width)
+	return m.Content()
 }
 
 func (m *editorComponent) Focused() bool {
@@ -337,9 +296,16 @@ func (m *editorComponent) Submit() (tea.Model, tea.Cmd) {
 	if value == "" {
 		return m, nil
 	}
+
+	switch value {
+	case "exit", "quit", "q", ":q":
+		return m, tea.Quit
+	}
+
 	if len(value) > 0 && value[len(value)-1] == '\\' {
 		// If the last character is a backslash, remove it and add a newline
-		m.textarea.ReplaceRange(len(value)-1, len(value), "")
+		backslashCol := m.textarea.CurrentRowLength() - 1
+		m.textarea.ReplaceRange(backslashCol, backslashCol+1, "")
 		m.textarea.InsertString("\n")
 		return m, nil
 	}
@@ -347,10 +313,10 @@ func (m *editorComponent) Submit() (tea.Model, tea.Cmd) {
 	var cmds []tea.Cmd
 
 	attachments := m.textarea.GetAttachments()
-	fileParts := make([]opencode.FilePartParam, 0)
+	fileParts := make([]opencode.FilePartInputParam, 0)
 	for _, attachment := range attachments {
-		fileParts = append(fileParts, opencode.FilePartParam{
+		fileParts = append(fileParts, opencode.FilePartInputParam{
-			Type:     opencode.F(opencode.FilePartTypeFile),
+			Type:     opencode.F(opencode.FilePartInputTypeFile),
 			Mime:     opencode.F(attachment.MediaType),
 			URL:      opencode.F(attachment.URL),
 			Filename: opencode.F(attachment.Filename),
@@ -411,6 +377,38 @@ func (m *editorComponent) SetValue(value string) {
 	m.textarea.SetValue(value)
 }
 
+func (m *editorComponent) SetValueWithAttachments(value string) {
+	m.textarea.Reset()
+
+	i := 0
+	for i < len(value) {
+		// Check if filepath and add attachment
+		if value[i] == '@' {
+			start := i + 1
+			end := start
+			for end < len(value) && value[end] != ' ' && value[end] != '\t' && value[end] != '\n' && value[end] != '\r' {
+				end++
+			}
+
+			if end > start {
+				filePath := value[start:end]
+				if _, err := os.Stat(filePath); err == nil {
+					attachment := m.createAttachmentFromFile(filePath)
+					if attachment != nil {
+						m.textarea.InsertAttachment(attachment)
+						i = end
+						continue
+					}
+				}
+			}
+		}
+
+		// Not a valid file path, insert the character normally
+		m.textarea.InsertRune(rune(value[i]))
+		i++
+	}
+}
+
 func (m *editorComponent) SetExitKeyInDebounce(inDebounce bool) {
 	m.exitKeyInDebounce = inDebounce
 }
@@ -491,3 +489,69 @@ func NewEditorComponent(app *app.App) EditorComponent {
 
 	return m
 }
+
+func getMediaTypeFromExtension(ext string) string {
+	switch strings.ToLower(ext) {
+	case ".jpg":
+		return "image/jpeg"
+	case ".png", ".jpeg", ".gif", ".webp":
+		return "image/" + ext[1:]
+	case ".pdf":
+		return "application/pdf"
+	default:
+		return "text/plain"
+	}
+}
+
+func (m *editorComponent) createAttachmentFromFile(filePath string) *textarea.Attachment {
+	ext := strings.ToLower(filepath.Ext(filePath))
+	mediaType := getMediaTypeFromExtension(ext)
+
+	// For text files, create a simple file reference
+	if mediaType == "text/plain" {
+		return &textarea.Attachment{
+			ID:        uuid.NewString(),
+			Display:   "@" + filePath,
+			URL:       fmt.Sprintf("file://./%s", filePath),
+			Filename:  filePath,
+			MediaType: mediaType,
+		}
+	}
+
+	// For binary files (images, PDFs), read and encode
+	fileBytes, err := os.ReadFile(filePath)
+	if err != nil {
+		slog.Error("Failed to read file", "error", err)
+		return nil
+	}
+
+	base64EncodedFile := base64.StdEncoding.EncodeToString(fileBytes)
+	url := fmt.Sprintf("data:%s;base64,%s", mediaType, base64EncodedFile)
+	attachmentCount := len(m.textarea.GetAttachments())
+	attachmentIndex := attachmentCount + 1
+	label := "File"
+	if strings.HasPrefix(mediaType, "image/") {
+		label = "Image"
+	}
+
+	return &textarea.Attachment{
+		ID:        uuid.NewString(),
+		MediaType: mediaType,
+		Display:   fmt.Sprintf("[%s #%d]", label, attachmentIndex),
+		URL:       url,
+		Filename:  filePath,
+	}
+}
+
+func (m *editorComponent) createAttachmentFromPath(filePath string) *textarea.Attachment {
+	extension := filepath.Ext(filePath)
+	mediaType := getMediaTypeFromExtension(extension)
+
+	return &textarea.Attachment{
+		ID:        uuid.NewString(),
+		Display:   "@" + filePath,
+		URL:       fmt.Sprintf("file://./%s", url.PathEscape(filePath)),
+		Filename:  filePath,
+		MediaType: mediaType,
+	}
+}

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

@@ -9,11 +9,11 @@ import (
 
 	"github.com/charmbracelet/lipgloss/v2"
 	"github.com/charmbracelet/lipgloss/v2/compat"
+	"github.com/charmbracelet/x/ansi"
+	"github.com/muesli/reflow/truncate"
 	"github.com/sst/opencode-sdk-go"
 	"github.com/sst/opencode/internal/app"
-	"github.com/sst/opencode/internal/commands"
 	"github.com/sst/opencode/internal/components/diff"
-	"github.com/sst/opencode/internal/layout"
 	"github.com/sst/opencode/internal/styles"
 	"github.com/sst/opencode/internal/theme"
 	"github.com/sst/opencode/internal/util"
@@ -109,7 +109,6 @@ func WithPaddingBottom(padding int) renderingOption {
 func renderContentBlock(
 	app *app.App,
 	content string,
-	highlight bool,
 	width int,
 	options ...renderingOption,
 ) string {
@@ -158,18 +157,6 @@ func renderContentBlock(
 				BorderRightBackground(t.Background())
 		}
 
-		if highlight {
-			style = style.
-				BorderLeftForeground(borderColor).
-				BorderRightForeground(borderColor)
-		}
-	}
-
-	if highlight {
-		style = style.
-			Foreground(t.Text()).
-			Background(t.BackgroundElement()).
-			Bold(true)
 	}
 
 	content = style.Render(content)
@@ -184,32 +171,6 @@ func renderContentBlock(
 		}
 	}
 
-	if highlight {
-		copy := app.Key(commands.MessagesCopyCommand)
-		// revert := app.Key(commands.MessagesRevertCommand)
-
-		background := t.Background()
-		header := layout.Render(
-			layout.FlexOptions{
-				Background: &background,
-				Direction:  layout.Row,
-				Justify:    layout.JustifyCenter,
-				Align:      layout.AlignStretch,
-				Width:      width - 2,
-				Gap:        5,
-			},
-			layout.FlexItem{
-				View: copy,
-			},
-			// layout.FlexItem{
-			// 	View: revert,
-			// },
-		)
-		header = styles.NewStyle().Background(t.Background()).Padding(0, 1).Render(header)
-
-		content = "\n\n\n" + header + "\n\n" + content + "\n\n\n"
-	}
-
 	return content
 }
 
@@ -219,7 +180,6 @@ func renderText(
 	text string,
 	author string,
 	showToolDetails bool,
-	highlight bool,
 	width int,
 	extra string,
 	toolCalls ...opencode.ToolPart,
@@ -228,9 +188,6 @@ func renderText(
 
 	var ts time.Time
 	backgroundColor := t.BackgroundPanel()
-	if highlight {
-		backgroundColor = t.BackgroundElement()
-	}
 	var content string
 	switch casted := message.(type) {
 	case opencode.AssistantMessage:
@@ -238,8 +195,25 @@ func renderText(
 		content = util.ToMarkdown(text, width, backgroundColor)
 	case opencode.UserMessage:
 		ts = time.UnixMilli(int64(casted.Time.Created))
-		messageStyle := styles.NewStyle().Background(backgroundColor).Width(width - 6)
+		base := styles.NewStyle().Foreground(t.Text()).Background(backgroundColor)
-		content = messageStyle.Render(text)
+
+		// Process @ mentions and styling with hyphen preservation
+		words := strings.Fields(text)
+		for i, word := range words {
+			if strings.HasPrefix(word, "@") {
+				words[i] = base.Foreground(t.Secondary()).Render(word + " ")
+			} else {
+				words[i] = base.Render(word + " ")
+			}
+		}
+		styledText := strings.Join(words, "")
+
+		// Apply word wrapping with hyphen preservation
+		frameSize := util.GetMessageContainerFrame()
+		wrappedText := util.ProcessTextWithHyphens(styledText, func(t string) string {
+			return ansi.WordwrapWc(t, width-frameSize, " ")
+		})
+		content = base.Width(width - frameSize).Render(wrappedText)
 	}
 
 	timestamp := ts.
@@ -277,7 +251,6 @@ func renderText(
 		return renderContentBlock(
 			app,
 			content,
-			highlight,
 			width,
 			WithTextColor(t.Text()),
 			WithBorderColorRight(t.Secondary()),
@@ -286,7 +259,6 @@ func renderText(
 		return renderContentBlock(
 			app,
 			content,
-			highlight,
 			width,
 			WithBorderColor(t.Accent()),
 		)
@@ -297,7 +269,6 @@ func renderText(
 func renderToolDetails(
 	app *app.App,
 	toolCall opencode.ToolPart,
-	highlight bool,
 	width int,
 ) string {
 	ignoredTools := []string{"todoread"}
@@ -307,7 +278,7 @@ func renderToolDetails(
 
 	if toolCall.State.Status == opencode.ToolPartStateStatusPending {
 		title := renderToolTitle(toolCall, width)
-		return renderContentBlock(app, title, highlight, width)
+		return renderContentBlock(app, title, width)
 	}
 
 	var result *string
@@ -332,129 +303,139 @@ func renderToolDetails(
 	t := theme.CurrentTheme()
 	backgroundColor := t.BackgroundPanel()
 	borderColor := t.BackgroundPanel()
-	if highlight {
+	defaultStyle := styles.NewStyle().Background(backgroundColor).Width(width - 6).Render
-		backgroundColor = t.BackgroundElement()
-		borderColor = t.BorderActive()
-	}
 
-	metadata := toolCall.State.Metadata.(map[string]any)
+	if toolCall.State.Metadata != nil {
-	switch toolCall.Tool {
+		metadata := toolCall.State.Metadata.(map[string]any)
-	case "read":
+		switch toolCall.Tool {
-		preview := metadata["preview"]
+		case "read":
-		if preview != nil && toolInputMap["filePath"] != nil {
+			var preview any
-			filename := toolInputMap["filePath"].(string)
+			if metadata != nil {
-			body = preview.(string)
+				preview = metadata["preview"]
-			body = util.RenderFile(filename, body, width, util.WithTruncate(6))
-		}
-	case "edit":
-		if filename, ok := toolInputMap["filePath"].(string); ok {
-			diffField := metadata["diff"]
-			if diffField != nil {
-				patch := diffField.(string)
-				var formattedDiff string
-				formattedDiff, _ = diff.FormatUnifiedDiff(
-					filename,
-					patch,
-					diff.WithWidth(width-2),
-				)
-				body = strings.TrimSpace(formattedDiff)
-				style := styles.NewStyle().
-					Background(backgroundColor).
-					Foreground(t.TextMuted()).
-					Padding(1, 2).
-					Width(width - 4)
-				if highlight {
-					style = style.Foreground(t.Text()).Bold(true)
-				}
-
-				if diagnostics := renderDiagnostics(metadata, filename); diagnostics != "" {
-					diagnostics = style.Render(diagnostics)
-					body += "\n" + diagnostics
-				}
-
-				title := renderToolTitle(toolCall, width)
-				title = style.Render(title)
-				content := title + "\n" + body
-				content = renderContentBlock(
-					app,
-					content,
-					highlight,
-					width,
-					WithPadding(0),
-					WithBorderColor(borderColor),
-				)
-				return content
 			}
-		}
+			if preview != nil && toolInputMap["filePath"] != nil {
-	case "write":
+				filename := toolInputMap["filePath"].(string)
-		if filename, ok := toolInputMap["filePath"].(string); ok {
+				body = preview.(string)
-			if content, ok := toolInputMap["content"].(string); ok {
+				body = util.RenderFile(filename, body, width, util.WithTruncate(6))
-				body = util.RenderFile(filename, content, width)
+			}
-				if diagnostics := renderDiagnostics(metadata, filename); diagnostics != "" {
+		case "edit":
-					body += "\n\n" + diagnostics
+			if filename, ok := toolInputMap["filePath"].(string); ok {
+				var diffField any
+				if metadata != nil {
+					diffField = metadata["diff"]
+				}
+				if diffField != nil {
+					patch := diffField.(string)
+					var formattedDiff string
+					if width < 120 {
+						formattedDiff, _ = diff.FormatUnifiedDiff(
+							filename,
+							patch,
+							diff.WithWidth(width-2),
+						)
+					} else {
+						formattedDiff, _ = diff.FormatDiff(
+							filename,
+							patch,
+							diff.WithWidth(width-2),
+						)
+					}
+					body = strings.TrimSpace(formattedDiff)
+					style := styles.NewStyle().
+						Background(backgroundColor).
+						Foreground(t.TextMuted()).
+						Padding(1, 2).
+						Width(width - 4)
+
+					if diagnostics := renderDiagnostics(metadata, filename, backgroundColor, width-6); diagnostics != "" {
+						diagnostics = style.Render(diagnostics)
+						body += "\n" + diagnostics
+					}
+
+					title := renderToolTitle(toolCall, width)
+					title = style.Render(title)
+					content := title + "\n" + body
+					content = renderContentBlock(
+						app,
+						content,
+						width,
+						WithPadding(0),
+						WithBorderColor(borderColor),
+					)
+					return content
 				}
 			}
-		}
+		case "write":
-	case "bash":
+			if filename, ok := toolInputMap["filePath"].(string); ok {
-		stdout := metadata["stdout"]
+				if content, ok := toolInputMap["content"].(string); ok {
-		if stdout != nil {
+					body = util.RenderFile(filename, content, width)
-			command := toolInputMap["command"].(string)
+					if diagnostics := renderDiagnostics(metadata, filename, backgroundColor, width-4); diagnostics != "" {
-			body = fmt.Sprintf("```console\n> %s\n%s```", command, stdout)
+						body += "\n\n" + diagnostics
-			body = util.ToMarkdown(body, width, backgroundColor)
+					}
-		}
+				}
-	case "webfetch":
+			}
-		if format, ok := toolInputMap["format"].(string); ok && result != nil {
+		case "bash":
-			body = *result
+			stdout := metadata["stdout"]
-			body = util.TruncateHeight(body, 10)
+			if stdout != nil {
-			if format == "html" || format == "markdown" {
+				command := toolInputMap["command"].(string)
+				out := ansi.Strip(fmt.Sprintf("%s", stdout))
+				body = fmt.Sprintf("```console\n> %s\n%s```", command, out)
 				body = util.ToMarkdown(body, width, backgroundColor)
 			}
-		}
+		case "webfetch":
-	case "todowrite":
+			if format, ok := toolInputMap["format"].(string); ok && result != nil {
-		todos := metadata["todos"]
+				body = *result
-		if todos != nil {
+				body = util.TruncateHeight(body, 10)
-			for _, item := range todos.([]any) {
+				if format == "html" || format == "markdown" {
-				todo := item.(map[string]any)
+					body = util.ToMarkdown(body, width, backgroundColor)
-				content := todo["content"].(string)
-				switch todo["status"] {
-				case "completed":
-					body += fmt.Sprintf("- [x] %s\n", content)
-				case "cancelled":
-					// strike through cancelled todo
-					body += fmt.Sprintf("- [~] ~~%s~~\n", content)
-				case "in_progress":
-					// highlight in progress todo
-					body += fmt.Sprintf("- [ ] `%s`\n", content)
-				default:
-					body += fmt.Sprintf("- [ ] %s\n", content)
 				}
 			}
-			body = util.ToMarkdown(body, width, backgroundColor)
+		case "todowrite":
-		}
+			todos := metadata["todos"]
-	case "task":
+			if todos != nil {
-		summary := metadata["summary"]
+				for _, item := range todos.([]any) {
-		if summary != nil {
+					todo := item.(map[string]any)
-			toolcalls := summary.([]any)
+					content := todo["content"].(string)
-			steps := []string{}
+					switch todo["status"] {
-			for _, item := range toolcalls {
+					case "completed":
-				data, _ := json.Marshal(item)
+						body += fmt.Sprintf("- [x] %s\n", content)
-				var toolCall opencode.ToolPart
+					case "cancelled":
-				_ = json.Unmarshal(data, &toolCall)
+						// strike through cancelled todo
-				step := renderToolTitle(toolCall, width)
+						body += fmt.Sprintf("- [~] ~~%s~~\n", content)
-				step = "∟ " + step
+					case "in_progress":
-				steps = append(steps, step)
+						// highlight in progress todo
+						body += fmt.Sprintf("- [ ] `%s`\n", content)
+					default:
+						body += fmt.Sprintf("- [ ] %s\n", content)
+					}
+				}
+				body = util.ToMarkdown(body, width, backgroundColor)
 			}
-			body = strings.Join(steps, "\n")
+		case "task":
+			summary := metadata["summary"]
+			if summary != nil {
+				toolcalls := summary.([]any)
+				steps := []string{}
+				for _, item := range toolcalls {
+					data, _ := json.Marshal(item)
+					var toolCall opencode.ToolPart
+					_ = json.Unmarshal(data, &toolCall)
+					step := renderToolTitle(toolCall, width)
+					step = "∟ " + step
+					steps = append(steps, step)
+				}
+				body = strings.Join(steps, "\n")
+			}
+			body = defaultStyle(body)
+		default:
+			if result == nil {
+				empty := ""
+				result = &empty
+			}
+			body = *result
+			body = util.TruncateHeight(body, 10)
+			body = defaultStyle(body)
 		}
-		body = styles.NewStyle().Width(width - 6).Render(body)
-	default:
-		if result == nil {
-			empty := ""
-			result = &empty
-		}
-		body = *result
-		body = util.TruncateHeight(body, 10)
-		body = styles.NewStyle().Width(width - 6).Render(body)
 	}
 
 	error := ""
@@ -473,12 +454,16 @@ func renderToolDetails(
 	if body == "" && error == "" && result != nil {
 		body = *result
 		body = util.TruncateHeight(body, 10)
-		body = styles.NewStyle().Width(width - 6).Render(body)
+		body = defaultStyle(body)
+	}
+
+	if body == "" {
+		body = defaultStyle("")
 	}
 
 	title := renderToolTitle(toolCall, width)
 	content := title + "\n\n" + body
-	return renderContentBlock(app, content, highlight, width, WithBorderColor(borderColor))
+	return renderContentBlock(app, content, width, WithBorderColor(borderColor))
 }
 
 func renderToolName(name string) string {
@@ -583,6 +568,8 @@ func renderToolTitle(
 		toolName := renderToolName(toolCall.Tool)
 		title = fmt.Sprintf("%s %s", toolName, toolArgs)
 	}
+
+	title = truncate.StringWithTail(title, uint(width-6), "...")
 	return title
 }
 
@@ -660,7 +647,12 @@ type Diagnostic struct {
 }
 
 // renderDiagnostics formats LSP diagnostics for display in the TUI
-func renderDiagnostics(metadata map[string]any, filePath string) string {
+func renderDiagnostics(
+	metadata map[string]any,
+	filePath string,
+	backgroundColor compat.AdaptiveColor,
+	width int,
+) string {
 	if diagnosticsData, ok := metadata["diagnostics"].(map[string]any); ok {
 		if fileDiagnostics, ok := diagnosticsData[filePath].([]any); ok {
 			var errorDiagnostics []string
@@ -696,9 +688,15 @@ func renderDiagnostics(metadata map[string]any, filePath string) string {
 			var result strings.Builder
 			for _, diagnostic := range errorDiagnostics {
 				if result.Len() > 0 {
-					result.WriteString("\n")
+					result.WriteString("\n\n")
 				}
-				result.WriteString(styles.NewStyle().Foreground(t.Error()).Render(diagnostic))
+				diagnostic = ansi.WordwrapWc(diagnostic, width, " -")
+				result.WriteString(
+					styles.NewStyle().
+						Background(backgroundColor).
+						Foreground(t.Error()).
+						Render(diagnostic),
+				)
 			}
 			return result.String()
 		}
@@ -717,5 +715,4 @@ func renderDiagnostics(metadata map[string]any, filePath string) string {
 	// if !ok {
 	// 	return ""
 	// }
-
 }

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

@@ -2,52 +2,48 @@ package chat
 
 import (
 	"fmt"
+	"log/slog"
 	"strings"
 
-	"github.com/charmbracelet/bubbles/v2/viewport"
 	tea "github.com/charmbracelet/bubbletea/v2"
 	"github.com/charmbracelet/lipgloss/v2"
 	"github.com/sst/opencode-sdk-go"
 	"github.com/sst/opencode/internal/app"
 	"github.com/sst/opencode/internal/components/dialog"
+	"github.com/sst/opencode/internal/components/toast"
 	"github.com/sst/opencode/internal/layout"
 	"github.com/sst/opencode/internal/styles"
 	"github.com/sst/opencode/internal/theme"
 	"github.com/sst/opencode/internal/util"
+	"github.com/sst/opencode/internal/viewport"
 )
 
 type MessagesComponent interface {
 	tea.Model
-	View(width, height int) string
+	tea.ViewModel
-	SetWidth(width int) tea.Cmd
 	PageUp() (tea.Model, tea.Cmd)
 	PageDown() (tea.Model, tea.Cmd)
 	HalfPageUp() (tea.Model, tea.Cmd)
 	HalfPageDown() (tea.Model, tea.Cmd)
-	First() (tea.Model, tea.Cmd)
-	Last() (tea.Model, tea.Cmd)
-	Previous() (tea.Model, tea.Cmd)
-	Next() (tea.Model, tea.Cmd)
 	ToolDetailsVisible() bool
-	Selected() string
+	GotoTop() (tea.Model, tea.Cmd)
+	GotoBottom() (tea.Model, tea.Cmd)
+	CopyLastMessage() (tea.Model, tea.Cmd)
 }
 
 type messagesComponent struct {
-	width           int
+	width, height   int
 	app             *app.App
+	header          string
 	viewport        viewport.Model
-	cache           *MessageCache
+	cache           *PartCache
-	rendering       bool
+	loading         bool
 	showToolDetails bool
+	rendering       bool
+	dirty           bool
 	tail            bool
 	partCount       int
 	lineCount       int
-	selectedPart    int
-	selectedText    string
-}
-type renderFinishedMsg struct{}
-type selectedMessagePartChangedMsg struct {
-	part int
 }
 
 type ToggleToolDetailsMsg struct{}
@@ -56,336 +52,381 @@ func (m *messagesComponent) Init() tea.Cmd {
 	return tea.Batch(m.viewport.Init())
 }
 
-func (m *messagesComponent) Selected() string {
-	return m.selectedText
-}
-
 func (m *messagesComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	measure := util.Measure("messages.Update")
+	defer measure("from", fmt.Sprintf("%T", msg))
 	var cmds []tea.Cmd
 	switch msg := msg.(type) {
+	case tea.WindowSizeMsg:
+		effectiveWidth := msg.Width - 4
+		// Clear cache on resize since width affects rendering
+		if m.width != effectiveWidth {
+			m.cache.Clear()
+		}
+		m.width = effectiveWidth
+		m.height = msg.Height - 7
+		m.viewport.SetWidth(m.width)
+		m.loading = true
+		return m, m.Reload()
 	case app.SendMsg:
 		m.viewport.GotoBottom()
 		m.tail = true
-		m.selectedPart = -1
 		return m, nil
-	case app.OptimisticMessageAddedMsg:
-		m.tail = true
-		m.rendering = true
-		return m, m.Reload()
 	case dialog.ThemeSelectedMsg:
 		m.cache.Clear()
-		m.rendering = true
+		m.loading = true
 		return m, m.Reload()
 	case ToggleToolDetailsMsg:
 		m.showToolDetails = !m.showToolDetails
-		m.rendering = true
 		return m, m.Reload()
 	case app.SessionLoadedMsg, app.SessionClearedMsg:
 		m.cache.Clear()
 		m.tail = true
-		m.rendering = true
+		m.loading = true
-		return m, m.Reload()
-	case renderFinishedMsg:
-		m.rendering = false
-		if m.tail {
-			m.viewport.GotoBottom()
-		}
-	case selectedMessagePartChangedMsg:
 		return m, m.Reload()
+
 	case opencode.EventListResponseEventSessionUpdated:
 		if msg.Properties.Info.ID == m.app.Session.ID {
-			m.renderView(m.width)
+			m.header = m.renderHeader()
-			if m.tail {
-				m.viewport.GotoBottom()
-			}
 		}
 	case opencode.EventListResponseEventMessageUpdated:
 		if msg.Properties.Info.SessionID == m.app.Session.ID {
-			m.renderView(m.width)
+			cmds = append(cmds, m.renderView())
-			if m.tail {
-				m.viewport.GotoBottom()
-			}
 		}
 	case opencode.EventListResponseEventMessagePartUpdated:
 		if msg.Properties.Part.SessionID == m.app.Session.ID {
-			m.renderView(m.width)
+			cmds = append(cmds, m.renderView())
-			if m.tail {
+		}
-				m.viewport.GotoBottom()
+	case renderCompleteMsg:
-			}
+		m.partCount = msg.partCount
+		m.lineCount = msg.lineCount
+		m.rendering = false
+		m.loading = false
+		m.tail = m.viewport.AtBottom()
+		m.viewport = msg.viewport
+		m.header = msg.header
+		if m.dirty {
+			cmds = append(cmds, m.renderView())
 		}
 	}
 
+	m.tail = m.viewport.AtBottom()
 	viewport, cmd := m.viewport.Update(msg)
 	m.viewport = viewport
-	m.tail = m.viewport.AtBottom()
 	cmds = append(cmds, cmd)
 
 	return m, tea.Batch(cmds...)
 }
 
-func (m *messagesComponent) renderView(width int) {
+type renderCompleteMsg struct {
-	measure := util.Measure("messages.renderView")
+	viewport  viewport.Model
-	defer measure("messageCount", len(m.app.Messages))
+	header    string
+	partCount int
+	lineCount int
+}
 
-	t := theme.CurrentTheme()
+func (m *messagesComponent) renderView() tea.Cmd {
-	blocks := make([]string, 0)
-	m.partCount = 0
-	m.lineCount = 0
 
-	orphanedToolCalls := make([]opencode.ToolPart, 0)
+	if m.rendering {
+		slog.Debug("pending render, skipping")
+		m.dirty = true
+		return func() tea.Msg {
+			return nil
+		}
+	}
+	m.dirty = false
+	m.rendering = true
 
-	for _, message := range m.app.Messages {
+	viewport := m.viewport
-		var content string
+	tail := m.tail
-		var cached bool
 
-		switch casted := message.Info.(type) {
+	return func() tea.Msg {
-		case opencode.UserMessage:
+		header := m.renderHeader()
-		userLoop:
+		measure := util.Measure("messages.renderView")
-			for partIndex, part := range message.Parts {
+		defer measure()
-				switch part := part.(type) {
+
-				case opencode.TextPart:
+		t := theme.CurrentTheme()
-					remainingParts := message.Parts[partIndex+1:]
+		blocks := make([]string, 0)
-					fileParts := make([]opencode.FilePart, 0)
+		partCount := 0
-					for _, part := range remainingParts {
+		lineCount := 0
-						switch part := part.(type) {
+
-						case opencode.FilePart:
+		orphanedToolCalls := make([]opencode.ToolPart, 0)
-							fileParts = append(fileParts, part)
+
+		width := m.width // always use full width
+
+		for _, message := range m.app.Messages {
+			var content string
+			var cached bool
+
+			switch casted := message.Info.(type) {
+			case opencode.UserMessage:
+				for partIndex, part := range message.Parts {
+					switch part := part.(type) {
+					case opencode.TextPart:
+						if part.Synthetic {
+							continue
 						}
-					}
+						remainingParts := message.Parts[partIndex+1:]
-					flexItems := []layout.FlexItem{}
+						fileParts := make([]opencode.FilePart, 0)
-					if len(fileParts) > 0 {
+						for _, part := range remainingParts {
-						fileStyle := styles.NewStyle().Background(t.BackgroundElement()).Foreground(t.TextMuted()).Padding(0, 1)
+							switch part := part.(type) {
-						mediaTypeStyle := styles.NewStyle().Background(t.Secondary()).Foreground(t.BackgroundPanel()).Padding(0, 1)
+							case opencode.FilePart:
-						for _, filePart := range fileParts {
+								fileParts = append(fileParts, part)
-							mediaType := ""
-							switch filePart.Mime {
-							case "text/plain":
-								mediaType = "txt"
-							case "image/png", "image/jpeg", "image/gif", "image/webp":
-								mediaType = "img"
-								mediaTypeStyle = mediaTypeStyle.Background(t.Accent())
-							case "application/pdf":
-								mediaType = "pdf"
-								mediaTypeStyle = mediaTypeStyle.Background(t.Primary())
 							}
-							flexItems = append(flexItems, layout.FlexItem{
-								View: mediaTypeStyle.Render(mediaType) + fileStyle.Render(filePart.Filename),
-							})
 						}
-					}
+						flexItems := []layout.FlexItem{}
-					bgColor := t.BackgroundPanel()
+						if len(fileParts) > 0 {
-					files := layout.Render(
+							fileStyle := styles.NewStyle().Background(t.BackgroundElement()).Foreground(t.TextMuted()).Padding(0, 1)
-						layout.FlexOptions{
+							mediaTypeStyle := styles.NewStyle().Background(t.Secondary()).Foreground(t.BackgroundPanel()).Padding(0, 1)
-							Background: &bgColor,
+							for _, filePart := range fileParts {
-							Width:      width - 6,
+								mediaType := ""
-							Direction:  layout.Column,
+								switch filePart.Mime {
-						},
+								case "text/plain":
-						flexItems...,
+									mediaType = "txt"
-					)
+								case "image/png", "image/jpeg", "image/gif", "image/webp":
-
+									mediaType = "img"
-					key := m.cache.GenerateKey(casted.ID, part.Text, width, m.selectedPart == m.partCount, files)
+									mediaTypeStyle = mediaTypeStyle.Background(t.Accent())
-					content, cached = m.cache.Get(key)
+								case "application/pdf":
-					if !cached {
+									mediaType = "pdf"
-						content = renderText(
+									mediaTypeStyle = mediaTypeStyle.Background(t.Primary())
-							m.app,
+								}
-							message.Info,
+								flexItems = append(flexItems, layout.FlexItem{
-							part.Text,
+									View: mediaTypeStyle.Render(mediaType) + fileStyle.Render(filePart.Filename),
-							m.app.Config.Username,
+								})
-							m.showToolDetails,
+							}
-							m.partCount == m.selectedPart,
+						}
-							width,
+						bgColor := t.BackgroundPanel()
-							files,
+						files := layout.Render(
+							layout.FlexOptions{
+								Background: &bgColor,
+								Width:      width - 6,
+								Direction:  layout.Column,
+							},
+							flexItems...,
 						)
-						m.cache.Set(key, content)
-					}
-					if content != "" {
-						m = m.updateSelected(content, part.Text)
-						blocks = append(blocks, content)
-					}
-					// Only render the first text part
-					break userLoop
-				}
-			}
 
-		case opencode.AssistantMessage:
+						key := m.cache.GenerateKey(casted.ID, part.Text, width, files)
-			hasTextPart := false
-			for partIndex, p := range message.Parts {
-				switch part := p.(type) {
-				case opencode.TextPart:
-					hasTextPart = true
-					finished := casted.Time.Completed > 0
-					remainingParts := message.Parts[partIndex+1:]
-					toolCallParts := make([]opencode.ToolPart, 0)
-
-					// sometimes tool calls happen without an assistant message
-					// these should be included in this assistant message as well
-					if len(orphanedToolCalls) > 0 {
-						toolCallParts = append(toolCallParts, orphanedToolCalls...)
-						orphanedToolCalls = make([]opencode.ToolPart, 0)
-					}
-
-					remaining := true
-					for _, part := range remainingParts {
-						if !remaining {
-							break
-						}
-						switch part := part.(type) {
-						case opencode.TextPart:
-							// we only want tool calls associated with the current text part.
-							// if we hit another text part, we're done.
-							remaining = false
-						case opencode.ToolPart:
-							toolCallParts = append(toolCallParts, part)
-							if part.State.Status != opencode.ToolPartStateStatusCompleted || part.State.Status != opencode.ToolPartStateStatusError {
-								// i don't think there's a case where a tool call isn't in result state
-								// and the message time is 0, but just in case
-								finished = false
-							}
-						}
-					}
-
-					if finished {
-						key := m.cache.GenerateKey(casted.ID, part.Text, width, m.showToolDetails, m.selectedPart == m.partCount)
 						content, cached = m.cache.Get(key)
 						if !cached {
+							content = renderText(
+								m.app,
+								message.Info,
+								part.Text,
+								m.app.Config.Username,
+								m.showToolDetails,
+								width,
+								files,
+							)
+							content = lipgloss.PlaceHorizontal(
+								m.width,
+								lipgloss.Center,
+								content,
+								styles.WhitespaceStyle(t.Background()),
+							)
+							m.cache.Set(key, content)
+						}
+						if content != "" {
+							partCount++
+							lineCount += lipgloss.Height(content) + 1
+							blocks = append(blocks, content)
+						}
+					}
+				}
+
+			case opencode.AssistantMessage:
+				hasTextPart := false
+				for partIndex, p := range message.Parts {
+					switch part := p.(type) {
+					case opencode.TextPart:
+						hasTextPart = true
+						finished := part.Time.End > 0
+						remainingParts := message.Parts[partIndex+1:]
+						toolCallParts := make([]opencode.ToolPart, 0)
+
+						// sometimes tool calls happen without an assistant message
+						// these should be included in this assistant message as well
+						if len(orphanedToolCalls) > 0 {
+							toolCallParts = append(toolCallParts, orphanedToolCalls...)
+							orphanedToolCalls = make([]opencode.ToolPart, 0)
+						}
+
+						remaining := true
+						for _, part := range remainingParts {
+							if !remaining {
+								break
+							}
+							switch part := part.(type) {
+							case opencode.TextPart:
+								// we only want tool calls associated with the current text part.
+								// if we hit another text part, we're done.
+								remaining = false
+							case opencode.ToolPart:
+								toolCallParts = append(toolCallParts, part)
+								if part.State.Status != opencode.ToolPartStateStatusCompleted && part.State.Status != opencode.ToolPartStateStatusError {
+									// i don't think there's a case where a tool call isn't in result state
+									// and the message time is 0, but just in case
+									finished = false
+								}
+							}
+						}
+
+						if finished {
+							key := m.cache.GenerateKey(casted.ID, part.Text, width, m.showToolDetails)
+							content, cached = m.cache.Get(key)
+							if !cached {
+								content = renderText(
+									m.app,
+									message.Info,
+									part.Text,
+									casted.ModelID,
+									m.showToolDetails,
+									width,
+									"",
+									toolCallParts...,
+								)
+								content = lipgloss.PlaceHorizontal(
+									m.width,
+									lipgloss.Center,
+									content,
+									styles.WhitespaceStyle(t.Background()),
+								)
+								m.cache.Set(key, content)
+							}
+						} else {
 							content = renderText(
 								m.app,
 								message.Info,
 								part.Text,
 								casted.ModelID,
 								m.showToolDetails,
-								m.partCount == m.selectedPart,
 								width,
 								"",
 								toolCallParts...,
 							)
-							m.cache.Set(key, content)
+							content = lipgloss.PlaceHorizontal(
+								m.width,
+								lipgloss.Center,
+								content,
+								styles.WhitespaceStyle(t.Background()),
+							)
 						}
-					} else {
+						if content != "" {
-						content = renderText(
+							partCount++
-							m.app,
+							lineCount += lipgloss.Height(content) + 1
-							message.Info,
+							blocks = append(blocks, content)
-							part.Text,
+						}
-							casted.ModelID,
+					case opencode.ToolPart:
-							m.showToolDetails,
+						if !m.showToolDetails {
-							m.partCount == m.selectedPart,
+							if !hasTextPart {
-							width,
+								orphanedToolCalls = append(orphanedToolCalls, part)
-							"",
+							}
-							toolCallParts...,
+							continue
-						)
-					}
-					if content != "" {
-						m = m.updateSelected(content, part.Text)
-						blocks = append(blocks, content)
-					}
-				case opencode.ToolPart:
-					if !m.showToolDetails {
-						if !hasTextPart {
-							orphanedToolCalls = append(orphanedToolCalls, part)
 						}
-						continue
-					}
 
-					if part.State.Status == opencode.ToolPartStateStatusCompleted || part.State.Status == opencode.ToolPartStateStatusError {
+						if part.State.Status == opencode.ToolPartStateStatusCompleted || part.State.Status == opencode.ToolPartStateStatusError {
-						key := m.cache.GenerateKey(casted.ID,
+							key := m.cache.GenerateKey(casted.ID,
-							part.ID,
+								part.ID,
-							m.showToolDetails,
+								m.showToolDetails,
-							width,
+								width,
-							m.partCount == m.selectedPart,
+							)
-						)
+							content, cached = m.cache.Get(key)
-						content, cached = m.cache.Get(key)
+							if !cached {
-						if !cached {
+								content = renderToolDetails(
+									m.app,
+									part,
+									width,
+								)
+								content = lipgloss.PlaceHorizontal(
+									m.width,
+									lipgloss.Center,
+									content,
+									styles.WhitespaceStyle(t.Background()),
+								)
+								m.cache.Set(key, content)
+							}
+						} else {
+							// if the tool call isn't finished, don't cache
 							content = renderToolDetails(
 								m.app,
 								part,
-								m.partCount == m.selectedPart,
 								width,
 							)
-							m.cache.Set(key, content)
+							content = lipgloss.PlaceHorizontal(
+								m.width,
+								lipgloss.Center,
+								content,
+								styles.WhitespaceStyle(t.Background()),
+							)
+						}
+						if content != "" {
+							partCount++
+							lineCount += lipgloss.Height(content) + 1
+							blocks = append(blocks, content)
 						}
-					} else {
-						// if the tool call isn't finished, don't cache
-						content = renderToolDetails(
-							m.app,
-							part,
-							m.partCount == m.selectedPart,
-							width,
-						)
-					}
-					if content != "" {
-						m = m.updateSelected(content, "")
-						blocks = append(blocks, content)
 					}
 				}
 			}
-		}
 
-		error := ""
+			error := ""
-		if assistant, ok := message.Info.(opencode.AssistantMessage); ok {
+			if assistant, ok := message.Info.(opencode.AssistantMessage); ok {
-			switch err := assistant.Error.AsUnion().(type) {
+				switch err := assistant.Error.AsUnion().(type) {
-			case nil:
+				case nil:
-			case opencode.AssistantMessageErrorMessageOutputLengthError:
+				case opencode.AssistantMessageErrorMessageOutputLengthError:
-				error = "Message output length exceeded"
+					error = "Message output length exceeded"
-			case opencode.ProviderAuthError:
+				case opencode.ProviderAuthError:
-				error = err.Data.Message
+					error = err.Data.Message
-			case opencode.MessageAbortedError:
+				case opencode.MessageAbortedError:
-				error = "Request was aborted"
+					error = "Request was aborted"
-			case opencode.UnknownError:
+				case opencode.UnknownError:
-				error = err.Data.Message
+					error = err.Data.Message
+				}
+			}
+
+			if error != "" {
+				error = styles.NewStyle().Width(width - 6).Render(error)
+				error = renderContentBlock(
+					m.app,
+					error,
+					width,
+					WithBorderColor(t.Error()),
+				)
+				error = lipgloss.PlaceHorizontal(
+					m.width,
+					lipgloss.Center,
+					error,
+					styles.WhitespaceStyle(t.Background()),
+				)
+				blocks = append(blocks, error)
+				lineCount += lipgloss.Height(error) + 1
 			}
 		}
 
-		if error != "" {
+		content := "\n" + strings.Join(blocks, "\n\n")
-			error = styles.NewStyle().Width(width - 6).Render(error)
+		viewport.SetHeight(m.height - lipgloss.Height(m.header))
-			error = renderContentBlock(
+		viewport.SetContent(content)
-				m.app,
+		if tail {
-				error,
+			viewport.GotoBottom()
-				false,
+		}
-				width,
+
-				WithBorderColor(t.Error()),
+		return renderCompleteMsg{
-			)
+			header:    header,
-			blocks = append(blocks, error)
+			viewport:  viewport,
-			m.lineCount += lipgloss.Height(error) + 1
+			partCount: partCount,
+			lineCount: lineCount,
 		}
 	}
-
-	m.viewport.SetContent("\n" + strings.Join(blocks, "\n\n"))
-	if m.selectedPart == m.partCount {
-		m.viewport.GotoBottom()
-	}
-
 }
 
-func (m *messagesComponent) updateSelected(content string, selectedText string) *messagesComponent {
+func (m *messagesComponent) renderHeader() string {
-	if m.selectedPart == m.partCount {
-		m.viewport.SetYOffset(m.lineCount - (m.viewport.Height() / 2) + 4)
-		m.selectedText = selectedText
-	}
-	m.partCount++
-	m.lineCount += lipgloss.Height(content) + 1
-	return m
-}
-
-func (m *messagesComponent) header(width int) string {
 	if m.app.Session.ID == "" {
 		return ""
 	}
 
+	headerWidth := m.width
+
 	t := theme.CurrentTheme()
 	base := styles.NewStyle().Foreground(t.Text()).Background(t.Background()).Render
 	muted := styles.NewStyle().Foreground(t.TextMuted()).Background(t.Background()).Render
-	headerLines := []string{}
-	headerLines = append(
-		headerLines,
-		util.ToMarkdown("# "+m.app.Session.Title, width-6, t.Background()),
-	)
-
-	share := ""
-	if m.app.Session.Share.URL != "" {
-		share = muted(m.app.Session.Share.URL + "  /unshare")
-	} else {
-		share = base("/share") + muted(" to create a shareable link")
-	}
 
 	sessionInfo := ""
 	tokens := float64(0)
@@ -419,30 +460,43 @@ func (m *messagesComponent) header(width int) string {
 		Background(t.Background()).
 		Render(formatTokensAndCost(tokens, contextWindow, cost, isSubscriptionModel))
 
+	shareEnabled := m.app.Config.Share != opencode.ConfigShareDisabled
+	headerText := util.ToMarkdown("# "+m.app.Session.Title, headerWidth-len(sessionInfo), t.Background())
+
+	var items []layout.FlexItem
+	if shareEnabled {
+		share := base("/share") + muted(" to create a shareable link")
+		if m.app.Session.Share.URL != "" {
+			share = muted(m.app.Session.Share.URL + "  /unshare")
+		}
+		items = []layout.FlexItem{{View: share}, {View: sessionInfo}}
+	} else {
+		items = []layout.FlexItem{{View: headerText}, {View: sessionInfo}}
+	}
+
 	background := t.Background()
-	share = layout.Render(
+	headerRow := layout.Render(
 		layout.FlexOptions{
 			Background: &background,
 			Direction:  layout.Row,
 			Justify:    layout.JustifySpaceBetween,
 			Align:      layout.AlignStretch,
-			Width:      width - 6,
+			Width:      headerWidth - 6,
-		},
-		layout.FlexItem{
-			View: share,
-		},
-		layout.FlexItem{
-			View: sessionInfo,
 		},
+		items...,
 	)
 
-	headerLines = append(headerLines, share)
+	var headerLines []string
+	if shareEnabled {
+		headerLines = []string{headerText, headerRow}
+	} else {
+		headerLines = []string{headerRow}
+	}
 
 	header := strings.Join(headerLines, "\n")
-
 	header = styles.NewStyle().
 		Background(t.Background()).
-		Width(width).
+		Width(headerWidth).
 		PaddingLeft(2).
 		PaddingRight(2).
 		BorderLeft(true).
@@ -451,6 +505,12 @@ func (m *messagesComponent) header(width int) string {
 		BorderForeground(t.BackgroundElement()).
 		BorderStyle(lipgloss.ThickBorder()).
 		Render(header)
+	header = lipgloss.PlaceHorizontal(
+		m.width,
+		lipgloss.Center,
+		header,
+		styles.WhitespaceStyle(t.Background()),
+	)
 
 	return "\n" + header + "\n"
 }
@@ -480,7 +540,10 @@ func formatTokensAndCost(
 		formattedTokens = strings.Replace(formattedTokens, ".0M", "M", 1)
 	}
 
-	percentage := (float64(tokens) / float64(contextWindow)) * 100
+	percentage := 0.0
+	if contextWindow > 0 {
+		percentage = (float64(tokens) / float64(contextWindow)) * 100
+	}
 
 	if isSubscriptionModel {
 		return fmt.Sprintf(
@@ -499,46 +562,29 @@ func formatTokensAndCost(
 	)
 }
 
-func (m *messagesComponent) View(width, height int) string {
+func (m *messagesComponent) View() string {
 	t := theme.CurrentTheme()
-	if m.rendering {
+	if m.loading {
 		return lipgloss.Place(
-			width,
+			m.width,
-			height,
+			m.height,
 			lipgloss.Center,
 			lipgloss.Center,
 			styles.NewStyle().Background(t.Background()).Render(""),
 			styles.WhitespaceStyle(t.Background()),
 		)
 	}
-	header := m.header(width)
-	m.viewport.SetWidth(width)
-	m.viewport.SetHeight(height - lipgloss.Height(header))
 
+	measure := util.Measure("messages.View")
+	viewport := m.viewport.View()
+	measure()
 	return styles.NewStyle().
 		Background(t.Background()).
-		Render(header + "\n" + m.viewport.View())
+		Render(m.header + "\n" + viewport)
-}
-
-func (m *messagesComponent) SetWidth(width int) tea.Cmd {
-	if m.width == width {
-		return nil
-	}
-	// Clear cache on resize since width affects rendering
-	if m.width != width {
-		m.cache.Clear()
-	}
-	m.width = width
-	m.viewport.SetWidth(width)
-	m.renderView(width)
-	return nil
 }
 
 func (m *messagesComponent) Reload() tea.Cmd {
-	return func() tea.Msg {
+	return m.renderView()
-		m.renderView(m.width)
-		return renderFinishedMsg{}
-	}
 }
 
 func (m *messagesComponent) PageUp() (tea.Model, tea.Cmd) {
@@ -561,61 +607,50 @@ func (m *messagesComponent) HalfPageDown() (tea.Model, tea.Cmd) {
 	return m, nil
 }
 
-func (m *messagesComponent) Previous() (tea.Model, tea.Cmd) {
-	m.tail = false
-	if m.selectedPart < 0 {
-		m.selectedPart = m.partCount
-	}
-	m.selectedPart--
-	if m.selectedPart < 0 {
-		m.selectedPart = 0
-	}
-	return m, util.CmdHandler(selectedMessagePartChangedMsg{
-		part: m.selectedPart,
-	})
-}
-
-func (m *messagesComponent) Next() (tea.Model, tea.Cmd) {
-	m.tail = false
-	m.selectedPart++
-	if m.selectedPart >= m.partCount {
-		m.selectedPart = m.partCount
-	}
-	return m, util.CmdHandler(selectedMessagePartChangedMsg{
-		part: m.selectedPart,
-	})
-}
-
-func (m *messagesComponent) First() (tea.Model, tea.Cmd) {
-	m.selectedPart = 0
-	m.tail = false
-	return m, util.CmdHandler(selectedMessagePartChangedMsg{
-		part: m.selectedPart,
-	})
-}
-
-func (m *messagesComponent) Last() (tea.Model, tea.Cmd) {
-	m.selectedPart = m.partCount - 1
-	m.tail = true
-	return m, util.CmdHandler(selectedMessagePartChangedMsg{
-		part: m.selectedPart,
-	})
-}
-
 func (m *messagesComponent) ToolDetailsVisible() bool {
 	return m.showToolDetails
 }
 
+func (m *messagesComponent) GotoTop() (tea.Model, tea.Cmd) {
+	m.viewport.GotoTop()
+	return m, nil
+}
+
+func (m *messagesComponent) GotoBottom() (tea.Model, tea.Cmd) {
+	m.viewport.GotoBottom()
+	return m, nil
+}
+
+func (m *messagesComponent) CopyLastMessage() (tea.Model, tea.Cmd) {
+	if len(m.app.Messages) == 0 {
+		return m, nil
+	}
+	lastMessage := m.app.Messages[len(m.app.Messages)-1]
+	var lastTextPart *opencode.TextPart
+	for _, part := range lastMessage.Parts {
+		if p, ok := part.(opencode.TextPart); ok {
+			lastTextPart = &p
+		}
+	}
+	if lastTextPart == nil {
+		return m, nil
+	}
+	var cmds []tea.Cmd
+	cmds = append(cmds, m.app.SetClipboard(lastTextPart.Text))
+	cmds = append(cmds, toast.NewSuccessToast("Message copied to clipboard"))
+	return m, tea.Batch(cmds...)
+}
+
 func NewMessagesComponent(app *app.App) MessagesComponent {
 	vp := viewport.New()
 	vp.KeyMap = viewport.KeyMap{}
+	vp.MouseWheelDelta = 4
 
 	return &messagesComponent{
 		app:             app,
 		viewport:        vp,
 		showToolDetails: true,
-		cache:           NewMessageCache(),
+		cache:           NewPartCache(),
 		tail:            true,
-		selectedPart:    -1,
 	}
 }

packages/tui/internal/components/dialog/complete.go

@@ -9,100 +9,17 @@ import (
 	"github.com/charmbracelet/bubbles/v2/textarea"
 	tea "github.com/charmbracelet/bubbletea/v2"
 	"github.com/charmbracelet/lipgloss/v2"
-	"github.com/charmbracelet/lipgloss/v2/compat"
 	"github.com/lithammer/fuzzysearch/fuzzy"
 	"github.com/muesli/reflow/truncate"
+	"github.com/sst/opencode/internal/completions"
 	"github.com/sst/opencode/internal/components/list"
 	"github.com/sst/opencode/internal/styles"
 	"github.com/sst/opencode/internal/theme"
 	"github.com/sst/opencode/internal/util"
 )
 
-type CompletionItem struct {
-	Title           string
-	Value           string
-	ProviderID      string
-	Raw             any
-	backgroundColor *compat.AdaptiveColor
-}
-
-type CompletionItemI interface {
-	list.ListItem
-	GetValue() string
-	DisplayValue() string
-	GetProviderID() string
-	GetRaw() any
-}
-
-func (ci *CompletionItem) Render(selected bool, width int, isFirstInViewport bool) string {
-	t := theme.CurrentTheme()
-	baseStyle := styles.NewStyle().Foreground(t.Text())
-
-	truncatedStr := truncate.String(string(ci.DisplayValue()), uint(width-4))
-
-	backgroundColor := t.BackgroundPanel()
-	if ci.backgroundColor != nil {
-		backgroundColor = *ci.backgroundColor
-	}
-
-	itemStyle := baseStyle.
-		Background(backgroundColor).
-		Padding(0, 1)
-
-	if selected {
-		itemStyle = itemStyle.Foreground(t.Primary())
-	}
-
-	title := itemStyle.Render(truncatedStr)
-	return title
-}
-
-func (ci *CompletionItem) DisplayValue() string {
-	return ci.Title
-}
-
-func (ci *CompletionItem) GetValue() string {
-	return ci.Value
-}
-
-func (ci *CompletionItem) GetProviderID() string {
-	return ci.ProviderID
-}
-
-func (ci *CompletionItem) GetRaw() any {
-	return ci.Raw
-}
-
-func (ci *CompletionItem) Selectable() bool {
-	return true
-}
-
-type CompletionItemOption func(*CompletionItem)
-
-func WithBackgroundColor(color compat.AdaptiveColor) CompletionItemOption {
-	return func(ci *CompletionItem) {
-		ci.backgroundColor = &color
-	}
-}
-
-func NewCompletionItem(
-	completionItem CompletionItem,
-	opts ...CompletionItemOption,
-) CompletionItemI {
-	for _, opt := range opts {
-		opt(&completionItem)
-	}
-	return &completionItem
-}
-
-type CompletionProvider interface {
-	GetId() string
-	GetChildEntries(query string) ([]CompletionItemI, error)
-	GetEmptyMessage() string
-}
-
 type CompletionSelectedMsg struct {
-	Item         CompletionItemI
+	Item         completions.CompletionSuggestion
 	SearchString string
 }
 
@@ -121,11 +38,11 @@ type CompletionDialog interface {
 
 type completionDialogComponent struct {
 	query                string
-	providers            []CompletionProvider
+	providers            []completions.CompletionProvider
 	width                int
 	height               int
 	pseudoSearchTextArea textarea.Model
-	list                 list.List[CompletionItemI]
+	list                 list.List[completions.CompletionSuggestion]
 	trigger              string
 }
 
@@ -139,7 +56,7 @@ var completionDialogKeys = completionDialogKeyMap{
 		key.WithKeys("tab", "enter", "right"),
 	),
 	Cancel: key.NewBinding(
-		key.WithKeys(" ", "esc", "backspace", "ctrl+c"),
+		key.WithKeys("space", " ", "esc", "backspace", "ctrl+h", "ctrl+c"),
 	),
 }
 
@@ -149,7 +66,8 @@ func (c *completionDialogComponent) Init() tea.Cmd {
 
 func (c *completionDialogComponent) getAllCompletions(query string) tea.Cmd {
 	return func() tea.Msg {
-		allItems := make([]CompletionItemI, 0)
+		allItems := make([]completions.CompletionSuggestion, 0)
+		providersWithResults := 0
 
 		// Collect results from all providers
 		for _, provider := range c.providers {
@@ -164,25 +82,27 @@ func (c *completionDialogComponent) getAllCompletions(query string) tea.Cmd {
 				)
 				continue
 			}
-			allItems = append(allItems, items...)
+			if len(items) > 0 {
+				providersWithResults++
+				allItems = append(allItems, items...)
+			}
 		}
 
 		// If there's a query, use fuzzy ranking to sort results
-		if query != "" && len(allItems) > 0 {
+		if query != "" && providersWithResults > 1 {
+			t := theme.CurrentTheme()
+			baseStyle := styles.NewStyle().Background(t.BackgroundElement())
 			// Create a slice of display values for fuzzy matching
 			displayValues := make([]string, len(allItems))
 			for i, item := range allItems {
-				displayValues[i] = item.DisplayValue()
+				displayValues[i] = item.Display(baseStyle)
 			}
 
-			// Get fuzzy matches with ranking
 			matches := fuzzy.RankFindFold(query, displayValues)
-
-			// Sort by score (best matches first)
 			sort.Sort(matches)
 
 			// Reorder items based on fuzzy ranking
-			rankedItems := make([]CompletionItemI, 0, len(matches))
+			rankedItems := make([]completions.CompletionSuggestion, 0, len(matches))
 			for _, match := range matches {
 				rankedItems = append(rankedItems, allItems[match.OriginalIndex])
 			}
@@ -196,7 +116,7 @@ func (c *completionDialogComponent) getAllCompletions(query string) tea.Cmd {
 func (c *completionDialogComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	var cmds []tea.Cmd
 	switch msg := msg.(type) {
-	case []CompletionItemI:
+	case []completions.CompletionSuggestion:
 		c.list.SetItems(msg)
 	case tea.KeyMsg:
 		if c.pseudoSearchTextArea.Focused() {
@@ -214,7 +134,7 @@ func (c *completionDialogComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				}
 
 				u, cmd := c.list.Update(msg)
-				c.list = u.(list.List[CompletionItemI])
+				c.list = u.(list.List[completions.CompletionSuggestion])
 				cmds = append(cmds, cmd)
 			}
 
@@ -230,7 +150,7 @@ func (c *completionDialogComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				width := lipgloss.Width(value)
 				triggerWidth := lipgloss.Width(c.trigger)
 				// Only close on backspace when there are no characters left, unless we're back to just the trigger
-				if msg.String() != "backspace" || (width <= triggerWidth && value != c.trigger) {
+				if (msg.String() != "backspace" && msg.String() != "ctrl+h") || (width <= triggerWidth && value != c.trigger) {
 					return c, c.close()
 				}
 			}
@@ -248,11 +168,11 @@ func (c *completionDialogComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 
 func (c *completionDialogComponent) View() string {
 	t := theme.CurrentTheme()
-	baseStyle := styles.NewStyle().Foreground(t.Text())
 	c.list.SetMaxWidth(c.width)
 
-	return baseStyle.
+	return styles.NewStyle().
-		Padding(0, 0).
+		Padding(0, 1).
+		Foreground(t.Text()).
 		Background(t.BackgroundElement()).
 		BorderStyle(lipgloss.ThickBorder()).
 		BorderLeft(true).
@@ -271,7 +191,7 @@ func (c *completionDialogComponent) IsEmpty() bool {
 	return c.list.IsEmpty()
 }
 
-func (c *completionDialogComponent) complete(item CompletionItemI) tea.Cmd {
+func (c *completionDialogComponent) complete(item completions.CompletionSuggestion) tea.Cmd {
 	value := c.pseudoSearchTextArea.Value()
 	return tea.Batch(
 		util.CmdHandler(CompletionSelectedMsg{
@@ -290,7 +210,7 @@ func (c *completionDialogComponent) close() tea.Cmd {
 
 func NewCompletionDialogComponent(
 	trigger string,
-	providers ...CompletionProvider,
+	providers ...completions.CompletionProvider,
 ) CompletionDialog {
 	ti := textarea.New()
 	ti.SetValue(trigger)
@@ -301,11 +221,34 @@ func NewCompletionDialogComponent(
 		emptyMessage = providers[0].GetEmptyMessage()
 	}
 
+	// Define render function for completion suggestions
+	renderFunc := func(item completions.CompletionSuggestion, selected bool, width int, baseStyle styles.Style) string {
+		t := theme.CurrentTheme()
+		style := baseStyle
+
+		if selected {
+			style = style.Background(t.BackgroundElement()).Foreground(t.Primary())
+		} else {
+			style = style.Background(t.BackgroundElement()).Foreground(t.Text())
+		}
+
+		// The item.Display string already has any inline colors from the provider
+		truncatedStr := truncate.String(item.Display(style), uint(width-4))
+		return style.Width(width - 4).Render(truncatedStr)
+	}
+
+	// Define selectable function - all completion suggestions are selectable
+	selectableFunc := func(item completions.CompletionSuggestion) bool {
+		return true
+	}
+
 	li := list.NewListComponent(
-		[]CompletionItemI{},
+		list.WithItems([]completions.CompletionSuggestion{}),
-		7,
+		list.WithMaxVisibleHeight[completions.CompletionSuggestion](7),
-		emptyMessage,
+		list.WithFallbackMessage[completions.CompletionSuggestion](emptyMessage),
-		false,
+		list.WithAlphaNumericKeys[completions.CompletionSuggestion](false),
+		list.WithRenderFunc(renderFunc),
+		list.WithSelectableFunc(selectableFunc),
 	)
 
 	c := &completionDialogComponent{
@@ -318,7 +261,7 @@ func NewCompletionDialogComponent(
 
 	// Load initial items from all providers
 	go func() {
-		allItems := make([]CompletionItemI, 0)
+		allItems := make([]completions.CompletionSuggestion, 0)
 		for _, provider := range providers {
 			items, err := provider.GetChildEntries("")
 			if err != nil {

packages/tui/internal/components/dialog/find.go

@@ -4,18 +4,29 @@ import (
 	"log/slog"
 
 	tea "github.com/charmbracelet/bubbletea/v2"
+	"github.com/sst/opencode/internal/completions"
 	"github.com/sst/opencode/internal/components/list"
 	"github.com/sst/opencode/internal/components/modal"
 	"github.com/sst/opencode/internal/layout"
+	"github.com/sst/opencode/internal/styles"
+	"github.com/sst/opencode/internal/theme"
 	"github.com/sst/opencode/internal/util"
 )
 
+const (
+	findDialogWidth = 76
+)
+
 type FindSelectedMsg struct {
 	FilePath string
 }
 
 type FindDialogCloseMsg struct{}
 
+type findInitialSuggestionsMsg struct {
+	suggestions []completions.CompletionSuggestion
+}
+
 type FindDialog interface {
 	layout.Modal
 	tea.Model
@@ -25,32 +36,102 @@ type FindDialog interface {
 	IsEmpty() bool
 }
 
+// findItem is a custom list item for file suggestions
+type findItem struct {
+	suggestion completions.CompletionSuggestion
+}
+
+func (f findItem) Render(
+	selected bool,
+	width int,
+	baseStyle styles.Style,
+) string {
+	t := theme.CurrentTheme()
+
+	itemStyle := baseStyle.
+		Background(t.BackgroundPanel()).
+		Foreground(t.TextMuted())
+
+	if selected {
+		itemStyle = itemStyle.Foreground(t.Primary())
+	}
+
+	return itemStyle.PaddingLeft(1).Render(f.suggestion.Display(itemStyle))
+}
+
+func (f findItem) Selectable() bool {
+	return true
+}
+
 type findDialogComponent struct {
-	completionProvider CompletionProvider
+	completionProvider completions.CompletionProvider
+	allSuggestions     []completions.CompletionSuggestion
 	width, height      int
 	modal              *modal.Modal
 	searchDialog       *SearchDialog
+	dialogWidth        int
 }
 
 func (f *findDialogComponent) Init() tea.Cmd {
-	return f.searchDialog.Init()
+	return tea.Batch(
+		f.loadInitialSuggestions(),
+		f.searchDialog.Init(),
+	)
+}
+
+func (f *findDialogComponent) loadInitialSuggestions() tea.Cmd {
+	return func() tea.Msg {
+		items, err := f.completionProvider.GetChildEntries("")
+		if err != nil {
+			slog.Error("Failed to get initial completion items", "error", err)
+			return findInitialSuggestionsMsg{suggestions: []completions.CompletionSuggestion{}}
+		}
+		return findInitialSuggestionsMsg{suggestions: items}
+	}
 }
 
 func (f *findDialogComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
-	case []CompletionItemI:
+	case findInitialSuggestionsMsg:
-		// Convert CompletionItemI to list.ListItem
+		// Handle initial suggestions setup
-		items := make([]list.ListItem, len(msg))
+		f.allSuggestions = msg.suggestions
-		for i, item := range msg {
+
-			items[i] = item
+		// Calculate dialog width
+		f.dialogWidth = f.calculateDialogWidth()
+
+		// Initialize search dialog with calculated width
+		f.searchDialog = NewSearchDialog("Search files...", 10)
+		f.searchDialog.SetWidth(f.dialogWidth)
+
+		// Convert to list items
+		items := make([]list.Item, len(f.allSuggestions))
+		for i, suggestion := range f.allSuggestions {
+			items[i] = findItem{suggestion: suggestion}
+		}
+		f.searchDialog.SetItems(items)
+
+		// Update modal with calculated width
+		f.modal = modal.New(
+			modal.WithTitle("Find Files"),
+			modal.WithMaxWidth(f.dialogWidth+4),
+		)
+
+		return f, f.searchDialog.Init()
+
+	case []completions.CompletionSuggestion:
+		// Store suggestions and convert to findItem for the search dialog
+		f.allSuggestions = msg
+		items := make([]list.Item, len(msg))
+		for i, suggestion := range msg {
+			items[i] = findItem{suggestion: suggestion}
 		}
 		f.searchDialog.SetItems(items)
 		return f, nil
 
 	case SearchSelectionMsg:
-		// Handle selection from search dialog
+		// Handle selection from search dialog - now we can directly access the suggestion
-		if item, ok := msg.Item.(CompletionItemI); ok {
+		if item, ok := msg.Item.(findItem); ok {
-			return f, f.selectFile(item)
+			return f, f.selectFile(item.suggestion)
 		}
 		return f, nil
 
@@ -63,9 +144,26 @@ func (f *findDialogComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			items, err := f.completionProvider.GetChildEntries(msg.Query)
 			if err != nil {
 				slog.Error("Failed to get completion items", "error", err)
+				return []completions.CompletionSuggestion{}
 			}
 			return items
 		}
+
+	case tea.WindowSizeMsg:
+		f.width = msg.Width
+		f.height = msg.Height
+		// Recalculate width based on new viewport size
+		oldWidth := f.dialogWidth
+		f.dialogWidth = f.calculateDialogWidth()
+		if oldWidth != f.dialogWidth {
+			f.searchDialog.SetWidth(f.dialogWidth)
+			// Update modal max width too
+			f.modal = modal.New(
+				modal.WithTitle("Find Files"),
+				modal.WithMaxWidth(f.dialogWidth+4),
+			)
+		}
+		f.searchDialog.SetHeight(msg.Height)
 	}
 
 	// Forward all other messages to the search dialog
@@ -78,9 +176,17 @@ func (f *findDialogComponent) View() string {
 	return f.searchDialog.View()
 }
 
+func (f *findDialogComponent) calculateDialogWidth() int {
+	// Use fixed width unless viewport is smaller
+	if f.width > 0 && f.width < findDialogWidth+10 {
+		return f.width - 10
+	}
+	return findDialogWidth
+}
+
 func (f *findDialogComponent) SetWidth(width int) {
 	f.width = width
-	f.searchDialog.SetWidth(width - 4)
+	f.searchDialog.SetWidth(f.dialogWidth)
 }
 
 func (f *findDialogComponent) SetHeight(height int) {
@@ -91,11 +197,11 @@ func (f *findDialogComponent) IsEmpty() bool {
 	return f.searchDialog.GetQuery() == ""
 }
 
-func (f *findDialogComponent) selectFile(item CompletionItemI) tea.Cmd {
+func (f *findDialogComponent) selectFile(item completions.CompletionSuggestion) tea.Cmd {
 	return tea.Sequence(
 		f.Close(),
 		util.CmdHandler(FindSelectedMsg{
-			FilePath: item.GetValue(),
+			FilePath: item.Value,
 		}),
 	)
 }
@@ -110,30 +216,21 @@ func (f *findDialogComponent) Close() tea.Cmd {
 	return util.CmdHandler(modal.CloseModalMsg{})
 }
 
-func NewFindDialog(completionProvider CompletionProvider) FindDialog {
+func NewFindDialog(completionProvider completions.CompletionProvider) FindDialog {
-	searchDialog := NewSearchDialog("Search files...", 10)
+	component := &findDialogComponent{
-
-	// Initialize with empty query to get initial items
-	go func() {
-		items, err := completionProvider.GetChildEntries("")
-		if err != nil {
-			slog.Error("Failed to get completion items", "error", err)
-			return
-		}
-		// Convert CompletionItemI to list.ListItem
-		listItems := make([]list.ListItem, len(items))
-		for i, item := range items {
-			listItems[i] = item
-		}
-		searchDialog.SetItems(listItems)
-	}()
-
-	return &findDialogComponent{
 		completionProvider: completionProvider,
-		searchDialog:       searchDialog,
+		dialogWidth:        findDialogWidth,
-		modal: modal.New(
+		allSuggestions:     []completions.CompletionSuggestion{},
-			modal.WithTitle("Find Files"),
-			modal.WithMaxWidth(80),
-		),
 	}
+
+	// Create search dialog and modal with fixed width
+	component.searchDialog = NewSearchDialog("Search files...", 10)
+	component.searchDialog.SetWidth(findDialogWidth)
+
+	component.modal = modal.New(
+		modal.WithTitle("Find Files"),
+		modal.WithMaxWidth(findDialogWidth+4),
+	)
+
+	return component
 }

packages/tui/internal/components/dialog/help.go

@@ -1,13 +1,13 @@
 package dialog
 
 import (
-	"github.com/charmbracelet/bubbles/v2/viewport"
 	tea "github.com/charmbracelet/bubbletea/v2"
 	"github.com/sst/opencode/internal/app"
 	commandsComponent "github.com/sst/opencode/internal/components/commands"
 	"github.com/sst/opencode/internal/components/modal"
 	"github.com/sst/opencode/internal/layout"
 	"github.com/sst/opencode/internal/theme"
+	"github.com/sst/opencode/internal/viewport"
 )
 
 type helpDialog struct {

packages/tui/internal/components/dialog/models.go

@@ -3,7 +3,6 @@ package dialog
 import (
 	"context"
 	"fmt"
-	"slices"
 	"sort"
 	"time"
 
@@ -24,6 +23,7 @@ const (
 	numVisibleModels = 10
 	minDialogWidth   = 40
 	maxDialogWidth   = 80
+	maxRecentModels  = 5
 )
 
 // ModelDialog interface for the model selection dialog
@@ -46,42 +46,41 @@ type ModelWithProvider struct {
 	Provider opencode.Provider
 }
 
-type ModelItem struct {
+// modelItem is a custom list item for model selections
-	ModelName    string
+type modelItem struct {
-	ProviderName string
+	model ModelWithProvider
 }
 
-func (m *ModelItem) Render(selected bool, width int, isFirstInViewport bool) string {
+func (m modelItem) Render(
+	selected bool,
+	width int,
+	baseStyle styles.Style,
+) string {
 	t := theme.CurrentTheme()
 
+	itemStyle := baseStyle.
+		Background(t.BackgroundPanel()).
+		Foreground(t.Text())
+
 	if selected {
-		displayText := fmt.Sprintf("%s (%s)", m.ModelName, m.ProviderName)
+		itemStyle = itemStyle.Foreground(t.Primary())
-		return styles.NewStyle().
-			Background(t.Primary()).
-			Foreground(t.BackgroundPanel()).
-			Width(width).
-			PaddingLeft(1).
-			Render(displayText)
-	} else {
-		modelStyle := styles.NewStyle().
-			Foreground(t.Text()).
-			Background(t.BackgroundPanel())
-		providerStyle := styles.NewStyle().
-			Foreground(t.TextMuted()).
-			Background(t.BackgroundPanel())
-
-		modelPart := modelStyle.Render(m.ModelName)
-		providerPart := providerStyle.Render(fmt.Sprintf(" (%s)", m.ProviderName))
-
-		combinedText := modelPart + providerPart
-		return styles.NewStyle().
-			Background(t.BackgroundPanel()).
-			PaddingLeft(1).
-			Render(combinedText)
 	}
+
+	providerStyle := baseStyle.
+		Foreground(t.TextMuted()).
+		Background(t.BackgroundPanel())
+
+	modelPart := itemStyle.Render(m.model.Model.Name)
+	providerPart := providerStyle.Render(fmt.Sprintf(" %s", m.model.Provider.Name))
+
+	combinedText := modelPart + providerPart
+	return baseStyle.
+		Background(t.BackgroundPanel()).
+		PaddingLeft(1).
+		Render(combinedText)
 }
 
-func (m *ModelItem) Selectable() bool {
+func (m modelItem) Selectable() bool {
 	return true
 }
 
@@ -110,26 +109,31 @@ func (m *modelDialog) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
 	case SearchSelectionMsg:
 		// Handle selection from search dialog
-		if modelItem, ok := msg.Item.(*ModelItem); ok {
+		if item, ok := msg.Item.(modelItem); ok {
-			// Find the corresponding ModelWithProvider
+			return m, tea.Sequence(
-			for _, model := range m.allModels {
+				util.CmdHandler(modal.CloseModalMsg{}),
-				if model.Model.Name == modelItem.ModelName && model.Provider.Name == modelItem.ProviderName {
+				util.CmdHandler(
-					return m, tea.Sequence(
+					app.ModelSelectedMsg{
-						util.CmdHandler(modal.CloseModalMsg{}),
+						Provider: item.model.Provider,
-						util.CmdHandler(
+						Model:    item.model.Model,
-							app.ModelSelectedMsg{
+					}),
-								Provider: model.Provider,
+			)
-								Model:    model.Model,
-							}),
-					)
-				}
-			}
 		}
 		return m, util.CmdHandler(modal.CloseModalMsg{})
-
 	case SearchCancelledMsg:
 		return m, util.CmdHandler(modal.CloseModalMsg{})
 
+	case SearchRemoveItemMsg:
+		if item, ok := msg.Item.(modelItem); ok {
+			if m.isModelInRecentSection(item.model, msg.Index) {
+				m.app.State.RemoveModelFromRecentlyUsed(item.model.Provider.ID, item.model.Model.ID)
+				m.app.SaveState()
+				items := m.buildDisplayList(m.searchDialog.GetQuery())
+				m.searchDialog.SetItems(items)
+			}
+		}
+		return m, nil
+
 	case SearchQueryChangedMsg:
 		// Update the list based on search query
 		items := m.buildDisplayList(msg.Query)
@@ -152,13 +156,13 @@ func (m *modelDialog) View() string {
 	return m.searchDialog.View()
 }
 
-func (m *modelDialog) calculateOptimalWidth(modelItems []ModelItem) int {
+func (m *modelDialog) calculateOptimalWidth(models []ModelWithProvider) int {
 	maxWidth := minDialogWidth
 
-	for _, item := range modelItems {
+	for _, model := range models {
 		// Calculate the width needed for this item: "ModelName (ProviderName)"
 		// Add 4 for the parentheses, space, and some padding
-		itemWidth := len(item.ModelName) + len(item.ProviderName) + 4
+		itemWidth := len(model.Model.Name) + len(model.Provider.Name) + 4
 		if itemWidth > maxWidth {
 			maxWidth = itemWidth
 		}
@@ -187,14 +191,7 @@ func (m *modelDialog) setupAllModels() {
 	m.sortModels()
 
 	// Calculate optimal width based on all models
-	modelItems := make([]ModelItem, len(m.allModels))
+	m.dialogWidth = m.calculateOptimalWidth(m.allModels)
-	for i, modelWithProvider := range m.allModels {
-		modelItems[i] = ModelItem{
-			ModelName:    modelWithProvider.Model.Name,
-			ProviderName: modelWithProvider.Provider.Name,
-		}
-	}
-	m.dialogWidth = m.calculateOptimalWidth(modelItems)
 
 	// Initialize search dialog
 	m.searchDialog = NewSearchDialog("Search models...", numVisibleModels)
@@ -266,7 +263,7 @@ func (m *modelDialog) getModelUsageTime(providerID, modelID string) time.Time {
 }
 
 // buildDisplayList creates the list items based on search query
-func (m *modelDialog) buildDisplayList(query string) []list.ListItem {
+func (m *modelDialog) buildDisplayList(query string) []list.Item {
 	if query != "" {
 		// Search mode: use fuzzy matching
 		return m.buildSearchResults(query)
@@ -277,7 +274,7 @@ func (m *modelDialog) buildDisplayList(query string) []list.ListItem {
 }
 
 // buildSearchResults creates a flat list of search results using fuzzy matching
-func (m *modelDialog) buildSearchResults(query string) []list.ListItem {
+func (m *modelDialog) buildSearchResults(query string) []list.Item {
 	type modelMatch struct {
 		model ModelWithProvider
 		score int
@@ -300,39 +297,33 @@ func (m *modelDialog) buildSearchResults(query string) []list.ListItem {
 	matches := fuzzy.RankFindFold(query, modelNames)
 	sort.Sort(matches)
 
-	items := []list.ListItem{}
+	items := []list.Item{}
+	seenModels := make(map[string]bool)
+
 	for _, match := range matches {
 		model := modelMap[match.Target]
-		existingItem := slices.IndexFunc(items, func(item list.ListItem) bool {
+		// Create a unique key to avoid duplicates
-			castedItem := item.(*ModelItem)
+		key := fmt.Sprintf("%s:%s", model.Provider.ID, model.Model.ID)
-			return castedItem.ModelName == model.Model.Name &&
+		if seenModels[key] {
-				castedItem.ProviderName == model.Provider.Name
-		})
-		if existingItem != -1 {
 			continue
 		}
-		items = append(items, &ModelItem{
+		seenModels[key] = true
-			ModelName:    model.Model.Name,
+		items = append(items, modelItem{model: model})
-			ProviderName: model.Provider.Name,
-		})
 	}
 
 	return items
 }
 
 // buildGroupedResults creates a grouped list with Recent section and provider groups
-func (m *modelDialog) buildGroupedResults() []list.ListItem {
+func (m *modelDialog) buildGroupedResults() []list.Item {
-	var items []list.ListItem
+	var items []list.Item
 
 	// Add Recent section
-	recentModels := m.getRecentModels(5)
+	recentModels := m.getRecentModels(maxRecentModels)
 	if len(recentModels) > 0 {
 		items = append(items, list.HeaderItem("Recent"))
 		for _, model := range recentModels {
-			items = append(items, &ModelItem{
+			items = append(items, modelItem{model: model})
-				ModelName:    model.Model.Name,
-				ProviderName: model.Provider.Name,
-			})
 		}
 	}
 
@@ -390,10 +381,7 @@ func (m *modelDialog) buildGroupedResults() []list.ListItem {
 
 		// Add models in this provider group
 		for _, model := range models {
-			items = append(items, &ModelItem{
+			items = append(items, modelItem{model: model})
-				ModelName:    model.Model.Name,
-				ProviderName: model.Provider.Name,
-			})
 		}
 	}
 
@@ -422,6 +410,28 @@ func (m *modelDialog) getRecentModels(limit int) []ModelWithProvider {
 	return recentModels
 }
 
+func (m *modelDialog) isModelInRecentSection(model ModelWithProvider, index int) bool {
+	// Only check if we're in grouped mode (no search query)
+	if m.searchDialog.GetQuery() != "" {
+		return false
+	}
+
+	recentModels := m.getRecentModels(maxRecentModels)
+	if len(recentModels) == 0 {
+		return false
+	}
+
+	// Index 0 is the "Recent" header, so recent models are at indices 1 to len(recentModels)
+	if index >= 1 && index <= len(recentModels) {
+		if index-1 < len(recentModels) {
+			recentModel := recentModels[index-1]
+			return recentModel.Provider.ID == model.Provider.ID && recentModel.Model.ID == model.Model.ID
+		}
+	}
+
+	return false
+}
+
 func (m *modelDialog) Render(background string) string {
 	return m.modal.Render(m.View(), background)
 }

packages/tui/internal/components/dialog/permission.go

@@ -1,496 +0,0 @@
-package dialog
-
-import (
-	"fmt"
-	"github.com/charmbracelet/bubbles/v2/key"
-	"github.com/charmbracelet/bubbles/v2/viewport"
-	tea "github.com/charmbracelet/bubbletea/v2"
-	"github.com/charmbracelet/lipgloss/v2"
-	"github.com/sst/opencode/internal/styles"
-	"github.com/sst/opencode/internal/theme"
-	"github.com/sst/opencode/internal/util"
-	"strings"
-)
-
-type PermissionAction string
-
-// Permission responses
-const (
-	PermissionAllow           PermissionAction = "allow"
-	PermissionAllowForSession PermissionAction = "allow_session"
-	PermissionDeny            PermissionAction = "deny"
-)
-
-// PermissionResponseMsg represents the user's response to a permission request
-type PermissionResponseMsg struct {
-	// Permission permission.PermissionRequest
-	Action PermissionAction
-}
-
-// PermissionDialogComponent interface for permission dialog component
-type PermissionDialogComponent interface {
-	tea.Model
-	tea.ViewModel
-	// SetPermissions(permission permission.PermissionRequest) tea.Cmd
-}
-
-type permissionsMapping struct {
-	Left         key.Binding
-	Right        key.Binding
-	EnterSpace   key.Binding
-	Allow        key.Binding
-	AllowSession key.Binding
-	Deny         key.Binding
-	Tab          key.Binding
-}
-
-var permissionsKeys = permissionsMapping{
-	Left: key.NewBinding(
-		key.WithKeys("left"),
-		key.WithHelp("←", "switch options"),
-	),
-	Right: key.NewBinding(
-		key.WithKeys("right"),
-		key.WithHelp("→", "switch options"),
-	),
-	EnterSpace: key.NewBinding(
-		key.WithKeys("enter", " "),
-		key.WithHelp("enter/space", "confirm"),
-	),
-	Allow: key.NewBinding(
-		key.WithKeys("a"),
-		key.WithHelp("a", "allow"),
-	),
-	AllowSession: key.NewBinding(
-		key.WithKeys("s"),
-		key.WithHelp("s", "allow for session"),
-	),
-	Deny: key.NewBinding(
-		key.WithKeys("d"),
-		key.WithHelp("d", "deny"),
-	),
-	Tab: key.NewBinding(
-		key.WithKeys("tab"),
-		key.WithHelp("tab", "switch options"),
-	),
-}
-
-// permissionDialogComponent is the implementation of PermissionDialog
-type permissionDialogComponent struct {
-	width  int
-	height int
-	// permission      permission.PermissionRequest
-	windowSize      tea.WindowSizeMsg
-	contentViewPort viewport.Model
-	selectedOption  int // 0: Allow, 1: Allow for session, 2: Deny
-
-	diffCache     map[string]string
-	markdownCache map[string]string
-}
-
-func (p *permissionDialogComponent) Init() tea.Cmd {
-	return p.contentViewPort.Init()
-}
-
-func (p *permissionDialogComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	var cmds []tea.Cmd
-
-	switch msg := msg.(type) {
-	case tea.WindowSizeMsg:
-		p.windowSize = msg
-		cmd := p.SetSize()
-		cmds = append(cmds, cmd)
-		p.markdownCache = make(map[string]string)
-		p.diffCache = make(map[string]string)
-		// case tea.KeyMsg:
-		// 	switch {
-		// 	case key.Matches(msg, permissionsKeys.Right) || key.Matches(msg, permissionsKeys.Tab):
-		// 		p.selectedOption = (p.selectedOption + 1) % 3
-		// 		return p, nil
-		// 	case key.Matches(msg, permissionsKeys.Left):
-		// 		p.selectedOption = (p.selectedOption + 2) % 3
-		// 	case key.Matches(msg, permissionsKeys.EnterSpace):
-		// 		return p, p.selectCurrentOption()
-		// 	case key.Matches(msg, permissionsKeys.Allow):
-		// 		return p, util.CmdHandler(PermissionResponseMsg{Action: PermissionAllow, Permission: p.permission})
-		// 	case key.Matches(msg, permissionsKeys.AllowSession):
-		// 		return p, util.CmdHandler(PermissionResponseMsg{Action: PermissionAllowForSession, Permission: p.permission})
-		// 	case key.Matches(msg, permissionsKeys.Deny):
-		// 		return p, util.CmdHandler(PermissionResponseMsg{Action: PermissionDeny, Permission: p.permission})
-		// 	default:
-		// 		// Pass other keys to viewport
-		// 		viewPort, cmd := p.contentViewPort.Update(msg)
-		// 		p.contentViewPort = viewPort
-		// 		cmds = append(cmds, cmd)
-		// 	}
-	}
-
-	return p, tea.Batch(cmds...)
-}
-
-func (p *permissionDialogComponent) selectCurrentOption() tea.Cmd {
-	var action PermissionAction
-
-	switch p.selectedOption {
-	case 0:
-		action = PermissionAllow
-	case 1:
-		action = PermissionAllowForSession
-	case 2:
-		action = PermissionDeny
-	}
-
-	return util.CmdHandler(PermissionResponseMsg{Action: action}) // , Permission: p.permission})
-}
-
-func (p *permissionDialogComponent) renderButtons() string {
-	t := theme.CurrentTheme()
-	baseStyle := styles.NewStyle().Foreground(t.Text())
-
-	allowStyle := baseStyle
-	allowSessionStyle := baseStyle
-	denyStyle := baseStyle
-	spacerStyle := baseStyle.Background(t.Background())
-
-	// Style the selected button
-	switch p.selectedOption {
-	case 0:
-		allowStyle = allowStyle.Background(t.Primary()).Foreground(t.Background())
-		allowSessionStyle = allowSessionStyle.Background(t.Background()).Foreground(t.Primary())
-		denyStyle = denyStyle.Background(t.Background()).Foreground(t.Primary())
-	case 1:
-		allowStyle = allowStyle.Background(t.Background()).Foreground(t.Primary())
-		allowSessionStyle = allowSessionStyle.Background(t.Primary()).Foreground(t.Background())
-		denyStyle = denyStyle.Background(t.Background()).Foreground(t.Primary())
-	case 2:
-		allowStyle = allowStyle.Background(t.Background()).Foreground(t.Primary())
-		allowSessionStyle = allowSessionStyle.Background(t.Background()).Foreground(t.Primary())
-		denyStyle = denyStyle.Background(t.Primary()).Foreground(t.Background())
-	}
-
-	allowButton := allowStyle.Padding(0, 1).Render("Allow (a)")
-	allowSessionButton := allowSessionStyle.Padding(0, 1).Render("Allow for session (s)")
-	denyButton := denyStyle.Padding(0, 1).Render("Deny (d)")
-
-	content := lipgloss.JoinHorizontal(
-		lipgloss.Left,
-		allowButton,
-		spacerStyle.Render("  "),
-		allowSessionButton,
-		spacerStyle.Render("  "),
-		denyButton,
-		spacerStyle.Render("  "),
-	)
-
-	remainingWidth := p.width - lipgloss.Width(content)
-	if remainingWidth > 0 {
-		content = spacerStyle.Render(strings.Repeat(" ", remainingWidth)) + content
-	}
-	return content
-}
-
-func (p *permissionDialogComponent) renderHeader() string {
-	return "NOT IMPLEMENTED"
-	// t := theme.CurrentTheme()
-	// baseStyle := styles.BaseStyle()
-	//
-	// toolKey := baseStyle.Foreground(t.TextMuted()).Bold(true).Render("Tool")
-	// toolValue := baseStyle.
-	// 	Foreground(t.Text()).
-	// 	Width(p.width - lipgloss.Width(toolKey)).
-	// 	Render(fmt.Sprintf(": %s", p.permission.ToolName))
-	//
-	// pathKey := baseStyle.Foreground(t.TextMuted()).Bold(true).Render("Path")
-	//
-	// // Get the current working directory to display relative path
-	// relativePath := p.permission.Path
-	// if filepath.IsAbs(relativePath) {
-	// 	if cwd, err := filepath.Rel(config.WorkingDirectory(), relativePath); err == nil {
-	// 		relativePath = cwd
-	// 	}
-	// }
-	//
-	// pathValue := baseStyle.
-	// 	Foreground(t.Text()).
-	// 	Width(p.width - lipgloss.Width(pathKey)).
-	// 	Render(fmt.Sprintf(": %s", relativePath))
-	//
-	// headerParts := []string{
-	// 	lipgloss.JoinHorizontal(
-	// 		lipgloss.Left,
-	// 		toolKey,
-	// 		toolValue,
-	// 	),
-	// 	baseStyle.Render(strings.Repeat(" ", p.width)),
-	// 	lipgloss.JoinHorizontal(
-	// 		lipgloss.Left,
-	// 		pathKey,
-	// 		pathValue,
-	// 	),
-	// 	baseStyle.Render(strings.Repeat(" ", p.width)),
-	// }
-	//
-	// // Add tool-specific header information
-	// switch p.permission.ToolName {
-	// case "bash":
-	// 	headerParts = append(headerParts, baseStyle.Foreground(t.TextMuted()).Width(p.width).Bold(true).Render("Command"))
-	// case "edit":
-	// 	headerParts = append(headerParts, baseStyle.Foreground(t.TextMuted()).Width(p.width).Bold(true).Render("Diff"))
-	// case "write":
-	// 	headerParts = append(headerParts, baseStyle.Foreground(t.TextMuted()).Width(p.width).Bold(true).Render("Diff"))
-	// case "fetch":
-	// 	headerParts = append(headerParts, baseStyle.Foreground(t.TextMuted()).Width(p.width).Bold(true).Render("URL"))
-	// }
-	//
-	// return lipgloss.NewStyle().Background(t.Background()).Render(lipgloss.JoinVertical(lipgloss.Left, headerParts...))
-}
-
-func (p *permissionDialogComponent) renderBashContent() string {
-	// t := theme.CurrentTheme()
-	// baseStyle := styles.BaseStyle()
-	//
-	// if pr, ok := p.permission.Params.(tools.BashPermissionsParams); ok {
-	// 	content := fmt.Sprintf("```bash\n%s\n```", pr.Command)
-	//
-	// 	// Use the cache for markdown rendering
-	// 	renderedContent := p.GetOrSetMarkdown(p.permission.ID, func() (string, error) {
-	// 		r := styles.GetMarkdownRenderer(p.width - 10)
-	// 		s, err := r.Render(content)
-	//    return s
-	// 	})
-	//
-	// 	finalContent := baseStyle.
-	// 		Width(p.contentViewPort.Width).
-	// 		Render(renderedContent)
-	// 	p.contentViewPort.SetContent(finalContent)
-	// 	return p.styleViewport()
-	// }
-	return ""
-}
-
-func (p *permissionDialogComponent) renderEditContent() string {
-	// if pr, ok := p.permission.Params.(tools.EditPermissionsParams); ok {
-	// 	diff := p.GetOrSetDiff(p.permission.ID, func() (string, error) {
-	// 		return diff.FormatDiff(pr.Diff, diff.WithTotalWidth(p.contentViewPort.Width))
-	// 	})
-	//
-	// 	p.contentViewPort.SetContent(diff)
-	// 	return p.styleViewport()
-	// }
-	return ""
-}
-
-func (p *permissionDialogComponent) renderPatchContent() string {
-	// if pr, ok := p.permission.Params.(tools.EditPermissionsParams); ok {
-	// 	diff := p.GetOrSetDiff(p.permission.ID, func() (string, error) {
-	// 		return diff.FormatDiff(pr.Diff, diff.WithTotalWidth(p.contentViewPort.Width))
-	// 	})
-	//
-	// 	p.contentViewPort.SetContent(diff)
-	// 	return p.styleViewport()
-	// }
-	return ""
-}
-
-func (p *permissionDialogComponent) renderWriteContent() string {
-	// if pr, ok := p.permission.Params.(tools.WritePermissionsParams); ok {
-	// 	// Use the cache for diff rendering
-	// 	diff := p.GetOrSetDiff(p.permission.ID, func() (string, error) {
-	// 		return diff.FormatDiff(pr.Diff, diff.WithTotalWidth(p.contentViewPort.Width))
-	// 	})
-	//
-	// 	p.contentViewPort.SetContent(diff)
-	// 	return p.styleViewport()
-	// }
-	return ""
-}
-
-func (p *permissionDialogComponent) renderFetchContent() string {
-	// 	t := theme.CurrentTheme()
-	// 	baseStyle := styles.BaseStyle()
-	//
-	// 	if pr, ok := p.permission.Params.(tools.FetchPermissionsParams); ok {
-	// 		content := fmt.Sprintf("```bash\n%s\n```", pr.URL)
-	//
-	// 		// Use the cache for markdown rendering
-	// 		renderedContent := p.GetOrSetMarkdown(p.permission.ID, func() (string, error) {
-	// 			r := styles.GetMarkdownRenderer(p.width - 10)
-	// 			s, err := r.Render(content)
-	//      return s
-	// 		})
-	//
-	// 		finalContent := baseStyle.
-	// 			Width(p.contentViewPort.Width).
-	// 			Render(renderedContent)
-	// 		p.contentViewPort.SetContent(finalContent)
-	// 		return p.styleViewport()
-	// 	}
-	return ""
-}
-
-func (p *permissionDialogComponent) renderDefaultContent() string {
-	// 	t := theme.CurrentTheme()
-	// 	baseStyle := styles.BaseStyle()
-	//
-	// 	content := p.permission.Description
-	//
-	// 	// Use the cache for markdown rendering
-	// 	renderedContent := p.GetOrSetMarkdown(p.permission.ID, func() (string, error) {
-	// 		r := styles.GetMarkdownRenderer(p.width - 10)
-	// 		s, err := r.Render(content)
-	//    return s
-	// 	})
-	//
-	// 	finalContent := baseStyle.
-	// 		Width(p.contentViewPort.Width).
-	// 		Render(renderedContent)
-	// 	p.contentViewPort.SetContent(finalContent)
-	//
-	// 	if renderedContent == "" {
-	// 		return ""
-	// 	}
-	//
-	return p.styleViewport()
-}
-
-func (p *permissionDialogComponent) styleViewport() string {
-	t := theme.CurrentTheme()
-	contentStyle := styles.NewStyle().Background(t.Background())
-
-	return contentStyle.Render(p.contentViewPort.View())
-}
-
-func (p *permissionDialogComponent) render() string {
-	return "NOT IMPLEMENTED"
-	// t := theme.CurrentTheme()
-	// baseStyle := styles.BaseStyle()
-	//
-	// title := baseStyle.
-	// 	Bold(true).
-	// 	Width(p.width - 4).
-	// 	Foreground(t.Primary()).
-	// 	Render("Permission Required")
-	// // Render header
-	// headerContent := p.renderHeader()
-	// // Render buttons
-	// buttons := p.renderButtons()
-	//
-	// // Calculate content height dynamically based on window size
-	// p.contentViewPort.Height = p.height - lipgloss.Height(headerContent) - lipgloss.Height(buttons) - 2 - lipgloss.Height(title)
-	// p.contentViewPort.Width = p.width - 4
-	//
-	// // Render content based on tool type
-	// var contentFinal string
-	// switch p.permission.ToolName {
-	// case "bash":
-	// 	contentFinal = p.renderBashContent()
-	// case "edit":
-	// 	contentFinal = p.renderEditContent()
-	// case "patch":
-	// 	contentFinal = p.renderPatchContent()
-	// case "write":
-	// 	contentFinal = p.renderWriteContent()
-	// case "fetch":
-	// 	contentFinal = p.renderFetchContent()
-	// default:
-	// 	contentFinal = p.renderDefaultContent()
-	// }
-	//
-	// content := lipgloss.JoinVertical(
-	// 	lipgloss.Top,
-	// 	title,
-	// 	baseStyle.Render(strings.Repeat(" ", lipgloss.Width(title))),
-	// 	headerContent,
-	// 	contentFinal,
-	// 	buttons,
-	// 	baseStyle.Render(strings.Repeat(" ", p.width-4)),
-	// )
-	//
-	// return baseStyle.
-	// 	Padding(1, 0, 0, 1).
-	// 	Border(lipgloss.RoundedBorder()).
-	// 	BorderBackground(t.Background()).
-	// 	BorderForeground(t.TextMuted()).
-	// 	Width(p.width).
-	// 	Height(p.height).
-	// 	Render(
-	// 		content,
-	// 	)
-}
-
-func (p *permissionDialogComponent) View() string {
-	return p.render()
-}
-
-func (p *permissionDialogComponent) SetSize() tea.Cmd {
-	// if p.permission.ID == "" {
-	// 	return nil
-	// }
-	// switch p.permission.ToolName {
-	// case "bash":
-	// 	p.width = int(float64(p.windowSize.Width) * 0.4)
-	// 	p.height = int(float64(p.windowSize.Height) * 0.3)
-	// case "edit":
-	// 	p.width = int(float64(p.windowSize.Width) * 0.8)
-	// 	p.height = int(float64(p.windowSize.Height) * 0.8)
-	// case "write":
-	// 	p.width = int(float64(p.windowSize.Width) * 0.8)
-	// 	p.height = int(float64(p.windowSize.Height) * 0.8)
-	// case "fetch":
-	// 	p.width = int(float64(p.windowSize.Width) * 0.4)
-	// 	p.height = int(float64(p.windowSize.Height) * 0.3)
-	// default:
-	// 	p.width = int(float64(p.windowSize.Width) * 0.7)
-	// 	p.height = int(float64(p.windowSize.Height) * 0.5)
-	// }
-	return nil
-}
-
-// func (p *permissionDialogCmp) SetPermissions(permission permission.PermissionRequest) tea.Cmd {
-// 	p.permission = permission
-// 	return p.SetSize()
-// }
-
-// Helper to get or set cached diff content
-func (c *permissionDialogComponent) GetOrSetDiff(key string, generator func() (string, error)) string {
-	if cached, ok := c.diffCache[key]; ok {
-		return cached
-	}
-
-	content, err := generator()
-	if err != nil {
-		return fmt.Sprintf("Error formatting diff: %v", err)
-	}
-
-	c.diffCache[key] = content
-
-	return content
-}
-
-// Helper to get or set cached markdown content
-func (c *permissionDialogComponent) GetOrSetMarkdown(key string, generator func() (string, error)) string {
-	if cached, ok := c.markdownCache[key]; ok {
-		return cached
-	}
-
-	content, err := generator()
-	if err != nil {
-		return fmt.Sprintf("Error rendering markdown: %v", err)
-	}
-
-	c.markdownCache[key] = content
-
-	return content
-}
-
-func NewPermissionDialogCmp() PermissionDialogComponent {
-	// Create viewport for content
-	contentViewport := viewport.New() // (0, 0)
-
-	return &permissionDialogComponent{
-		contentViewPort: contentViewport,
-		selectedOption:  0, // Default to "Allow"
-		diffCache:       make(map[string]string),
-		markdownCache:   make(map[string]string),
-	}
-}

packages/tui/internal/components/dialog/search.go

@@ -17,17 +17,23 @@ type SearchQueryChangedMsg struct {
 
 // SearchSelectionMsg is emitted when an item is selected
 type SearchSelectionMsg struct {
-	Item  interface{}
+	Item  any
 	Index int
 }
 
 // SearchCancelledMsg is emitted when the search is cancelled
 type SearchCancelledMsg struct{}
 
+// SearchRemoveItemMsg is emitted when Ctrl+X is pressed to remove an item
+type SearchRemoveItemMsg struct {
+	Item  any
+	Index int
+}
+
 // SearchDialog is a reusable component that combines a text input with a list
 type SearchDialog struct {
 	textInput textinput.Model
-	list      list.List[list.ListItem]
+	list      list.List[list.Item]
 	width     int
 	height    int
 	focused   bool
@@ -38,6 +44,7 @@ type searchKeyMap struct {
 	Down   key.Binding
 	Enter  key.Binding
 	Escape key.Binding
+	Remove key.Binding
 }
 
 var searchKeys = searchKeyMap{
@@ -57,10 +64,14 @@ var searchKeys = searchKeyMap{
 		key.WithKeys("esc"),
 		key.WithHelp("esc", "cancel"),
 	),
+	Remove: key.NewBinding(
+		key.WithKeys("ctrl+x"),
+		key.WithHelp("ctrl+x", "remove from recent"),
+	),
 }
 
 // NewSearchDialog creates a new SearchDialog
-func NewSearchDialog(placeholder string, maxVisibleItems int) *SearchDialog {
+func NewSearchDialog(placeholder string, maxVisibleHeight int) *SearchDialog {
 	t := theme.CurrentTheme()
 	bgColor := t.BackgroundElement()
 	textColor := t.Text()
@@ -95,10 +106,18 @@ func NewSearchDialog(placeholder string, maxVisibleItems int) *SearchDialog {
 	ti.Focus()
 
 	emptyList := list.NewListComponent(
-		[]list.ListItem{},
+		list.WithItems([]list.Item{}),
-		maxVisibleItems,
+		list.WithMaxVisibleHeight[list.Item](maxVisibleHeight),
-		" No items",
+		list.WithFallbackMessage[list.Item](" No items"),
-		false,
+		list.WithAlphaNumericKeys[list.Item](false),
+		list.WithRenderFunc(
+			func(item list.Item, selected bool, width int, baseStyle styles.Style) string {
+				return item.Render(selected, width, baseStyle)
+			},
+		),
+		list.WithSelectableFunc(func(item list.Item) bool {
+			return item.Selectable()
+		}),
 	)
 
 	return &SearchDialog{
@@ -134,16 +153,23 @@ func (s *SearchDialog) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			return s, func() tea.Msg { return SearchCancelledMsg{} }
 
 		case key.Matches(msg, searchKeys.Enter):
-			if selectedItem, idx := s.list.GetSelectedItem(); selectedItem != nil {
+			if selectedItem, idx := s.list.GetSelectedItem(); idx != -1 {
 				return s, func() tea.Msg {
 					return SearchSelectionMsg{Item: selectedItem, Index: idx}
 				}
 			}
 
+		case key.Matches(msg, searchKeys.Remove):
+			if selectedItem, idx := s.list.GetSelectedItem(); idx != -1 {
+				return s, func() tea.Msg {
+					return SearchRemoveItemMsg{Item: selectedItem, Index: idx}
+				}
+			}
+
 		case key.Matches(msg, searchKeys.Up):
 			var cmd tea.Cmd
 			listModel, cmd := s.list.Update(msg)
-			s.list = listModel.(list.List[list.ListItem])
+			s.list = listModel.(list.List[list.Item])
 			if cmd != nil {
 				cmds = append(cmds, cmd)
 			}
@@ -151,7 +177,7 @@ func (s *SearchDialog) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		case key.Matches(msg, searchKeys.Down):
 			var cmd tea.Cmd
 			listModel, cmd := s.list.Update(msg)
-			s.list = listModel.(list.List[list.ListItem])
+			s.list = listModel.(list.List[list.Item])
 			if cmd != nil {
 				cmds = append(cmds, cmd)
 			}
@@ -177,7 +203,7 @@ func (s *SearchDialog) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 func (s *SearchDialog) View() string {
 	s.list.SetMaxWidth(s.width)
 	listView := s.list.View()
-	listView = lipgloss.PlaceVertical(s.list.GetMaxVisibleItems(), lipgloss.Top, listView)
+	listView = lipgloss.PlaceVertical(s.list.GetMaxVisibleHeight(), lipgloss.Top, listView)
 	textinput := s.textInput.View()
 	return textinput + "\n\n" + listView
 }
@@ -194,7 +220,7 @@ func (s *SearchDialog) SetHeight(height int) {
 }
 
 // SetItems updates the list items
-func (s *SearchDialog) SetItems(items []list.ListItem) {
+func (s *SearchDialog) SetItems(items []list.Item) {
 	s.list.SetItems(items)
 }
 

packages/tui/internal/components/dialog/session.go

@@ -28,17 +28,26 @@ type SessionDialog interface {
 type sessionItem struct {
 	title              string
 	isDeleteConfirming bool
+	isCurrentSession   bool
 }
 
-func (s sessionItem) Render(selected bool, width int, isFirstInViewport bool) string {
+func (s sessionItem) Render(
+	selected bool,
+	width int,
+	isFirstInViewport bool,
+	baseStyle styles.Style,
+) string {
 	t := theme.CurrentTheme()
-	baseStyle := styles.NewStyle()
 
 	var text string
 	if s.isDeleteConfirming {
 		text = "Press again to confirm delete"
 	} else {
-		text = s.title
+		if s.isCurrentSession {
+			text = "● " + s.title
+		} else {
+			text = s.title
+		}
 	}
 
 	truncatedStr := truncate.StringWithTail(text, uint(width-1), "...")
@@ -52,6 +61,14 @@ func (s sessionItem) Render(selected bool, width int, isFirstInViewport bool) st
 				Foreground(t.BackgroundElement()).
 				Width(width).
 				PaddingLeft(1)
+		} else if s.isCurrentSession {
+			// Different style for current session when selected
+			itemStyle = baseStyle.
+				Background(t.Primary()).
+				Foreground(t.BackgroundElement()).
+				Width(width).
+				PaddingLeft(1).
+				Bold(true)
 		} else {
 			// Normal selection
 			itemStyle = baseStyle.
@@ -66,6 +83,12 @@ func (s sessionItem) Render(selected bool, width int, isFirstInViewport bool) st
 			itemStyle = baseStyle.
 				Foreground(t.Error()).
 				PaddingLeft(1)
+		} else if s.isCurrentSession {
+			// Highlight current session when not selected
+			itemStyle = baseStyle.
+				Foreground(t.Primary()).
+				PaddingLeft(1).
+				Bold(true)
 		} else {
 			itemStyle = baseStyle.
 				PaddingLeft(1)
@@ -190,6 +213,7 @@ func (s *sessionDialog) updateListItems() {
 		item := sessionItem{
 			title:              sess.Title,
 			isDeleteConfirming: s.deleteConfirmation == i,
+			isCurrentSession:   s.app.Session != nil && s.app.Session.ID == sess.ID,
 		}
 		items = append(items, item)
 	}
@@ -225,15 +249,23 @@ func NewSessionDialog(app *app.App) SessionDialog {
 		items = append(items, sessionItem{
 			title:              sess.Title,
 			isDeleteConfirming: false,
+			isCurrentSession:   app.Session != nil && app.Session.ID == sess.ID,
 		})
 	}
 
-	// Create a generic list component
 	listComponent := list.NewListComponent(
-		items,
+		list.WithItems(items),
-		10, // maxVisibleSessions
+		list.WithMaxVisibleHeight[sessionItem](10),
-		"No sessions available",
+		list.WithFallbackMessage[sessionItem]("No sessions available"),
-		true, // useAlphaNumericKeys
+		list.WithAlphaNumericKeys[sessionItem](true),
+		list.WithRenderFunc(
+			func(item sessionItem, selected bool, width int, baseStyle styles.Style) string {
+				return item.Render(selected, width, false, baseStyle)
+			},
+		),
+		list.WithSelectableFunc(func(item sessionItem) bool {
+			return true
+		}),
 	)
 	listComponent.SetMaxWidth(layout.Current.Container.Width - 12)
 

packages/tui/internal/components/dialog/theme.go

@@ -5,6 +5,7 @@ import (
 	list "github.com/sst/opencode/internal/components/list"
 	"github.com/sst/opencode/internal/components/modal"
 	"github.com/sst/opencode/internal/layout"
+	"github.com/sst/opencode/internal/styles"
 	"github.com/sst/opencode/internal/theme"
 	"github.com/sst/opencode/internal/util"
 )
@@ -24,7 +25,7 @@ type themeDialog struct {
 	height int
 
 	modal         *modal.Modal
-	list          list.List[list.StringItem]
+	list          list.List[list.Item]
 	originalTheme string
 	themeApplied  bool
 }
@@ -42,16 +43,18 @@ func (t *themeDialog) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		switch msg.String() {
 		case "enter":
 			if item, idx := t.list.GetSelectedItem(); idx >= 0 {
-				selectedTheme := string(item)
+				if stringItem, ok := item.(list.StringItem); ok {
-				if err := theme.SetTheme(selectedTheme); err != nil {
+					selectedTheme := string(stringItem)
-					// status.Error(err.Error())
+					if err := theme.SetTheme(selectedTheme); err != nil {
-					return t, nil
+						// status.Error(err.Error())
+						return t, nil
+					}
+					t.themeApplied = true
+					return t, tea.Sequence(
+						util.CmdHandler(modal.CloseModalMsg{}),
+						util.CmdHandler(ThemeSelectedMsg{ThemeName: selectedTheme}),
+					)
 				}
-				t.themeApplied = true
-				return t, tea.Sequence(
-					util.CmdHandler(modal.CloseModalMsg{}),
-					util.CmdHandler(ThemeSelectedMsg{ThemeName: selectedTheme}),
-				)
 			}
 
 		}
@@ -61,11 +64,13 @@ func (t *themeDialog) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 
 	var cmd tea.Cmd
 	listModel, cmd := t.list.Update(msg)
-	t.list = listModel.(list.List[list.StringItem])
+	t.list = listModel.(list.List[list.Item])
 
 	if item, newIdx := t.list.GetSelectedItem(); newIdx >= 0 && newIdx != prevIdx {
-		theme.SetTheme(string(item))
+		if stringItem, ok := item.(list.StringItem); ok {
-		return t, util.CmdHandler(ThemeSelectedMsg{ThemeName: string(item)})
+			theme.SetTheme(string(stringItem))
+			return t, util.CmdHandler(ThemeSelectedMsg{ThemeName: string(stringItem)})
+		}
 	}
 	return t, cmd
 }
@@ -94,21 +99,32 @@ func NewThemeDialog() ThemeDialog {
 		}
 	}
 
-	list := list.NewStringList(
+	// Convert themes to list items
-		themes,
+	items := make([]list.Item, len(themes))
-		10, // maxVisibleThemes
+	for i, theme := range themes {
-		"No themes available",
+		items[i] = list.StringItem(theme)
-		true,
+	}
+
+	listComponent := list.NewListComponent(
+		list.WithItems(items),
+		list.WithMaxVisibleHeight[list.Item](10),
+		list.WithFallbackMessage[list.Item]("No themes available"),
+		list.WithAlphaNumericKeys[list.Item](true),
+		list.WithRenderFunc(func(item list.Item, selected bool, width int, baseStyle styles.Style) string {
+			return item.Render(selected, width, baseStyle)
+		}),
+		list.WithSelectableFunc(func(item list.Item) bool {
+			return item.Selectable()
+		}),
 	)
 
 	// Set the initial selection to the current theme
-	list.SetSelectedIndex(selectedIdx)
+	listComponent.SetSelectedIndex(selectedIdx)
 
 	// Set the max width for the list to match the modal width
-	list.SetMaxWidth(36) // 40 (modal max width) - 4 (modal padding)
+	listComponent.SetMaxWidth(36) // 40 (modal max width) - 4 (modal padding)
-
 	return &themeDialog{
-		list:          list,
+		list:          listComponent,
 		modal:         modal.New(modal.WithTitle("Select Theme"), modal.WithMaxWidth(40)),
 		originalTheme: currentTheme,
 		themeApplied:  false,

packages/tui/internal/components/diff/diff.go

@@ -38,6 +38,10 @@ const (
 	LineRemoved                 // Line removed from the old file
 )
 
+var (
+	ansiRegex = regexp.MustCompile(`\x1b(?:[@-Z\\-_]|\[[0-9?]*(?:;[0-9?]*)*[@-~])`)
+)
+
 // Segment represents a portion of a line for intra-line highlighting
 type Segment struct {
 	Start int
@@ -548,7 +552,6 @@ func createStyles(t theme.Theme) (removedLineStyle, addedLineStyle, contextLineS
 // applyHighlighting applies intra-line highlighting to a piece of text
 func applyHighlighting(content string, segments []Segment, segmentType LineType, highlightBg compat.AdaptiveColor) string {
 	// Find all ANSI sequences in the content
-	ansiRegex := regexp.MustCompile(`\x1b(?:[@-Z\\-_]|\[[0-9?]*(?:;[0-9?]*)*[@-~])`)
 	ansiMatches := ansiRegex.FindAllStringIndex(content, -1)
 
 	// Build a mapping of visible character positions to their actual indices

packages/tui/internal/components/fileviewer/fileviewer.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/charmbracelet/bubbles/v2/viewport"
 	tea "github.com/charmbracelet/bubbletea/v2"
 
 	"github.com/sst/opencode/internal/app"
@@ -15,6 +14,7 @@ import (
 	"github.com/sst/opencode/internal/styles"
 	"github.com/sst/opencode/internal/theme"
 	"github.com/sst/opencode/internal/util"
+	"github.com/sst/opencode/internal/viewport"
 )
 
 type DiffStyle int

packages/tui/internal/components/list/list.go

@@ -5,17 +5,88 @@ import (
 
 	"github.com/charmbracelet/bubbles/v2/key"
 	tea "github.com/charmbracelet/bubbletea/v2"
+	"github.com/charmbracelet/lipgloss/v2"
 	"github.com/muesli/reflow/truncate"
 	"github.com/sst/opencode/internal/styles"
 	"github.com/sst/opencode/internal/theme"
 )
 
-type ListItem interface {
+// Item interface that all list items must implement
-	Render(selected bool, width int, isFirstInViewport bool) string
+type Item interface {
+	Render(selected bool, width int, baseStyle styles.Style) string
 	Selectable() bool
 }
 
-type List[T ListItem] interface {
+// RenderFunc defines how to render an item in the list
+type RenderFunc[T any] func(item T, selected bool, width int, baseStyle styles.Style) string
+
+// SelectableFunc defines whether an item is selectable
+type SelectableFunc[T any] func(item T) bool
+
+// Options holds configuration for the list component
+type Options[T any] struct {
+	items               []T
+	maxVisibleHeight    int
+	fallbackMsg         string
+	useAlphaNumericKeys bool
+	renderItem          RenderFunc[T]
+	isSelectable        SelectableFunc[T]
+	baseStyle           styles.Style
+}
+
+// Option is a function that configures the list component
+type Option[T any] func(*Options[T])
+
+// WithItems sets the initial items for the list
+func WithItems[T any](items []T) Option[T] {
+	return func(o *Options[T]) {
+		o.items = items
+	}
+}
+
+// WithMaxVisibleHeight sets the maximum visible height in lines
+func WithMaxVisibleHeight[T any](height int) Option[T] {
+	return func(o *Options[T]) {
+		o.maxVisibleHeight = height
+	}
+}
+
+// WithFallbackMessage sets the message to show when the list is empty
+func WithFallbackMessage[T any](msg string) Option[T] {
+	return func(o *Options[T]) {
+		o.fallbackMsg = msg
+	}
+}
+
+// WithAlphaNumericKeys enables j/k navigation keys
+func WithAlphaNumericKeys[T any](enabled bool) Option[T] {
+	return func(o *Options[T]) {
+		o.useAlphaNumericKeys = enabled
+	}
+}
+
+// WithRenderFunc sets the function to render items
+func WithRenderFunc[T any](fn RenderFunc[T]) Option[T] {
+	return func(o *Options[T]) {
+		o.renderItem = fn
+	}
+}
+
+// WithSelectableFunc sets the function to determine if items are selectable
+func WithSelectableFunc[T any](fn SelectableFunc[T]) Option[T] {
+	return func(o *Options[T]) {
+		o.isSelectable = fn
+	}
+}
+
+// WithStyle sets the base style that gets passed to render functions
+func WithStyle[T any](style styles.Style) Option[T] {
+	return func(o *Options[T]) {
+		o.baseStyle = style
+	}
+}
+
+type List[T any] interface {
 	tea.Model
 	tea.ViewModel
 	SetMaxWidth(maxWidth int)
@@ -25,19 +96,21 @@ type List[T ListItem] interface {
 	SetSelectedIndex(idx int)
 	SetEmptyMessage(msg string)
 	IsEmpty() bool
-	GetMaxVisibleItems() int
+	GetMaxVisibleHeight() int
-	GetActualHeight() int
 }
 
-type listComponent[T ListItem] struct {
+type listComponent[T any] struct {
 	fallbackMsg         string
 	items               []T
 	selectedIdx         int
 	maxWidth            int
-	maxVisibleItems     int
+	maxVisibleHeight    int
 	useAlphaNumericKeys bool
 	width               int
 	height              int
+	renderItem          RenderFunc[T]
+	isSelectable        SelectableFunc[T]
+	baseStyle           styles.Style
 }
 
 type listKeyMap struct {
@@ -94,7 +167,7 @@ func (c *listComponent[T]) moveUp() {
 
 	// Find the previous selectable item
 	for i := c.selectedIdx - 1; i >= 0; i-- {
-		if c.items[i].Selectable() {
+		if c.isSelectable(c.items[i]) {
 			c.selectedIdx = i
 			return
 		}
@@ -117,7 +190,7 @@ func (c *listComponent[T]) moveDown() {
 			break
 		}
 
-		if c.items[c.selectedIdx].Selectable() {
+		if c.isSelectable(c.items[c.selectedIdx]) {
 			return
 		}
 
@@ -129,7 +202,7 @@ func (c *listComponent[T]) moveDown() {
 }
 
 func (c *listComponent[T]) GetSelectedItem() (T, int) {
-	if len(c.items) > 0 && c.items[c.selectedIdx].Selectable() {
+	if len(c.items) > 0 && c.isSelectable(c.items[c.selectedIdx]) {
 		return c.items[c.selectedIdx], c.selectedIdx
 	}
 
@@ -142,7 +215,7 @@ func (c *listComponent[T]) SetItems(items []T) {
 	c.selectedIdx = 0
 
 	// Ensure initial selection is on a selectable item
-	if len(items) > 0 && !items[0].Selectable() {
+	if len(items) > 0 && !c.isSelectable(items[0]) {
 		c.moveDown()
 	}
 }
@@ -169,48 +242,8 @@ func (c *listComponent[T]) SetSelectedIndex(idx int) {
 	}
 }
 
-func (c *listComponent[T]) GetMaxVisibleItems() int {
+func (c *listComponent[T]) GetMaxVisibleHeight() int {
-	return c.maxVisibleItems
+	return c.maxVisibleHeight
-}
-
-func (c *listComponent[T]) GetActualHeight() int {
-	items := c.items
-	if len(items) == 0 {
-		return 1 // For empty message
-	}
-
-	maxVisibleItems := min(c.maxVisibleItems, len(items))
-	startIdx := 0
-
-	if len(items) > maxVisibleItems {
-		halfVisible := maxVisibleItems / 2
-		if c.selectedIdx >= halfVisible && c.selectedIdx < len(items)-halfVisible {
-			startIdx = c.selectedIdx - halfVisible
-		} else if c.selectedIdx >= len(items)-halfVisible {
-			startIdx = len(items) - maxVisibleItems
-		}
-	}
-
-	endIdx := min(startIdx+maxVisibleItems, len(items))
-
-	height := 0
-	for i := startIdx; i < endIdx; i++ {
-		item := items[i]
-		isFirstInViewport := (i == startIdx)
-
-		// Check if this is a HeaderItem and calculate its height
-		if _, ok := any(item).(HeaderItem); ok {
-			if isFirstInViewport {
-				height += 1 // No top margin
-			} else {
-				height += 2 // With top margin
-			}
-		} else {
-			height += 1 // Regular items take 1 line
-		}
-	}
-
-	return height
 }
 
 func (c *listComponent[T]) View() string {
@@ -224,95 +257,88 @@ func (c *listComponent[T]) View() string {
 		return c.fallbackMsg
 	}
 
-	// Calculate viewport based on actual heights, not item counts
+	// Calculate viewport based on actual heights
 	startIdx, endIdx := c.calculateViewport()
 
 	listItems := make([]string, 0, endIdx-startIdx)
 
 	for i := startIdx; i < endIdx; i++ {
 		item := items[i]
-		isFirstInViewport := (i == startIdx)
+
-		title := item.Render(i == c.selectedIdx, maxWidth, isFirstInViewport)
+		// Special handling for HeaderItem to remove top margin on first item
+		if i == startIdx {
+			// Check if this is a HeaderItem
+			if _, ok := any(item).(Item); ok {
+				if headerItem, isHeader := any(item).(HeaderItem); isHeader {
+					// Render header without top margin when it's first
+					t := theme.CurrentTheme()
+					truncatedStr := truncate.StringWithTail(string(headerItem), uint(maxWidth-1), "...")
+					headerStyle := c.baseStyle.
+						Foreground(t.Accent()).
+						Bold(true).
+						MarginBottom(0).
+						PaddingLeft(1)
+					listItems = append(listItems, headerStyle.Render(truncatedStr))
+					continue
+				}
+			}
+		}
+
+		title := c.renderItem(item, i == c.selectedIdx, maxWidth, c.baseStyle)
 		listItems = append(listItems, title)
 	}
 
 	return strings.Join(listItems, "\n")
 }
 
-// calculateViewport determines which items to show based on available height
+// calculateViewport determines which items to show based on available space
 func (c *listComponent[T]) calculateViewport() (startIdx, endIdx int) {
 	items := c.items
 	if len(items) == 0 {
 		return 0, 0
 	}
 
-	// Helper function to calculate height of an item at given position
+	// Calculate heights of all items
-	getItemHeight := func(idx int, isFirst bool) int {
+	itemHeights := make([]int, len(items))
-		if _, ok := any(items[idx]).(HeaderItem); ok {
+	for i, item := range items {
-			if isFirst {
+		rendered := c.renderItem(item, false, c.maxWidth, c.baseStyle)
-				return 1 // No top margin
+		itemHeights[i] = lipgloss.Height(rendered)
-			} else {
-				return 2 // With top margin
-			}
-		}
-		return 1 // Regular items
 	}
 
-	// If we have fewer items than max, show all
+	// Find the range of items that fit within maxVisibleHeight
-	if len(items) <= c.maxVisibleItems {
+	// Start by trying to center the selected item
-		return 0, len(items)
+	start := 0
+	end := len(items)
+
+	// Calculate height from start to selected
+	heightToSelected := 0
+	for i := 0; i <= c.selectedIdx && i < len(items); i++ {
+		heightToSelected += itemHeights[i]
 	}
 
-	// Try to center the selected item in the viewport
+	// If selected item is beyond visible height, scroll to show it
-	// Start by trying to put selected item in the middle
+	if heightToSelected > c.maxVisibleHeight {
-	targetStart := c.selectedIdx - c.maxVisibleItems/2
+		// Start from selected and work backwards to find start
-	if targetStart < 0 {
+		currentHeight := itemHeights[c.selectedIdx]
-		targetStart = 0
+		start = c.selectedIdx
-	}
 
-	// Find the actual start and end indices that fit within our height budget
+		for i := c.selectedIdx - 1; i >= 0 && currentHeight+itemHeights[i] <= c.maxVisibleHeight; i-- {
-	bestStart := 0
+			currentHeight += itemHeights[i]
-	bestEnd := 0
+			start = i
-	bestHeight := 0
-
-	// Try different starting positions around our target
-	for start := max(0, targetStart-2); start <= min(len(items)-1, targetStart+2); start++ {
-		currentHeight := 0
-		end := start
-
-		for end < len(items) && currentHeight < c.maxVisibleItems {
-			itemHeight := getItemHeight(end, end == start)
-			if currentHeight+itemHeight > c.maxVisibleItems {
-				break
-			}
-			currentHeight += itemHeight
-			end++
-		}
-
-		// Check if this viewport contains the selected item and is better than current best
-		if start <= c.selectedIdx && c.selectedIdx < end {
-			if currentHeight > bestHeight || (currentHeight == bestHeight && abs(start+end-2*c.selectedIdx) < abs(bestStart+bestEnd-2*c.selectedIdx)) {
-				bestStart = start
-				bestEnd = end
-				bestHeight = currentHeight
-			}
 		}
 	}
 
-	// If no good viewport found that contains selected item, just show from selected item
+	// Calculate end based on start
-	if bestEnd == 0 {
+	currentHeight := 0
-		bestStart = c.selectedIdx
+	for i := start; i < len(items); i++ {
-		currentHeight := 0
+		if currentHeight+itemHeights[i] > c.maxVisibleHeight {
-		for bestEnd = bestStart; bestEnd < len(items) && currentHeight < c.maxVisibleItems; bestEnd++ {
+			end = i
-			itemHeight := getItemHeight(bestEnd, bestEnd == bestStart)
+			break
-			if currentHeight+itemHeight > c.maxVisibleItems {
-				break
-			}
-			currentHeight += itemHeight
 		}
+		currentHeight += itemHeights[i]
 	}
 
-	return bestStart, bestEnd
+	return start, end
 }
 
 func abs(x int) int {
@@ -329,27 +355,32 @@ func max(a, b int) int {
 	return b
 }
 
-func NewListComponent[T ListItem](
+func NewListComponent[T any](opts ...Option[T]) List[T] {
-	items []T,
+	options := &Options[T]{
-	maxVisibleItems int,
+		baseStyle: styles.NewStyle(), // Default empty style
-	fallbackMsg string,
+	}
-	useAlphaNumericKeys bool,
+
-) List[T] {
+	for _, opt := range opts {
+		opt(options)
+	}
+
 	return &listComponent[T]{
-		fallbackMsg:         fallbackMsg,
+		fallbackMsg:         options.fallbackMsg,
-		items:               items,
+		items:               options.items,
-		maxVisibleItems:     maxVisibleItems,
+		maxVisibleHeight:    options.maxVisibleHeight,
-		useAlphaNumericKeys: useAlphaNumericKeys,
+		useAlphaNumericKeys: options.useAlphaNumericKeys,
 		selectedIdx:         0,
+		renderItem:          options.renderItem,
+		isSelectable:        options.isSelectable,
+		baseStyle:           options.baseStyle,
 	}
 }
 
-// StringItem is a simple implementation of ListItem for string values
+// StringItem is a simple implementation of Item for string values
 type StringItem string
 
-func (s StringItem) Render(selected bool, width int, isFirstInViewport bool) string {
+func (s StringItem) Render(selected bool, width int, baseStyle styles.Style) string {
 	t := theme.CurrentTheme()
-	baseStyle := styles.NewStyle()
 
 	truncatedStr := truncate.StringWithTail(string(s), uint(width-1), "...")
 
@@ -376,23 +407,18 @@ func (s StringItem) Selectable() bool {
 // HeaderItem is a non-selectable header item for grouping
 type HeaderItem string
 
-func (h HeaderItem) Render(selected bool, width int, isFirstInViewport bool) string {
+func (h HeaderItem) Render(selected bool, width int, baseStyle styles.Style) string {
 	t := theme.CurrentTheme()
-	baseStyle := styles.NewStyle()
 
 	truncatedStr := truncate.StringWithTail(string(h), uint(width-1), "...")
 
 	headerStyle := baseStyle.
 		Foreground(t.Accent()).
 		Bold(true).
+		MarginTop(1).
 		MarginBottom(0).
 		PaddingLeft(1)
 
-	// Only add top margin if this is not the first item in the viewport
-	if !isFirstInViewport {
-		headerStyle = headerStyle.MarginTop(1)
-	}
-
 	return headerStyle.Render(truncatedStr)
 }
 
@@ -400,16 +426,6 @@ func (h HeaderItem) Selectable() bool {
 	return false
 }
 
-// NewStringList creates a new list component with string items
+// Ensure StringItem and HeaderItem implement Item
-func NewStringList(
+var _ Item = StringItem("")
-	items []string,
+var _ Item = HeaderItem("")
-	maxVisibleItems int,
-	fallbackMsg string,
-	useAlphaNumericKeys bool,
-) List[StringItem] {
-	stringItems := make([]StringItem, len(items))
-	for i, item := range items {
-		stringItems[i] = StringItem(item)
-	}
-	return NewListComponent(stringItems, maxVisibleItems, fallbackMsg, useAlphaNumericKeys)
-}

packages/tui/internal/components/list/list_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	tea "github.com/charmbracelet/bubbletea/v2"
+	"github.com/sst/opencode/internal/styles"
 )
 
 // testItem is a simple test implementation of ListItem
@@ -11,10 +12,19 @@ type testItem struct {
 	value string
 }
 
-func (t testItem) Render(selected bool, width int) string {
+func (t testItem) Render(
+	selected bool,
+	width int,
+	isFirstInViewport bool,
+	baseStyle styles.Style,
+) string {
 	return t.value
 }
 
+func (t testItem) Selectable() bool {
+	return true
+}
+
 // createTestList creates a list with test items for testing
 func createTestList() *listComponent[testItem] {
 	items := []testItem{
@@ -22,7 +32,24 @@ func createTestList() *listComponent[testItem] {
 		{value: "item2"},
 		{value: "item3"},
 	}
-	list := NewListComponent(items, 5, "empty", false)
+	list := NewListComponent(
+		WithItems(items),
+		WithMaxVisibleItems[testItem](5),
+		WithFallbackMessage[testItem]("empty"),
+		WithAlphaNumericKeys[testItem](false),
+		WithRenderFunc(
+			func(item testItem, selected bool, width int, baseStyle styles.Style) string {
+				return item.Render(selected, width, false, baseStyle)
+			},
+		),
+		WithSelectableFunc(func(item testItem) bool {
+			return item.Selectable()
+		}),
+		WithHeightFunc(func(item testItem, isFirstInViewport bool) int {
+			return 1
+		}),
+	)
+
 	return list.(*listComponent[testItem])
 }
 
@@ -55,7 +82,23 @@ func TestJKKeyNavigation(t *testing.T) {
 		{value: "item3"},
 	}
 	// Create list with alpha keys enabled
-	list := NewListComponent(items, 5, "empty", true).(*listComponent[testItem])
+	list := NewListComponent(
+		WithItems(items),
+		WithMaxVisibleItems[testItem](5),
+		WithFallbackMessage[testItem]("empty"),
+		WithAlphaNumericKeys[testItem](true),
+		WithRenderFunc(
+			func(item testItem, selected bool, width int, baseStyle styles.Style) string {
+				return item.Render(selected, width, false, baseStyle)
+			},
+		),
+		WithSelectableFunc(func(item testItem) bool {
+			return item.Selectable()
+		}),
+		WithHeightFunc(func(item testItem, isFirstInViewport bool) int {
+			return 1
+		}),
+	)
 
 	// Test j key (down)
 	jKey := tea.KeyPressMsg{Code: 'j', Text: "j"}
@@ -131,7 +174,23 @@ func TestNavigationBoundaries(t *testing.T) {
 }
 
 func TestEmptyList(t *testing.T) {
-	emptyList := NewListComponent([]testItem{}, 5, "empty", false).(*listComponent[testItem])
+	emptyList := NewListComponent(
+		WithItems([]testItem{}),
+		WithMaxVisibleItems[testItem](5),
+		WithFallbackMessage[testItem]("empty"),
+		WithAlphaNumericKeys[testItem](false),
+		WithRenderFunc(
+			func(item testItem, selected bool, width int, baseStyle styles.Style) string {
+				return item.Render(selected, width, false, baseStyle)
+			},
+		),
+		WithSelectableFunc(func(item testItem) bool {
+			return item.Selectable()
+		}),
+		WithHeightFunc(func(item testItem, isFirstInViewport bool) int {
+			return 1
+		}),
+	)
 
 	// Test navigation on empty list (should not crash)
 	downKey := tea.KeyPressMsg{Code: tea.KeyDown}

packages/tui/internal/components/textarea/textarea.go

@@ -2051,6 +2051,10 @@ func wrapInterfaces(content []any, width int) [][]any {
 			if unicode.IsSpace(r) {
 				isSpace = true
 			}
+			// Use hyphen-aware word boundary detection
+			if r == '-' {
+				isSpace = false
+			}
 			itemW = rw.RuneWidth(r)
 		} else if att, ok := item.(*Attachment); ok {
 			itemW = uniseg.StringWidth(att.Display)

packages/tui/internal/config/config.go

@@ -69,6 +69,15 @@ func (s *State) UpdateModelUsage(providerID, modelID string) {
 	}
 }
 
+func (s *State) RemoveModelFromRecentlyUsed(providerID, modelID string) {
+	for i, usage := range s.RecentlyUsedModels {
+		if usage.ProviderID == providerID && usage.ModelID == modelID {
+			s.RecentlyUsedModels = append(s.RecentlyUsedModels[:i], s.RecentlyUsedModels[i+1:]...)
+			return
+		}
+	}
+}
+
 // SaveState writes the provided Config struct to the specified TOML file.
 // It will create the file if it doesn't exist, or overwrite it if it does.
 func SaveState(filePath string, state *State) error {

packages/tui/internal/layout/overlay.go

@@ -15,6 +15,11 @@ import (
 	"github.com/sst/opencode/internal/util"
 )
 
+var (
+	// ANSI escape sequence regex
+	ansiRegex = regexp.MustCompile(`\x1b\[[0-9;]*m`)
+)
+
 // Split a string into lines, additionally returning the size of the widest line.
 func getLines(s string) (lines []string, widest int) {
 	lines = strings.Split(s, "\n")
@@ -272,9 +277,6 @@ func combineStyles(bgStyle ansiStyle, fgColor *compat.AdaptiveColor) string {
 
 // getStyleAtPosition extracts the active ANSI style at a given visual position
 func getStyleAtPosition(s string, targetPos int) ansiStyle {
-	// ANSI escape sequence regex
-	ansiRegex := regexp.MustCompile(`\x1b\[[0-9;]*m`)
-
 	visualPos := 0
 	currentStyle := ansiStyle{}
 

packages/tui/internal/styles/markdown.go

@@ -284,7 +284,6 @@ func generateMarkdownStyleConfig(backgroundColor compat.AdaptiveColor) ansi.Styl
 		Table: ansi.StyleTable{
 			StyleBlock: ansi.StyleBlock{
 				StylePrimitive: ansi.StylePrimitive{
-					BlockPrefix: "\n",
 					BlockSuffix: "\n",
 				},
 			},

packages/tui/internal/tui/tui.go

@@ -2,6 +2,7 @@ package tui
 
 import (
 	"context"
+	"fmt"
 	"log/slog"
 	"os"
 	"os/exec"
@@ -55,7 +56,6 @@ const (
 
 const interruptDebounceTimeout = 1 * time.Second
 const exitDebounceTimeout = 1 * time.Second
-const fileViewerFullWidthCutoff = 160
 
 type appModel struct {
 	width, height        int
@@ -65,9 +65,9 @@ type appModel struct {
 	editor               chat.EditorComponent
 	messages             chat.MessagesComponent
 	completions          dialog.CompletionDialog
-	commandProvider      dialog.CompletionProvider
+	commandProvider      completions.CompletionProvider
-	fileProvider         dialog.CompletionProvider
+	fileProvider         completions.CompletionProvider
-	symbolsProvider      dialog.CompletionProvider
+	symbolsProvider      completions.CompletionProvider
 	showCompletionDialog bool
 	leaderBinding        *key.Binding
 	// isLeaderSequence     bool
@@ -76,10 +76,6 @@ type appModel struct {
 	exitKeyState      ExitKeyState
 	messagesRight     bool
 	fileViewer        fileviewer.Model
-	lastMouse         tea.Mouse
-	fileViewerStart   int
-	fileViewerEnd     int
-	fileViewerHit     bool
 }
 
 func (a appModel) Init() tea.Cmd {
@@ -107,6 +103,9 @@ func (a appModel) Init() tea.Cmd {
 }
 
 func (a appModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	measure := util.Measure("app.Update")
+	defer measure("from", fmt.Sprintf("%T", msg))
+
 	var cmd tea.Cmd
 	var cmds []tea.Cmd
 
@@ -114,11 +113,6 @@ func (a appModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	case tea.KeyPressMsg:
 		keyString := msg.String()
 
-		// Handle Ctrl+Z for suspend
-		if keyString == "ctrl+z" {
-			return a, tea.Suspend
-		}
-
 		// 1. Handle active modal
 		if a.modal != nil {
 			switch keyString {
@@ -281,36 +275,27 @@ func (a appModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			return a, util.CmdHandler(commands.ExecuteCommandsMsg(matches))
 		}
 
+		// Fallback: suspend if ctrl+z is pressed and no user keybind matched
+		if keyString == "ctrl+z" {
+			return a, tea.Suspend
+		}
+
 		// 10. Fallback to editor. This is for other characters like backspace, tab, etc.
 		updatedEditor, cmd := a.editor.Update(msg)
 		a.editor = updatedEditor.(chat.EditorComponent)
 		return a, cmd
 	case tea.MouseWheelMsg:
 		if a.modal != nil {
-			return a, nil
+			u, cmd := a.modal.Update(msg)
-		}
+			a.modal = u.(layout.Modal)
-
-		var cmd tea.Cmd
-		if a.fileViewerHit {
-			a.fileViewer, cmd = a.fileViewer.Update(msg)
 			cmds = append(cmds, cmd)
-		} else {
+			return a, tea.Batch(cmds...)
-			updated, cmd := a.messages.Update(msg)
-			a.messages = updated.(chat.MessagesComponent)
-			cmds = append(cmds, cmd)
 		}
 
+		updated, cmd := a.messages.Update(msg)
+		a.messages = updated.(chat.MessagesComponent)
+		cmds = append(cmds, cmd)
 		return a, tea.Batch(cmds...)
-	case tea.MouseMotionMsg:
-		a.lastMouse = msg.Mouse()
-		a.fileViewerHit = a.fileViewer.HasFile() &&
-			a.lastMouse.X > a.fileViewerStart &&
-			a.lastMouse.X < a.fileViewerEnd
-	case tea.MouseClickMsg:
-		a.lastMouse = msg.Mouse()
-		a.fileViewerHit = a.fileViewer.HasFile() &&
-			a.lastMouse.X > a.fileViewerStart &&
-			a.lastMouse.X < a.fileViewerEnd
 	case tea.BackgroundColorMsg:
 		styles.Terminal = &styles.TerminalInfo{
 			Background:       msg.Color,
@@ -352,7 +337,7 @@ func (a appModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		cmds = append(cmds, cmd)
 	case app.SetEditorContentMsg:
 		// Set the editor content without sending
-		a.editor.SetValue(msg.Text)
+		a.editor.SetValueWithAttachments(msg.Text)
 		updated, cmd := a.editor.Focus()
 		a.editor = updated.(chat.EditorComponent)
 		cmds = append(cmds, cmd)
@@ -457,14 +442,7 @@ func (a appModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	case tea.WindowSizeMsg:
 		msg.Height -= 2 // Make space for the status bar
 		a.width, a.height = msg.Width, msg.Height
-		container := min(a.width, 84)
+		container := min(a.width, 86)
-		if a.fileViewer.HasFile() {
-			if a.width < fileViewerFullWidthCutoff {
-				container = a.width
-			} else {
-				container = min(min(a.width, max(a.width/2, 50)), 84)
-			}
-		}
 		layout.Current = &layout.LayoutInfo{
 			Viewport: layout.Dimensions{
 				Width:  a.width,
@@ -474,30 +452,18 @@ func (a appModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				Width: container,
 			},
 		}
-		mainWidth := layout.Current.Container.Width
-		a.messages.SetWidth(mainWidth - 4)
-
-		sideWidth := a.width - mainWidth
-		if a.width < fileViewerFullWidthCutoff {
-			sideWidth = a.width
-		}
-		a.fileViewerStart = mainWidth
-		a.fileViewerEnd = a.fileViewerStart + sideWidth
-		if a.messagesRight {
-			a.fileViewerStart = 0
-			a.fileViewerEnd = sideWidth
-		}
-		a.fileViewer, cmd = a.fileViewer.SetSize(sideWidth, layout.Current.Viewport.Height)
-		cmds = append(cmds, cmd)
 	case app.SessionSelectedMsg:
 		messages, err := a.app.ListMessages(context.Background(), msg.ID)
 		if err != nil {
-			slog.Error("Failed to list messages", "error", err)
+			slog.Error("Failed to list messages", "error", err.Error())
 			return a, toast.NewErrorToast("Failed to open session")
 		}
 		a.app.Session = msg
 		a.app.Messages = messages
 		return a, util.CmdHandler(app.SessionLoadedMsg{})
+	case app.SessionCreatedMsg:
+		a.app.Session = msg.Session
+		return a, util.CmdHandler(app.SessionLoadedMsg{})
 	case app.ModelSelectedMsg:
 		a.app.Provider = &msg.Provider
 		a.app.Model = &msg.Model
@@ -562,51 +528,27 @@ func (a appModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 }
 
 func (a appModel) View() string {
+	measure := util.Measure("app.View")
+	defer measure()
 	t := theme.CurrentTheme()
 
 	var mainLayout string
-	mainWidth := layout.Current.Container.Width - 4
+
 	if a.app.Session.ID == "" {
-		mainLayout = a.home(mainWidth)
+		mainLayout = a.home()
 	} else {
-		mainLayout = a.chat(mainWidth)
+		mainLayout = a.chat()
 	}
 	mainLayout = styles.NewStyle().
 		Background(t.Background()).
 		Padding(0, 2).
 		Render(mainLayout)
-
+	mainLayout = lipgloss.PlaceHorizontal(
-	mainHeight := lipgloss.Height(mainLayout)
+		a.width,
-
+		lipgloss.Center,
-	if a.fileViewer.HasFile() {
+		mainLayout,
-		file := a.fileViewer.View()
+		styles.WhitespaceStyle(t.Background()),
-		baseStyle := styles.NewStyle().Background(t.BackgroundPanel())
+	)
-		sidePanel := baseStyle.Height(mainHeight).Render(file)
-		if a.width >= fileViewerFullWidthCutoff {
-			if a.messagesRight {
-				mainLayout = lipgloss.JoinHorizontal(
-					lipgloss.Top,
-					sidePanel,
-					mainLayout,
-				)
-			} else {
-				mainLayout = lipgloss.JoinHorizontal(
-					lipgloss.Top,
-					mainLayout,
-					sidePanel,
-				)
-			}
-		} else {
-			mainLayout = sidePanel
-		}
-	} else {
-		mainLayout = lipgloss.PlaceHorizontal(
-			a.width,
-			lipgloss.Center,
-			mainLayout,
-			styles.WhitespaceStyle(t.Background()),
-		)
-	}
 
 	mainStyle := styles.NewStyle().Background(t.Background())
 	mainLayout = mainStyle.Render(mainLayout)
@@ -642,8 +584,9 @@ func (a appModel) openFile(filepath string) (tea.Model, tea.Cmd) {
 	return a, cmd
 }
 
-func (a appModel) home(width int) string {
+func (a appModel) home() string {
 	t := theme.CurrentTheme()
+	effectiveWidth := a.width - 4
 	baseStyle := styles.NewStyle().Background(t.Background())
 	base := baseStyle.Render
 	muted := styles.NewStyle().Foreground(t.TextMuted()).Background(t.Background()).Render
@@ -674,7 +617,7 @@ func (a appModel) home(width int) string {
 
 	logoAndVersion := strings.Join([]string{logo, version}, "\n")
 	logoAndVersion = lipgloss.PlaceHorizontal(
-		width,
+		effectiveWidth,
 		lipgloss.Center,
 		logoAndVersion,
 		styles.WhitespaceStyle(t.Background()),
@@ -685,7 +628,7 @@ func (a appModel) home(width int) string {
 		cmdcomp.WithLimit(6),
 	)
 	cmds := lipgloss.PlaceHorizontal(
-		width,
+		effectiveWidth,
 		lipgloss.Center,
 		commandsView.View(),
 		styles.WhitespaceStyle(t.Background()),
@@ -697,19 +640,16 @@ func (a appModel) home(width int) string {
 	lines = append(lines, logoAndVersion)
 	lines = append(lines, "")
 	lines = append(lines, "")
-	// lines = append(lines, base("cwd ")+muted(cwd))
-	// lines = append(lines, base("config ")+muted(config))
-	// lines = append(lines, "")
 	lines = append(lines, cmds)
 	lines = append(lines, "")
 	lines = append(lines, "")
 
 	mainHeight := lipgloss.Height(strings.Join(lines, "\n"))
 
-	editorWidth := min(width, 80)
+	editorView := a.editor.View()
-	editorView := a.editor.View(editorWidth)
+	editorWidth := lipgloss.Width(editorView)
 	editorView = lipgloss.PlaceHorizontal(
-		width,
+		effectiveWidth,
 		lipgloss.Center,
 		editorView,
 		styles.WhitespaceStyle(t.Background()),
@@ -719,7 +659,7 @@ func (a appModel) home(width int) string {
 	editorLines := a.editor.Lines()
 
 	mainLayout := lipgloss.Place(
-		width,
+		effectiveWidth,
 		a.height,
 		lipgloss.Center,
 		lipgloss.Center,
@@ -727,14 +667,14 @@ func (a appModel) home(width int) string {
 		styles.WhitespaceStyle(t.Background()),
 	)
 
-	editorX := (width - editorWidth) / 2
+	editorX := (effectiveWidth - editorWidth) / 2
 	editorY := (a.height / 2) + (mainHeight / 2) - 2
 
 	if editorLines > 1 {
 		mainLayout = layout.PlaceOverlay(
 			editorX,
 			editorY,
-			a.editor.Content(editorWidth),
+			a.editor.Content(),
 			mainLayout,
 		)
 	}
@@ -755,23 +695,33 @@ func (a appModel) home(width int) string {
 	return mainLayout
 }
 
-func (a appModel) chat(width int) string {
+func (a appModel) chat() string {
-	editorView := a.editor.View(width)
+	measure := util.Measure("chat.View")
+	defer measure()
+	effectiveWidth := a.width - 4
+	t := theme.CurrentTheme()
+	editorView := a.editor.View()
 	lines := a.editor.Lines()
-	messagesView := a.messages.View(width, a.height-5)
+	messagesView := a.messages.View()
 
 	editorWidth := lipgloss.Width(editorView)
 	editorHeight := max(lines, 5)
+	editorView = lipgloss.PlaceHorizontal(
+		effectiveWidth,
+		lipgloss.Center,
+		editorView,
+		styles.WhitespaceStyle(t.Background()),
+	)
 
 	mainLayout := messagesView + "\n" + editorView
-	editorX := (a.width - editorWidth) / 2
+	editorX := (effectiveWidth - editorWidth) / 2
 
 	if lines > 1 {
 		editorY := a.height - editorHeight
 		mainLayout = layout.PlaceOverlay(
 			editorX,
 			editorY,
-			a.editor.Content(width),
+			a.editor.Content(),
 			mainLayout,
 		)
 	}
@@ -806,6 +756,10 @@ func (a appModel) executeCommand(command commands.Command) (tea.Model, tea.Cmd)
 		updated, cmd := a.app.SwitchMode()
 		a.app = updated
 		cmds = append(cmds, cmd)
+	case commands.SwitchModeReverseCommand:
+		updated, cmd := a.app.SwitchModeReverse()
+		a.app = updated
+		cmds = append(cmds, cmd)
 	case commands.EditorOpenCommand:
 		if a.app.IsBusy() {
 			// status.Warn("Agent is working, please wait...")
@@ -897,6 +851,56 @@ func (a appModel) executeCommand(command commands.Command) (tea.Model, tea.Cmd)
 		}
 		// TODO: block until compaction is complete
 		a.app.CompactSession(context.Background())
+	case commands.SessionExportCommand:
+		if a.app.Session.ID == "" {
+			return a, toast.NewErrorToast("No active session to export.")
+		}
+
+		// Use current conversation history
+		messages := a.app.Messages
+		if len(messages) == 0 {
+			return a, toast.NewInfoToast("No messages to export.")
+		}
+
+		// Format to Markdown
+		markdownContent := formatConversationToMarkdown(messages)
+
+		// Check if EDITOR is set
+		editor := os.Getenv("EDITOR")
+		if editor == "" {
+			return a, toast.NewErrorToast("No EDITOR set, can't open editor")
+		}
+
+		// Create and write to temp file
+		tmpfile, err := os.CreateTemp("", "conversation-*.md")
+		if err != nil {
+			slog.Error("Failed to create temp file", "error", err)
+			return a, toast.NewErrorToast("Failed to create temporary file.")
+		}
+
+		_, err = tmpfile.WriteString(markdownContent)
+		if err != nil {
+			slog.Error("Failed to write to temp file", "error", err)
+			tmpfile.Close()
+			os.Remove(tmpfile.Name())
+			return a, toast.NewErrorToast("Failed to write conversation to file.")
+		}
+		tmpfile.Close()
+
+		// Open in editor
+		c := exec.Command(editor, tmpfile.Name())
+		c.Stdin = os.Stdin
+		c.Stdout = os.Stdout
+		c.Stderr = os.Stderr
+		cmd = tea.ExecProcess(c, func(err error) tea.Msg {
+			if err != nil {
+				slog.Error("Failed to open editor for conversation", "error", err)
+			}
+			// Clean up the file after editor closes
+			os.Remove(tmpfile.Name())
+			return nil
+		})
+		cmds = append(cmds, cmd)
 	case commands.ToolDetailsCommand:
 		message := "Tool details are now visible"
 		if a.messages.ToolDetailsVisible() {
@@ -910,12 +914,11 @@ func (a appModel) executeCommand(command commands.Command) (tea.Model, tea.Cmd)
 	case commands.ThemeListCommand:
 		themeDialog := dialog.NewThemeDialog()
 		a.modal = themeDialog
-	case commands.FileListCommand:
+	// case commands.FileListCommand:
-		a.editor.Blur()
+	// 	a.editor.Blur()
-		provider := completions.NewFileContextGroup(a.app)
+	// 	findDialog := dialog.NewFindDialog(a.fileProvider)
-		findDialog := dialog.NewFindDialog(provider)
+	// 	cmds = append(cmds, findDialog.Init())
-		findDialog.SetWidth(layout.Current.Container.Width - 8)
+	// 	a.modal = findDialog
-		a.modal = findDialog
 	case commands.FileCloseCommand:
 		a.fileViewer, cmd = a.fileViewer.Clear()
 		cmds = append(cmds, cmd)
@@ -948,11 +951,11 @@ func (a appModel) executeCommand(command commands.Command) (tea.Model, tea.Cmd)
 		a.editor = updated.(chat.EditorComponent)
 		cmds = append(cmds, cmd)
 	case commands.MessagesFirstCommand:
-		updated, cmd := a.messages.First()
+		updated, cmd := a.messages.GotoTop()
 		a.messages = updated.(chat.MessagesComponent)
 		cmds = append(cmds, cmd)
 	case commands.MessagesLastCommand:
-		updated, cmd := a.messages.Last()
+		updated, cmd := a.messages.GotoBottom()
 		a.messages = updated.(chat.MessagesComponent)
 		cmds = append(cmds, cmd)
 	case commands.MessagesPageUpCommand:
@@ -991,26 +994,14 @@ func (a appModel) executeCommand(command commands.Command) (tea.Model, tea.Cmd)
 			a.messages = updated.(chat.MessagesComponent)
 			cmds = append(cmds, cmd)
 		}
-	case commands.MessagesPreviousCommand:
-		updated, cmd := a.messages.Previous()
-		a.messages = updated.(chat.MessagesComponent)
-		cmds = append(cmds, cmd)
-	case commands.MessagesNextCommand:
-		updated, cmd := a.messages.Next()
-		a.messages = updated.(chat.MessagesComponent)
-		cmds = append(cmds, cmd)
 	case commands.MessagesLayoutToggleCommand:
 		a.messagesRight = !a.messagesRight
 		a.app.State.MessagesRight = a.messagesRight
 		a.app.SaveState()
 	case commands.MessagesCopyCommand:
-		selected := a.messages.Selected()
+		updated, cmd := a.messages.CopyLastMessage()
-		if selected != "" {
+		a.messages = updated.(chat.MessagesComponent)
-			cmd = a.app.SetClipboard(selected)
+		cmds = append(cmds, cmd)
-			cmds = append(cmds, cmd)
-			cmd = toast.NewSuccessToast("Message copied to clipboard")
-			cmds = append(cmds, cmd)
-		}
 	case commands.MessagesRevertCommand:
 	case commands.AppExitCommand:
 		return a, tea.Quit
@@ -1053,3 +1044,44 @@ func NewModel(app *app.App) tea.Model {
 
 	return model
 }
+
+func formatConversationToMarkdown(messages []app.Message) string {
+	var builder strings.Builder
+
+	builder.WriteString("# Conversation History\n\n")
+
+	for _, msg := range messages {
+		builder.WriteString("---\n\n")
+
+		var role string
+		var timestamp time.Time
+
+		switch info := msg.Info.(type) {
+		case opencode.UserMessage:
+			role = "User"
+			timestamp = time.UnixMilli(int64(info.Time.Created))
+		case opencode.AssistantMessage:
+			role = "Assistant"
+			timestamp = time.UnixMilli(int64(info.Time.Created))
+		default:
+			continue
+		}
+
+		builder.WriteString(
+			fmt.Sprintf("**%s** (*%s*)\n\n", role, timestamp.Format("2006-01-02 15:04:05")),
+		)
+
+		for _, part := range msg.Parts {
+			switch p := part.(type) {
+			case opencode.TextPart:
+				builder.WriteString(p.Text + "\n\n")
+			case opencode.FilePart:
+				builder.WriteString(fmt.Sprintf("[File: %s]\n\n", p.Filename))
+			case opencode.ToolPart:
+				builder.WriteString(fmt.Sprintf("[Tool: %s]\n\n", p.Tool))
+			}
+		}
+	}
+
+	return builder.String()
+}

packages/tui/internal/util/file.go

@@ -83,11 +83,17 @@ func Extension(path string) string {
 }
 
 func ToMarkdown(content string, width int, backgroundColor compat.AdaptiveColor) string {
-	r := styles.GetMarkdownRenderer(width-6, backgroundColor)
+	renderWidth := width - GetMarkdownContainerFrame()
+	r := styles.GetMarkdownRenderer(renderWidth, backgroundColor)
 	content = strings.ReplaceAll(content, RootPath+"/", "")
-	rendered, _ := r.Render(content)
-	lines := strings.Split(rendered, "\n")
 
+	// Apply hyphen preservation during markdown rendering
+	rendered := ProcessTextWithHyphens(content, func(t string) string {
+		result, _ := r.Render(t)
+		return result
+	})
+	lines := strings.Split(rendered, "\n")
+	// Clean up empty lines at start/end
 	if len(lines) > 0 {
 		firstLine := lines[0]
 		cleaned := ansi.Strip(firstLine)

packages/tui/internal/util/text.go

@@ -0,0 +1,52 @@
+package util
+
+import (
+	"regexp"
+	"strings"
+
+	"github.com/charmbracelet/lipgloss/v2"
+)
+
+// PreventHyphenBreaks replaces regular hyphens with non-breaking hyphens to prevent
+// sparse word breaks in hyphenated terms like "claude-code-action".
+// This improves readability by keeping hyphenated words together.
+// Only preserves hyphens within words, not markdown syntax like bullet points.
+func PreventHyphenBreaks(text string) string {
+	// Use regex to match hyphens that are between word characters
+	// This preserves hyphens in words like "claude-code-action" but not in "- [ ]"
+	re := regexp.MustCompile(`(\w)-(\w)`)
+	return re.ReplaceAllString(text, "$1\u2011$2")
+}
+
+// RestoreHyphens converts non-breaking hyphens back to regular hyphens.
+// This should be called after text processing (like word wrapping) is complete.
+func RestoreHyphens(text string) string {
+	return strings.ReplaceAll(text, "\u2011", "-")
+}
+
+// ProcessTextWithHyphens applies hyphen preservation to text during processing.
+// It wraps the provided processFunc with hyphen handling.
+func ProcessTextWithHyphens(text string, processFunc func(string) string) string {
+	preserved := PreventHyphenBreaks(text)
+	processed := processFunc(preserved)
+	return RestoreHyphens(processed)
+}
+
+// GetMessageContainerFrame calculates the actual horizontal frame size
+// (padding + borders) for message containers based on current theme.
+func GetMessageContainerFrame() int {
+	style := lipgloss.NewStyle().
+		BorderStyle(lipgloss.ThickBorder()).
+		BorderLeft(true).
+		BorderRight(true).
+		PaddingLeft(2).
+		PaddingRight(2)
+	return style.GetHorizontalFrameSize()
+}
+
+// GetMarkdownContainerFrame calculates the actual horizontal frame size
+// for markdown containers based on current theme.
+func GetMarkdownContainerFrame() int {
+	// Markdown containers use the same styling as message containers
+	return GetMessageContainerFrame()
+}

packages/tui/internal/util/util.go

@@ -40,8 +40,8 @@ func IsWsl() bool {
 
 func Measure(tag string) func(...any) {
 	startTime := time.Now()
-	return func(tags ...any) {
+	return func(args ...any) {
-		args := append([]any{"timeTakenMs", time.Since(startTime).Milliseconds()}, tags...)
+		args = append(args, []any{"timeTakenMs", time.Since(startTime).Milliseconds()}...)
 		slog.Debug(tag, args...)
 	}
 }

packages/tui/internal/viewport/highlight.go

@@ -0,0 +1,141 @@
+package viewport
+
+import (
+	"github.com/charmbracelet/lipgloss/v2"
+	"github.com/charmbracelet/x/ansi"
+	"github.com/rivo/uniseg"
+)
+
+// parseMatches converts the given matches into highlight ranges.
+//
+// Assumptions:
+// - matches are measured in bytes, e.g. what [regex.FindAllStringIndex] would return
+// - matches were made against the given content
+// - matches are in order
+// - matches do not overlap
+// - content is line terminated with \n only
+//
+// We'll then convert the ranges into [highlightInfo]s, which hold the starting
+// line and the grapheme positions.
+func parseMatches(
+	content string,
+	matches [][]int,
+) []highlightInfo {
+	if len(matches) == 0 {
+		return nil
+	}
+
+	line := 0
+	graphemePos := 0
+	previousLinesOffset := 0
+	bytePos := 0
+
+	highlights := make([]highlightInfo, 0, len(matches))
+	gr := uniseg.NewGraphemes(ansi.Strip(content))
+
+	for _, match := range matches {
+		byteStart, byteEnd := match[0], match[1]
+
+		// hilight for this match:
+		hi := highlightInfo{
+			lines: map[int][2]int{},
+		}
+
+		// find the beginning of this byte range, setup current line and
+		// grapheme position.
+		for byteStart > bytePos {
+			if !gr.Next() {
+				break
+			}
+			if content[bytePos] == '\n' {
+				previousLinesOffset = graphemePos + 1
+				line++
+			}
+			graphemePos += max(1, gr.Width())
+			bytePos += len(gr.Str())
+		}
+
+		hi.lineStart = line
+		hi.lineEnd = line
+
+		graphemeStart := graphemePos
+
+		// loop until we find the end
+		for byteEnd > bytePos {
+			if !gr.Next() {
+				break
+			}
+
+			// if it ends with a new line, add the range, increase line, and continue
+			if content[bytePos] == '\n' {
+				colstart := max(0, graphemeStart-previousLinesOffset)
+				colend := max(graphemePos-previousLinesOffset+1, colstart) // +1 its \n itself
+
+				if colend > colstart {
+					hi.lines[line] = [2]int{colstart, colend}
+					hi.lineEnd = line
+				}
+
+				previousLinesOffset = graphemePos + 1
+				line++
+			}
+
+			graphemePos += max(1, gr.Width())
+			bytePos += len(gr.Str())
+		}
+
+		// we found it!, add highlight and continue
+		if bytePos == byteEnd {
+			colstart := max(0, graphemeStart-previousLinesOffset)
+			colend := max(graphemePos-previousLinesOffset, colstart)
+
+			if colend > colstart {
+				hi.lines[line] = [2]int{colstart, colend}
+				hi.lineEnd = line
+			}
+		}
+
+		highlights = append(highlights, hi)
+	}
+
+	return highlights
+}
+
+type highlightInfo struct {
+	// in which line this highlight starts and ends
+	lineStart, lineEnd int
+
+	// the grapheme highlight ranges for each of these lines
+	lines map[int][2]int
+}
+
+// coords returns the line x column of this highlight.
+func (hi highlightInfo) coords() (int, int, int) {
+	for i := hi.lineStart; i <= hi.lineEnd; i++ {
+		hl, ok := hi.lines[i]
+		if !ok {
+			continue
+		}
+		return i, hl[0], hl[1]
+	}
+	return hi.lineStart, 0, 0
+}
+
+func makeHighlightRanges(
+	highlights []highlightInfo,
+	line int,
+	style lipgloss.Style,
+) []lipgloss.Range {
+	result := []lipgloss.Range{}
+	for _, hi := range highlights {
+		lihi, ok := hi.lines[line]
+		if !ok {
+			continue
+		}
+		if lihi == [2]int{} {
+			continue
+		}
+		result = append(result, lipgloss.NewRange(lihi[0], lihi[1], style))
+	}
+	return result
+}

packages/tui/internal/viewport/keymap.go

@@ -0,0 +1,56 @@
+package viewport
+
+import "github.com/charmbracelet/bubbles/v2/key"
+
+// KeyMap defines the keybindings for the viewport. Note that you don't
+// necessary need to use keybindings at all; the viewport can be controlled
+// programmatically with methods like Model.LineDown(1). See the GoDocs for
+// details.
+type KeyMap struct {
+	PageDown     key.Binding
+	PageUp       key.Binding
+	HalfPageUp   key.Binding
+	HalfPageDown key.Binding
+	Down         key.Binding
+	Up           key.Binding
+	Left         key.Binding
+	Right        key.Binding
+}
+
+// DefaultKeyMap returns a set of pager-like default keybindings.
+func DefaultKeyMap() KeyMap {
+	return KeyMap{
+		PageDown: key.NewBinding(
+			key.WithKeys("pgdown", "space", "f"),
+			key.WithHelp("f/pgdn", "page down"),
+		),
+		PageUp: key.NewBinding(
+			key.WithKeys("pgup", "b"),
+			key.WithHelp("b/pgup", "page up"),
+		),
+		HalfPageUp: key.NewBinding(
+			key.WithKeys("u", "ctrl+u"),
+			key.WithHelp("u", "½ page up"),
+		),
+		HalfPageDown: key.NewBinding(
+			key.WithKeys("d", "ctrl+d"),
+			key.WithHelp("d", "½ page down"),
+		),
+		Up: key.NewBinding(
+			key.WithKeys("up", "k"),
+			key.WithHelp("↑/k", "up"),
+		),
+		Down: key.NewBinding(
+			key.WithKeys("down", "j"),
+			key.WithHelp("↓/j", "down"),
+		),
+		Left: key.NewBinding(
+			key.WithKeys("left", "h"),
+			key.WithHelp("←/h", "move left"),
+		),
+		Right: key.NewBinding(
+			key.WithKeys("right", "l"),
+			key.WithHelp("→/l", "move right"),
+		),
+	}
+}

packages/tui/internal/viewport/viewport.go

@@ -0,0 +1,803 @@
+package viewport
+
+import (
+	"math"
+	"strings"
+
+	"github.com/charmbracelet/bubbles/v2/key"
+	tea "github.com/charmbracelet/bubbletea/v2"
+	"github.com/charmbracelet/lipgloss/v2"
+	"github.com/charmbracelet/x/ansi"
+)
+
+const (
+	defaultHorizontalStep = 6
+)
+
+// Option is a configuration option that works in conjunction with [New]. For
+// example:
+//
+//	timer := New(WithWidth(10, WithHeight(5)))
+type Option func(*Model)
+
+// WithWidth is an initialization option that sets the width of the
+// viewport. Pass as an argument to [New].
+func WithWidth(w int) Option {
+	return func(m *Model) {
+		m.width = w
+	}
+}
+
+// WithHeight is an initialization option that sets the height of the
+// viewport. Pass as an argument to [New].
+func WithHeight(h int) Option {
+	return func(m *Model) {
+		m.height = h
+	}
+}
+
+// New returns a new model with the given width and height as well as default
+// key mappings.
+func New(opts ...Option) (m Model) {
+	for _, opt := range opts {
+		opt(&m)
+	}
+	m.setInitialValues()
+	m.memo = &Memo{}
+	return m
+}
+
+type Memo struct {
+	dirty bool
+	cache string
+}
+
+func (m *Memo) View(render func() string) string {
+	if m.dirty {
+		// slog.Debug("memo dirty")
+		m.cache = render()
+		m.dirty = false
+		return m.cache
+	}
+	// slog.Debug("memo cache")
+	return m.cache
+}
+
+func (m *Memo) Invalidate() {
+	m.dirty = true
+}
+
+// Model is the Bubble Tea model for this viewport element.
+type Model struct {
+	memo   *Memo
+	width  int
+	height int
+	KeyMap KeyMap
+
+	// Whether or not to wrap text. If false, it'll allow horizontal scrolling
+	// instead.
+	SoftWrap bool
+
+	// Whether or not to fill to the height of the viewport with empty lines.
+	FillHeight bool
+
+	// Whether or not to respond to the mouse. The mouse must be enabled in
+	// Bubble Tea for this to work. For details, see the Bubble Tea docs.
+	MouseWheelEnabled bool
+
+	// The number of lines the mouse wheel will scroll. By default, this is 3.
+	MouseWheelDelta int
+
+	// YOffset is the vertical scroll position.
+	YOffset int
+
+	// xOffset is the horizontal scroll position.
+	xOffset int
+
+	// horizontalStep is the number of columns we move left or right during a
+	// default horizontal scroll.
+	horizontalStep int
+
+	// YPosition is the position of the viewport in relation to the terminal
+	// window. It's used in high performance rendering only.
+	YPosition int
+
+	// Style applies a lipgloss style to the viewport. Realistically, it's most
+	// useful for setting borders, margins and padding.
+	Style lipgloss.Style
+
+	// LeftGutterFunc allows to define a [GutterFunc] that adds a column into
+	// the left of the viewport, which is kept when horizontal scrolling.
+	// This can be used for things like line numbers, selection indicators,
+	// show statuses, etc.
+	LeftGutterFunc GutterFunc
+
+	initialized      bool
+	lines            []string
+	longestLineWidth int
+
+	// HighlightStyle highlights the ranges set with [SetHighligths].
+	HighlightStyle lipgloss.Style
+
+	// SelectedHighlightStyle highlights the highlight range focused during
+	// navigation.
+	// Use [SetHighligths] to set the highlight ranges, and [HightlightNext]
+	// and [HihglightPrevious] to navigate.
+	SelectedHighlightStyle lipgloss.Style
+
+	// StyleLineFunc allows to return a [lipgloss.Style] for each line.
+	// The argument is the line index.
+	StyleLineFunc func(int) lipgloss.Style
+
+	highlights []highlightInfo
+	hiIdx      int
+}
+
+// GutterFunc can be implemented and set into [Model.LeftGutterFunc].
+//
+// Example implementation showing line numbers:
+//
+//	func(info GutterContext) string {
+//		if info.Soft {
+//			return "     │ "
+//		}
+//		if info.Index >= info.TotalLines {
+//			return "   ~ │ "
+//		}
+//		return fmt.Sprintf("%4d │ ", info.Index+1)
+//	}
+type GutterFunc func(GutterContext) string
+
+// NoGutter is the default gutter used.
+var NoGutter = func(GutterContext) string { return "" }
+
+// GutterContext provides context to a [GutterFunc].
+type GutterContext struct {
+	Index      int
+	TotalLines int
+	Soft       bool
+}
+
+func (m *Model) setInitialValues() {
+	m.KeyMap = DefaultKeyMap()
+	m.MouseWheelEnabled = true
+	m.MouseWheelDelta = 3
+	m.initialized = true
+	m.horizontalStep = defaultHorizontalStep
+	m.LeftGutterFunc = NoGutter
+}
+
+// Init exists to satisfy the tea.Model interface for composability purposes.
+func (m Model) Init() tea.Cmd {
+	return nil
+}
+
+// Height returns the height of the viewport.
+func (m Model) Height() int {
+	return m.height
+}
+
+// SetHeight sets the height of the viewport.
+func (m *Model) SetHeight(h int) {
+	m.height = h
+	m.memo.Invalidate()
+}
+
+// Width returns the width of the viewport.
+func (m Model) Width() int {
+	return m.width
+}
+
+// SetWidth sets the width of the viewport.
+func (m *Model) SetWidth(w int) {
+	m.width = w
+	m.memo.Invalidate()
+}
+
+// AtTop returns whether or not the viewport is at the very top position.
+func (m Model) AtTop() bool {
+	return m.YOffset <= 0
+}
+
+// AtBottom returns whether or not the viewport is at or past the very bottom
+// position.
+func (m Model) AtBottom() bool {
+	return m.YOffset >= m.maxYOffset()
+}
+
+// PastBottom returns whether or not the viewport is scrolled beyond the last
+// line. This can happen when adjusting the viewport height.
+func (m Model) PastBottom() bool {
+	return m.YOffset > m.maxYOffset()
+}
+
+// ScrollPercent returns the amount scrolled as a float between 0 and 1.
+func (m Model) ScrollPercent() float64 {
+	count := m.lineCount()
+	if m.Height() >= count {
+		return 1.0
+	}
+	y := float64(m.YOffset)
+	h := float64(m.Height())
+	t := float64(count)
+	v := y / (t - h)
+	return math.Max(0.0, math.Min(1.0, v))
+}
+
+// HorizontalScrollPercent returns the amount horizontally scrolled as a float
+// between 0 and 1.
+func (m Model) HorizontalScrollPercent() float64 {
+	if m.xOffset >= m.longestLineWidth-m.Width() {
+		return 1.0
+	}
+	y := float64(m.xOffset)
+	h := float64(m.Width())
+	t := float64(m.longestLineWidth)
+	v := y / (t - h)
+	return math.Max(0.0, math.Min(1.0, v))
+}
+
+// SetContent set the pager's text content.
+// Line endings will be normalized to '\n'.
+func (m *Model) SetContent(s string) {
+	s = strings.ReplaceAll(s, "\r\n", "\n") // normalize line endings
+	m.SetContentLines(strings.Split(s, "\n"))
+	m.memo.Invalidate()
+}
+
+// SetContentLines allows to set the lines to be shown instead of the content.
+// If a given line has a \n in it, it'll be considered a [Model.SoftWrap].
+// See also [Model.SetContent].
+func (m *Model) SetContentLines(lines []string) {
+	// if there's no content, set content to actual nil instead of one empty
+	// line.
+	m.lines = lines
+	if len(m.lines) == 1 && ansi.StringWidth(m.lines[0]) == 0 {
+		m.lines = nil
+	}
+	m.longestLineWidth = maxLineWidth(m.lines)
+	m.ClearHighlights()
+
+	if m.YOffset > m.maxYOffset() {
+		m.GotoBottom()
+	}
+	m.memo.Invalidate()
+}
+
+// GetContent returns the entire content as a single string.
+// Line endings are normalized to '\n'.
+func (m Model) GetContent() string {
+	return strings.Join(m.lines, "\n")
+}
+
+// calculateLine taking soft wraping into account, returns the total viewable
+// lines and the real-line index for the given yoffset.
+func (m Model) calculateLine(yoffset int) (total, idx int) {
+	if !m.SoftWrap {
+		for i, line := range m.lines {
+			adjust := max(1, lipgloss.Height(line))
+			if yoffset >= total && yoffset < total+adjust {
+				idx = i
+			}
+			total += adjust
+		}
+		if yoffset >= total {
+			idx = len(m.lines)
+		}
+		return total, idx
+	}
+
+	maxWidth := m.maxWidth()
+	var gutterSize int
+	if m.LeftGutterFunc != nil {
+		gutterSize = lipgloss.Width(m.LeftGutterFunc(GutterContext{}))
+	}
+	for i, line := range m.lines {
+		adjust := max(1, lipgloss.Width(line)/(maxWidth-gutterSize))
+		if yoffset >= total && yoffset < total+adjust {
+			idx = i
+		}
+		total += adjust
+	}
+	if yoffset >= total {
+		idx = len(m.lines)
+	}
+	return total, idx
+}
+
+// lineToIndex taking soft wrappign into account, return the real line index
+// for the given line.
+func (m Model) lineToIndex(y int) int {
+	_, idx := m.calculateLine(y)
+	return idx
+}
+
+// lineCount taking soft wrapping into account, return the total viewable line
+// count (real lines + soft wrapped line).
+func (m Model) lineCount() int {
+	total, _ := m.calculateLine(0)
+	return total
+}
+
+// maxYOffset returns the maximum possible value of the y-offset based on the
+// viewport's content and set height.
+func (m Model) maxYOffset() int {
+	return max(0, m.lineCount()-m.Height()+m.Style.GetVerticalFrameSize())
+}
+
+// maxXOffset returns the maximum possible value of the x-offset based on the
+// viewport's content and set width.
+func (m Model) maxXOffset() int {
+	return max(0, m.longestLineWidth-m.Width())
+}
+
+func (m Model) maxWidth() int {
+	var gutterSize int
+	if m.LeftGutterFunc != nil {
+		gutterSize = lipgloss.Width(m.LeftGutterFunc(GutterContext{}))
+	}
+	return m.Width() -
+		m.Style.GetHorizontalFrameSize() -
+		gutterSize
+}
+
+func (m Model) maxHeight() int {
+	return m.Height() - m.Style.GetVerticalFrameSize()
+}
+
+// visibleLines returns the lines that should currently be visible in the
+// viewport.
+func (m Model) visibleLines() (lines []string) {
+	maxHeight := m.maxHeight()
+	maxWidth := m.maxWidth()
+
+	if m.lineCount() > 0 {
+		pos := m.lineToIndex(m.YOffset)
+		top := max(0, pos)
+		bottom := clamp(pos+maxHeight, top, len(m.lines))
+		lines = make([]string, bottom-top)
+		copy(lines, m.lines[top:bottom])
+		lines = m.styleLines(lines, top)
+		lines = m.highlightLines(lines, top)
+	}
+
+	for m.FillHeight && len(lines) < maxHeight {
+		lines = append(lines, "")
+	}
+
+	// if longest line fit within width, no need to do anything else.
+	if (m.xOffset == 0 && m.longestLineWidth <= maxWidth) || maxWidth == 0 {
+		return m.setupGutter(lines)
+	}
+
+	if m.SoftWrap {
+		return m.softWrap(lines, maxWidth)
+	}
+
+	for i, line := range lines {
+		sublines := strings.Split(line, "\n") // will only have more than 1 if caller used [Model.SetContentLines].
+		for j := range sublines {
+			sublines[j] = ansi.Cut(sublines[j], m.xOffset, m.xOffset+maxWidth)
+		}
+		lines[i] = strings.Join(sublines, "\n")
+	}
+	return m.setupGutter(lines)
+}
+
+// styleLines styles the lines using [Model.StyleLineFunc].
+func (m Model) styleLines(lines []string, offset int) []string {
+	if m.StyleLineFunc == nil {
+		return lines
+	}
+	for i := range lines {
+		lines[i] = m.StyleLineFunc(i + offset).Render(lines[i])
+	}
+	return lines
+}
+
+// highlightLines highlights the lines with [Model.HighlightStyle] and
+// [Model.SelectedHighlightStyle].
+func (m Model) highlightLines(lines []string, offset int) []string {
+	if len(m.highlights) == 0 {
+		return lines
+	}
+	for i := range lines {
+		ranges := makeHighlightRanges(
+			m.highlights,
+			i+offset,
+			m.HighlightStyle,
+		)
+		lines[i] = lipgloss.StyleRanges(lines[i], ranges...)
+		if m.hiIdx < 0 {
+			continue
+		}
+		sel := m.highlights[m.hiIdx]
+		if hi, ok := sel.lines[i+offset]; ok {
+			lines[i] = lipgloss.StyleRanges(lines[i], lipgloss.NewRange(
+				hi[0],
+				hi[1],
+				m.SelectedHighlightStyle,
+			))
+		}
+	}
+	return lines
+}
+
+func (m Model) softWrap(lines []string, maxWidth int) []string {
+	var wrappedLines []string
+	total := m.TotalLineCount()
+	for i, line := range lines {
+		idx := 0
+		for ansi.StringWidth(line) >= idx {
+			truncatedLine := ansi.Cut(line, idx, maxWidth+idx)
+			if m.LeftGutterFunc != nil {
+				truncatedLine = m.LeftGutterFunc(GutterContext{
+					Index:      i + m.YOffset,
+					TotalLines: total,
+					Soft:       idx > 0,
+				}) + truncatedLine
+			}
+			wrappedLines = append(wrappedLines, truncatedLine)
+			idx += maxWidth
+		}
+	}
+	return wrappedLines
+}
+
+// setupGutter sets up the left gutter using [Moddel.LeftGutterFunc].
+func (m Model) setupGutter(lines []string) []string {
+	if m.LeftGutterFunc == nil {
+		return lines
+	}
+
+	offset := max(0, m.lineToIndex(m.YOffset))
+	total := m.TotalLineCount()
+	result := make([]string, len(lines))
+	for i := range lines {
+		var line []string
+		for j, realLine := range strings.Split(lines[i], "\n") {
+			line = append(line, m.LeftGutterFunc(GutterContext{
+				Index:      i + offset,
+				TotalLines: total,
+				Soft:       j > 0,
+			})+realLine)
+		}
+		result[i] = strings.Join(line, "\n")
+	}
+	m.memo.Invalidate()
+	return result
+}
+
+// SetYOffset sets the Y offset.
+func (m *Model) SetYOffset(n int) {
+	m.YOffset = clamp(n, 0, m.maxYOffset())
+	m.memo.Invalidate()
+}
+
+// SetXOffset sets the X offset.
+// No-op when soft wrap is enabled.
+func (m *Model) SetXOffset(n int) {
+	if m.SoftWrap {
+		return
+	}
+	m.xOffset = clamp(n, 0, m.maxXOffset())
+	m.memo.Invalidate()
+}
+
+// EnsureVisible ensures that the given line and column are in the viewport.
+func (m *Model) EnsureVisible(line, colstart, colend int) {
+	maxWidth := m.maxWidth()
+	if colend <= maxWidth {
+		m.SetXOffset(0)
+	} else {
+		m.SetXOffset(colstart - m.horizontalStep) // put one step to the left, feels more natural
+	}
+
+	if line < m.YOffset || line >= m.YOffset+m.maxHeight() {
+		m.SetYOffset(line)
+	}
+
+	m.visibleLines()
+}
+
+// ViewDown moves the view down by the number of lines in the viewport.
+// Basically, "page down".
+func (m *Model) ViewDown() {
+	if m.AtBottom() {
+		return
+	}
+
+	m.LineDown(m.Height())
+	m.memo.Invalidate()
+}
+
+// ViewUp moves the view up by one height of the viewport. Basically, "page up".
+func (m *Model) ViewUp() {
+	if m.AtTop() {
+		return
+	}
+
+	m.LineUp(m.Height())
+	m.memo.Invalidate()
+}
+
+// HalfViewDown moves the view down by half the height of the viewport.
+func (m *Model) HalfViewDown() {
+	if m.AtBottom() {
+		return
+	}
+
+	m.LineDown(m.Height() / 2) //nolint:mnd
+	m.memo.Invalidate()
+}
+
+// HalfViewUp moves the view up by half the height of the viewport.
+func (m *Model) HalfViewUp() {
+	if m.AtTop() {
+		return
+	}
+
+	m.LineUp(m.Height() / 2) //nolint:mnd
+	m.memo.Invalidate()
+}
+
+// LineDown moves the view down by the given number of lines.
+func (m *Model) LineDown(n int) {
+	if m.AtBottom() || n == 0 || len(m.lines) == 0 {
+		return
+	}
+
+	// Make sure the number of lines by which we're going to scroll isn't
+	// greater than the number of lines we actually have left before we reach
+	// the bottom.
+	m.SetYOffset(m.YOffset + n)
+	m.hiIdx = m.findNearedtMatch()
+	m.memo.Invalidate()
+}
+
+// LineUp moves the view down by the given number of lines. Returns the new
+// lines to show.
+func (m *Model) LineUp(n int) {
+	if m.AtTop() || n == 0 || len(m.lines) == 0 {
+		return
+	}
+
+	// Make sure the number of lines by which we're going to scroll isn't
+	// greater than the number of lines we are from the top.
+	m.SetYOffset(m.YOffset - n)
+	m.hiIdx = m.findNearedtMatch()
+	m.memo.Invalidate()
+}
+
+// TotalLineCount returns the total number of lines (both hidden and visible) within the viewport.
+func (m Model) TotalLineCount() int {
+	return m.lineCount()
+}
+
+// VisibleLineCount returns the number of the visible lines within the viewport.
+func (m Model) VisibleLineCount() int {
+	return len(m.visibleLines())
+}
+
+// GotoTop sets the viewport to the top position.
+func (m *Model) GotoTop() (lines []string) {
+	if m.AtTop() {
+		return nil
+	}
+
+	m.SetYOffset(0)
+	m.hiIdx = m.findNearedtMatch()
+	m.memo.Invalidate()
+	return m.visibleLines()
+}
+
+// GotoBottom sets the viewport to the bottom position.
+func (m *Model) GotoBottom() (lines []string) {
+	m.SetYOffset(m.maxYOffset())
+	m.hiIdx = m.findNearedtMatch()
+	m.memo.Invalidate()
+	return m.visibleLines()
+}
+
+// SetHorizontalStep sets the amount of cells that the viewport moves in the
+// default viewport keymapping. If set to 0 or less, horizontal scrolling is
+// disabled.
+func (m *Model) SetHorizontalStep(n int) {
+	if n < 0 {
+		n = 0
+	}
+
+	m.horizontalStep = n
+	m.memo.Invalidate()
+}
+
+// MoveLeft moves the viewport to the left by the given number of columns.
+func (m *Model) MoveLeft(cols int) {
+	m.xOffset -= cols
+	if m.xOffset < 0 {
+		m.xOffset = 0
+		m.memo.Invalidate()
+	}
+}
+
+// MoveRight moves viewport to the right by the given number of columns.
+func (m *Model) MoveRight(cols int) {
+	// prevents over scrolling to the right
+	w := m.maxWidth()
+	if m.xOffset > m.longestLineWidth-w {
+		return
+	}
+	m.xOffset += cols
+}
+
+// Resets lines indent to zero.
+func (m *Model) ResetIndent() {
+	m.xOffset = 0
+	m.memo.Invalidate()
+}
+
+// SetHighlights sets ranges of characters to highlight.
+// For instance, `[]int{[]int{2, 10}, []int{20, 30}}` will highlight characters
+// 2 to 10 and 20 to 30.
+// Note that highlights are not expected to transpose each other, and are also
+// expected to be in order.
+// Use [Model.SetHighlights] to set the highlight ranges, and
+// [Model.HighlightNext] and [Model.HighlightPrevious] to navigate.
+// Use [Model.ClearHighlights] to remove all highlights.
+func (m *Model) SetHighlights(matches [][]int) {
+	if len(matches) == 0 || len(m.lines) == 0 {
+		return
+	}
+	m.highlights = parseMatches(m.GetContent(), matches)
+	m.hiIdx = m.findNearedtMatch()
+	m.showHighlight()
+	m.memo.Invalidate()
+}
+
+// ClearHighlights clears previously set highlights.
+func (m *Model) ClearHighlights() {
+	m.highlights = nil
+	m.hiIdx = -1
+	m.memo.Invalidate()
+}
+
+func (m *Model) showHighlight() {
+	if m.hiIdx == -1 {
+		return
+	}
+	line, colstart, colend := m.highlights[m.hiIdx].coords()
+	m.EnsureVisible(line, colstart, colend)
+	m.memo.Invalidate()
+}
+
+// HighlightNext highlights the next match.
+func (m *Model) HighlightNext() {
+	if m.highlights == nil {
+		return
+	}
+
+	m.hiIdx = (m.hiIdx + 1) % len(m.highlights)
+	m.showHighlight()
+	m.memo.Invalidate()
+}
+
+// HighlightPrevious highlights the previous match.
+func (m *Model) HighlightPrevious() {
+	if m.highlights == nil {
+		return
+	}
+
+	m.hiIdx = (m.hiIdx - 1 + len(m.highlights)) % len(m.highlights)
+	m.showHighlight()
+	m.memo.Invalidate()
+}
+
+func (m Model) findNearedtMatch() int {
+	for i, match := range m.highlights {
+		if match.lineStart >= m.YOffset {
+			return i
+		}
+	}
+	return -1
+}
+
+// Update handles standard message-based viewport updates.
+func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
+	m = m.updateAsModel(msg)
+	return m, nil
+}
+
+// Author's note: this method has been broken out to make it easier to
+// potentially transition Update to satisfy tea.Model.
+func (m Model) updateAsModel(msg tea.Msg) Model {
+	if !m.initialized {
+		m.setInitialValues()
+	}
+
+	switch msg := msg.(type) {
+	case tea.KeyPressMsg:
+		switch {
+		case key.Matches(msg, m.KeyMap.PageDown):
+			m.ViewDown()
+
+		case key.Matches(msg, m.KeyMap.PageUp):
+			m.ViewUp()
+
+		case key.Matches(msg, m.KeyMap.HalfPageDown):
+			m.HalfViewDown()
+
+		case key.Matches(msg, m.KeyMap.HalfPageUp):
+			m.HalfViewUp()
+
+		case key.Matches(msg, m.KeyMap.Down):
+			m.LineDown(1)
+
+		case key.Matches(msg, m.KeyMap.Up):
+			m.LineUp(1)
+
+		case key.Matches(msg, m.KeyMap.Left):
+			m.MoveLeft(m.horizontalStep)
+
+		case key.Matches(msg, m.KeyMap.Right):
+			m.MoveRight(m.horizontalStep)
+		}
+
+	case tea.MouseWheelMsg:
+		if !m.MouseWheelEnabled {
+			break
+		}
+
+		switch msg.Button {
+		case tea.MouseWheelDown:
+			m.LineDown(m.MouseWheelDelta)
+
+		case tea.MouseWheelUp:
+			m.LineUp(m.MouseWheelDelta)
+		}
+	}
+
+	return m
+}
+
+// View renders the viewport into a string.
+func (m *Model) render() {
+}
+
+func (m Model) View() string {
+	return m.memo.View(func() string {
+		w, h := m.Width(), m.Height()
+		if sw := m.Style.GetWidth(); sw != 0 {
+			w = min(w, sw)
+		}
+		if sh := m.Style.GetHeight(); sh != 0 {
+			h = min(h, sh)
+		}
+		contentWidth := w - m.Style.GetHorizontalFrameSize()
+		contentHeight := h - m.Style.GetVerticalFrameSize()
+		visible := m.visibleLines()
+		contents := lipgloss.NewStyle().
+			Width(contentWidth).      // pad to width.
+			Height(contentHeight).    // pad to height.
+			MaxHeight(contentHeight). // truncate height if taller.
+			MaxWidth(contentWidth).   // truncate width if wider.
+			Render(strings.Join(visible, "\n"))
+		return m.Style.
+			UnsetWidth().UnsetHeight(). // Style size already applied in contents.
+			Render(contents)
+	})
+}
+
+func clamp(v, low, high int) int {
+	if high < low {
+		low, high = high, low
+	}
+	return min(high, max(low, v))
+}
+
+func maxLineWidth(lines []string) int {
+	result := 0
+	for _, line := range lines {
+		result = max(result, lipgloss.Width(line))
+	}
+	return result
+}

packages/tui/sdk/.stats.yml

@@ -1,4 +1,4 @@
 configured_endpoints: 22
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/opencode%2Fopencode-05150c78e0e6e97b0ce97ed685ebcf1cb01dc839beccb99e9d3ead5b783cfd47.yml
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/opencode%2Fopencode-a1da357fcefd3105736841fbf44018022fade78e67ffc81e178cf9196da723ee.yml
-openapi_spec_hash: 833a5b6d53d98dc2beac2c4c394b20d5
+openapi_spec_hash: 9bd27afcc5b8f43d8e4223f7c984035f
-config_hash: 3695cfc829cfaae14490850b4a1ed282
+config_hash: 62b73a3397120578a992bffd1e69386a

packages/tui/sdk/README.md

@@ -49,14 +49,11 @@ import (
 
 func main() {
 	client := opencode.NewClient()
-	stream := client.Event.ListStreaming(context.TODO())
+	sessions, err := client.Session.List(context.TODO())
-	for stream.Next() {
-		fmt.Printf("%+v\n", stream.Current())
-	}
-	err := stream.Err()
 	if err != nil {
 		panic(err.Error())
 	}
+	fmt.Printf("%+v\n", sessions)
 }
 
 ```
@@ -145,7 +142,7 @@ client := opencode.NewClient(
 	option.WithHeader("X-Some-Header", "custom_header_info"),
 )
 
-client.Event.List(context.TODO(), ...,
+client.Session.List(context.TODO(), ...,
 	// Override the header
 	option.WithHeader("X-Some-Header", "some_other_custom_header_info"),
 	// Add an undocumented field to the request body, using sjson syntax
@@ -174,14 +171,14 @@ When the API returns a non-success status code, we return an error with type
 To handle errors, we recommend that you use the `errors.As` pattern:
 
 ```go
-stream := client.Event.ListStreaming(context.TODO())
+_, err := client.Session.List(context.TODO())
-if stream.Err() != nil {
+if err != nil {
 	var apierr *opencode.Error
-	if errors.As(stream.Err(), &apierr) {
+	if errors.As(err, &apierr) {
 		println(string(apierr.DumpRequest(true)))  // Prints the serialized HTTP request
 		println(string(apierr.DumpResponse(true))) // Prints the serialized HTTP response
 	}
-	panic(stream.Err().Error()) // GET "/event": 400 Bad Request { ... }
+	panic(err.Error()) // GET "/session": 400 Bad Request { ... }
 }
 ```
 
@@ -199,7 +196,7 @@ To set a per-retry timeout, use `option.WithRequestTimeout()`.
 // This sets the timeout for the request, including all the retries.
 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
 defer cancel()
-client.Event.ListStreaming(
+client.Session.List(
 	ctx,
 	// This sets the per-retry timeout
 	option.WithRequestTimeout(20*time.Second),
@@ -234,7 +231,7 @@ client := opencode.NewClient(
 )
 
 // Override per-request:
-client.Event.ListStreaming(context.TODO(), option.WithMaxRetries(5))
+client.Session.List(context.TODO(), option.WithMaxRetries(5))
 ```
 
 ### Accessing raw response data (e.g. response headers)
@@ -245,11 +242,11 @@ you need to examine response headers, status codes, or other details.
 ```go
 // Create a variable to store the HTTP response
 var response *http.Response
-stream := client.Event.ListStreaming(context.TODO(), option.WithResponseInto(&response))
+sessions, err := client.Session.List(context.TODO(), option.WithResponseInto(&response))
-if stream.Err() != nil {
+if err != nil {
 	// handle error
 }
-fmt.Printf("%+v\n", events)
+fmt.Printf("%+v\n", sessions)
 
 fmt.Printf("Status Code: %d\n", response.StatusCode)
 fmt.Printf("Headers: %+#v\n", response.Header)

packages/tui/sdk/api.md

@@ -21,6 +21,9 @@ Response Types:
 - <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#App">App</a>
 - <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#LogLevel">LogLevel</a>
 - <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#Mode">Mode</a>
+- <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#Model">Model</a>
+- <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#Provider">Provider</a>
+- <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#AppProvidersResponse">AppProvidersResponse</a>
 
 Methods:
 
@@ -28,6 +31,7 @@ Methods:
 - <code title="post /app/init">client.App.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#AppService.Init">Init</a>(ctx <a href="https://pkg.go.dev/context">context</a>.<a href="https://pkg.go.dev/context#Context">Context</a>) (<a href="https://pkg.go.dev/builtin#bool">bool</a>, <a href="https://pkg.go.dev/builtin#error">error</a>)</code>
 - <code title="post /log">client.App.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#AppService.Log">Log</a>(ctx <a href="https://pkg.go.dev/context">context</a>.<a href="https://pkg.go.dev/context#Context">Context</a>, body <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#AppLogParams">AppLogParams</a>) (<a href="https://pkg.go.dev/builtin#bool">bool</a>, <a href="https://pkg.go.dev/builtin#error">error</a>)</code>
 - <code title="get /mode">client.App.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#AppService.Modes">Modes</a>(ctx <a href="https://pkg.go.dev/context">context</a>.<a href="https://pkg.go.dev/context#Context">Context</a>) ([]<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#Mode">Mode</a>, <a href="https://pkg.go.dev/builtin#error">error</a>)</code>
+- <code title="get /config/providers">client.App.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#AppService.Providers">Providers</a>(ctx <a href="https://pkg.go.dev/context">context</a>.<a href="https://pkg.go.dev/context#Context">Context</a>) (<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#AppProvidersResponse">AppProvidersResponse</a>, <a href="https://pkg.go.dev/builtin#error">error</a>)</code>
 
 # Find
 
@@ -59,24 +63,21 @@ Methods:
 Response Types:
 
 - <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#Config">Config</a>
-- <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#Keybinds">Keybinds</a>
+- <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#KeybindsConfig">KeybindsConfig</a>
-- <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#McpLocal">McpLocal</a>
+- <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#McpLocalConfig">McpLocalConfig</a>
-- <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#McpRemote">McpRemote</a>
+- <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#McpRemoteConfig">McpRemoteConfig</a>
-- <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#Model">Model</a>
+- <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#ModeConfig">ModeConfig</a>
-- <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#Provider">Provider</a>
-- <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#ConfigProvidersResponse">ConfigProvidersResponse</a>
 
 Methods:
 
 - <code title="get /config">client.Config.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#ConfigService.Get">Get</a>(ctx <a href="https://pkg.go.dev/context">context</a>.<a href="https://pkg.go.dev/context#Context">Context</a>) (<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#Config">Config</a>, <a href="https://pkg.go.dev/builtin#error">error</a>)</code>
-- <code title="get /config/providers">client.Config.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#ConfigService.Providers">Providers</a>(ctx <a href="https://pkg.go.dev/context">context</a>.<a href="https://pkg.go.dev/context#Context">Context</a>) (<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#ConfigProvidersResponse">ConfigProvidersResponse</a>, <a href="https://pkg.go.dev/builtin#error">error</a>)</code>
 
 # Session
 
 Params Types:
 
-- <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#FilePartParam">FilePartParam</a>
+- <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#FilePartInputParam">FilePartInputParam</a>
-- <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#TextPartParam">TextPartParam</a>
+- <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#TextPartInputParam">TextPartInputParam</a>
 
 Response Types:
 
@@ -85,6 +86,7 @@ Response Types:
 - <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#Message">Message</a>
 - <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#Part">Part</a>
 - <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#Session">Session</a>
+- <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#SnapshotPart">SnapshotPart</a>
 - <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#StepFinishPart">StepFinishPart</a>
 - <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#StepStartPart">StepStartPart</a>
 - <a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go">opencode</a>.<a href="https://pkg.go.dev/github.com/sst/opencode-sdk-go#TextPart">TextPart</a>

packages/tui/sdk/app.go

@@ -63,6 +63,14 @@ func (r *AppService) Modes(ctx context.Context, opts ...option.RequestOption) (r
 	return
 }
 
+// List all providers
+func (r *AppService) Providers(ctx context.Context, opts ...option.RequestOption) (res *AppProvidersResponse, err error) {
+	opts = append(r.Options[:], opts...)
+	path := "config/providers"
+	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
+	return
+}
+
 type App struct {
 	Git      bool    `json:"git,required"`
 	Hostname string  `json:"hostname,required"`
@@ -203,6 +211,145 @@ func (r modeModelJSON) RawJSON() string {
 	return r.raw
 }
 
+type Model struct {
+	ID          string                 `json:"id,required"`
+	Attachment  bool                   `json:"attachment,required"`
+	Cost        ModelCost              `json:"cost,required"`
+	Limit       ModelLimit             `json:"limit,required"`
+	Name        string                 `json:"name,required"`
+	Options     map[string]interface{} `json:"options,required"`
+	Reasoning   bool                   `json:"reasoning,required"`
+	ReleaseDate string                 `json:"release_date,required"`
+	Temperature bool                   `json:"temperature,required"`
+	ToolCall    bool                   `json:"tool_call,required"`
+	JSON        modelJSON              `json:"-"`
+}
+
+// modelJSON contains the JSON metadata for the struct [Model]
+type modelJSON struct {
+	ID          apijson.Field
+	Attachment  apijson.Field
+	Cost        apijson.Field
+	Limit       apijson.Field
+	Name        apijson.Field
+	Options     apijson.Field
+	Reasoning   apijson.Field
+	ReleaseDate apijson.Field
+	Temperature apijson.Field
+	ToolCall    apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *Model) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r modelJSON) RawJSON() string {
+	return r.raw
+}
+
+type ModelCost struct {
+	Input      float64       `json:"input,required"`
+	Output     float64       `json:"output,required"`
+	CacheRead  float64       `json:"cache_read"`
+	CacheWrite float64       `json:"cache_write"`
+	JSON       modelCostJSON `json:"-"`
+}
+
+// modelCostJSON contains the JSON metadata for the struct [ModelCost]
+type modelCostJSON struct {
+	Input       apijson.Field
+	Output      apijson.Field
+	CacheRead   apijson.Field
+	CacheWrite  apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *ModelCost) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r modelCostJSON) RawJSON() string {
+	return r.raw
+}
+
+type ModelLimit struct {
+	Context float64        `json:"context,required"`
+	Output  float64        `json:"output,required"`
+	JSON    modelLimitJSON `json:"-"`
+}
+
+// modelLimitJSON contains the JSON metadata for the struct [ModelLimit]
+type modelLimitJSON struct {
+	Context     apijson.Field
+	Output      apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *ModelLimit) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r modelLimitJSON) RawJSON() string {
+	return r.raw
+}
+
+type Provider struct {
+	ID     string           `json:"id,required"`
+	Env    []string         `json:"env,required"`
+	Models map[string]Model `json:"models,required"`
+	Name   string           `json:"name,required"`
+	API    string           `json:"api"`
+	Npm    string           `json:"npm"`
+	JSON   providerJSON     `json:"-"`
+}
+
+// providerJSON contains the JSON metadata for the struct [Provider]
+type providerJSON struct {
+	ID          apijson.Field
+	Env         apijson.Field
+	Models      apijson.Field
+	Name        apijson.Field
+	API         apijson.Field
+	Npm         apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *Provider) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r providerJSON) RawJSON() string {
+	return r.raw
+}
+
+type AppProvidersResponse struct {
+	Default   map[string]string        `json:"default,required"`
+	Providers []Provider               `json:"providers,required"`
+	JSON      appProvidersResponseJSON `json:"-"`
+}
+
+// appProvidersResponseJSON contains the JSON metadata for the struct
+// [AppProvidersResponse]
+type appProvidersResponseJSON struct {
+	Default     apijson.Field
+	Providers   apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *AppProvidersResponse) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r appProvidersResponseJSON) RawJSON() string {
+	return r.raw
+}
+
 type AppLogParams struct {
 	// Log level
 	Level param.Field[AppLogParamsLevel] `json:"level,required"`

packages/tui/sdk/app_test.go

@@ -107,3 +107,25 @@ func TestAppModes(t *testing.T) {
 		t.Fatalf("err should be nil: %s", err.Error())
 	}
 }
+
+func TestAppProviders(t *testing.T) {
+	t.Skip("skipped: tests are disabled for the time being")
+	baseURL := "http://localhost:4010"
+	if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
+		baseURL = envURL
+	}
+	if !testutil.CheckTestServer(t, baseURL) {
+		return
+	}
+	client := opencode.NewClient(
+		option.WithBaseURL(baseURL),
+	)
+	_, err := client.App.Providers(context.TODO())
+	if err != nil {
+		var apierr *opencode.Error
+		if errors.As(err, &apierr) {
+			t.Log(string(apierr.DumpRequest(true)))
+		}
+		t.Fatalf("err should be nil: %s", err.Error())
+	}
+}

packages/tui/sdk/client_test.go

@@ -38,7 +38,7 @@ func TestUserAgentHeader(t *testing.T) {
 			},
 		}),
 	)
-	client.Event.ListStreaming(context.Background())
+	client.Session.List(context.Background())
 	if userAgent != fmt.Sprintf("Opencode/Go %s", internal.PackageVersion) {
 		t.Errorf("Expected User-Agent to be correct, but got: %#v", userAgent)
 	}
@@ -61,11 +61,7 @@ func TestRetryAfter(t *testing.T) {
 			},
 		}),
 	)
-	stream := client.Event.ListStreaming(context.Background())
+	_, err := client.Session.List(context.Background())
-	for stream.Next() {
-		// ...
-	}
-	err := stream.Err()
 	if err == nil {
 		t.Error("Expected there to be a cancel error")
 	}
@@ -99,11 +95,7 @@ func TestDeleteRetryCountHeader(t *testing.T) {
 		}),
 		option.WithHeaderDel("X-Stainless-Retry-Count"),
 	)
-	stream := client.Event.ListStreaming(context.Background())
+	_, err := client.Session.List(context.Background())
-	for stream.Next() {
-		// ...
-	}
-	err := stream.Err()
 	if err == nil {
 		t.Error("Expected there to be a cancel error")
 	}
@@ -132,11 +124,7 @@ func TestOverwriteRetryCountHeader(t *testing.T) {
 		}),
 		option.WithHeader("X-Stainless-Retry-Count", "42"),
 	)
-	stream := client.Event.ListStreaming(context.Background())
+	_, err := client.Session.List(context.Background())
-	for stream.Next() {
-		// ...
-	}
-	err := stream.Err()
 	if err == nil {
 		t.Error("Expected there to be a cancel error")
 	}
@@ -164,11 +152,7 @@ func TestRetryAfterMs(t *testing.T) {
 			},
 		}),
 	)
-	stream := client.Event.ListStreaming(context.Background())
+	_, err := client.Session.List(context.Background())
-	for stream.Next() {
-		// ...
-	}
-	err := stream.Err()
 	if err == nil {
 		t.Error("Expected there to be a cancel error")
 	}
@@ -190,11 +174,7 @@ func TestContextCancel(t *testing.T) {
 	)
 	cancelCtx, cancel := context.WithCancel(context.Background())
 	cancel()
-	stream := client.Event.ListStreaming(cancelCtx)
+	_, err := client.Session.List(cancelCtx)
-	for stream.Next() {
-		// ...
-	}
-	err := stream.Err()
 	if err == nil {
 		t.Error("Expected there to be a cancel error")
 	}
@@ -213,11 +193,7 @@ func TestContextCancelDelay(t *testing.T) {
 	)
 	cancelCtx, cancel := context.WithTimeout(context.Background(), 2*time.Millisecond)
 	defer cancel()
-	stream := client.Event.ListStreaming(cancelCtx)
+	_, err := client.Session.List(cancelCtx)
-	for stream.Next() {
-		// ...
-	}
-	err := stream.Err()
 	if err == nil {
 		t.Error("expected there to be a cancel error")
 	}
@@ -242,11 +218,7 @@ func TestContextDeadline(t *testing.T) {
 				},
 			}),
 		)
-		stream := client.Event.ListStreaming(deadlineCtx)
+		_, err := client.Session.List(deadlineCtx)
-		for stream.Next() {
-			// ...
-		}
-		err := stream.Err()
 		if err == nil {
 			t.Error("expected there to be a deadline error")
 		}

packages/tui/sdk/config.go

@@ -40,14 +40,6 @@ func (r *ConfigService) Get(ctx context.Context, opts ...option.RequestOption) (
 	return
 }
 
-// List all providers
-func (r *ConfigService) Providers(ctx context.Context, opts ...option.RequestOption) (res *ConfigProvidersResponse, err error) {
-	opts = append(r.Options[:], opts...)
-	path := "config/providers"
-	err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
-	return
-}
-
 type Config struct {
 	// JSON schema reference for configuration validation
 	Schema string `json:"$schema"`
@@ -62,18 +54,21 @@ type Config struct {
 	// Additional instruction files or patterns to include
 	Instructions []string `json:"instructions"`
 	// Custom keybind configurations
-	Keybinds Keybinds `json:"keybinds"`
+	Keybinds KeybindsConfig `json:"keybinds"`
+	// @deprecated Always uses stretch layout.
+	Layout ConfigLayout `json:"layout"`
 	// Minimum log level to write to log files
 	LogLevel LogLevel `json:"log_level"`
 	// MCP (Model Context Protocol) server configurations
-	Mcp  map[string]ConfigMcp `json:"mcp"`
+	Mcp map[string]ConfigMcp `json:"mcp"`
-	Mode ConfigMode           `json:"mode"`
+	// Modes configuration, see https://opencode.ai/docs/modes
+	Mode ConfigMode `json:"mode"`
 	// Model to use in the format of provider/model, eg anthropic/claude-2
 	Model string `json:"model"`
 	// Custom provider configurations and model overrides
 	Provider map[string]ConfigProvider `json:"provider"`
-	// Control sharing behavior: 'auto' enables automatic sharing, 'disabled' disables
+	// Control sharing behavior:'manual' allows manual sharing via commands, 'auto'
-	// all sharing
+	// enables automatic sharing, 'disabled' disables all sharing
 	Share ConfigShare `json:"share"`
 	// Theme name to use for the interface
 	Theme string `json:"theme"`
@@ -91,6 +86,7 @@ type configJSON struct {
 	Experimental      apijson.Field
 	Instructions      apijson.Field
 	Keybinds          apijson.Field
+	Layout            apijson.Field
 	LogLevel          apijson.Field
 	Mcp               apijson.Field
 	Mode              apijson.Field
@@ -201,6 +197,22 @@ func (r configExperimentalHookSessionCompletedJSON) RawJSON() string {
 	return r.raw
 }
 
+// @deprecated Always uses stretch layout.
+type ConfigLayout string
+
+const (
+	ConfigLayoutAuto    ConfigLayout = "auto"
+	ConfigLayoutStretch ConfigLayout = "stretch"
+)
+
+func (r ConfigLayout) IsKnown() bool {
+	switch r {
+	case ConfigLayoutAuto, ConfigLayoutStretch:
+		return true
+	}
+	return false
+}
+
 type ConfigMcp struct {
 	// Type of MCP server connection
 	Type ConfigMcpType `json:"type,required"`
@@ -210,6 +222,8 @@ type ConfigMcp struct {
 	Enabled bool `json:"enabled"`
 	// This field can have the runtime type of [map[string]string].
 	Environment interface{} `json:"environment"`
+	// This field can have the runtime type of [map[string]string].
+	Headers interface{} `json:"headers"`
 	// URL of the remote MCP server
 	URL   string        `json:"url"`
 	JSON  configMcpJSON `json:"-"`
@@ -222,6 +236,7 @@ type configMcpJSON struct {
 	Command     apijson.Field
 	Enabled     apijson.Field
 	Environment apijson.Field
+	Headers     apijson.Field
 	URL         apijson.Field
 	raw         string
 	ExtraFields map[string]apijson.Field
@@ -243,12 +258,12 @@ func (r *ConfigMcp) UnmarshalJSON(data []byte) (err error) {
 // AsUnion returns a [ConfigMcpUnion] interface which you can cast to the specific
 // types for more type safety.
 //
-// Possible runtime types of the union are [McpLocal], [McpRemote].
+// Possible runtime types of the union are [McpLocalConfig], [McpRemoteConfig].
 func (r ConfigMcp) AsUnion() ConfigMcpUnion {
 	return r.union
 }
 
-// Union satisfied by [McpLocal] or [McpRemote].
+// Union satisfied by [McpLocalConfig] or [McpRemoteConfig].
 type ConfigMcpUnion interface {
 	implementsConfigMcp()
 }
@@ -259,12 +274,12 @@ func init() {
 		"type",
 		apijson.UnionVariant{
 			TypeFilter:         gjson.JSON,
-			Type:               reflect.TypeOf(McpLocal{}),
+			Type:               reflect.TypeOf(McpLocalConfig{}),
 			DiscriminatorValue: "local",
 		},
 		apijson.UnionVariant{
 			TypeFilter:         gjson.JSON,
-			Type:               reflect.TypeOf(McpRemote{}),
+			Type:               reflect.TypeOf(McpRemoteConfig{}),
 			DiscriminatorValue: "remote",
 		},
 	)
@@ -286,10 +301,11 @@ func (r ConfigMcpType) IsKnown() bool {
 	return false
 }
 
+// Modes configuration, see https://opencode.ai/docs/modes
 type ConfigMode struct {
-	Build       ConfigModeBuild       `json:"build"`
+	Build       ModeConfig            `json:"build"`
-	Plan        ConfigModePlan        `json:"plan"`
+	Plan        ModeConfig            `json:"plan"`
-	ExtraFields map[string]ConfigMode `json:"-,extras"`
+	ExtraFields map[string]ModeConfig `json:"-,extras"`
 	JSON        configModeJSON        `json:"-"`
 }
 
@@ -309,54 +325,6 @@ func (r configModeJSON) RawJSON() string {
 	return r.raw
 }
 
-type ConfigModeBuild struct {
-	Model  string              `json:"model"`
-	Prompt string              `json:"prompt"`
-	Tools  map[string]bool     `json:"tools"`
-	JSON   configModeBuildJSON `json:"-"`
-}
-
-// configModeBuildJSON contains the JSON metadata for the struct [ConfigModeBuild]
-type configModeBuildJSON struct {
-	Model       apijson.Field
-	Prompt      apijson.Field
-	Tools       apijson.Field
-	raw         string
-	ExtraFields map[string]apijson.Field
-}
-
-func (r *ConfigModeBuild) UnmarshalJSON(data []byte) (err error) {
-	return apijson.UnmarshalRoot(data, r)
-}
-
-func (r configModeBuildJSON) RawJSON() string {
-	return r.raw
-}
-
-type ConfigModePlan struct {
-	Model  string             `json:"model"`
-	Prompt string             `json:"prompt"`
-	Tools  map[string]bool    `json:"tools"`
-	JSON   configModePlanJSON `json:"-"`
-}
-
-// configModePlanJSON contains the JSON metadata for the struct [ConfigModePlan]
-type configModePlanJSON struct {
-	Model       apijson.Field
-	Prompt      apijson.Field
-	Tools       apijson.Field
-	raw         string
-	ExtraFields map[string]apijson.Field
-}
-
-func (r *ConfigModePlan) UnmarshalJSON(data []byte) (err error) {
-	return apijson.UnmarshalRoot(data, r)
-}
-
-func (r configModePlanJSON) RawJSON() string {
-	return r.raw
-}
-
 type ConfigProvider struct {
 	Models  map[string]ConfigProviderModel `json:"models,required"`
 	ID      string                         `json:"id"`
@@ -478,24 +446,25 @@ func (r configProviderModelsLimitJSON) RawJSON() string {
 	return r.raw
 }
 
-// Control sharing behavior: 'auto' enables automatic sharing, 'disabled' disables
+// Control sharing behavior:'manual' allows manual sharing via commands, 'auto'
-// all sharing
+// enables automatic sharing, 'disabled' disables all sharing
 type ConfigShare string
 
 const (
+	ConfigShareManual   ConfigShare = "manual"
 	ConfigShareAuto     ConfigShare = "auto"
 	ConfigShareDisabled ConfigShare = "disabled"
 )
 
 func (r ConfigShare) IsKnown() bool {
 	switch r {
-	case ConfigShareAuto, ConfigShareDisabled:
+	case ConfigShareManual, ConfigShareAuto, ConfigShareDisabled:
 		return true
 	}
 	return false
 }
 
-type Keybinds struct {
+type KeybindsConfig struct {
 	// Exit the application
 	AppExit string `json:"app_exit,required"`
 	// Show help dialog
@@ -548,6 +517,8 @@ type Keybinds struct {
 	ProjectInit string `json:"project_init,required"`
 	// Compact the session
 	SessionCompact string `json:"session_compact,required"`
+	// Export session to editor
+	SessionExport string `json:"session_export,required"`
 	// Interrupt current session
 	SessionInterrupt string `json:"session_interrupt,required"`
 	// List all sessions
@@ -558,17 +529,19 @@ type Keybinds struct {
 	SessionShare string `json:"session_share,required"`
 	// Unshare current session
 	SessionUnshare string `json:"session_unshare,required"`
-	// Switch mode
+	// Next mode
 	SwitchMode string `json:"switch_mode,required"`
+	// Previous Mode
+	SwitchModeReverse string `json:"switch_mode_reverse,required"`
 	// List available themes
 	ThemeList string `json:"theme_list,required"`
 	// Toggle tool details
-	ToolDetails string       `json:"tool_details,required"`
+	ToolDetails string             `json:"tool_details,required"`
-	JSON        keybindsJSON `json:"-"`
+	JSON        keybindsConfigJSON `json:"-"`
 }
 
-// keybindsJSON contains the JSON metadata for the struct [Keybinds]
+// keybindsConfigJSON contains the JSON metadata for the struct [KeybindsConfig]
-type keybindsJSON struct {
+type keybindsConfigJSON struct {
 	AppExit              apijson.Field
 	AppHelp              apijson.Field
 	EditorOpen           apijson.Field
@@ -595,40 +568,42 @@ type keybindsJSON struct {
 	ModelList            apijson.Field
 	ProjectInit          apijson.Field
 	SessionCompact       apijson.Field
+	SessionExport        apijson.Field
 	SessionInterrupt     apijson.Field
 	SessionList          apijson.Field
 	SessionNew           apijson.Field
 	SessionShare         apijson.Field
 	SessionUnshare       apijson.Field
 	SwitchMode           apijson.Field
+	SwitchModeReverse    apijson.Field
 	ThemeList            apijson.Field
 	ToolDetails          apijson.Field
 	raw                  string
 	ExtraFields          map[string]apijson.Field
 }
 
-func (r *Keybinds) UnmarshalJSON(data []byte) (err error) {
+func (r *KeybindsConfig) UnmarshalJSON(data []byte) (err error) {
 	return apijson.UnmarshalRoot(data, r)
 }
 
-func (r keybindsJSON) RawJSON() string {
+func (r keybindsConfigJSON) RawJSON() string {
 	return r.raw
 }
 
-type McpLocal struct {
+type McpLocalConfig struct {
 	// Command and arguments to run the MCP server
 	Command []string `json:"command,required"`
 	// Type of MCP server connection
-	Type McpLocalType `json:"type,required"`
+	Type McpLocalConfigType `json:"type,required"`
 	// Enable or disable the MCP server on startup
 	Enabled bool `json:"enabled"`
 	// Environment variables to set when running the MCP server
-	Environment map[string]string `json:"environment"`
+	Environment map[string]string  `json:"environment"`
-	JSON        mcpLocalJSON      `json:"-"`
+	JSON        mcpLocalConfigJSON `json:"-"`
 }
 
-// mcpLocalJSON contains the JSON metadata for the struct [McpLocal]
+// mcpLocalConfigJSON contains the JSON metadata for the struct [McpLocalConfig]
-type mcpLocalJSON struct {
+type mcpLocalConfigJSON struct {
 	Command     apijson.Field
 	Type        apijson.Field
 	Enabled     apijson.Field
@@ -637,210 +612,98 @@ type mcpLocalJSON struct {
 	ExtraFields map[string]apijson.Field
 }
 
-func (r *McpLocal) UnmarshalJSON(data []byte) (err error) {
+func (r *McpLocalConfig) UnmarshalJSON(data []byte) (err error) {
 	return apijson.UnmarshalRoot(data, r)
 }
 
-func (r mcpLocalJSON) RawJSON() string {
+func (r mcpLocalConfigJSON) RawJSON() string {
 	return r.raw
 }
 
-func (r McpLocal) implementsConfigMcp() {}
+func (r McpLocalConfig) implementsConfigMcp() {}
 
 // Type of MCP server connection
-type McpLocalType string
+type McpLocalConfigType string
 
 const (
-	McpLocalTypeLocal McpLocalType = "local"
+	McpLocalConfigTypeLocal McpLocalConfigType = "local"
 )
 
-func (r McpLocalType) IsKnown() bool {
+func (r McpLocalConfigType) IsKnown() bool {
 	switch r {
-	case McpLocalTypeLocal:
+	case McpLocalConfigTypeLocal:
 		return true
 	}
 	return false
 }
 
-type McpRemote struct {
+type McpRemoteConfig struct {
 	// Type of MCP server connection
-	Type McpRemoteType `json:"type,required"`
+	Type McpRemoteConfigType `json:"type,required"`
 	// URL of the remote MCP server
 	URL string `json:"url,required"`
 	// Enable or disable the MCP server on startup
-	Enabled bool          `json:"enabled"`
+	Enabled bool `json:"enabled"`
-	JSON    mcpRemoteJSON `json:"-"`
+	// Headers to send with the request
+	Headers map[string]string   `json:"headers"`
+	JSON    mcpRemoteConfigJSON `json:"-"`
 }
 
-// mcpRemoteJSON contains the JSON metadata for the struct [McpRemote]
+// mcpRemoteConfigJSON contains the JSON metadata for the struct [McpRemoteConfig]
-type mcpRemoteJSON struct {
+type mcpRemoteConfigJSON struct {
 	Type        apijson.Field
 	URL         apijson.Field
 	Enabled     apijson.Field
+	Headers     apijson.Field
 	raw         string
 	ExtraFields map[string]apijson.Field
 }
 
-func (r *McpRemote) UnmarshalJSON(data []byte) (err error) {
+func (r *McpRemoteConfig) UnmarshalJSON(data []byte) (err error) {
 	return apijson.UnmarshalRoot(data, r)
 }
 
-func (r mcpRemoteJSON) RawJSON() string {
+func (r mcpRemoteConfigJSON) RawJSON() string {
 	return r.raw
 }
 
-func (r McpRemote) implementsConfigMcp() {}
+func (r McpRemoteConfig) implementsConfigMcp() {}
 
 // Type of MCP server connection
-type McpRemoteType string
+type McpRemoteConfigType string
 
 const (
-	McpRemoteTypeRemote McpRemoteType = "remote"
+	McpRemoteConfigTypeRemote McpRemoteConfigType = "remote"
 )
 
-func (r McpRemoteType) IsKnown() bool {
+func (r McpRemoteConfigType) IsKnown() bool {
 	switch r {
-	case McpRemoteTypeRemote:
+	case McpRemoteConfigTypeRemote:
 		return true
 	}
 	return false
 }
 
-type Model struct {
+type ModeConfig struct {
-	ID          string                 `json:"id,required"`
+	Model  string          `json:"model"`
-	Attachment  bool                   `json:"attachment,required"`
+	Prompt string          `json:"prompt"`
-	Cost        ModelCost              `json:"cost,required"`
+	Tools  map[string]bool `json:"tools"`
-	Limit       ModelLimit             `json:"limit,required"`
+	JSON   modeConfigJSON  `json:"-"`
-	Name        string                 `json:"name,required"`
-	Options     map[string]interface{} `json:"options,required"`
-	Reasoning   bool                   `json:"reasoning,required"`
-	ReleaseDate string                 `json:"release_date,required"`
-	Temperature bool                   `json:"temperature,required"`
-	ToolCall    bool                   `json:"tool_call,required"`
-	JSON        modelJSON              `json:"-"`
 }
 
-// modelJSON contains the JSON metadata for the struct [Model]
+// modeConfigJSON contains the JSON metadata for the struct [ModeConfig]
-type modelJSON struct {
+type modeConfigJSON struct {
-	ID          apijson.Field
+	Model       apijson.Field
-	Attachment  apijson.Field
+	Prompt      apijson.Field
-	Cost        apijson.Field
+	Tools       apijson.Field
-	Limit       apijson.Field
-	Name        apijson.Field
-	Options     apijson.Field
-	Reasoning   apijson.Field
-	ReleaseDate apijson.Field
-	Temperature apijson.Field
-	ToolCall    apijson.Field
 	raw         string
 	ExtraFields map[string]apijson.Field
 }
 
-func (r *Model) UnmarshalJSON(data []byte) (err error) {
+func (r *ModeConfig) UnmarshalJSON(data []byte) (err error) {
 	return apijson.UnmarshalRoot(data, r)
 }
 
-func (r modelJSON) RawJSON() string {
+func (r modeConfigJSON) RawJSON() string {
-	return r.raw
-}
-
-type ModelCost struct {
-	Input      float64       `json:"input,required"`
-	Output     float64       `json:"output,required"`
-	CacheRead  float64       `json:"cache_read"`
-	CacheWrite float64       `json:"cache_write"`
-	JSON       modelCostJSON `json:"-"`
-}
-
-// modelCostJSON contains the JSON metadata for the struct [ModelCost]
-type modelCostJSON struct {
-	Input       apijson.Field
-	Output      apijson.Field
-	CacheRead   apijson.Field
-	CacheWrite  apijson.Field
-	raw         string
-	ExtraFields map[string]apijson.Field
-}
-
-func (r *ModelCost) UnmarshalJSON(data []byte) (err error) {
-	return apijson.UnmarshalRoot(data, r)
-}
-
-func (r modelCostJSON) RawJSON() string {
-	return r.raw
-}
-
-type ModelLimit struct {
-	Context float64        `json:"context,required"`
-	Output  float64        `json:"output,required"`
-	JSON    modelLimitJSON `json:"-"`
-}
-
-// modelLimitJSON contains the JSON metadata for the struct [ModelLimit]
-type modelLimitJSON struct {
-	Context     apijson.Field
-	Output      apijson.Field
-	raw         string
-	ExtraFields map[string]apijson.Field
-}
-
-func (r *ModelLimit) UnmarshalJSON(data []byte) (err error) {
-	return apijson.UnmarshalRoot(data, r)
-}
-
-func (r modelLimitJSON) RawJSON() string {
-	return r.raw
-}
-
-type Provider struct {
-	ID     string           `json:"id,required"`
-	Env    []string         `json:"env,required"`
-	Models map[string]Model `json:"models,required"`
-	Name   string           `json:"name,required"`
-	API    string           `json:"api"`
-	Npm    string           `json:"npm"`
-	JSON   providerJSON     `json:"-"`
-}
-
-// providerJSON contains the JSON metadata for the struct [Provider]
-type providerJSON struct {
-	ID          apijson.Field
-	Env         apijson.Field
-	Models      apijson.Field
-	Name        apijson.Field
-	API         apijson.Field
-	Npm         apijson.Field
-	raw         string
-	ExtraFields map[string]apijson.Field
-}
-
-func (r *Provider) UnmarshalJSON(data []byte) (err error) {
-	return apijson.UnmarshalRoot(data, r)
-}
-
-func (r providerJSON) RawJSON() string {
-	return r.raw
-}
-
-type ConfigProvidersResponse struct {
-	Default   map[string]string           `json:"default,required"`
-	Providers []Provider                  `json:"providers,required"`
-	JSON      configProvidersResponseJSON `json:"-"`
-}
-
-// configProvidersResponseJSON contains the JSON metadata for the struct
-// [ConfigProvidersResponse]
-type configProvidersResponseJSON struct {
-	Default     apijson.Field
-	Providers   apijson.Field
-	raw         string
-	ExtraFields map[string]apijson.Field
-}
-
-func (r *ConfigProvidersResponse) UnmarshalJSON(data []byte) (err error) {
-	return apijson.UnmarshalRoot(data, r)
-}
-
-func (r configProvidersResponseJSON) RawJSON() string {
 	return r.raw
 }

packages/tui/sdk/config_test.go

@@ -34,25 +34,3 @@ func TestConfigGet(t *testing.T) {
 		t.Fatalf("err should be nil: %s", err.Error())
 	}
 }
-
-func TestConfigProviders(t *testing.T) {
-	t.Skip("skipped: tests are disabled for the time being")
-	baseURL := "http://localhost:4010"
-	if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
-		baseURL = envURL
-	}
-	if !testutil.CheckTestServer(t, baseURL) {
-		return
-	}
-	client := opencode.NewClient(
-		option.WithBaseURL(baseURL),
-	)
-	_, err := client.Config.Providers(context.TODO())
-	if err != nil {
-		var apierr *opencode.Error
-		if errors.As(err, &apierr) {
-			t.Log(string(apierr.DumpRequest(true)))
-		}
-		t.Fatalf("err should be nil: %s", err.Error())
-	}
-}

packages/tui/sdk/session.go

@@ -481,21 +481,33 @@ func (r FilePartType) IsKnown() bool {
 	return false
 }
 
-type FilePartParam struct {
+type FilePartInputParam struct {
-	ID        param.Field[string]       `json:"id,required"`
+	Mime     param.Field[string]            `json:"mime,required"`
-	MessageID param.Field[string]       `json:"messageID,required"`
+	Type     param.Field[FilePartInputType] `json:"type,required"`
-	Mime      param.Field[string]       `json:"mime,required"`
+	URL      param.Field[string]            `json:"url,required"`
-	SessionID param.Field[string]       `json:"sessionID,required"`
+	ID       param.Field[string]            `json:"id"`
-	Type      param.Field[FilePartType] `json:"type,required"`
+	Filename param.Field[string]            `json:"filename"`
-	URL       param.Field[string]       `json:"url,required"`
-	Filename  param.Field[string]       `json:"filename"`
 }
 
-func (r FilePartParam) MarshalJSON() (data []byte, err error) {
+func (r FilePartInputParam) MarshalJSON() (data []byte, err error) {
 	return apijson.MarshalRoot(r)
 }
 
-func (r FilePartParam) implementsSessionChatParamsPartUnion() {}
+func (r FilePartInputParam) implementsSessionChatParamsPartUnion() {}
+
+type FilePartInputType string
+
+const (
+	FilePartInputTypeFile FilePartInputType = "file"
+)
+
+func (r FilePartInputType) IsKnown() bool {
+	switch r {
+	case FilePartInputTypeFile:
+		return true
+	}
+	return false
+}
 
 type Message struct {
 	ID        string      `json:"id,required"`
@@ -659,13 +671,13 @@ func (r *Part) UnmarshalJSON(data []byte) (err error) {
 // for more type safety.
 //
 // Possible runtime types of the union are [TextPart], [FilePart], [ToolPart],
-// [StepStartPart], [StepFinishPart], [PartObject].
+// [StepStartPart], [StepFinishPart], [SnapshotPart].
 func (r Part) AsUnion() PartUnion {
 	return r.union
 }
 
 // Union satisfied by [TextPart], [FilePart], [ToolPart], [StepStartPart],
-// [StepFinishPart] or [PartObject].
+// [StepFinishPart] or [SnapshotPart].
 type PartUnion interface {
 	implementsPart()
 }
@@ -673,78 +685,40 @@ type PartUnion interface {
 func init() {
 	apijson.RegisterUnion(
 		reflect.TypeOf((*PartUnion)(nil)).Elem(),
-		"",
+		"type",
 		apijson.UnionVariant{
-			TypeFilter: gjson.JSON,
+			TypeFilter:         gjson.JSON,
-			Type:       reflect.TypeOf(TextPart{}),
+			Type:               reflect.TypeOf(TextPart{}),
+			DiscriminatorValue: "text",
 		},
 		apijson.UnionVariant{
-			TypeFilter: gjson.JSON,
+			TypeFilter:         gjson.JSON,
-			Type:       reflect.TypeOf(FilePart{}),
+			Type:               reflect.TypeOf(FilePart{}),
+			DiscriminatorValue: "file",
 		},
 		apijson.UnionVariant{
-			TypeFilter: gjson.JSON,
+			TypeFilter:         gjson.JSON,
-			Type:       reflect.TypeOf(ToolPart{}),
+			Type:               reflect.TypeOf(ToolPart{}),
+			DiscriminatorValue: "tool",
 		},
 		apijson.UnionVariant{
-			TypeFilter: gjson.JSON,
+			TypeFilter:         gjson.JSON,
-			Type:       reflect.TypeOf(StepStartPart{}),
+			Type:               reflect.TypeOf(StepStartPart{}),
+			DiscriminatorValue: "step-start",
 		},
 		apijson.UnionVariant{
-			TypeFilter: gjson.JSON,
+			TypeFilter:         gjson.JSON,
-			Type:       reflect.TypeOf(StepFinishPart{}),
+			Type:               reflect.TypeOf(StepFinishPart{}),
+			DiscriminatorValue: "step-finish",
 		},
 		apijson.UnionVariant{
-			TypeFilter: gjson.JSON,
+			TypeFilter:         gjson.JSON,
-			Type:       reflect.TypeOf(PartObject{}),
+			Type:               reflect.TypeOf(SnapshotPart{}),
+			DiscriminatorValue: "snapshot",
 		},
 	)
 }
 
-type PartObject struct {
-	ID        string         `json:"id,required"`
-	MessageID string         `json:"messageID,required"`
-	SessionID string         `json:"sessionID,required"`
-	Snapshot  string         `json:"snapshot,required"`
-	Type      PartObjectType `json:"type,required"`
-	JSON      partObjectJSON `json:"-"`
-}
-
-// partObjectJSON contains the JSON metadata for the struct [PartObject]
-type partObjectJSON struct {
-	ID          apijson.Field
-	MessageID   apijson.Field
-	SessionID   apijson.Field
-	Snapshot    apijson.Field
-	Type        apijson.Field
-	raw         string
-	ExtraFields map[string]apijson.Field
-}
-
-func (r *PartObject) UnmarshalJSON(data []byte) (err error) {
-	return apijson.UnmarshalRoot(data, r)
-}
-
-func (r partObjectJSON) RawJSON() string {
-	return r.raw
-}
-
-func (r PartObject) implementsPart() {}
-
-type PartObjectType string
-
-const (
-	PartObjectTypeSnapshot PartObjectType = "snapshot"
-)
-
-func (r PartObjectType) IsKnown() bool {
-	switch r {
-	case PartObjectTypeSnapshot:
-		return true
-	}
-	return false
-}
-
 type PartType string
 
 const (
@@ -862,6 +836,50 @@ func (r sessionShareJSON) RawJSON() string {
 	return r.raw
 }
 
+type SnapshotPart struct {
+	ID        string           `json:"id,required"`
+	MessageID string           `json:"messageID,required"`
+	SessionID string           `json:"sessionID,required"`
+	Snapshot  string           `json:"snapshot,required"`
+	Type      SnapshotPartType `json:"type,required"`
+	JSON      snapshotPartJSON `json:"-"`
+}
+
+// snapshotPartJSON contains the JSON metadata for the struct [SnapshotPart]
+type snapshotPartJSON struct {
+	ID          apijson.Field
+	MessageID   apijson.Field
+	SessionID   apijson.Field
+	Snapshot    apijson.Field
+	Type        apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *SnapshotPart) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r snapshotPartJSON) RawJSON() string {
+	return r.raw
+}
+
+func (r SnapshotPart) implementsPart() {}
+
+type SnapshotPartType string
+
+const (
+	SnapshotPartTypeSnapshot SnapshotPartType = "snapshot"
+)
+
+func (r SnapshotPartType) IsKnown() bool {
+	switch r {
+	case SnapshotPartTypeSnapshot:
+		return true
+	}
+	return false
+}
+
 type StepFinishPart struct {
 	ID        string               `json:"id,required"`
 	Cost      float64              `json:"cost,required"`
@@ -1070,28 +1088,40 @@ func (r textPartTimeJSON) RawJSON() string {
 	return r.raw
 }
 
-type TextPartParam struct {
+type TextPartInputParam struct {
-	ID        param.Field[string]            `json:"id,required"`
+	Text      param.Field[string]                 `json:"text,required"`
-	MessageID param.Field[string]            `json:"messageID,required"`
+	Type      param.Field[TextPartInputType]      `json:"type,required"`
-	SessionID param.Field[string]            `json:"sessionID,required"`
+	ID        param.Field[string]                 `json:"id"`
-	Text      param.Field[string]            `json:"text,required"`
+	Synthetic param.Field[bool]                   `json:"synthetic"`
-	Type      param.Field[TextPartType]      `json:"type,required"`
+	Time      param.Field[TextPartInputTimeParam] `json:"time"`
-	Synthetic param.Field[bool]              `json:"synthetic"`
-	Time      param.Field[TextPartTimeParam] `json:"time"`
 }
 
-func (r TextPartParam) MarshalJSON() (data []byte, err error) {
+func (r TextPartInputParam) MarshalJSON() (data []byte, err error) {
 	return apijson.MarshalRoot(r)
 }
 
-func (r TextPartParam) implementsSessionChatParamsPartUnion() {}
+func (r TextPartInputParam) implementsSessionChatParamsPartUnion() {}
 
-type TextPartTimeParam struct {
+type TextPartInputType string
+
+const (
+	TextPartInputTypeText TextPartInputType = "text"
+)
+
+func (r TextPartInputType) IsKnown() bool {
+	switch r {
+	case TextPartInputTypeText:
+		return true
+	}
+	return false
+}
+
+type TextPartInputTimeParam struct {
 	Start param.Field[float64] `json:"start,required"`
 	End   param.Field[float64] `json:"end"`
 }
 
-func (r TextPartTimeParam) MarshalJSON() (data []byte, err error) {
+func (r TextPartInputTimeParam) MarshalJSON() (data []byte, err error) {
 	return apijson.MarshalRoot(r)
 }
 
@@ -1568,11 +1598,11 @@ func (r sessionMessagesResponseJSON) RawJSON() string {
 }
 
 type SessionChatParams struct {
-	MessageID  param.Field[string]                       `json:"messageID,required"`
-	Mode       param.Field[string]                       `json:"mode,required"`
 	ModelID    param.Field[string]                       `json:"modelID,required"`
 	Parts      param.Field[[]SessionChatParamsPartUnion] `json:"parts,required"`
 	ProviderID param.Field[string]                       `json:"providerID,required"`
+	MessageID  param.Field[string]                       `json:"messageID"`
+	Mode       param.Field[string]                       `json:"mode"`
 }
 
 func (r SessionChatParams) MarshalJSON() (data []byte, err error) {
@@ -1580,10 +1610,8 @@ func (r SessionChatParams) MarshalJSON() (data []byte, err error) {
 }
 
 type SessionChatParamsPart struct {
-	ID        param.Field[string]                     `json:"id,required"`
-	MessageID param.Field[string]                     `json:"messageID,required"`
-	SessionID param.Field[string]                     `json:"sessionID,required"`
 	Type      param.Field[SessionChatParamsPartsType] `json:"type,required"`
+	ID        param.Field[string]                     `json:"id"`
 	Filename  param.Field[string]                     `json:"filename"`
 	Mime      param.Field[string]                     `json:"mime"`
 	Synthetic param.Field[bool]                       `json:"synthetic"`
@@ -1598,7 +1626,8 @@ func (r SessionChatParamsPart) MarshalJSON() (data []byte, err error) {
 
 func (r SessionChatParamsPart) implementsSessionChatParamsPartUnion() {}
 
-// Satisfied by [FilePartParam], [TextPartParam], [SessionChatParamsPart].
+// Satisfied by [TextPartInputParam], [FilePartInputParam],
+// [SessionChatParamsPart].
 type SessionChatParamsPartUnion interface {
 	implementsSessionChatParamsPartUnion()
 }
@@ -1606,13 +1635,13 @@ type SessionChatParamsPartUnion interface {
 type SessionChatParamsPartsType string
 
 const (
-	SessionChatParamsPartsTypeFile SessionChatParamsPartsType = "file"
 	SessionChatParamsPartsTypeText SessionChatParamsPartsType = "text"
+	SessionChatParamsPartsTypeFile SessionChatParamsPartsType = "file"
 )
 
 func (r SessionChatParamsPartsType) IsKnown() bool {
 	switch r {
-	case SessionChatParamsPartsTypeFile, SessionChatParamsPartsTypeText:
+	case SessionChatParamsPartsTypeText, SessionChatParamsPartsTypeFile:
 		return true
 	}
 	return false

packages/tui/sdk/session_test.go

@@ -101,7 +101,7 @@ func TestSessionAbort(t *testing.T) {
 	}
 }
 
-func TestSessionChat(t *testing.T) {
+func TestSessionChatWithOptionalParams(t *testing.T) {
 	t.Skip("skipped: tests are disabled for the time being")
 	baseURL := "http://localhost:4010"
 	if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
@@ -117,19 +117,20 @@ func TestSessionChat(t *testing.T) {
 		context.TODO(),
 		"id",
 		opencode.SessionChatParams{
-			MessageID: opencode.F("messageID"),
+			ModelID: opencode.F("modelID"),
-			Mode:      opencode.F("mode"),
+			Parts: opencode.F([]opencode.SessionChatParamsPartUnion{opencode.TextPartInputParam{
-			ModelID:   opencode.F("modelID"),
+				Text:      opencode.F("text"),
-			Parts: opencode.F([]opencode.SessionChatParamsPartUnion{opencode.FilePartParam{
+				Type:      opencode.F(opencode.TextPartInputTypeText),
 				ID:        opencode.F("id"),
-				MessageID: opencode.F("messageID"),
+				Synthetic: opencode.F(true),
-				Mime:      opencode.F("mime"),
+				Time: opencode.F(opencode.TextPartInputTimeParam{
-				SessionID: opencode.F("sessionID"),
+					Start: opencode.F(0.000000),
-				Type:      opencode.F(opencode.FilePartTypeFile),
+					End:   opencode.F(0.000000),
-				URL:       opencode.F("url"),
+				}),
-				Filename:  opencode.F("filename"),
 			}}),
 			ProviderID: opencode.F("providerID"),
+			MessageID:  opencode.F("msg"),
+			Mode:       opencode.F("mode"),
 		},
 	)
 	if err != nil {

packages/tui/sdk/usage_test.go

@@ -23,13 +23,10 @@ func TestUsage(t *testing.T) {
 	client := opencode.NewClient(
 		option.WithBaseURL(baseURL),
 	)
-	stream := client.Event.ListStreaming(context.TODO())
+	sessions, err := client.Session.List(context.TODO())
-	for stream.Next() {
-		t.Logf("%+v\n", stream.Current())
-	}
-	err := stream.Err()
 	if err != nil {
 		t.Error(err)
 		return
 	}
+	t.Logf("%+v\n", sessions)
 }

packages/web/astro.config.mjs

@@ -33,6 +33,7 @@ export default defineConfig({
     solidJs(),
     starlight({
       title: "opencode",
+      lastUpdated: true,
       expressiveCode: { themes: ["github-light", "github-dark"] },
       social: [
         { icon: "github", label: "GitHub", href: config.github },

packages/web/package.json

@@ -27,6 +27,7 @@
     "marked": "15.0.12",
     "marked-shiki": "1.2.0",
     "rehype-autolink-headings": "7.1.0",
+    "remeda": "2.26.0",
     "sharp": "0.32.5",
     "shiki": "3.4.2",
     "solid-js": "1.9.7",

packages/web/src/components/Share.tsx

@@ -1,6 +1,7 @@
 import { For, Show, onMount, Suspense, onCleanup, createMemo, createSignal, SuspenseList, createEffect } from "solid-js"
 import { DateTime } from "luxon"
 import { createStore, reconcile, unwrap } from "solid-js/store"
+import { mapValues } from "remeda"
 import { IconArrowDown } from "./icons"
 import { IconOpencode } from "./icons/custom"
 import styles from "./share.module.css"
@@ -60,7 +61,7 @@ export default function Share(props: {
   const [store, setStore] = createStore<{
     info?: Session.Info
     messages: Record<string, MessageWithParts>
-  }>({ info: props.info, messages: props.messages })
+  }>({ info: props.info, messages: mapValues(props.messages, (x: any) => "metadata" in x ? fromV1(x) : x) })
   const messages = createMemo(() => Object.values(store.messages).toSorted((a, b) => a.id?.localeCompare(b.id)))
   const [connectionStatus, setConnectionStatus] = createSignal<[Status, string?]>(["disconnected", "Disconnected"])
   createEffect(() => {
@@ -340,6 +341,7 @@ export default function Share(props: {
                   const filteredParts = createMemo(() =>
                     msg.parts.filter((x, index) => {
                       if (x.type === "step-start" && index > 0) return false
+                      if (x.type === "snapshot") return false
                       if (x.type === "step-finish") return false
                       if (x.type === "text" && x.synthetic === true) return false
                       if (x.type === "tool" && x.tool === "todoread") return false

packages/web/src/components/icons/custom.tsx

@@ -58,3 +58,11 @@ export function IconMeta(props: JSX.SvgSVGAttributes<SVGSVGElement>) {
     </svg>
   )
 }
+
+// https://icones.js.org/collection/ri?s=robot&icon=ri:robot-2-line
+export function IconRobot(props: JSX.SvgSVGAttributes<SVGSVGElement>) {
+  return (
+    <svg {...props} xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+      <path fill="currentColor" d="M13.5 2c0 .444-.193.843-.5 1.118V5h5a3 3 0 0 1 3 3v10a3 3 0 0 1-3 3H6a3 3 0 0 1-3-3V8a3 3 0 0 1 3-3h5V3.118A1.5 1.5 0 1 1 13.5 2M6 7a1 1 0 0 0-1 1v10a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1V8a1 1 0 0 0-1-1zm-4 3H0v6h2zm20 0h2v6h-2zM9 14.5a1.5 1.5 0 1 0 0-3a1.5 1.5 0 0 0 0 3m6 0a1.5 1.5 0 1 0 0-3a1.5 1.5 0 0 0 0 3" /></svg>
+  )
+}

packages/web/src/components/share/content-code.tsx

@@ -1,4 +1,4 @@
-import { codeToHtml } from "shiki"
+import { codeToHtml, bundledLanguages } from "shiki"
 import { createResource, Suspense } from "solid-js"
 import { transformerNotationDiff } from "@shikijs/transformers"
 import style from "./content-code.module.css"
@@ -15,7 +15,7 @@ export function ContentCode(props: Props) {
       // TODO: For testing delays
       // await new Promise((resolve) => setTimeout(resolve, 3000))
       return (await codeToHtml(code || "", {
-        lang: lang || "text",
+        lang: lang && lang in bundledLanguages ? lang : "text",
         themes: {
           light: "github-light",
           dark: "github-dark",

packages/web/src/components/share/content-diff.module.css

@@ -23,6 +23,20 @@
     grid-template-columns: 1fr 1fr;
     align-items: stretch;
 
+    &:first-child {
+      [data-slot="before"],
+      [data-slot="after"] {
+        padding-top: 0.25rem;
+      }
+    }
+
+    &:last-child {
+      [data-slot="before"],
+      [data-slot="after"] {
+        padding-bottom: 0.25rem;
+      }
+    }
+
     [data-slot="before"],
     [data-slot="after"] {
       position: relative;
@@ -75,46 +89,16 @@
     }
   }
 
-  /* .diff > .row:first-child [data-section="cell"]:first-child { */
-  /*   padding-top: 0.5rem; */
-  /* } */
-  /**/
-  /* .diff > .row:last-child [data-section="cell"]:last-child { */
-  /*   padding-bottom: 0.5rem; */
-  /* } */
-  /**/
-  /* [data-section="cell"] { */
-  /*   position: relative; */
-  /*   flex: 1; */
-  /*   display: flex; */
-  /*   flex-direction: column; */
-  /**/
-  /*   width: 100%; */
-  /*   padding: 0.1875rem 0.5rem 0.1875rem 2.2ch; */
-  /*   margin: 0; */
-  /**/
-  /*   &[data-display-mobile="true"] { */
-  /*     display: none; */
-  /*   } */
-  /**/
-  /*   pre { */
-  /*     --shiki-dark-bg: var(--sl-color-bg-surface) !important; */
-  /*     background-color: var(--sl-color-bg-surface) !important; */
-  /**/
-  /*     white-space: pre-wrap; */
-  /*     word-break: break-word; */
-  /**/
-  /*     code > span:empty::before { */
-  /*       content: "\00a0"; */
-  /*       white-space: pre; */
-  /*       display: inline-block; */
-  /*       width: 0; */
-  /*     } */
-  /*   } */
-  /* } */
-
   [data-component="mobile"] {
 
+    & > [data-component="diff-block"]:first-child > div {
+      padding-top: 0.25rem;
+    }
+
+    & > [data-component="diff-block"]:last-child > div {
+      padding-bottom: 0.25rem;
+    }
+
     & > [data-component="diff-block"] > div {
       padding: 0 1rem 0 2.2ch;
 

packages/web/src/components/share/content-diff.tsx

@@ -1,5 +1,5 @@
-import { type Component, createMemo } from "solid-js"
 import { parsePatch } from "diff"
+import { createMemo } from "solid-js"
 import { ContentCode } from "./content-code"
 import styles from "./content-diff.module.css"
 
@@ -90,8 +90,8 @@ export function ContentDiff(props: Props) {
               i++
             } else if (prefix === " ") {
               diffRows.push({
-                left: content,
+                left: content === "" ? " " : content,
-                right: content,
+                right: content === "" ? " " : content,
                 type: "unchanged",
               })
               i++