better amazon bedrock caching with anthropic models

Update STATS.md
Update download stats 2025-06-29
2025-06-29 19:27:07 -04:00 · 2025-06-29 13:04:44 -04:00 · 2025-06-29 12:23:40 +00:00 · 2025-06-29 02:00:18 +00:00 · 2025-06-28 21:59:14 -04:00 · 2025-06-28 21:57:46 -04:00
170 changed files with 10759 additions and 8885 deletions
@@ -17,7 +17,7 @@ jobs:

      - uses: oven-sh/setup-bun@v1
        with:
-          bun-version: latest
+          bun-version: 1.2.17

      - run: bun install

@@ -32,7 +32,7 @@ jobs:

      - uses: oven-sh/setup-bun@v2
        with:
-          bun-version: 1.2.16
+          bun-version: 1.2.17

      - name: Install makepkg
        run: |
@@ -0,0 +1,32 @@
+name: stats
+
+on:
+  schedule:
+    - cron: "0 12 * * *" # Run daily at 12:00 UTC
+  workflow_dispatch: # Allow manual trigger
+
+jobs:
+  stats:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Run stats script
+        run: bun scripts/stats.ts
+
+      - name: Commit stats
+        run: |
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
+          git add STATS.md
+          git diff --staged --quiet || git commit -m "Update download stats $(date -I)"
+          git push
@@ -1,6 +1,6 @@
 MIT License

-Copyright (c) 2025 OpenCode
+Copyright (c) 2025 opencode

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -1,9 +1,9 @@
 <p align="center">
  <a href="https://opencode.ai">
    <picture>
-      <source srcset="packages/web/src/assets/logo-dark.svg" media="(prefers-color-scheme: dark)">
-      <source srcset="packages/web/src/assets/logo-light.svg" media="(prefers-color-scheme: light)">
-      <img src="packages/web/src/assets/logo-light.svg" alt="opencode logo">
+      <source srcset="packages/web/src/assets/logo-ornate-dark.svg" media="(prefers-color-scheme: dark)">
+      <source srcset="packages/web/src/assets/logo-ornate-light.svg" media="(prefers-color-scheme: light)">
+      <img src="packages/web/src/assets/logo-ornate-light.svg" alt="opencode logo">
    </picture>
  </a>
 </p>
@@ -14,7 +14,7 @@
  <a href="https://github.com/sst/opencode/actions/workflows/publish.yml"><img alt="Build status" src="https://img.shields.io/github/actions/workflow/status/sst/opencode/publish.yml?style=flat-square&branch=dev" /></a>
 </p>

-[![opencode Terminal UI](packages/web/src/assets/themes/opencode.png)](https://opencode.ai)
+[![opencode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

 ---

@@ -38,6 +38,8 @@ For more info on how to configure opencode [**head over to our docs**](https://o

 ### Contributing

+For any new features we'd appreciate it if you could open an issue first to discuss what you'd like to implement. We're pretty responsive there and it'll save you from working on something that we don't end up using. No need to do this for simpler fixes.
+
 To run opencode locally you need.

 - Bun
@@ -50,32 +52,12 @@ $ bun install
 $ bun run packages/opencode/src/index.ts
 ```

+#### Development Notes
+
+**API Client**: After making changes to the TypeScript API endpoints in `packages/opencode/src/server/server.ts`, you will need the opencode team to generate a new stainless sdk for the clients.
+
 ### FAQ

-#### How do I use this with OpenRouter?
-
-OpenRouter is not in the Models.dev database yet, but you can configure it manually.
-
-```json title="opencode.json"
-{
-  "$schema": "https://opencode.ai/config.json",
-  "provider": {
-    "openrouter": {
-      "npm": "@openrouter/ai-sdk-provider",
-      "name": "OpenRouter",
-      "options": {},
-      "models": {
-        "anthropic/claude-3.5-sonnet": {
-          "name": "Claude 3.5 Sonnet"
-        }
-      }
-    }
-  }
-}
-```
-
-And then to configure an api key you can do `opencode auth login` and select "Other -> 'openrouter'"
-
 #### How is this different than Claude Code?

 It's very similar to Claude Code in terms of capability. Here are the key differences:
@@ -0,0 +1,5 @@
+# Download Stats
+
+| Date       | GitHub Downloads | npm Downloads    | Total            |
+| ---------- | ---------------- | ---------------- | ---------------- |
+| 2025-06-29 | 18,789 (+0)      | 39,420 (+0)      | 58,209 (+0)      |
@@ -19,7 +19,10 @@
    },
    "packages/opencode": {
      "name": "opencode",
-      "version": "0.0.0",
+      "version": "0.0.5",
+      "bin": {
+        "opencode": "./bin/opencode",
+      },
      "dependencies": {
        "@clack/prompts": "0.11.0",
        "@flystorage/file-storage": "1.1.0",
@@ -71,6 +74,7 @@
        "astro": "5.7.13",
        "diff": "8.0.2",
        "js-base64": "3.7.7",
+        "lang-map": "0.4.0",
        "luxon": "3.6.1",
        "marked": "15.0.12",
        "rehype-autolink-headings": "7.1.0",
@@ -457,7 +461,7 @@

    "@types/babel__traverse": ["@types/babel__traverse@7.20.7", "", { "dependencies": { "@babel/types": "^7.20.7" } }, "sha512-dkO5fhS7+/oos4ciWxyEyjWe48zmG6wbCheo/G2ZnHx4fs3EU6YC6UM8rk56gAjNJ9P3MTH2jo5jb92/K6wbng=="],

-    "@types/bun": ["@types/bun@1.2.16", "", { "dependencies": { "bun-types": "1.2.16" } }, "sha512-1aCZJ/6nSiViw339RsaNhkNoEloLaPzZhxMOYEa7OzRzO41IGg5n/7I43/ZIAW/c+Q6cT12Vf7fOZOoVIzb5BQ=="],
+    "@types/bun": ["@types/bun@1.2.17", "", { "dependencies": { "bun-types": "1.2.17" } }, "sha512-l/BYs/JYt+cXA/0+wUhulYJB6a6p//GTPiJ7nV+QHa8iiId4HZmnu/3J/SowP5g0rTiERY2kfGKXEK5Ehltx4Q=="],

    "@types/debug": ["@types/debug@4.1.12", "", { "dependencies": { "@types/ms": "*" } }, "sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ=="],

@@ -595,7 +599,7 @@

    "buffer": ["buffer@4.9.2", "", { "dependencies": { "base64-js": "^1.0.2", "ieee754": "^1.1.4", "isarray": "^1.0.0" } }, "sha512-xq+q3SRMOxGivLhBNaUdC64hDTQwejJ+H0T/NB1XMtTVEwNTrfFF3gAxiyW0Bu/xWEGhjVKgUcMhCrUy2+uCWg=="],

-    "bun-types": ["bun-types@1.2.16", "", { "dependencies": { "@types/node": "*" } }, "sha512-ciXLrHV4PXax9vHvUrkvun9VPVGOVwbbbBF/Ev1cXz12lyEZMoJpIJABOfPcN9gDJRaiKF9MVbSygLg4NXu3/A=="],
+    "bun-types": ["bun-types@1.2.17", "", { "dependencies": { "@types/node": "*" } }, "sha512-ElC7ItwT3SCQwYZDYoAH+q6KT4Fxjl8DtZ6qDulUFBmXA8YB4xo+l54J9ZJN+k2pphfn9vk7kfubeSd5QfTVJQ=="],

    "bundle-name": ["bundle-name@4.1.0", "", { "dependencies": { "run-applescript": "^7.0.0" } }, "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q=="],

@@ -1011,6 +1015,10 @@

    "klona": ["klona@2.0.6", "", {}, "sha512-dhG34DXATL5hSxJbIexCft8FChFXtmskoZYnoPWjXQuebWYCNkVeV3KkGegCK9CP1oswI/vQibS2GY7Em/sJJA=="],

+    "lang-map": ["lang-map@0.4.0", "", { "dependencies": { "language-map": "^1.1.0" } }, "sha512-oiSqZIEUnWdFeDNsp4HId4tAxdFbx5iMBOwA3666Fn2L8Khj8NiD9xRvMsGmKXopPVkaDFtSv3CJOmXFUB0Hcg=="],
+
+    "language-map": ["language-map@1.5.0", "", {}, "sha512-n7gFZpe+DwEAX9cXVTw43i3wiudWDDtSn28RmdnS/HCPr284dQI/SztsamWanRr75oSlKSaGbV2nmWCTzGCoVg=="],
+
    "leven": ["leven@2.1.0", "", {}, "sha512-nvVPLpIHUxCUoRLrFqTgSxXJ614d8AgQoWl7zPe/2VadE8+1dpU3LBhowRuBAcuwruWtOdD8oYC9jDNJjXDPyA=="],

    "longest-streak": ["longest-streak@3.1.0", "", {}, "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g=="],
@@ -1,3 +1,19 @@
 {
-  "$schema": "https://opencode.ai/config.json"
+  "$schema": "https://opencode.ai/config.json",
+  "experimental": {
+    "hook": {
+      "file_edited": {
+        ".json": [
+          {
+            "command": ["bun", "run", "prettier", "$FILE"]
+          }
+        ]
+      },
+      "session_completed": [
+        {
+          "command": ["touch", "./node_modules/foo"]
+        }
+      ]
+    }
+  }
 }
@@ -6,20 +6,20 @@
 import "sst"
 declare module "sst" {
  export interface Resource {
-    "Web": {
-      "type": "sst.cloudflare.Astro"
-      "url": string
+    Web: {
+      type: "sst.cloudflare.Astro"
+      url: string
    }
  }
 }
-// cloudflare 
-import * as cloudflare from "@cloudflare/workers-types";
+// cloudflare
+import * as cloudflare from "@cloudflare/workers-types"
 declare module "sst" {
  export interface Resource {
-    "Api": cloudflare.Service
-    "Bucket": cloudflare.R2Bucket
+    Api: cloudflare.Service
+    Bucket: cloudflare.R2Bucket
  }
 }

 import "sst"
-export {}
+export {}
@@ -37,3 +37,4 @@
 - **Validation**: All inputs validated with Zod schemas
 - **Logging**: Use `Log.create({ service: "name" })` pattern
 - **Storage**: Use `Storage` namespace for persistence
+- **API Client**: Go TUI communicates with TypeScript server via stainless SDK. When adding/modifying server endpoints in `packages/opencode/src/server/server.ts`, ask the user to generate a new client SDK to proceed with client-side changes.
@@ -0,0 +1,56 @@
+@echo off
+setlocal enabledelayedexpansion
+
+if defined OPENCODE_BIN_PATH (
+    set "resolved=%OPENCODE_BIN_PATH%"
+    goto :execute
+)
+
+rem Get the directory of this script
+set "script_dir=%~dp0"
+set "script_dir=%script_dir:~0,-1%"
+
+rem Detect platform and architecture
+set "platform=win32"
+
+rem Detect architecture
+if "%PROCESSOR_ARCHITECTURE%"=="AMD64" (
+    set "arch=x64"
+) else if "%PROCESSOR_ARCHITECTURE%"=="ARM64" (
+    set "arch=arm64"
+) else if "%PROCESSOR_ARCHITECTURE%"=="x86" (
+    set "arch=x86"
+) else (
+    set "arch=x64"
+)
+
+set "name=opencode-!platform!-!arch!"
+set "binary=opencode.exe"
+
+rem Search for the binary starting from script location
+set "resolved="
+set "current_dir=%script_dir%"
+
+:search_loop
+set "candidate=%current_dir%\node_modules\%name%\bin\%binary%"
+if exist "%candidate%" (
+    set "resolved=%candidate%"
+    goto :execute
+)
+
+rem Move up one directory
+for %%i in ("%current_dir%") do set "parent_dir=%%~dpi"
+set "parent_dir=%parent_dir:~0,-1%"
+
+rem Check if we've reached the root
+if "%current_dir%"=="%parent_dir%" goto :not_found
+set "current_dir=%parent_dir%"
+goto :search_loop
+
+:not_found
+echo It seems that your package manager failed to install the right version of the OpenCode CLI for your platform. You can try manually installing the "%name%" package >&2
+exit /b 1
+
+:execute
+rem Execute the binary with all arguments
+"%resolved%" %*
@@ -183,6 +183,9 @@
                "temperature": {
                  "type": "boolean"
                },
+                "tool_call": {
+                  "type": "boolean"
+                },
                "cost": {
                  "type": "object",
                  "properties": {
@@ -199,10 +202,7 @@
                      "type": "number"
                    }
                  },
-                  "required": [
-                    "input",
-                    "output"
-                  ],
+                  "required": ["input", "output"],
                  "additionalProperties": false
                },
                "limit": {
@@ -215,14 +215,15 @@
                      "type": "number"
                    }
                  },
-                  "required": [
-                    "context",
-                    "output"
-                  ],
+                  "required": ["context", "output"],
                  "additionalProperties": false
                },
                "id": {
                  "type": "string"
+                },
+                "options": {
+                  "type": "object",
+                  "additionalProperties": {}
                }
              },
              "additionalProperties": false
@@ -233,9 +234,7 @@
            "additionalProperties": {}
          }
        },
-        "required": [
-          "models"
-        ],
+        "required": ["models"],
        "additionalProperties": false
      },
      "description": "Custom provider configurations and model overrides"
@@ -265,12 +264,13 @@
                  "type": "string"
                },
                "description": "Environment variables to set when running the MCP server"
+              },
+              "enabled": {
+                "type": "boolean",
+                "description": "Enable or disable the MCP server on startup"
              }
            },
-            "required": [
-              "type",
-              "command"
-            ],
+            "required": ["type", "command"],
            "additionalProperties": false
          },
          {
@@ -284,19 +284,79 @@
              "url": {
                "type": "string",
                "description": "URL of the remote MCP server"
+              },
+              "enabled": {
+                "type": "boolean",
+                "description": "Enable or disable the MCP server on startup"
              }
            },
-            "required": [
-              "type",
-              "url"
-            ],
+            "required": ["type", "url"],
            "additionalProperties": false
          }
        ]
      },
      "description": "MCP (Model Context Protocol) server configurations"
+    },
+    "experimental": {
+      "type": "object",
+      "properties": {
+        "hook": {
+          "type": "object",
+          "properties": {
+            "file_edited": {
+              "type": "object",
+              "additionalProperties": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "properties": {
+                    "command": {
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      }
+                    },
+                    "environment": {
+                      "type": "object",
+                      "additionalProperties": {
+                        "type": "string"
+                      }
+                    }
+                  },
+                  "required": ["command"],
+                  "additionalProperties": false
+                }
+              }
+            },
+            "session_completed": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "command": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  },
+                  "environment": {
+                    "type": "object",
+                    "additionalProperties": {
+                      "type": "string"
+                    }
+                  }
+                },
+                "required": ["command"],
+                "additionalProperties": false
+              }
+            }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
-}
+}
@@ -1,6 +1,6 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0",
+  "version": "0.0.5",
  "name": "opencode",
  "type": "module",
  "private": true,
@@ -8,6 +8,9 @@
    "typecheck": "tsc --noEmit",
    "dev": "bun run ./src/index.ts"
  },
+  "bin": {
+    "opencode": "./bin/opencode"
+  },
  "exports": {
    "./*": "./src/*.ts"
  },
@@ -29,7 +29,7 @@ const targets = [
  ["linux", "x64"],
  ["darwin", "x64"],
  ["darwin", "arm64"],
-  // ["windows", "x64"],
+  ["windows", "x64"],
 ]

 await $`rm -rf dist`
@@ -142,7 +142,7 @@ if (!snapshot) {
    "# Maintainer: dax",
    "# Maintainer: adam",
    "",
-    "pkgname='opencode-bin'",
+    "pkgname='${pkg}'",
    `pkgver=${version.split("-")[0]}`,
    "options=('!debug' '!strip')",
    "pkgrel=1",
@@ -166,14 +166,17 @@ if (!snapshot) {
    "",
  ].join("\n")

-  await $`rm -rf ./dist/aur-opencode-bin`
-
-  await $`git clone ssh://aur@aur.archlinux.org/opencode-bin.git ./dist/aur-opencode-bin`
-  await Bun.file("./dist/aur-opencode-bin/PKGBUILD").write(pkgbuild)
-  await $`cd ./dist/aur-opencode-bin && makepkg --printsrcinfo > .SRCINFO`
-  await $`cd ./dist/aur-opencode-bin && git add PKGBUILD .SRCINFO`
-  await $`cd ./dist/aur-opencode-bin && git commit -m "Update to v${version}"`
-  if (!dry) await $`cd ./dist/aur-opencode-bin && git push`
+  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 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`
+    await $`cd ./dist/aur-${pkg} && git commit -m "Update to v${version}"`
+    if (!dry) await $`cd ./dist/aur-${pkg} && git push`
+  }

  // Homebrew formula
  const homebrewFormula = [
@@ -1,3 +1,4 @@
+import "zod-openapi/extend"
 import { Log } from "../util/log"
 import { Context } from "../util/context"
 import { Filesystem } from "../util/filesystem"
@@ -12,6 +13,7 @@ export namespace App {
  export const Info = z
    .object({
      user: z.string(),
+      hostname: z.string(),
      git: z.boolean(),
      path: z.object({
        config: z.string(),
@@ -25,15 +27,25 @@ export namespace App {
      }),
    })
    .openapi({
-      ref: "App.Info",
+      ref: "App",
    })
  export type Info = z.infer<typeof Info>

-  const ctx = Context.create<Awaited<ReturnType<typeof create>>>("app")
+  const ctx = Context.create<{
+    info: Info
+    services: Map<any, { state: any; shutdown?: (input: any) => Promise<void> }>
+  }>("app")

  const APP_JSON = "app.json"

-  async function create(input: { cwd: string }) {
+  export type Input = {
+    cwd: string
+  }
+
+  export async function provide<T>(
+    input: Input,
+    cb: (app: App.Info) => Promise<T>,
+  ) {
    log.info("creating", {
      cwd: input.cwd,
    })
@@ -45,7 +57,7 @@ export namespace App {
    const data = path.join(
      Global.Path.data,
      "project",
-      git ? git.split(path.sep).join("-") : "global",
+      git ? directory(git) : "global",
    )
    const stateFile = Bun.file(path.join(data, APP_JSON))
    const state = (await stateFile.json().catch(() => ({}))) as {
@@ -61,8 +73,11 @@ export namespace App {
      }
    >()

+    const root = git ?? input.cwd
+
    const info: Info = {
      user: os.userInfo().username,
+      hostname: os.hostname(),
      time: {
        initialized: state.initialized,
      },
@@ -71,16 +86,24 @@ export namespace App {
        config: Global.Path.config,
        state: Global.Path.state,
        data,
-        root: git ?? input.cwd,
+        root,
        cwd: input.cwd,
      },
    }
-    const result = {
+    const app = {
      services,
      info,
    }

-    return result
+    return ctx.provide(app, async () => {
+      const result = await cb(app.info)
+      for (const [key, entry] of app.services.entries()) {
+        if (!entry.shutdown) continue
+        log.info("shutdown", { name: key })
+        await entry.shutdown?.(await entry.state)
+      }
+      return result
+    })
  }

  export function state<State>(
@@ -106,22 +129,6 @@ export namespace App {
    return ctx.use().info
  }

-  export async function provide<T>(
-    input: { cwd: string },
-    cb: (app: Info) => Promise<T>,
-  ) {
-    const app = await create(input)
-    return ctx.provide(app, async () => {
-      const result = await cb(app.info)
-      for (const [key, entry] of app.services.entries()) {
-        if (!entry.shutdown) continue
-        log.info("shutdown", { name: key })
-        await entry.shutdown?.(await entry.state)
-      }
-      return result
-    })
-  }
-
  export async function initialize() {
    const { info } = ctx.use()
    info.time.initialized = Date.now()
@@ -132,4 +139,12 @@ export namespace App {
      }),
    )
  }
+
+  function directory(input: string): string {
+    return input
+      .split(path.sep)
+      .filter(Boolean)
+      .join("-")
+      .replace(/[^A-Za-z0-9_]/g, "-")
+  }
 }
@@ -0,0 +1,20 @@
+import { Global } from "../global"
+import { lazy } from "../util/lazy"
+import path from "path"
+
+export const AuthCopilot = lazy(async () => {
+  const file = Bun.file(path.join(Global.Path.state, "plugin", "copilot.ts"))
+  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()) {
+    const worked = await response
+    if (!worked) return
+  }
+  const result = await import(file.name!).catch(() => {})
+  if (!result) return
+  return result.AuthCopilot
+})
@@ -0,0 +1,150 @@
+import { z } from "zod"
+import { Auth } from "./index"
+import { NamedError } from "../util/error"
+
+export namespace AuthGithubCopilot {
+  const CLIENT_ID = "Iv1.b507a08c87ecfe98"
+  const DEVICE_CODE_URL = "https://github.com/login/device/code"
+  const ACCESS_TOKEN_URL = "https://github.com/login/oauth/access_token"
+  const COPILOT_API_KEY_URL = "https://api.github.com/copilot_internal/v2/token"
+
+  interface DeviceCodeResponse {
+    device_code: string
+    user_code: string
+    verification_uri: string
+    expires_in: number
+    interval: number
+  }
+
+  interface AccessTokenResponse {
+    access_token?: string
+    error?: string
+    error_description?: string
+  }
+
+  interface CopilotTokenResponse {
+    token: string
+    expires_at: number
+    refresh_in: number
+    endpoints: {
+      api: string
+    }
+  }
+
+  export async function authorize() {
+    const deviceResponse = await fetch(DEVICE_CODE_URL, {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "User-Agent": "GitHubCopilotChat/0.26.7",
+      },
+      body: JSON.stringify({
+        client_id: CLIENT_ID,
+        scope: "read:user",
+      }),
+    })
+    const deviceData: DeviceCodeResponse = await deviceResponse.json()
+    return {
+      device: deviceData.device_code,
+      user: deviceData.user_code,
+      verification: deviceData.verification_uri,
+      interval: deviceData.interval || 5,
+      expiry: deviceData.expires_in,
+    }
+  }
+
+  export async function poll(device_code: string) {
+    const response = await fetch(ACCESS_TOKEN_URL, {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "User-Agent": "GitHubCopilotChat/0.26.7",
+      },
+      body: JSON.stringify({
+        client_id: CLIENT_ID,
+        device_code,
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      }),
+    })
+
+    if (!response.ok) return "failed"
+
+    const data: AccessTokenResponse = await response.json()
+
+    if (data.access_token) {
+      // Store the GitHub OAuth token
+      await Auth.set("github-copilot", {
+        type: "oauth",
+        refresh: data.access_token,
+        access: "",
+        expires: 0,
+      })
+      return "complete"
+    }
+
+    if (data.error === "authorization_pending") return "pending"
+
+    if (data.error) return "failed"
+
+    return "pending"
+  }
+
+  export async function access() {
+    const info = await Auth.get("github-copilot")
+    if (!info || info.type !== "oauth") return
+    if (info.access && info.expires > Date.now()) return info.access
+
+    // Get new Copilot API token
+    const response = await fetch(COPILOT_API_KEY_URL, {
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${info.refresh}`,
+        "User-Agent": "GitHubCopilotChat/0.26.7",
+        "Editor-Version": "vscode/1.99.3",
+        "Editor-Plugin-Version": "copilot-chat/0.26.7",
+      },
+    })
+
+    if (!response.ok) return
+
+    const tokenData: CopilotTokenResponse = await response.json()
+
+    // Store the Copilot API token
+    await Auth.set("github-copilot", {
+      type: "oauth",
+      refresh: info.refresh,
+      access: tokenData.token,
+      expires: tokenData.expires_at * 1000,
+    })
+
+    return tokenData.token
+  }
+
+  export const DeviceCodeError = NamedError.create(
+    "DeviceCodeError",
+    z.object({}),
+  )
+
+  export const TokenExchangeError = NamedError.create(
+    "TokenExchangeError",
+    z.object({
+      message: z.string(),
+    }),
+  )
+
+  export const AuthenticationError = NamedError.create(
+    "AuthenticationError",
+    z.object({
+      message: z.string(),
+    }),
+  )
+
+  export const CopilotTokenError = NamedError.create(
+    "CopilotTokenError",
+    z.object({
+      message: z.string(),
+    }),
+  )
+}
@@ -3,6 +3,7 @@ import { Global } from "../global"
 import { Log } from "../util/log"
 import path from "path"
 import { NamedError } from "../util/error"
+import { readableStreamToText } from "bun"

 export namespace BunProc {
  const log = Log.create({ service: "bun" })
@@ -13,7 +14,7 @@ export namespace BunProc {
  ) {
    log.info("running", {
      cmd: [which(), ...cmd],
-      options,
+      ...options,
    })
    const result = Bun.spawn([which(), ...cmd], {
      ...options,
@@ -25,7 +26,14 @@ export namespace BunProc {
        BUN_BE_BUN: "1",
      },
    })
-    const code = await result.exited
+    const code = await result.exited;
+    const stdout = result.stdout ? typeof result.stdout === "number" ? result.stdout : await readableStreamToText(result.stdout) : undefined
+    const stderr = result.stderr ? typeof result.stderr === "number" ? result.stderr : await readableStreamToText(result.stderr) : undefined
+    log.info("done", {
+      code,
+      stdout,
+      stderr,
+    })
    if (code !== 0) {
      throw new Error(`Command failed with exit code ${result.exitCode}`)
    }
@@ -53,10 +61,10 @@ export namespace BunProc {
    if (parsed.dependencies[pkg] === version) return mod
    parsed.dependencies[pkg] = version
    await Bun.write(pkgjson, JSON.stringify(parsed, null, 2))
-    await BunProc.run(["install"], {
+    await BunProc.run(["install", "--registry=https://registry.npmjs.org"], {
      cwd: Global.Path.cache,
    }).catch((e) => {
-      new InstallFailedError(
+      throw new InstallFailedError(
        { pkg, version },
        {
          cause: e,
@@ -49,7 +49,7 @@ export namespace Bus {
    )
  }

-  export function publish<Definition extends EventDefinition>(
+  export async function publish<Definition extends EventDefinition>(
    def: Definition,
    properties: z.output<Definition["properties"]>,
  ) {
@@ -60,12 +60,14 @@ export namespace Bus {
    log.info("publishing", {
      type: def.type,
    })
+    const pending = []
    for (const key of [def.type, "*"]) {
      const match = state().subscriptions.get(key)
      for (const sub of match ?? []) {
-        sub(payload)
+        pending.push(sub(payload))
      }
    }
+    return Promise.all(pending)
  }

  export function subscribe<Definition extends EventDefinition>(
@@ -0,0 +1,17 @@
+import { App } from "../app/app"
+import { ConfigHooks } from "../config/hooks"
+import { Format } from "../format"
+import { Share } from "../share/share"
+
+export async function bootstrap<T>(
+  input: App.Input,
+  cb: (app: App.Info) => Promise<T>,
+) {
+  return App.provide(input, async (app) => {
+    Share.init()
+    Format.init()
+    ConfigHooks.init()
+
+    return cb(app)
+  })
+}
@@ -1,4 +1,5 @@
 import { AuthAnthropic } from "../../auth/anthropic"
+import { AuthCopilot } from "../../auth/copilot"
 import { Auth } from "../../auth"
 import { cmd } from "./cmd"
 import * as prompts from "@clack/prompts"
@@ -6,17 +7,20 @@ import open from "open"
 import { UI } from "../ui"
 import { ModelsDev } from "../../provider/models"
 import { map, pipe, sortBy, values } from "remeda"
+import path from "path"
+import os from "os"
+import { Global } from "../../global"

 export const AuthCommand = cmd({
  command: "auth",
-  describe: "Manage credentials",
+  describe: "manage credentials",
  builder: (yargs) =>
    yargs
      .command(AuthLoginCommand)
      .command(AuthLogoutCommand)
      .command(AuthListCommand)
      .demandCommand(),
-  async handler() { },
+  async handler() {},
 })

 export const AuthListCommand = cmd({
@@ -25,30 +29,61 @@ export const AuthListCommand = cmd({
  describe: "list providers",
  async handler() {
    UI.empty()
-    prompts.intro("Credentials")
+    const authPath = path.join(Global.Path.data, "auth.json")
+    const homedir = os.homedir()
+    const displayPath = authPath.startsWith(homedir)
+      ? authPath.replace(homedir, "~")
+      : authPath
+    prompts.intro(`Credentials ${UI.Style.TEXT_DIM}${displayPath}`)
    const results = await Auth.all().then((x) => Object.entries(x))
    const database = await ModelsDev.get()

    for (const [providerID, result] of results) {
      const name = database[providerID]?.name || providerID
-      prompts.log.info(`${name} ${UI.Style.TEXT_DIM}(${result.type})`)
+      prompts.log.info(`${name} ${UI.Style.TEXT_DIM}${result.type}`)
    }

    prompts.outro(`${results.length} credentials`)
+
+    // Environment variables section
+    const activeEnvVars: Array<{ provider: string; envVar: string }> = []
+
+    for (const [providerID, provider] of Object.entries(database)) {
+      for (const envVar of provider.env) {
+        if (process.env[envVar]) {
+          activeEnvVars.push({
+            provider: provider.name || providerID,
+            envVar,
+          })
+        }
+      }
+    }
+
+    if (activeEnvVars.length > 0) {
+      UI.empty()
+      prompts.intro("Environment")
+
+      for (const { provider, envVar } of activeEnvVars) {
+        prompts.log.info(`${provider} ${UI.Style.TEXT_DIM}${envVar}`)
+      }
+
+      prompts.outro(`${activeEnvVars.length} environment variables`)
+    }
  },
 })

 export const AuthLoginCommand = cmd({
  command: "login",
-  describe: "login to a provider",
+  describe: "log in to a provider",
  async handler() {
    UI.empty()
    prompts.intro("Add credential")
    const providers = await ModelsDev.get()
    const priority: Record<string, number> = {
      anthropic: 0,
-      openai: 1,
-      google: 2,
+      "github-copilot": 1,
+      openai: 2,
+      google: 3,
    }
    let provider = await prompts.select({
      message: "Select provider",
@@ -146,6 +181,44 @@ export const AuthLoginCommand = cmd({
      }
    }

+    const copilot = await AuthCopilot()
+    if (provider === "github-copilot" && copilot) {
+      await new Promise((resolve) => setTimeout(resolve, 10))
+      const deviceInfo = await copilot.authorize()
+
+      prompts.note(
+        `Please visit: ${deviceInfo.verification}\nEnter code: ${deviceInfo.user}`,
+      )
+
+      const spinner = prompts.spinner()
+      spinner.start("Waiting for authorization...")
+
+      while (true) {
+        await new Promise((resolve) =>
+          setTimeout(resolve, deviceInfo.interval * 1000),
+        )
+        const response = await copilot.poll(deviceInfo.device)
+        if (response.status === "pending") continue
+        if (response.status === "success") {
+          await Auth.set("github-copilot", {
+            type: "oauth",
+            refresh: response.refresh,
+            access: response.access,
+            expires: response.expires,
+          })
+          spinner.stop("Login successful")
+          break
+        }
+        if (response.status === "failed") {
+          spinner.stop("Failed to authorize", 1)
+          break
+        }
+      }
+
+      prompts.outro("Done")
+      return
+    }
+
    const key = await prompts.password({
      message: "Enter your API key",
      validate: (x) => (x.length > 0 ? undefined : "Required"),
@@ -162,7 +235,7 @@ export const AuthLoginCommand = cmd({

 export const AuthLogoutCommand = cmd({
  command: "logout",
-  describe: "logout from a configured provider",
+  describe: "log out from a configured provider",
  async handler() {
    UI.empty()
    const credentials = await Auth.all().then((x) => Object.entries(x))
@@ -1,20 +0,0 @@
-import { AuthAnthropic } from "../../auth/anthropic"
-import { UI } from "../ui"
-
-// Example: https://claude.ai/oauth/authorize?code=true&client_id=9d1c250a-e61b-44d9-88ed-5944d1962f5e&response_type=code&redirect_uri=https%3A%2F%2Fconsole.anthropic.com%2Foauth%2Fcode%2Fcallback&scope=org%3Acreate_api_key+user%3Aprofile+user%3Ainference&code_challenge=MdFtFgFap23AWDSN0oa3-eaKjQRFE4CaEhXx8M9fHZg&code_challenge_method=S256&state=rKLtaDzm88GSwekyEqdi0wXX-YqIr13tSzYymSzpvfs
-
-export const LoginAnthropicCommand = {
-  command: "anthropic",
-  describe: "Login to Anthropic",
-  handler: async () => {
-    const { url, verifier } = await AuthAnthropic.authorize()
-
-    UI.println("Login to Anthropic")
-    UI.println("Open the following URL in your browser:")
-    UI.println(url)
-    UI.println("")
-
-    const code = await UI.input("Paste the authorization code here: ")
-    await AuthAnthropic.exchange(code, verifier)
-  },
-}
@@ -0,0 +1,19 @@
+import { App } from "../../app/app"
+import { Provider } from "../../provider/provider"
+import { cmd } from "./cmd"
+
+export const ModelsCommand = cmd({
+  command: "models",
+  describe: "list all available models",
+  handler: async () => {
+    await App.provide({ cwd: process.cwd() }, async () => {
+      const providers = await Provider.list()
+
+      for (const [providerID, provider] of Object.entries(providers)) {
+        for (const modelID of Object.keys(provider.info.models)) {
+          console.log(`${providerID}/${modelID}`)
+        }
+      }
+    })
+  },
+})
@@ -1,14 +1,13 @@
 import type { Argv } from "yargs"
-import { App } from "../../app/app"
 import { Bus } from "../../bus"
 import { Provider } from "../../provider/provider"
 import { Session } from "../../session"
-import { Share } from "../../share/share"
 import { Message } from "../../session/message"
 import { UI } from "../ui"
 import { cmd } from "./cmd"
 import { Flag } from "../../flag/flag"
 import { Config } from "../../config/config"
+import { bootstrap } from "../bootstrap"

 const TOOL: Record<string, [string, string]> = {
  todowrite: ["Todo", UI.Style.TEXT_WARNING_BOLD],
@@ -25,7 +24,7 @@ const TOOL: Record<string, [string, string]> = {

 export const RunCommand = cmd({
  command: "run [message..]",
-  describe: "Run opencode with a message",
+  describe: "run opencode with a message",
  builder: (yargs: Argv) => {
    return yargs
      .positional("message", {
@@ -36,12 +35,12 @@ export const RunCommand = cmd({
      })
      .option("continue", {
        alias: ["c"],
-        describe: "Continue the last session",
+        describe: "continue the last session",
        type: "boolean",
      })
      .option("session", {
        alias: ["s"],
-        describe: "Session ID to continue",
+        describe: "session id to continue",
        type: "string",
      })
      .option("share", {
@@ -51,115 +50,114 @@ export const RunCommand = cmd({
      .option("model", {
        type: "string",
        alias: ["m"],
-        describe: "Model to use in the format of provider/model",
+        describe: "model to use in the format of provider/model",
      })
  },
  handler: async (args) => {
    const message = args.message.join(" ")
-    await App.provide(
-      {
-        cwd: process.cwd(),
-      },
-      async () => {
-        await Share.init()
-        const session = await (async () => {
-          if (args.continue) {
-            const first = await Session.list().next()
-            if (first.done) return
-            return first.value
-          }
-
-          if (args.session) return Session.get(args.session)
-
-          return Session.create()
-        })()
-
-        if (!session) {
-          UI.error("Session not found")
-          return
+    await bootstrap({ cwd: process.cwd() }, async () => {
+      const session = await (async () => {
+        if (args.continue) {
+          const first = await Session.list().next()
+          if (first.done) return
+          return first.value
        }

-        UI.empty()
-        UI.println(UI.logo())
-        UI.empty()
-        UI.println(UI.Style.TEXT_NORMAL_BOLD + "> ", message)
-        UI.empty()
+        if (args.session) return Session.get(args.session)

-        const cfg = await Config.get()
-        if (cfg.autoshare || Flag.OPENCODE_AUTO_SHARE || args.share) {
-          await Session.share(session.id)
-          UI.println(
-            UI.Style.TEXT_INFO_BOLD +
+        return Session.create()
+      })()
+
+      if (!session) {
+        UI.error("Session not found")
+        return
+      }
+
+      const isPiped = !process.stdout.isTTY
+
+      UI.empty()
+      UI.println(UI.logo())
+      UI.empty()
+      UI.println(UI.Style.TEXT_NORMAL_BOLD + "> ", message)
+      UI.empty()
+
+      const cfg = await Config.get()
+      if (cfg.autoshare || Flag.OPENCODE_AUTO_SHARE || args.share) {
+        await Session.share(session.id)
+        UI.println(
+          UI.Style.TEXT_INFO_BOLD +
            "~  https://opencode.ai/s/" +
            session.id.slice(-8),
-          )
-        }
-        UI.empty()
-
-        const { providerID, modelID } = args.model
-          ? Provider.parseModel(args.model)
-          : await Provider.defaultModel()
-        UI.println(
-          UI.Style.TEXT_NORMAL_BOLD + "@ ",
-          UI.Style.TEXT_NORMAL + `${providerID}/${modelID}`,
        )
-        UI.empty()
+      }
+      UI.empty()

-        function printEvent(color: string, type: string, title: string) {
-          UI.println(
-            color + `|`,
-            UI.Style.TEXT_NORMAL +
-            UI.Style.TEXT_DIM +
-            ` ${type.padEnd(7, " ")}`,
-            "",
-            UI.Style.TEXT_NORMAL + title,
-          )
+      const { providerID, modelID } = args.model
+        ? Provider.parseModel(args.model)
+        : await Provider.defaultModel()
+      UI.println(
+        UI.Style.TEXT_NORMAL_BOLD + "@ ",
+        UI.Style.TEXT_NORMAL + `${providerID}/${modelID}`,
+      )
+      UI.empty()
+
+      function printEvent(color: string, type: string, title: string) {
+        UI.println(
+          color + `|`,
+          UI.Style.TEXT_NORMAL + UI.Style.TEXT_DIM + ` ${type.padEnd(7, " ")}`,
+          "",
+          UI.Style.TEXT_NORMAL + title,
+        )
+      }
+
+      Bus.subscribe(Message.Event.PartUpdated, async (evt) => {
+        if (evt.properties.sessionID !== session.id) return
+        const part = evt.properties.part
+        const message = await Session.getMessage(
+          evt.properties.sessionID,
+          evt.properties.messageID,
+        )
+
+        if (
+          part.type === "tool-invocation" &&
+          part.toolInvocation.state === "result"
+        ) {
+          const metadata = message.metadata.tool[part.toolInvocation.toolCallId]
+          const [tool, color] = TOOL[part.toolInvocation.toolName] ?? [
+            part.toolInvocation.toolName,
+            UI.Style.TEXT_INFO_BOLD,
+          ]
+          printEvent(color, tool, metadata?.title || "Unknown")
        }

-        Bus.subscribe(Message.Event.PartUpdated, async (evt) => {
-          if (evt.properties.sessionID !== session.id) return
-          const part = evt.properties.part
-          const message = await Session.getMessage(
-            evt.properties.sessionID,
-            evt.properties.messageID,
-          )
-
-          if (
-            part.type === "tool-invocation" &&
-            part.toolInvocation.state === "result"
-          ) {
-            const metadata =
-              message.metadata.tool[part.toolInvocation.toolCallId]
-            const [tool, color] = TOOL[part.toolInvocation.toolName] ?? [
-              part.toolInvocation.toolName,
-              UI.Style.TEXT_INFO_BOLD,
-            ]
-            printEvent(color, tool, metadata.title)
+        if (part.type === "text") {
+          if (part.text.includes("\n")) {
+            UI.empty()
+            UI.println(part.text)
+            UI.empty()
+            return
          }
+          printEvent(UI.Style.TEXT_NORMAL_BOLD, "Text", part.text)
+        }
+      })

-          if (part.type === "text") {
-            if (part.text.includes("\n")) {
-              UI.empty()
-              UI.println(part.text)
-              UI.empty()
-              return
-            }
-            printEvent(UI.Style.TEXT_NORMAL_BOLD, "Text", part.text)
-          }
-        })
-        await Session.chat({
-          sessionID: session.id,
-          providerID,
-          modelID,
-          parts: [
-            {
-              type: "text",
-              text: message,
-            },
-          ],
-        })
-        UI.empty()
-      },
-    )
+      const result = await Session.chat({
+        sessionID: session.id,
+        providerID,
+        modelID,
+        parts: [
+          {
+            type: "text",
+            text: message,
+          },
+        ],
+      })
+
+      if (isPiped) {
+        const match = result.parts.findLast((x) => x.type === "text")
+        if (match) process.stdout.write(match.text)
+      }
+      UI.empty()
+    })
  },
 })
@@ -7,12 +7,9 @@ export const ScrapCommand = cmd({
  builder: (yargs) =>
    yargs.positional("file", { type: "string", demandOption: true }),
  async handler(args) {
-    await App.provide(
-      { cwd: process.cwd() },
-      async () => {
-        await LSP.touchFile(args.file, true)
-        console.log(await LSP.diagnostics())
-      },
-    )
+    await App.provide({ cwd: process.cwd() }, async () => {
+      await LSP.touchFile(args.file, true)
+      console.log(await LSP.diagnostics())
+    })
  },
 })
@@ -0,0 +1,50 @@
+import { App } from "../../app/app"
+import { Provider } from "../../provider/provider"
+import { Server } from "../../server/server"
+import { Share } from "../../share/share"
+import { cmd } from "./cmd"
+
+export const ServeCommand = cmd({
+  command: "serve",
+  builder: (yargs) =>
+    yargs
+      .option("port", {
+        alias: ["p"],
+        type: "number",
+        describe: "port to listen on",
+        default: 4096,
+      })
+      .option("hostname", {
+        alias: ["h"],
+        type: "string",
+        describe: "hostname to listen on",
+        default: "127.0.0.1",
+      }),
+  describe: "starts a headless opencode server",
+  handler: async (args) => {
+    const cwd = process.cwd()
+    await App.provide({ cwd }, async () => {
+      const providers = await Provider.list()
+      if (Object.keys(providers).length === 0) {
+        return "needs_provider"
+      }
+
+      const hostname = args.hostname
+      const port = args.port
+
+      await Share.init()
+      const server = Server.listen({
+        port,
+        hostname,
+      })
+
+      console.log(
+        `opencode server listening on http://${server.hostname}:${server.port}`,
+      )
+
+      await new Promise(() => {})
+
+      server.stop()
+    })
+  },
+})
@@ -0,0 +1,114 @@
+import { Global } from "../../global"
+import { Provider } from "../../provider/provider"
+import { Server } from "../../server/server"
+import { bootstrap } from "../bootstrap"
+import { UI } from "../ui"
+import { cmd } from "./cmd"
+import path from "path"
+import fs from "fs/promises"
+import { Installation } from "../../installation"
+import { Config } from "../../config/config"
+import { Bus } from "../../bus"
+
+export const TuiCommand = cmd({
+  command: "$0 [project]",
+  describe: "start opencode tui",
+  builder: (yargs) =>
+    yargs.positional("project", {
+      type: "string",
+      describe: "path to start opencode in",
+    }),
+  handler: async (args) => {
+    while (true) {
+      const cwd = args.project ? path.resolve(args.project) : process.cwd()
+      try {
+        process.chdir(cwd)
+      } catch (e) {
+        UI.error("Failed to change directory to " + cwd)
+        return
+      }
+      const result = await bootstrap({ cwd }, async (app) => {
+        const providers = await Provider.list()
+        if (Object.keys(providers).length === 0) {
+          return "needs_provider"
+        }
+
+        const server = Server.listen({
+          port: 0,
+          hostname: "127.0.0.1",
+        })
+
+        let cmd = ["go", "run", "./main.go"]
+        let cwd = Bun.fileURLToPath(
+          new URL("../../../../tui/cmd/opencode", import.meta.url),
+        )
+        if (Bun.embeddedFiles.length > 0) {
+          const blob = Bun.embeddedFiles[0] as File
+          let binaryName = blob.name
+          if (process.platform === "win32" && !binaryName.endsWith(".exe")) {
+            binaryName += ".exe"
+          }
+          const binary = path.join(Global.Path.cache, "tui", binaryName)
+          const file = Bun.file(binary)
+          if (!(await file.exists())) {
+            await Bun.write(file, blob, { mode: 0o755 })
+            await fs.chmod(binary, 0o755)
+          }
+          cwd = process.cwd()
+          cmd = [binary]
+        }
+        const proc = Bun.spawn({
+          cmd: [...cmd, ...process.argv.slice(2)],
+          cwd,
+          stdout: "inherit",
+          stderr: "inherit",
+          stdin: "inherit",
+          env: {
+            ...process.env,
+            OPENCODE_SERVER: server.url.toString(),
+            OPENCODE_APP_INFO: JSON.stringify(app),
+          },
+          onExit: () => {
+            server.stop()
+          },
+        })
+
+        ;(async () => {
+          if (Installation.VERSION === "dev") return
+          if (Installation.isSnapshot()) return
+          const config = await Config.global()
+          if (config.autoupdate === false) return
+          const latest = await Installation.latest().catch(() => {})
+          if (!latest) return
+          if (Installation.VERSION === latest) return
+          const method = await Installation.method()
+          if (method === "unknown") return
+          await Installation.upgrade(method, latest)
+            .then(() => {
+              Bus.publish(Installation.Event.Updated, { version: latest })
+            })
+            .catch(() => {})
+        })()
+
+        await proc.exited
+        server.stop()
+
+        return "done"
+      })
+      if (result === "done") break
+      if (result === "needs_provider") {
+        UI.empty()
+        UI.println(UI.logo("   "))
+        const result = await Bun.spawn({
+          cmd: [process.execPath, "auth", "login"],
+          cwd: process.cwd(),
+          stdout: "inherit",
+          stderr: "inherit",
+          stdin: "inherit",
+        }).exited
+        if (result !== 0) return
+        UI.empty()
+      }
+    }
+  },
+})
@@ -5,19 +5,27 @@ import { Installation } from "../../installation"

 export const UpgradeCommand = {
  command: "upgrade [target]",
-  describe: "upgrade opencode to the latest version or a specific version",
+  describe: "upgrade opencode to the latest or a specific version",
  builder: (yargs: Argv) => {
-    return yargs.positional("target", {
-      describe: "specific version to upgrade to (e.g., '0.1.48' or 'v0.1.48')",
-      type: "string",
-    })
+    return yargs
+      .positional("target", {
+        describe: "version to upgrade to, for ex '0.1.48' or 'v0.1.48'",
+        type: "string",
+      })
+      .option("method", {
+        alias: "m",
+        describe: "installation method to use",
+        type: "string",
+        choices: ["curl", "npm", "pnpm", "bun", "brew"],
+      })
  },
-  handler: async (args: { target?: string }) => {
+  handler: async (args: { target?: string; method?: string }) => {
    UI.empty()
    UI.println(UI.logo("  "))
    UI.empty()
    prompts.intro("Upgrade")
-    const method = await Installation.method()
+    const detectedMethod = await Installation.method()
+    const method = (args.method as Installation.Method) ?? detectedMethod
    if (method === "unknown") {
      prompts.log.error(
        `opencode is installed to ${process.execPath} and seems to be managed by a package manager`,
@@ -25,6 +33,7 @@ export const UpgradeCommand = {
      prompts.outro("Done")
      return
    }
+    prompts.log.info("Using method: " + method)
    const target = args.target ?? (await Installation.latest())
    prompts.log.info(`From ${Installation.VERSION} → ${target}`)
    const spinner = prompts.spinner()
@@ -1,6 +1,10 @@
 import { Config } from "../config/config"
+import { MCP } from "../mcp"
+import { UI } from "./ui"

 export function FormatError(input: unknown) {
+  if (MCP.Failed.isInstance(input))
+    return `MCP server "${input.data.name}" failed. Note, opencode does not support MCP authentication yet.`
  if (Config.JsonError.isInstance(input))
    return `Config file at ${input.data.path} is not valid JSON`
  if (Config.InvalidError.isInstance(input))
@@ -10,4 +14,6 @@ export function FormatError(input: unknown) {
        (issue) => "↳ " + issue.message + " " + issue.path.join("."),
      ) ?? []),
    ].join("\n")
+
+  if (UI.CancelledError.isInstance(input)) return ""
 }
@@ -1,4 +1,5 @@
 import { z } from "zod"
+import { EOL } from "os"
 import { NamedError } from "../util/error"

 export namespace UI {
@@ -29,7 +30,7 @@ export namespace UI {

  export function println(...message: string[]) {
    print(...message)
-    Bun.stderr.write("\n")
+    Bun.stderr.write(EOL)
  }

  export function print(...message: string[]) {
@@ -52,7 +53,7 @@ export namespace UI {
      result.push(row[0])
      result.push("\x1b[0m")
      result.push(row[1])
-      result.push("\n")
+      result.push(EOL)
    }
    return result.join("").trimEnd()
  }
@@ -22,6 +22,7 @@ export namespace Config {
      }
    }
    log.info("loaded", result)
+
    return result
  })

@@ -36,20 +37,28 @@ export namespace Config {
        .record(z.string(), z.string())
        .optional()
        .describe("Environment variables to set when running the MCP server"),
+      enabled: z
+        .boolean()
+        .optional()
+        .describe("Enable or disable the MCP server on startup"),
    })
    .strict()
    .openapi({
-      ref: "Config.McpLocal",
+      ref: "McpLocalConfig",
    })

  export const McpRemote = z
    .object({
      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"),
    })
    .strict()
    .openapi({
-      ref: "Config.McpRemote",
+      ref: "McpRemoteConfig",
    })

  export const Mcp = z.discriminatedUnion("type", [McpLocal, McpRemote])
@@ -123,7 +132,7 @@ export namespace Config {
    })
    .strict()
    .openapi({
-      ref: "Config.Keybinds",
+      ref: "KeybindsConfig",
    })
  export const Info = z
    .object({
@@ -167,10 +176,36 @@ export namespace Config {
        .record(z.string(), Mcp)
        .optional()
        .describe("MCP (Model Context Protocol) server configurations"),
+      experimental: z
+        .object({
+          hook: z
+            .object({
+              file_edited: z
+                .record(
+                  z.string(),
+                  z
+                    .object({
+                      command: z.string().array(),
+                      environment: z.record(z.string(), z.string()).optional(),
+                    })
+                    .array(),
+                )
+                .optional(),
+              session_completed: z
+                .object({
+                  command: z.string().array(),
+                  environment: z.record(z.string(), z.string()).optional(),
+                })
+                .array()
+                .optional(),
+            })
+            .optional(),
+        })
+        .optional(),
    })
    .strict()
    .openapi({
-      ref: "Config.Info",
+      ref: "Config",
    })

  export type Info = z.output<typeof Info>
@@ -0,0 +1,54 @@
+import { App } from "../app/app"
+import { Bus } from "../bus"
+import { File } from "../file"
+import { Session } from "../session"
+import { Log } from "../util/log"
+import { Config } from "./config"
+import path from "path"
+
+export namespace ConfigHooks {
+  const log = Log.create({ service: "config.hooks" })
+
+  export function init() {
+    log.info("init")
+    const app = App.info()
+
+    Bus.subscribe(File.Event.Edited, async (payload) => {
+      const cfg = await Config.get()
+      const ext = path.extname(payload.properties.file)
+      for (const item of cfg.experimental?.hook?.file_edited?.[ext] ?? []) {
+        log.info("file_edited", {
+          file: payload.properties.file,
+          command: item.command,
+        })
+        Bun.spawn({
+          cmd: item.command.map((x) =>
+            x.replace("$FILE", payload.properties.file),
+          ),
+          env: item.environment,
+          cwd: app.path.cwd,
+          stdout: "ignore",
+          stderr: "ignore",
+        })
+      }
+    })
+
+    Bus.subscribe(Session.Event.Idle, async () => {
+      const cfg = await Config.get()
+      if (cfg.experimental?.hook?.session_completed) {
+        for (const item of cfg.experimental.hook.session_completed) {
+          log.info("session_completed", {
+            command: item.command,
+          })
+          Bun.spawn({
+            cmd: item.command,
+            cwd: App.info().path.cwd,
+            env: item.environment,
+            stdout: "ignore",
+            stderr: "ignore",
+          })
+        }
+      }
+    })
+  }
+}
@@ -116,14 +116,17 @@ export namespace Ripgrep {
  export async function files(input: {
    cwd: string
    query?: string
+    glob?: string
    limit?: number
  }) {
-    const commands = [`${await filepath()} --files --hidden --glob='!.git/*'`]
+    const commands = [
+      `${await filepath()} --files --hidden --glob='!.git/*' ${input.glob ? `--glob='${input.glob}'` : ``}`,
+    ]
    if (input.query)
      commands.push(`${await Fzf.filepath()} --filter=${input.query}`)
    if (input.limit) commands.push(`head -n ${input.limit}`)
    const joined = commands.join(" | ")
-    const result = await $`${{ raw: joined }}`.cwd(input.cwd).text()
+    const result = await $`${{ raw: joined }}`.cwd(input.cwd).nothrow().text()
    return result.split("\n").filter(Boolean)
  }
 }
@@ -0,0 +1,13 @@
+import { z } from "zod"
+import { Bus } from "../bus"
+
+export namespace File {
+  export const Event = {
+    Edited: Bus.event(
+      "file.edited",
+      z.object({
+        file: z.string(),
+      }),
+    ),
+  }
+}
@@ -1,6 +1,6 @@
-import { App } from "../../app/app"
+import { App } from "../app/app"

-export namespace FileTimes {
+export namespace FileTime {
  export const state = App.state("tool.filetimes", () => {
    const read: {
      [sessionID: string]: {
@@ -0,0 +1,165 @@
+import { App } from "../app/app"
+import { BunProc } from "../bun"
+import { Bus } from "../bus"
+import { File } from "../file"
+import { Log } from "../util/log"
+import path from "path"
+
+export namespace Format {
+  const log = Log.create({ service: "format" })
+
+  const state = App.state("format", () => {
+    const enabled: Record<string, boolean> = {}
+
+    return {
+      enabled,
+    }
+  })
+
+  async function isEnabled(item: Definition) {
+    const s = state()
+    let status = s.enabled[item.name]
+    if (status === undefined) {
+      status = await item.enabled()
+      s.enabled[item.name] = status
+    }
+    return status
+  }
+
+  async function getFormatter(ext: string) {
+    const result = []
+    for (const item of FORMATTERS) {
+      if (!item.extensions.includes(ext)) continue
+      if (!isEnabled(item)) continue
+      result.push(item)
+    }
+    return result
+  }
+
+  export function init() {
+    log.info("init")
+    Bus.subscribe(File.Event.Edited, async (payload) => {
+      const file = payload.properties.file
+      log.info("formatting", { file })
+      const ext = path.extname(file)
+
+      for (const item of await getFormatter(ext)) {
+        log.info("running", { command: item.command })
+        const proc = Bun.spawn({
+          cmd: item.command.map((x) => x.replace("$FILE", file)),
+          cwd: App.info().path.cwd,
+          env: item.environment,
+          stdout: "ignore",
+          stderr: "ignore",
+        })
+        const exit = await proc.exited
+        if (exit !== 0)
+          log.error("failed", {
+            command: item.command,
+            ...item.environment,
+          })
+      }
+    })
+  }
+
+  interface Definition {
+    name: string
+    command: string[]
+    environment?: Record<string, string>
+    extensions: string[]
+    enabled(): Promise<boolean>
+  }
+
+  const FORMATTERS: Definition[] = [
+    {
+      name: "prettier",
+      command: [BunProc.which(), "run", "prettier", "--write", "$FILE"],
+      environment: {
+        BUN_BE_BUN: "1",
+      },
+      extensions: [
+        ".js",
+        ".jsx",
+        ".mjs",
+        ".cjs",
+        ".ts",
+        ".tsx",
+        ".mts",
+        ".cts",
+        ".html",
+        ".htm",
+        ".css",
+        ".scss",
+        ".sass",
+        ".less",
+        ".vue",
+        ".svelte",
+        ".json",
+        ".jsonc",
+        ".yaml",
+        ".yml",
+        ".toml",
+        ".xml",
+        ".md",
+        ".mdx",
+        ".graphql",
+        ".gql",
+      ],
+      async enabled() {
+        try {
+          const proc = Bun.spawn({
+            cmd: [BunProc.which(), "run", "prettier", "--version"],
+            cwd: App.info().path.cwd,
+            env: {
+              BUN_BE_BUN: "1",
+            },
+            stdout: "ignore",
+            stderr: "ignore",
+          })
+          const exit = await proc.exited
+          return exit === 0
+        } catch {
+          return false
+        }
+      },
+    },
+    {
+      name: "mix",
+      command: ["mix", "format", "$FILE"],
+      extensions: [".ex", ".exs", ".eex", ".heex", ".leex", ".neex", ".sface"],
+      async enabled() {
+        try {
+          const proc = Bun.spawn({
+            cmd: ["mix", "--version"],
+            cwd: App.info().path.cwd,
+            stdout: "ignore",
+            stderr: "ignore",
+          })
+          const exit = await proc.exited
+          return exit === 0
+        } catch {
+          return false
+        }
+      },
+    },
+    {
+      name: "gofmt",
+      command: ["gofmt", "-w", "$FILE"],
+      extensions: [".go"],
+      async enabled() {
+        try {
+          const proc = Bun.spawn({
+            cmd: ["gofmt", "-h"],
+            cwd: App.info().path.cwd,
+            stdout: "ignore",
+            stderr: "ignore",
+          })
+          const exit = await proc.exited
+          return exit === 0
+        } catch {
+          return false
+        }
+      },
+    },
+  ]
+}
@@ -41,6 +41,17 @@ export namespace Identifier {
    return given
  }

+  function randomBase62(length: number): string {
+    const chars =
+      "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+    let result = ""
+    const bytes = randomBytes(length)
+    for (let i = 0; i < length; i++) {
+      result += chars[bytes[i] % 62]
+    }
+    return result
+  }
+
  function generateNewID(
    prefix: keyof typeof prefixes,
    descending: boolean,
@@ -62,14 +73,11 @@ export namespace Identifier {
      timeBytes[i] = Number((now >> BigInt(40 - 8 * i)) & BigInt(0xff))
    }

-    const randLength = (LENGTH - 12) / 2
-    const random = randomBytes(randLength)
-
    return (
      prefixes[prefix] +
      "_" +
      timeBytes.toString("hex") +
-      random.toString("hex")
+      randomBase62(LENGTH - 12)
    )
  }
 }
@@ -1,31 +1,41 @@
 import "zod-openapi/extend"
-import { App } from "./app/app"
-import { Server } from "./server/server"
-import fs from "fs/promises"
-import path from "path"
-import { Share } from "./share/share"
-import { Global } from "./global"
 import yargs from "yargs"
 import { hideBin } from "yargs/helpers"
 import { RunCommand } from "./cli/cmd/run"
 import { GenerateCommand } from "./cli/cmd/generate"
 import { ScrapCommand } from "./cli/cmd/scrap"
 import { Log } from "./util/log"
-import { AuthCommand, AuthLoginCommand } from "./cli/cmd/auth"
+import { AuthCommand } from "./cli/cmd/auth"
 import { UpgradeCommand } from "./cli/cmd/upgrade"
-import { Provider } from "./provider/provider"
+import { ModelsCommand } from "./cli/cmd/models"
 import { UI } from "./cli/ui"
 import { Installation } from "./installation"
-import { Bus } from "./bus"
-import { Config } from "./config/config"
 import { NamedError } from "./util/error"
 import { FormatError } from "./cli/error"
+import { ServeCommand } from "./cli/cmd/serve"
+import { TuiCommand } from "./cli/cmd/tui"
+
+const cancel = new AbortController()
+
+process.on("unhandledRejection", (e) => {
+  Log.Default.error("rejection", {
+    e: e instanceof Error ? e.message : e,
+  })
+})
+
+process.on("uncaughtException", (e) => {
+  Log.Default.error("exception", {
+    e: e instanceof Error ? e.message : e,
+  })
+})

 const cli = yargs(hideBin(process.argv))
  .scriptName("opencode")
-  .version(Installation.VERSION)
+  .help("help", "show help")
+  .version("version", "show version number", Installation.VERSION)
+  .alias("version", "v")
  .option("print-logs", {
-    describe: "Print logs to stderr",
+    describe: "print logs to stderr",
    type: "boolean",
  })
  .middleware(async () => {
@@ -36,92 +46,14 @@ const cli = yargs(hideBin(process.argv))
    })
  })
  .usage("\n" + UI.logo())
-  .command({
-    command: "$0 [project]",
-    describe: "start opencode TUI",
-    builder: (yargs) =>
-      yargs.positional("project", {
-        type: "string",
-        describe: "path to start opencode in",
-      }),
-    handler: async (args) => {
-      while (true) {
-        const cwd = args.project ? path.resolve(args.project) : process.cwd()
-        process.chdir(cwd)
-        const result = await App.provide({ cwd }, async (app) => {
-          const providers = await Provider.list()
-          if (Object.keys(providers).length === 0) {
-            return "needs_provider"
-          }
-
-          await Share.init()
-          const server = Server.listen()
-
-          let cmd = ["go", "run", "./main.go"]
-          let cwd = new URL("../../tui/cmd/opencode", import.meta.url).pathname
-          if (Bun.embeddedFiles.length > 0) {
-            const blob = Bun.embeddedFiles[0] as File
-            const binary = path.join(Global.Path.cache, "tui", blob.name)
-            const file = Bun.file(binary)
-            if (!(await file.exists())) {
-              await Bun.write(file, blob, { mode: 0o755 })
-              await fs.chmod(binary, 0o755)
-            }
-            cwd = process.cwd()
-            cmd = [binary]
-          }
-          const proc = Bun.spawn({
-            cmd: [...cmd, ...process.argv.slice(2)],
-            cwd,
-            stdout: "inherit",
-            stderr: "inherit",
-            stdin: "inherit",
-            env: {
-              ...process.env,
-              OPENCODE_SERVER: server.url.toString(),
-              OPENCODE_APP_INFO: JSON.stringify(app),
-            },
-            onExit: () => {
-              server.stop()
-            },
-          })
-
-          ;(async () => {
-            if (Installation.VERSION === "dev") return
-            if (Installation.isSnapshot()) return
-            const config = await Config.global()
-            if (config.autoupdate === false) return
-            const latest = await Installation.latest()
-            if (Installation.VERSION === latest) return
-            const method = await Installation.method()
-            if (method === "unknown") return
-            await Installation.upgrade(method, latest)
-              .then(() => {
-                Bus.publish(Installation.Event.Updated, { version: latest })
-              })
-              .catch(() => {})
-          })()
-
-          await proc.exited
-          server.stop()
-
-          return "done"
-        })
-        if (result === "done") break
-        if (result === "needs_provider") {
-          UI.empty()
-          UI.println(UI.logo("   "))
-          UI.empty()
-          await AuthLoginCommand.handler(args)
-        }
-      }
-    },
-  })
+  .command(TuiCommand)
  .command(RunCommand)
  .command(GenerateCommand)
  .command(ScrapCommand)
  .command(AuthCommand)
  .command(UpgradeCommand)
+  .command(ServeCommand)
+  .command(ModelsCommand)
  .fail((msg) => {
    if (
      msg.startsWith("Unknown argument") ||
@@ -135,13 +67,14 @@ const cli = yargs(hideBin(process.argv))
 try {
  await cli.parse()
 } catch (e) {
-  const data: Record<string, any> = {}
+  let data: Record<string, any> = {}
  if (e instanceof NamedError) {
    const obj = e.toObject()
    Object.assign(data, {
      ...obj.data,
    })
  }
+
  if (e instanceof Error) {
    Object.assign(data, {
      name: e.name,
@@ -149,11 +82,26 @@ try {
      cause: e.cause?.toString(),
    })
  }
+
+  if (e instanceof ResolveMessage) {
+    Object.assign(data, {
+      name: e.name,
+      message: e.message,
+      code: e.code,
+      specifier: e.specifier,
+      referrer: e.referrer,
+      position: e.position,
+      importKind: e.importKind,
+    })
+  }
  Log.Default.error("fatal", data)
  const formatted = FormatError(e)
  if (formatted) UI.error(formatted)
-  if (!formatted)
+  if (formatted === undefined)
    UI.error(
      "Unexpected error, check log file at " + Log.file() + " for more details",
    )
+  process.exitCode = 1
 }
+
+cancel.abort()
@@ -3,12 +3,15 @@ import { $ } from "bun"
 import { z } from "zod"
 import { NamedError } from "../util/error"
 import { Bus } from "../bus"
+import { Log } from "../util/log"

 declare global {
  const OPENCODE_VERSION: string
 }

 export namespace Installation {
+  const log = Log.create({ service: "installation" })
+
  export type Method = Awaited<ReturnType<typeof method>>

  export const Event = {
@@ -66,6 +69,10 @@ export namespace Installation {
        name: "bun" as const,
        command: () => $`bun pm ls -g`.throws(false).text(),
      },
+      {
+        name: "brew" as const,
+        command: () => $`brew list --formula opencode-ai`.throws(false).text(),
+      },
    ]

    checks.sort((a, b) => {
@@ -97,18 +104,31 @@ export namespace Installation {
    const cmd = (() => {
      switch (method) {
        case "curl":
-          return $`curl -fsSL https://opencode.ai/install | bash`
+          return $`curl -fsSL https://opencode.ai/install | bash`.env({
+            ...process.env,
+            VERSION: target,
+          })
        case "npm":
          return $`npm install -g opencode-ai@${target}`
        case "pnpm":
          return $`pnpm install -g opencode-ai@${target}`
        case "bun":
          return $`bun install -g opencode-ai@${target}`
+        case "brew":
+          return $`brew install sst/tap/opencode`.env({
+            HOMEBREW_NO_AUTO_UPDATE: "1",
+          })
        default:
          throw new Error(`Unknown method: ${method}`)
      }
    })()
    const result = await cmd.quiet().throws(false)
+    log.info("upgraded", {
+      method,
+      target,
+      stdout: result.stdout.toString(),
+      stderr: result.stderr.toString(),
+    })
    if (result.exitCode !== 0)
      throw new UpgradeFailedError({
        stderr: result.stderr.toString("utf8"),
@@ -2,8 +2,22 @@ import { experimental_createMCPClient, type Tool } from "ai"
 import { Experimental_StdioMCPTransport } from "ai/mcp-stdio"
 import { App } from "../app/app"
 import { Config } from "../config/config"
+import { Log } from "../util/log"
+import { NamedError } from "../util/error"
+import { z } from "zod"
+import { Session } from "../session"
+import { Bus } from "../bus"

 export namespace MCP {
+  const log = Log.create({ service: "mcp" })
+
+  export const Failed = NamedError.create(
+    "MCPFailed",
+    z.object({
+      name: z.string(),
+    }),
+  )
+
  const state = App.state(
    "mcp",
    async () => {
@@ -12,27 +26,60 @@ export namespace MCP {
        [name: string]: Awaited<ReturnType<typeof experimental_createMCPClient>>
      } = {}
      for (const [key, mcp] of Object.entries(cfg.mcp ?? {})) {
+        if (mcp.enabled === false) {
+          log.info("mcp server disabled", { key })
+          continue
+        }
+        log.info("found", { key, type: mcp.type })
        if (mcp.type === "remote") {
-          clients[key] = await experimental_createMCPClient({
+          const client = await experimental_createMCPClient({
            name: key,
            transport: {
              type: "sse",
              url: mcp.url,
            },
-          })
+          }).catch(() => {})
+          if (!client) {
+            Bus.publish(Session.Event.Error, {
+              error: {
+                name: "UnknownError",
+                data: {
+                  message: `MCP server ${key} failed to start`,
+                },
+              },
+            })
+            continue
+          }
+          clients[key] = client
        }

        if (mcp.type === "local") {
          const [cmd, ...args] = mcp.command
-          clients[key] = await experimental_createMCPClient({
+          const client = await experimental_createMCPClient({
            name: key,
            transport: new Experimental_StdioMCPTransport({
              stderr: "ignore",
              command: cmd,
              args,
-              env: mcp.environment,
+              env: {
+                ...process.env,
+                ...(cmd === "opencode" ? { BUN_BE_BUN: "1" } : {}),
+                ...mcp.environment,
+              },
            }),
-          })
+          }).catch(() => {})
+          if (!client) {
+            Bus.publish(Session.Event.Error, {
+              error: {
+                name: "UnknownError",
+                data: {
+                  message: `MCP server ${key} failed to start`,
+                },
+              },
+            })
+            continue
+          }
+          clients[key] = client
        }
      }

@@ -0,0 +1,4 @@
+export async function data() {
+  const json = await fetch("https://models.dev/api.json").then((x) => x.text())
+  return json
+}
@@ -2,6 +2,7 @@ import { Global } from "../global"
 import { Log } from "../util/log"
 import path from "path"
 import { z } from "zod"
+import { data } from "./models-macro" with { type: "macro" }

 export namespace ModelsDev {
  const log = Log.create({ service: "models.dev" })
@@ -28,7 +29,7 @@ export namespace ModelsDev {
      options: z.record(z.any()),
    })
    .openapi({
-      ref: "Model.Info",
+      ref: "Model",
    })
  export type Model = z.infer<typeof Model>

@@ -42,7 +43,7 @@ export namespace ModelsDev {
      models: z.record(Model),
    })
    .openapi({
-      ref: "Provider.Info",
+      ref: "Provider",
    })

  export type Provider = z.infer<typeof Provider>
@@ -54,16 +55,15 @@ export namespace ModelsDev {
      refresh()
      return result as Record<string, Provider>
    }
-    await refresh()
-    return get()
+    refresh()
+    const json = await data()
+    return JSON.parse(json) as Record<string, Provider>
  }

  async function refresh() {
    const file = Bun.file(filepath)
    log.info("refreshing")
-    const result = await fetch("https://models.dev/api.json")
-    if (!result.ok)
-      throw new Error(`Failed to fetch models.dev: ${result.statusText}`)
-    await Bun.write(file, result)
+    const result = await fetch("https://models.dev/api.json").catch(() => {})
+    if (result && result.ok) await Bun.write(file, result)
  }
 }
@@ -19,28 +19,29 @@ import type { Tool } from "../tool/tool"
 import { WriteTool } from "../tool/write"
 import { TodoReadTool, TodoWriteTool } from "../tool/todo"
 import { AuthAnthropic } from "../auth/anthropic"
+import { AuthCopilot } from "../auth/copilot"
 import { ModelsDev } from "./models"
 import { NamedError } from "../util/error"
 import { Auth } from "../auth"
-import { TaskTool } from "../tool/task"

 export namespace Provider {
  const log = Log.create({ service: "provider" })

-  type CustomLoader = (provider: ModelsDev.Provider) => Promise<
-    | {
-        getModel?: (sdk: any, modelID: string) => Promise<any>
-        options: Record<string, any>
-      }
-    | false
-  >
+  type CustomLoader = (
+    provider: ModelsDev.Provider,
+    api?: string,
+  ) => Promise<{
+    autoload: boolean
+    getModel?: (sdk: any, modelID: string) => Promise<any>
+    options?: Record<string, any>
+  }>

  type Source = "env" | "config" | "custom" | "api"

  const CUSTOM_LOADERS: Record<string, CustomLoader> = {
    async anthropic(provider) {
      const access = await AuthAnthropic.access()
-      if (!access) return false
+      if (!access) return { autoload: false }
      for (const model of Object.values(provider.models)) {
        model.cost = {
          input: 0,
@@ -48,6 +49,7 @@ export namespace Provider {
        }
      }
      return {
+        autoload: true,
        options: {
          apiKey: "",
          async fetch(input: any, init: any) {
@@ -66,8 +68,56 @@ export namespace Provider {
        },
      }
    },
+    "github-copilot": async (provider) => {
+      const copilot = await AuthCopilot()
+      if (!copilot) return { autoload: false }
+      let info = await Auth.get("github-copilot")
+      if (!info || info.type !== "oauth") return { autoload: false }
+
+      if (provider && provider.models) {
+        for (const model of Object.values(provider.models)) {
+          model.cost = {
+            input: 0,
+            output: 0,
+          }
+        }
+      }
+
+      return {
+        autoload: true,
+        options: {
+          apiKey: "",
+          async fetch(input: any, init: any) {
+            const info = await Auth.get("github-copilot")
+            if (!info || info.type !== "oauth") return
+            if (!info.access || info.expires < Date.now()) {
+              const tokens = await copilot.access(info.refresh)
+              if (!tokens)
+                throw new Error("GitHub Copilot authentication expired")
+              await Auth.set("github-copilot", {
+                type: "oauth",
+                ...tokens,
+              })
+              info.access = tokens.access
+            }
+            const headers = {
+              ...init.headers,
+              ...copilot.HEADERS,
+              Authorization: `Bearer ${info.access}`,
+              "Openai-Intent": "conversation-edits",
+            }
+            delete headers["x-api-key"]
+            return fetch(input, {
+              ...init,
+              headers,
+            })
+          },
+        },
+      }
+    },
    openai: async () => {
      return {
+        autoload: false,
        async getModel(sdk: any, modelID: string) {
          return sdk.responses(modelID)
        },
@@ -75,7 +125,8 @@ export namespace Provider {
      }
    },
    "amazon-bedrock": async () => {
-      if (!process.env["AWS_PROFILE"]) false
+      if (!process.env["AWS_PROFILE"] && !process.env["AWS_ACCESS_KEY_ID"])
+        return { autoload: false }

      const region = process.env["AWS_REGION"] ?? "us-east-1"

@@ -83,6 +134,7 @@ export namespace Provider {
        await BunProc.install("@aws-sdk/credential-providers")
      )
      return {
+        autoload: true,
        options: {
          region,
          credentialProvider: fromNodeProviderChain(),
@@ -133,6 +185,7 @@ export namespace Provider {
          source,
          info,
          options,
+          getModel,
        }
        return
      }
@@ -208,8 +261,14 @@ export namespace Provider {
    for (const [providerID, fn] of Object.entries(CUSTOM_LOADERS)) {
      if (disabled.has(providerID)) continue
      const result = await fn(database[providerID])
-      if (result)
-        mergeProvider(providerID, result.options, "custom", result.getModel)
+      if (result && (result.autoload || providers[providerID])) {
+        mergeProvider(
+          providerID,
+          result.options ?? {},
+          "custom",
+          result.getModel,
+        )
+      }
    }

    // load config
@@ -352,7 +411,7 @@ export namespace Provider {
    // MultiEditTool,
    WriteTool,
    TodoWriteTool,
-    TaskTool,
+    // TaskTool,
    TodoReadTool,
  ]

@@ -1,24 +1,38 @@
-import type { CoreMessage } from "ai"
+import type { LanguageModelV1Prompt } from "ai"
+import { unique } from "remeda"

 export namespace ProviderTransform {
  export function message(
-    msg: CoreMessage,
-    index: number,
+    msgs: LanguageModelV1Prompt,
    providerID: string,
    modelID: string,
  ) {
-    if (
-      (providerID === "anthropic" || modelID.includes("anthropic")) &&
-      index < 4
-    ) {
-      msg.providerOptions = {
-        ...msg.providerOptions,
-        anthropic: {
-          cacheControl: { type: "ephemeral" },
-        },
+    if (providerID === "anthropic" || 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.providerMetadata = {
+          ...msg.providerMetadata,
+          anthropic: {
+            cacheControl: { 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)

-    return msg
+      for (const msg of unique([...system, ...final])) {
+        msg.providerMetadata = {
+          ...msg.providerMetadata,
+          bedrock: {
+            cachePoint: { type: "ephemeral" },
+          },
+        }
+      }
+    }
+    return msgs
  }
 }
@@ -9,12 +9,10 @@ import { z } from "zod"
 import { Message } from "../session/message"
 import { Provider } from "../provider/provider"
 import { App } from "../app/app"
-import { Global } from "../global"
 import { mapValues } from "remeda"
 import { NamedError } from "../util/error"
 import { ModelsDev } from "../provider/models"
 import { Ripgrep } from "../external/ripgrep"
-import { Installation } from "../installation"
 import { Config } from "../config/config"

 const ERRORS = {
@@ -70,12 +68,12 @@ export namespace Server {
        })
      })
      .get(
-        "/openapi",
+        "/doc",
        openAPISpecs(app, {
          documentation: {
            info: {
              title: "opencode",
-              version: "1.0.0",
+              version: "0.0.2",
              description: "opencode api",
            },
            openapi: "3.0.0",
@@ -122,8 +120,8 @@ export namespace Server {
          })
        },
      )
-      .post(
-        "/app_info",
+      .get(
+        "/app",
        describeRoute({
          description: "Get app info",
          responses: {
@@ -142,26 +140,7 @@ export namespace Server {
        },
      )
      .post(
-        "/config_get",
-        describeRoute({
-          description: "Get config info",
-          responses: {
-            200: {
-              description: "Get config info",
-              content: {
-                "application/json": {
-                  schema: resolver(Config.Info),
-                },
-              },
-            },
-          },
-        }),
-        async (c) => {
-          return c.json(await Config.get())
-        },
-      )
-      .post(
-        "/app_initialize",
+        "/app/init",
        describeRoute({
          description: "Initialize the app",
          responses: {
@@ -180,144 +159,27 @@ export namespace Server {
          return c.json(true)
        },
      )
-      .post(
-        "/session_initialize",
+      .get(
+        "/config",
        describeRoute({
-          description: "Analyze the app and create an AGENTS.md file",
+          description: "Get config info",
          responses: {
            200: {
-              description: "200",
+              description: "Get config info",
              content: {
                "application/json": {
-                  schema: resolver(z.boolean()),
-                },
-              },
-            },
-          },
-        }),
-        zValidator(
-          "json",
-          z.object({
-            sessionID: z.string(),
-            providerID: z.string(),
-            modelID: z.string(),
-          }),
-        ),
-        async (c) => {
-          const body = c.req.valid("json")
-          await Session.initialize(body)
-          return c.json(true)
-        },
-      )
-      .post(
-        "/path_get",
-        describeRoute({
-          description: "Get paths",
-          responses: {
-            200: {
-              description: "200",
-              content: {
-                "application/json": {
-                  schema: resolver(
-                    z.object({
-                      root: z.string(),
-                      data: z.string(),
-                      cwd: z.string(),
-                      config: z.string(),
-                    }),
-                  ),
+                  schema: resolver(Config.Info),
                },
              },
            },
          },
        }),
        async (c) => {
-          const app = App.info()
-          return c.json({
-            root: app.path.root,
-            data: app.path.data,
-            cwd: app.path.cwd,
-            config: Global.Path.data,
-          })
+          return c.json(await Config.get())
        },
      )
-      .post(
-        "/session_create",
-        describeRoute({
-          description: "Create a new session",
-          responses: {
-            ...ERRORS,
-            200: {
-              description: "Successfully created session",
-              content: {
-                "application/json": {
-                  schema: resolver(Session.Info),
-                },
-              },
-            },
-          },
-        }),
-        async (c) => {
-          const session = await Session.create()
-          return c.json(session)
-        },
-      )
-      .post(
-        "/session_share",
-        describeRoute({
-          description: "Share the session",
-          responses: {
-            200: {
-              description: "Successfully shared session",
-              content: {
-                "application/json": {
-                  schema: resolver(Session.Info),
-                },
-              },
-            },
-          },
-        }),
-        zValidator(
-          "json",
-          z.object({
-            sessionID: z.string(),
-          }),
-        ),
-        async (c) => {
-          const body = c.req.valid("json")
-          await Session.share(body.sessionID)
-          const session = await Session.get(body.sessionID)
-          return c.json(session)
-        },
-      )
-      .post(
-        "/session_messages",
-        describeRoute({
-          description: "Get messages for a session",
-          responses: {
-            200: {
-              description: "Successfully created session",
-              content: {
-                "application/json": {
-                  schema: resolver(Message.Info.array()),
-                },
-              },
-            },
-          },
-        }),
-        zValidator(
-          "json",
-          z.object({
-            sessionID: z.string(),
-          }),
-        ),
-        async (c) => {
-          const messages = await Session.messages(c.req.valid("json").sessionID)
-          return c.json(messages)
-        },
-      )
-      .post(
-        "/session_list",
+      .get(
+        "/session",
        describeRoute({
          description: "List all sessions",
          responses: {
@@ -337,7 +199,89 @@ export namespace Server {
        },
      )
      .post(
-        "/session_abort",
+        "/session",
+        describeRoute({
+          description: "Create a new session",
+          responses: {
+            ...ERRORS,
+            200: {
+              description: "Successfully created session",
+              content: {
+                "application/json": {
+                  schema: resolver(Session.Info),
+                },
+              },
+            },
+          },
+        }),
+        async (c) => {
+          const session = await Session.create()
+          return c.json(session)
+        },
+      )
+      .delete(
+        "/session/:id",
+        describeRoute({
+          description: "Delete a session and all its data",
+          responses: {
+            200: {
+              description: "Successfully deleted session",
+              content: {
+                "application/json": {
+                  schema: resolver(z.boolean()),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "param",
+          z.object({
+            id: z.string(),
+          }),
+        ),
+        async (c) => {
+          await Session.remove(c.req.valid("param").id)
+          return c.json(true)
+        },
+      )
+      .post(
+        "/session/:id/init",
+        describeRoute({
+          description: "Analyze the app and create an AGENTS.md file",
+          responses: {
+            200: {
+              description: "200",
+              content: {
+                "application/json": {
+                  schema: resolver(z.boolean()),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "param",
+          z.object({
+            id: z.string().openapi({ description: "Session ID" }),
+          }),
+        ),
+        zValidator(
+          "json",
+          z.object({
+            providerID: z.string(),
+            modelID: z.string(),
+          }),
+        ),
+        async (c) => {
+          const sessionID = c.req.valid("param").id
+          const body = c.req.valid("json")
+          await Session.initialize({ ...body, sessionID })
+          return c.json(true)
+        },
+      )
+      .post(
+        "/session/:id/abort",
        describeRoute({
          description: "Abort a session",
          responses: {
@@ -352,23 +296,78 @@ export namespace Server {
          },
        }),
        zValidator(
-          "json",
+          "param",
          z.object({
-            sessionID: z.string(),
+            id: z.string(),
          }),
        ),
        async (c) => {
-          const body = c.req.valid("json")
-          return c.json(Session.abort(body.sessionID))
+          return c.json(Session.abort(c.req.valid("param").id))
        },
      )
      .post(
-        "/session_summarize",
+        "/session/:id/share",
+        describeRoute({
+          description: "Share a session",
+          responses: {
+            200: {
+              description: "Successfully shared session",
+              content: {
+                "application/json": {
+                  schema: resolver(Session.Info),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "param",
+          z.object({
+            id: z.string(),
+          }),
+        ),
+        async (c) => {
+          const id = c.req.valid("param").id
+          await Session.share(id)
+          const session = await Session.get(id)
+          return c.json(session)
+        },
+      )
+      .delete(
+        "/session/:id/share",
+        describeRoute({
+          description: "Unshare the session",
+          responses: {
+            200: {
+              description: "Successfully unshared session",
+              content: {
+                "application/json": {
+                  schema: resolver(Session.Info),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "param",
+          z.object({
+            id: z.string(),
+          }),
+        ),
+        async (c) => {
+          const id = c.req.valid("param").id
+          await Session.unshare(id)
+          const session = await Session.get(id)
+          return c.json(session)
+        },
+      )
+      .post(
+        "/session/:id/summarize",
        describeRoute({
          description: "Summarize the session",
          responses: {
            200: {
-              description: "Summarize the session",
+              description: "Summarized session",
              content: {
                "application/json": {
                  schema: resolver(z.boolean()),
@@ -377,27 +376,59 @@ export namespace Server {
            },
          },
        }),
+        zValidator(
+          "param",
+          z.object({
+            id: z.string().openapi({ description: "Session ID" }),
+          }),
+        ),
        zValidator(
          "json",
          z.object({
-            sessionID: z.string(),
            providerID: z.string(),
            modelID: z.string(),
          }),
        ),
        async (c) => {
+          const id = c.req.valid("param").id
          const body = c.req.valid("json")
-          await Session.summarize(body)
+          await Session.summarize({ ...body, sessionID: id })
          return c.json(true)
        },
      )
-      .post(
-        "/session_chat",
+      .get(
+        "/session/:id/message",
        describeRoute({
-          description: "Chat with a model",
+          description: "List messages for a session",
          responses: {
            200: {
-              description: "Chat with a model",
+              description: "List of messages",
+              content: {
+                "application/json": {
+                  schema: resolver(Message.Info.array()),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "param",
+          z.object({
+            id: z.string().openapi({ description: "Session ID" }),
+          }),
+        ),
+        async (c) => {
+          const messages = await Session.messages(c.req.valid("param").id)
+          return c.json(messages)
+        },
+      )
+      .post(
+        "/session/:id/message",
+        describeRoute({
+          description: "Create and send a new message to a session",
+          responses: {
+            200: {
+              description: "Created message",
              content: {
                "application/json": {
                  schema: resolver(Message.Info),
@@ -406,23 +437,29 @@ export namespace Server {
            },
          },
        }),
+        zValidator(
+          "param",
+          z.object({
+            id: z.string().openapi({ description: "Session ID" }),
+          }),
+        ),
        zValidator(
          "json",
          z.object({
-            sessionID: z.string(),
            providerID: z.string(),
            modelID: z.string(),
-            parts: Message.Part.array(),
+            parts: Message.MessagePart.array(),
          }),
        ),
        async (c) => {
+          const sessionID = c.req.valid("param").id
          const body = c.req.valid("json")
-          const msg = await Session.chat(body)
+          const msg = await Session.chat({ ...body, sessionID })
          return c.json(msg)
        },
      )
-      .post(
-        "/provider_list",
+      .get(
+        "/config/providers",
        describeRoute({
          description: "List all providers",
          responses: {
@@ -454,8 +491,8 @@ export namespace Server {
          })
        },
      )
-      .post(
-        "/file_search",
+      .get(
+        "/file",
        describeRoute({
          description: "Search for files",
          responses: {
@@ -470,41 +507,22 @@ export namespace Server {
          },
        }),
        zValidator(
-          "json",
+          "query",
          z.object({
            query: z.string(),
          }),
        ),
        async (c) => {
-          const body = c.req.valid("json")
+          const query = c.req.valid("query").query
          const app = App.info()
          const result = await Ripgrep.files({
            cwd: app.path.cwd,
-            query: body.query,
+            query,
            limit: 10,
          })
          return c.json(result)
        },
      )
-      .post(
-        "installation_info",
-        describeRoute({
-          description: "Get installation info",
-          responses: {
-            200: {
-              description: "Get installation info",
-              content: {
-                "application/json": {
-                  schema: resolver(Installation.Info),
-                },
-              },
-            },
-          },
-        }),
-        async (c) => {
-          return c.json(Installation.info())
-        },
-      )

    return result
  }
@@ -524,10 +542,10 @@ export namespace Server {
    return result
  }

-  export function listen() {
+  export function listen(opts: { port: number; hostname: string }) {
    const server = Bun.serve({
-      port: 0,
-      hostname: "0.0.0.0",
+      port: opts.port,
+      hostname: opts.hostname,
      idleTimeout: 0,
      fetch: app().fetch,
    })
@@ -1,19 +0,0 @@
-import { App } from "../app/app"
-import { Filesystem } from "../util/filesystem"
-
-export namespace SessionContext {
-  const FILES = [
-    "AGENTS.md",
-    "CLAUDE.md",
-    "CONTEXT.md", // deprecated
-  ]
-  export async function find() {
-    const { cwd, root } = App.info().path
-    const found = []
-    for (const item of FILES) {
-      const matches = await Filesystem.findUp(item, cwd, root)
-      found.push(...matches.map((x) => Bun.file(x).text()))
-    }
-    return Promise.all(found).then((parts) => parts.join("\n\n"))
-  }
-}
@@ -14,6 +14,7 @@ import {
  type CoreMessage,
  type UIMessage,
  type ProviderMetadata,
+  wrapLanguageModel,
 } from "ai"
 import { z, ZodSchema } from "zod"
 import { Decimal } from "decimal.js"
@@ -54,14 +55,18 @@ export namespace Session {
      }),
    })
    .openapi({
-      ref: "session.info",
+      ref: "Session",
    })
  export type Info = z.output<typeof Info>

-  export const ShareInfo = z.object({
-    secret: z.string(),
-    url: z.string(),
-  })
+  export const ShareInfo = z
+    .object({
+      secret: z.string(),
+      url: z.string(),
+    })
+    .openapi({
+      ref: "SessionShare",
+    })
  export type ShareInfo = z.output<typeof ShareInfo>

  export const Event = {
@@ -71,6 +76,18 @@ export namespace Session {
        info: Info,
      }),
    ),
+    Deleted: Bus.event(
+      "session.deleted",
+      z.object({
+        info: Info,
+      }),
+    ),
+    Idle: Bus.event(
+      "session.idle",
+      z.object({
+        sessionID: z.string(),
+      }),
+    ),
    Error: Bus.event(
      "session.error",
      z.object({
@@ -159,6 +176,14 @@ export namespace Session {
    return share
  }

+  export async function unshare(id: string) {
+    await Storage.remove("session/share/" + id)
+    await update(id, (draft) => {
+      draft.share = undefined
+    })
+    await Share.remove(id)
+  }
+
  export async function update(id: string, editor: (session: Info) => void) {
    const { sessions } = state()
    const session = await get(id)
@@ -197,6 +222,17 @@ export namespace Session {
    }
  }

+  export async function children(parentID: string) {
+    const result = [] as Session.Info[]
+    for await (const item of Storage.list("session/info")) {
+      const sessionID = path.basename(item, ".json")
+      const session = await get(sessionID)
+      if (session.parentID !== parentID) continue
+      result.push(session)
+    }
+    return result
+  }
+
  export function abort(sessionID: string) {
    const controller = state().pending.get(sessionID)
    if (!controller) return false
@@ -205,6 +241,28 @@ export namespace Session {
    return true
  }

+  export async function remove(sessionID: string, emitEvent = true) {
+    try {
+      abort(sessionID)
+      const session = await get(sessionID)
+      for (const child of await children(sessionID)) {
+        await remove(child.id, false)
+      }
+      await unshare(sessionID).catch(() => {})
+      await Storage.remove(`session/info/${sessionID}`).catch(() => {})
+      await Storage.removeDir(`session/message/${sessionID}/`).catch(() => {})
+      state().sessions.delete(sessionID)
+      state().messages.delete(sessionID)
+      if (emitEvent) {
+        Bus.publish(Event.Deleted, {
+          info: session,
+        })
+      }
+    } catch (e) {
+      log.error(e)
+    }
+  }
+
  async function updateMessage(msg: Message.Info) {
    await Storage.writeJSON(
      "session/message/" + msg.metadata.sessionID + "/" + msg.id,
@@ -219,7 +277,7 @@ export namespace Session {
    sessionID: string
    providerID: string
    modelID: string
-    parts: Message.Part[]
+    parts: Message.MessagePart[]
    system?: string[]
    tools?: Tool.Info[]
  }) {
@@ -239,7 +297,10 @@ export namespace Session {
      if (
        model.info.limit.context &&
        tokens >
-          (model.info.limit.context - (model.info.limit.output ?? 0)) * 0.9
+          Math.max(
+            (model.info.limit.context - (model.info.limit.output ?? 0)) * 0.9,
+            0,
+          )
      ) {
        await summarize({
          sessionID: input.sessionID,
@@ -277,9 +338,7 @@ export namespace Session {
              parts: toParts(input.parts),
            },
          ]),
-        ].map((msg, i) =>
-          ProviderTransform.message(msg, i, input.providerID, input.modelID),
-        ),
+        ],
        model: model.language,
      })
        .then((result) => {
@@ -426,24 +485,6 @@ export namespace Session {
    }

    let text: Message.TextPart | undefined
-    await Bun.write(
-      "/tmp/message.json",
-      JSON.stringify(
-        [
-          ...system.map(
-            (x): CoreMessage => ({
-              role: "system",
-              content: x,
-            }),
-          ),
-          ...convertToCoreMessages(
-            msgs.map(toUIMessage).filter((x) => x.parts.length > 0),
-          ),
-        ],
-        null,
-        2,
-      ),
-    )
    const result = streamText({
      onStepFinish: async (step) => {
        log.info("step finish", { finishReason: step.finishReason })
@@ -506,6 +547,7 @@ export namespace Session {
      //   return step
      // },
      toolCallStreaming: true,
+      maxTokens: Math.max(0, model.info.limit.output) || undefined,
      abortSignal: abort.signal,
      maxSteps: 1000,
      providerOptions: model.info.options,
@@ -519,12 +561,26 @@ export namespace Session {
        ...convertToCoreMessages(
          msgs.map(toUIMessage).filter((x) => x.parts.length > 0),
        ),
-      ].map((msg, i) =>
-        ProviderTransform.message(msg, i, input.providerID, input.modelID),
-      ),
+      ],
      temperature: model.info.temperature ? 0 : undefined,
      tools: model.info.tool_call === false ? undefined : tools,
-      model: model.language,
+      model: wrapLanguageModel({
+        model: model.language,
+        middleware: [
+          {
+            async transformParams(args) {
+              if (args.type === "stream") {
+                args.params.prompt = ProviderTransform.message(
+                  args.params.prompt,
+                  input.providerID,
+                  input.modelID,
+                )
+              }
+              return args.params
+            },
+          },
+        ],
+      }),
    })
    try {
      for await (const value of result.fullStream) {
@@ -615,6 +671,21 @@ export namespace Session {
            }
            break

+          case "finish":
+            log.info("message finish", {
+              reason: value.finishReason,
+            })
+            const assistant = next.metadata!.assistant!
+            const usage = getUsage(
+              model.info,
+              value.usage,
+              value.providerMetadata,
+            )
+            assistant.cost = usage.cost
+            await updateMessage(next)
+            if (value.finishReason === "length")
+              throw new Message.OutputLengthError({})
+            break
          default:
            l.info("unhandled", {
              type: value.type,
@@ -628,6 +699,9 @@ export namespace Session {
        error: e,
      })
      switch (true) {
+        case Message.OutputLengthError.isInstance(e):
+          next.metadata.error = e
+          break
        case LoadAPIKeyError.isInstance(e):
          next.metadata.error = new Provider.AuthError(
            {
@@ -715,7 +789,9 @@ export namespace Session {
      },
    }
    await updateMessage(next)
-    const result = await generateText({
+
+    let text: Message.TextPart | undefined
+    const result = streamText({
      abortSignal: abort.signal,
      model: model.language,
      messages: [
@@ -736,16 +812,46 @@ export namespace Session {
          ],
        },
      ],
+      onStepFinish: async (step) => {
+        const assistant = next.metadata!.assistant!
+        const usage = getUsage(model.info, step.usage, step.providerMetadata)
+        assistant.cost += usage.cost
+        assistant.tokens = usage.tokens
+        await updateMessage(next)
+        if (text) {
+          Bus.publish(Message.Event.PartUpdated, {
+            part: text,
+            messageID: next.id,
+            sessionID: next.metadata.sessionID,
+          })
+        }
+        text = undefined
+      },
+      async onFinish(input) {
+        const assistant = next.metadata!.assistant!
+        const usage = getUsage(model.info, input.usage, input.providerMetadata)
+        assistant.cost = usage.cost
+        assistant.tokens = usage.tokens
+        next.metadata!.time.completed = Date.now()
+        await updateMessage(next)
+      },
    })
-    next.parts.push({
-      type: "text",
-      text: result.text,
-    })
-    const assistant = next.metadata!.assistant!
-    const usage = getUsage(model.info, result.usage, result.providerMetadata)
-    assistant.cost = usage.cost
-    assistant.tokens = usage.tokens
-    await updateMessage(next)
+
+    for await (const value of result.fullStream) {
+      switch (value.type) {
+        case "text-delta":
+          if (!text) {
+            text = {
+              type: "text",
+              text: value.textDelta,
+            }
+            next.parts.push(text)
+          } else text.text += value.textDelta
+
+          await updateMessage(next)
+          break
+      }
+    }
  }

  function lock(sessionID: string) {
@@ -758,6 +864,9 @@ export namespace Session {
      [Symbol.dispose]() {
        log.info("unlocking", { sessionID })
        state().pending.delete(sessionID)
+        Bus.publish(Event.Idle, {
+          sessionID,
+        })
      },
    }
  }
@@ -773,8 +882,12 @@ export namespace Session {
      reasoning: 0,
      cache: {
        write: (metadata?.["anthropic"]?.["cacheCreationInputTokens"] ??
+          // @ts-expect-error
+          metadata?.["bedrock"]?.["usage"]?.["cacheWriteInputTokens"] ??
          0) as number,
        read: (metadata?.["anthropic"]?.["cacheReadInputTokens"] ??
+          // @ts-expect-error
+          metadata?.["bedrock"]?.["usage"]?.["cacheReadInputTokens"] ??
          0) as number,
      },
    }
@@ -846,7 +959,7 @@ function toUIMessage(msg: Message.Info): UIMessage {
  throw new Error("not implemented")
 }

-function toParts(parts: Message.Part[]): UIMessage["parts"] {
+function toParts(parts: Message.MessagePart[]): UIMessage["parts"] {
  const result: UIMessage["parts"] = []
  for (const part of parts) {
    switch (part.type) {
@@ -4,6 +4,11 @@ import { Provider } from "../provider/provider"
 import { NamedError } from "../util/error"

 export namespace Message {
+  export const OutputLengthError = NamedError.create(
+    "MessageOutputLengthError",
+    z.object({}),
+  )
+
  export const ToolCall = z
    .object({
      state: z.literal("call"),
@@ -13,7 +18,7 @@ export namespace Message {
      args: z.custom<Required<unknown>>(),
    })
    .openapi({
-      ref: "Message.ToolInvocation.ToolCall",
+      ref: "ToolCall",
    })
  export type ToolCall = z.infer<typeof ToolCall>

@@ -26,7 +31,7 @@ export namespace Message {
      args: z.custom<Required<unknown>>(),
    })
    .openapi({
-      ref: "Message.ToolInvocation.ToolPartialCall",
+      ref: "ToolPartialCall",
    })
  export type ToolPartialCall = z.infer<typeof ToolPartialCall>

@@ -40,14 +45,14 @@ export namespace Message {
      result: z.string(),
    })
    .openapi({
-      ref: "Message.ToolInvocation.ToolResult",
+      ref: "ToolResult",
    })
  export type ToolResult = z.infer<typeof ToolResult>

  export const ToolInvocation = z
    .discriminatedUnion("state", [ToolCall, ToolPartialCall, ToolResult])
    .openapi({
-      ref: "Message.ToolInvocation",
+      ref: "ToolInvocation",
    })
  export type ToolInvocation = z.infer<typeof ToolInvocation>

@@ -57,7 +62,7 @@ export namespace Message {
      text: z.string(),
    })
    .openapi({
-      ref: "Message.Part.Text",
+      ref: "TextPart",
    })
  export type TextPart = z.infer<typeof TextPart>

@@ -68,7 +73,7 @@ export namespace Message {
      providerMetadata: z.record(z.any()).optional(),
    })
    .openapi({
-      ref: "Message.Part.Reasoning",
+      ref: "ReasoningPart",
    })
  export type ReasoningPart = z.infer<typeof ReasoningPart>

@@ -78,7 +83,7 @@ export namespace Message {
      toolInvocation: ToolInvocation,
    })
    .openapi({
-      ref: "Message.Part.ToolInvocation",
+      ref: "ToolInvocationPart",
    })
  export type ToolInvocationPart = z.infer<typeof ToolInvocationPart>

@@ -91,7 +96,7 @@ export namespace Message {
      providerMetadata: z.record(z.any()).optional(),
    })
    .openapi({
-      ref: "Message.Part.SourceUrl",
+      ref: "SourceUrlPart",
    })
  export type SourceUrlPart = z.infer<typeof SourceUrlPart>

@@ -103,7 +108,7 @@ export namespace Message {
      url: z.string(),
    })
    .openapi({
-      ref: "Message.Part.File",
+      ref: "FilePart",
    })
  export type FilePart = z.infer<typeof FilePart>

@@ -112,11 +117,11 @@ export namespace Message {
      type: z.literal("step-start"),
    })
    .openapi({
-      ref: "Message.Part.StepStart",
+      ref: "StepStartPart",
    })
  export type StepStartPart = z.infer<typeof StepStartPart>

-  export const Part = z
+  export const MessagePart = z
    .discriminatedUnion("type", [
      TextPart,
      ReasoningPart,
@@ -126,65 +131,68 @@ export namespace Message {
      StepStartPart,
    ])
    .openapi({
-      ref: "Message.Part",
+      ref: "MessagePart",
    })
-  export type Part = z.infer<typeof Part>
+  export type MessagePart = z.infer<typeof MessagePart>

  export const Info = z
    .object({
      id: z.string(),
      role: z.enum(["user", "assistant"]),
-      parts: z.array(Part),
-      metadata: z.object({
-        time: z.object({
-          created: z.number(),
-          completed: z.number().optional(),
-        }),
-        error: z
-          .discriminatedUnion("name", [
-            Provider.AuthError.Schema,
-            NamedError.Unknown.Schema,
-          ])
-          .optional(),
-        sessionID: z.string(),
-        tool: z.record(
-          z.string(),
-          z
+      parts: z.array(MessagePart),
+      metadata: z
+        .object({
+          time: z.object({
+            created: z.number(),
+            completed: z.number().optional(),
+          }),
+          error: z
+            .discriminatedUnion("name", [
+              Provider.AuthError.Schema,
+              NamedError.Unknown.Schema,
+              OutputLengthError.Schema,
+            ])
+            .optional(),
+          sessionID: z.string(),
+          tool: z.record(
+            z.string(),
+            z
+              .object({
+                title: z.string(),
+                time: z.object({
+                  start: z.number(),
+                  end: z.number(),
+                }),
+              })
+              .catchall(z.any()),
+          ),
+          assistant: z
            .object({
-              title: z.string(),
-              time: z.object({
-                start: z.number(),
-                end: z.number(),
+              system: z.string().array(),
+              modelID: z.string(),
+              providerID: z.string(),
+              path: z.object({
+                cwd: z.string(),
+                root: z.string(),
+              }),
+              cost: z.number(),
+              summary: z.boolean().optional(),
+              tokens: z.object({
+                input: z.number(),
+                output: z.number(),
+                reasoning: z.number(),
+                cache: z.object({
+                  read: z.number(),
+                  write: z.number(),
+                }),
              }),
            })
-            .catchall(z.any()),
-        ),
-        assistant: z
-          .object({
-            system: z.string().array(),
-            modelID: z.string(),
-            providerID: z.string(),
-            path: z.object({
-              cwd: z.string(),
-              root: z.string(),
-            }),
-            cost: z.number(),
-            summary: z.boolean().optional(),
-            tokens: z.object({
-              input: z.number(),
-              output: z.number(),
-              reasoning: z.number(),
-              cache: z.object({
-                read: z.number(),
-                write: z.number(),
-              }),
-            }),
-          })
-          .optional(),
-      }),
+            .optional(),
+        })
+        .openapi({ ref: "MessageMetadata" }),
    })
    .openapi({
-      ref: "Message.Info",
+      ref: "Message",
    })
  export type Info = z.infer<typeof Info>

@@ -197,7 +205,11 @@ export namespace Message {
    ),
    PartUpdated: Bus.event(
      "message.part.updated",
-      z.object({ part: Part, sessionID: z.string(), messageID: z.string() }),
+      z.object({
+        part: MessagePart,
+        sessionID: z.string(),
+        messageID: z.string(),
+      }),
    ),
  }
 }
@@ -1,7 +1,11 @@
-You will generate a short title based on the first message a user begins a conversation with
- ensure it is not more than 50 characters long
- the title should be a summary of the user's message
- it should be one line long
- do not use quotes or colons
- the entire text you return will be used as the title
- never return anything that is more than one sentence (one line) long
+Generate a short title based on the first message a user begins a conversation with. CRITICAL: Your response must be EXACTLY one line with NO line breaks, newlines, or multiple sentences.
+
+Requirements:
+- Maximum 50 characters
+- Single line only - NO newlines or line breaks
+- Summary of the user's message
+- No quotes, colons, or special formatting
+- Do not include explanatory text like "summary:" or similar
+- Your entire response becomes the title
+
+IMPORTANT: Return only the title text on a single line. Do not add any explanations, formatting, or additional text.
@@ -1,6 +1,9 @@
 import { App } from "../app/app"
 import { Ripgrep } from "../external/ripgrep"
+import { Global } from "../global"
 import { Filesystem } from "../util/filesystem"
+import path from "path"
+import os from "os"

 import PROMPT_ANTHROPIC from "./prompt/anthropic.txt"
 import PROMPT_ANTHROPIC_SPOOF from "./prompt/anthropic_spoof.txt"
@@ -101,7 +104,17 @@ export namespace SystemPrompt {
      const matches = await Filesystem.findUp(item, cwd, root)
      found.push(...matches.map((x) => Bun.file(x).text()))
    }
-    return Promise.all(found)
+    found.push(
+      Bun.file(path.join(Global.Path.config, "AGENTS.md"))
+        .text()
+        .catch(() => ""),
+    )
+    found.push(
+      Bun.file(path.join(os.homedir(), ".claude", "CLAUDE.md"))
+        .text()
+        .catch(() => ""),
+    )
+    return Promise.all(found).then((result) => result.filter(Boolean))
  }

  export function summarize(providerID: string) {
@@ -1,4 +1,3 @@
-import { App } from "../app/app"
 import { Bus } from "../bus"
 import { Installation } from "../installation"
 import { Session } from "../session"
@@ -11,12 +10,6 @@ export namespace Share {
  let queue: Promise<void> = Promise.resolve()
  const pending = new Map<string, any>()

-  const state = App.state("share", async () => {
-    Bus.subscribe(Storage.Event.Write, async (payload) => {
-      await sync(payload.properties.key, payload.properties.content)
-    })
-  })
-
  export async function sync(key: string, content: any) {
    const [root, ...splits] = key.split("/")
    if (root !== "session") return
@@ -52,8 +45,10 @@ export namespace Share {
      })
  }

-  export async function init() {
-    await state()
+  export function init() {
+    Bus.subscribe(Storage.Event.Write, async (payload) => {
+      await sync(payload.properties.key, payload.properties.content)
+    })
  }

  export const URL =
@@ -70,4 +65,11 @@ export namespace Share {
      .then((x) => x.json())
      .then((x) => x as { url: string; secret: string })
  }
+
+  export async function remove(id: string) {
+    return fetch(`${URL}/share_delete`, {
+      method: "POST",
+      body: JSON.stringify({ id }),
+    }).then((x) => x.json())
+  }
 }
@@ -24,6 +24,16 @@ export namespace Storage {
    }
  })

+  export async function remove(key: string) {
+    const target = path.join(state().dir, key + ".json")
+    await fs.unlink(target).catch(() => {})
+  }
+
+  export async function removeDir(key: string) {
+    const target = path.join(state().dir, key)
+    await fs.rm(target, { recursive: true, force: true }).catch(() => {})
+  }
+
  export async function readJSON<T>(key: string) {
    return Bun.file(path.join(state().dir, key + ".json")).json() as Promise<T>
  }
@@ -63,10 +63,18 @@ export const BashTool = Tool.define({
      metadata: {
        stderr,
        stdout,
+        exit: process.exitCode,
        description: params.description,
        title: params.command,
      },
-      output: stdout.replaceAll(/\x1b\[[0-9;]*m/g, ""),
+      output: [
+        `<stdout>`,
+        stdout ?? "",
+        `</stdout>`,
+        `<stderr>`,
+        stderr ?? "",
+        `</stderr>`,
+      ].join("\n"),
    }
  },
 })
@@ -1,12 +1,18 @@
+// the approaches in this edit tool are sourced from
+// https://github.com/cline/cline/blob/main/evals/diff-edits/diff-apply/diff-06-23-25.ts
+// https://github.com/google-gemini/gemini-cli/blob/main/packages/core/src/utils/editCorrector.ts
+
 import { z } from "zod"
 import * as path from "path"
 import { Tool } from "./tool"
-import { FileTimes } from "./util/file-times"
 import { LSP } from "../lsp"
 import { createTwoFilesPatch } from "diff"
 import { Permission } from "../permission"
 import DESCRIPTION from "./edit.txt"
 import { App } from "../app/app"
+import { File } from "../file"
+import { Bus } from "../bus"
+import { FileTime } from "../file/time"

 export const EditTool = Tool.define({
  id: "edit",
@@ -22,13 +28,17 @@ export const EditTool = Tool.define({
    replaceAll: z
      .boolean()
      .optional()
-      .describe("Replace all occurences of old_string (default false)"),
+      .describe("Replace all occurrences of old_string (default false)"),
  }),
  async execute(params, ctx) {
    if (!params.filePath) {
      throw new Error("filePath is required")
    }

+    if (params.oldString === params.newString) {
+      throw new Error("oldString and newString must be different")
+    }
+
    const app = App.info()
    const filepath = path.isAbsolute(params.filePath)
      ? params.filePath
@@ -51,47 +61,38 @@ export const EditTool = Tool.define({
      if (params.oldString === "") {
        contentNew = params.newString
        await Bun.write(filepath, params.newString)
+        await Bus.publish(File.Event.Edited, {
+          file: filepath,
+        })
        return
      }

      const file = Bun.file(filepath)
-      if (!(await file.exists())) throw new Error(`File ${filepath} not found`)
-      const stats = await file.stat()
+      const stats = await file.stat().catch(() => {})
+      if (!stats) throw new Error(`File ${filepath} not found`)
      if (stats.isDirectory())
        throw new Error(`Path is a directory, not a file: ${filepath}`)
-      await FileTimes.assert(ctx.sessionID, filepath)
+      await FileTime.assert(ctx.sessionID, filepath)
      contentOld = await file.text()
-      const index = contentOld.indexOf(params.oldString)
-      if (index === -1)
-        throw new Error(
-          `oldString not found in file. Make sure it matches exactly, including whitespace and line breaks`,
-        )
-
-      if (params.replaceAll) {
-        contentNew = contentOld.replaceAll(params.oldString, params.newString)
-      }
-
-      if (!params.replaceAll) {
-        const lastIndex = contentOld.lastIndexOf(params.oldString)
-        if (index !== lastIndex)
-          throw new Error(
-            `oldString appears multiple times in the file. Please provide more context to ensure a unique match`,
-          )
-
-        contentNew =
-          contentOld.substring(0, index) +
-          params.newString +
-          contentOld.substring(index + params.oldString.length)
-      }

+      contentNew = replace(
+        contentOld,
+        params.oldString,
+        params.newString,
+        params.replaceAll,
+      )
      await file.write(contentNew)
+      await Bus.publish(File.Event.Edited, {
+        file: filepath,
+      })
+      contentNew = await file.text()
    })()

    const diff = trimDiff(
      createTwoFilesPatch(filepath, filepath, contentOld, contentNew),
    )

-    FileTimes.read(ctx.sessionID, filepath)
+    FileTime.read(ctx.sessionID, filepath)

    let output = ""
    await LSP.touchFile(filepath, true)
@@ -116,6 +117,326 @@ export const EditTool = Tool.define({
  },
 })

+export type Replacer = (
+  content: string,
+  find: string,
+) => Generator<string, void, unknown>
+
+export const SimpleReplacer: Replacer = function* (_content, find) {
+  yield find
+}
+
+export const LineTrimmedReplacer: Replacer = function* (content, find) {
+  const originalLines = content.split("\n")
+  const searchLines = find.split("\n")
+
+  if (searchLines[searchLines.length - 1] === "") {
+    searchLines.pop()
+  }
+
+  for (let i = 0; i <= originalLines.length - searchLines.length; i++) {
+    let matches = true
+
+    for (let j = 0; j < searchLines.length; j++) {
+      const originalTrimmed = originalLines[i + j].trim()
+      const searchTrimmed = searchLines[j].trim()
+
+      if (originalTrimmed !== searchTrimmed) {
+        matches = false
+        break
+      }
+    }
+
+    if (matches) {
+      let matchStartIndex = 0
+      for (let k = 0; k < i; k++) {
+        matchStartIndex += originalLines[k].length + 1
+      }
+
+      let matchEndIndex = matchStartIndex
+      for (let k = 0; k < searchLines.length; k++) {
+        matchEndIndex += originalLines[i + k].length + 1
+      }
+
+      yield content.substring(matchStartIndex, matchEndIndex)
+    }
+  }
+}
+
+export const BlockAnchorReplacer: Replacer = function* (content, find) {
+  const originalLines = content.split("\n")
+  const searchLines = find.split("\n")
+
+  if (searchLines.length < 3) {
+    return
+  }
+
+  if (searchLines[searchLines.length - 1] === "") {
+    searchLines.pop()
+  }
+
+  const firstLineSearch = searchLines[0].trim()
+  const lastLineSearch = searchLines[searchLines.length - 1].trim()
+
+  // Find blocks where first line matches the search first line
+  for (let i = 0; i < originalLines.length; i++) {
+    if (originalLines[i].trim() !== firstLineSearch) {
+      continue
+    }
+
+    // Look for the matching last line after this first line
+    for (let j = i + 2; j < originalLines.length; j++) {
+      if (originalLines[j].trim() === lastLineSearch) {
+        // Found a potential block from i to j
+        let matchStartIndex = 0
+        for (let k = 0; k < i; k++) {
+          matchStartIndex += originalLines[k].length + 1
+        }
+
+        let matchEndIndex = matchStartIndex
+        for (let k = 0; k <= j - i; k++) {
+          matchEndIndex += originalLines[i + k].length
+          if (k < j - i) {
+            matchEndIndex += 1 // Add newline character except for the last line
+          }
+        }
+
+        yield content.substring(matchStartIndex, matchEndIndex)
+        break // Only match the first occurrence of the last line
+      }
+    }
+  }
+}
+
+export const WhitespaceNormalizedReplacer: Replacer = function* (
+  content,
+  find,
+) {
+  const normalizeWhitespace = (text: string) => text.replace(/\s+/g, " ").trim()
+  const normalizedFind = normalizeWhitespace(find)
+
+  // Handle single line matches
+  const lines = content.split("\n")
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    if (normalizeWhitespace(line) === normalizedFind) {
+      yield line
+    }
+
+    // Also check for substring matches within lines
+    const normalizedLine = normalizeWhitespace(line)
+    if (normalizedLine.includes(normalizedFind)) {
+      // Find the actual substring in the original line that matches
+      const words = find.trim().split(/\s+/)
+      if (words.length > 0) {
+        const pattern = words
+          .map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+          .join("\\s+")
+        try {
+          const regex = new RegExp(pattern)
+          const match = line.match(regex)
+          if (match) {
+            yield match[0]
+          }
+        } catch (e) {
+          // Invalid regex pattern, skip
+        }
+      }
+    }
+  }
+
+  // Handle multi-line matches
+  const findLines = find.split("\n")
+  if (findLines.length > 1) {
+    for (let i = 0; i <= lines.length - findLines.length; i++) {
+      const block = lines.slice(i, i + findLines.length)
+      if (normalizeWhitespace(block.join("\n")) === normalizedFind) {
+        yield block.join("\n")
+      }
+    }
+  }
+}
+
+export const IndentationFlexibleReplacer: Replacer = function* (content, find) {
+  const removeIndentation = (text: string) => {
+    const lines = text.split("\n")
+    const nonEmptyLines = lines.filter((line) => line.trim().length > 0)
+    if (nonEmptyLines.length === 0) return text
+
+    const minIndent = Math.min(
+      ...nonEmptyLines.map((line) => {
+        const match = line.match(/^(\s*)/)
+        return match ? match[1].length : 0
+      }),
+    )
+
+    return lines
+      .map((line) => (line.trim().length === 0 ? line : line.slice(minIndent)))
+      .join("\n")
+  }
+
+  const normalizedFind = removeIndentation(find)
+  const contentLines = content.split("\n")
+  const findLines = find.split("\n")
+
+  for (let i = 0; i <= contentLines.length - findLines.length; i++) {
+    const block = contentLines.slice(i, i + findLines.length).join("\n")
+    if (removeIndentation(block) === normalizedFind) {
+      yield block
+    }
+  }
+}
+
+export const EscapeNormalizedReplacer: Replacer = function* (content, find) {
+  const unescapeString = (str: string): string => {
+    return str.replace(/\\(n|t|r|'|"|`|\\|\n|\$)/g, (match, capturedChar) => {
+      switch (capturedChar) {
+        case "n":
+          return "\n"
+        case "t":
+          return "\t"
+        case "r":
+          return "\r"
+        case "'":
+          return "'"
+        case '"':
+          return '"'
+        case "`":
+          return "`"
+        case "\\":
+          return "\\"
+        case "\n":
+          return "\n"
+        case "$":
+          return "$"
+        default:
+          return match
+      }
+    })
+  }
+
+  const unescapedFind = unescapeString(find)
+
+  // Try direct match with unescaped find string
+  if (content.includes(unescapedFind)) {
+    yield unescapedFind
+  }
+
+  // Also try finding escaped versions in content that match unescaped find
+  const lines = content.split("\n")
+  const findLines = unescapedFind.split("\n")
+
+  for (let i = 0; i <= lines.length - findLines.length; i++) {
+    const block = lines.slice(i, i + findLines.length).join("\n")
+    const unescapedBlock = unescapeString(block)
+
+    if (unescapedBlock === unescapedFind) {
+      yield block
+    }
+  }
+}
+
+export const MultiOccurrenceReplacer: Replacer = function* (content, find) {
+  // This replacer yields all exact matches, allowing the replace function
+  // to handle multiple occurrences based on replaceAll parameter
+  let startIndex = 0
+
+  while (true) {
+    const index = content.indexOf(find, startIndex)
+    if (index === -1) break
+
+    yield find
+    startIndex = index + find.length
+  }
+}
+
+export const TrimmedBoundaryReplacer: Replacer = function* (content, find) {
+  const trimmedFind = find.trim()
+
+  if (trimmedFind === find) {
+    // Already trimmed, no point in trying
+    return
+  }
+
+  // Try to find the trimmed version
+  if (content.includes(trimmedFind)) {
+    yield trimmedFind
+  }
+
+  // Also try finding blocks where trimmed content matches
+  const lines = content.split("\n")
+  const findLines = find.split("\n")
+
+  for (let i = 0; i <= lines.length - findLines.length; i++) {
+    const block = lines.slice(i, i + findLines.length).join("\n")
+
+    if (block.trim() === trimmedFind) {
+      yield block
+    }
+  }
+}
+
+export const ContextAwareReplacer: Replacer = function* (content, find) {
+  const findLines = find.split("\n")
+  if (findLines.length < 3) {
+    // Need at least 3 lines to have meaningful context
+    return
+  }
+
+  // Remove trailing empty line if present
+  if (findLines[findLines.length - 1] === "") {
+    findLines.pop()
+  }
+
+  const contentLines = content.split("\n")
+
+  // Extract first and last lines as context anchors
+  const firstLine = findLines[0].trim()
+  const lastLine = findLines[findLines.length - 1].trim()
+
+  // Find blocks that start and end with the context anchors
+  for (let i = 0; i < contentLines.length; i++) {
+    if (contentLines[i].trim() !== firstLine) continue
+
+    // Look for the matching last line
+    for (let j = i + 2; j < contentLines.length; j++) {
+      if (contentLines[j].trim() === lastLine) {
+        // Found a potential context block
+        const blockLines = contentLines.slice(i, j + 1)
+        const block = blockLines.join("\n")
+
+        // Check if the middle content has reasonable similarity
+        // (simple heuristic: at least 50% of non-empty lines should match when trimmed)
+        if (blockLines.length === findLines.length) {
+          let matchingLines = 0
+          let totalNonEmptyLines = 0
+
+          for (let k = 1; k < blockLines.length - 1; k++) {
+            const blockLine = blockLines[k].trim()
+            const findLine = findLines[k].trim()
+
+            if (blockLine.length > 0 || findLine.length > 0) {
+              totalNonEmptyLines++
+              if (blockLine === findLine) {
+                matchingLines++
+              }
+            }
+          }
+
+          if (
+            totalNonEmptyLines === 0 ||
+            matchingLines / totalNonEmptyLines >= 0.5
+          ) {
+            yield block
+            break // Only match the first occurrence
+          }
+        }
+        break
+      }
+    }
+  }
+}
+
 function trimDiff(diff: string): string {
  const lines = diff.split("\n")
  const contentLines = lines.filter(
@@ -151,3 +472,42 @@ function trimDiff(diff: string): string {

  return trimmedLines.join("\n")
 }
+
+export function replace(
+  content: string,
+  oldString: string,
+  newString: string,
+  replaceAll = false,
+): string {
+  if (oldString === newString) {
+    throw new Error("oldString and newString must be different")
+  }
+
+  for (const replacer of [
+    SimpleReplacer,
+    LineTrimmedReplacer,
+    BlockAnchorReplacer,
+    WhitespaceNormalizedReplacer,
+    IndentationFlexibleReplacer,
+    EscapeNormalizedReplacer,
+    TrimmedBoundaryReplacer,
+    ContextAwareReplacer,
+    MultiOccurrenceReplacer,
+  ]) {
+    for (const search of replacer(content, oldString)) {
+      const index = content.indexOf(search)
+      if (index === -1) continue
+      if (replaceAll) {
+        return content.replaceAll(search, newString)
+      }
+      const lastIndex = content.lastIndexOf(search)
+      if (index !== lastIndex) continue
+      return (
+        content.substring(0, index) +
+        newString +
+        content.substring(index + search.length)
+      )
+    }
+  }
+  throw new Error("oldString not found in content or was found multiple times")
+}
@@ -3,6 +3,7 @@ import path from "path"
 import { Tool } from "./tool"
 import { App } from "../app/app"
 import DESCRIPTION from "./glob.txt"
+import { Ripgrep } from "../external/ripgrep"

 export const GlobTool = Tool.define({
  id: "glob",
@@ -24,10 +25,12 @@ export const GlobTool = Tool.define({
      : path.resolve(app.path.cwd, search)

    const limit = 100
-    const glob = new Bun.Glob(params.pattern)
    const files = []
    let truncated = false
-    for await (const file of glob.scan({ cwd: search, dot: true })) {
+    for (const file of await Ripgrep.files({
+      cwd: search,
+      glob: params.pattern,
+    })) {
      if (files.length >= limit) {
        truncated = true
        break
@@ -10,7 +10,7 @@ To make multiple file edits, provide the following:
 2. edits: An array of edit operations to perform, where each edit contains:
   - old_string: The text to replace (must match the file contents exactly, including all whitespace and indentation)
   - new_string: The edited text to replace the old_string
-   - replace_all: Replace all occurences of old_string. This parameter is optional and defaults to false.
+   - replace_all: Replace all occurrences of old_string. This parameter is optional and defaults to false.

 IMPORTANT:
 - All edits are applied in sequence, in the order they are provided
@@ -2,7 +2,7 @@ import { z } from "zod"
 import * as path from "path"
 import * as fs from "fs/promises"
 import { Tool } from "./tool"
-import { FileTimes } from "./util/file-times"
+import { FileTime } from "../file/time"
 import DESCRIPTION from "./patch.txt"

 const PatchParams = z.object({
@@ -244,7 +244,7 @@ export const PatchTool = Tool.define({
        absPath = path.resolve(process.cwd(), absPath)
      }

-      await FileTimes.assert(ctx.sessionID, absPath)
+      await FileTime.assert(ctx.sessionID, absPath)

      try {
        const stats = await fs.stat(absPath)
@@ -351,7 +351,7 @@ export const PatchTool = Tool.define({
      totalAdditions += additions
      totalRemovals += removals

-      FileTimes.read(ctx.sessionID, absPath)
+      FileTime.read(ctx.sessionID, absPath)
    }

    const result = `Patch applied successfully. ${changedFiles.length} files changed, ${totalAdditions} additions, ${totalRemovals} removals`
@@ -3,7 +3,7 @@ import * as fs from "fs"
 import * as path from "path"
 import { Tool } from "./tool"
 import { LSP } from "../lsp"
-import { FileTimes } from "./util/file-times"
+import { FileTime } from "../file/time"
 import DESCRIPTION from "./read.txt"
 import { App } from "../app/app"

@@ -90,7 +90,7 @@ export const ReadTool = Tool.define({

    // just warms the lsp client
    await LSP.touchFile(filePath, true)
-    FileTimes.read(ctx.sessionID, filePath)
+    FileTime.read(ctx.sessionID, filePath)

    return {
      output,
@@ -1,11 +1,13 @@
 import { z } from "zod"
 import * as path from "path"
 import { Tool } from "./tool"
-import { FileTimes } from "./util/file-times"
 import { LSP } from "../lsp"
 import { Permission } from "../permission"
 import DESCRIPTION from "./write.txt"
 import { App } from "../app/app"
+import { Bus } from "../bus"
+import { File } from "../file"
+import { FileTime } from "../file/time"

 export const WriteTool = Tool.define({
  id: "write",
@@ -26,7 +28,7 @@ export const WriteTool = Tool.define({

    const file = Bun.file(filepath)
    const exists = await file.exists()
-    if (exists) await FileTimes.assert(ctx.sessionID, filepath)
+    if (exists) await FileTime.assert(ctx.sessionID, filepath)

    await Permission.ask({
      id: "write",
@@ -42,7 +44,10 @@ export const WriteTool = Tool.define({
    })

    await Bun.write(filepath, params.content)
-    FileTimes.read(ctx.sessionID, filepath)
+    await Bus.publish(File.Event.Edited, {
+      file: filepath,
+    })
+    FileTime.read(ctx.sessionID, filepath)

    let output = ""
    await LSP.touchFile(filepath, true)
@@ -8,4 +8,3 @@ export function lazy<T>(fn: () => T) {
    return value as T
  }
 }
-
@@ -19,7 +19,10 @@ export namespace Log {
    await fs.mkdir(dir, { recursive: true })
    cleanup(dir)
    if (options.print) return
-    logpath = path.join(dir, new Date().toISOString().split(".")[0] + ".log")
+    logpath = path.join(
+      dir,
+      new Date().toISOString().split(".")[0].replace(/:/g, "") + ".log",
+    )
    const logfile = Bun.file(logpath)
    await fs.truncate(logpath).catch(() => {})
    const writer = logfile.writer()
@@ -6,4 +6,4 @@
 /// <reference path="../../sst-env.d.ts" />

 import "sst"
-export {}
+export {}
@@ -0,0 +1,413 @@
+import { describe, expect, test } from "bun:test"
+import { replace } from "../../src/tool/edit"
+
+interface TestCase {
+  content: string
+  find: string
+  replace: string
+  all?: boolean
+  fail?: boolean
+}
+
+const testCases: TestCase[] = [
+  // SimpleReplacer cases
+  {
+    content: ["function hello() {", '  console.log("world");', "}"].join("\n"),
+    find: 'console.log("world");',
+    replace: 'console.log("universe");',
+  },
+  {
+    content: [
+      "if (condition) {",
+      "  doSomething();",
+      "  doSomethingElse();",
+      "}",
+    ].join("\n"),
+    find: ["  doSomething();", "  doSomethingElse();"].join("\n"),
+    replace: ["  doNewThing();", "  doAnotherThing();"].join("\n"),
+  },
+
+  // LineTrimmedReplacer cases
+  {
+    content: ["function test() {", '    console.log("hello");', "}"].join("\n"),
+    find: 'console.log("hello");',
+    replace: 'console.log("goodbye");',
+  },
+  {
+    content: ["const x = 5;   ", "const y = 10;"].join("\n"),
+    find: "const x = 5;",
+    replace: "const x = 15;",
+  },
+  {
+    content: ["  if (true) {", "    return false;", "  }"].join("\n"),
+    find: ["if (true) {", "return false;", "}"].join("\n"),
+    replace: ["if (false) {", "return true;", "}"].join("\n"),
+  },
+
+  // BlockAnchorReplacer cases
+  {
+    content: [
+      "function calculate(a, b) {",
+      "  const temp = a + b;",
+      "  const result = temp * 2;",
+      "  return result;",
+      "}",
+    ].join("\n"),
+    find: [
+      "function calculate(a, b) {",
+      "  // different middle content",
+      "  return result;",
+      "}",
+    ].join("\n"),
+    replace: ["function calculate(a, b) {", "  return a * b * 2;", "}"].join(
+      "\n",
+    ),
+  },
+  {
+    content: [
+      "class MyClass {",
+      "  constructor() {",
+      "    this.value = 0;",
+      "  }",
+      "  ",
+      "  getValue() {",
+      "    return this.value;",
+      "  }",
+      "}",
+    ].join("\n"),
+    find: ["class MyClass {", "  // different implementation", "}"].join("\n"),
+    replace: [
+      "class MyClass {",
+      "  constructor() {",
+      "    this.value = 42;",
+      "  }",
+      "}",
+    ].join("\n"),
+  },
+
+  // WhitespaceNormalizedReplacer cases
+  {
+    content: ["function test() {", '\tconsole.log("hello");', "}"].join("\n"),
+    find: '  console.log("hello");',
+    replace: '  console.log("world");',
+  },
+  {
+    content: "const   x    =     5;",
+    find: "const x = 5;",
+    replace: "const x = 10;",
+  },
+  {
+    content: "if\t(  condition\t) {",
+    find: "if ( condition ) {",
+    replace: "if (newCondition) {",
+  },
+
+  // IndentationFlexibleReplacer cases
+  {
+    content: [
+      "    function nested() {",
+      '      console.log("deeply nested");',
+      "      return true;",
+      "    }",
+    ].join("\n"),
+    find: [
+      "function nested() {",
+      '  console.log("deeply nested");',
+      "  return true;",
+      "}",
+    ].join("\n"),
+    replace: [
+      "function nested() {",
+      '  console.log("updated");',
+      "  return false;",
+      "}",
+    ].join("\n"),
+  },
+  {
+    content: [
+      "  if (true) {",
+      '    console.log("level 1");',
+      '      console.log("level 2");',
+      "  }",
+    ].join("\n"),
+    find: [
+      "if (true) {",
+      'console.log("level 1");',
+      '  console.log("level 2");',
+      "}",
+    ].join("\n"),
+    replace: ["if (true) {", 'console.log("updated");', "}"].join("\n"),
+  },
+
+  // replaceAll option cases
+  {
+    content: [
+      'console.log("test");',
+      'console.log("test");',
+      'console.log("test");',
+    ].join("\n"),
+    find: 'console.log("test");',
+    replace: 'console.log("updated");',
+    all: true,
+  },
+  {
+    content: ['console.log("test");', 'console.log("test");'].join("\n"),
+    find: 'console.log("test");',
+    replace: 'console.log("updated");',
+    all: false,
+  },
+
+  // Error cases
+  {
+    content: 'console.log("hello");',
+    find: "nonexistent string",
+    replace: "updated",
+    fail: true,
+  },
+  {
+    content: ["test", "test", "different content", "test"].join("\n"),
+    find: "test",
+    replace: "updated",
+    all: false,
+    fail: true,
+  },
+
+  // Edge cases
+  {
+    content: "",
+    find: "",
+    replace: "new content",
+  },
+  {
+    content: "const regex = /[.*+?^${}()|[\\\\]\\\\\\\\]/g;",
+    find: "/[.*+?^${}()|[\\\\]\\\\\\\\]/g",
+    replace: "/\\\\w+/g",
+  },
+  {
+    content: 'const message = "Hello 世界! 🌍";',
+    find: "Hello 世界! 🌍",
+    replace: "Hello World! 🌎",
+  },
+
+  // EscapeNormalizedReplacer cases
+  {
+    content: 'console.log("Hello\nWorld");',
+    find: 'console.log("Hello\\nWorld");',
+    replace: 'console.log("Hello\nUniverse");',
+  },
+  {
+    content: "const str = 'It's working';",
+    find: "const str = 'It\\'s working';",
+    replace: "const str = 'It's fixed';",
+  },
+  {
+    content: "const template = `Hello ${name}`;",
+    find: "const template = `Hello \\${name}`;",
+    replace: "const template = `Hi ${name}`;",
+  },
+  {
+    content: "const path = 'C:\\Users\\test';",
+    find: "const path = 'C:\\\\Users\\\\test';",
+    replace: "const path = 'C:\\Users\\admin';",
+  },
+
+  // MultiOccurrenceReplacer cases (with replaceAll)
+  {
+    content: ["debug('start');", "debug('middle');", "debug('end');"].join(
+      "\n",
+    ),
+    find: "debug",
+    replace: "log",
+    all: true,
+  },
+  {
+    content: "const x = 1; const y = 1; const z = 1;",
+    find: "1",
+    replace: "2",
+    all: true,
+  },
+
+  // TrimmedBoundaryReplacer cases
+  {
+    content: ["  function test() {", "    return true;", "  }"].join("\n"),
+    find: ["function test() {", "  return true;", "}"].join("\n"),
+    replace: ["function test() {", "  return false;", "}"].join("\n"),
+  },
+  {
+    content: "\n  const value = 42;  \n",
+    find: "const value = 42;",
+    replace: "const value = 24;",
+  },
+  {
+    content: ["", "  if (condition) {", "    doSomething();", "  }", ""].join(
+      "\n",
+    ),
+    find: ["if (condition) {", "  doSomething();", "}"].join("\n"),
+    replace: ["if (condition) {", "  doNothing();", "}"].join("\n"),
+  },
+
+  // ContextAwareReplacer cases
+  {
+    content: [
+      "function calculate(a, b) {",
+      "  const temp = a + b;",
+      "  const result = temp * 2;",
+      "  return result;",
+      "}",
+    ].join("\n"),
+    find: [
+      "function calculate(a, b) {",
+      "  // some different content here",
+      "  // more different content",
+      "  return result;",
+      "}",
+    ].join("\n"),
+    replace: ["function calculate(a, b) {", "  return (a + b) * 2;", "}"].join(
+      "\n",
+    ),
+  },
+  {
+    content: [
+      "class TestClass {",
+      "  constructor() {",
+      "    this.value = 0;",
+      "  }",
+      "  ",
+      "  method() {",
+      "    return this.value;",
+      "  }",
+      "}",
+    ].join("\n"),
+    find: [
+      "class TestClass {",
+      "  // different implementation",
+      "  // with multiple lines",
+      "}",
+    ].join("\n"),
+    replace: ["class TestClass {", "  getValue() { return 42; }", "}"].join(
+      "\n",
+    ),
+  },
+
+  // Combined edge cases for new replacers
+  {
+    content: '\tconsole.log("test");\t',
+    find: 'console.log("test");',
+    replace: 'console.log("updated");',
+  },
+  {
+    content: ["  ", "function test() {", "  return 'value';", "}", "  "].join(
+      "\n",
+    ),
+    find: ["function test() {", "return 'value';", "}"].join("\n"),
+    replace: ["function test() {", "return 'new value';", "}"].join("\n"),
+  },
+
+  // Test for same oldString and newString (should fail)
+  {
+    content: 'console.log("test");',
+    find: 'console.log("test");',
+    replace: 'console.log("test");',
+    fail: true,
+  },
+
+  // Additional tests for fixes made
+
+  // WhitespaceNormalizedReplacer - test regex special characters that could cause errors
+  {
+    content: 'const pattern = "test[123]";',
+    find: "test[123]",
+    replace: "test[456]",
+  },
+  {
+    content: 'const regex = "^start.*end$";',
+    find: "^start.*end$",
+    replace: "^begin.*finish$",
+  },
+
+  // EscapeNormalizedReplacer - test single backslash vs double backslash
+  {
+    content: 'const path = "C:\\Users";',
+    find: 'const path = "C:\\Users";',
+    replace: 'const path = "D:\\Users";',
+  },
+  {
+    content: 'console.log("Line1\\nLine2");',
+    find: 'console.log("Line1\\nLine2");',
+    replace: 'console.log("First\\nSecond");',
+  },
+
+  // BlockAnchorReplacer - test edge case with exact newline boundaries
+  {
+    content: ["function test() {", "  return true;", "}"].join("\n"),
+    find: ["function test() {", "  // middle", "}"].join("\n"),
+    replace: ["function test() {", "  return false;", "}"].join("\n"),
+  },
+
+  // ContextAwareReplacer - test with trailing newline in find string
+  {
+    content: [
+      "class Test {",
+      "  method1() {",
+      "    return 1;",
+      "  }",
+      "}",
+    ].join("\n"),
+    find: [
+      "class Test {",
+      "  // different content",
+      "}",
+      "", // trailing empty line
+    ].join("\n"),
+    replace: ["class Test {", "  method2() { return 2; }", "}"].join("\n"),
+  },
+
+  // Test validation for empty strings with same oldString and newString
+  {
+    content: "",
+    find: "",
+    replace: "",
+    fail: true,
+  },
+
+  // Test multiple occurrences with replaceAll=false (should fail)
+  {
+    content: ["const a = 1;", "const b = 1;", "const c = 1;"].join("\n"),
+    find: "= 1",
+    replace: "= 2",
+    all: false,
+    fail: true,
+  },
+
+  // Test whitespace normalization with multiple spaces and tabs mixed
+  {
+    content: "if\t \t( \tcondition\t )\t{",
+    find: "if ( condition ) {",
+    replace: "if (newCondition) {",
+  },
+
+  // Test escape sequences in template literals
+  {
+    content: "const msg = `Hello\\tWorld`;",
+    find: "const msg = `Hello\\tWorld`;",
+    replace: "const msg = `Hi\\tWorld`;",
+  },
+]
+
+describe("EditTool Replacers", () => {
+  test.each(testCases)("case %#", (testCase) => {
+    if (testCase.fail) {
+      expect(() => {
+        replace(testCase.content, testCase.find, testCase.replace, testCase.all)
+      }).toThrow()
+    } else {
+      const result = replace(
+        testCase.content,
+        testCase.find,
+        testCase.replace,
+        testCase.all,
+      )
+      expect(result).toContain(testCase.replace)
+    }
+  })
+})
@@ -14,7 +14,7 @@ describe("tool.glob", () => {
    await App.provide({ cwd: process.cwd() }, async () => {
      let result = await GlobTool.execute(
        {
-          pattern: "./node_modules/**/*",
+          pattern: "../../node_modules/**/*",
          path: undefined,
        },
        ctx,
@@ -33,7 +33,7 @@ describe("tool.glob", () => {
      )
      expect(result.metadata).toMatchObject({
        truncated: false,
-        count: 2,
+        count: 3,
      })
    })
  })
@@ -0,0 +1 @@
+opencode-test
@@ -0,0 +1,25 @@
+# TUI Agent Guidelines
+
+## Build/Test Commands
+
+- **Build**: `go build ./cmd/opencode` (builds main binary)
+- **Test**: `go test ./...` (runs all tests)
+- **Single test**: `go test ./internal/theme -run TestLoadThemesFromJSON` (specific test)
+- **Release build**: Uses `.goreleaser.yml` configuration
+
+## Code Style
+
+- **Language**: Go 1.24+ with standard formatting (`gofmt`)
+- **Imports**: Group standard, third-party, local packages with blank lines
+- **Naming**: Go conventions - PascalCase exports, camelCase private, ALL_CAPS constants
+- **Error handling**: Return errors explicitly, use `fmt.Errorf` for wrapping
+- **Structs**: Define clear interfaces, embed when appropriate
+- **Testing**: Use table-driven tests, `t.TempDir()` for file operations
+
+## Architecture
+
+- **TUI Framework**: Bubble Tea v2 with Lipgloss v2 for styling
+- **Client**: Generated OpenAPI client communicates with TypeScript server
+- **Components**: Reusable UI components in `internal/components/`
+- **Themes**: JSON-based theming system with override hierarchy
+- **State**: Centralized app state with message passing
@@ -9,6 +9,8 @@ import (
 	"strings"

 	tea "github.com/charmbracelet/bubbletea/v2"
+	"github.com/sst/opencode-sdk-go"
+	"github.com/sst/opencode-sdk-go/option"
 	"github.com/sst/opencode/internal/app"
 	"github.com/sst/opencode/internal/tui"
 	"github.com/sst/opencode/pkg/client"
@@ -25,8 +27,12 @@ func main() {
 	url := os.Getenv("OPENCODE_SERVER")

 	appInfoStr := os.Getenv("OPENCODE_APP_INFO")
-	var appInfo client.AppInfo
-	json.Unmarshal([]byte(appInfoStr), &appInfo)
+	var appInfo opencode.App
+	err := json.Unmarshal([]byte(appInfoStr), &appInfo)
+	if err != nil {
+		slog.Error("Failed to unmarshal app info", "error", err)
+		os.Exit(1)
+	}

 	logfile := filepath.Join(appInfo.Path.Data, "log", "tui.log")
 	if _, err := os.Stat(filepath.Dir(logfile)); os.IsNotExist(err) {
@@ -45,7 +51,12 @@ func main() {
 	logger := slog.New(slog.NewTextHandler(file, &slog.HandlerOptions{Level: slog.LevelDebug}))
 	slog.SetDefault(logger)

-	httpClient, err := client.NewClientWithResponses(url)
+	slog.Debug("TUI launched", "app", appInfo)
+
+	httpClient := opencode.NewClient(
+		option.WithBaseURL(url),
+	)
+
 	if err != nil {
 		slog.Error("Failed to create client", "error", err)
 		os.Exit(1)
@@ -67,13 +78,7 @@ func main() {
 		tea.WithMouseCellMotion(),
 	)

-	eventClient, err := client.NewClient(url)
-	if err != nil {
-		slog.Error("Failed to create event client", "error", err)
-		os.Exit(1)
-	}
-
-	evts, err := eventClient.Event(ctx)
+	evts, err := client.Event(httpClient, url, ctx)
 	if err != nil {
 		slog.Error("Failed to subscribe to events", "error", err)
 		os.Exit(1)
@@ -16,6 +16,8 @@ require (
 	github.com/muesli/termenv v0.16.0
 	github.com/oapi-codegen/runtime v1.1.1
 	github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3
+	github.com/sst/opencode-sdk-go v0.1.0-alpha.5
+	github.com/tidwall/gjson v1.14.4
 	rsc.io/qr v0.2.0
 )

@@ -48,6 +50,9 @@ require (
 	github.com/sosodev/duration v1.3.1 // indirect
 	github.com/speakeasy-api/openapi-overlay v0.9.0 // indirect
 	github.com/spf13/cobra v1.9.1 // indirect
+	github.com/tidwall/match v1.1.1 // indirect
+	github.com/tidwall/pretty v1.2.1 // indirect
+	github.com/tidwall/sjson v1.2.5 // indirect
 	github.com/vmware-labs/yaml-jsonpath v0.3.2 // indirect
 	golang.org/x/mod v0.24.0 // indirect
 	golang.org/x/tools v0.31.0 // indirect
@@ -68,10 +73,10 @@ require (
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/lucasb-eyer/go-colorful v1.2.0
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-runewidth v0.0.16 // indirect
+	github.com/mattn/go-runewidth v0.0.16
 	github.com/microcosm-cc/bluemonday v1.0.27 // indirect
 	github.com/muesli/cancelreader v0.2.2 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/rivo/uniseg v0.4.7
 	github.com/rogpeppe/go-internal v1.14.1 // indirect
 	github.com/spf13/pflag v1.0.6 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
@@ -191,6 +191,8 @@ github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wx
 github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
 github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad/go.mod h1:qLr4V1qq6nMqFKkMo8ZTx3f+BZEkzsRUY10Xsm2mwU0=
+github.com/sst/opencode-sdk-go v0.1.0-alpha.5 h1:iZjdSHLo6jOMjUbDH5JWi+44v76yNbEktsRqG/Qxrco=
+github.com/sst/opencode-sdk-go v0.1.0-alpha.5/go.mod h1:uagorfAHZsVy6vf0xY6TlQraM4uCILdZ5tKKhl1oToM=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v0.0.0-20161117074351-18a02ba4a312/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
@@ -198,6 +200,16 @@ github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81P
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/tidwall/gjson v1.14.2/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
+github.com/tidwall/gjson v1.14.4 h1:uo0p8EbA09J7RQaflQ1aBRffTR7xedD2bcIVSYxLnkM=
+github.com/tidwall/gjson v1.14.4/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
+github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
+github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
+github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
+github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY=
+github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28=
 github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU=
 github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
 github.com/vmware-labs/yaml-jsonpath v0.3.2 h1:/5QKeCBGdsInyDCyVNLbXyilb61MXGi9NP674f9Hobk=
@@ -6,37 +6,40 @@ import (
 	"path/filepath"
 	"sort"
 	"strings"
+	"time"

 	"log/slog"

 	tea "github.com/charmbracelet/bubbletea/v2"
+	"github.com/sst/opencode-sdk-go"
 	"github.com/sst/opencode/internal/commands"
+	"github.com/sst/opencode/internal/components/toast"
 	"github.com/sst/opencode/internal/config"
+	"github.com/sst/opencode/internal/styles"
 	"github.com/sst/opencode/internal/theme"
 	"github.com/sst/opencode/internal/util"
-	"github.com/sst/opencode/pkg/client"
 )

 var RootPath string

 type App struct {
-	Info      client.AppInfo
+	Info      opencode.App
 	Version   string
 	StatePath string
-	Config    *client.ConfigInfo
-	Client    *client.ClientWithResponses
+	Config    *opencode.Config
+	Client    *opencode.Client
 	State     *config.State
-	Provider  *client.ProviderInfo
-	Model     *client.ModelInfo
-	Session   *client.SessionInfo
-	Messages  []client.MessageInfo
+	Provider  *opencode.Provider
+	Model     *opencode.Model
+	Session   *opencode.Session
+	Messages  []opencode.Message
 	Commands  commands.CommandRegistry
 }

-type SessionSelectedMsg = *client.SessionInfo
+type SessionSelectedMsg = *opencode.Session
 type ModelSelectedMsg struct {
-	Provider client.ProviderInfo
-	Model    client.ModelInfo
+	Provider opencode.Provider
+	Model    opencode.Model
 }
 type SessionClearedMsg struct{}
 type CompactSessionMsg struct{}
@@ -44,29 +47,28 @@ type SendMsg struct {
 	Text        string
 	Attachments []Attachment
 }
-type CompletionDialogTriggerdMsg struct {
+type CompletionDialogTriggeredMsg struct {
 	InitialValue string
 }
+type OptimisticMessageAddedMsg struct {
+	Message opencode.Message
+}

 func New(
 	ctx context.Context,
 	version string,
-	appInfo client.AppInfo,
-	httpClient *client.ClientWithResponses,
+	appInfo opencode.App,
+	httpClient *opencode.Client,
 ) (*App, error) {
 	RootPath = appInfo.Path.Root

-	configResponse, err := httpClient.PostConfigGetWithResponse(ctx)
+	configInfo, err := httpClient.Config.Get(ctx)
 	if err != nil {
 		return nil, err
 	}
-	configInfo := configResponse.JSON200
-	if configInfo.Keybinds == nil {
-		leader := "ctrl+x"
-		keybinds := client.ConfigKeybinds{
-			Leader: &leader,
-		}
-		configInfo.Keybinds = &keybinds
+
+	if configInfo.Keybinds.Leader == "" {
+		configInfo.Keybinds.Leader = "ctrl+x"
 	}

 	appStatePath := filepath.Join(appInfo.Path.State, "tui")
@@ -76,16 +78,31 @@ func New(
 		config.SaveState(appStatePath, appState)
 	}

-	if configInfo.Theme != nil {
-		appState.Theme = *configInfo.Theme
+	if configInfo.Theme != "" {
+		appState.Theme = configInfo.Theme
 	}
-	if configInfo.Model != nil {
-		splits := strings.Split(*configInfo.Model, "/")
+
+	if configInfo.Model != "" {
+		splits := strings.Split(configInfo.Model, "/")
 		appState.Provider = splits[0]
 		appState.Model = strings.Join(splits[1:], "/")
 	}

+	if err := theme.LoadThemesFromDirectories(
+		appInfo.Path.Config,
+		appInfo.Path.Root,
+		appInfo.Path.Cwd,
+	); err != nil {
+		slog.Warn("Failed to load themes from directories", "error", err)
+	}
+
 	if appState.Theme != "" {
+		if appState.Theme == "system" && styles.Terminal != nil {
+			theme.UpdateSystemTheme(
+				styles.Terminal.Background,
+				styles.Terminal.BackgroundIsDark,
+			)
+		}
 		theme.SetTheme(appState.Theme)
 	}

@@ -98,8 +115,8 @@ func New(
 		Config:    configInfo,
 		State:     appState,
 		Client:    httpClient,
-		Session:   &client.SessionInfo{},
-		Messages:  []client.MessageInfo{},
+		Session:   &opencode.Session{},
+		Messages:  []opencode.Message{},
 		Commands:  commands.LoadFromConfig(configInfo),
 	}

@@ -108,19 +125,19 @@ func New(

 func (a *App) InitializeProvider() tea.Cmd {
 	return func() tea.Msg {
-		providersResponse, err := a.Client.PostProviderListWithResponse(context.Background())
+		providersResponse, err := a.Client.Config.Providers(context.Background())
 		if err != nil {
 			slog.Error("Failed to list providers", "error", err)
 			// TODO: notify user
 			return nil
 		}
-		providers := []client.ProviderInfo{}
-		var defaultProvider *client.ProviderInfo
-		var defaultModel *client.ModelInfo
+		providers := providersResponse.Providers
+		var defaultProvider *opencode.Provider
+		var defaultModel *opencode.Model

-		var anthropic *client.ProviderInfo
-		for _, provider := range providersResponse.JSON200.Providers {
-			if provider.Id == "anthropic" {
+		var anthropic *opencode.Provider
+		for _, provider := range providers {
+			if provider.ID == "anthropic" {
 				anthropic = &provider
 			}
 		}
@@ -131,7 +148,7 @@ func (a *App) InitializeProvider() tea.Cmd {
 			defaultModel = getDefaultModel(providersResponse, *anthropic)
 		}

-		for _, provider := range providersResponse.JSON200.Providers {
+		for _, provider := range providers {
 			if defaultProvider == nil || defaultModel == nil {
 				defaultProvider = &provider
 				defaultModel = getDefaultModel(providersResponse, provider)
@@ -143,14 +160,14 @@ func (a *App) InitializeProvider() tea.Cmd {
 			return nil
 		}

-		var currentProvider *client.ProviderInfo
-		var currentModel *client.ModelInfo
+		var currentProvider *opencode.Provider
+		var currentModel *opencode.Model
 		for _, provider := range providers {
-			if provider.Id == a.State.Provider {
+			if provider.ID == a.State.Provider {
 				currentProvider = &provider

 				for _, model := range provider.Models {
-					if model.Id == a.State.Model {
+					if model.ID == a.State.Model {
 						currentModel = &model
 					}
 				}
@@ -161,7 +178,6 @@ func (a *App) InitializeProvider() tea.Cmd {
 			currentModel = defaultModel
 		}

-		// TODO: handle no provider or model setup, yet
 		return ModelSelectedMsg{
 			Provider: *currentProvider,
 			Model:    *currentModel,
@@ -169,8 +185,8 @@ func (a *App) InitializeProvider() tea.Cmd {
 	}
 }

-func getDefaultModel(response *client.PostProviderListResponse, provider client.ProviderInfo) *client.ModelInfo {
-	if match, ok := response.JSON200.Default[provider.Id]; ok {
+func getDefaultModel(response *opencode.ConfigProvidersResponse, provider opencode.Provider) *opencode.Model {
+	if match, ok := response.Default[provider.ID]; ok {
 		model := provider.Models[match]
 		return &model
 	} else {
@@ -194,7 +210,7 @@ func (a *App) IsBusy() bool {
 	}

 	lastMessage := a.Messages[len(a.Messages)-1]
-	return lastMessage.Metadata.Time.Completed == nil
+	return lastMessage.Metadata.Time.Completed == 0
 }

 func (a *App) SaveState() {
@@ -217,104 +233,96 @@ func (a *App) InitializeProject(ctx context.Context) tea.Cmd {
 	cmds = append(cmds, util.CmdHandler(SessionSelectedMsg(session)))

 	go func() {
-		response, err := a.Client.PostSessionInitialize(ctx, client.PostSessionInitializeJSONRequestBody{
-			SessionID:  a.Session.Id,
-			ProviderID: a.Provider.Id,
-			ModelID:    a.Model.Id,
+		_, err := a.Client.Session.Init(ctx, a.Session.ID, opencode.SessionInitParams{
+			ProviderID: opencode.F(a.Provider.ID),
+			ModelID:    opencode.F(a.Model.ID),
 		})
 		if err != nil {
 			slog.Error("Failed to initialize project", "error", err)
 			// status.Error(err.Error())
 		}
-		if response != nil && response.StatusCode != 200 {
-			slog.Error("Failed to initialize project", "error", response.StatusCode)
-			// status.Error(fmt.Sprintf("failed to initialize project: %d", response.StatusCode))
-		}
 	}()

 	return tea.Batch(cmds...)
 }

 func (a *App) CompactSession(ctx context.Context) tea.Cmd {
-	response, err := a.Client.PostSessionSummarizeWithResponse(ctx, client.PostSessionSummarizeJSONRequestBody{
-		SessionID:  a.Session.Id,
-		ProviderID: a.Provider.Id,
-		ModelID:    a.Model.Id,
-	})
-	if err != nil {
-		slog.Error("Failed to compact session", "error", err)
-	}
-	if response != nil && response.StatusCode() != 200 {
-		slog.Error("Failed to compact session", "error", response.StatusCode)
-	}
+	go func() {
+		_, err := a.Client.Session.Summarize(ctx, a.Session.ID, opencode.SessionSummarizeParams{
+			ProviderID: opencode.F(a.Provider.ID),
+			ModelID:    opencode.F(a.Model.ID),
+		})
+		if err != nil {
+			slog.Error("Failed to compact session", "error", err)
+		}
+	}()
 	return nil
 }

 func (a *App) MarkProjectInitialized(ctx context.Context) error {
-	response, err := a.Client.PostAppInitialize(ctx)
+	_, err := a.Client.App.Init(ctx)
 	if err != nil {
 		slog.Error("Failed to mark project as initialized", "error", err)
 		return err
 	}
-	if response != nil && response.StatusCode != 200 {
-		return fmt.Errorf("failed to initialize project: %d", response.StatusCode)
-	}
 	return nil
 }

-func (a *App) CreateSession(ctx context.Context) (*client.SessionInfo, error) {
-	resp, err := a.Client.PostSessionCreateWithResponse(ctx)
+func (a *App) CreateSession(ctx context.Context) (*opencode.Session, error) {
+	session, err := a.Client.Session.New(ctx)
 	if err != nil {
 		return nil, err
 	}
-	if resp != nil && resp.StatusCode() != 200 {
-		return nil, fmt.Errorf("failed to create session: %d", resp.StatusCode())
-	}
-	session := resp.JSON200
 	return session, nil
 }

 func (a *App) SendChatMessage(ctx context.Context, text string, attachments []Attachment) tea.Cmd {
 	var cmds []tea.Cmd
-	if a.Session.Id == "" {
+	if a.Session.ID == "" {
 		session, err := a.CreateSession(ctx)
 		if err != nil {
-			// status.Error(err.Error())
-			return nil
+			return toast.NewErrorToast(err.Error())
 		}
 		a.Session = session
 		cmds = append(cmds, util.CmdHandler(SessionSelectedMsg(session)))
 	}

-	// TODO: Handle attachments when API supports them
-	if len(attachments) > 0 {
-		// For now, ignore attachments
-		// return "", fmt.Errorf("attachments not supported yet")
+	optimisticMessage := opencode.Message{
+		ID:   fmt.Sprintf("optimistic-%d", time.Now().UnixNano()),
+		Role: opencode.MessageRoleUser,
+		Parts: []opencode.MessagePart{{
+			Type: opencode.MessagePartTypeText,
+			Text: text,
+		}},
+		Metadata: opencode.MessageMetadata{
+			SessionID: a.Session.ID,
+			Time: opencode.MessageMetadataTime{
+				Created: float64(time.Now().Unix()),
+			},
+		},
 	}

-	part := client.MessagePart{}
-	part.FromMessagePartText(client.MessagePartText{
-		Type: "text",
-		Text: text,
-	})
-	parts := []client.MessagePart{part}
+	a.Messages = append(a.Messages, optimisticMessage)
+	cmds = append(cmds, util.CmdHandler(OptimisticMessageAddedMsg{Message: optimisticMessage}))

-	go func() {
-		response, err := a.Client.PostSessionChat(ctx, client.PostSessionChatJSONRequestBody{
-			SessionID:  a.Session.Id,
-			Parts:      parts,
-			ProviderID: a.Provider.Id,
-			ModelID:    a.Model.Id,
+	cmds = append(cmds, func() tea.Msg {
+		_, err := a.Client.Session.Chat(ctx, a.Session.ID, opencode.SessionChatParams{
+			Parts: opencode.F([]opencode.MessagePartUnionParam{
+				opencode.TextPartParam{
+					Type: opencode.F(opencode.TextPartTypeText),
+					Text: opencode.F(text),
+				},
+			}),
+			ProviderID: opencode.F(a.Provider.ID),
+			ModelID:    opencode.F(a.Model.ID),
 		})
 		if err != nil {
-			slog.Error("Failed to send message", "error", err)
-			// status.Error(err.Error())
+			errormsg := fmt.Sprintf("failed to send message: %v", err)
+			slog.Error(errormsg)
+			return toast.NewErrorToast(errormsg)()
 		}
-		if response != nil && response.StatusCode != 200 {
-			slog.Error("Failed to send message", "error", fmt.Sprintf("failed to send message: %d", response.StatusCode))
-			// status.Error(fmt.Sprintf("failed to send message: %d", response.StatusCode))
-		}
-	}()
+		return nil
+	})

 	// The actual response will come through SSE
 	// For now, just return success
@@ -322,70 +330,61 @@ func (a *App) SendChatMessage(ctx context.Context, text string, attachments []At
 }

 func (a *App) Cancel(ctx context.Context, sessionID string) error {
-	response, err := a.Client.PostSessionAbort(ctx, client.PostSessionAbortJSONRequestBody{
-		SessionID: sessionID,
-	})
+	_, err := a.Client.Session.Abort(ctx, sessionID)
 	if err != nil {
 		slog.Error("Failed to cancel session", "error", err)
 		// status.Error(err.Error())
 		return err
 	}
-	if response != nil && response.StatusCode != 200 {
-		slog.Error("Failed to cancel session", "error", fmt.Sprintf("failed to cancel session: %d", response.StatusCode))
-		// status.Error(fmt.Sprintf("failed to cancel session: %d", response.StatusCode))
-		return fmt.Errorf("failed to cancel session: %d", response.StatusCode)
+	return nil
+}
+
+func (a *App) ListSessions(ctx context.Context) ([]opencode.Session, error) {
+	response, err := a.Client.Session.List(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if response == nil {
+		return []opencode.Session{}, nil
+	}
+	sessions := *response
+	sort.Slice(sessions, func(i, j int) bool {
+		return sessions[i].Time.Created-sessions[j].Time.Created > 0
+	})
+	return sessions, nil
+}
+
+func (a *App) DeleteSession(ctx context.Context, sessionID string) error {
+	_, err := a.Client.Session.Delete(ctx, sessionID)
+	if err != nil {
+		slog.Error("Failed to delete session", "error", err)
+		return err
 	}
 	return nil
 }

-func (a *App) ListSessions(ctx context.Context) ([]client.SessionInfo, error) {
-	resp, err := a.Client.PostSessionListWithResponse(ctx)
+func (a *App) ListMessages(ctx context.Context, sessionId string) ([]opencode.Message, error) {
+	response, err := a.Client.Session.Messages(ctx, sessionId)
 	if err != nil {
 		return nil, err
 	}
-	if resp.StatusCode() != 200 {
-		return nil, fmt.Errorf("failed to list sessions: %d", resp.StatusCode())
+	if response == nil {
+		return []opencode.Message{}, nil
 	}
-	if resp.JSON200 == nil {
-		return []client.SessionInfo{}, nil
-	}
-	sessions := *resp.JSON200
-
-	sort.Slice(sessions, func(i, j int) bool {
-		return sessions[i].Time.Created-sessions[j].Time.Created > 0
-	})
-
-	return sessions, nil
-}
-
-func (a *App) ListMessages(ctx context.Context, sessionId string) ([]client.MessageInfo, error) {
-	resp, err := a.Client.PostSessionMessagesWithResponse(ctx, client.PostSessionMessagesJSONRequestBody{SessionID: sessionId})
-	if err != nil {
-		return nil, err
-	}
-	if resp.StatusCode() != 200 {
-		return nil, fmt.Errorf("failed to list messages: %d", resp.StatusCode())
-	}
-	if resp.JSON200 == nil {
-		return []client.MessageInfo{}, nil
-	}
-	messages := *resp.JSON200
+	messages := *response
 	return messages, nil
 }

-func (a *App) ListProviders(ctx context.Context) ([]client.ProviderInfo, error) {
-	resp, err := a.Client.PostProviderListWithResponse(ctx)
+func (a *App) ListProviders(ctx context.Context) ([]opencode.Provider, error) {
+	response, err := a.Client.Config.Providers(ctx)
 	if err != nil {
 		return nil, err
 	}
-	if resp.StatusCode() != 200 {
-		return nil, fmt.Errorf("failed to list sessions: %d", resp.StatusCode())
-	}
-	if resp.JSON200 == nil {
-		return []client.ProviderInfo{}, nil
+	if response == nil {
+		return []opencode.Provider{}, nil
 	}

-	providers := *resp.JSON200
+	providers := *response
 	return providers.Providers, nil
 }

@@ -6,7 +6,7 @@ import (
 	"strings"

 	tea "github.com/charmbracelet/bubbletea/v2"
-	"github.com/sst/opencode/pkg/client"
+	"github.com/sst/opencode-sdk-go"
 )

 type ExecuteCommandMsg Command
@@ -123,7 +123,7 @@ func parseBindings(bindings ...string) []Keybinding {
 	return parsedBindings
 }

-func LoadFromConfig(config *client.ConfigInfo) CommandRegistry {
+func LoadFromConfig(config *opencode.Config) CommandRegistry {
 	defaults := []Command{
 		{
 			Name:        AppHelpCommand,
@@ -269,10 +269,10 @@ func LoadFromConfig(config *client.ConfigInfo) CommandRegistry {
 	}
 	registry := make(CommandRegistry)
 	keybinds := map[string]string{}
-	marshalled, _ := json.Marshal(*config.Keybinds)
+	marshalled, _ := json.Marshal(config.Keybinds)
 	json.Unmarshal(marshalled, &keybinds)
 	for _, command := range defaults {
-		if keybind, ok := keybinds[string(command.Name)]; ok {
+		if keybind, ok := keybinds[string(command.Name)]; ok && keybind != "" {
 			command.Keybindings = parseBindings(keybind)
 		}
 		registry[command.Name] = command
@@ -9,6 +9,7 @@ import (
 	"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"
 )

@@ -37,7 +38,7 @@ func (c *CommandCompletionProvider) GetEmptyMessage() string {

 func getCommandCompletionItem(cmd commands.Command, space int, t theme.Theme) dialog.CompletionItemI {
 	spacer := strings.Repeat(" ", space)
-	title := "  /" + cmd.Trigger + lipgloss.NewStyle().Foreground(t.TextMuted()).Render(spacer+cmd.Description)
+	title := "  /" + cmd.Trigger + styles.NewStyle().Foreground(t.TextMuted()).Render(spacer+cmd.Description)
 	value := string(cmd.Name)
 	return dialog.NewCompletionItem(dialog.CompletionItem{
 		Title: title,
@@ -3,9 +3,9 @@ package completions
 import (
 	"context"

+	"github.com/sst/opencode-sdk-go"
 	"github.com/sst/opencode/internal/app"
 	"github.com/sst/opencode/internal/components/dialog"
-	"github.com/sst/opencode/pkg/client"
 )

 type filesAndFoldersContextGroup struct {
@@ -29,17 +29,14 @@ func (cg *filesAndFoldersContextGroup) GetEmptyMessage() string {
 }

 func (cg *filesAndFoldersContextGroup) getFiles(query string) ([]string, error) {
-	response, err := cg.app.Client.PostFileSearchWithResponse(context.Background(), client.PostFileSearchJSONRequestBody{
-		Query: query,
-	})
+	files, err := cg.app.Client.File.Search(
+		context.Background(),
+		opencode.FileSearchParams{Query: opencode.F(query)},
+	)
 	if err != nil {
 		return []string{}, err
 	}
-	if response.JSON200 == nil {
-		return []string{}, nil
-	}
-
-	return *response.JSON200, nil
+	return *files, nil
 }

 func (cg *filesAndFoldersContextGroup) GetChildEntries(query string) ([]dialog.CompletionItemI, error) {
@@ -26,27 +26,32 @@ type EditorComponent interface {
 	Content() string
 	Lines() int
 	Value() string
+	Focused() bool
+	Focus() (tea.Model, tea.Cmd)
+	Blur()
 	Submit() (tea.Model, tea.Cmd)
 	Clear() (tea.Model, tea.Cmd)
 	Paste() (tea.Model, tea.Cmd)
 	Newline() (tea.Model, tea.Cmd)
 	Previous() (tea.Model, tea.Cmd)
 	Next() (tea.Model, tea.Cmd)
+	SetInterruptKeyInDebounce(inDebounce bool)
 }

 type editorComponent struct {
-	app            *app.App
-	width, height  int
-	textarea       textarea.Model
-	attachments    []app.Attachment
-	history        []string
-	historyIndex   int
-	currentMessage string
-	spinner        spinner.Model
+	app                    *app.App
+	width, height          int
+	textarea               textarea.Model
+	attachments            []app.Attachment
+	history                []string
+	historyIndex           int
+	currentMessage         string
+	spinner                spinner.Model
+	interruptKeyInDebounce bool
 }

 func (m *editorComponent) Init() tea.Cmd {
-	return tea.Batch(textarea.Blink, m.spinner.Tick, tea.EnableReportFocus)
+	return tea.Batch(m.textarea.Focus(), m.spinner.Tick, tea.EnableReportFocus)
 }

 func (m *editorComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
@@ -67,7 +72,7 @@ func (m *editorComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	case dialog.ThemeSelectedMsg:
 		m.textarea = createTextArea(&m.textarea)
 		m.spinner = createSpinner()
-		return m, tea.Batch(m.spinner.Tick, textarea.Blink)
+		return m, tea.Batch(m.spinner.Tick, m.textarea.Focus())
 	case dialog.CompletionSelectedMsg:
 		if msg.IsCommand {
 			commandName := strings.TrimPrefix(msg.CompletionValue, "/")
@@ -78,8 +83,15 @@ func (m *editorComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			return m, tea.Batch(cmds...)
 		} else {
 			existingValue := m.textarea.Value()
-			modifiedValue := strings.Replace(existingValue, msg.SearchString, msg.CompletionValue, 1)
-			m.textarea.SetValue(modifiedValue + " ")
+
+			// Replace the current token (after last space)
+			lastSpaceIndex := strings.LastIndex(existingValue, " ")
+			if lastSpaceIndex == -1 {
+				m.textarea.SetValue(msg.CompletionValue + " ")
+			} else {
+				modifiedValue := existingValue[:lastSpaceIndex+1] + msg.CompletionValue
+				m.textarea.SetValue(modifiedValue + " ")
+			}
 			return m, nil
 		}
 	}
@@ -95,12 +107,11 @@ func (m *editorComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {

 func (m *editorComponent) Content() string {
 	t := theme.CurrentTheme()
-	base := styles.BaseStyle().Background(t.Background()).Render
-	muted := styles.Muted().Background(t.Background()).Render
-	promptStyle := lipgloss.NewStyle().
+	base := styles.NewStyle().Foreground(t.Text()).Background(t.Background()).Render
+	muted := styles.NewStyle().Foreground(t.TextMuted()).Background(t.Background()).Render
+	promptStyle := styles.NewStyle().Foreground(t.Primary()).
 		Padding(0, 0, 0, 1).
-		Bold(true).
-		Foreground(t.Primary())
+		Bold(true)
 	prompt := promptStyle.Render(">")

 	textarea := lipgloss.JoinHorizontal(
@@ -108,16 +119,26 @@ func (m *editorComponent) Content() string {
 		prompt,
 		m.textarea.View(),
 	)
-	textarea = styles.BaseStyle().
+	textarea = styles.NewStyle().
+		Background(t.BackgroundElement()).
 		Width(m.width).
 		PaddingTop(1).
 		PaddingBottom(1).
-		Background(t.BackgroundElement()).
+		BorderStyle(lipgloss.ThickBorder()).
+		BorderForeground(t.Border()).
+		BorderBackground(t.Background()).
+		BorderLeft(true).
+		BorderRight(true).
 		Render(textarea)

-	hint := base("enter") + muted(" send   ")
+	hint := base(m.getSubmitKeyText()) + muted(" send   ")
 	if m.app.IsBusy() {
-		hint = muted("working") + m.spinner.View() + muted("  ") + base("esc") + muted(" interrupt")
+		keyText := m.getInterruptKeyText()
+		if m.interruptKeyInDebounce {
+			hint = muted("working") + m.spinner.View() + muted("  ") + base(keyText+" again") + muted(" interrupt")
+		} else {
+			hint = muted("working") + m.spinner.View() + muted("  ") + base(keyText) + muted(" interrupt")
+		}
 	}

 	model := ""
@@ -126,10 +147,10 @@ func (m *editorComponent) Content() string {
 	}

 	space := m.width - 2 - lipgloss.Width(model) - lipgloss.Width(hint)
-	spacer := lipgloss.NewStyle().Background(t.Background()).Width(space).Render("")
+	spacer := styles.NewStyle().Background(t.Background()).Width(space).Render("")

 	info := hint + spacer + model
-	info = styles.Padded().Background(t.Background()).Render(info)
+	info = styles.NewStyle().Background(t.Background()).Padding(0, 1).Render(info)

 	content := strings.Join([]string{"", textarea, info}, "\n")
 	return content
@@ -142,6 +163,18 @@ func (m *editorComponent) View() string {
 	return m.Content()
 }

+func (m *editorComponent) Focused() bool {
+	return m.textarea.Focused()
+}
+
+func (m *editorComponent) Focus() (tea.Model, tea.Cmd) {
+	return m, m.textarea.Focus()
+}
+
+func (m *editorComponent) Blur() {
+	m.textarea.Blur()
+}
+
 func (m *editorComponent) GetSize() (width, height int) {
 	return m.width, m.height
 }
@@ -149,8 +182,6 @@ func (m *editorComponent) GetSize() (width, height int) {
 func (m *editorComponent) SetSize(width, height int) tea.Cmd {
 	m.width = width
 	m.height = height
-	m.textarea.SetWidth(width - 5) // account for the prompt and padding right
-	// m.textarea.SetHeight(height - 4)
 	return nil
 }

@@ -263,6 +294,18 @@ func (m *editorComponent) Next() (tea.Model, tea.Cmd) {
 	return m, nil
 }

+func (m *editorComponent) SetInterruptKeyInDebounce(inDebounce bool) {
+	m.interruptKeyInDebounce = inDebounce
+}
+
+func (m *editorComponent) getInterruptKeyText() string {
+	return m.app.Commands[commands.SessionInterruptCommand].Keys()[0]
+}
+
+func (m *editorComponent) getSubmitKeyText() string {
+	return m.app.Commands[commands.InputSubmitCommand].Keys()[0]
+}
+
 func createTextArea(existing *textarea.Model) textarea.Model {
 	t := theme.CurrentTheme()
 	bgColor := t.BackgroundElement()
@@ -271,38 +314,42 @@ func createTextArea(existing *textarea.Model) textarea.Model {

 	ta := textarea.New()

-	ta.Styles.Blurred.Base = lipgloss.NewStyle().Background(bgColor).Foreground(textColor)
-	ta.Styles.Blurred.CursorLine = lipgloss.NewStyle().Background(bgColor)
-	ta.Styles.Blurred.Placeholder = lipgloss.NewStyle().Background(bgColor).Foreground(textMutedColor)
-	ta.Styles.Blurred.Text = lipgloss.NewStyle().Background(bgColor).Foreground(textColor)
-	ta.Styles.Focused.Base = lipgloss.NewStyle().Background(bgColor).Foreground(textColor)
-	ta.Styles.Focused.CursorLine = lipgloss.NewStyle().Background(bgColor)
-	ta.Styles.Focused.Placeholder = lipgloss.NewStyle().Background(bgColor).Foreground(textMutedColor)
-	ta.Styles.Focused.Text = lipgloss.NewStyle().Background(bgColor).Foreground(textColor)
+	ta.Styles.Blurred.Base = styles.NewStyle().Foreground(textColor).Background(bgColor).Lipgloss()
+	ta.Styles.Blurred.CursorLine = styles.NewStyle().Background(bgColor).Lipgloss()
+	ta.Styles.Blurred.Placeholder = styles.NewStyle().Foreground(textMutedColor).Background(bgColor).Lipgloss()
+	ta.Styles.Blurred.Text = styles.NewStyle().Foreground(textColor).Background(bgColor).Lipgloss()
+	ta.Styles.Focused.Base = styles.NewStyle().Foreground(textColor).Background(bgColor).Lipgloss()
+	ta.Styles.Focused.CursorLine = styles.NewStyle().Background(bgColor).Lipgloss()
+	ta.Styles.Focused.Placeholder = styles.NewStyle().Foreground(textMutedColor).Background(bgColor).Lipgloss()
+	ta.Styles.Focused.Text = styles.NewStyle().Foreground(textColor).Background(bgColor).Lipgloss()
 	ta.Styles.Cursor.Color = t.Primary()

 	ta.Prompt = " "
 	ta.ShowLineNumbers = false
 	ta.CharLimit = -1
+	ta.SetWidth(layout.Current.Container.Width - 6)

 	if existing != nil {
 		ta.SetValue(existing.Value())
-		ta.SetWidth(existing.Width())
+		// ta.SetWidth(existing.Width())
 		ta.SetHeight(existing.Height())
 	}

-	ta.Focus()
+	// ta.Focus()
 	return ta
 }

 func createSpinner() spinner.Model {
+	t := theme.CurrentTheme()
 	return spinner.New(
 		spinner.WithSpinner(spinner.Ellipsis),
 		spinner.WithStyle(
-			styles.
-				Muted().
-				Background(theme.CurrentTheme().Background()).
-				Width(3)),
+			styles.NewStyle().
+				Background(t.Background()).
+				Foreground(t.TextMuted()).
+				Width(3).
+				Lipgloss(),
+		),
 	)
 }

@@ -311,11 +358,12 @@ func NewEditorComponent(app *app.App) EditorComponent {
 	ta := createTextArea(nil)

 	return &editorComponent{
-		app:            app,
-		textarea:       ta,
-		history:        []string{},
-		historyIndex:   0,
-		currentMessage: "",
-		spinner:        s,
+		app:                    app,
+		textarea:               ta,
+		history:                []string{},
+		historyIndex:           0,
+		currentMessage:         "",
+		spinner:                s,
+		interruptKeyInDebounce: false,
 	}
 }
@@ -12,12 +12,13 @@ import (
 	"github.com/charmbracelet/lipgloss/v2"
 	"github.com/charmbracelet/lipgloss/v2/compat"
 	"github.com/charmbracelet/x/ansi"
+	"github.com/sst/opencode-sdk-go"
 	"github.com/sst/opencode/internal/app"
 	"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/pkg/client"
+	"github.com/tidwall/gjson"
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
 )
@@ -44,7 +45,6 @@ func toMarkdown(content string, width int, backgroundColor compat.AdaptiveColor)
 			}
 		}
 	}
-
 	content = strings.Join(lines, "\n")
 	return strings.TrimSuffix(content, "\n")
 }
@@ -130,15 +130,13 @@ func renderContentBlock(content string, options ...renderingOption) string {
 		option(renderer)
 	}

-	style := styles.BaseStyle().
+	style := styles.NewStyle().Foreground(t.TextMuted()).Background(t.BackgroundPanel()).
 		// MarginTop(renderer.marginTop).
 		// MarginBottom(renderer.marginBottom).
 		PaddingTop(renderer.paddingTop).
 		PaddingBottom(renderer.paddingBottom).
 		PaddingLeft(renderer.paddingLeft).
 		PaddingRight(renderer.paddingRight).
-		Background(t.BackgroundPanel()).
-		Foreground(t.TextMuted()).
 		BorderStyle(lipgloss.ThickBorder())

 	align := lipgloss.Left
@@ -180,13 +178,13 @@ func renderContentBlock(content string, options ...renderingOption) string {
 		layout.Current.Container.Width,
 		align,
 		content,
-		lipgloss.WithWhitespaceStyle(lipgloss.NewStyle().Background(t.Background())),
+		styles.WhitespaceStyle(t.Background()),
 	)
 	content = lipgloss.PlaceHorizontal(
 		layout.Current.Viewport.Width,
 		lipgloss.Center,
 		content,
-		lipgloss.WithWhitespaceStyle(lipgloss.NewStyle().Background(t.Background())),
+		styles.WhitespaceStyle(t.Background()),
 	)
 	if renderer.marginTop > 0 {
 		for range renderer.marginTop {
@@ -212,7 +210,7 @@ func calculatePadding() int {
 	}
 }

-func renderText(message client.MessageInfo, text string, author string) string {
+func renderText(message opencode.Message, text string, author string) string {
 	t := theme.CurrentTheme()
 	width := layout.Current.Container.Width
 	padding := calculatePadding()
@@ -226,19 +224,30 @@ func renderText(message client.MessageInfo, text string, author string) string {

 	textWidth := max(lipgloss.Width(text), lipgloss.Width(info))
 	markdownWidth := min(textWidth, width-padding-4) // -4 for the border and padding
-	if message.Role == client.Assistant {
-		markdownWidth = width - padding - 4
+	if message.Role == opencode.MessageRoleAssistant {
+		markdownWidth = width - padding - 4 - 3
+	}
+	minWidth := max(markdownWidth, (width-4)/2)
+	messageStyle := styles.NewStyle().
+		Width(minWidth).
+		Background(t.BackgroundPanel()).
+		Foreground(t.Text())
+	if textWidth < minWidth {
+		messageStyle = messageStyle.AlignHorizontal(lipgloss.Right)
+	}
+	content := messageStyle.Render(text)
+	if message.Role == opencode.MessageRoleAssistant {
+		content = toMarkdown(text, markdownWidth, t.BackgroundPanel())
 	}
-	content := toMarkdown(text, markdownWidth, t.BackgroundPanel())
 	content = strings.Join([]string{content, info}, "\n")

 	switch message.Role {
-	case client.User:
+	case opencode.MessageRoleUser:
 		return renderContentBlock(content,
 			WithAlign(lipgloss.Right),
 			WithBorderColor(t.Secondary()),
 		)
-	case client.Assistant:
+	case opencode.MessageRoleAssistant:
 		return renderContentBlock(content,
 			WithAlign(lipgloss.Left),
 			WithBorderColor(t.Accent()),
@@ -248,15 +257,16 @@ func renderText(message client.MessageInfo, text string, author string) string {
 }

 func renderToolInvocation(
-	toolCall client.MessageToolInvocationToolCall,
+	toolCall opencode.ToolInvocationPart,
 	result *string,
-	metadata client.MessageInfo_Metadata_Tool_AdditionalProperties,
+	metadata opencode.MessageMetadataTool,
 	showDetails bool,
 	isLast bool,
 	contentOnly bool,
+	messageMetadata opencode.MessageMetadata,
 ) string {
 	ignoredTools := []string{"todoread"}
-	if slices.Contains(ignoredTools, toolCall.ToolName) {
+	if slices.Contains(ignoredTools, toolCall.ToolInvocation.ToolName) {
 		return ""
 	}

@@ -272,9 +282,10 @@ func renderToolInvocation(
 	}

 	t := theme.CurrentTheme()
-	style := styles.Muted().
-		Width(outerWidth).
+	style := styles.NewStyle().
+		Foreground(t.TextMuted()).
 		Background(t.BackgroundPanel()).
+		Width(outerWidth).
 		PaddingTop(paddingTop).
 		PaddingBottom(paddingBottom).
 		PaddingLeft(2).
@@ -285,12 +296,14 @@ func renderToolInvocation(
 		BorderForeground(t.BackgroundPanel()).
 		BorderStyle(lipgloss.ThickBorder())

-	if toolCall.State == "partial-call" {
-		title := renderToolAction(toolCall.ToolName)
+	if toolCall.ToolInvocation.State == "partial-call" {
+		title := renderToolAction(toolCall.ToolInvocation.ToolName)
 		if !showDetails {
 			title = "∟ " + title
 			padding := calculatePadding()
-			style := lipgloss.NewStyle().Width(outerWidth - padding - 4).Background(t.BackgroundPanel())
+			style := styles.NewStyle().
+				Background(t.BackgroundPanel()).
+				Width(outerWidth - padding - 4 - 3)
 			return renderContentBlock(style.Render(title),
 				WithAlign(lipgloss.Left),
 				WithBorderColor(t.Accent()),
@@ -305,8 +318,8 @@ func renderToolInvocation(

 	toolArgs := ""
 	toolArgsMap := make(map[string]any)
-	if toolCall.Args != nil {
-		value := *toolCall.Args
+	if toolCall.ToolInvocation.Args != nil {
+		value := toolCall.ToolInvocation.Args
 		if m, ok := value.(map[string]any); ok {
 			toolArgsMap = m

@@ -328,28 +341,35 @@ func renderToolInvocation(
 	error := ""
 	finished := result != nil && *result != ""

-	if e, ok := metadata.Get("error"); ok && e.(bool) == true {
-		if m, ok := metadata.Get("message"); ok {
-			style = style.BorderLeftForeground(t.Error())
-			error = styles.BaseStyle().
-				Background(t.BackgroundPanel()).
-				Foreground(t.Error()).
-				Render(m.(string))
-			error = renderContentBlock(
-				error,
-				WithFullWidth(),
-				WithBorderColor(t.Error()),
-				WithMarginBottom(1),
-			)
-		}
+	er := messageMetadata.Error.AsUnion()
+	switch er.(type) {
+	case nil:
+	default:
+		clientError := er.(opencode.UnknownError)
+		error = clientError.Data.Message
+	}
+
+	if error != "" {
+		style = style.BorderLeftForeground(t.Error())
+		error = styles.NewStyle().
+			Foreground(t.Error()).
+			Background(t.BackgroundPanel()).
+			Render(error)
+		error = renderContentBlock(
+			error,
+			WithFullWidth(),
+			WithBorderColor(t.Error()),
+			WithMarginBottom(1),
+		)
 	}

 	title := ""
-	switch toolCall.ToolName {
+	switch toolCall.ToolInvocation.ToolName {
 	case "read":
 		toolArgs = renderArgs(&toolArgsMap, "filePath")
 		title = fmt.Sprintf("READ %s", toolArgs)
-		if preview, ok := metadata.Get("preview"); ok && toolArgsMap["filePath"] != nil {
+		preview := metadata.ExtraFields["preview"]
+		if preview != nil && toolArgsMap["filePath"] != nil {
 			filename := toolArgsMap["filePath"].(string)
 			body = preview.(string)
 			body = renderFile(filename, body, WithTruncate(6))
@@ -357,8 +377,9 @@ func renderToolInvocation(
 	case "edit":
 		if filename, ok := toolArgsMap["filePath"].(string); ok {
 			title = fmt.Sprintf("EDIT %s", relative(filename))
-			if d, ok := metadata.Get("diff"); ok {
-				patch := d.(string)
+			diffField := metadata.ExtraFields["diff"]
+			if diffField != nil {
+				patch := diffField.(string)
 				var formattedDiff string
 				if layout.Current.Viewport.Width < 80 {
 					formattedDiff, _ = diff.FormatUnifiedDiff(
@@ -371,7 +392,7 @@ func renderToolInvocation(
 					formattedDiff, _ = diff.FormatDiff(filename, patch, diff.WithTotalWidth(diffWidth))
 				}
 				formattedDiff = strings.TrimSpace(formattedDiff)
-				formattedDiff = lipgloss.NewStyle().
+				formattedDiff = styles.NewStyle().
 					BorderStyle(lipgloss.ThickBorder()).
 					BorderBackground(t.Background()).
 					BorderForeground(t.BackgroundPanel()).
@@ -391,8 +412,13 @@ func renderToolInvocation(
 					lipgloss.Center,
 					lipgloss.Top,
 					body,
-					lipgloss.WithWhitespaceStyle(lipgloss.NewStyle().Background(t.Background())),
+					styles.WhitespaceStyle(t.Background()),
 				)
+
+				// Add diagnostics at the bottom if they exist
+				if diagnostics := renderDiagnostics(messageMetadata, filename); diagnostics != "" {
+					body += "\n" + renderContentBlock(diagnostics, WithFullWidth(), WithBorderColor(t.Error()))
+				}
 			}
 		}
 	case "write":
@@ -400,15 +426,21 @@ func renderToolInvocation(
 			title = fmt.Sprintf("WRITE %s", relative(filename))
 			if content, ok := toolArgsMap["content"].(string); ok {
 				body = renderFile(filename, content)
+
+				// Add diagnostics at the bottom if they exist
+				if diagnostics := renderDiagnostics(messageMetadata, filename); diagnostics != "" {
+					body += "\n" + renderContentBlock(diagnostics, WithFullWidth(), WithBorderColor(t.Error()))
+				}
 			}
 		}
 	case "bash":
 		if description, ok := toolArgsMap["description"].(string); ok {
 			title = fmt.Sprintf("SHELL %s", description)
 		}
-		if stdout, ok := metadata.Get("stdout"); ok {
+		stdout := metadata.JSON.ExtraFields["stdout"]
+		if !stdout.IsNull() {
 			command := toolArgsMap["command"].(string)
-			stdout := stdout.(string)
+			stdout := stdout.Raw()
 			body = fmt.Sprintf("```console\n> %s\n%s```", command, stdout)
 			body = toMarkdown(body, innerWidth, t.BackgroundPanel())
 			body = renderContentBlock(body, WithFullWidth(), WithMarginBottom(1))
@@ -429,12 +461,13 @@ func renderToolInvocation(
 	case "todowrite":
 		title = fmt.Sprintf("PLAN")

-		if to, ok := metadata.Get("todos"); ok && finished {
-			todos := to.([]any)
-			for _, todo := range todos {
-				t := todo.(map[string]any)
-				content := t["content"].(string)
-				switch t["status"].(string) {
+		todos := metadata.JSON.ExtraFields["todos"]
+		if !todos.IsNull() && finished {
+			strTodos := todos.Raw()
+			todos := gjson.Parse(strTodos)
+			for _, todo := range todos.Array() {
+				content := todo.Get("content").String()
+				switch todo.Get("status").String() {
 				case "completed":
 					body += fmt.Sprintf("- [x] %s\n", content)
 				// case "in-progress":
@@ -449,21 +482,22 @@ func renderToolInvocation(
 	case "task":
 		if description, ok := toolArgsMap["description"].(string); ok {
 			title = fmt.Sprintf("TASK %s", description)
-			if summary, ok := metadata.Get("summary"); ok {
-				toolcalls := summary.([]any)
-				// toolcalls :=
+			summary := metadata.JSON.ExtraFields["summary"]
+			if !summary.IsNull() {
+				strValue := summary.Raw()
+				toolcalls := gjson.Parse(strValue).Array()

 				steps := []string{}
 				for _, toolcall := range toolcalls {
-					call := toolcall.(map[string]any)
+					call := toolcall.Value().(map[string]any)
 					if toolInvocation, ok := call["toolInvocation"].(map[string]any); ok {
 						data, _ := json.Marshal(toolInvocation)
-						var toolCall client.MessageToolInvocationToolCall
+						var toolCall opencode.ToolInvocationPart
 						_ = json.Unmarshal(data, &toolCall)

 						if metadata, ok := call["metadata"].(map[string]any); ok {
 							data, _ = json.Marshal(metadata)
-							var toolMetadata client.MessageInfo_Metadata_Tool_AdditionalProperties
+							var toolMetadata opencode.MessageMetadataTool
 							_ = json.Unmarshal(data, &toolMetadata)

 							step := renderToolInvocation(
@@ -473,6 +507,7 @@ func renderToolInvocation(
 								false,
 								false,
 								true,
+								messageMetadata,
 							)
 							steps = append(steps, step)
 						}
@@ -484,7 +519,7 @@ func renderToolInvocation(
 		}

 	default:
-		toolName := renderToolName(toolCall.ToolName)
+		toolName := renderToolName(toolCall.ToolInvocation.ToolName)
 		title = fmt.Sprintf("%s %s", toolName, toolArgs)
 		if result == nil {
 			empty := ""
@@ -503,7 +538,7 @@ func renderToolInvocation(
 	if !showDetails {
 		title = "∟ " + title
 		padding := calculatePadding()
-		style := lipgloss.NewStyle().Width(outerWidth - padding - 4).Background(t.BackgroundPanel())
+		style := styles.NewStyle().Background(t.BackgroundPanel()).Width(outerWidth - padding - 4 - 3)
 		paddingBottom := 0
 		if isLast {
 			paddingBottom = 1
@@ -516,7 +551,7 @@ func renderToolInvocation(
 		)
 	}

-	if body == "" && error == "" {
+	if body == "" && error == "" && result != nil {
 		body = *result
 		body = truncateHeight(body, 10)
 		body = renderContentBlock(body, WithFullWidth(), WithMarginBottom(1))
@@ -527,7 +562,7 @@ func renderToolInvocation(
 		layout.Current.Viewport.Width,
 		lipgloss.Center,
 		content,
-		lipgloss.WithWhitespaceStyle(lipgloss.NewStyle().Background(t.Background())),
+		styles.WhitespaceStyle(t.Background()),
 	)
 	if showDetails && body != "" && error == "" {
 		content += "\n" + body
@@ -681,3 +716,78 @@ func extension(path string) string {
 	}
 	return ext
 }
+
+// Diagnostic represents an LSP diagnostic
+type Diagnostic struct {
+	Range struct {
+		Start struct {
+			Line      int `json:"line"`
+			Character int `json:"character"`
+		} `json:"start"`
+	} `json:"range"`
+	Severity int    `json:"severity"`
+	Message  string `json:"message"`
+}
+
+// renderDiagnostics formats LSP diagnostics for display in the TUI
+func renderDiagnostics(metadata opencode.MessageMetadata, filePath string) string {
+	diagnosticsData := metadata.JSON.ExtraFields["diagnostics"]
+	if diagnosticsData.IsNull() {
+		return ""
+	}
+
+	// diagnosticsData should be a map[string][]Diagnostic
+	strDiagnosticsData := diagnosticsData.Raw()
+	diagnosticsMap := gjson.Parse(strDiagnosticsData).Value().(map[string]any)
+	fileDiagnostics, ok := diagnosticsMap[filePath]
+	if !ok {
+		return ""
+	}
+
+	diagnosticsList, ok := fileDiagnostics.([]any)
+	if !ok {
+		return ""
+	}
+
+	var errorDiagnostics []string
+	for _, diagInterface := range diagnosticsList {
+		diagMap, ok := diagInterface.(map[string]any)
+		if !ok {
+			continue
+		}
+
+		// Parse the diagnostic
+		var diag Diagnostic
+		diagBytes, err := json.Marshal(diagMap)
+		if err != nil {
+			continue
+		}
+		if err := json.Unmarshal(diagBytes, &diag); err != nil {
+			continue
+		}
+
+		// Only show error diagnostics (severity === 1)
+		if diag.Severity != 1 {
+			continue
+		}
+
+		line := diag.Range.Start.Line + 1        // 1-based
+		column := diag.Range.Start.Character + 1 // 1-based
+		errorDiagnostics = append(errorDiagnostics, fmt.Sprintf("Error [%d:%d] %s", line, column, diag.Message))
+	}
+
+	if len(errorDiagnostics) == 0 {
+		return ""
+	}
+
+	t := theme.CurrentTheme()
+	var result strings.Builder
+	for _, diagnostic := range errorDiagnostics {
+		if result.Len() > 0 {
+			result.WriteString("\n")
+		}
+		result.WriteString(styles.NewStyle().Foreground(t.Error()).Render(diagnostic))
+	}
+
+	return result.String()
+}
@@ -9,13 +9,14 @@ import (
 	"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/commands"
 	"github.com/sst/opencode/internal/components/dialog"
 	"github.com/sst/opencode/internal/layout"
 	"github.com/sst/opencode/internal/styles"
 	"github.com/sst/opencode/internal/theme"
-	"github.com/sst/opencode/pkg/client"
+	"github.com/sst/opencode/internal/util"
 )

 type MessagesComponent interface {
@@ -58,6 +59,12 @@ func (m *messagesComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		m.viewport.GotoBottom()
 		m.tail = true
 		return m, nil
+	case app.OptimisticMessageAddedMsg:
+		m.renderView()
+		if m.tail {
+			m.viewport.GotoBottom()
+		}
+		return m, nil
 	case dialog.ThemeSelectedMsg:
 		m.cache.Clear()
 		return m, m.Reload()
@@ -77,7 +84,7 @@ func (m *messagesComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		if m.tail {
 			m.viewport.GotoBottom()
 		}
-	case client.EventSessionUpdated, client.EventMessageUpdated:
+	case opencode.EventListResponseEventSessionUpdated, opencode.EventListResponseEventMessageUpdated:
 		m.renderView()
 		if m.tail {
 			m.viewport.GotoBottom()
@@ -115,99 +122,110 @@ func (m *messagesComponent) renderView() {
 		return
 	}

+	measure := util.Measure("messages.renderView")
+	defer measure("messageCount", len(m.app.Messages))
+
 	t := theme.CurrentTheme()
 	blocks := make([]string, 0)
 	previousBlockType := none
+
 	for _, message := range m.app.Messages {
 		var content string
 		var cached bool
 		lastToolIndex := 0
 		lastToolIndices := []int{}
 		for i, p := range message.Parts {
-			part, _ := p.ValueByDiscriminator()
-			switch part.(type) {
-			case client.MessagePartText:
+			switch p.Type {
+			case opencode.MessagePartTypeText:
 				lastToolIndices = append(lastToolIndices, lastToolIndex)
-			case client.MessagePartToolInvocation:
+			case opencode.MessagePartTypeToolInvocation:
 				lastToolIndex = i
 			}
 		}

 		author := ""
 		switch message.Role {
-		case client.User:
+		case opencode.MessageRoleUser:
 			author = m.app.Info.User
-		case client.Assistant:
+		case opencode.MessageRoleAssistant:
 			author = message.Metadata.Assistant.ModelID
 		}

 		for i, p := range message.Parts {
-			part, err := p.ValueByDiscriminator()
-			if err != nil {
-				continue //TODO: handle error?
-			}
-
-			switch part.(type) {
+			switch part := p.AsUnion().(type) {
 			// case client.MessagePartStepStart:
 			// 	messages = append(messages, "")
-			case client.MessagePartText:
-				text := part.(client.MessagePartText)
-				key := m.cache.GenerateKey(message.Id, text.Text, layout.Current.Viewport.Width)
+			case opencode.TextPart:
+				key := m.cache.GenerateKey(message.ID, p.Text, layout.Current.Viewport.Width)
 				content, cached = m.cache.Get(key)
 				if !cached {
-					content = renderText(message, text.Text, author)
+					content = renderText(message, p.Text, author)
 					m.cache.Set(key, content)
 				}
 				if previousBlockType != none {
 					blocks = append(blocks, "")
 				}
 				blocks = append(blocks, content)
-				if message.Role == client.User {
+				if message.Role == opencode.MessageRoleUser {
 					previousBlockType = userTextBlock
-				} else if message.Role == client.Assistant {
+				} else if message.Role == opencode.MessageRoleAssistant {
 					previousBlockType = assistantTextBlock
 				}
-			case client.MessagePartToolInvocation:
+			case opencode.ToolInvocationPart:
 				isLastToolInvocation := slices.Contains(lastToolIndices, i)
-				toolInvocationPart := part.(client.MessagePartToolInvocation)
-				toolCall, _ := toolInvocationPart.ToolInvocation.AsMessageToolInvocationToolCall()
-				metadata := client.MessageInfo_Metadata_Tool_AdditionalProperties{}
-				if _, ok := message.Metadata.Tool[toolCall.ToolCallId]; ok {
-					metadata = message.Metadata.Tool[toolCall.ToolCallId]
-				}
-				var result *string
-				resultPart, resultError := toolInvocationPart.ToolInvocation.AsMessageToolInvocationToolResult()
-				if resultError == nil {
-					result = &resultPart.Result
+				metadata := opencode.MessageMetadataTool{}
+
+				toolCallID := part.ToolInvocation.ToolCallID
+				// var toolCallID string
+				// var result *string
+				// switch toolCall := part.ToolInvocation.AsUnion().(type) {
+				// case opencode.ToolCall:
+				// 	toolCallID = toolCall.ToolCallID
+				// case opencode.ToolPartialCall:
+				// 	toolCallID = toolCall.ToolCallID
+				// case opencode.ToolResult:
+				// 	toolCallID = toolCall.ToolCallID
+				// 	result = &toolCall.Result
+				// }
+
+				if _, ok := message.Metadata.Tool[toolCallID]; ok {
+					metadata = message.Metadata.Tool[toolCallID]
 				}

-				if toolCall.State == "result" {
-					key := m.cache.GenerateKey(message.Id,
-						toolCall.ToolCallId,
+				var result *string
+				if part.ToolInvocation.Result != "" {
+					result = &part.ToolInvocation.Result
+				}
+
+				if part.ToolInvocation.State == "result" {
+					key := m.cache.GenerateKey(message.ID,
+						part.ToolInvocation.ToolCallID,
 						m.showToolDetails,
 						layout.Current.Viewport.Width,
 					)
 					content, cached = m.cache.Get(key)
 					if !cached {
 						content = renderToolInvocation(
-							toolCall,
+							part,
 							result,
 							metadata,
 							m.showToolDetails,
 							isLastToolInvocation,
 							false,
+							message.Metadata,
 						)
 						m.cache.Set(key, content)
 					}
 				} else {
 					// if the tool call isn't finished, don't cache
 					content = renderToolInvocation(
-						toolCall,
+						part,
 						result,
 						metadata,
 						m.showToolDetails,
 						isLastToolInvocation,
 						false,
+						message.Metadata,
 					)
 				}

@@ -220,16 +238,17 @@ func (m *messagesComponent) renderView() {
 		}

 		error := ""
-		if message.Metadata.Error != nil {
-			errorValue, _ := message.Metadata.Error.ValueByDiscriminator()
-			switch errorValue.(type) {
-			case client.UnknownError:
-				clientError := errorValue.(client.UnknownError)
-				error = clientError.Data.Message
-				error = renderContentBlock(error, WithBorderColor(t.Error()), WithFullWidth(), WithMarginTop(1), WithMarginBottom(1))
-				blocks = append(blocks, error)
-				previousBlockType = errorBlock
-			}
+		switch err := message.Metadata.Error.AsUnion().(type) {
+		case nil:
+		default:
+			clientError := err.(opencode.UnknownError)
+			error = clientError.Data.Message
+		}
+
+		if error != "" {
+			error = renderContentBlock(error, WithBorderColor(t.Error()), WithFullWidth(), WithMarginTop(1), WithMarginBottom(1))
+			blocks = append(blocks, error)
+			previousBlockType = errorBlock
 		}
 	}

@@ -239,7 +258,7 @@ func (m *messagesComponent) renderView() {
 			m.width,
 			lipgloss.Center,
 			block,
-			lipgloss.WithWhitespaceStyle(lipgloss.NewStyle().Background(t.Background())),
+			styles.WhitespaceStyle(t.Background()),
 		))
 	}

@@ -248,28 +267,28 @@ func (m *messagesComponent) renderView() {
 }

 func (m *messagesComponent) header() string {
-	if m.app.Session.Id == "" {
+	if m.app.Session.ID == "" {
 		return ""
 	}

 	t := theme.CurrentTheme()
 	width := layout.Current.Container.Width
-	base := styles.BaseStyle().Background(t.Background()).Render
-	muted := styles.Muted().Background(t.Background()).Render
+	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, toMarkdown("# "+m.app.Session.Title, width-6, t.Background()))
-	if m.app.Session.Share != nil && m.app.Session.Share.Url != "" {
-		headerLines = append(headerLines, muted(m.app.Session.Share.Url))
+	if m.app.Session.Share.URL != "" {
+		headerLines = append(headerLines, muted(m.app.Session.Share.URL))
 	} else {
 		headerLines = append(headerLines, base("/share")+muted(" to create a shareable link"))
 	}
 	header := strings.Join(headerLines, "\n")

-	header = styles.BaseStyle().
+	header = styles.NewStyle().
+		Background(t.Background()).
 		Width(width).
 		PaddingLeft(2).
 		PaddingRight(2).
-		Background(t.Background()).
 		BorderLeft(true).
 		BorderRight(true).
 		BorderBackground(t.Background()).
@@ -300,7 +319,7 @@ func (m *messagesComponent) View() string {
 			m.width,
 			lipgloss.Center,
 			m.header(),
-			lipgloss.WithWhitespaceStyle(lipgloss.NewStyle().Background(t.Background())),
+			styles.WhitespaceStyle(t.Background()),
 		),
 		m.viewport.View(),
 	)
@@ -308,9 +327,9 @@ func (m *messagesComponent) View() string {

 func (m *messagesComponent) home() string {
 	t := theme.CurrentTheme()
-	baseStyle := styles.BaseStyle().Background(t.Background())
+	baseStyle := styles.NewStyle().Background(t.Background())
 	base := baseStyle.Render
-	muted := styles.Muted().Background(t.Background()).Render
+	muted := styles.NewStyle().Foreground(t.TextMuted()).Background(t.Background()).Render

 	open := `
 █▀▀█ █▀▀█ █▀▀ █▀▀▄ 
@@ -329,9 +348,9 @@ func (m *messagesComponent) home() string {
 	// cwd := app.Info.Path.Cwd
 	// config := app.Info.Path.Config

-	versionStyle := lipgloss.NewStyle().
-		Background(t.Background()).
+	versionStyle := styles.NewStyle().
 		Foreground(t.TextMuted()).
+		Background(t.Background()).
 		Width(lipgloss.Width(logo)).
 		Align(lipgloss.Right)
 	version := versionStyle.Render(m.app.Version)
@@ -341,14 +360,14 @@ func (m *messagesComponent) home() string {
 		m.width,
 		lipgloss.Center,
 		logoAndVersion,
-		lipgloss.WithWhitespaceStyle(lipgloss.NewStyle().Background(t.Background())),
+		styles.WhitespaceStyle(t.Background()),
 	)
 	m.commands.SetBackgroundColor(t.Background())
 	commands := lipgloss.PlaceHorizontal(
 		m.width,
 		lipgloss.Center,
 		m.commands.View(),
-		lipgloss.WithWhitespaceStyle(lipgloss.NewStyle().Background(t.Background())),
+		styles.WhitespaceStyle(t.Background()),
 	)

 	lines := []string{}
@@ -366,7 +385,7 @@ func (m *messagesComponent) home() string {
 		lipgloss.Center,
 		lipgloss.Center,
 		baseStyle.Render(strings.Join(lines, "\n")),
-		lipgloss.WithWhitespaceStyle(lipgloss.NewStyle().Background(t.Background())),
+		styles.WhitespaceStyle(t.Background()),
 	)
 }

@@ -25,6 +25,7 @@ type commandsComponent struct {
 	app           *app.App
 	width, height int
 	showKeybinds  bool
+	showAll       bool
 	background    *compat.AdaptiveColor
 	limit         *int
 }
@@ -59,15 +60,9 @@ func (c *commandsComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 func (c *commandsComponent) View() string {
 	t := theme.CurrentTheme()

-	triggerStyle := lipgloss.NewStyle().
-		Foreground(t.Primary()).
-		Bold(true)
-
-	descriptionStyle := lipgloss.NewStyle().
-		Foreground(t.Text())
-
-	keybindStyle := lipgloss.NewStyle().
-		Foreground(t.TextMuted())
+	triggerStyle := styles.NewStyle().Foreground(t.Primary()).Bold(true)
+	descriptionStyle := styles.NewStyle().Foreground(t.Text())
+	keybindStyle := styles.NewStyle().Foreground(t.TextMuted())

 	if c.background != nil {
 		triggerStyle = triggerStyle.Background(*c.background)
@@ -75,18 +70,34 @@ func (c *commandsComponent) View() string {
 		keybindStyle = keybindStyle.Background(*c.background)
 	}

-	var commandsWithTriggers []commands.Command
+	var commandsToShow []commands.Command
+	var triggeredCommands []commands.Command
+	var untriggeredCommands []commands.Command
+
 	for _, cmd := range c.app.Commands.Sorted() {
-		if cmd.Trigger != "" {
-			commandsWithTriggers = append(commandsWithTriggers, cmd)
+		if c.showAll || cmd.Trigger != "" {
+			if cmd.Trigger != "" {
+				triggeredCommands = append(triggeredCommands, cmd)
+			} else if c.showAll {
+				untriggeredCommands = append(untriggeredCommands, cmd)
+			}
 		}
 	}
-	if c.limit != nil && len(commandsWithTriggers) > *c.limit {
-		commandsWithTriggers = commandsWithTriggers[:*c.limit]
+
+	// Combine triggered commands first, then untriggered
+	commandsToShow = append(commandsToShow, triggeredCommands...)
+	commandsToShow = append(commandsToShow, untriggeredCommands...)
+
+	if c.limit != nil && len(commandsToShow) > *c.limit {
+		commandsToShow = commandsToShow[:*c.limit]
 	}

-	if len(commandsWithTriggers) == 0 {
-		return styles.Muted().Render("No commands with triggers available")
+	if len(commandsToShow) == 0 {
+		muted := styles.NewStyle().Foreground(theme.CurrentTheme().TextMuted())
+		if c.showAll {
+			return muted.Render("No commands available")
+		}
+		return muted.Render("No commands with triggers available")
 	}

 	// Calculate column widths
@@ -101,10 +112,15 @@ func (c *commandsComponent) View() string {
 		keybinds    string
 	}

-	rows := make([]commandRow, 0, len(commandsWithTriggers))
+	rows := make([]commandRow, 0, len(commandsToShow))

-	for _, cmd := range commandsWithTriggers {
-		trigger := "/" + cmd.Trigger
+	for _, cmd := range commandsToShow {
+		trigger := ""
+		if cmd.Trigger != "" {
+			trigger = "/" + cmd.Trigger
+		} else {
+			trigger = string(cmd.Name)
+		}
 		description := cmd.Description

 		// Format keybindings
@@ -112,7 +128,7 @@ func (c *commandsComponent) View() string {
 		if c.showKeybinds {
 			for _, kb := range cmd.Keybindings {
 				if kb.RequiresLeader {
-					keybindStrs = append(keybindStrs, *c.app.Config.Keybinds.Leader+" "+kb.Key)
+					keybindStrs = append(keybindStrs, c.app.Config.Keybinds.Leader+" "+kb.Key)
 				} else {
 					keybindStrs = append(keybindStrs, kb.Key)
 				}
@@ -144,6 +160,7 @@ func (c *commandsComponent) View() string {
 	// Build the output
 	var output strings.Builder

+	maxWidth := 0
 	for _, row := range rows {
 		// Pad each column to align properly
 		trigger := fmt.Sprintf("%-*s", maxTriggerWidth, row.trigger)
@@ -160,10 +177,14 @@ func (c *commandsComponent) View() string {
 		}

 		output.WriteString(line + "\n")
+		maxWidth = max(maxWidth, lipgloss.Width(line))
 	}

 	// Remove trailing newline
 	result := strings.TrimSuffix(output.String(), "\n")
+	if c.background != nil {
+		result = styles.NewStyle().Background(*c.background).Width(maxWidth).Render(result)
+	}

 	return result
 }
@@ -188,11 +209,18 @@ func WithLimit(limit int) Option {
 	}
 }

+func WithShowAll(showAll bool) Option {
+	return func(c *commandsComponent) {
+		c.showAll = showAll
+	}
+}
+
 func New(app *app.App, opts ...Option) CommandsComponent {
 	c := &commandsComponent{
 		app:          app,
 		background:   nil,
 		showKeybinds: true,
+		showAll:      false,
 	}
 	for _, opt := range opts {
 		opt(c)
@@ -6,6 +6,7 @@ import (
 	"github.com/charmbracelet/bubbles/v2/key"
 	"github.com/charmbracelet/bubbles/v2/textarea"
 	tea "github.com/charmbracelet/bubbletea/v2"
+	"github.com/charmbracelet/lipgloss/v2"
 	"github.com/sst/opencode/internal/app"
 	"github.com/sst/opencode/internal/components/list"
 	"github.com/sst/opencode/internal/styles"
@@ -26,7 +27,7 @@ type CompletionItemI interface {

 func (ci *CompletionItem) Render(selected bool, width int) string {
 	t := theme.CurrentTheme()
-	baseStyle := styles.BaseStyle()
+	baseStyle := styles.NewStyle().Foreground(t.Text())

 	itemStyle := baseStyle.
 		Background(t.BackgroundElement()).
@@ -34,8 +35,7 @@ func (ci *CompletionItem) Render(selected bool, width int) string {
 		Padding(0, 1)

 	if selected {
-		itemStyle = itemStyle.
-			Foreground(t.Primary())
+		itemStyle = itemStyle.Foreground(t.Primary())
 	}

 	title := itemStyle.Render(
@@ -116,7 +116,7 @@ func (c *completionDialogComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
 	case []CompletionItemI:
 		c.list.SetItems(msg)
-	case app.CompletionDialogTriggerdMsg:
+	case app.CompletionDialogTriggeredMsg:
 		c.pseudoSearchTextArea.SetValue(msg.InitialValue)
 	case tea.KeyMsg:
 		if c.pseudoSearchTextArea.Focused() {
@@ -185,7 +185,7 @@ func (c *completionDialogComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {

 func (c *completionDialogComponent) View() string {
 	t := theme.CurrentTheme()
-	baseStyle := styles.BaseStyle()
+	baseStyle := styles.NewStyle().Foreground(t.Text())

 	maxWidth := 40
 	completions := c.list.GetItems()
@@ -199,8 +199,14 @@ func (c *completionDialogComponent) View() string {

 	c.list.SetMaxWidth(maxWidth)

-	return baseStyle.Padding(0, 0).
+	return baseStyle.
+		Padding(0, 0).
 		Background(t.BackgroundElement()).
+		BorderStyle(lipgloss.ThickBorder()).
+		BorderLeft(true).
+		BorderRight(true).
+		BorderForeground(t.Border()).
+		BorderBackground(t.Background()).
 		Width(c.width).
 		Render(c.list.View())
 }
@@ -1,71 +1,62 @@
 package dialog

 import (
-	"strings"
-
+	"github.com/charmbracelet/bubbles/v2/viewport"
 	tea "github.com/charmbracelet/bubbletea/v2"
-	"github.com/charmbracelet/lipgloss/v2"
-	"github.com/sst/opencode/internal/commands"
+	"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"
 )

 type helpDialog struct {
-	width    int
-	height   int
-	modal    *modal.Modal
-	commands []commands.Command
+	width             int
+	height            int
+	modal             *modal.Modal
+	app               *app.App
+	commandsComponent commandsComponent.CommandsComponent
+	viewport          viewport.Model
 }

 func (h *helpDialog) Init() tea.Cmd {
-	return nil
+	return tea.Batch(
+		h.commandsComponent.Init(),
+		h.viewport.Init(),
+	)
 }

 func (h *helpDialog) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	var cmds []tea.Cmd
+
 	switch msg := msg.(type) {
 	case tea.WindowSizeMsg:
 		h.width = msg.Width
 		h.height = msg.Height
+		// Set viewport size with some padding for the modal
+		h.viewport = viewport.New(viewport.WithWidth(msg.Width-4), viewport.WithHeight(msg.Height-6))
+		h.commandsComponent.SetSize(msg.Width-4, msg.Height-6)
 	}
-	return h, nil
+
+	// Update commands component first to get the latest content
+	_, cmdCmd := h.commandsComponent.Update(msg)
+	cmds = append(cmds, cmdCmd)
+
+	// Update viewport content
+	h.viewport.SetContent(h.commandsComponent.View())
+
+	// Update viewport
+	var vpCmd tea.Cmd
+	h.viewport, vpCmd = h.viewport.Update(msg)
+	cmds = append(cmds, vpCmd)
+
+	return h, tea.Batch(cmds...)
 }

 func (h *helpDialog) View() string {
 	t := theme.CurrentTheme()
-	keyStyle := lipgloss.NewStyle().
-		Background(t.BackgroundElement()).
-		Foreground(t.Text()).
-		Bold(true)
-	descStyle := lipgloss.NewStyle().
-		Background(t.BackgroundElement()).
-		Foreground(t.TextMuted())
-	contentStyle := lipgloss.NewStyle().
-		PaddingLeft(1).Background(t.BackgroundElement())
-
-	lines := []string{}
-	for _, b := range h.commands {
-		// Only interested in slash commands
-		if b.Trigger == "" {
-			continue
-		}
-
-		content := keyStyle.Render("/" + b.Trigger)
-		content += descStyle.Render(" " + b.Description)
-		// for i, key := range b.Keybindings {
-		// 	if i == 0 {
-		// keyString := " (" + key.Key + ")"
-		// space := max(h.width-lipgloss.Width(content)-lipgloss.Width(keyString), 0)
-		// spacer := strings.Repeat(" ", space)
-		// content += descStyle.Render(spacer)
-		// content += descStyle.Render(keyString)
-		// 	}
-		// }
-
-		lines = append(lines, contentStyle.Render(content))
-	}
-
-	return strings.Join(lines, "\n")
+	h.commandsComponent.SetBackgroundColor(t.BackgroundElement())
+	return h.viewport.View()
 }

 func (h *helpDialog) Render(background string) string {
@@ -80,9 +71,16 @@ type HelpDialog interface {
 	layout.Modal
 }

-func NewHelpDialog(commands []commands.Command) HelpDialog {
+func NewHelpDialog(app *app.App) HelpDialog {
+	vp := viewport.New(viewport.WithHeight(12))
 	return &helpDialog{
-		commands: commands,
+		app: app,
+		commandsComponent: commandsComponent.New(app,
+			commandsComponent.WithBackground(theme.CurrentTheme().BackgroundElement()),
+			commandsComponent.WithShowAll(true),
+			commandsComponent.WithKeybinds(true),
+		),
 		modal:    modal.New(modal.WithTitle("Help")),
+		viewport: vp,
 	}
 }
@@ -94,7 +94,7 @@ func (m InitDialogCmp) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 // View implements tea.Model.
 func (m InitDialogCmp) View() string {
 	t := theme.CurrentTheme()
-	baseStyle := styles.BaseStyle()
+	baseStyle := styles.NewStyle().Foreground(t.Text())

 	// Calculate width needed for content
 	maxWidth := 60 // Width for explanation text
@@ -10,13 +10,14 @@ import (
 	"github.com/charmbracelet/bubbles/v2/key"
 	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/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"
-	"github.com/sst/opencode/pkg/client"
 )

 const (
@@ -31,22 +32,17 @@ type ModelDialog interface {

 type modelDialog struct {
 	app                *app.App
-	availableProviders []client.ProviderInfo
-	provider           client.ProviderInfo
-
-	selectedIdx     int
-	width           int
-	height          int
-	scrollOffset    int
-	hScrollOffset   int
-	hScrollPossible bool
-
-	modal *modal.Modal
+	availableProviders []opencode.Provider
+	provider           opencode.Provider
+	width              int
+	height             int
+	hScrollOffset      int
+	hScrollPossible    bool
+	modal              *modal.Modal
+	modelList          list.List[list.StringItem]
 }

 type modelKeyMap struct {
-	Up     key.Binding
-	Down   key.Binding
 	Left   key.Binding
 	Right  key.Binding
 	Enter  key.Binding
@@ -54,14 +50,6 @@ type modelKeyMap struct {
 }

 var modelKeys = modelKeyMap{
-	Up: key.NewBinding(
-		key.WithKeys("up", "k"),
-		key.WithHelp("↑", "previous model"),
-	),
-	Down: key.NewBinding(
-		key.WithKeys("down", "j"),
-		key.WithHelp("↓", "next model"),
-	),
 	Left: key.NewBinding(
 		key.WithKeys("left", "h"),
 		key.WithHelp("←", "scroll left"),
@@ -81,15 +69,7 @@ var modelKeys = modelKeyMap{
 }

 func (m *modelDialog) Init() tea.Cmd {
-	// cfg := config.Get()
-	// modelInfo := GetSelectedModel(cfg)
-	// m.availableProviders = getEnabledProviders(cfg)
-	// m.hScrollPossible = len(m.availableProviders) > 1
-
-	// m.provider = modelInfo.Provider
-	// m.hScrollOffset = findProviderIndex(m.availableProviders, m.provider)
-
-	// m.setupModelsForProvider(m.provider)
+	m.setupModelsForProvider(m.provider.ID)
 	return nil
 }

@@ -97,26 +77,32 @@ func (m *modelDialog) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
 	case tea.KeyMsg:
 		switch {
-		case key.Matches(msg, modelKeys.Up):
-			m.moveSelectionUp()
-		case key.Matches(msg, modelKeys.Down):
-			m.moveSelectionDown()
 		case key.Matches(msg, modelKeys.Left):
 			if m.hScrollPossible {
 				m.switchProvider(-1)
 			}
+			return m, nil
 		case key.Matches(msg, modelKeys.Right):
 			if m.hScrollPossible {
 				m.switchProvider(1)
 			}
+			return m, nil
 		case key.Matches(msg, modelKeys.Enter):
+			selectedItem, _ := m.modelList.GetSelectedItem()
 			models := m.models()
+			var selectedModel opencode.Model
+			for _, model := range models {
+				if model.Name == string(selectedItem) {
+					selectedModel = model
+					break
+				}
+			}
 			return m, tea.Sequence(
 				util.CmdHandler(modal.CloseModalMsg{}),
 				util.CmdHandler(
 					app.ModelSelectedMsg{
 						Provider: m.provider,
-						Model:    models[m.selectedIdx],
+						Model:    selectedModel,
 					}),
 			)
 		case key.Matches(msg, modelKeys.Escape):
@@ -127,50 +113,22 @@ func (m *modelDialog) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		m.height = msg.Height
 	}

-	return m, nil
+	// Update the list component
+	updatedList, cmd := m.modelList.Update(msg)
+	m.modelList = updatedList.(list.List[list.StringItem])
+	return m, cmd
 }

-func (m *modelDialog) models() []client.ModelInfo {
-	models := slices.SortedFunc(maps.Values(m.provider.Models), func(a, b client.ModelInfo) int {
+func (m *modelDialog) models() []opencode.Model {
+	models := slices.SortedFunc(maps.Values(m.provider.Models), func(a, b opencode.Model) int {
 		return strings.Compare(a.Name, b.Name)
 	})
 	return models
 }

-// moveSelectionUp moves the selection up or wraps to bottom
-func (m *modelDialog) moveSelectionUp() {
-	if m.selectedIdx > 0 {
-		m.selectedIdx--
-	} else {
-		m.selectedIdx = len(m.provider.Models) - 1
-		m.scrollOffset = max(0, len(m.provider.Models)-numVisibleModels)
-	}
-
-	// Keep selection visible
-	if m.selectedIdx < m.scrollOffset {
-		m.scrollOffset = m.selectedIdx
-	}
-}
-
-// moveSelectionDown moves the selection down or wraps to top
-func (m *modelDialog) moveSelectionDown() {
-	if m.selectedIdx < len(m.provider.Models)-1 {
-		m.selectedIdx++
-	} else {
-		m.selectedIdx = 0
-		m.scrollOffset = 0
-	}
-
-	// Keep selection visible
-	if m.selectedIdx >= m.scrollOffset+numVisibleModels {
-		m.scrollOffset = m.selectedIdx - (numVisibleModels - 1)
-	}
-}
-
 func (m *modelDialog) switchProvider(offset int) {
 	newOffset := m.hScrollOffset + offset

-	// Ensure we stay within bounds
 	if newOffset < 0 {
 		newOffset = len(m.availableProviders) - 1
 	}
@@ -181,109 +139,50 @@ func (m *modelDialog) switchProvider(offset int) {
 	m.hScrollOffset = newOffset
 	m.provider = m.availableProviders[m.hScrollOffset]
 	m.modal.SetTitle(fmt.Sprintf("Select %s Model", m.provider.Name))
-	m.setupModelsForProvider(m.provider.Id)
+	m.setupModelsForProvider(m.provider.ID)
 }

 func (m *modelDialog) View() string {
-	t := theme.CurrentTheme()
-	baseStyle := lipgloss.NewStyle().
-		Background(t.BackgroundElement()).
-		Foreground(t.Text())
-
-	// Render visible models
-	endIdx := min(m.scrollOffset+numVisibleModels, len(m.provider.Models))
-	modelItems := make([]string, 0, endIdx-m.scrollOffset)
-
-	models := m.models()
-	for i := m.scrollOffset; i < endIdx; i++ {
-		itemStyle := baseStyle.Width(maxDialogWidth)
-		if i == m.selectedIdx {
-			itemStyle = itemStyle.
-				Background(t.Primary()).
-				Foreground(t.BackgroundElement()).
-				Bold(true)
-		}
-		modelItems = append(modelItems, itemStyle.Render(models[i].Name))
-	}
-
+	listView := m.modelList.View()
 	scrollIndicator := m.getScrollIndicators(maxDialogWidth)
-
-	content := lipgloss.JoinVertical(
-		lipgloss.Left,
-		baseStyle.
-			Width(maxDialogWidth).
-			Render(lipgloss.JoinVertical(lipgloss.Left, modelItems...)),
-		scrollIndicator,
-	)
-
-	return content
+	return strings.Join([]string{listView, scrollIndicator}, "\n")
 }

 func (m *modelDialog) getScrollIndicators(maxWidth int) string {
 	var indicator string
-
-	if len(m.provider.Models) > numVisibleModels {
-		if m.scrollOffset > 0 {
-			indicator += "↑ "
-		}
-		if m.scrollOffset+numVisibleModels < len(m.provider.Models) {
-			indicator += "↓ "
-		}
-	}
-
 	if m.hScrollPossible {
-		indicator = "← " + indicator + "→"
+		indicator = "← → (switch provider) "
 	}
-
 	if indicator == "" {
 		return ""
 	}

 	t := theme.CurrentTheme()
-	baseStyle := styles.BaseStyle()
-
-	return baseStyle.
-		Foreground(t.Primary()).
+	return styles.NewStyle().
+		Foreground(t.TextMuted()).
 		Width(maxWidth).
 		Align(lipgloss.Right).
-		Bold(true).
 		Render(indicator)
 }

-// findProviderIndex returns the index of the provider in the list, or -1 if not found
-// func findProviderIndex(providers []string, provider string) int {
-// 	for i, p := range providers {
-// 		if p == provider {
-// 			return i
-// 		}
-// 	}
-// 	return -1
-// }
+func (m *modelDialog) setupModelsForProvider(providerId string) {
+	models := m.models()
+	modelNames := make([]string, len(models))
+	for i, model := range models {
+		modelNames[i] = model.Name
+	}

-func (m *modelDialog) setupModelsForProvider(_ string) {
-	m.selectedIdx = 0
-	m.scrollOffset = 0
+	m.modelList = list.NewStringList(modelNames, numVisibleModels, "No models available", true)
+	m.modelList.SetMaxWidth(maxDialogWidth)

-	// cfg := config.Get()
-	// agentCfg := cfg.Agents[config.AgentPrimary]
-	// selectedModelId := agentCfg.Model
-
-	// m.provider = provider
-	// m.models = getModelsForProvider(provider)
-
-	// Try to select the current model if it belongs to this provider
-	// if provider == models.SupportedModels[selectedModelId].Provider {
-	// 	for i, model := range m.models {
-	// 		if model.ID == selectedModelId {
-	// 			m.selectedIdx = i
-	// 			// Adjust scroll position to keep selected model visible
-	// 			if m.selectedIdx >= numVisibleModels {
-	// 				m.scrollOffset = m.selectedIdx - (numVisibleModels - 1)
-	// 			}
-	// 			break
-	// 		}
-	// 	}
-	// }
+	if m.app.Provider != nil && m.app.Model != nil && m.app.Provider.ID == providerId {
+		for i, model := range models {
+			if model.ID == m.app.Model.ID {
+				m.modelList.SetSelectedIndex(i)
+				break
+			}
+		}
+	}
 }

 func (m *modelDialog) Render(background string) string {
@@ -297,11 +196,30 @@ func (s *modelDialog) Close() tea.Cmd {
 func NewModelDialog(app *app.App) ModelDialog {
 	availableProviders, _ := app.ListProviders(context.Background())

-	return &modelDialog{
-		availableProviders: availableProviders,
-		hScrollOffset:      0,
-		hScrollPossible:    len(availableProviders) > 1,
-		provider:           availableProviders[0],
-		modal:              modal.New(modal.WithTitle(fmt.Sprintf("Select %s Model", availableProviders[0].Name))),
+	currentProvider := availableProviders[0]
+	hScrollOffset := 0
+	if app.Provider != nil {
+		for i, provider := range availableProviders {
+			if provider.ID == app.Provider.ID {
+				currentProvider = provider
+				hScrollOffset = i
+				break
+			}
+		}
 	}
+
+	dialog := &modelDialog{
+		app:                app,
+		availableProviders: availableProviders,
+		hScrollOffset:      hScrollOffset,
+		hScrollPossible:    len(availableProviders) > 1,
+		provider:           currentProvider,
+		modal: modal.New(
+			modal.WithTitle(fmt.Sprintf("Select %s Model", currentProvider.Name)),
+			modal.WithMaxWidth(maxDialogWidth+4),
+		),
+	}
+
+	dialog.setupModelsForProvider(currentProvider.ID)
+	return dialog
 }
@@ -145,7 +145,7 @@ func (p *permissionDialogComponent) selectCurrentOption() tea.Cmd {

 func (p *permissionDialogComponent) renderButtons() string {
 	t := theme.CurrentTheme()
-	baseStyle := styles.BaseStyle()
+	baseStyle := styles.NewStyle().Foreground(t.Text())

 	allowStyle := baseStyle
 	allowSessionStyle := baseStyle
@@ -355,8 +355,7 @@ func (p *permissionDialogComponent) renderDefaultContent() string {

 func (p *permissionDialogComponent) styleViewport() string {
 	t := theme.CurrentTheme()
-	contentStyle := lipgloss.NewStyle().
-		Background(t.Background())
+	contentStyle := styles.NewStyle().Background(t.Background())

 	return contentStyle.Render(p.contentViewPort.View())
 }
@@ -2,16 +2,21 @@ package dialog

 import (
 	"context"
+	"strings"
+
+	"slices"

 	tea "github.com/charmbracelet/bubbletea/v2"
+	"github.com/muesli/reflow/truncate"
+	"github.com/sst/opencode-sdk-go"
 	"github.com/sst/opencode/internal/app"
 	"github.com/sst/opencode/internal/components/list"
 	"github.com/sst/opencode/internal/components/modal"
+	"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/pkg/client"
 )

 // SessionDialog interface for the session switching dialog
@@ -19,33 +24,65 @@ type SessionDialog interface {
 	layout.Modal
 }

-type sessionItem client.SessionInfo
+// sessionItem is a custom list item for sessions that can show delete confirmation
+type sessionItem struct {
+	title              string
+	isDeleteConfirming bool
+}

 func (s sessionItem) Render(selected bool, width int) string {
 	t := theme.CurrentTheme()
-	baseStyle := styles.BaseStyle().
-		Width(width - 4).
-		Background(t.BackgroundElement())
+	baseStyle := styles.NewStyle()

-	if selected {
-		baseStyle = baseStyle.
-			Background(t.Primary()).
-			Foreground(t.BackgroundElement()).
-			Bold(true)
+	var text string
+	if s.isDeleteConfirming {
+		text = "Press again to confirm delete"
 	} else {
-		baseStyle = baseStyle.
-			Foreground(t.Text())
+		text = s.title
 	}

-	return baseStyle.Padding(0, 1).Render(s.Title)
+	truncatedStr := truncate.StringWithTail(text, uint(width-1), "...")
+
+	var itemStyle styles.Style
+	if selected {
+		if s.isDeleteConfirming {
+			// Red background for delete confirmation
+			itemStyle = baseStyle.
+				Background(t.Error()).
+				Foreground(t.BackgroundElement()).
+				Width(width).
+				PaddingLeft(1)
+		} else {
+			// Normal selection
+			itemStyle = baseStyle.
+				Background(t.Primary()).
+				Foreground(t.BackgroundElement()).
+				Width(width).
+				PaddingLeft(1)
+		}
+	} else {
+		if s.isDeleteConfirming {
+			// Red text for delete confirmation when not selected
+			itemStyle = baseStyle.
+				Foreground(t.Error()).
+				PaddingLeft(1)
+		} else {
+			itemStyle = baseStyle.
+				PaddingLeft(1)
+		}
+	}
+
+	return itemStyle.Render(truncatedStr)
 }

 type sessionDialog struct {
-	width             int
-	height            int
-	modal             *modal.Modal
-	selectedSessionID string
-	list              list.List[sessionItem]
+	width              int
+	height             int
+	modal              *modal.Modal
+	sessions           []opencode.Session
+	list               list.List[sessionItem]
+	app                *app.App
+	deleteConfirmation int // -1 means no confirmation, >= 0 means confirming deletion of session at this index
 }

 func (s *sessionDialog) Init() tea.Cmd {
@@ -61,13 +98,45 @@ func (s *sessionDialog) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	case tea.KeyPressMsg:
 		switch msg.String() {
 		case "enter":
-			if item, idx := s.list.GetSelectedItem(); idx >= 0 {
-				s.selectedSessionID = item.Id
+			if s.deleteConfirmation >= 0 {
+				s.deleteConfirmation = -1
+				s.updateListItems()
+				return s, nil
+			}
+			if _, idx := s.list.GetSelectedItem(); idx >= 0 && idx < len(s.sessions) {
+				selectedSession := s.sessions[idx]
 				return s, tea.Sequence(
 					util.CmdHandler(modal.CloseModalMsg{}),
-					util.CmdHandler(app.SessionSelectedMsg(&item)),
+					util.CmdHandler(app.SessionSelectedMsg(&selectedSession)),
 				)
 			}
+		case "x", "delete", "backspace":
+			if _, idx := s.list.GetSelectedItem(); idx >= 0 && idx < len(s.sessions) {
+				if s.deleteConfirmation == idx {
+					// Second press - actually delete the session
+					sessionToDelete := s.sessions[idx]
+					return s, tea.Sequence(
+						func() tea.Msg {
+							s.sessions = slices.Delete(s.sessions, idx, idx+1)
+							s.deleteConfirmation = -1
+							s.updateListItems()
+							return nil
+						},
+						s.deleteSession(sessionToDelete.ID),
+					)
+				} else {
+					// First press - enter delete confirmation mode
+					s.deleteConfirmation = idx
+					s.updateListItems()
+					return s, nil
+				}
+			}
+		case "esc":
+			if s.deleteConfirmation >= 0 {
+				s.deleteConfirmation = -1
+				s.updateListItems()
+				return s, nil
+			}
 		}
 	}

@@ -78,7 +147,42 @@ func (s *sessionDialog) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 }

 func (s *sessionDialog) Render(background string) string {
-	return s.modal.Render(s.list.View(), background)
+	listView := s.list.View()
+
+	t := theme.CurrentTheme()
+	helpStyle := styles.NewStyle().PaddingLeft(1).PaddingTop(1)
+	helpText := styles.NewStyle().Foreground(t.Text()).Render("x/del")
+	helpText = helpText + styles.NewStyle().Background(t.BackgroundElement()).Foreground(t.TextMuted()).Render(" delete session")
+	helpText = helpStyle.Render(helpText)
+
+	content := strings.Join([]string{listView, helpText}, "\n")
+
+	return s.modal.Render(content, background)
+}
+
+func (s *sessionDialog) updateListItems() {
+	_, currentIdx := s.list.GetSelectedItem()
+
+	var items []sessionItem
+	for i, sess := range s.sessions {
+		item := sessionItem{
+			title:              sess.Title,
+			isDeleteConfirming: s.deleteConfirmation == i,
+		}
+		items = append(items, item)
+	}
+	s.list.SetItems(items)
+	s.list.SetSelectedIndex(currentIdx)
+}
+
+func (s *sessionDialog) deleteSession(sessionID string) tea.Cmd {
+	return func() tea.Msg {
+		ctx := context.Background()
+		if err := s.app.DeleteSession(ctx, sessionID); err != nil {
+			return toast.NewErrorToast("Failed to delete session: " + err.Error())()
+		}
+		return nil
+	}
 }

 func (s *sessionDialog) Close() tea.Cmd {
@@ -89,23 +193,36 @@ func (s *sessionDialog) Close() tea.Cmd {
 func NewSessionDialog(app *app.App) SessionDialog {
 	sessions, _ := app.ListSessions(context.Background())

-	var sessionItems []sessionItem
+	var filteredSessions []opencode.Session
+	var items []sessionItem
 	for _, sess := range sessions {
-		if sess.ParentID != nil {
+		if sess.ParentID != "" {
 			continue
 		}
-		sessionItems = append(sessionItems, sessionItem(sess))
+		filteredSessions = append(filteredSessions, sess)
+		items = append(items, sessionItem{
+			title:              sess.Title,
+			isDeleteConfirming: false,
+		})
 	}

-	list := list.NewListComponent(
-		sessionItems,
+	// Create a generic list component
+	listComponent := list.NewListComponent(
+		items,
 		10, // maxVisibleSessions
 		"No sessions available",
 		true, // useAlphaNumericKeys
 	)
+	listComponent.SetMaxWidth(layout.Current.Container.Width - 12)

 	return &sessionDialog{
-		list:  list,
-		modal: modal.New(modal.WithTitle("Switch Session"), modal.WithMaxWidth(80)),
+		sessions:           filteredSessions,
+		list:               listComponent,
+		app:                app,
+		deleteConfirmation: -1,
+		modal: modal.New(
+			modal.WithTitle("Switch Session"),
+			modal.WithMaxWidth(layout.Current.Container.Width-8),
+		),
 	}
 }
@@ -5,7 +5,6 @@ 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"
 )
@@ -20,35 +19,14 @@ type ThemeDialog interface {
 	layout.Modal
 }

-type themeItem struct {
-	name string
-}
-
-func (t themeItem) Render(selected bool, width int) string {
-	th := theme.CurrentTheme()
-	baseStyle := styles.BaseStyle().
-		Width(width - 2).
-		Background(th.BackgroundElement())
-
-	if selected {
-		baseStyle = baseStyle.
-			Background(th.Primary()).
-			Foreground(th.BackgroundElement()).
-			Bold(true)
-	} else {
-		baseStyle = baseStyle.
-			Foreground(th.Text())
-	}
-
-	return baseStyle.Padding(0, 1).Render(t.name)
-}
-
 type themeDialog struct {
 	width  int
 	height int

-	modal *modal.Modal
-	list  list.List[themeItem]
+	modal         *modal.Modal
+	list          list.List[list.StringItem]
+	originalTheme string
+	themeApplied  bool
 }

 func (t *themeDialog) Init() tea.Cmd {
@@ -64,26 +42,31 @@ func (t *themeDialog) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		switch msg.String() {
 		case "enter":
 			if item, idx := t.list.GetSelectedItem(); idx >= 0 {
-				previousTheme := theme.CurrentThemeName()
-				selectedTheme := item.name
-				if previousTheme == selectedTheme {
-					return t, util.CmdHandler(modal.CloseModalMsg{})
-				}
+				selectedTheme := string(item)
 				if err := theme.SetTheme(selectedTheme); err != nil {
 					// status.Error(err.Error())
 					return t, nil
 				}
+				t.themeApplied = true
 				return t, tea.Sequence(
 					util.CmdHandler(modal.CloseModalMsg{}),
 					util.CmdHandler(ThemeSelectedMsg{ThemeName: selectedTheme}),
 				)
 			}
+
 		}
 	}

+	_, prevIdx := t.list.GetSelectedItem()
+
 	var cmd tea.Cmd
 	listModel, cmd := t.list.Update(msg)
-	t.list = listModel.(list.List[themeItem])
+	t.list = listModel.(list.List[list.StringItem])
+
+	if item, newIdx := t.list.GetSelectedItem(); newIdx >= 0 && newIdx != prevIdx {
+		theme.SetTheme(string(item))
+		return t, util.CmdHandler(ThemeSelectedMsg{ThemeName: string(item)})
+	}
 	return t, cmd
 }

@@ -92,6 +75,10 @@ func (t *themeDialog) Render(background string) string {
 }

 func (t *themeDialog) Close() tea.Cmd {
+	if !t.themeApplied {
+		theme.SetTheme(t.originalTheme)
+		return util.CmdHandler(ThemeSelectedMsg{ThemeName: t.originalTheme})
+	}
 	return nil
 }

@@ -100,17 +87,15 @@ func NewThemeDialog() ThemeDialog {
 	themes := theme.AvailableThemes()
 	currentTheme := theme.CurrentThemeName()

-	var themeItems []themeItem
 	var selectedIdx int
 	for i, name := range themes {
-		themeItems = append(themeItems, themeItem{name: name})
 		if name == currentTheme {
 			selectedIdx = i
 		}
 	}

-	list := list.NewListComponent(
-		themeItems,
+	list := list.NewStringList(
+		themes,
 		10, // maxVisibleThemes
 		"No themes available",
 		true,
@@ -119,8 +104,13 @@ func NewThemeDialog() ThemeDialog {
 	// Set the initial selection to the current theme
 	list.SetSelectedIndex(selectedIdx)

+	// Set the max width for the list to match the modal width
+	list.SetMaxWidth(36) // 40 (modal max width) - 4 (modal padding)
+
 	return &themeDialog{
-		list:  list,
-		modal: modal.New(modal.WithTitle("Select Theme"), modal.WithMaxWidth(40)),
+		list:          list,
+		modal:         modal.New(modal.WithTitle("Select Theme"), modal.WithMaxWidth(40)),
+		originalTheme: currentTheme,
+		themeApplied:  false,
 	}
 }
@@ -8,6 +8,7 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
+	"sync"

 	"github.com/alecthomas/chroma/v2"
 	"github.com/alecthomas/chroma/v2/formatters"
@@ -19,6 +20,7 @@ import (
 	"github.com/sergi/go-diff/diffmatchpatch"
 	stylesi "github.com/sst/opencode/internal/styles"
 	"github.com/sst/opencode/internal/theme"
+	"github.com/sst/opencode/internal/util"
 )

 // -------------------------------------------------------------------------
@@ -441,84 +443,84 @@ func SyntaxHighlight(w io.Writer, source, fileName, formatter string, bg color.C
 	<entry type="TextWhitespace" style="%s"/>
 </style>
 `,
-		getColor(t.BackgroundPanel()), // Background
-		getColor(t.Text()),            // Text
-		getColor(t.Text()),            // Other
-		getColor(t.Error()),           // Error
+		getChromaColor(t.BackgroundPanel()), // Background
+		getChromaColor(t.Text()),            // Text
+		getChromaColor(t.Text()),            // Other
+		getChromaColor(t.Error()),           // Error

-		getColor(t.SyntaxKeyword()), // Keyword
-		getColor(t.SyntaxKeyword()), // KeywordConstant
-		getColor(t.SyntaxKeyword()), // KeywordDeclaration
-		getColor(t.SyntaxKeyword()), // KeywordNamespace
-		getColor(t.SyntaxKeyword()), // KeywordPseudo
-		getColor(t.SyntaxKeyword()), // KeywordReserved
-		getColor(t.SyntaxType()),    // KeywordType
+		getChromaColor(t.SyntaxKeyword()), // Keyword
+		getChromaColor(t.SyntaxKeyword()), // KeywordConstant
+		getChromaColor(t.SyntaxKeyword()), // KeywordDeclaration
+		getChromaColor(t.SyntaxKeyword()), // KeywordNamespace
+		getChromaColor(t.SyntaxKeyword()), // KeywordPseudo
+		getChromaColor(t.SyntaxKeyword()), // KeywordReserved
+		getChromaColor(t.SyntaxType()),    // KeywordType

-		getColor(t.Text()),           // Name
-		getColor(t.SyntaxVariable()), // NameAttribute
-		getColor(t.SyntaxType()),     // NameBuiltin
-		getColor(t.SyntaxVariable()), // NameBuiltinPseudo
-		getColor(t.SyntaxType()),     // NameClass
-		getColor(t.SyntaxVariable()), // NameConstant
-		getColor(t.SyntaxFunction()), // NameDecorator
-		getColor(t.SyntaxVariable()), // NameEntity
-		getColor(t.SyntaxType()),     // NameException
-		getColor(t.SyntaxFunction()), // NameFunction
-		getColor(t.Text()),           // NameLabel
-		getColor(t.SyntaxType()),     // NameNamespace
-		getColor(t.SyntaxVariable()), // NameOther
-		getColor(t.SyntaxKeyword()),  // NameTag
-		getColor(t.SyntaxVariable()), // NameVariable
-		getColor(t.SyntaxVariable()), // NameVariableClass
-		getColor(t.SyntaxVariable()), // NameVariableGlobal
-		getColor(t.SyntaxVariable()), // NameVariableInstance
+		getChromaColor(t.Text()),           // Name
+		getChromaColor(t.SyntaxVariable()), // NameAttribute
+		getChromaColor(t.SyntaxType()),     // NameBuiltin
+		getChromaColor(t.SyntaxVariable()), // NameBuiltinPseudo
+		getChromaColor(t.SyntaxType()),     // NameClass
+		getChromaColor(t.SyntaxVariable()), // NameConstant
+		getChromaColor(t.SyntaxFunction()), // NameDecorator
+		getChromaColor(t.SyntaxVariable()), // NameEntity
+		getChromaColor(t.SyntaxType()),     // NameException
+		getChromaColor(t.SyntaxFunction()), // NameFunction
+		getChromaColor(t.Text()),           // NameLabel
+		getChromaColor(t.SyntaxType()),     // NameNamespace
+		getChromaColor(t.SyntaxVariable()), // NameOther
+		getChromaColor(t.SyntaxKeyword()),  // NameTag
+		getChromaColor(t.SyntaxVariable()), // NameVariable
+		getChromaColor(t.SyntaxVariable()), // NameVariableClass
+		getChromaColor(t.SyntaxVariable()), // NameVariableGlobal
+		getChromaColor(t.SyntaxVariable()), // NameVariableInstance

-		getColor(t.SyntaxString()), // Literal
-		getColor(t.SyntaxString()), // LiteralDate
-		getColor(t.SyntaxString()), // LiteralString
-		getColor(t.SyntaxString()), // LiteralStringBacktick
-		getColor(t.SyntaxString()), // LiteralStringChar
-		getColor(t.SyntaxString()), // LiteralStringDoc
-		getColor(t.SyntaxString()), // LiteralStringDouble
-		getColor(t.SyntaxString()), // LiteralStringEscape
-		getColor(t.SyntaxString()), // LiteralStringHeredoc
-		getColor(t.SyntaxString()), // LiteralStringInterpol
-		getColor(t.SyntaxString()), // LiteralStringOther
-		getColor(t.SyntaxString()), // LiteralStringRegex
-		getColor(t.SyntaxString()), // LiteralStringSingle
-		getColor(t.SyntaxString()), // LiteralStringSymbol
+		getChromaColor(t.SyntaxString()), // Literal
+		getChromaColor(t.SyntaxString()), // LiteralDate
+		getChromaColor(t.SyntaxString()), // LiteralString
+		getChromaColor(t.SyntaxString()), // LiteralStringBacktick
+		getChromaColor(t.SyntaxString()), // LiteralStringChar
+		getChromaColor(t.SyntaxString()), // LiteralStringDoc
+		getChromaColor(t.SyntaxString()), // LiteralStringDouble
+		getChromaColor(t.SyntaxString()), // LiteralStringEscape
+		getChromaColor(t.SyntaxString()), // LiteralStringHeredoc
+		getChromaColor(t.SyntaxString()), // LiteralStringInterpol
+		getChromaColor(t.SyntaxString()), // LiteralStringOther
+		getChromaColor(t.SyntaxString()), // LiteralStringRegex
+		getChromaColor(t.SyntaxString()), // LiteralStringSingle
+		getChromaColor(t.SyntaxString()), // LiteralStringSymbol

-		getColor(t.SyntaxNumber()), // LiteralNumber
-		getColor(t.SyntaxNumber()), // LiteralNumberBin
-		getColor(t.SyntaxNumber()), // LiteralNumberFloat
-		getColor(t.SyntaxNumber()), // LiteralNumberHex
-		getColor(t.SyntaxNumber()), // LiteralNumberInteger
-		getColor(t.SyntaxNumber()), // LiteralNumberIntegerLong
-		getColor(t.SyntaxNumber()), // LiteralNumberOct
+		getChromaColor(t.SyntaxNumber()), // LiteralNumber
+		getChromaColor(t.SyntaxNumber()), // LiteralNumberBin
+		getChromaColor(t.SyntaxNumber()), // LiteralNumberFloat
+		getChromaColor(t.SyntaxNumber()), // LiteralNumberHex
+		getChromaColor(t.SyntaxNumber()), // LiteralNumberInteger
+		getChromaColor(t.SyntaxNumber()), // LiteralNumberIntegerLong
+		getChromaColor(t.SyntaxNumber()), // LiteralNumberOct

-		getColor(t.SyntaxOperator()),    // Operator
-		getColor(t.SyntaxKeyword()),     // OperatorWord
-		getColor(t.SyntaxPunctuation()), // Punctuation
+		getChromaColor(t.SyntaxOperator()),    // Operator
+		getChromaColor(t.SyntaxKeyword()),     // OperatorWord
+		getChromaColor(t.SyntaxPunctuation()), // Punctuation

-		getColor(t.SyntaxComment()), // Comment
-		getColor(t.SyntaxComment()), // CommentHashbang
-		getColor(t.SyntaxComment()), // CommentMultiline
-		getColor(t.SyntaxComment()), // CommentSingle
-		getColor(t.SyntaxComment()), // CommentSpecial
-		getColor(t.SyntaxKeyword()), // CommentPreproc
+		getChromaColor(t.SyntaxComment()), // Comment
+		getChromaColor(t.SyntaxComment()), // CommentHashbang
+		getChromaColor(t.SyntaxComment()), // CommentMultiline
+		getChromaColor(t.SyntaxComment()), // CommentSingle
+		getChromaColor(t.SyntaxComment()), // CommentSpecial
+		getChromaColor(t.SyntaxKeyword()), // CommentPreproc

-		getColor(t.Text()),      // Generic
-		getColor(t.Error()),     // GenericDeleted
-		getColor(t.Text()),      // GenericEmph
-		getColor(t.Error()),     // GenericError
-		getColor(t.Text()),      // GenericHeading
-		getColor(t.Success()),   // GenericInserted
-		getColor(t.TextMuted()), // GenericOutput
-		getColor(t.Text()),      // GenericPrompt
-		getColor(t.Text()),      // GenericStrong
-		getColor(t.Text()),      // GenericSubheading
-		getColor(t.Error()),     // GenericTraceback
-		getColor(t.Text()),      // TextWhitespace
+		getChromaColor(t.Text()),      // Generic
+		getChromaColor(t.Error()),     // GenericDeleted
+		getChromaColor(t.Text()),      // GenericEmph
+		getChromaColor(t.Error()),     // GenericError
+		getChromaColor(t.Text()),      // GenericHeading
+		getChromaColor(t.Success()),   // GenericInserted
+		getChromaColor(t.TextMuted()), // GenericOutput
+		getChromaColor(t.Text()),      // GenericPrompt
+		getChromaColor(t.Text()),      // GenericStrong
+		getChromaColor(t.Text()),      // GenericSubheading
+		getChromaColor(t.Error()),     // GenericTraceback
+		getChromaColor(t.Text()),      // TextWhitespace
 	)

 	r := strings.NewReader(syntaxThemeXml)
@@ -527,6 +529,9 @@ func SyntaxHighlight(w io.Writer, source, fileName, formatter string, bg color.C
 	// Modify the style to use the provided background
 	s, err := style.Builder().Transform(
 		func(t chroma.StyleEntry) chroma.StyleEntry {
+			if _, ok := bg.(lipgloss.NoColor); ok {
+				return t
+			}
 			r, g, b, _ := bg.RGBA()
 			t.Background = chroma.NewColour(uint8(r>>8), uint8(g>>8), uint8(b>>8))
 			return t
@@ -546,10 +551,18 @@ func SyntaxHighlight(w io.Writer, source, fileName, formatter string, bg color.C
 }

 // getColor returns the appropriate hex color string based on terminal background
-func getColor(adaptiveColor compat.AdaptiveColor) string {
+func getColor(adaptiveColor compat.AdaptiveColor) *string {
 	return stylesi.AdaptiveColorToString(adaptiveColor)
 }

+func getChromaColor(adaptiveColor compat.AdaptiveColor) string {
+	color := stylesi.AdaptiveColorToString(adaptiveColor)
+	if color == nil {
+		return ""
+	}
+	return *color
+}
+
 // highlightLine applies syntax highlighting to a single line
 func highlightLine(fileName string, line string, bg color.Color) string {
 	var buf bytes.Buffer
@@ -561,11 +574,11 @@ func highlightLine(fileName string, line string, bg color.Color) string {
 }

 // createStyles generates the lipgloss styles needed for rendering diffs
-func createStyles(t theme.Theme) (removedLineStyle, addedLineStyle, contextLineStyle, lineNumberStyle lipgloss.Style) {
-	removedLineStyle = lipgloss.NewStyle().Background(t.DiffRemovedBg())
-	addedLineStyle = lipgloss.NewStyle().Background(t.DiffAddedBg())
-	contextLineStyle = lipgloss.NewStyle().Background(t.DiffContextBg())
-	lineNumberStyle = lipgloss.NewStyle().Background(t.DiffLineNumber()).Foreground(t.TextMuted())
+func createStyles(t theme.Theme) (removedLineStyle, addedLineStyle, contextLineStyle, lineNumberStyle stylesi.Style) {
+	removedLineStyle = stylesi.NewStyle().Background(t.DiffRemovedBg())
+	addedLineStyle = stylesi.NewStyle().Background(t.DiffAddedBg())
+	contextLineStyle = stylesi.NewStyle().Background(t.DiffContextBg())
+	lineNumberStyle = stylesi.NewStyle().Foreground(t.TextMuted()).Background(t.DiffLineNumber())
 	return
 }

@@ -613,9 +626,17 @@ func applyHighlighting(content string, segments []Segment, segmentType LineType,
 	currentPos := 0

 	// Get the appropriate color based on terminal background
-	bgColor := lipgloss.Color(getColor(highlightBg))
-	fgColor := lipgloss.Color(getColor(theme.CurrentTheme().BackgroundPanel()))
+	bg := getColor(highlightBg)
+	fg := getColor(theme.CurrentTheme().BackgroundPanel())
+	var bgColor color.Color
+	var fgColor color.Color

+	if bg != nil {
+		bgColor = lipgloss.Color(*bg)
+	}
+	if fg != nil {
+		fgColor = lipgloss.Color(*fg)
+	}
 	for i := 0; i < len(content); {
 		// Check if we're at an ANSI sequence
 		isAnsi := false
@@ -651,12 +672,20 @@ func applyHighlighting(content string, segments []Segment, segmentType LineType,
 			currentStyle := ansiSequences[currentPos]

 			// Apply foreground and background highlight
-			sb.WriteString("\x1b[38;2;")
-			r, g, b, _ := fgColor.RGBA()
-			sb.WriteString(fmt.Sprintf("%d;%d;%dm", r>>8, g>>8, b>>8))
-			sb.WriteString("\x1b[48;2;")
-			r, g, b, _ = bgColor.RGBA()
-			sb.WriteString(fmt.Sprintf("%d;%d;%dm", r>>8, g>>8, b>>8))
+			if fgColor != nil {
+				sb.WriteString("\x1b[38;2;")
+				r, g, b, _ := fgColor.RGBA()
+				sb.WriteString(fmt.Sprintf("%d;%d;%dm", r>>8, g>>8, b>>8))
+			} else {
+				sb.WriteString("\x1b[49m")
+			}
+			if bgColor != nil {
+				sb.WriteString("\x1b[48;2;")
+				r, g, b, _ := bgColor.RGBA()
+				sb.WriteString(fmt.Sprintf("%d;%d;%dm", r>>8, g>>8, b>>8))
+			} else {
+				sb.WriteString("\x1b[39m")
+			}
 			sb.WriteString(char)

 			// Full reset of all attributes to ensure clean state
@@ -677,16 +706,16 @@ func applyHighlighting(content string, segments []Segment, segmentType LineType,
 }

 // renderLinePrefix renders the line number and marker prefix for a diff line
-func renderLinePrefix(dl DiffLine, lineNum string, marker string, lineNumberStyle lipgloss.Style, t theme.Theme) string {
+func renderLinePrefix(dl DiffLine, lineNum string, marker string, lineNumberStyle stylesi.Style, t theme.Theme) string {
 	// Style the marker based on line type
 	var styledMarker string
 	switch dl.Kind {
 	case LineRemoved:
-		styledMarker = lipgloss.NewStyle().Background(t.DiffRemovedBg()).Foreground(t.DiffRemoved()).Render(marker)
+		styledMarker = stylesi.NewStyle().Foreground(t.DiffRemoved()).Background(t.DiffRemovedBg()).Render(marker)
 	case LineAdded:
-		styledMarker = lipgloss.NewStyle().Background(t.DiffAddedBg()).Foreground(t.DiffAdded()).Render(marker)
+		styledMarker = stylesi.NewStyle().Foreground(t.DiffAdded()).Background(t.DiffAddedBg()).Render(marker)
 	case LineContext:
-		styledMarker = lipgloss.NewStyle().Background(t.DiffContextBg()).Foreground(t.TextMuted()).Render(marker)
+		styledMarker = stylesi.NewStyle().Foreground(t.TextMuted()).Background(t.DiffContextBg()).Render(marker)
 	default:
 		styledMarker = marker
 	}
@@ -695,7 +724,7 @@ func renderLinePrefix(dl DiffLine, lineNum string, marker string, lineNumberStyl
 }

 // renderLineContent renders the content of a diff line with syntax and intra-line highlighting
-func renderLineContent(fileName string, dl DiffLine, bgStyle lipgloss.Style, highlightColor compat.AdaptiveColor, width int, t theme.Theme) string {
+func renderLineContent(fileName string, dl DiffLine, bgStyle stylesi.Style, highlightColor compat.AdaptiveColor, width int) string {
 	// Apply syntax highlighting
 	content := highlightLine(fileName, dl.Content, bgStyle.GetBackground())

@@ -714,7 +743,9 @@ func renderLineContent(fileName string, dl DiffLine, bgStyle lipgloss.Style, hig
 		ansi.Truncate(
 			content,
 			width,
-			lipgloss.NewStyle().Background(bgStyle.GetBackground()).Foreground(t.TextMuted()).Render("..."),
+			"...",
+			// stylesi.NewStyleWithColors(t.TextMuted(), bgStyle.GetBackground()).Render("..."),
+			// stylesi.WithForeground(stylesi.NewStyle().Background(bgStyle.GetBackground()), t.TextMuted()).Render("..."),
 		),
 	)
 }
@@ -725,7 +756,7 @@ func renderUnifiedLine(fileName string, dl DiffLine, width int, t theme.Theme) s

 	// Determine line style and marker based on line type
 	var marker string
-	var bgStyle lipgloss.Style
+	var bgStyle stylesi.Style
 	var lineNum string
 	var highlightColor compat.AdaptiveColor

@@ -733,8 +764,8 @@ func renderUnifiedLine(fileName string, dl DiffLine, width int, t theme.Theme) s
 	case LineRemoved:
 		marker = "-"
 		bgStyle = removedLineStyle
-		lineNumberStyle = lineNumberStyle.Foreground(t.DiffRemoved()).Background(t.DiffRemovedLineNumberBg())
-		highlightColor = t.DiffHighlightRemoved()
+		lineNumberStyle = lineNumberStyle.Background(t.DiffRemovedLineNumberBg()).Foreground(t.DiffRemoved())
+		highlightColor = t.DiffHighlightRemoved() // TODO: handle "none"
 		if dl.OldLineNo > 0 {
 			lineNum = fmt.Sprintf("%6d       ", dl.OldLineNo)
 		} else {
@@ -743,8 +774,8 @@ func renderUnifiedLine(fileName string, dl DiffLine, width int, t theme.Theme) s
 	case LineAdded:
 		marker = "+"
 		bgStyle = addedLineStyle
-		lineNumberStyle = lineNumberStyle.Foreground(t.DiffAdded()).Background(t.DiffAddedLineNumberBg())
-		highlightColor = t.DiffHighlightAdded()
+		lineNumberStyle = lineNumberStyle.Background(t.DiffAddedLineNumberBg()).Foreground(t.DiffAdded())
+		highlightColor = t.DiffHighlightAdded() // TODO: handle "none"
 		if dl.NewLineNo > 0 {
 			lineNum = fmt.Sprintf("      %7d", dl.NewLineNo)
 		} else {
@@ -766,7 +797,7 @@ func renderUnifiedLine(fileName string, dl DiffLine, width int, t theme.Theme) s
 	// Render the content
 	prefixWidth := ansi.StringWidth(prefix)
 	contentWidth := width - prefixWidth
-	content := renderLineContent(fileName, dl, bgStyle, highlightColor, contentWidth, t)
+	content := renderLineContent(fileName, dl, bgStyle, highlightColor, contentWidth)

 	return prefix + content
 }
@@ -780,7 +811,7 @@ func renderDiffColumnLine(
 	t theme.Theme,
 ) string {
 	if dl == nil {
-		contextLineStyle := lipgloss.NewStyle().Background(t.DiffContextBg())
+		contextLineStyle := stylesi.NewStyle().Background(t.DiffContextBg())
 		return contextLineStyle.Width(colWidth).Render("")
 	}

@@ -788,7 +819,7 @@ func renderDiffColumnLine(

 	// Determine line style based on line type and column
 	var marker string
-	var bgStyle lipgloss.Style
+	var bgStyle stylesi.Style
 	var lineNum string
 	var highlightColor compat.AdaptiveColor

@@ -798,8 +829,8 @@ func renderDiffColumnLine(
 		case LineRemoved:
 			marker = "-"
 			bgStyle = removedLineStyle
-			lineNumberStyle = lineNumberStyle.Foreground(t.DiffRemoved()).Background(t.DiffRemovedLineNumberBg())
-			highlightColor = t.DiffHighlightRemoved()
+			lineNumberStyle = lineNumberStyle.Background(t.DiffRemovedLineNumberBg()).Foreground(t.DiffRemoved())
+			highlightColor = t.DiffHighlightRemoved() // TODO: handle "none"
 		case LineAdded:
 			marker = "?"
 			bgStyle = contextLineStyle
@@ -818,7 +849,7 @@ func renderDiffColumnLine(
 		case LineAdded:
 			marker = "+"
 			bgStyle = addedLineStyle
-			lineNumberStyle = lineNumberStyle.Foreground(t.DiffAdded()).Background(t.DiffAddedLineNumberBg())
+			lineNumberStyle = lineNumberStyle.Background(t.DiffAddedLineNumberBg()).Foreground(t.DiffAdded())
 			highlightColor = t.DiffHighlightAdded()
 		case LineRemoved:
 			marker = "?"
@@ -849,7 +880,7 @@ func renderDiffColumnLine(
 	// Render the content
 	prefixWidth := ansi.StringWidth(prefix)
 	contentWidth := colWidth - prefixWidth
-	content := renderLineContent(fileName, *dl, bgStyle, highlightColor, contentWidth, t)
+	content := renderLineContent(fileName, *dl, bgStyle, highlightColor, contentWidth)

 	return prefix + content
 }
@@ -910,11 +941,22 @@ func RenderSideBySideHunk(fileName string, h Hunk, opts ...SideBySideOption) str
 	leftWidth := colWidth
 	rightWidth := config.TotalWidth - colWidth
 	var sb strings.Builder
-	for _, p := range pairs {
-		leftStr := renderLeftColumn(fileName, p.left, leftWidth)
-		rightStr := renderRightColumn(fileName, p.right, rightWidth)
-		sb.WriteString(leftStr + rightStr + "\n")
-	}
+
+	util.WriteStringsPar(&sb, pairs, func(p linePair) string {
+		wg := &sync.WaitGroup{}
+		var leftStr, rightStr string
+		wg.Add(2)
+		go func() {
+			defer wg.Done()
+			leftStr = renderLeftColumn(fileName, p.left, leftWidth)
+		}()
+		go func() {
+			defer wg.Done()
+			rightStr = renderRightColumn(fileName, p.right, rightWidth)
+		}()
+		wg.Wait()
+		return leftStr + rightStr + "\n"
+	})

 	return sb.String()
 }
@@ -928,7 +970,8 @@ func FormatUnifiedDiff(filename string, diffText string, opts ...UnifiedOption)

 	var sb strings.Builder
 	for _, h := range diffResult.Hunks {
-		sb.WriteString(RenderUnifiedHunk(filename, h, opts...))
+		unifiedDiff := RenderUnifiedHunk(filename, h, opts...)
+		sb.WriteString(unifiedDiff)
 	}

 	return sb.String(), nil
@@ -944,7 +987,7 @@ func FormatDiff(filename string, diffText string, opts ...SideBySideOption) (str

 	var sb strings.Builder
 	// config := NewSideBySideConfig(opts...)
-	for _, h := range diffResult.Hunks {
+	util.WriteStringsPar(&sb, diffResult.Hunks, func(h Hunk) string {
 		// sb.WriteString(
 		// 	lipgloss.NewStyle().
 		// 		Background(t.DiffHunkHeader()).
@@ -952,8 +995,8 @@ func FormatDiff(filename string, diffText string, opts ...SideBySideOption) (str
 		// 		Width(config.TotalWidth).
 		// 		Render(h.Header) + "\n",
 		// )
-		sb.WriteString(RenderSideBySideHunk(filename, h, opts...))
-	}
+		return RenderSideBySideHunk(filename, h, opts...)
+	})

 	return sb.String(), nil
 }
@@ -5,6 +5,9 @@ import (

 	"github.com/charmbracelet/bubbles/v2/key"
 	tea "github.com/charmbracelet/bubbletea/v2"
+	"github.com/muesli/reflow/truncate"
+	"github.com/sst/opencode/internal/styles"
+	"github.com/sst/opencode/internal/theme"
 )

 type ListItem interface {
@@ -123,6 +126,9 @@ func (c *listComponent[T]) SetSelectedIndex(idx int) {
 func (c *listComponent[T]) View() string {
 	items := c.items
 	maxWidth := c.maxWidth
+	if maxWidth == 0 {
+		maxWidth = 80 // Default width if not set
+	}
 	maxVisibleItems := min(c.maxVisibleItems, len(items))
 	startIdx := 0

@@ -161,3 +167,37 @@ func NewListComponent[T ListItem](items []T, maxVisibleItems int, fallbackMsg st
 		selectedIdx:         0,
 	}
 }
+
+// StringItem is a simple implementation of ListItem for string values
+type StringItem string
+
+func (s StringItem) Render(selected bool, width int) string {
+	t := theme.CurrentTheme()
+	baseStyle := styles.NewStyle()
+
+	truncatedStr := truncate.StringWithTail(string(s), uint(width-1), "...")
+
+	var itemStyle styles.Style
+	if selected {
+		itemStyle = baseStyle.
+			Background(t.Primary()).
+			Foreground(t.BackgroundElement()).
+			Width(width).
+			PaddingLeft(1)
+	} else {
+		itemStyle = baseStyle.
+			Foreground(t.TextMuted()).
+			PaddingLeft(1)
+	}
+
+	return itemStyle.Render(truncatedStr)
+}
+
+// NewStringList creates a new list component with string items
+func NewStringList(items []string, 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)
+}
@@ -90,12 +90,8 @@ func (m *Modal) Render(contentView string, background string) string {

 	innerWidth := outerWidth - 4

-	// Base style for the modal
-	baseStyle := styles.BaseStyle().
-		Background(t.BackgroundElement()).
-		Foreground(t.TextMuted())
+	baseStyle := styles.NewStyle().Foreground(t.TextMuted()).Background(t.BackgroundElement())

-	// Add title if provided
 	var finalContent string
 	if m.title != "" {
 		titleStyle := baseStyle.
@@ -103,18 +99,18 @@ func (m *Modal) Render(contentView string, background string) string {
 			Bold(true).
 			Padding(0, 1)

-		escStyle := baseStyle.Foreground(t.TextMuted()).Bold(false)
+		escStyle := baseStyle.Foreground(t.TextMuted())
 		escText := escStyle.Render("esc")

 		// Calculate position for esc text
 		titleWidth := lipgloss.Width(m.title)
 		escWidth := lipgloss.Width(escText)
-		spacesNeeded := max(0, innerWidth-titleWidth-escWidth-3)
+		spacesNeeded := max(0, innerWidth-titleWidth-escWidth-2)
 		spacer := strings.Repeat(" ", spacesNeeded)
 		titleLine := m.title + spacer + escText
 		titleLine = titleStyle.Render(titleLine)

-		finalContent = strings.Join([]string{titleLine, contentView}, "\n") + "\n"
+		finalContent = strings.Join([]string{titleLine, "", contentView}, "\n")
 	} else {
 		finalContent = contentView
 	}
@@ -3,7 +3,7 @@ package qr
 import (
 	"strings"

-	"github.com/charmbracelet/lipgloss/v2"
+	"github.com/sst/opencode/internal/styles"
 	"github.com/sst/opencode/internal/theme"
 	"rsc.io/qr"
 )
@@ -23,9 +23,7 @@ func Generate(text string) (string, int, error) {
 	}

 	// Create lipgloss style for QR code with theme colors
-	qrStyle := lipgloss.NewStyle().
-		Foreground(t.Text()).
-		Background(t.Background())
+	qrStyle := styles.NewStyleWithColors(t.Text(), t.Background())

 	var result strings.Builder

@@ -36,18 +36,19 @@ func (m statusComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd) {

 func (m statusComponent) logo() string {
 	t := theme.CurrentTheme()
-	base := lipgloss.NewStyle().Background(t.BackgroundElement()).Foreground(t.TextMuted()).Render
-	emphasis := lipgloss.NewStyle().Bold(true).Background(t.BackgroundElement()).Foreground(t.Text()).Render
+	base := styles.NewStyle().Foreground(t.TextMuted()).Background(t.BackgroundElement()).Render
+	emphasis := styles.NewStyle().Foreground(t.Text()).Background(t.BackgroundElement()).Bold(true).Render

 	open := base("open")
 	code := emphasis("code ")
 	version := base(m.app.Version)
-	return styles.Padded().
+	return styles.NewStyle().
 		Background(t.BackgroundElement()).
+		Padding(0, 1).
 		Render(open + code + version)
 }

-func formatTokensAndCost(tokens float32, contextWindow float32, cost float32) string {
+func formatTokensAndCost(tokens float64, contextWindow float64, cost float64) string {
 	// Format tokens in human-readable format (e.g., 110K, 1.2M)
 	var formattedTokens string
 	switch {
@@ -71,13 +72,13 @@ func formatTokensAndCost(tokens float32, contextWindow float32, cost float32) st
 	formattedCost := fmt.Sprintf("$%.2f", cost)
 	percentage := (float64(tokens) / float64(contextWindow)) * 100

-	return fmt.Sprintf("Tokens: %s (%d%%), Cost: %s", formattedTokens, int(percentage), formattedCost)
+	return fmt.Sprintf("Context: %s (%d%%), Cost: %s", formattedTokens, int(percentage), formattedCost)
 }

 func (m statusComponent) View() string {
 	t := theme.CurrentTheme()
-	if m.app.Session.Id == "" {
-		return styles.BaseStyle().
+	if m.app.Session.ID == "" {
+		return styles.NewStyle().
 			Background(t.Background()).
 			Width(m.width).
 			Height(2).
@@ -86,34 +87,38 @@ func (m statusComponent) View() string {

 	logo := m.logo()

-	cwd := styles.Padded().
+	cwd := styles.NewStyle().
 		Foreground(t.TextMuted()).
 		Background(t.BackgroundPanel()).
+		Padding(0, 1).
 		Render(m.app.Info.Path.Cwd)

 	sessionInfo := ""
-	if m.app.Session.Id != "" {
-		tokens := float32(0)
-		cost := float32(0)
+	if m.app.Session.ID != "" {
+		tokens := float64(0)
+		cost := float64(0)
 		contextWindow := m.app.Model.Limit.Context

 		for _, message := range m.app.Messages {
-			if message.Metadata.Assistant != nil {
-				cost += message.Metadata.Assistant.Cost
-				usage := message.Metadata.Assistant.Tokens
-				if usage.Output > 0 {
-					tokens = (usage.Input +
-						usage.Cache.Write +
-						usage.Cache.Read +
-						usage.Output +
-						usage.Reasoning)
+			cost += message.Metadata.Assistant.Cost
+			usage := message.Metadata.Assistant.Tokens
+			if usage.Output > 0 {
+				if message.Metadata.Assistant.Summary {
+					tokens = usage.Output
+					continue
 				}
+				tokens = (usage.Input +
+					usage.Cache.Write +
+					usage.Cache.Read +
+					usage.Output +
+					usage.Reasoning)
 			}
 		}

-		sessionInfo = styles.Padded().
-			Background(t.BackgroundElement()).
+		sessionInfo = styles.NewStyle().
 			Foreground(t.TextMuted()).
+			Background(t.BackgroundElement()).
+			Padding(0, 1).
 			Render(formatTokensAndCost(tokens, contextWindow, cost))
 	}

@@ -123,11 +128,11 @@ func (m statusComponent) View() string {
 		0,
 		m.width-lipgloss.Width(logo)-lipgloss.Width(cwd)-lipgloss.Width(sessionInfo),
 	)
-	spacer := lipgloss.NewStyle().Background(t.BackgroundPanel()).Width(space).Render("")
+	spacer := styles.NewStyle().Background(t.BackgroundPanel()).Width(space).Render("")

 	status := logo + cwd + spacer + sessionInfo

-	blank := styles.BaseStyle().Background(t.Background()).Width(m.width).Render("")
+	blank := styles.NewStyle().Background(t.Background()).Width(m.width).Render("")
 	return blank + "\n" + status
 }

@@ -90,9 +90,9 @@ func (tm *ToastManager) Update(msg tea.Msg) (*ToastManager, tea.Cmd) {
 func (tm *ToastManager) renderSingleToast(toast Toast) string {
 	t := theme.CurrentTheme()

-	baseStyle := styles.BaseStyle().
-		Background(t.BackgroundElement()).
+	baseStyle := styles.NewStyle().
 		Foreground(t.Text()).
+		Background(t.BackgroundElement()).
 		Padding(1, 2)

 	maxWidth := max(40, layout.Current.Viewport.Width/3)
@@ -101,15 +101,14 @@ func (tm *ToastManager) renderSingleToast(toast Toast) string {
 	// Build content with wrapping
 	var content strings.Builder
 	if toast.Title != nil {
-		titleStyle := lipgloss.NewStyle().
-			Foreground(toast.Color).
+		titleStyle := styles.NewStyle().Foreground(toast.Color).
 			Bold(true)
 		content.WriteString(titleStyle.Render(*toast.Title))
 		content.WriteString("\n")
 	}

 	// Wrap message text
-	messageStyle := lipgloss.NewStyle()
+	messageStyle := styles.NewStyle()
 	contentWidth := lipgloss.Width(toast.Message)
 	if contentWidth > contentMaxWidth {
 		messageStyle = messageStyle.Width(contentMaxWidth)
@@ -7,7 +7,6 @@ import (
 	"os"

 	"github.com/BurntSushi/toml"
-	"github.com/sst/opencode/pkg/client"
 )

 type State struct {
@@ -22,13 +21,6 @@ func NewState() *State {
 	}
 }

-func MergeState(state *State, config *client.ConfigInfo) *client.ConfigInfo {
-	if config.Theme == nil {
-		config.Theme = &state.Theme
-	}
-	return config
-}
-
 // 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 {
@@ -5,8 +5,8 @@ package image
 import (
 	"bytes"
 	"fmt"
-	"image"
 	"github.com/atotto/clipboard"
+	"image"
 )

 func GetImageFromClipboard() ([]byte, string, error) {
@@ -28,8 +28,6 @@ func GetImageFromClipboard() ([]byte, string, error) {

 }

-
-
 func binaryToImage(data []byte) ([]byte, error) {
 	reader := bytes.NewReader(data)
 	img, _, err := image.Decode(reader)
@@ -40,7 +38,6 @@ func binaryToImage(data []byte) ([]byte, error) {
 	return ImageToBytes(img)
 }

-
 func min(a, b int) int {
 	if a < b {
 		return a
@@ -3,6 +3,7 @@ package layout
 import (
 	tea "github.com/charmbracelet/bubbletea/v2"
 	"github.com/charmbracelet/lipgloss/v2"
+	"github.com/sst/opencode/internal/styles"
 	"github.com/sst/opencode/internal/theme"
 )

@@ -57,7 +58,7 @@ func (c *container) Update(msg tea.Msg) (tea.Model, tea.Cmd) {

 func (c *container) View() string {
 	t := theme.CurrentTheme()
-	style := lipgloss.NewStyle()
+	style := styles.NewStyle().Background(t.Background())
 	width := c.width
 	height := c.height

@@ -66,8 +67,6 @@ func (c *container) View() string {
 		width = c.maxWidth
 	}

-	style = style.Background(t.Background())
-
 	// Apply border if any side is enabled
 	if c.borderTop || c.borderRight || c.borderBottom || c.borderLeft {
 		// Adjust width and height for borders
@@ -3,6 +3,7 @@ package layout
 import (
 	tea "github.com/charmbracelet/bubbletea/v2"
 	"github.com/charmbracelet/lipgloss/v2"
+	"github.com/sst/opencode/internal/styles"
 	"github.com/sst/opencode/internal/theme"
 )

@@ -66,7 +67,7 @@ func (f *flexLayout) View() string {
 				alignment,
 				child.View(),
 				// TODO: make configurable WithBackgroundStyle
-				lipgloss.WithWhitespaceStyle(lipgloss.NewStyle().Background(t.Background())),
+				lipgloss.WithWhitespaceStyle(styles.NewStyle().Background(t.Background()).Lipgloss()),
 			)
 			views = append(views, view)
 		} else {
@@ -78,7 +79,7 @@ func (f *flexLayout) View() string {
 				alignment,
 				child.View(),
 				// TODO: make configurable WithBackgroundStyle
-				lipgloss.WithWhitespaceStyle(lipgloss.NewStyle().Background(t.Background())),
+				lipgloss.WithWhitespaceStyle(styles.NewStyle().Background(t.Background()).Lipgloss()),
 			)
 			views = append(views, view)
 		}
@@ -109,18 +109,26 @@ func PlaceOverlay(
 			// Get the foreground line
 			fgLine := fgLines[i-y]
 			fgLineWidth := ansi.PrintableRuneWidth(fgLine)
-			
+
 			// Extract the styles at the border positions
-			leftStyle := getStyleAtPosition(bgLine, pos)
-			rightStyle := getStyleAtPosition(bgLine, pos + 1 + fgLineWidth)
-			
+			// We need to get the style just before the border position to preserve background
+			leftStyle := ansiStyle{}
+			if pos > 0 {
+				leftStyle = getStyleAtPosition(bgLine, pos-1)
+			} else {
+				leftStyle = getStyleAtPosition(bgLine, pos)
+			}
+			rightStyle := getStyleAtPosition(bgLine, pos+fgLineWidth)
+
 			// Left border - combine background from original with border foreground
 			leftSeq := combineStyles(leftStyle, options.borderColor)
 			if leftSeq != "" {
 				b.WriteString(leftSeq)
 			}
 			b.WriteString("┃")
-			b.WriteString("\x1b[0m") // Reset all styles
+			if leftSeq != "" {
+				b.WriteString("\x1b[0m") // Reset all styles only if we applied any
+			}
 			pos++

 			// Content
@@ -133,7 +141,9 @@ func PlaceOverlay(
 				b.WriteString(rightSeq)
 			}
 			b.WriteString("┃")
-			b.WriteString("\x1b[0m") // Reset all styles
+			if rightSeq != "" {
+				b.WriteString("\x1b[0m") // Reset all styles only if we applied any
+			}
 			pos++
 		} else {
 			// No border, just render the content
@@ -172,23 +182,25 @@ type ansiStyle struct {
 // parseANSISequence parses an ANSI escape sequence into its components
 func parseANSISequence(seq string) ansiStyle {
 	style := ansiStyle{}
-	
+
 	// Extract the parameters from the sequence (e.g., \x1b[38;5;123;48;5;456m -> "38;5;123;48;5;456")
 	if !strings.HasPrefix(seq, "\x1b[") || !strings.HasSuffix(seq, "m") {
 		return style
 	}
-	
+
 	params := seq[2 : len(seq)-1]
 	if params == "" {
 		return style
 	}
-	
+
 	parts := strings.Split(params, ";")
 	i := 0
 	for i < len(parts) {
 		switch parts[i] {
 		case "0": // Reset
-			style = ansiStyle{}
+			// Mark this as a reset by adding it to attrs
+			style.attrs = append(style.attrs, "0")
+			// Don't clear the style here, let the caller handle it
 		case "1", "2", "3", "4", "5", "6", "7", "8", "9": // Various attributes
 			style.attrs = append(style.attrs, parts[i])
 		case "38": // Foreground color
@@ -222,7 +234,7 @@ func parseANSISequence(seq string) ansiStyle {
 		}
 		i++
 	}
-	
+
 	return style
 }

@@ -231,32 +243,30 @@ func combineStyles(bgStyle ansiStyle, fgColor *compat.AdaptiveColor) string {
 	if fgColor == nil && bgStyle.bgColor == "" && len(bgStyle.attrs) == 0 {
 		return ""
 	}
-	
+
 	var parts []string
-	
+
 	// Add attributes
 	parts = append(parts, bgStyle.attrs...)
-	
+
 	// Add background color from the original style
 	if bgStyle.bgColor != "" {
 		parts = append(parts, bgStyle.bgColor)
 	}
-	
+
 	// Add foreground color if specified
 	if fgColor != nil {
-		// Use the light color (could be improved to detect terminal background)
-		color := (*fgColor).Light
-		
-		// Use RGBA to get color components
-		r, g, b, _ := color.RGBA()
+		// Use the adaptive color which automatically selects based on terminal background
+		// The RGBA method already handles light/dark selection
+		r, g, b, _ := fgColor.RGBA()
 		// RGBA returns 16-bit values, we need 8-bit
 		parts = append(parts, fmt.Sprintf("38;2;%d;%d;%d", r>>8, g>>8, b>>8))
 	}
-	
+
 	if len(parts) == 0 {
 		return ""
 	}
-	
+
 	return fmt.Sprintf("\x1b[%sm", strings.Join(parts, ";"))
 }

@@ -264,10 +274,10 @@ func combineStyles(bgStyle ansiStyle, fgColor *compat.AdaptiveColor) string {
 func getStyleAtPosition(s string, targetPos int) ansiStyle {
 	// ANSI escape sequence regex
 	ansiRegex := regexp.MustCompile(`\x1b\[[0-9;]*m`)
-	
+
 	visualPos := 0
 	currentStyle := ansiStyle{}
-	
+
 	i := 0
 	for i < len(s) && visualPos <= targetPos {
 		// Check if we're at an ANSI escape sequence
@@ -275,18 +285,24 @@ func getStyleAtPosition(s string, targetPos int) ansiStyle {
 			// Found an ANSI sequence at current position
 			seq := s[i : i+match[1]]
 			parsedStyle := parseANSISequence(seq)
-			
-			// Update current style (merge with existing)
-			if parsedStyle.fgColor != "" {
-				currentStyle.fgColor = parsedStyle.fgColor
+
+			// Check if this is a reset sequence
+			if len(parsedStyle.attrs) > 0 && parsedStyle.attrs[0] == "0" {
+				// Reset all styles
+				currentStyle = ansiStyle{}
+			} else {
+				// Update current style (merge with existing)
+				if parsedStyle.fgColor != "" {
+					currentStyle.fgColor = parsedStyle.fgColor
+				}
+				if parsedStyle.bgColor != "" {
+					currentStyle.bgColor = parsedStyle.bgColor
+				}
+				if len(parsedStyle.attrs) > 0 {
+					currentStyle.attrs = parsedStyle.attrs
+				}
 			}
-			if parsedStyle.bgColor != "" {
-				currentStyle.bgColor = parsedStyle.bgColor
-			}
-			if len(parsedStyle.attrs) > 0 {
-				currentStyle.attrs = parsedStyle.attrs
-			}
-			
+
 			i += match[1]
 		} else if i < len(s) {
 			// Regular character
@@ -298,7 +314,7 @@ func getStyleAtPosition(s string, targetPos int) ansiStyle {
 			visualPos++
 		}
 	}
-	
+
 	return currentStyle
 }

@@ -1,6 +1,9 @@
 package styles

+import "image/color"
+
 type TerminalInfo struct {
+	Background       color.Color
 	BackgroundIsDark bool
 }

@@ -8,6 +11,7 @@ var Terminal *TerminalInfo

 func init() {
 	Terminal = &TerminalInfo{
+		Background:       color.Black,
 		BackgroundIsDark: true,
 	}
 }
@@ -3,6 +3,7 @@ package styles
 import (
 	"github.com/charmbracelet/glamour"
 	"github.com/charmbracelet/glamour/ansi"
+	"github.com/charmbracelet/lipgloss/v2"
 	"github.com/charmbracelet/lipgloss/v2/compat"
 	"github.com/lucasb-eyer/go-colorful"
 	"github.com/sst/opencode/internal/theme"
@@ -29,7 +30,7 @@ func GetMarkdownRenderer(width int, backgroundColor compat.AdaptiveColor) *glamo
 // using adaptive colors from the provided theme.
 func generateMarkdownStyleConfig(backgroundColor compat.AdaptiveColor) ansi.StyleConfig {
 	t := theme.CurrentTheme()
-	background := stringPtr(AdaptiveColorToString(backgroundColor))
+	background := AdaptiveColorToString(backgroundColor)

 	return ansi.StyleConfig{
 		Document: ansi.StyleBlock{
@@ -37,12 +38,12 @@ func generateMarkdownStyleConfig(backgroundColor compat.AdaptiveColor) ansi.Styl
 				BlockPrefix:     "",
 				BlockSuffix:     "",
 				BackgroundColor: background,
-				Color:           stringPtr(AdaptiveColorToString(t.MarkdownText())),
+				Color:           AdaptiveColorToString(t.MarkdownText()),
 			},
 		},
 		BlockQuote: ansi.StyleBlock{
 			StylePrimitive: ansi.StylePrimitive{
-				Color:  stringPtr(AdaptiveColorToString(t.MarkdownBlockQuote())),
+				Color:  AdaptiveColorToString(t.MarkdownBlockQuote()),
 				Italic: boolPtr(true),
 				Prefix: "┃ ",
 			},
@@ -54,108 +55,108 @@ func generateMarkdownStyleConfig(backgroundColor compat.AdaptiveColor) ansi.Styl
 			StyleBlock: ansi.StyleBlock{
 				IndentToken: stringPtr(" "),
 				StylePrimitive: ansi.StylePrimitive{
-					Color: stringPtr(AdaptiveColorToString(t.MarkdownText())),
+					Color: AdaptiveColorToString(t.MarkdownText()),
 				},
 			},
 		},
 		Heading: ansi.StyleBlock{
 			StylePrimitive: ansi.StylePrimitive{
 				BlockSuffix: "\n",
-				Color:       stringPtr(AdaptiveColorToString(t.MarkdownHeading())),
+				Color:       AdaptiveColorToString(t.MarkdownHeading()),
 				Bold:        boolPtr(true),
 			},
 		},
 		H1: ansi.StyleBlock{
 			StylePrimitive: ansi.StylePrimitive{
 				Prefix: "# ",
-				Color:  stringPtr(AdaptiveColorToString(t.MarkdownHeading())),
+				Color:  AdaptiveColorToString(t.MarkdownHeading()),
 				Bold:   boolPtr(true),
 			},
 		},
 		H2: ansi.StyleBlock{
 			StylePrimitive: ansi.StylePrimitive{
 				Prefix: "## ",
-				Color:  stringPtr(AdaptiveColorToString(t.MarkdownHeading())),
+				Color:  AdaptiveColorToString(t.MarkdownHeading()),
 				Bold:   boolPtr(true),
 			},
 		},
 		H3: ansi.StyleBlock{
 			StylePrimitive: ansi.StylePrimitive{
 				Prefix: "### ",
-				Color:  stringPtr(AdaptiveColorToString(t.MarkdownHeading())),
+				Color:  AdaptiveColorToString(t.MarkdownHeading()),
 				Bold:   boolPtr(true),
 			},
 		},
 		H4: ansi.StyleBlock{
 			StylePrimitive: ansi.StylePrimitive{
 				Prefix: "#### ",
-				Color:  stringPtr(AdaptiveColorToString(t.MarkdownHeading())),
+				Color:  AdaptiveColorToString(t.MarkdownHeading()),
 				Bold:   boolPtr(true),
 			},
 		},
 		H5: ansi.StyleBlock{
 			StylePrimitive: ansi.StylePrimitive{
 				Prefix: "##### ",
-				Color:  stringPtr(AdaptiveColorToString(t.MarkdownHeading())),
+				Color:  AdaptiveColorToString(t.MarkdownHeading()),
 				Bold:   boolPtr(true),
 			},
 		},
 		H6: ansi.StyleBlock{
 			StylePrimitive: ansi.StylePrimitive{
 				Prefix: "###### ",
-				Color:  stringPtr(AdaptiveColorToString(t.MarkdownHeading())),
+				Color:  AdaptiveColorToString(t.MarkdownHeading()),
 				Bold:   boolPtr(true),
 			},
 		},
 		Strikethrough: ansi.StylePrimitive{
 			CrossedOut: boolPtr(true),
-			Color:      stringPtr(AdaptiveColorToString(t.TextMuted())),
+			Color:      AdaptiveColorToString(t.TextMuted()),
 		},
 		Emph: ansi.StylePrimitive{
-			Color:  stringPtr(AdaptiveColorToString(t.MarkdownEmph())),
+			Color:  AdaptiveColorToString(t.MarkdownEmph()),
 			Italic: boolPtr(true),
 		},
 		Strong: ansi.StylePrimitive{
 			Bold:  boolPtr(true),
-			Color: stringPtr(AdaptiveColorToString(t.MarkdownStrong())),
+			Color: AdaptiveColorToString(t.MarkdownStrong()),
 		},
 		HorizontalRule: ansi.StylePrimitive{
-			Color:  stringPtr(AdaptiveColorToString(t.MarkdownHorizontalRule())),
+			Color:  AdaptiveColorToString(t.MarkdownHorizontalRule()),
 			Format: "\n─────────────────────────────────────────\n",
 		},
 		Item: ansi.StylePrimitive{
 			BlockPrefix: "• ",
-			Color:       stringPtr(AdaptiveColorToString(t.MarkdownListItem())),
+			Color:       AdaptiveColorToString(t.MarkdownListItem()),
 		},
 		Enumeration: ansi.StylePrimitive{
 			BlockPrefix: ". ",
-			Color:       stringPtr(AdaptiveColorToString(t.MarkdownListEnumeration())),
+			Color:       AdaptiveColorToString(t.MarkdownListEnumeration()),
 		},
 		Task: ansi.StyleTask{
 			Ticked:   "[✓] ",
 			Unticked: "[ ] ",
 		},
 		Link: ansi.StylePrimitive{
-			Color:     stringPtr(AdaptiveColorToString(t.MarkdownLink())),
+			Color:     AdaptiveColorToString(t.MarkdownLink()),
 			Underline: boolPtr(true),
 		},
 		LinkText: ansi.StylePrimitive{
-			Color: stringPtr(AdaptiveColorToString(t.MarkdownLinkText())),
+			Color: AdaptiveColorToString(t.MarkdownLinkText()),
 			Bold:  boolPtr(true),
 		},
 		Image: ansi.StylePrimitive{
-			Color:     stringPtr(AdaptiveColorToString(t.MarkdownImage())),
+			Color:     AdaptiveColorToString(t.MarkdownImage()),
 			Underline: boolPtr(true),
 			Format:    "🖼 {{.text}}",
 		},
 		ImageText: ansi.StylePrimitive{
-			Color:  stringPtr(AdaptiveColorToString(t.MarkdownImageText())),
+			Color:  AdaptiveColorToString(t.MarkdownImageText()),
 			Format: "{{.text}}",
 		},
 		Code: ansi.StyleBlock{
 			StylePrimitive: ansi.StylePrimitive{
 				BackgroundColor: background,
-				Color:           stringPtr(AdaptiveColorToString(t.MarkdownCode())),
+				Color:           AdaptiveColorToString(t.MarkdownCode()),
 				Prefix:          "",
 				Suffix:          "",
 			},
@@ -165,7 +166,7 @@ func generateMarkdownStyleConfig(backgroundColor compat.AdaptiveColor) ansi.Styl
 				StylePrimitive: ansi.StylePrimitive{
 					BackgroundColor: background,
 					Prefix:          " ",
-					Color:           stringPtr(AdaptiveColorToString(t.MarkdownCodeBlock())),
+					Color:           AdaptiveColorToString(t.MarkdownCodeBlock()),
 				},
 			},
 			Chroma: &ansi.Chroma{
@@ -174,109 +175,109 @@ func generateMarkdownStyleConfig(backgroundColor compat.AdaptiveColor) ansi.Styl
 				},
 				Text: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.MarkdownText())),
+					Color:           AdaptiveColorToString(t.MarkdownText()),
 				},
 				Error: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.Error())),
+					Color:           AdaptiveColorToString(t.Error()),
 				},
 				Comment: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.SyntaxComment())),
+					Color:           AdaptiveColorToString(t.SyntaxComment()),
 				},
 				CommentPreproc: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.SyntaxKeyword())),
+					Color:           AdaptiveColorToString(t.SyntaxKeyword()),
 				},
 				Keyword: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.SyntaxKeyword())),
+					Color:           AdaptiveColorToString(t.SyntaxKeyword()),
 				},
 				KeywordReserved: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.SyntaxKeyword())),
+					Color:           AdaptiveColorToString(t.SyntaxKeyword()),
 				},
 				KeywordNamespace: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.SyntaxKeyword())),
+					Color:           AdaptiveColorToString(t.SyntaxKeyword()),
 				},
 				KeywordType: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.SyntaxType())),
+					Color:           AdaptiveColorToString(t.SyntaxType()),
 				},
 				Operator: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.SyntaxOperator())),
+					Color:           AdaptiveColorToString(t.SyntaxOperator()),
 				},
 				Punctuation: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.SyntaxPunctuation())),
+					Color:           AdaptiveColorToString(t.SyntaxPunctuation()),
 				},
 				Name: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.SyntaxVariable())),
+					Color:           AdaptiveColorToString(t.SyntaxVariable()),
 				},
 				NameBuiltin: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.SyntaxVariable())),
+					Color:           AdaptiveColorToString(t.SyntaxVariable()),
 				},
 				NameTag: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.SyntaxKeyword())),
+					Color:           AdaptiveColorToString(t.SyntaxKeyword()),
 				},
 				NameAttribute: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.SyntaxFunction())),
+					Color:           AdaptiveColorToString(t.SyntaxFunction()),
 				},
 				NameClass: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.SyntaxType())),
+					Color:           AdaptiveColorToString(t.SyntaxType()),
 				},
 				NameConstant: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.SyntaxVariable())),
+					Color:           AdaptiveColorToString(t.SyntaxVariable()),
 				},
 				NameDecorator: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.SyntaxFunction())),
+					Color:           AdaptiveColorToString(t.SyntaxFunction()),
 				},
 				NameFunction: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.SyntaxFunction())),
+					Color:           AdaptiveColorToString(t.SyntaxFunction()),
 				},
 				LiteralNumber: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.SyntaxNumber())),
+					Color:           AdaptiveColorToString(t.SyntaxNumber()),
 				},
 				LiteralString: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.SyntaxString())),
+					Color:           AdaptiveColorToString(t.SyntaxString()),
 				},
 				LiteralStringEscape: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.SyntaxKeyword())),
+					Color:           AdaptiveColorToString(t.SyntaxKeyword()),
 				},
 				GenericDeleted: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.DiffRemoved())),
+					Color:           AdaptiveColorToString(t.DiffRemoved()),
 				},
 				GenericEmph: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.MarkdownEmph())),
+					Color:           AdaptiveColorToString(t.MarkdownEmph()),
 					Italic:          boolPtr(true),
 				},
 				GenericInserted: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.DiffAdded())),
+					Color:           AdaptiveColorToString(t.DiffAdded()),
 				},
 				GenericStrong: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.MarkdownStrong())),
+					Color:           AdaptiveColorToString(t.MarkdownStrong()),
 					Bold:            boolPtr(true),
 				},
 				GenericSubheading: ansi.StylePrimitive{
 					BackgroundColor: background,
-					Color:           stringPtr(AdaptiveColorToString(t.MarkdownHeading())),
+					Color:           AdaptiveColorToString(t.MarkdownHeading()),
 				},
 			},
 		},
@@ -293,14 +294,14 @@ func generateMarkdownStyleConfig(backgroundColor compat.AdaptiveColor) ansi.Styl
 		},
 		DefinitionDescription: ansi.StylePrimitive{
 			BlockPrefix: "\n ❯ ",
-			Color:       stringPtr(AdaptiveColorToString(t.MarkdownLinkText())),
+			Color:       AdaptiveColorToString(t.MarkdownLinkText()),
 		},
 		Text: ansi.StylePrimitive{
-			Color: stringPtr(AdaptiveColorToString(t.MarkdownText())),
+			Color: AdaptiveColorToString(t.MarkdownText()),
 		},
 		Paragraph: ansi.StyleBlock{
 			StylePrimitive: ansi.StylePrimitive{
-				Color: stringPtr(AdaptiveColorToString(t.MarkdownText())),
+				Color: AdaptiveColorToString(t.MarkdownText()),
 			},
 		},
 	}
@@ -308,11 +309,17 @@ func generateMarkdownStyleConfig(backgroundColor compat.AdaptiveColor) ansi.Styl

 // AdaptiveColorToString converts a compat.AdaptiveColor to the appropriate
 // hex color string based on the current terminal background
-func AdaptiveColorToString(color compat.AdaptiveColor) string {
+func AdaptiveColorToString(color compat.AdaptiveColor) *string {
 	if Terminal.BackgroundIsDark {
+		if _, ok := color.Dark.(lipgloss.NoColor); ok {
+			return nil
+		}
 		c1, _ := colorful.MakeColor(color.Dark)
-		return c1.Hex()
+		return stringPtr(c1.Hex())
+	}
+	if _, ok := color.Light.(lipgloss.NoColor); ok {
+		return nil
 	}
 	c1, _ := colorful.MakeColor(color.Light)
-	return c1.Hex()
+	return stringPtr(c1.Hex())
 }
@@ -3,155 +3,8 @@ package styles
 import (
 	"github.com/charmbracelet/lipgloss/v2"
 	"github.com/charmbracelet/lipgloss/v2/compat"
-	"github.com/sst/opencode/internal/theme"
 )

-// BaseStyle returns the base style with background and foreground colors
-func BaseStyle() lipgloss.Style {
-	t := theme.CurrentTheme()
-	return lipgloss.NewStyle().Foreground(t.Text())
-}
-
-func Panel() lipgloss.Style {
-	t := theme.CurrentTheme()
-	return lipgloss.NewStyle().
-		Background(t.BackgroundPanel()).
-		Border(lipgloss.NormalBorder(), true, false, true, false).
-		BorderForeground(t.BorderSubtle()).
-		Foreground(t.Text())
-}
-
-// Regular returns a basic unstyled lipgloss.Style
-func Regular() lipgloss.Style {
-	return lipgloss.NewStyle()
-}
-
-func Muted() lipgloss.Style {
-	t := theme.CurrentTheme()
-	return lipgloss.NewStyle().Foreground(t.TextMuted())
-}
-
-// Bold returns a bold style
-func Bold() lipgloss.Style {
-	return BaseStyle().Bold(true)
-}
-
-// Padded returns a style with horizontal padding
-func Padded() lipgloss.Style {
-	return BaseStyle().Padding(0, 1)
-}
-
-// Border returns a style with a normal border
-func Border() lipgloss.Style {
-	t := theme.CurrentTheme()
-	return Regular().
-		Border(lipgloss.NormalBorder()).
-		BorderForeground(t.Border())
-}
-
-// ThickBorder returns a style with a thick border
-func ThickBorder() lipgloss.Style {
-	t := theme.CurrentTheme()
-	return Regular().
-		Border(lipgloss.ThickBorder()).
-		BorderForeground(t.Border())
-}
-
-// DoubleBorder returns a style with a double border
-func DoubleBorder() lipgloss.Style {
-	t := theme.CurrentTheme()
-	return Regular().
-		Border(lipgloss.DoubleBorder()).
-		BorderForeground(t.Border())
-}
-
-// FocusedBorder returns a style with a border using the focused border color
-func FocusedBorder() lipgloss.Style {
-	t := theme.CurrentTheme()
-	return Regular().
-		Border(lipgloss.NormalBorder()).
-		BorderForeground(t.BorderActive())
-}
-
-// DimBorder returns a style with a border using the dim border color
-func DimBorder() lipgloss.Style {
-	t := theme.CurrentTheme()
-	return Regular().
-		Border(lipgloss.NormalBorder()).
-		BorderForeground(t.BorderSubtle())
-}
-
-// PrimaryColor returns the primary color from the current theme
-func PrimaryColor() compat.AdaptiveColor {
-	return theme.CurrentTheme().Primary()
-}
-
-// SecondaryColor returns the secondary color from the current theme
-func SecondaryColor() compat.AdaptiveColor {
-	return theme.CurrentTheme().Secondary()
-}
-
-// AccentColor returns the accent color from the current theme
-func AccentColor() compat.AdaptiveColor {
-	return theme.CurrentTheme().Accent()
-}
-
-// ErrorColor returns the error color from the current theme
-func ErrorColor() compat.AdaptiveColor {
-	return theme.CurrentTheme().Error()
-}
-
-// WarningColor returns the warning color from the current theme
-func WarningColor() compat.AdaptiveColor {
-	return theme.CurrentTheme().Warning()
-}
-
-// SuccessColor returns the success color from the current theme
-func SuccessColor() compat.AdaptiveColor {
-	return theme.CurrentTheme().Success()
-}
-
-// InfoColor returns the info color from the current theme
-func InfoColor() compat.AdaptiveColor {
-	return theme.CurrentTheme().Info()
-}
-
-// TextColor returns the text color from the current theme
-func TextColor() compat.AdaptiveColor {
-	return theme.CurrentTheme().Text()
-}
-
-// TextMutedColor returns the muted text color from the current theme
-func TextMutedColor() compat.AdaptiveColor {
-	return theme.CurrentTheme().TextMuted()
-}
-
-// BackgroundColor returns the background color from the current theme
-func BackgroundColor() compat.AdaptiveColor {
-	return theme.CurrentTheme().Background()
-}
-
-// BackgroundPanelColor returns the subtle background color from the current theme
-func BackgroundPanelColor() compat.AdaptiveColor {
-	return theme.CurrentTheme().BackgroundPanel()
-}
-
-// BackgroundElementColor returns the darker background color from the current theme
-func BackgroundElementColor() compat.AdaptiveColor {
-	return theme.CurrentTheme().BackgroundElement()
-}
-
-// BorderColor returns the border color from the current theme
-func BorderColor() compat.AdaptiveColor {
-	return theme.CurrentTheme().Border()
-}
-
-// BorderActiveColor returns the active border color from the current theme
-func BorderActiveColor() compat.AdaptiveColor {
-	return theme.CurrentTheme().BorderActive()
-}
-
-// BorderSubtleColor returns the subtle border color from the current theme
-func BorderSubtleColor() compat.AdaptiveColor {
-	return theme.CurrentTheme().BorderSubtle()
+func WhitespaceStyle(bg compat.AdaptiveColor) lipgloss.WhitespaceOption {
+	return lipgloss.WithWhitespaceStyle(NewStyle().Background(bg).Lipgloss())
 }
@@ -0,0 +1,295 @@
+package styles
+
+import (
+	"image/color"
+
+	"github.com/charmbracelet/lipgloss/v2"
+	"github.com/charmbracelet/lipgloss/v2/compat"
+)
+
+// IsNoColor checks if a color is the special NoColor type
+func IsNoColor(c color.Color) bool {
+	_, ok := c.(lipgloss.NoColor)
+	return ok
+}
+
+// Style wraps lipgloss.Style to provide a fluent API for handling "none" colors
+type Style struct {
+	lipgloss.Style
+}
+
+// NewStyle creates a new Style with proper handling of "none" colors
+func NewStyle() Style {
+	return Style{lipgloss.NewStyle()}
+}
+
+func (s Style) Lipgloss() lipgloss.Style {
+	return s.Style
+}
+
+// Foreground sets the foreground color, handling "none" appropriately
+func (s Style) Foreground(c compat.AdaptiveColor) Style {
+	if IsNoColor(c.Dark) && IsNoColor(c.Light) {
+		return Style{s.Style.UnsetForeground()}
+	}
+	return Style{s.Style.Foreground(c)}
+}
+
+// Background sets the background color, handling "none" appropriately
+func (s Style) Background(c compat.AdaptiveColor) Style {
+	if IsNoColor(c.Dark) && IsNoColor(c.Light) {
+		return Style{s.Style.UnsetBackground()}
+	}
+	return Style{s.Style.Background(c)}
+}
+
+// BorderForeground sets the border foreground color, handling "none" appropriately
+func (s Style) BorderForeground(c compat.AdaptiveColor) Style {
+	if IsNoColor(c.Dark) && IsNoColor(c.Light) {
+		return Style{s.Style.UnsetBorderForeground()}
+	}
+	return Style{s.Style.BorderForeground(c)}
+}
+
+// BorderBackground sets the border background color, handling "none" appropriately
+func (s Style) BorderBackground(c compat.AdaptiveColor) Style {
+	if IsNoColor(c.Dark) && IsNoColor(c.Light) {
+		return Style{s.Style.UnsetBorderBackground()}
+	}
+	return Style{s.Style.BorderBackground(c)}
+}
+
+// BorderTopForeground sets the border top foreground color, handling "none" appropriately
+func (s Style) BorderTopForeground(c compat.AdaptiveColor) Style {
+	if IsNoColor(c.Dark) && IsNoColor(c.Light) {
+		return Style{s.Style.UnsetBorderTopForeground()}
+	}
+	return Style{s.Style.BorderTopForeground(c)}
+}
+
+// BorderTopBackground sets the border top background color, handling "none" appropriately
+func (s Style) BorderTopBackground(c compat.AdaptiveColor) Style {
+	if IsNoColor(c.Dark) && IsNoColor(c.Light) {
+		return Style{s.Style.UnsetBorderTopBackground()}
+	}
+	return Style{s.Style.BorderTopBackground(c)}
+}
+
+// BorderBottomForeground sets the border bottom foreground color, handling "none" appropriately
+func (s Style) BorderBottomForeground(c compat.AdaptiveColor) Style {
+	if IsNoColor(c.Dark) && IsNoColor(c.Light) {
+		return Style{s.Style.UnsetBorderBottomForeground()}
+	}
+	return Style{s.Style.BorderBottomForeground(c)}
+}
+
+// BorderBottomBackground sets the border bottom background color, handling "none" appropriately
+func (s Style) BorderBottomBackground(c compat.AdaptiveColor) Style {
+	if IsNoColor(c.Dark) && IsNoColor(c.Light) {
+		return Style{s.Style.UnsetBorderBottomBackground()}
+	}
+	return Style{s.Style.BorderBottomBackground(c)}
+}
+
+// BorderLeftForeground sets the border left foreground color, handling "none" appropriately
+func (s Style) BorderLeftForeground(c compat.AdaptiveColor) Style {
+	if IsNoColor(c.Dark) && IsNoColor(c.Light) {
+		return Style{s.Style.UnsetBorderLeftForeground()}
+	}
+	return Style{s.Style.BorderLeftForeground(c)}
+}
+
+// BorderLeftBackground sets the border left background color, handling "none" appropriately
+func (s Style) BorderLeftBackground(c compat.AdaptiveColor) Style {
+	if IsNoColor(c.Dark) && IsNoColor(c.Light) {
+		return Style{s.Style.UnsetBorderLeftBackground()}
+	}
+	return Style{s.Style.BorderLeftBackground(c)}
+}
+
+// BorderRightForeground sets the border right foreground color, handling "none" appropriately
+func (s Style) BorderRightForeground(c compat.AdaptiveColor) Style {
+	if IsNoColor(c.Dark) && IsNoColor(c.Light) {
+		return Style{s.Style.UnsetBorderRightForeground()}
+	}
+	return Style{s.Style.BorderRightForeground(c)}
+}
+
+// BorderRightBackground sets the border right background color, handling "none" appropriately
+func (s Style) BorderRightBackground(c compat.AdaptiveColor) Style {
+	if IsNoColor(c.Dark) && IsNoColor(c.Light) {
+		return Style{s.Style.UnsetBorderRightBackground()}
+	}
+	return Style{s.Style.BorderRightBackground(c)}
+}
+
+// Render applies the style to a string
+func (s Style) Render(str string) string {
+	return s.Style.Render(str)
+}
+
+// Common lipgloss.Style method delegations for seamless usage
+
+func (s Style) Bold(v bool) Style {
+	return Style{s.Style.Bold(v)}
+}
+
+func (s Style) Italic(v bool) Style {
+	return Style{s.Style.Italic(v)}
+}
+
+func (s Style) Underline(v bool) Style {
+	return Style{s.Style.Underline(v)}
+}
+
+func (s Style) Strikethrough(v bool) Style {
+	return Style{s.Style.Strikethrough(v)}
+}
+
+func (s Style) Blink(v bool) Style {
+	return Style{s.Style.Blink(v)}
+}
+
+func (s Style) Faint(v bool) Style {
+	return Style{s.Style.Faint(v)}
+}
+
+func (s Style) Reverse(v bool) Style {
+	return Style{s.Style.Reverse(v)}
+}
+
+func (s Style) Width(i int) Style {
+	return Style{s.Style.Width(i)}
+}
+
+func (s Style) Height(i int) Style {
+	return Style{s.Style.Height(i)}
+}
+
+func (s Style) Padding(i ...int) Style {
+	return Style{s.Style.Padding(i...)}
+}
+
+func (s Style) PaddingTop(i int) Style {
+	return Style{s.Style.PaddingTop(i)}
+}
+
+func (s Style) PaddingBottom(i int) Style {
+	return Style{s.Style.PaddingBottom(i)}
+}
+
+func (s Style) PaddingLeft(i int) Style {
+	return Style{s.Style.PaddingLeft(i)}
+}
+
+func (s Style) PaddingRight(i int) Style {
+	return Style{s.Style.PaddingRight(i)}
+}
+
+func (s Style) Margin(i ...int) Style {
+	return Style{s.Style.Margin(i...)}
+}
+
+func (s Style) MarginTop(i int) Style {
+	return Style{s.Style.MarginTop(i)}
+}
+
+func (s Style) MarginBottom(i int) Style {
+	return Style{s.Style.MarginBottom(i)}
+}
+
+func (s Style) MarginLeft(i int) Style {
+	return Style{s.Style.MarginLeft(i)}
+}
+
+func (s Style) MarginRight(i int) Style {
+	return Style{s.Style.MarginRight(i)}
+}
+
+func (s Style) Border(b lipgloss.Border, sides ...bool) Style {
+	return Style{s.Style.Border(b, sides...)}
+}
+
+func (s Style) BorderStyle(b lipgloss.Border) Style {
+	return Style{s.Style.BorderStyle(b)}
+}
+
+func (s Style) BorderTop(v bool) Style {
+	return Style{s.Style.BorderTop(v)}
+}
+
+func (s Style) BorderBottom(v bool) Style {
+	return Style{s.Style.BorderBottom(v)}
+}
+
+func (s Style) BorderLeft(v bool) Style {
+	return Style{s.Style.BorderLeft(v)}
+}
+
+func (s Style) BorderRight(v bool) Style {
+	return Style{s.Style.BorderRight(v)}
+}
+
+func (s Style) Align(p ...lipgloss.Position) Style {
+	return Style{s.Style.Align(p...)}
+}
+
+func (s Style) AlignHorizontal(p lipgloss.Position) Style {
+	return Style{s.Style.AlignHorizontal(p)}
+}
+
+func (s Style) AlignVertical(p lipgloss.Position) Style {
+	return Style{s.Style.AlignVertical(p)}
+}
+
+func (s Style) Inline(v bool) Style {
+	return Style{s.Style.Inline(v)}
+}
+
+func (s Style) MaxWidth(n int) Style {
+	return Style{s.Style.MaxWidth(n)}
+}
+
+func (s Style) MaxHeight(n int) Style {
+	return Style{s.Style.MaxHeight(n)}
+}
+
+func (s Style) TabWidth(n int) Style {
+	return Style{s.Style.TabWidth(n)}
+}
+
+func (s Style) UnsetBold() Style {
+	return Style{s.Style.UnsetBold()}
+}
+
+func (s Style) UnsetItalic() Style {
+	return Style{s.Style.UnsetItalic()}
+}
+
+func (s Style) UnsetUnderline() Style {
+	return Style{s.Style.UnsetUnderline()}
+}
+
+func (s Style) UnsetStrikethrough() Style {
+	return Style{s.Style.UnsetStrikethrough()}
+}
+
+func (s Style) UnsetBlink() Style {
+	return Style{s.Style.UnsetBlink()}
+}
+
+func (s Style) UnsetFaint() Style {
+	return Style{s.Style.UnsetFaint()}
+}
+
+func (s Style) UnsetReverse() Style {
+	return Style{s.Style.UnsetReverse()}
+}
+
+func (s Style) Copy() Style {
+	return Style{s.Style}
+}
+
+func (s Style) Inherit(i Style) Style {
+	return Style{s.Style.Inherit(i.Style)}
+}
@@ -1,276 +0,0 @@
-package theme
-
-import (
-	"github.com/charmbracelet/lipgloss/v2"
-	"github.com/charmbracelet/lipgloss/v2/compat"
-)
-
-// AyuTheme implements the Theme interface with Ayu Dark colors.
-// It provides a modern dark theme inspired by the Ayu color scheme.
-type AyuTheme struct {
-	BaseTheme
-}
-
-// NewAyuTheme creates a new instance of the Ayu Dark theme.
-func NewAyuTheme() *AyuTheme {
-	// Ayu Dark color palette
-	// Base background colors
-	darkBg := "#0B0E14"    // App background
-	darkBgAlt := "#0D1017" // Editor background
-	darkLine := "#11151C"  // UI line separators
-	darkPanel := "#0F131A" // UI panel background
-
-	// Text colors
-	darkFg := "#BFBDB6"      // Primary text
-	darkFgMuted := "#565B66" // Muted text
-	darkGutter := "#6C7380"  // Gutter text
-
-	// Syntax highlighting colors
-	darkTag := "#39BAE6"      // Tags and attributes
-	darkFunc := "#FFB454"     // Functions
-	darkEntity := "#59C2FF"   // Entities and variables
-	darkString := "#AAD94C"   // Strings
-	darkRegexp := "#95E6CB"   // Regular expressions
-	darkMarkup := "#F07178"   // Markup elements
-	darkKeyword := "#FF8F40"  // Keywords
-	darkSpecial := "#E6B673"  // Special characters
-	darkComment := "#ACB6BF"  // Comments
-	darkConstant := "#D2A6FF" // Constants
-	darkOperator := "#F29668" // Operators
-
-	// Version control colors
-	darkAdded := "#7FD962"   // Added lines
-	darkRemoved := "#F26D78" // Removed lines
-
-	// Accent colors
-	darkAccent := "#E6B450" // Primary accent
-	darkError := "#D95757"  // Error color
-
-	// Active state colors
-	darkIndentActive := "#6C7380" // Active indent guides
-
-	theme := &AyuTheme{}
-
-	// Base colors
-	theme.PrimaryColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkEntity),
-		Light: lipgloss.Color(darkEntity),
-	}
-	theme.SecondaryColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkConstant),
-		Light: lipgloss.Color(darkConstant),
-	}
-	theme.AccentColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkAccent),
-		Light: lipgloss.Color(darkAccent),
-	}
-
-	// Status colors
-	theme.ErrorColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkError),
-		Light: lipgloss.Color(darkError),
-	}
-	theme.WarningColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkSpecial),
-		Light: lipgloss.Color(darkSpecial),
-	}
-	theme.SuccessColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkAdded),
-		Light: lipgloss.Color(darkAdded),
-	}
-	theme.InfoColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkTag),
-		Light: lipgloss.Color(darkTag),
-	}
-
-	// Text colors
-	theme.TextColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkFg),
-		Light: lipgloss.Color(darkFg),
-	}
-	theme.TextMutedColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkFgMuted),
-		Light: lipgloss.Color(darkFgMuted),
-	}
-
-	// Background colors
-	theme.BackgroundColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkBg),
-		Light: lipgloss.Color(darkBg),
-	}
-	theme.BackgroundPanelColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkBgAlt),
-		Light: lipgloss.Color(darkBgAlt),
-	}
-	theme.BackgroundElementColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkPanel),
-		Light: lipgloss.Color(darkPanel),
-	}
-
-	// Border colors
-	theme.BorderColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkGutter),
-		Light: lipgloss.Color(darkGutter),
-	}
-	theme.BorderActiveColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkIndentActive),
-		Light: lipgloss.Color(darkIndentActive),
-	}
-	theme.BorderSubtleColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkLine),
-		Light: lipgloss.Color(darkLine),
-	}
-
-	// Diff view colors
-	theme.DiffAddedColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkAdded),
-		Light: lipgloss.Color(darkAdded),
-	}
-	theme.DiffRemovedColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkRemoved),
-		Light: lipgloss.Color(darkRemoved),
-	}
-	theme.DiffContextColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkFgMuted),
-		Light: lipgloss.Color(darkFgMuted),
-	}
-	theme.DiffHunkHeaderColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkGutter),
-		Light: lipgloss.Color(darkGutter),
-	}
-	theme.DiffHighlightAddedColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkAdded),
-		Light: lipgloss.Color(darkAdded),
-	}
-	theme.DiffHighlightRemovedColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkRemoved),
-		Light: lipgloss.Color(darkRemoved),
-	}
-	theme.DiffAddedBgColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color("#1a2b1a"),
-		Light: lipgloss.Color("#1a2b1a"),
-	}
-	theme.DiffRemovedBgColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color("#2b1a1a"),
-		Light: lipgloss.Color("#2b1a1a"),
-	}
-	theme.DiffContextBgColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkBgAlt),
-		Light: lipgloss.Color(darkBgAlt),
-	}
-	theme.DiffLineNumberColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkGutter),
-		Light: lipgloss.Color(darkGutter),
-	}
-	theme.DiffAddedLineNumberBgColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color("#152b15"),
-		Light: lipgloss.Color("#152b15"),
-	}
-	theme.DiffRemovedLineNumberBgColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color("#2b1515"),
-		Light: lipgloss.Color("#2b1515"),
-	}
-
-	// Markdown colors
-	theme.MarkdownTextColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkFg),
-		Light: lipgloss.Color(darkFg),
-	}
-	theme.MarkdownHeadingColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkFunc),
-		Light: lipgloss.Color(darkFunc),
-	}
-	theme.MarkdownLinkColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkTag),
-		Light: lipgloss.Color(darkTag),
-	}
-	theme.MarkdownLinkTextColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkEntity),
-		Light: lipgloss.Color(darkEntity),
-	}
-	theme.MarkdownCodeColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkString),
-		Light: lipgloss.Color(darkString),
-	}
-	theme.MarkdownBlockQuoteColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkSpecial),
-		Light: lipgloss.Color(darkSpecial),
-	}
-	theme.MarkdownEmphColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkKeyword),
-		Light: lipgloss.Color(darkKeyword),
-	}
-	theme.MarkdownStrongColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkMarkup),
-		Light: lipgloss.Color(darkMarkup),
-	}
-	theme.MarkdownHorizontalRuleColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkGutter),
-		Light: lipgloss.Color(darkGutter),
-	}
-	theme.MarkdownListItemColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkOperator),
-		Light: lipgloss.Color(darkOperator),
-	}
-	theme.MarkdownListEnumerationColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkConstant),
-		Light: lipgloss.Color(darkConstant),
-	}
-	theme.MarkdownImageColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkRegexp),
-		Light: lipgloss.Color(darkRegexp),
-	}
-	theme.MarkdownImageTextColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkEntity),
-		Light: lipgloss.Color(darkEntity),
-	}
-	theme.MarkdownCodeBlockColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkString),
-		Light: lipgloss.Color(darkString),
-	}
-
-	// Syntax highlighting colors
-	theme.SyntaxCommentColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkComment),
-		Light: lipgloss.Color(darkComment),
-	}
-	theme.SyntaxKeywordColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkKeyword),
-		Light: lipgloss.Color(darkKeyword),
-	}
-	theme.SyntaxFunctionColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkFunc),
-		Light: lipgloss.Color(darkFunc),
-	}
-	theme.SyntaxVariableColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkEntity),
-		Light: lipgloss.Color(darkEntity),
-	}
-	theme.SyntaxStringColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkString),
-		Light: lipgloss.Color(darkString),
-	}
-	theme.SyntaxNumberColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkConstant),
-		Light: lipgloss.Color(darkConstant),
-	}
-	theme.SyntaxTypeColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkSpecial),
-		Light: lipgloss.Color(darkSpecial),
-	}
-	theme.SyntaxOperatorColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkOperator),
-		Light: lipgloss.Color(darkOperator),
-	}
-	theme.SyntaxPunctuationColor = compat.AdaptiveColor{
-		Dark:  lipgloss.Color(darkFg),
-		Light: lipgloss.Color(darkFg),
-	}
-
-	return theme
-}
-
-func init() {
-	// Register the Ayu theme with the theme manager
-	RegisterTheme("ayu", NewAyuTheme())
-}
--- a/Show More
+++ b/Show More