huge optimization for token usage with anthropic

🤖 Generated with [opencode](https://opencode.ai)

Co-Authored-By: opencode <noreply@opencode.ai>

README.md

@@ -50,6 +50,17 @@ $ bun install
 $ bun run packages/opencode/src/index.ts
 ```
 
+#### Development Notes
+
+**API Client Generation**: After making changes to the TypeScript API endpoints in `packages/opencode/src/server/server.ts`, you need to regenerate the Go client and OpenAPI specification:
+
+```bash
+$ cd packages/tui
+$ go generate ./pkg/client/
+```
+
+This updates the generated Go client code that the TUI uses to communicate with the backend server.
+
 ### FAQ
 
 #### How is this different than Claude Code?

packages/opencode/AGENTS.md

@@ -7,6 +7,7 @@
 - **Typecheck**: `bun run typecheck` (npm run typecheck)
 - **Test**: `bun test` (runs all tests)
 - **Single test**: `bun test test/tool/tool.test.ts` (specific test file)
+- **API Client Generation**: `cd packages/tui && go generate ./pkg/client/` (after changes to server endpoints)
 
 ## Code Style
 
@@ -37,3 +38,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 generated client. When adding/modifying server endpoints in `packages/opencode/src/server/server.ts`, run `cd packages/tui && go generate ./pkg/client/` to update the Go client code and OpenAPI spec.

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

@@ -7,17 +7,25 @@ export const UpgradeCommand = {
   command: "upgrade [target]",
   describe: "upgrade opencode to the latest version 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: "specific version to upgrade to (e.g., '0.1.48' or 'v0.1.48')",
+        type: "string",
+      })
+      .option("method", {
+        alias: "m",
+        describe: "installation method to use (curl, npm, pnpm, bun, brew)",
+        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()

packages/opencode/src/id/id.ts

@@ -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)
     )
   }
 }

packages/opencode/src/installation/index.ts

@@ -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,29 @@ 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`
         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"),

packages/opencode/src/provider/provider.ts

@@ -75,7 +75,7 @@ export namespace Provider {
       }
     },
     "amazon-bedrock": async () => {
-      if (!process.env["AWS_PROFILE"]) false
+      if (!process.env["AWS_PROFILE"]) return false
 
       const region = process.env["AWS_REGION"] ?? "us-east-1"
 

packages/opencode/src/provider/transform.ts

@@ -1,24 +1,25 @@
-import type { CoreMessage } from "ai"
+import type { CoreMessage, 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" },
+          },
+        }
       }
     }
-
-    return msg
+    return msgs
   }
 }

packages/opencode/src/session/index.ts

@@ -14,6 +14,7 @@ import {
   type CoreMessage,
   type UIMessage,
   type ProviderMetadata,
+  wrapLanguageModel,
 } from "ai"
 import { z, ZodSchema } from "zod"
 import { Decimal } from "decimal.js"
@@ -285,9 +286,7 @@ export namespace Session {
               parts: toParts(input.parts),
             },
           ]),
-        ].map((msg, i) =>
-          ProviderTransform.message(msg, i, input.providerID, input.modelID),
-        ),
+        ],
         model: model.language,
       })
         .then((result) => {
@@ -527,12 +526,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) {