release: v1.1.48

Revert "feat: Transitions, spacing, scroll fade, prompt area update (#11168 )" (#11461 )
Co-authored-by: adamelmore <2363879+adamdottv@users.noreply.github.com>
2026-01-31 13:48:22 +00:00 · 2026-01-31 07:18:51 -06:00 · 2026-01-31 06:42:47 -06:00 · 2026-01-31 01:07:22 -06:00 · 2026-01-31 06:59:18 +00:00 · 2026-01-31 01:58:20 -05:00
137 changed files with 13775 additions and 4105 deletions
@@ -0,0 +1,43 @@
+name: "Setup Git Committer"
+description: "Create app token and configure git user"
+inputs:
+  opencode-app-id:
+    description: "OpenCode GitHub App ID"
+    required: true
+  opencode-app-secret:
+    description: "OpenCode GitHub App private key"
+    required: true
+outputs:
+  token:
+    description: "GitHub App token"
+    value: ${{ steps.apptoken.outputs.token }}
+  app-slug:
+    description: "GitHub App slug"
+    value: ${{ steps.apptoken.outputs.app-slug }}
+runs:
+  using: "composite"
+  steps:
+    - name: Create app token
+      id: apptoken
+      uses: actions/create-github-app-token@v2
+      with:
+        app-id: ${{ inputs.opencode-app-id }}
+        private-key: ${{ inputs.opencode-app-secret }}
+        owner: ${{ github.repository_owner }}
+
+    - name: Configure git user
+      run: |
+        slug="${{ steps.apptoken.outputs.app-slug }}"
+        git config --global user.name "${slug}[bot]"
+        git config --global user.email "${slug}[bot]@users.noreply.github.com"
+      shell: bash
+
+    - name: Clear checkout auth
+      run: |
+        git config --local --unset-all http.https://github.com/.extraheader || true
+      shell: bash
+
+    - name: Configure git remote
+      run: |
+        git remote set-url origin https://x-access-token:${{ steps.apptoken.outputs.token }}@github.com/${{ github.repository }}
+      shell: bash
@@ -1,3 +1,7 @@
 ### What does this PR do?

+Please provide a description of the issue (if there is one), the changes you made to fix it, and why they work. It is expected that you understand why your changes work and if you do not understand why at least say as much so a maintainer knows how much to value the pr.
+
+**If you paste a large clearly AI generated description here your PR may be IGNORED or CLOSED!**
+
 ### How did you verify your code works?
@@ -1,34 +1,32 @@
 name: beta

 on:
-  push:
-    branches: [dev]
-  pull_request:
-    types: [opened, synchronize, labeled, unlabeled]
+  workflow_dispatch:
+  schedule:
+    - cron: "0 * * * *"

 jobs:
  sync:
-    if: |
-      github.event_name == 'push' || 
-      (github.event_name == 'pull_request' && 
-       contains(github.event.pull_request.labels.*.name, 'contributor'))
    runs-on: blacksmith-4vcpu-ubuntu-2404
    permissions:
      contents: write
-      pull-requests: write
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0

      - name: Setup Bun
        uses: ./.github/actions/setup-bun

-      - name: Configure Git
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
+      - name: Setup Git Committer
+        id: setup-git-committer
+        uses: ./.github/actions/setup-git-committer
+        with:
+          opencode-app-id: ${{ vars.OPENCODE_APP_ID }}
+          opencode-app-secret: ${{ secrets.OPENCODE_APP_SECRET }}

      - name: Sync beta branch
        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GH_TOKEN: ${{ steps.setup-git-committer.outputs.token }}
        run: bun script/beta.ts
@@ -4,8 +4,6 @@ on:
  push:
    branches:
      - dev
-  pull_request:
-  workflow_dispatch:

 jobs:
  generate:
@@ -16,14 +14,17 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          repository: ${{ github.event.pull_request.head.repo.full_name || github.repository }}
-          ref: ${{ github.event.pull_request.head.ref || github.ref_name }}

      - name: Setup Bun
        uses: ./.github/actions/setup-bun

+      - name: Setup git committer
+        id: committer
+        uses: ./.github/actions/setup-git-committer
+        with:
+          opencode-app-id: ${{ vars.OPENCODE_APP_ID }}
+          opencode-app-secret: ${{ secrets.OPENCODE_APP_SECRET }}
+
      - name: Generate
        run: ./script/generate.ts

@@ -33,10 +34,8 @@ jobs:
            echo "No changes to commit"
            exit 0
          fi
-          git config --local user.email "action@github.com"
-          git config --local user.name "GitHub Action"
          git add -A
-          git commit -m "chore: generate"
+          git commit -m "chore: generate" --allow-empty
          git push origin HEAD:${{ github.ref_name }} --no-verify
          # if ! git push origin HEAD:${{ github.event.pull_request.head.ref || github.ref_name }} --no-verify; then
          #   echo ""
@@ -36,14 +36,16 @@ jobs:
          ref: ${{ github.head_ref || github.ref_name }}
          repository: ${{ github.event.pull_request.head.repo.full_name || github.repository }}

+      - name: Setup git committer
+        id: committer
+        uses: ./.github/actions/setup-git-committer
+        with:
+          opencode-app-id: ${{ vars.OPENCODE_APP_ID }}
+          opencode-app-secret: ${{ secrets.OPENCODE_APP_SECRET }}
+
      - name: Setup Nix
        uses: nixbuild/nix-quick-install-action@v34

-      - name: Configure git
-        run: |
-          git config --global user.email "action@github.com"
-          git config --global user.name "Github Action"
-
      - name: Pull latest changes
        env:
          TARGET_BRANCH: ${{ github.head_ref || github.ref_name }}
@@ -36,7 +36,15 @@ jobs:
    if: github.repository == 'anomalyco/opencode'
    steps:
      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
      - uses: ./.github/actions/setup-bun
+
+      - name: Install OpenCode
+        if: inputs.bump || inputs.version
+        run: bun i -g opencode-ai
+
      - id: version
        run: |
          ./script/version.ts
@@ -44,6 +52,7 @@ jobs:
          GH_TOKEN: ${{ github.token }}
          OPENCODE_BUMP: ${{ inputs.bump }}
          OPENCODE_VERSION: ${{ inputs.version }}
+          OPENCODE_API_KEY: ${{ secrets.OPENCODE_API_KEY }}
    outputs:
      version: ${{ steps.version.outputs.version }}
      release: ${{ steps.version.outputs.release }}
@@ -94,7 +103,7 @@ jobs:
            target: x86_64-pc-windows-msvc
          - host: blacksmith-4vcpu-ubuntu-2404
            target: x86_64-unknown-linux-gnu
-          - host: blacksmith-4vcpu-ubuntu-2404-arm
+          - host: blacksmith-8vcpu-ubuntu-2404-arm
            target: aarch64-unknown-linux-gnu
    runs-on: ${{ matrix.settings.host }}
    steps:
@@ -155,7 +164,7 @@ jobs:
          bun ./scripts/prepare.ts
        env:
          OPENCODE_VERSION: ${{ needs.version.outputs.version }}
-          GITHUB_TOKEN: ${{ secrets.SST_GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ steps.committer.outputs.token }}
          RUST_TARGET: ${{ matrix.settings.target }}
          GH_TOKEN: ${{ github.token }}
          GITHUB_RUN_ID: ${{ github.run_id }}
@@ -201,15 +210,9 @@ jobs:
    runs-on: blacksmith-4vcpu-ubuntu-2404
    steps:
      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0

      - uses: ./.github/actions/setup-bun

-      - name: Install OpenCode
-        if: inputs.bump || inputs.version
-        run: bun i -g opencode-ai
-
      - name: Login to GitHub Container Registry
        uses: docker/login-action@v3
        with:
@@ -228,11 +231,12 @@ jobs:
          node-version: "24"
          registry-url: "https://registry.npmjs.org"

-      - name: Setup Git Identity
-        run: |
-          git config --global user.email "opencode@sst.dev"
-          git config --global user.name "opencode"
-          git remote set-url origin https://x-access-token:${{ secrets.SST_GITHUB_TOKEN }}@github.com/${{ github.repository }}
+      - name: Setup git committer
+        id: committer
+        uses: ./.github/actions/setup-git-committer
+        with:
+          opencode-app-id: ${{ vars.OPENCODE_APP_ID }}
+          opencode-app-secret: ${{ secrets.OPENCODE_APP_SECRET }}

      - uses: actions/download-artifact@v4
        with:
@@ -263,6 +267,5 @@ jobs:
          OPENCODE_VERSION: ${{ needs.version.outputs.version }}
          OPENCODE_RELEASE: ${{ needs.version.outputs.release }}
          AUR_KEY: ${{ secrets.AUR_KEY }}
-          GITHUB_TOKEN: ${{ secrets.SST_GITHUB_TOKEN }}
-          OPENCODE_API_KEY: ${{ secrets.OPENCODE_API_KEY }}
+          GITHUB_TOKEN: ${{ steps.committer.outputs.token }}
          NPM_CONFIG_PROVENANCE: false
@@ -1,6 +1,9 @@
 name: test

 on:
+  push:
+    branches:
+      - dev
  pull_request:
  workflow_dispatch:
 jobs:
@@ -23,7 +23,7 @@
    },
    "packages/app": {
      "name": "@opencode-ai/app",
-      "version": "1.1.44",
+      "version": "1.1.48",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@opencode-ai/sdk": "workspace:*",
@@ -73,7 +73,7 @@
    },
    "packages/console/app": {
      "name": "@opencode-ai/console-app",
-      "version": "1.1.44",
+      "version": "1.1.48",
      "dependencies": {
        "@cloudflare/vite-plugin": "1.15.2",
        "@ibm/plex": "6.4.1",
@@ -107,7 +107,7 @@
    },
    "packages/console/core": {
      "name": "@opencode-ai/console-core",
-      "version": "1.1.44",
+      "version": "1.1.48",
      "dependencies": {
        "@aws-sdk/client-sts": "3.782.0",
        "@jsx-email/render": "1.1.1",
@@ -134,7 +134,7 @@
    },
    "packages/console/function": {
      "name": "@opencode-ai/console-function",
-      "version": "1.1.44",
+      "version": "1.1.48",
      "dependencies": {
        "@ai-sdk/anthropic": "2.0.0",
        "@ai-sdk/openai": "2.0.2",
@@ -158,7 +158,7 @@
    },
    "packages/console/mail": {
      "name": "@opencode-ai/console-mail",
-      "version": "1.1.44",
+      "version": "1.1.48",
      "dependencies": {
        "@jsx-email/all": "2.2.3",
        "@jsx-email/cli": "1.4.3",
@@ -182,7 +182,7 @@
    },
    "packages/desktop": {
      "name": "@opencode-ai/desktop",
-      "version": "1.1.44",
+      "version": "1.1.48",
      "dependencies": {
        "@opencode-ai/app": "workspace:*",
        "@opencode-ai/ui": "workspace:*",
@@ -213,7 +213,7 @@
    },
    "packages/enterprise": {
      "name": "@opencode-ai/enterprise",
-      "version": "1.1.44",
+      "version": "1.1.48",
      "dependencies": {
        "@opencode-ai/ui": "workspace:*",
        "@opencode-ai/util": "workspace:*",
@@ -242,7 +242,7 @@
    },
    "packages/function": {
      "name": "@opencode-ai/function",
-      "version": "1.1.44",
+      "version": "1.1.48",
      "dependencies": {
        "@octokit/auth-app": "8.0.1",
        "@octokit/rest": "catalog:",
@@ -258,7 +258,7 @@
    },
    "packages/opencode": {
      "name": "opencode",
-      "version": "1.1.44",
+      "version": "1.1.48",
      "bin": {
        "opencode": "./bin/opencode",
      },
@@ -362,7 +362,7 @@
    },
    "packages/plugin": {
      "name": "@opencode-ai/plugin",
-      "version": "1.1.44",
+      "version": "1.1.48",
      "dependencies": {
        "@opencode-ai/sdk": "workspace:*",
        "zod": "catalog:",
@@ -382,7 +382,7 @@
    },
    "packages/sdk/js": {
      "name": "@opencode-ai/sdk",
-      "version": "1.1.44",
+      "version": "1.1.48",
      "devDependencies": {
        "@hey-api/openapi-ts": "0.90.10",
        "@tsconfig/node22": "catalog:",
@@ -393,7 +393,7 @@
    },
    "packages/slack": {
      "name": "@opencode-ai/slack",
-      "version": "1.1.44",
+      "version": "1.1.48",
      "dependencies": {
        "@opencode-ai/sdk": "workspace:*",
        "@slack/bolt": "^3.17.1",
@@ -406,7 +406,7 @@
    },
    "packages/ui": {
      "name": "@opencode-ai/ui",
-      "version": "1.1.44",
+      "version": "1.1.48",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@opencode-ai/sdk": "workspace:*",
@@ -448,7 +448,7 @@
    },
    "packages/util": {
      "name": "@opencode-ai/util",
-      "version": "1.1.44",
+      "version": "1.1.48",
      "dependencies": {
        "zod": "catalog:",
      },
@@ -459,7 +459,7 @@
    },
    "packages/web": {
      "name": "@opencode-ai/web",
-      "version": "1.1.44",
+      "version": "1.1.48",
      "dependencies": {
        "@astrojs/cloudflare": "12.6.3",
        "@astrojs/markdown-remark": "6.3.1",
@@ -133,6 +133,8 @@ const ZEN_MODELS = [
  new sst.Secret("ZEN_MODELS6"),
  new sst.Secret("ZEN_MODELS7"),
  new sst.Secret("ZEN_MODELS8"),
+  new sst.Secret("ZEN_MODELS9"),
+  new sst.Secret("ZEN_MODELS10"),
 ]
 const STRIPE_SECRET_KEY = new sst.Secret("STRIPE_SECRET_KEY")
 const STRIPE_PUBLISHABLE_KEY = new sst.Secret("STRIPE_PUBLISHABLE_KEY")
@@ -0,0 +1,271 @@
+import { expect, type Locator, type Page } from "@playwright/test"
+import fs from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { execSync } from "node:child_process"
+import { modKey, serverUrl } from "./utils"
+import {
+  sessionItemSelector,
+  dropdownMenuTriggerSelector,
+  dropdownMenuContentSelector,
+  titlebarRightSelector,
+  popoverBodySelector,
+  listItemSelector,
+  listItemKeySelector,
+  listItemKeyStartsWithSelector,
+} from "./selectors"
+import type { createSdk } from "./utils"
+
+export async function defocus(page: Page) {
+  await page.mouse.click(5, 5)
+}
+
+export async function openPalette(page: Page) {
+  await defocus(page)
+  await page.keyboard.press(`${modKey}+P`)
+
+  const dialog = page.getByRole("dialog")
+  await expect(dialog).toBeVisible()
+  await expect(dialog.getByRole("textbox").first()).toBeVisible()
+  return dialog
+}
+
+export async function closeDialog(page: Page, dialog: Locator) {
+  await page.keyboard.press("Escape")
+  const closed = await dialog
+    .waitFor({ state: "detached", timeout: 1500 })
+    .then(() => true)
+    .catch(() => false)
+
+  if (closed) return
+
+  await page.keyboard.press("Escape")
+  const closedSecond = await dialog
+    .waitFor({ state: "detached", timeout: 1500 })
+    .then(() => true)
+    .catch(() => false)
+
+  if (closedSecond) return
+
+  await page.locator('[data-component="dialog-overlay"]').click({ position: { x: 5, y: 5 } })
+  await expect(dialog).toHaveCount(0)
+}
+
+export async function isSidebarClosed(page: Page) {
+  const main = page.locator("main")
+  const classes = (await main.getAttribute("class")) ?? ""
+  return classes.includes("xl:border-l")
+}
+
+export async function toggleSidebar(page: Page) {
+  await defocus(page)
+  await page.keyboard.press(`${modKey}+B`)
+}
+
+export async function openSidebar(page: Page) {
+  if (!(await isSidebarClosed(page))) return
+  await toggleSidebar(page)
+  await expect(page.locator("main")).not.toHaveClass(/xl:border-l/)
+}
+
+export async function closeSidebar(page: Page) {
+  if (await isSidebarClosed(page)) return
+  await toggleSidebar(page)
+  await expect(page.locator("main")).toHaveClass(/xl:border-l/)
+}
+
+export async function openSettings(page: Page) {
+  await defocus(page)
+
+  const dialog = page.getByRole("dialog")
+  await page.keyboard.press(`${modKey}+Comma`).catch(() => undefined)
+
+  const opened = await dialog
+    .waitFor({ state: "visible", timeout: 3000 })
+    .then(() => true)
+    .catch(() => false)
+
+  if (opened) return dialog
+
+  await page.getByRole("button", { name: "Settings" }).first().click()
+  await expect(dialog).toBeVisible()
+  return dialog
+}
+
+export async function seedProjects(page: Page, input: { directory: string; extra?: string[] }) {
+  await page.addInitScript(
+    (args: { directory: string; serverUrl: string; extra: string[] }) => {
+      const key = "opencode.global.dat:server"
+      const raw = localStorage.getItem(key)
+      const parsed = (() => {
+        if (!raw) return undefined
+        try {
+          return JSON.parse(raw) as unknown
+        } catch {
+          return undefined
+        }
+      })()
+
+      const store = parsed && typeof parsed === "object" ? (parsed as Record<string, unknown>) : {}
+      const list = Array.isArray(store.list) ? store.list : []
+      const lastProject = store.lastProject && typeof store.lastProject === "object" ? store.lastProject : {}
+      const projects = store.projects && typeof store.projects === "object" ? store.projects : {}
+      const nextProjects = { ...(projects as Record<string, unknown>) }
+
+      const add = (origin: string, directory: string) => {
+        const current = nextProjects[origin]
+        const items = Array.isArray(current) ? current : []
+        const existing = items.filter(
+          (p): p is { worktree: string; expanded?: boolean } =>
+            !!p &&
+            typeof p === "object" &&
+            "worktree" in p &&
+            typeof (p as { worktree?: unknown }).worktree === "string",
+        )
+
+        if (existing.some((p) => p.worktree === directory)) return
+        nextProjects[origin] = [{ worktree: directory, expanded: true }, ...existing]
+      }
+
+      const directories = [args.directory, ...args.extra]
+      for (const directory of directories) {
+        add("local", directory)
+        add(args.serverUrl, directory)
+      }
+
+      localStorage.setItem(
+        key,
+        JSON.stringify({
+          list,
+          projects: nextProjects,
+          lastProject,
+        }),
+      )
+    },
+    { directory: input.directory, serverUrl, extra: input.extra ?? [] },
+  )
+}
+
+export async function createTestProject() {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-e2e-project-"))
+
+  await fs.writeFile(path.join(root, "README.md"), "# e2e\n")
+
+  execSync("git init", { cwd: root, stdio: "ignore" })
+  execSync("git add -A", { cwd: root, stdio: "ignore" })
+  execSync('git -c user.name="e2e" -c user.email="e2e@example.com" commit -m "init" --allow-empty', {
+    cwd: root,
+    stdio: "ignore",
+  })
+
+  return root
+}
+
+export async function cleanupTestProject(directory: string) {
+  await fs.rm(directory, { recursive: true, force: true }).catch(() => undefined)
+}
+
+export function sessionIDFromUrl(url: string) {
+  const match = /\/session\/([^/?#]+)/.exec(url)
+  return match?.[1]
+}
+
+export async function hoverSessionItem(page: Page, sessionID: string) {
+  const sessionEl = page.locator(sessionItemSelector(sessionID)).first()
+  await expect(sessionEl).toBeVisible()
+  await sessionEl.hover()
+  return sessionEl
+}
+
+export async function openSessionMoreMenu(page: Page, sessionID: string) {
+  const sessionEl = await hoverSessionItem(page, sessionID)
+
+  const menuTrigger = sessionEl.locator(dropdownMenuTriggerSelector).first()
+  await expect(menuTrigger).toBeVisible()
+  await menuTrigger.click()
+
+  const menu = page.locator(dropdownMenuContentSelector).first()
+  await expect(menu).toBeVisible()
+  return menu
+}
+
+export async function clickMenuItem(menu: Locator, itemName: string | RegExp, options?: { force?: boolean }) {
+  const item = menu.getByRole("menuitem").filter({ hasText: itemName }).first()
+  await expect(item).toBeVisible()
+  await item.click({ force: options?.force })
+}
+
+export async function confirmDialog(page: Page, buttonName: string | RegExp) {
+  const dialog = page.getByRole("dialog").first()
+  await expect(dialog).toBeVisible()
+
+  const button = dialog.getByRole("button").filter({ hasText: buttonName }).first()
+  await expect(button).toBeVisible()
+  await button.click()
+}
+
+export async function openSharePopover(page: Page) {
+  const rightSection = page.locator(titlebarRightSelector)
+  const shareButton = rightSection.getByRole("button", { name: "Share" }).first()
+  await expect(shareButton).toBeVisible()
+
+  const popoverBody = page
+    .locator(popoverBodySelector)
+    .filter({ has: page.getByRole("button", { name: /^(Publish|Unpublish)$/ }) })
+    .first()
+
+  const opened = await popoverBody
+    .isVisible()
+    .then((x) => x)
+    .catch(() => false)
+
+  if (!opened) {
+    await shareButton.click()
+    await expect(popoverBody).toBeVisible()
+  }
+  return { rightSection, popoverBody }
+}
+
+export async function clickPopoverButton(page: Page, buttonName: string | RegExp) {
+  const button = page.getByRole("button").filter({ hasText: buttonName }).first()
+  await expect(button).toBeVisible()
+  await button.click()
+}
+
+export async function clickListItem(
+  container: Locator | Page,
+  filter: string | RegExp | { key?: string; text?: string | RegExp; keyStartsWith?: string },
+): Promise<Locator> {
+  let item: Locator
+
+  if (typeof filter === "string" || filter instanceof RegExp) {
+    item = container.locator(listItemSelector).filter({ hasText: filter }).first()
+  } else if (filter.keyStartsWith) {
+    item = container.locator(listItemKeyStartsWithSelector(filter.keyStartsWith)).first()
+  } else if (filter.key) {
+    item = container.locator(listItemKeySelector(filter.key)).first()
+  } else if (filter.text) {
+    item = container.locator(listItemSelector).filter({ hasText: filter.text }).first()
+  } else {
+    throw new Error("Invalid filter provided to clickListItem")
+  }
+
+  await expect(item).toBeVisible()
+  await item.click()
+  return item
+}
+
+export async function withSession<T>(
+  sdk: ReturnType<typeof createSdk>,
+  title: string,
+  callback: (session: { id: string; title: string }) => Promise<T>,
+): Promise<T> {
+  const session = await sdk.session.create({ title }).then((r) => r.data)
+  if (!session?.id) throw new Error("Session create did not return an id")
+
+  try {
+    return await callback(session)
+  } finally {
+    await sdk.session.delete({ sessionID: session.id }).catch(() => undefined)
+  }
+}
@@ -1,5 +1,5 @@
-import { test, expect } from "./fixtures"
-import { serverName } from "./utils"
+import { test, expect } from "../fixtures"
+import { serverName } from "../utils"

 test("home renders and shows core entrypoints", async ({ page }) => {
  await page.goto("/")
@@ -1,5 +1,6 @@
-import { test, expect } from "./fixtures"
-import { dirPath, promptSelector } from "./utils"
+import { test, expect } from "../fixtures"
+import { promptSelector } from "../selectors"
+import { dirPath } from "../utils"

 test("project route redirects to /session", async ({ page, directory, slug }) => {
  await page.goto(dirPath(directory))
@@ -0,0 +1,11 @@
+import { test, expect } from "../fixtures"
+import { openPalette } from "../actions"
+
+test("search palette opens and closes", async ({ page, gotoSession }) => {
+  await gotoSession()
+
+  const dialog = await openPalette(page)
+
+  await page.keyboard.press("Escape")
+  await expect(dialog).toHaveCount(0)
+})
@@ -1,5 +1,6 @@
-import { test, expect } from "./fixtures"
-import { serverName, serverUrl } from "./utils"
+import { test, expect } from "../fixtures"
+import { serverName, serverUrl } from "../utils"
+import { clickListItem, closeDialog, clickMenuItem } from "../actions"

 const DEFAULT_SERVER_URL_KEY = "opencode.settings.dat:defaultServerUrl"

@@ -33,31 +34,18 @@ test("can set a default server on web", async ({ page, gotoSession }) => {
  const row = dialog.locator('[data-slot="list-item"]').filter({ hasText: serverName }).first()
  await expect(row).toBeVisible()

-  const menu = row.locator('[data-component="icon-button"]').last()
-  await menu.click()
-  await page.getByRole("menuitem", { name: "Set as default" }).click()
+  const menuTrigger = row.locator('[data-slot="dropdown-menu-trigger"]').first()
+  await expect(menuTrigger).toBeVisible()
+  await menuTrigger.click({ force: true })
+
+  const menu = page.locator('[data-component="dropdown-menu-content"]').first()
+  await expect(menu).toBeVisible()
+  await clickMenuItem(menu, /set as default/i)

  await expect.poll(() => page.evaluate((key) => localStorage.getItem(key), DEFAULT_SERVER_URL_KEY)).toBe(serverUrl)
  await expect(row.getByText("Default", { exact: true })).toBeVisible()

-  await page.keyboard.press("Escape")
-  const closed = await dialog
-    .waitFor({ state: "detached", timeout: 1500 })
-    .then(() => true)
-    .catch(() => false)
-
-  if (!closed) {
-    await page.keyboard.press("Escape")
-    const closedSecond = await dialog
-      .waitFor({ state: "detached", timeout: 1500 })
-      .then(() => true)
-      .catch(() => false)
-
-    if (!closedSecond) {
-      await page.locator('[data-component="dialog-overlay"]').click({ position: { x: 5, y: 5 } })
-      await expect(dialog).toHaveCount(0)
-    }
-  }
+  await closeDialog(page, dialog)

  await ensurePopoverOpen()

@@ -0,0 +1,16 @@
+import { test, expect } from "../fixtures"
+import { promptSelector } from "../selectors"
+import { withSession } from "../actions"
+
+test("can open an existing session and type into the prompt", async ({ page, sdk, gotoSession }) => {
+  const title = `e2e smoke ${Date.now()}`
+
+  await withSession(sdk, title, async (session) => {
+    await gotoSession(session.id)
+
+    const prompt = page.locator(promptSelector)
+    await prompt.click()
+    await page.keyboard.type("hello from e2e")
+    await expect(prompt).toContainText("hello from e2e")
+  })
+})
@@ -0,0 +1,42 @@
+import { test, expect } from "../fixtures"
+import { openSidebar, withSession } from "../actions"
+import { promptSelector } from "../selectors"
+
+test("titlebar back/forward navigates between sessions", async ({ page, slug, sdk, gotoSession }) => {
+  await page.setViewportSize({ width: 1400, height: 800 })
+
+  const stamp = Date.now()
+
+  await withSession(sdk, `e2e titlebar history 1 ${stamp}`, async (one) => {
+    await withSession(sdk, `e2e titlebar history 2 ${stamp}`, async (two) => {
+      await gotoSession(one.id)
+
+      await openSidebar(page)
+
+      const link = page.locator(`[data-session-id="${two.id}"] a`).first()
+      await expect(link).toBeVisible()
+      await link.scrollIntoViewIfNeeded()
+      await link.click()
+
+      await expect(page).toHaveURL(new RegExp(`/${slug}/session/${two.id}(?:\\?|#|$)`))
+      await expect(page.locator(promptSelector)).toBeVisible()
+
+      const back = page.getByRole("button", { name: "Back" })
+      const forward = page.getByRole("button", { name: "Forward" })
+
+      await expect(back).toBeVisible()
+      await expect(back).toBeEnabled()
+      await back.click()
+
+      await expect(page).toHaveURL(new RegExp(`/${slug}/session/${one.id}(?:\\?|#|$)`))
+      await expect(page.locator(promptSelector)).toBeVisible()
+
+      await expect(forward).toBeVisible()
+      await expect(forward).toBeEnabled()
+      await forward.click()
+
+      await expect(page).toHaveURL(new RegExp(`/${slug}/session/${two.id}(?:\\?|#|$)`))
+      await expect(page.locator(promptSelector)).toBeVisible()
+    })
+  })
+})
@@ -1,20 +1,15 @@
-import { test, expect } from "./fixtures"
-import { modKey } from "./utils"
+import { test, expect } from "../fixtures"
+import { openPalette, clickListItem } from "../actions"

 test("can open a file tab from the search palette", async ({ page, gotoSession }) => {
  await gotoSession()

-  await page.keyboard.press(`${modKey}+P`)
-
-  const dialog = page.getByRole("dialog")
-  await expect(dialog).toBeVisible()
+  const dialog = await openPalette(page)

  const input = dialog.getByRole("textbox").first()
  await input.fill("package.json")

-  const fileItem = dialog.locator('[data-slot="list-item"][data-key^="file:"]').first()
-  await expect(fileItem).toBeVisible()
-  await fileItem.click()
+  await clickListItem(dialog, { keyStartsWith: "file:" })

  await expect(dialog).toHaveCount(0)

@@ -1,4 +1,4 @@
-import { test, expect } from "./fixtures"
+import { test, expect } from "../fixtures"

 test.skip("file tree can expand folders and open a file", async ({ page, gotoSession }) => {
  await gotoSession()
@@ -1,5 +1,5 @@
-import { test, expect } from "./fixtures"
-import { modKey } from "./utils"
+import { test, expect } from "../fixtures"
+import { openPalette, clickListItem } from "../actions"

 test("smoke file viewer renders real file content", async ({ page, gotoSession }) => {
  await gotoSession()
@@ -7,21 +7,12 @@ test("smoke file viewer renders real file content", async ({ page, gotoSession }
  const sep = process.platform === "win32" ? "\\" : "/"
  const file = ["packages", "app", "package.json"].join(sep)

-  await page.keyboard.press(`${modKey}+P`)
-
-  const dialog = page.getByRole("dialog")
-  await expect(dialog).toBeVisible()
+  const dialog = await openPalette(page)

  const input = dialog.getByRole("textbox").first()
  await input.fill(file)

-  const fileItem = dialog
-    .locator(
-      '[data-slot="list-item"][data-key^="file:"][data-key*="packages"][data-key*="app"][data-key$="package.json"]',
-    )
-    .first()
-  await expect(fileItem).toBeVisible()
-  await fileItem.click()
+  await clickListItem(dialog, { text: /packages.*app.*package.json/ })

  await expect(dialog).toHaveCount(0)

@@ -1,5 +1,7 @@
 import { test as base, expect } from "@playwright/test"
-import { createSdk, dirSlug, getWorktree, promptSelector, serverUrl, sessionPath } from "./utils"
+import { seedProjects } from "./actions"
+import { promptSelector } from "./selectors"
+import { createSdk, dirSlug, getWorktree, sessionPath } from "./utils"

 type TestFixtures = {
  sdk: ReturnType<typeof createSdk>
@@ -29,54 +31,17 @@ export const test = base.extend<TestFixtures, WorkerFixtures>({
    await use(createSdk(directory))
  },
  gotoSession: async ({ page, directory }, use) => {
-    await page.addInitScript(
-      (input: { directory: string; serverUrl: string }) => {
-        const key = "opencode.global.dat:server"
-        const raw = localStorage.getItem(key)
-        const parsed = (() => {
-          if (!raw) return undefined
-          try {
-            return JSON.parse(raw) as unknown
-          } catch {
-            return undefined
-          }
-        })()
-
-        const store = parsed && typeof parsed === "object" ? (parsed as Record<string, unknown>) : {}
-        const list = Array.isArray(store.list) ? store.list : []
-        const lastProject = store.lastProject && typeof store.lastProject === "object" ? store.lastProject : {}
-        const projects = store.projects && typeof store.projects === "object" ? store.projects : {}
-        const nextProjects = { ...(projects as Record<string, unknown>) }
-
-        const add = (origin: string) => {
-          const current = nextProjects[origin]
-          const items = Array.isArray(current) ? current : []
-          const existing = items.filter(
-            (p): p is { worktree: string; expanded?: boolean } =>
-              !!p &&
-              typeof p === "object" &&
-              "worktree" in p &&
-              typeof (p as { worktree?: unknown }).worktree === "string",
-          )
-
-          if (existing.some((p) => p.worktree === input.directory)) return
-          nextProjects[origin] = [{ worktree: input.directory, expanded: true }, ...existing]
-        }
-
-        add("local")
-        add(input.serverUrl)
-
-        localStorage.setItem(
-          key,
-          JSON.stringify({
-            list,
-            projects: nextProjects,
-            lastProject,
-          }),
-        )
-      },
-      { directory, serverUrl },
-    )
+    await seedProjects(page, { directory })
+    await page.addInitScript(() => {
+      localStorage.setItem(
+        "opencode.global.dat:model",
+        JSON.stringify({
+          recent: [{ providerID: "opencode", modelID: "big-pickle" }],
+          user: [],
+          variant: {},
+        }),
+      )
+    })

    const gotoSession = async (sessionID?: string) => {
      await page.goto(sessionPath(directory, sessionID))
@@ -1,5 +1,6 @@
-import { test, expect } from "./fixtures"
-import { promptSelector } from "./utils"
+import { test, expect } from "../fixtures"
+import { promptSelector } from "../selectors"
+import { clickListItem } from "../actions"

 test("smoke model selection updates prompt footer", async ({ page, gotoSession }) => {
  await gotoSession()
@@ -32,9 +33,7 @@ test("smoke model selection updates prompt footer", async ({ page, gotoSession }

  await input.fill(model)

-  const item = dialog.locator(`[data-slot="list-item"][data-key="${key}"]`)
-  await expect(item).toBeVisible()
-  await item.click()
+  await clickListItem(dialog, { key })

  await expect(dialog).toHaveCount(0)

@@ -1,5 +1,6 @@
-import { test, expect } from "./fixtures"
-import { modKey, promptSelector } from "./utils"
+import { test, expect } from "../fixtures"
+import { promptSelector } from "../selectors"
+import { closeDialog, openSettings, clickListItem } from "../actions"

 test("hiding a model removes it from the model picker", async ({ page, gotoSession }) => {
  await gotoSession()
@@ -27,18 +28,7 @@ test("hiding a model removes it from the model picker", async ({ page, gotoSessi
  await page.keyboard.press("Escape")
  await expect(picker).toHaveCount(0)

-  const settings = page.getByRole("dialog")
-
-  await page.keyboard.press(`${modKey}+Comma`).catch(() => undefined)
-  const opened = await settings
-    .waitFor({ state: "visible", timeout: 3000 })
-    .then(() => true)
-    .catch(() => false)
-
-  if (!opened) {
-    await page.getByRole("button", { name: "Settings" }).first().click()
-    await expect(settings).toBeVisible()
-  }
+  const settings = await openSettings(page)

  await settings.getByRole("tab", { name: "Models" }).click()
  const search = settings.getByPlaceholder("Search models")
@@ -52,22 +42,7 @@ test("hiding a model removes it from the model picker", async ({ page, gotoSessi
  await toggle.locator('[data-slot="switch-control"]').click()
  await expect(input).toHaveAttribute("aria-checked", "false")

-  await page.keyboard.press("Escape")
-  const closed = await settings
-    .waitFor({ state: "detached", timeout: 1500 })
-    .then(() => true)
-    .catch(() => false)
-  if (!closed) {
-    await page.keyboard.press("Escape")
-    const closedSecond = await settings
-      .waitFor({ state: "detached", timeout: 1500 })
-      .then(() => true)
-      .catch(() => false)
-    if (!closedSecond) {
-      await page.locator('[data-component="dialog-overlay"]').click({ position: { x: 5, y: 5 } })
-      await expect(settings).toHaveCount(0)
-    }
-  }
+  await closeDialog(page, settings)

  await page.locator(promptSelector).click()
  await page.keyboard.type("/model")
@@ -1,15 +0,0 @@
-import { test, expect } from "./fixtures"
-import { modKey } from "./utils"
-
-test("search palette opens and closes", async ({ page, gotoSession }) => {
-  await gotoSession()
-
-  await page.keyboard.press(`${modKey}+P`)
-
-  const dialog = page.getByRole("dialog")
-  await expect(dialog).toBeVisible()
-  await expect(dialog.getByRole("textbox").first()).toBeVisible()
-
-  await page.keyboard.press("Escape")
-  await expect(dialog).toHaveCount(0)
-})
@@ -0,0 +1,52 @@
+import { test, expect } from "../fixtures"
+import { openSidebar } from "../actions"
+
+test("dialog edit project updates name and startup script", async ({ page, gotoSession }) => {
+  await gotoSession()
+  await page.setViewportSize({ width: 1400, height: 800 })
+
+  await openSidebar(page)
+
+  const open = async () => {
+    const header = page.locator(".group\\/project").first()
+    await header.hover()
+    const trigger = header.getByRole("button", { name: "More options" }).first()
+    await expect(trigger).toBeVisible()
+    await trigger.click({ force: true })
+
+    const menu = page.locator('[data-component="dropdown-menu-content"]').first()
+    await expect(menu).toBeVisible()
+
+    const editItem = menu.getByRole("menuitem", { name: "Edit" }).first()
+    await expect(editItem).toBeVisible()
+    await editItem.click({ force: true })
+
+    const dialog = page.getByRole("dialog")
+    await expect(dialog).toBeVisible()
+    await expect(dialog.getByRole("heading", { level: 2 })).toHaveText("Edit project")
+    return dialog
+  }
+
+  const name = `e2e project ${Date.now()}`
+  const startup = `echo e2e_${Date.now()}`
+
+  const dialog = await open()
+
+  const nameInput = dialog.getByLabel("Name")
+  await nameInput.fill(name)
+
+  const startupInput = dialog.getByLabel("Workspace startup script")
+  await startupInput.fill(startup)
+
+  await dialog.getByRole("button", { name: "Save" }).click()
+  await expect(dialog).toHaveCount(0)
+
+  const header = page.locator(".group\\/project").first()
+  await expect(header).toContainText(name)
+
+  const reopened = await open()
+  await expect(reopened.getByLabel("Name")).toHaveValue(name)
+  await expect(reopened.getByLabel("Workspace startup script")).toHaveValue(startup)
+  await reopened.getByRole("button", { name: "Cancel" }).click()
+  await expect(reopened).toHaveCount(0)
+})
@@ -0,0 +1,70 @@
+import { test, expect } from "../fixtures"
+import { createTestProject, seedProjects, cleanupTestProject, openSidebar, clickMenuItem } from "../actions"
+import { projectCloseHoverSelector, projectCloseMenuSelector, projectSwitchSelector } from "../selectors"
+import { dirSlug } from "../utils"
+
+test("can close a project via hover card close button", async ({ page, directory, gotoSession }) => {
+  await page.setViewportSize({ width: 1400, height: 800 })
+
+  const other = await createTestProject()
+  const otherSlug = dirSlug(other)
+  await seedProjects(page, { directory, extra: [other] })
+
+  try {
+    await gotoSession()
+
+    await openSidebar(page)
+
+    const otherButton = page.locator(projectSwitchSelector(otherSlug)).first()
+    await expect(otherButton).toBeVisible()
+    await otherButton.hover()
+
+    const close = page.locator(projectCloseHoverSelector(otherSlug)).first()
+    await expect(close).toBeVisible()
+    await close.click()
+
+    await expect(otherButton).toHaveCount(0)
+  } finally {
+    await cleanupTestProject(other)
+  }
+})
+
+test("can close a project via project header more options menu", async ({ page, directory, gotoSession }) => {
+  await page.setViewportSize({ width: 1400, height: 800 })
+
+  const other = await createTestProject()
+  const otherName = other.split("/").pop() ?? other
+  const otherSlug = dirSlug(other)
+  await seedProjects(page, { directory, extra: [other] })
+
+  try {
+    await gotoSession()
+
+    await openSidebar(page)
+
+    const otherButton = page.locator(projectSwitchSelector(otherSlug)).first()
+    await expect(otherButton).toBeVisible()
+    await otherButton.click()
+
+    await expect(page).toHaveURL(new RegExp(`/${otherSlug}/session`))
+
+    const header = page
+      .locator(".group\\/project")
+      .filter({ has: page.locator(`[data-action="project-menu"][data-project="${otherSlug}"]`) })
+      .first()
+    await expect(header).toContainText(otherName)
+
+    const trigger = header.locator(`[data-action="project-menu"][data-project="${otherSlug}"]`).first()
+    await expect(trigger).toHaveCount(1)
+    await trigger.focus()
+    await page.keyboard.press("Enter")
+
+    const menu = page.locator('[data-component="dropdown-menu-content"]').first()
+    await expect(menu).toBeVisible({ timeout: 10_000 })
+
+    await clickMenuItem(menu, /^Close$/i, { force: true })
+    await expect(otherButton).toHaveCount(0)
+  } finally {
+    await cleanupTestProject(other)
+  }
+})
@@ -0,0 +1,34 @@
+import { test, expect } from "../fixtures"
+import { defocus, createTestProject, seedProjects, cleanupTestProject } from "../actions"
+import { projectSwitchSelector } from "../selectors"
+import { dirSlug } from "../utils"
+
+test("can switch between projects from sidebar", async ({ page, directory, gotoSession }) => {
+  await page.setViewportSize({ width: 1400, height: 800 })
+
+  const other = await createTestProject()
+  const otherSlug = dirSlug(other)
+
+  await seedProjects(page, { directory, extra: [other] })
+
+  try {
+    await gotoSession()
+
+    await defocus(page)
+
+    const currentSlug = dirSlug(directory)
+    const otherButton = page.locator(projectSwitchSelector(otherSlug)).first()
+    await expect(otherButton).toBeVisible()
+    await otherButton.click()
+
+    await expect(page).toHaveURL(new RegExp(`/${otherSlug}/session`))
+
+    const currentButton = page.locator(projectSwitchSelector(currentSlug)).first()
+    await expect(currentButton).toBeVisible()
+    await currentButton.click()
+
+    await expect(page).toHaveURL(new RegExp(`/${currentSlug}/session`))
+  } finally {
+    await cleanupTestProject(other)
+  }
+})
@@ -1,16 +1,13 @@
-import { test, expect } from "./fixtures"
-import { promptSelector } from "./utils"
+import { test, expect } from "../fixtures"
+import { promptSelector } from "../selectors"
+import { withSession } from "../actions"

 test("context panel can be opened from the prompt", async ({ page, sdk, gotoSession }) => {
  const title = `e2e smoke context ${Date.now()}`
-  const created = await sdk.session.create({ title }).then((r) => r.data)

-  if (!created?.id) throw new Error("Session create did not return an id")
-  const sessionID = created.id
-
-  try {
+  await withSession(sdk, title, async (session) => {
    await sdk.session.promptAsync({
-      sessionID,
+      sessionID: session.id,
      noReply: true,
      parts: [
        {
@@ -22,12 +19,12 @@ test("context panel can be opened from the prompt", async ({ page, sdk, gotoSess

    await expect
      .poll(async () => {
-        const messages = await sdk.session.messages({ sessionID, limit: 1 }).then((r) => r.data ?? [])
+        const messages = await sdk.session.messages({ sessionID: session.id, limit: 1 }).then((r) => r.data ?? [])
        return messages.length
      })
      .toBeGreaterThan(0)

-    await gotoSession(sessionID)
+    await gotoSession(session.id)

    const contextButton = page
      .locator('[data-component="button"]')
@@ -39,7 +36,5 @@ test("context panel can be opened from the prompt", async ({ page, sdk, gotoSess

    const tabs = page.locator('[data-component="tabs"][data-variant="normal"]')
    await expect(tabs.getByRole("tab", { name: "Context" })).toBeVisible()
-  } finally {
-    await sdk.session.delete({ sessionID }).catch(() => undefined)
-  }
+  })
 })
@@ -1,5 +1,5 @@
-import { test, expect } from "./fixtures"
-import { promptSelector } from "./utils"
+import { test, expect } from "../fixtures"
+import { promptSelector } from "../selectors"

 test("smoke @mention inserts file pill token", async ({ page, gotoSession }) => {
  await gotoSession()
@@ -1,5 +1,5 @@
-import { test, expect } from "./fixtures"
-import { promptSelector } from "./utils"
+import { test, expect } from "../fixtures"
+import { promptSelector } from "../selectors"

 test("smoke /open opens file picker dialog", async ({ page, gotoSession }) => {
  await gotoSession()
@@ -1,10 +1,6 @@
-import { test, expect } from "./fixtures"
-import { promptSelector } from "./utils"
-
-function sessionIDFromUrl(url: string) {
-  const match = /\/session\/([^/?#]+)/.exec(url)
-  return match?.[1]
-}
+import { test, expect } from "../fixtures"
+import { promptSelector } from "../selectors"
+import { sessionIDFromUrl, withSession } from "../actions"

 test("can send a prompt and receive a reply", async ({ page, sdk, gotoSession }) => {
  test.setTimeout(120_000)
@@ -0,0 +1,35 @@
+export const promptSelector = '[data-component="prompt-input"]'
+export const terminalSelector = '[data-component="terminal"]'
+
+export const modelVariantCycleSelector = '[data-action="model-variant-cycle"]'
+export const settingsLanguageSelectSelector = '[data-action="settings-language"]'
+
+export const sidebarNavSelector = '[data-component="sidebar-nav-desktop"]'
+
+export const projectSwitchSelector = (slug: string) =>
+  `${sidebarNavSelector} [data-action="project-switch"][data-project="${slug}"]`
+
+export const projectCloseHoverSelector = (slug: string) => `[data-action="project-close-hover"][data-project="${slug}"]`
+
+export const projectMenuTriggerSelector = (slug: string) =>
+  `${sidebarNavSelector} [data-action="project-menu"][data-project="${slug}"]`
+
+export const projectCloseMenuSelector = (slug: string) => `[data-action="project-close-menu"][data-project="${slug}"]`
+
+export const titlebarRightSelector = "#opencode-titlebar-right"
+
+export const popoverBodySelector = '[data-slot="popover-body"]'
+
+export const dropdownMenuTriggerSelector = '[data-slot="dropdown-menu-trigger"]'
+
+export const dropdownMenuContentSelector = '[data-component="dropdown-menu-content"]'
+
+export const inlineInputSelector = '[data-component="inline-input"]'
+
+export const sessionItemSelector = (sessionID: string) => `${sidebarNavSelector} [data-session-id="${sessionID}"]`
+
+export const listItemSelector = '[data-slot="list-item"]'
+
+export const listItemKeyStartsWithSelector = (prefix: string) => `${listItemSelector}[data-key^="${prefix}"]`
+
+export const listItemKeySelector = (key: string) => `${listItemSelector}[data-key="${key}"]`
@@ -1,21 +0,0 @@
-import { test, expect } from "./fixtures"
-import { promptSelector } from "./utils"
-
-test("can open an existing session and type into the prompt", async ({ page, sdk, gotoSession }) => {
-  const title = `e2e smoke ${Date.now()}`
-  const created = await sdk.session.create({ title }).then((r) => r.data)
-
-  if (!created?.id) throw new Error("Session create did not return an id")
-  const sessionID = created.id
-
-  try {
-    await gotoSession(sessionID)
-
-    const prompt = page.locator(promptSelector)
-    await prompt.click()
-    await page.keyboard.type("hello from e2e")
-    await expect(prompt).toContainText("hello from e2e")
-  } finally {
-    await sdk.session.delete({ sessionID }).catch(() => undefined)
-  }
-})
@@ -0,0 +1,115 @@
+import { test, expect } from "../fixtures"
+import {
+  openSidebar,
+  openSessionMoreMenu,
+  clickMenuItem,
+  confirmDialog,
+  openSharePopover,
+  withSession,
+} from "../actions"
+import { sessionItemSelector, inlineInputSelector } from "../selectors"
+
+const shareDisabled = process.env.OPENCODE_DISABLE_SHARE === "true" || process.env.OPENCODE_DISABLE_SHARE === "1"
+
+test("sidebar session can be renamed", async ({ page, sdk, gotoSession }) => {
+  const stamp = Date.now()
+  const originalTitle = `e2e rename test ${stamp}`
+  const newTitle = `e2e renamed ${stamp}`
+
+  await withSession(sdk, originalTitle, async (session) => {
+    await gotoSession(session.id)
+    await openSidebar(page)
+
+    const menu = await openSessionMoreMenu(page, session.id)
+    await clickMenuItem(menu, /rename/i)
+
+    const input = page.locator(sessionItemSelector(session.id)).locator(inlineInputSelector).first()
+    await expect(input).toBeVisible()
+    await input.fill(newTitle)
+    await input.press("Enter")
+
+    await expect(page.locator(sessionItemSelector(session.id)).locator("a").first()).toContainText(newTitle)
+  })
+})
+
+test("sidebar session can be archived", async ({ page, sdk, gotoSession }) => {
+  const stamp = Date.now()
+  const title = `e2e archive test ${stamp}`
+
+  await withSession(sdk, title, async (session) => {
+    await gotoSession(session.id)
+    await openSidebar(page)
+
+    const sessionEl = page.locator(sessionItemSelector(session.id))
+    const menu = await openSessionMoreMenu(page, session.id)
+    await clickMenuItem(menu, /archive/i)
+
+    await expect(sessionEl).not.toBeVisible()
+  })
+})
+
+test("sidebar session can be deleted", async ({ page, sdk, gotoSession }) => {
+  const stamp = Date.now()
+  const title = `e2e delete test ${stamp}`
+
+  await withSession(sdk, title, async (session) => {
+    await gotoSession(session.id)
+    await openSidebar(page)
+
+    const sessionEl = page.locator(sessionItemSelector(session.id))
+    const menu = await openSessionMoreMenu(page, session.id)
+    await clickMenuItem(menu, /delete/i)
+    await confirmDialog(page, /delete/i)
+
+    await expect(sessionEl).not.toBeVisible()
+  })
+})
+
+test("session can be shared and unshared via header button", async ({ page, sdk, gotoSession }) => {
+  test.skip(shareDisabled, "Share is disabled in this environment (OPENCODE_DISABLE_SHARE).")
+
+  const stamp = Date.now()
+  const title = `e2e share test ${stamp}`
+
+  await withSession(sdk, title, async (session) => {
+    await gotoSession(session.id)
+
+    const { rightSection, popoverBody } = await openSharePopover(page)
+    await popoverBody.getByRole("button", { name: "Publish" }).first().click()
+
+    await expect
+      .poll(
+        async () => {
+          const data = await sdk.session.get({ sessionID: session.id }).then((r) => r.data)
+          return data?.share?.url || undefined
+        },
+        { timeout: 30_000 },
+      )
+      .not.toBeUndefined()
+
+    const copyButton = rightSection.locator('button[aria-label="Copy link"]').first()
+    await expect(copyButton).toBeVisible({ timeout: 30_000 })
+
+    const sharedPopover = await openSharePopover(page)
+    const unpublish = sharedPopover.popoverBody.getByRole("button", { name: "Unpublish" }).first()
+    await expect(unpublish).toBeVisible({ timeout: 30_000 })
+    await unpublish.click()
+
+    await expect
+      .poll(
+        async () => {
+          const data = await sdk.session.get({ sessionID: session.id }).then((r) => r.data)
+          return data?.share?.url || undefined
+        },
+        { timeout: 30_000 },
+      )
+      .toBeUndefined()
+
+    await expect(copyButton).not.toBeVisible({ timeout: 30_000 })
+
+    const unsharedPopover = await openSharePopover(page)
+    await expect(unsharedPopover.popoverBody.getByRole("button", { name: "Publish" }).first()).toBeVisible({
+      timeout: 30_000,
+    })
+  })
+})
@@ -1,44 +0,0 @@
-import { test, expect } from "./fixtures"
-import { modKey } from "./utils"
-
-test("smoke settings dialog opens, switches tabs, closes", async ({ page, gotoSession }) => {
-  await gotoSession()
-
-  const dialog = page.getByRole("dialog")
-
-  await page.keyboard.press(`${modKey}+Comma`).catch(() => undefined)
-
-  const opened = await dialog
-    .waitFor({ state: "visible", timeout: 3000 })
-    .then(() => true)
-    .catch(() => false)
-
-  if (!opened) {
-    await page.getByRole("button", { name: "Settings" }).first().click()
-    await expect(dialog).toBeVisible()
-  }
-
-  await dialog.getByRole("tab", { name: "Shortcuts" }).click()
-  await expect(dialog.getByRole("button", { name: "Reset to defaults" })).toBeVisible()
-  await expect(dialog.getByPlaceholder("Search shortcuts")).toBeVisible()
-
-  await page.keyboard.press("Escape")
-
-  const closed = await dialog
-    .waitFor({ state: "detached", timeout: 1500 })
-    .then(() => true)
-    .catch(() => false)
-
-  if (closed) return
-
-  await page.keyboard.press("Escape")
-  const closedSecond = await dialog
-    .waitFor({ state: "detached", timeout: 1500 })
-    .then(() => true)
-    .catch(() => false)
-
-  if (closedSecond) return
-
-  await page.locator('[data-component="dialog-overlay"]').click({ position: { x: 5, y: 5 } })
-  await expect(dialog).toHaveCount(0)
-})
@@ -0,0 +1,28 @@
+import { test, expect } from "../fixtures"
+import { settingsLanguageSelectSelector } from "../selectors"
+import { openSettings } from "../actions"
+
+test("smoke changing language updates settings labels", async ({ page, gotoSession }) => {
+  await page.addInitScript(() => {
+    localStorage.setItem("opencode.global.dat:language", JSON.stringify({ locale: "en" }))
+  })
+
+  await gotoSession()
+
+  const dialog = await openSettings(page)
+
+  const heading = dialog.getByRole("heading", { level: 2 })
+  await expect(heading).toHaveText("General")
+
+  const select = dialog.locator(settingsLanguageSelectSelector)
+  await expect(select).toBeVisible()
+  await select.locator('[data-slot="select-select-trigger"]').click()
+
+  await page.locator('[data-slot="select-select-item"]').filter({ hasText: "Deutsch" }).click()
+
+  await expect(heading).toHaveText("Allgemein")
+
+  await select.locator('[data-slot="select-select-trigger"]').click()
+  await page.locator('[data-slot="select-select-item"]').filter({ hasText: "English" }).click()
+  await expect(heading).toHaveText("General")
+})
@@ -1,22 +1,11 @@
-import { test, expect } from "./fixtures"
-import { modKey, promptSelector } from "./utils"
+import { test, expect } from "../fixtures"
+import { promptSelector } from "../selectors"
+import { closeDialog, openSettings, clickListItem } from "../actions"

 test("smoke providers settings opens provider selector", async ({ page, gotoSession }) => {
  await gotoSession()

-  const dialog = page.getByRole("dialog")
-
-  await page.keyboard.press(`${modKey}+Comma`).catch(() => undefined)
-
-  const opened = await dialog
-    .waitFor({ state: "visible", timeout: 3000 })
-    .then(() => true)
-    .catch(() => false)
-
-  if (!opened) {
-    await page.getByRole("button", { name: "Settings" }).first().click()
-    await expect(dialog).toBeVisible()
-  }
+  const dialog = await openSettings(page)

  await dialog.getByRole("tab", { name: "Providers" }).click()
  await expect(dialog.getByText("Connected providers", { exact: true })).toBeVisible()
@@ -37,20 +26,5 @@ test("smoke providers settings opens provider selector", async ({ page, gotoSess
  const stillOpen = await dialog.isVisible().catch(() => false)
  if (!stillOpen) return

-  await page.keyboard.press("Escape")
-  const closed = await dialog
-    .waitFor({ state: "detached", timeout: 1500 })
-    .then(() => true)
-    .catch(() => false)
-  if (closed) return
-
-  await page.keyboard.press("Escape")
-  const closedSecond = await dialog
-    .waitFor({ state: "detached", timeout: 1500 })
-    .then(() => true)
-    .catch(() => false)
-  if (closedSecond) return
-
-  await page.locator('[data-component="dialog-overlay"]').click({ position: { x: 5, y: 5 } })
-  await expect(dialog).toHaveCount(0)
+  await closeDialog(page, dialog)
 })
@@ -0,0 +1,14 @@
+import { test, expect } from "../fixtures"
+import { closeDialog, openSettings } from "../actions"
+
+test("smoke settings dialog opens, switches tabs, closes", async ({ page, gotoSession }) => {
+  await gotoSession()
+
+  const dialog = await openSettings(page)
+
+  await dialog.getByRole("tab", { name: "Shortcuts" }).click()
+  await expect(dialog.getByRole("button", { name: "Reset to defaults" })).toBeVisible()
+  await expect(dialog.getByPlaceholder("Search shortcuts")).toBeVisible()
+
+  await closeDialog(page, dialog)
+})
@@ -1,21 +0,0 @@
-import { test, expect } from "./fixtures"
-import { modKey } from "./utils"
-
-test("sidebar can be collapsed and expanded", async ({ page, gotoSession }) => {
-  await gotoSession()
-
-  const main = page.locator("main")
-  const closedClass = /xl:border-l/
-  const isClosed = await main.evaluate((node) => node.className.includes("xl:border-l"))
-
-  if (isClosed) {
-    await page.keyboard.press(`${modKey}+B`)
-    await expect(main).not.toHaveClass(closedClass)
-  }
-
-  await page.keyboard.press(`${modKey}+B`)
-  await expect(main).toHaveClass(closedClass)
-
-  await page.keyboard.press(`${modKey}+B`)
-  await expect(main).not.toHaveClass(closedClass)
-})
@@ -1,33 +1,8 @@
-import { test, expect } from "./fixtures"
-import { modKey, promptSelector } from "./utils"
+import { test, expect } from "../fixtures"
+import { openSidebar, withSession } from "../actions"
+import { promptSelector } from "../selectors"

-type Locator = {
-  first: () => Locator
-  getAttribute: (name: string) => Promise<string | null>
-  scrollIntoViewIfNeeded: () => Promise<void>
-  click: () => Promise<void>
-}
-
-type Page = {
-  locator: (selector: string) => Locator
-  keyboard: {
-    press: (key: string) => Promise<void>
-  }
-}
-
-type Fixtures = {
-  page: Page
-  slug: string
-  sdk: {
-    session: {
-      create: (input: { title: string }) => Promise<{ data?: { id?: string } }>
-      delete: (input: { sessionID: string }) => Promise<unknown>
-    }
-  }
-  gotoSession: (sessionID?: string) => Promise<void>
-}
-
-test("sidebar session links navigate to the selected session", async ({ page, slug, sdk, gotoSession }: Fixtures) => {
+test("sidebar session links navigate to the selected session", async ({ page, slug, sdk, gotoSession }) => {
  const stamp = Date.now()

  const one = await sdk.session.create({ title: `e2e sidebar nav 1 ${stamp}` }).then((r) => r.data)
@@ -39,12 +14,7 @@ test("sidebar session links navigate to the selected session", async ({ page, sl
  try {
    await gotoSession(one.id)

-    const main = page.locator("main")
-    const collapsed = ((await main.getAttribute("class")) ?? "").includes("xl:border-l")
-    if (collapsed) {
-      await page.keyboard.press(`${modKey}+B`)
-      await expect(main).not.toHaveClass(/xl:border-l/)
-    }
+    await openSidebar(page)

    const target = page.locator(`[data-session-id="${two.id}"] a`).first()
    await expect(target).toBeVisible()
@@ -0,0 +1,14 @@
+import { test, expect } from "../fixtures"
+import { openSidebar, toggleSidebar } from "../actions"
+
+test("sidebar can be collapsed and expanded", async ({ page, gotoSession }) => {
+  await gotoSession()
+
+  await openSidebar(page)
+
+  await toggleSidebar(page)
+  await expect(page.locator("main")).toHaveClass(/xl:border-l/)
+
+  await toggleSidebar(page)
+  await expect(page.locator("main")).not.toHaveClass(/xl:border-l/)
+})
@@ -1,5 +1,6 @@
-import { test, expect } from "./fixtures"
-import { promptSelector, terminalSelector, terminalToggleKey } from "./utils"
+import { test, expect } from "../fixtures"
+import { promptSelector, terminalSelector } from "../selectors"
+import { terminalToggleKey } from "../utils"

 test("smoke terminal mounts and can create a second tab", async ({ page, gotoSession }) => {
  await gotoSession()
@@ -1,5 +1,6 @@
-import { test, expect } from "./fixtures"
-import { terminalSelector, terminalToggleKey } from "./utils"
+import { test, expect } from "../fixtures"
+import { terminalSelector } from "../selectors"
+import { terminalToggleKey } from "../utils"

 test("terminal panel can be toggled", async ({ page, gotoSession }) => {
  await gotoSession()
@@ -1,5 +1,5 @@
 import { test, expect } from "./fixtures"
-import { modelVariantCycleSelector } from "./utils"
+import { modelVariantCycleSelector } from "./selectors"

 test("smoke model variant cycle updates label", async ({ page, gotoSession }) => {
  await gotoSession()
@@ -1,52 +0,0 @@
-import { test, expect } from "./fixtures"
-import { modKey, promptSelector } from "./utils"
-
-test("titlebar back/forward navigates between sessions", async ({ page, slug, sdk, gotoSession }) => {
-  await page.setViewportSize({ width: 1400, height: 800 })
-
-  const stamp = Date.now()
-  const one = await sdk.session.create({ title: `e2e titlebar history 1 ${stamp}` }).then((r) => r.data)
-  const two = await sdk.session.create({ title: `e2e titlebar history 2 ${stamp}` }).then((r) => r.data)
-
-  if (!one?.id) throw new Error("Session create did not return an id")
-  if (!two?.id) throw new Error("Session create did not return an id")
-
-  try {
-    await gotoSession(one.id)
-
-    const main = page.locator("main")
-    const collapsed = ((await main.getAttribute("class")) ?? "").includes("xl:border-l")
-    if (collapsed) {
-      await page.keyboard.press(`${modKey}+B`)
-      await expect(main).not.toHaveClass(/xl:border-l/)
-    }
-
-    const link = page.locator(`[data-session-id="${two.id}"] a`).first()
-    await expect(link).toBeVisible()
-    await link.scrollIntoViewIfNeeded()
-    await link.click()
-
-    await expect(page).toHaveURL(new RegExp(`/${slug}/session/${two.id}(?:\\?|#|$)`))
-    await expect(page.locator(promptSelector)).toBeVisible()
-
-    const back = page.getByRole("button", { name: "Back" })
-    const forward = page.getByRole("button", { name: "Forward" })
-
-    await expect(back).toBeVisible()
-    await expect(back).toBeEnabled()
-    await back.click()
-
-    await expect(page).toHaveURL(new RegExp(`/${slug}/session/${one.id}(?:\\?|#|$)`))
-    await expect(page.locator(promptSelector)).toBeVisible()
-
-    await expect(forward).toBeVisible()
-    await expect(forward).toBeEnabled()
-    await forward.click()
-
-    await expect(page).toHaveURL(new RegExp(`/${slug}/session/${two.id}(?:\\?|#|$)`))
-    await expect(page.locator(promptSelector)).toBeVisible()
-  } finally {
-    await sdk.session.delete({ sessionID: one.id }).catch(() => undefined)
-    await sdk.session.delete({ sessionID: two.id }).catch(() => undefined)
-  }
-})
@@ -2,7 +2,7 @@
  "extends": "../tsconfig.json",
  "compilerOptions": {
    "noEmit": true,
-    "types": ["node"]
+    "types": ["node", "bun"]
  },
  "include": ["./**/*.ts"]
 }
@@ -10,10 +10,6 @@ export const serverName = `${serverHost}:${serverPort}`
 export const modKey = process.platform === "darwin" ? "Meta" : "Control"
 export const terminalToggleKey = "Control+Backquote"

-export const promptSelector = '[data-component="prompt-input"]'
-export const terminalSelector = '[data-component="terminal"]'
-export const modelVariantCycleSelector = '[data-action="model-variant-cycle"]'
-
 export function createSdk(directory?: string) {
  return createOpencodeClient({ baseUrl: serverUrl, directory, throwOnError: true })
 }
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/app",
-  "version": "1.1.44",
+  "version": "1.1.48",
  "description": "",
  "type": "module",
  "exports": {
@@ -58,7 +58,7 @@ const sandbox = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-e2e-"))

 const serverEnv = {
  ...process.env,
-  OPENCODE_DISABLE_SHARE: "true",
+  OPENCODE_DISABLE_SHARE: process.env.OPENCODE_DISABLE_SHARE ?? "true",
  OPENCODE_DISABLE_LSP_DOWNLOAD: "true",
  OPENCODE_DISABLE_DEFAULT_PLUGINS: "true",
  OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER: "true",
@@ -148,6 +148,7 @@ export const SettingsGeneral: Component = () => {
              description={language.t("settings.general.row.language.description")}
            >
              <Select
+                data-action="settings-language"
                options={languageOptions()}
                current={languageOptions().find((o) => o.value === language.locale())}
                value={(o) => o.value}
@@ -2285,6 +2285,8 @@ export default function Layout(props: ParentProps) {
      <button
        type="button"
        aria-label={projectName()}
+        data-action="project-switch"
+        data-project={base64Encode(props.project.worktree)}
        classList={{
          "flex items-center justify-center size-10 p-1 rounded-lg overflow-hidden transition-colors cursor-default": true,
          "bg-transparent border-2 border-icon-strong-base hover:bg-surface-base-hover": selected(),
@@ -2335,6 +2337,8 @@ export default function Layout(props: ParentProps) {
                    icon="circle-x"
                    variant="ghost"
                    class="shrink-0"
+                    data-action="project-close-hover"
+                    data-project={base64Encode(props.project.worktree)}
                    aria-label={language.t("common.close")}
                    onClick={(event) => {
                      event.stopPropagation()
@@ -2577,6 +2581,8 @@ export default function Layout(props: ParentProps) {
                      as={IconButton}
                      icon="dot-grid"
                      variant="ghost"
+                      data-action="project-menu"
+                      data-project={base64Encode(p.worktree)}
                      class="shrink-0 size-6 rounded-md opacity-0 group-hover/project:opacity-100 data-[expanded]:opacity-100 data-[expanded]:bg-surface-base-active"
                      aria-label={language.t("common.moreOptions")}
                    />
@@ -2604,7 +2610,11 @@ export default function Layout(props: ParentProps) {
                          </DropdownMenu.ItemLabel>
                        </DropdownMenu.Item>
                        <DropdownMenu.Separator />
-                        <DropdownMenu.Item onSelect={() => closeProject(p.worktree)}>
+                        <DropdownMenu.Item
+                          data-action="project-close-menu"
+                          data-project={base64Encode(p.worktree)}
+                          onSelect={() => closeProject(p.worktree)}
+                        >
                          <DropdownMenu.ItemLabel>{language.t("common.close")}</DropdownMenu.ItemLabel>
                        </DropdownMenu.Item>
                      </DropdownMenu.Content>
@@ -2814,6 +2824,7 @@ export default function Layout(props: ParentProps) {
      <div class="flex-1 min-h-0 flex">
        <nav
          aria-label={language.t("sidebar.nav.projectsAndSessions")}
+          data-component="sidebar-nav-desktop"
          classList={{
            "hidden xl:block": true,
            "relative shrink-0": true,
@@ -2873,6 +2884,7 @@ export default function Layout(props: ParentProps) {
          />
          <nav
            aria-label={language.t("sidebar.nav.projectsAndSessions")}
+            data-component="sidebar-nav-mobile"
            classList={{
              "@container fixed top-10 bottom-0 left-0 z-50 w-72 bg-background-base transition-transform duration-200 ease-out": true,
              "translate-x-0": layout.mobileSidebar.opened(),
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/console-app",
-  "version": "1.1.44",
+  "version": "1.1.48",
  "type": "module",
  "license": "MIT",
  "scripts": {
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode-ai/console-core",
-  "version": "1.1.44",
+  "version": "1.1.48",
  "private": true,
  "type": "module",
  "license": "MIT",
@@ -2,20 +2,21 @@

 import { $ } from "bun"
 import path from "path"
+import os from "os"
 import { ZenData } from "../src/model"

 const stage = process.argv[2]
 if (!stage) throw new Error("Stage is required")

 const root = path.resolve(process.cwd(), "..", "..", "..")
-const PARTS = 8
+const PARTS = 10

 // read the secret
 const ret = await $`bun sst secret list`.cwd(root).text()
 const lines = ret.split("\n")
 const values = Array.from({ length: PARTS }, (_, i) => {
  const value = lines
-    .find((line) => line.startsWith(`ZEN_MODELS${i + 1}`))
+    .find((line) => line.startsWith(`ZEN_MODELS${i + 1}=`))
    ?.split("=")
    .slice(1)
    .join("=")
@@ -27,6 +28,6 @@ const values = Array.from({ length: PARTS }, (_, i) => {
 ZenData.validate(JSON.parse(values.join("")))

 // update the secret
-for (let i = 0; i < PARTS; i++) {
-  await $`bun sst secret set ZEN_MODELS${i + 1} --stage ${stage} -- ${values[i]}`
-}
+const envFile = Bun.file(path.join(os.tmpdir(), `models-${Date.now()}.env`))
+await envFile.write(values.map((v, i) => `ZEN_MODELS${i + 1}=${v}`).join("\n"))
+await $`bun sst secret load ${envFile.name} --stage ${stage}`.cwd(root)
@@ -2,20 +2,21 @@

 import { $ } from "bun"
 import path from "path"
+import os from "os"
 import { ZenData } from "../src/model"

 const stage = process.argv[2]
 if (!stage) throw new Error("Stage is required")

 const root = path.resolve(process.cwd(), "..", "..", "..")
-const PARTS = 8
+const PARTS = 10

 // read the secret
 const ret = await $`bun sst secret list --stage ${stage}`.cwd(root).text()
 const lines = ret.split("\n")
 const values = Array.from({ length: PARTS }, (_, i) => {
  const value = lines
-    .find((line) => line.startsWith(`ZEN_MODELS${i + 1}`))
+    .find((line) => line.startsWith(`ZEN_MODELS${i + 1}=`))
    ?.split("=")
    .slice(1)
    .join("=")
@@ -27,6 +28,6 @@ const values = Array.from({ length: PARTS }, (_, i) => {
 ZenData.validate(JSON.parse(values.join("")))

 // update the secret
-for (let i = 0; i < PARTS; i++) {
-  await $`bun sst secret set ZEN_MODELS${i + 1} -- ${values[i]}`
-}
+const envFile = Bun.file(path.join(os.tmpdir(), `models-${Date.now()}.env`))
+await envFile.write(values.map((v, i) => `ZEN_MODELS${i + 1}=${v}`).join("\n"))
+await $`bun sst secret load ${envFile.name}`.cwd(root)
@@ -7,18 +7,20 @@ import { ZenData } from "../src/model"

 const root = path.resolve(process.cwd(), "..", "..", "..")
 const models = await $`bun sst secret list`.cwd(root).text()
-const PARTS = 8
+const PARTS = 10

 // read the line starting with "ZEN_MODELS"
 const lines = models.split("\n")
 const oldValues = Array.from({ length: PARTS }, (_, i) => {
  const value = lines
-    .find((line) => line.startsWith(`ZEN_MODELS${i + 1}`))
+    .find((line) => line.startsWith(`ZEN_MODELS${i + 1}=`))
    ?.split("=")
    .slice(1)
    .join("=")
-  if (!value) throw new Error(`ZEN_MODELS${i + 1} not found`)
-  return value
+  // TODO
+  //if (!value) throw new Error(`ZEN_MODELS${i + 1} not found`)
+  //return value
+  return value ?? ""
 })

 // store the prettified json to a temp file
@@ -38,6 +40,6 @@ const newValues = Array.from({ length: PARTS }, (_, i) =>
  newValue.slice(chunk * i, i === PARTS - 1 ? undefined : chunk * (i + 1)),
 )

-for (let i = 0; i < PARTS; i++) {
-  await $`bun sst secret set ZEN_MODELS${i + 1} -- ${newValues[i]}`
-}
+const envFile = Bun.file(path.join(os.tmpdir(), `models-${Date.now()}.env`))
+await envFile.write(newValues.map((v, i) => `ZEN_MODELS${i + 1}=${v}`).join("\n"))
+await $`bun sst secret load ${envFile.name}`.cwd(root)
@@ -75,7 +75,9 @@ export namespace ZenData {
        Resource.ZEN_MODELS5.value +
        Resource.ZEN_MODELS6.value +
        Resource.ZEN_MODELS7.value +
-        Resource.ZEN_MODELS8.value,
+        Resource.ZEN_MODELS8.value +
+        Resource.ZEN_MODELS9.value +
+        Resource.ZEN_MODELS10.value,
    )
    return ModelsSchema.parse(json)
  })
@@ -133,6 +133,10 @@ declare module "sst" {
      "type": "sst.sst.Secret"
      "value": string
    }
+    "ZEN_MODELS10": {
+      "type": "sst.sst.Secret"
+      "value": string
+    }
    "ZEN_MODELS2": {
      "type": "sst.sst.Secret"
      "value": string
@@ -161,6 +165,10 @@ declare module "sst" {
      "type": "sst.sst.Secret"
      "value": string
    }
+    "ZEN_MODELS9": {
+      "type": "sst.sst.Secret"
+      "value": string
+    }
    "ZEN_SESSION_SECRET": {
      "type": "sst.sst.Secret"
      "value": string
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/console-function",
-  "version": "1.1.44",
+  "version": "1.1.48",
  "$schema": "https://json.schemastore.org/package.json",
  "private": true,
  "type": "module",
@@ -133,6 +133,10 @@ declare module "sst" {
      "type": "sst.sst.Secret"
      "value": string
    }
+    "ZEN_MODELS10": {
+      "type": "sst.sst.Secret"
+      "value": string
+    }
    "ZEN_MODELS2": {
      "type": "sst.sst.Secret"
      "value": string
@@ -161,6 +165,10 @@ declare module "sst" {
      "type": "sst.sst.Secret"
      "value": string
    }
+    "ZEN_MODELS9": {
+      "type": "sst.sst.Secret"
+      "value": string
+    }
    "ZEN_SESSION_SECRET": {
      "type": "sst.sst.Secret"
      "value": string
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/console-mail",
-  "version": "1.1.44",
+  "version": "1.1.48",
  "dependencies": {
    "@jsx-email/all": "2.2.3",
    "@jsx-email/cli": "1.4.3",
@@ -133,6 +133,10 @@ declare module "sst" {
      "type": "sst.sst.Secret"
      "value": string
    }
+    "ZEN_MODELS10": {
+      "type": "sst.sst.Secret"
+      "value": string
+    }
    "ZEN_MODELS2": {
      "type": "sst.sst.Secret"
      "value": string
@@ -161,6 +165,10 @@ declare module "sst" {
      "type": "sst.sst.Secret"
      "value": string
    }
+    "ZEN_MODELS9": {
+      "type": "sst.sst.Secret"
+      "value": string
+    }
    "ZEN_SESSION_SECRET": {
      "type": "sst.sst.Secret"
      "value": string
@@ -1,7 +1,7 @@
 {
  "name": "@opencode-ai/desktop",
  "private": true,
-  "version": "1.1.44",
+  "version": "1.1.48",
  "type": "module",
  "license": "MIT",
  "scripts": {
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/enterprise",
-  "version": "1.1.44",
+  "version": "1.1.48",
  "private": true,
  "type": "module",
  "license": "MIT",
@@ -133,6 +133,10 @@ declare module "sst" {
      "type": "sst.sst.Secret"
      "value": string
    }
+    "ZEN_MODELS10": {
+      "type": "sst.sst.Secret"
+      "value": string
+    }
    "ZEN_MODELS2": {
      "type": "sst.sst.Secret"
      "value": string
@@ -161,6 +165,10 @@ declare module "sst" {
      "type": "sst.sst.Secret"
      "value": string
    }
+    "ZEN_MODELS9": {
+      "type": "sst.sst.Secret"
+      "value": string
+    }
    "ZEN_SESSION_SECRET": {
      "type": "sst.sst.Secret"
      "value": string
@@ -1,7 +1,7 @@
 id = "opencode"
 name = "OpenCode"
 description = "The open source coding agent."
-version = "1.1.44"
+version = "1.1.48"
 schema_version = 1
 authors = ["Anomaly"]
 repository = "https://github.com/anomalyco/opencode"
@@ -11,26 +11,26 @@ name = "OpenCode"
 icon = "./icons/opencode.svg"

 [agent_servers.opencode.targets.darwin-aarch64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.1.44/opencode-darwin-arm64.zip"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.1.48/opencode-darwin-arm64.zip"
 cmd = "./opencode"
 args = ["acp"]

 [agent_servers.opencode.targets.darwin-x86_64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.1.44/opencode-darwin-x64.zip"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.1.48/opencode-darwin-x64.zip"
 cmd = "./opencode"
 args = ["acp"]

 [agent_servers.opencode.targets.linux-aarch64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.1.44/opencode-linux-arm64.tar.gz"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.1.48/opencode-linux-arm64.tar.gz"
 cmd = "./opencode"
 args = ["acp"]

 [agent_servers.opencode.targets.linux-x86_64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.1.44/opencode-linux-x64.tar.gz"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.1.48/opencode-linux-x64.tar.gz"
 cmd = "./opencode"
 args = ["acp"]

 [agent_servers.opencode.targets.windows-x86_64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.1.44/opencode-windows-x64.zip"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.1.48/opencode-windows-x64.zip"
 cmd = "./opencode.exe"
 args = ["acp"]
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/function",
-  "version": "1.1.44",
+  "version": "1.1.48",
  "$schema": "https://json.schemastore.org/package.json",
  "private": true,
  "type": "module",
@@ -133,6 +133,10 @@ declare module "sst" {
      "type": "sst.sst.Secret"
      "value": string
    }
+    "ZEN_MODELS10": {
+      "type": "sst.sst.Secret"
+      "value": string
+    }
    "ZEN_MODELS2": {
      "type": "sst.sst.Secret"
      "value": string
@@ -161,6 +165,10 @@ declare module "sst" {
      "type": "sst.sst.Secret"
      "value": string
    }
+    "ZEN_MODELS9": {
+      "type": "sst.sst.Secret"
+      "value": string
+    }
    "ZEN_SESSION_SECRET": {
      "type": "sst.sst.Secret"
      "value": string
@@ -1,6 +1,6 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
-  "version": "1.1.44",
+  "version": "1.1.48",
  "name": "opencode",
  "type": "module",
  "license": "MIT",
@@ -14,11 +14,11 @@ process.chdir(dir)

 import pkg from "../package.json"
 import { Script } from "@opencode-ai/script"
-
+const modelsUrl = process.env.OPENCODE_MODELS_URL || "https://models.dev"
 // Fetch and generate models.dev snapshot
 const modelsData = process.env.MODELS_DEV_API_JSON
  ? await Bun.file(process.env.MODELS_DEV_API_JSON).text()
-  : await fetch(`https://models.dev/api.json`).then((x) => x.text())
+  : await fetch(`${modelsUrl}/api.json`).then((x) => x.text())
 await Bun.write(
  path.join(dir, "src/provider/models-snapshot.ts"),
  `// Auto-generated by build.ts - do not edit\nexport const snapshot = ${modelsData} as const\n`,
@@ -230,8 +230,14 @@ if (!Script.preview) {
    "",
  ].join("\n")

+  const token = process.env.GITHUB_TOKEN
+  if (!token) {
+    console.error("GITHUB_TOKEN is required to update homebrew tap")
+    process.exit(1)
+  }
+  const tap = `https://x-access-token:${token}@github.com/anomalyco/homebrew-tap.git`
  await $`rm -rf ./dist/homebrew-tap`
-  await $`git clone https://${process.env["GITHUB_TOKEN"]}@github.com/sst/homebrew-tap.git ./dist/homebrew-tap`
+  await $`git clone ${tap} ./dist/homebrew-tap`
  await Bun.file("./dist/homebrew-tap/opencode.rb").write(homebrewFormula)
  await $`cd ./dist/homebrew-tap && git add opencode.rb`
  await $`cd ./dist/homebrew-tap && git commit -m "Update to v${Script.version}"`
@@ -20,6 +20,7 @@ export const AcpCommand = cmd({
    })
  },
  handler: async (args) => {
+    process.env.OPENCODE_CLIENT = "acp"
    await bootstrap(process.cwd(), async () => {
      const opts = await resolveNetworkOptions(args)
      const server = Server.listen(opts)
@@ -345,8 +345,9 @@ export function Autocomplete(props: {
    const results: AutocompleteOption[] = [...command.slashes()]

    for (const serverCommand of sync.data.command) {
+      const label = serverCommand.source === "mcp" ? ":mcp" : serverCommand.source === "skill" ? ":skill" : ""
      results.push({
-        display: "/" + serverCommand.name + (serverCommand.mcp ? " (MCP)" : ""),
+        display: "/" + serverCommand.name + label,
        description: serverCommand.description,
        onSelect: () => {
          const newText = "/" + serverCommand.name + " "
@@ -6,6 +6,7 @@ import { Identifier } from "../id/id"
 import PROMPT_INITIALIZE from "./template/initialize.txt"
 import PROMPT_REVIEW from "./template/review.txt"
 import { MCP } from "../mcp"
+import { Skill } from "../skill"

 export namespace Command {
  export const Event = {
@@ -26,7 +27,7 @@ export namespace Command {
      description: z.string().optional(),
      agent: z.string().optional(),
      model: z.string().optional(),
-      mcp: z.boolean().optional(),
+      source: z.enum(["command", "mcp", "skill"]).optional(),
      // workaround for zod not supporting async functions natively so we use getters
      // https://zod.dev/v4/changelog?id=zfunction
      template: z.promise(z.string()).or(z.string()),
@@ -94,7 +95,7 @@ export namespace Command {
    for (const [name, prompt] of Object.entries(await MCP.prompts())) {
      result[name] = {
        name,
-        mcp: true,
+        source: "mcp",
        description: prompt.description,
        get template() {
          // since a getter can't be async we need to manually return a promise here
@@ -118,6 +119,21 @@ export namespace Command {
      }
    }

+    // Add skills as invokable commands
+    for (const skill of await Skill.all()) {
+      // Skip if a command with this name already exists
+      if (result[skill.name]) continue
+      result[skill.name] = {
+        name: skill.name,
+        description: skill.description,
+        source: "skill",
+        get template() {
+          return skill.content
+        },
+        hints: [],
+      }
+    }
+
    return result
  })

@@ -1078,29 +1078,6 @@ export namespace Config {
        .optional(),
      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(),
-          chatMaxRetries: z.number().optional().describe("Number of retries for chat completions on failure"),
          disable_paste_summary: z.boolean().optional(),
          batch_tool: z.boolean().optional().describe("Enable the batch tool"),
          openTelemetry: z
@@ -2,7 +2,9 @@ import { Instance } from "../project/instance"

 export namespace Env {
  const state = Instance.state(() => {
-    return process.env as Record<string, string | undefined>
+    // Create a shallow copy to isolate environment per instance
+    // Prevents parallel tests from interfering with each other's env vars
+    return { ...process.env } as Record<string, string | undefined>
  })

  export function get(key: string) {
@@ -214,8 +214,8 @@ export namespace Ripgrep {
    input.signal?.throwIfAborted()

    const args = [await filepath(), "--files", "--glob=!.git/*"]
-    if (input.follow !== false) args.push("--follow")
-    if (input.hidden !== false) args.push("--hidden")
+    if (input.follow) args.push("--follow")
+    if (input.hidden) args.push("--hidden")
    if (input.maxDepth !== undefined) args.push(`--max-depth=${input.maxDepth}`)
    if (input.glob) {
      for (const g of input.glob) {
@@ -381,7 +381,7 @@ export namespace Ripgrep {
    follow?: boolean
  }) {
    const args = [`${await filepath()}`, "--json", "--hidden", "--glob='!.git/*'"]
-    if (input.follow !== false) args.push("--follow")
+    if (input.follow) args.push("--follow")

    if (input.glob) {
      for (const g of input.glob) {
@@ -25,7 +25,7 @@ export namespace Flag {
    OPENCODE_DISABLE_CLAUDE_CODE || truthy("OPENCODE_DISABLE_CLAUDE_CODE_SKILLS")
  export declare const OPENCODE_DISABLE_PROJECT_CONFIG: boolean
  export const OPENCODE_FAKE_VCS = process.env["OPENCODE_FAKE_VCS"]
-  export const OPENCODE_CLIENT = process.env["OPENCODE_CLIENT"] ?? "cli"
+  export declare const OPENCODE_CLIENT: string
  export const OPENCODE_SERVER_PASSWORD = process.env["OPENCODE_SERVER_PASSWORD"]
  export const OPENCODE_SERVER_USERNAME = process.env["OPENCODE_SERVER_USERNAME"]

@@ -47,6 +47,7 @@ export namespace Flag {
  export const OPENCODE_EXPERIMENTAL_PLAN_MODE = OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_PLAN_MODE")
  export const OPENCODE_EXPERIMENTAL_MARKDOWN = truthy("OPENCODE_EXPERIMENTAL_MARKDOWN")
  export const OPENCODE_MODELS_URL = process.env["OPENCODE_MODELS_URL"]
+  export const OPENCODE_MODELS_PATH = process.env["OPENCODE_MODELS_PATH"]

  function number(key: string) {
    const value = process.env[key]
@@ -77,3 +78,14 @@ Object.defineProperty(Flag, "OPENCODE_CONFIG_DIR", {
  enumerable: true,
  configurable: false,
 })
+
+// Dynamic getter for OPENCODE_CLIENT
+// This must be evaluated at access time, not module load time,
+// because some commands override the client at runtime
+Object.defineProperty(Flag, "OPENCODE_CLIENT", {
+  get() {
+    return process.env["OPENCODE_CLIENT"] ?? "cli"
+  },
+  enumerable: true,
+  configurable: false,
+})
@@ -85,7 +85,7 @@ export namespace ModelsDev {
  }

  export const Data = lazy(async () => {
-    const file = Bun.file(filepath)
+    const file = Bun.file(Flag.OPENCODE_MODELS_PATH ?? filepath)
    const result = await file.json().catch(() => {})
    if (result) return result
    // @ts-ignore
@@ -24,7 +24,7 @@ import { createVertexAnthropic } from "@ai-sdk/google-vertex/anthropic"
 import { createOpenAI } from "@ai-sdk/openai"
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible"
 import { createOpenRouter, type LanguageModelV2 } from "@openrouter/ai-sdk-provider"
-import { createOpenaiCompatible as createGitHubCopilotOpenAICompatible } from "./sdk/openai-compatible/src"
+import { createOpenaiCompatible as createGitHubCopilotOpenAICompatible } from "./sdk/copilot"
 import { createXai } from "@ai-sdk/xai"
 import { createMistral } from "@ai-sdk/mistral"
 import { createGroq } from "@ai-sdk/groq"
@@ -1023,12 +1023,9 @@ export namespace Provider {
        })
      }

-      // Special case: google-vertex-anthropic uses a subpath import
-      const bundledKey =
-        model.providerID === "google-vertex-anthropic" ? "@ai-sdk/google-vertex/anthropic" : model.api.npm
-      const bundledFn = BUNDLED_PROVIDERS[bundledKey]
+      const bundledFn = BUNDLED_PROVIDERS[model.api.npm]
      if (bundledFn) {
-        log.info("using bundled provider", { providerID: model.providerID, pkg: bundledKey })
+        log.info("using bundled provider", { providerID: model.providerID, pkg: model.api.npm })
        const loaded = bundledFn({
          name: model.providerID,
          ...options,
@@ -0,0 +1,169 @@
+import {
+  type LanguageModelV2Prompt,
+  type SharedV2ProviderMetadata,
+  UnsupportedFunctionalityError,
+} from "@ai-sdk/provider"
+import type { OpenAICompatibleChatPrompt } from "./openai-compatible-api-types"
+import { convertToBase64 } from "@ai-sdk/provider-utils"
+
+function getOpenAIMetadata(message: { providerOptions?: SharedV2ProviderMetadata }) {
+  return message?.providerOptions?.copilot ?? {}
+}
+
+export function convertToOpenAICompatibleChatMessages(prompt: LanguageModelV2Prompt): OpenAICompatibleChatPrompt {
+  const messages: OpenAICompatibleChatPrompt = []
+  for (const { role, content, ...message } of prompt) {
+    const metadata = getOpenAIMetadata({ ...message })
+    switch (role) {
+      case "system": {
+        messages.push({
+          role: "system",
+          content: [
+            {
+              type: "text",
+              text: content,
+            },
+          ],
+          ...metadata,
+        })
+        break
+      }
+
+      case "user": {
+        if (content.length === 1 && content[0].type === "text") {
+          messages.push({
+            role: "user",
+            content: content[0].text,
+            ...getOpenAIMetadata(content[0]),
+          })
+          break
+        }
+
+        messages.push({
+          role: "user",
+          content: content.map((part) => {
+            const partMetadata = getOpenAIMetadata(part)
+            switch (part.type) {
+              case "text": {
+                return { type: "text", text: part.text, ...partMetadata }
+              }
+              case "file": {
+                if (part.mediaType.startsWith("image/")) {
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType
+
+                  return {
+                    type: "image_url",
+                    image_url: {
+                      url:
+                        part.data instanceof URL
+                          ? part.data.toString()
+                          : `data:${mediaType};base64,${convertToBase64(part.data)}`,
+                    },
+                    ...partMetadata,
+                  }
+                } else {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: `file part media type ${part.mediaType}`,
+                  })
+                }
+              }
+            }
+          }),
+          ...metadata,
+        })
+
+        break
+      }
+
+      case "assistant": {
+        let text = ""
+        let reasoningText: string | undefined
+        let reasoningOpaque: string | undefined
+        const toolCalls: Array<{
+          id: string
+          type: "function"
+          function: { name: string; arguments: string }
+        }> = []
+
+        for (const part of content) {
+          const partMetadata = getOpenAIMetadata(part)
+          // Check for reasoningOpaque on any part (may be attached to text/tool-call)
+          const partOpaque = (part.providerOptions as { copilot?: { reasoningOpaque?: string } })?.copilot
+            ?.reasoningOpaque
+          if (partOpaque && !reasoningOpaque) {
+            reasoningOpaque = partOpaque
+          }
+
+          switch (part.type) {
+            case "text": {
+              text += part.text
+              break
+            }
+            case "reasoning": {
+              reasoningText = part.text
+              break
+            }
+            case "tool-call": {
+              toolCalls.push({
+                id: part.toolCallId,
+                type: "function",
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.input),
+                },
+                ...partMetadata,
+              })
+              break
+            }
+          }
+        }
+
+        messages.push({
+          role: "assistant",
+          content: text || null,
+          tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+          reasoning_text: reasoningText,
+          reasoning_opaque: reasoningOpaque,
+          ...metadata,
+        })
+
+        break
+      }
+
+      case "tool": {
+        for (const toolResponse of content) {
+          const output = toolResponse.output
+
+          let contentValue: string
+          switch (output.type) {
+            case "text":
+            case "error-text":
+              contentValue = output.value
+              break
+            case "content":
+            case "json":
+            case "error-json":
+              contentValue = JSON.stringify(output.value)
+              break
+          }
+
+          const toolResponseMetadata = getOpenAIMetadata(toolResponse)
+          messages.push({
+            role: "tool",
+            tool_call_id: toolResponse.toolCallId,
+            content: contentValue,
+            ...toolResponseMetadata,
+          })
+        }
+        break
+      }
+
+      default: {
+        const _exhaustiveCheck: never = role
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`)
+      }
+    }
+  }
+
+  return messages
+}
@@ -0,0 +1,15 @@
+export function getResponseMetadata({
+  id,
+  model,
+  created,
+}: {
+  id?: string | undefined | null
+  created?: number | undefined | null
+  model?: string | undefined | null
+}) {
+  return {
+    id: id ?? undefined,
+    modelId: model ?? undefined,
+    timestamp: created != null ? new Date(created * 1000) : undefined,
+  }
+}
@@ -0,0 +1,17 @@
+import type { LanguageModelV2FinishReason } from "@ai-sdk/provider"
+
+export function mapOpenAICompatibleFinishReason(finishReason: string | null | undefined): LanguageModelV2FinishReason {
+  switch (finishReason) {
+    case "stop":
+      return "stop"
+    case "length":
+      return "length"
+    case "content_filter":
+      return "content-filter"
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls"
+    default:
+      return "unknown"
+  }
+}
@@ -0,0 +1,64 @@
+import type { JSONValue } from "@ai-sdk/provider"
+
+export type OpenAICompatibleChatPrompt = Array<OpenAICompatibleMessage>
+
+export type OpenAICompatibleMessage =
+  | OpenAICompatibleSystemMessage
+  | OpenAICompatibleUserMessage
+  | OpenAICompatibleAssistantMessage
+  | OpenAICompatibleToolMessage
+
+// Allow for arbitrary additional properties for general purpose
+// provider-metadata-specific extensibility.
+type JsonRecord<T = never> = Record<string, JSONValue | JSONValue[] | T | T[] | undefined>
+
+export interface OpenAICompatibleSystemMessage extends JsonRecord<OpenAICompatibleSystemContentPart> {
+  role: "system"
+  content: string | Array<OpenAICompatibleSystemContentPart>
+}
+
+export interface OpenAICompatibleSystemContentPart extends JsonRecord {
+  type: "text"
+  text: string
+}
+
+export interface OpenAICompatibleUserMessage extends JsonRecord<OpenAICompatibleContentPart> {
+  role: "user"
+  content: string | Array<OpenAICompatibleContentPart>
+}
+
+export type OpenAICompatibleContentPart = OpenAICompatibleContentPartText | OpenAICompatibleContentPartImage
+
+export interface OpenAICompatibleContentPartImage extends JsonRecord {
+  type: "image_url"
+  image_url: { url: string }
+}
+
+export interface OpenAICompatibleContentPartText extends JsonRecord {
+  type: "text"
+  text: string
+}
+
+export interface OpenAICompatibleAssistantMessage extends JsonRecord<OpenAICompatibleMessageToolCall> {
+  role: "assistant"
+  content?: string | null
+  tool_calls?: Array<OpenAICompatibleMessageToolCall>
+  // Copilot-specific reasoning fields
+  reasoning_text?: string
+  reasoning_opaque?: string
+}
+
+export interface OpenAICompatibleMessageToolCall extends JsonRecord {
+  type: "function"
+  id: string
+  function: {
+    arguments: string
+    name: string
+  }
+}
+
+export interface OpenAICompatibleToolMessage extends JsonRecord {
+  role: "tool"
+  content: string
+  tool_call_id: string
+}
@@ -0,0 +1,765 @@
+import {
+  APICallError,
+  InvalidResponseDataError,
+  type LanguageModelV2,
+  type LanguageModelV2CallWarning,
+  type LanguageModelV2Content,
+  type LanguageModelV2FinishReason,
+  type LanguageModelV2StreamPart,
+  type SharedV2ProviderMetadata,
+} from "@ai-sdk/provider"
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  type FetchFunction,
+  generateId,
+  isParsableJson,
+  parseProviderOptions,
+  type ParseResult,
+  postJsonToApi,
+  type ResponseHandler,
+} from "@ai-sdk/provider-utils"
+import { z } from "zod/v4"
+import { convertToOpenAICompatibleChatMessages } from "./convert-to-openai-compatible-chat-messages"
+import { getResponseMetadata } from "./get-response-metadata"
+import { mapOpenAICompatibleFinishReason } from "./map-openai-compatible-finish-reason"
+import { type OpenAICompatibleChatModelId, openaiCompatibleProviderOptions } from "./openai-compatible-chat-options"
+import { defaultOpenAICompatibleErrorStructure, type ProviderErrorStructure } from "../openai-compatible-error"
+import type { MetadataExtractor } from "./openai-compatible-metadata-extractor"
+import { prepareTools } from "./openai-compatible-prepare-tools"
+
+export type OpenAICompatibleChatConfig = {
+  provider: string
+  headers: () => Record<string, string | undefined>
+  url: (options: { modelId: string; path: string }) => string
+  fetch?: FetchFunction
+  includeUsage?: boolean
+  errorStructure?: ProviderErrorStructure<any>
+  metadataExtractor?: MetadataExtractor
+
+  /**
+   * Whether the model supports structured outputs.
+   */
+  supportsStructuredOutputs?: boolean
+
+  /**
+   * The supported URLs for the model.
+   */
+  supportedUrls?: () => LanguageModelV2["supportedUrls"]
+}
+
+export class OpenAICompatibleChatLanguageModel implements LanguageModelV2 {
+  readonly specificationVersion = "v2"
+
+  readonly supportsStructuredOutputs: boolean
+
+  readonly modelId: OpenAICompatibleChatModelId
+  private readonly config: OpenAICompatibleChatConfig
+  private readonly failedResponseHandler: ResponseHandler<APICallError>
+  private readonly chunkSchema // type inferred via constructor
+
+  constructor(modelId: OpenAICompatibleChatModelId, config: OpenAICompatibleChatConfig) {
+    this.modelId = modelId
+    this.config = config
+
+    // initialize error handling:
+    const errorStructure = config.errorStructure ?? defaultOpenAICompatibleErrorStructure
+    this.chunkSchema = createOpenAICompatibleChatChunkSchema(errorStructure.errorSchema)
+    this.failedResponseHandler = createJsonErrorResponseHandler(errorStructure)
+
+    this.supportsStructuredOutputs = config.supportsStructuredOutputs ?? false
+  }
+
+  get provider(): string {
+    return this.config.provider
+  }
+
+  private get providerOptionsName(): string {
+    return this.config.provider.split(".")[0].trim()
+  }
+
+  get supportedUrls() {
+    return this.config.supportedUrls?.() ?? {}
+  }
+
+  private async getArgs({
+    prompt,
+    maxOutputTokens,
+    temperature,
+    topP,
+    topK,
+    frequencyPenalty,
+    presencePenalty,
+    providerOptions,
+    stopSequences,
+    responseFormat,
+    seed,
+    toolChoice,
+    tools,
+  }: Parameters<LanguageModelV2["doGenerate"]>[0]) {
+    const warnings: LanguageModelV2CallWarning[] = []
+
+    // Parse provider options
+    const compatibleOptions = Object.assign(
+      (await parseProviderOptions({
+        provider: "copilot",
+        providerOptions,
+        schema: openaiCompatibleProviderOptions,
+      })) ?? {},
+      (await parseProviderOptions({
+        provider: this.providerOptionsName,
+        providerOptions,
+        schema: openaiCompatibleProviderOptions,
+      })) ?? {},
+    )
+
+    if (topK != null) {
+      warnings.push({ type: "unsupported-setting", setting: "topK" })
+    }
+
+    if (responseFormat?.type === "json" && responseFormat.schema != null && !this.supportsStructuredOutputs) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "responseFormat",
+        details: "JSON response format schema is only supported with structuredOutputs",
+      })
+    }
+
+    const {
+      tools: openaiTools,
+      toolChoice: openaiToolChoice,
+      toolWarnings,
+    } = prepareTools({
+      tools,
+      toolChoice,
+    })
+
+    return {
+      args: {
+        // model id:
+        model: this.modelId,
+
+        // model specific settings:
+        user: compatibleOptions.user,
+
+        // standardized settings:
+        max_tokens: maxOutputTokens,
+        temperature,
+        top_p: topP,
+        frequency_penalty: frequencyPenalty,
+        presence_penalty: presencePenalty,
+        response_format:
+          responseFormat?.type === "json"
+            ? this.supportsStructuredOutputs === true && responseFormat.schema != null
+              ? {
+                  type: "json_schema",
+                  json_schema: {
+                    schema: responseFormat.schema,
+                    name: responseFormat.name ?? "response",
+                    description: responseFormat.description,
+                  },
+                }
+              : { type: "json_object" }
+            : undefined,
+
+        stop: stopSequences,
+        seed,
+        ...Object.fromEntries(
+          Object.entries(providerOptions?.[this.providerOptionsName] ?? {}).filter(
+            ([key]) => !Object.keys(openaiCompatibleProviderOptions.shape).includes(key),
+          ),
+        ),
+
+        reasoning_effort: compatibleOptions.reasoningEffort,
+        verbosity: compatibleOptions.textVerbosity,
+
+        // messages:
+        messages: convertToOpenAICompatibleChatMessages(prompt),
+
+        // tools:
+        tools: openaiTools,
+        tool_choice: openaiToolChoice,
+
+        // thinking_budget
+        thinking_budget: compatibleOptions.thinking_budget,
+      },
+      warnings: [...warnings, ...toolWarnings],
+    }
+  }
+
+  async doGenerate(
+    options: Parameters<LanguageModelV2["doGenerate"]>[0],
+  ): Promise<Awaited<ReturnType<LanguageModelV2["doGenerate"]>>> {
+    const { args, warnings } = await this.getArgs({ ...options })
+
+    const body = JSON.stringify(args)
+
+    const {
+      responseHeaders,
+      value: responseBody,
+      rawValue: rawResponse,
+    } = await postJsonToApi({
+      url: this.config.url({
+        path: "/chat/completions",
+        modelId: this.modelId,
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: args,
+      failedResponseHandler: this.failedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(OpenAICompatibleChatResponseSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    })
+
+    const choice = responseBody.choices[0]
+    const content: Array<LanguageModelV2Content> = []
+
+    // text content:
+    const text = choice.message.content
+    if (text != null && text.length > 0) {
+      content.push({ type: "text", text })
+    }
+
+    // reasoning content (Copilot uses reasoning_text):
+    const reasoning = choice.message.reasoning_text
+    if (reasoning != null && reasoning.length > 0) {
+      content.push({
+        type: "reasoning",
+        text: reasoning,
+        // Include reasoning_opaque for Copilot multi-turn reasoning
+        providerMetadata: choice.message.reasoning_opaque
+          ? { copilot: { reasoningOpaque: choice.message.reasoning_opaque } }
+          : undefined,
+      })
+    }
+
+    // tool calls:
+    if (choice.message.tool_calls != null) {
+      for (const toolCall of choice.message.tool_calls) {
+        content.push({
+          type: "tool-call",
+          toolCallId: toolCall.id ?? generateId(),
+          toolName: toolCall.function.name,
+          input: toolCall.function.arguments!,
+        })
+      }
+    }
+
+    // provider metadata:
+    const providerMetadata: SharedV2ProviderMetadata = {
+      [this.providerOptionsName]: {},
+      ...(await this.config.metadataExtractor?.extractMetadata?.({
+        parsedBody: rawResponse,
+      })),
+    }
+    const completionTokenDetails = responseBody.usage?.completion_tokens_details
+    if (completionTokenDetails?.accepted_prediction_tokens != null) {
+      providerMetadata[this.providerOptionsName].acceptedPredictionTokens =
+        completionTokenDetails?.accepted_prediction_tokens
+    }
+    if (completionTokenDetails?.rejected_prediction_tokens != null) {
+      providerMetadata[this.providerOptionsName].rejectedPredictionTokens =
+        completionTokenDetails?.rejected_prediction_tokens
+    }
+
+    return {
+      content,
+      finishReason: mapOpenAICompatibleFinishReason(choice.finish_reason),
+      usage: {
+        inputTokens: responseBody.usage?.prompt_tokens ?? undefined,
+        outputTokens: responseBody.usage?.completion_tokens ?? undefined,
+        totalTokens: responseBody.usage?.total_tokens ?? undefined,
+        reasoningTokens: responseBody.usage?.completion_tokens_details?.reasoning_tokens ?? undefined,
+        cachedInputTokens: responseBody.usage?.prompt_tokens_details?.cached_tokens ?? undefined,
+      },
+      providerMetadata,
+      request: { body },
+      response: {
+        ...getResponseMetadata(responseBody),
+        headers: responseHeaders,
+        body: rawResponse,
+      },
+      warnings,
+    }
+  }
+
+  async doStream(
+    options: Parameters<LanguageModelV2["doStream"]>[0],
+  ): Promise<Awaited<ReturnType<LanguageModelV2["doStream"]>>> {
+    const { args, warnings } = await this.getArgs({ ...options })
+
+    const body = {
+      ...args,
+      stream: true,
+
+      // only include stream_options when in strict compatibility mode:
+      stream_options: this.config.includeUsage ? { include_usage: true } : undefined,
+    }
+
+    const metadataExtractor = this.config.metadataExtractor?.createStreamExtractor()
+
+    const { responseHeaders, value: response } = await postJsonToApi({
+      url: this.config.url({
+        path: "/chat/completions",
+        modelId: this.modelId,
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: this.failedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler(this.chunkSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    })
+
+    const toolCalls: Array<{
+      id: string
+      type: "function"
+      function: {
+        name: string
+        arguments: string
+      }
+      hasFinished: boolean
+    }> = []
+
+    let finishReason: LanguageModelV2FinishReason = "unknown"
+    const usage: {
+      completionTokens: number | undefined
+      completionTokensDetails: {
+        reasoningTokens: number | undefined
+        acceptedPredictionTokens: number | undefined
+        rejectedPredictionTokens: number | undefined
+      }
+      promptTokens: number | undefined
+      promptTokensDetails: {
+        cachedTokens: number | undefined
+      }
+      totalTokens: number | undefined
+    } = {
+      completionTokens: undefined,
+      completionTokensDetails: {
+        reasoningTokens: undefined,
+        acceptedPredictionTokens: undefined,
+        rejectedPredictionTokens: undefined,
+      },
+      promptTokens: undefined,
+      promptTokensDetails: {
+        cachedTokens: undefined,
+      },
+      totalTokens: undefined,
+    }
+    let isFirstChunk = true
+    const providerOptionsName = this.providerOptionsName
+    let isActiveReasoning = false
+    let isActiveText = false
+    let reasoningOpaque: string | undefined
+
+    return {
+      stream: response.pipeThrough(
+        new TransformStream<ParseResult<z.infer<typeof this.chunkSchema>>, LanguageModelV2StreamPart>({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings })
+          },
+
+          // TODO we lost type safety on Chunk, most likely due to the error schema. MUST FIX
+          transform(chunk, controller) {
+            // Emit raw chunk if requested (before anything else)
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: "raw", rawValue: chunk.rawValue })
+            }
+
+            // handle failed chunk parsing / validation:
+            if (!chunk.success) {
+              finishReason = "error"
+              controller.enqueue({ type: "error", error: chunk.error })
+              return
+            }
+            const value = chunk.value
+
+            metadataExtractor?.processChunk(chunk.rawValue)
+
+            // handle error chunks:
+            if ("error" in value) {
+              finishReason = "error"
+              controller.enqueue({ type: "error", error: value.error.message })
+              return
+            }
+
+            if (isFirstChunk) {
+              isFirstChunk = false
+
+              controller.enqueue({
+                type: "response-metadata",
+                ...getResponseMetadata(value),
+              })
+            }
+
+            if (value.usage != null) {
+              const {
+                prompt_tokens,
+                completion_tokens,
+                total_tokens,
+                prompt_tokens_details,
+                completion_tokens_details,
+              } = value.usage
+
+              usage.promptTokens = prompt_tokens ?? undefined
+              usage.completionTokens = completion_tokens ?? undefined
+              usage.totalTokens = total_tokens ?? undefined
+              if (completion_tokens_details?.reasoning_tokens != null) {
+                usage.completionTokensDetails.reasoningTokens = completion_tokens_details?.reasoning_tokens
+              }
+              if (completion_tokens_details?.accepted_prediction_tokens != null) {
+                usage.completionTokensDetails.acceptedPredictionTokens =
+                  completion_tokens_details?.accepted_prediction_tokens
+              }
+              if (completion_tokens_details?.rejected_prediction_tokens != null) {
+                usage.completionTokensDetails.rejectedPredictionTokens =
+                  completion_tokens_details?.rejected_prediction_tokens
+              }
+              if (prompt_tokens_details?.cached_tokens != null) {
+                usage.promptTokensDetails.cachedTokens = prompt_tokens_details?.cached_tokens
+              }
+            }
+
+            const choice = value.choices[0]
+
+            if (choice?.finish_reason != null) {
+              finishReason = mapOpenAICompatibleFinishReason(choice.finish_reason)
+            }
+
+            if (choice?.delta == null) {
+              return
+            }
+
+            const delta = choice.delta
+
+            // Capture reasoning_opaque for Copilot multi-turn reasoning
+            if (delta.reasoning_opaque) {
+              if (reasoningOpaque != null) {
+                throw new InvalidResponseDataError({
+                  data: delta,
+                  message:
+                    "Multiple reasoning_opaque values received in a single response. Only one thinking part per response is supported.",
+                })
+              }
+              reasoningOpaque = delta.reasoning_opaque
+            }
+
+            // enqueue reasoning before text deltas (Copilot uses reasoning_text):
+            const reasoningContent = delta.reasoning_text
+            if (reasoningContent) {
+              if (!isActiveReasoning) {
+                controller.enqueue({
+                  type: "reasoning-start",
+                  id: "reasoning-0",
+                })
+                isActiveReasoning = true
+              }
+
+              controller.enqueue({
+                type: "reasoning-delta",
+                id: "reasoning-0",
+                delta: reasoningContent,
+              })
+            }
+
+            if (delta.content) {
+              // If reasoning was active and we're starting text, end reasoning first
+              // This handles the case where reasoning_opaque and content come in the same chunk
+              if (isActiveReasoning && !isActiveText) {
+                controller.enqueue({
+                  type: "reasoning-end",
+                  id: "reasoning-0",
+                  providerMetadata: reasoningOpaque ? { copilot: { reasoningOpaque } } : undefined,
+                })
+                isActiveReasoning = false
+              }
+
+              if (!isActiveText) {
+                controller.enqueue({ type: "text-start", id: "txt-0" })
+                isActiveText = true
+              }
+
+              controller.enqueue({
+                type: "text-delta",
+                id: "txt-0",
+                delta: delta.content,
+              })
+            }
+
+            if (delta.tool_calls != null) {
+              // If reasoning was active and we're starting tool calls, end reasoning first
+              // This handles the case where reasoning goes directly to tool calls with no content
+              if (isActiveReasoning) {
+                controller.enqueue({
+                  type: "reasoning-end",
+                  id: "reasoning-0",
+                  providerMetadata: reasoningOpaque ? { copilot: { reasoningOpaque } } : undefined,
+                })
+                isActiveReasoning = false
+              }
+              for (const toolCallDelta of delta.tool_calls) {
+                const index = toolCallDelta.index
+
+                if (toolCalls[index] == null) {
+                  if (toolCallDelta.id == null) {
+                    throw new InvalidResponseDataError({
+                      data: toolCallDelta,
+                      message: `Expected 'id' to be a string.`,
+                    })
+                  }
+
+                  if (toolCallDelta.function?.name == null) {
+                    throw new InvalidResponseDataError({
+                      data: toolCallDelta,
+                      message: `Expected 'function.name' to be a string.`,
+                    })
+                  }
+
+                  controller.enqueue({
+                    type: "tool-input-start",
+                    id: toolCallDelta.id,
+                    toolName: toolCallDelta.function.name,
+                  })
+
+                  toolCalls[index] = {
+                    id: toolCallDelta.id,
+                    type: "function",
+                    function: {
+                      name: toolCallDelta.function.name,
+                      arguments: toolCallDelta.function.arguments ?? "",
+                    },
+                    hasFinished: false,
+                  }
+
+                  const toolCall = toolCalls[index]
+
+                  if (toolCall.function?.name != null && toolCall.function?.arguments != null) {
+                    // send delta if the argument text has already started:
+                    if (toolCall.function.arguments.length > 0) {
+                      controller.enqueue({
+                        type: "tool-input-delta",
+                        id: toolCall.id,
+                        delta: toolCall.function.arguments,
+                      })
+                    }
+
+                    // check if tool call is complete
+                    // (some providers send the full tool call in one chunk):
+                    if (isParsableJson(toolCall.function.arguments)) {
+                      controller.enqueue({
+                        type: "tool-input-end",
+                        id: toolCall.id,
+                      })
+
+                      controller.enqueue({
+                        type: "tool-call",
+                        toolCallId: toolCall.id ?? generateId(),
+                        toolName: toolCall.function.name,
+                        input: toolCall.function.arguments,
+                      })
+                      toolCall.hasFinished = true
+                    }
+                  }
+
+                  continue
+                }
+
+                // existing tool call, merge if not finished
+                const toolCall = toolCalls[index]
+
+                if (toolCall.hasFinished) {
+                  continue
+                }
+
+                if (toolCallDelta.function?.arguments != null) {
+                  toolCall.function!.arguments += toolCallDelta.function?.arguments ?? ""
+                }
+
+                // send delta
+                controller.enqueue({
+                  type: "tool-input-delta",
+                  id: toolCall.id,
+                  delta: toolCallDelta.function.arguments ?? "",
+                })
+
+                // check if tool call is complete
+                if (
+                  toolCall.function?.name != null &&
+                  toolCall.function?.arguments != null &&
+                  isParsableJson(toolCall.function.arguments)
+                ) {
+                  controller.enqueue({
+                    type: "tool-input-end",
+                    id: toolCall.id,
+                  })
+
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallId: toolCall.id ?? generateId(),
+                    toolName: toolCall.function.name,
+                    input: toolCall.function.arguments,
+                  })
+                  toolCall.hasFinished = true
+                }
+              }
+            }
+          },
+
+          flush(controller) {
+            if (isActiveReasoning) {
+              controller.enqueue({
+                type: "reasoning-end",
+                id: "reasoning-0",
+                // Include reasoning_opaque for Copilot multi-turn reasoning
+                providerMetadata: reasoningOpaque ? { copilot: { reasoningOpaque } } : undefined,
+              })
+            }
+
+            if (isActiveText) {
+              controller.enqueue({ type: "text-end", id: "txt-0" })
+            }
+
+            // go through all tool calls and send the ones that are not finished
+            for (const toolCall of toolCalls.filter((toolCall) => !toolCall.hasFinished)) {
+              controller.enqueue({
+                type: "tool-input-end",
+                id: toolCall.id,
+              })
+
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: toolCall.id ?? generateId(),
+                toolName: toolCall.function.name,
+                input: toolCall.function.arguments,
+              })
+            }
+
+            const providerMetadata: SharedV2ProviderMetadata = {
+              [providerOptionsName]: {},
+              // Include reasoning_opaque for Copilot multi-turn reasoning
+              ...(reasoningOpaque ? { copilot: { reasoningOpaque } } : {}),
+              ...metadataExtractor?.buildMetadata(),
+            }
+            if (usage.completionTokensDetails.acceptedPredictionTokens != null) {
+              providerMetadata[providerOptionsName].acceptedPredictionTokens =
+                usage.completionTokensDetails.acceptedPredictionTokens
+            }
+            if (usage.completionTokensDetails.rejectedPredictionTokens != null) {
+              providerMetadata[providerOptionsName].rejectedPredictionTokens =
+                usage.completionTokensDetails.rejectedPredictionTokens
+            }
+
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              usage: {
+                inputTokens: usage.promptTokens ?? undefined,
+                outputTokens: usage.completionTokens ?? undefined,
+                totalTokens: usage.totalTokens ?? undefined,
+                reasoningTokens: usage.completionTokensDetails.reasoningTokens ?? undefined,
+                cachedInputTokens: usage.promptTokensDetails.cachedTokens ?? undefined,
+              },
+              providerMetadata,
+            })
+          },
+        }),
+      ),
+      request: { body },
+      response: { headers: responseHeaders },
+    }
+  }
+}
+
+const openaiCompatibleTokenUsageSchema = z
+  .object({
+    prompt_tokens: z.number().nullish(),
+    completion_tokens: z.number().nullish(),
+    total_tokens: z.number().nullish(),
+    prompt_tokens_details: z
+      .object({
+        cached_tokens: z.number().nullish(),
+      })
+      .nullish(),
+    completion_tokens_details: z
+      .object({
+        reasoning_tokens: z.number().nullish(),
+        accepted_prediction_tokens: z.number().nullish(),
+        rejected_prediction_tokens: z.number().nullish(),
+      })
+      .nullish(),
+  })
+  .nullish()
+
+// limited version of the schema, focussed on what is needed for the implementation
+// this approach limits breakages when the API changes and increases efficiency
+const OpenAICompatibleChatResponseSchema = z.object({
+  id: z.string().nullish(),
+  created: z.number().nullish(),
+  model: z.string().nullish(),
+  choices: z.array(
+    z.object({
+      message: z.object({
+        role: z.literal("assistant").nullish(),
+        content: z.string().nullish(),
+        // Copilot-specific reasoning fields
+        reasoning_text: z.string().nullish(),
+        reasoning_opaque: z.string().nullish(),
+        tool_calls: z
+          .array(
+            z.object({
+              id: z.string().nullish(),
+              function: z.object({
+                name: z.string(),
+                arguments: z.string(),
+              }),
+            }),
+          )
+          .nullish(),
+      }),
+      finish_reason: z.string().nullish(),
+    }),
+  ),
+  usage: openaiCompatibleTokenUsageSchema,
+})
+
+// limited version of the schema, focussed on what is needed for the implementation
+// this approach limits breakages when the API changes and increases efficiency
+const createOpenAICompatibleChatChunkSchema = <ERROR_SCHEMA extends z.core.$ZodType>(errorSchema: ERROR_SCHEMA) =>
+  z.union([
+    z.object({
+      id: z.string().nullish(),
+      created: z.number().nullish(),
+      model: z.string().nullish(),
+      choices: z.array(
+        z.object({
+          delta: z
+            .object({
+              role: z.enum(["assistant"]).nullish(),
+              content: z.string().nullish(),
+              // Copilot-specific reasoning fields
+              reasoning_text: z.string().nullish(),
+              reasoning_opaque: z.string().nullish(),
+              tool_calls: z
+                .array(
+                  z.object({
+                    index: z.number(),
+                    id: z.string().nullish(),
+                    function: z.object({
+                      name: z.string().nullish(),
+                      arguments: z.string().nullish(),
+                    }),
+                  }),
+                )
+                .nullish(),
+            })
+            .nullish(),
+          finish_reason: z.string().nullish(),
+        }),
+      ),
+      usage: openaiCompatibleTokenUsageSchema,
+    }),
+    errorSchema,
+  ])
@@ -0,0 +1,28 @@
+import { z } from "zod/v4"
+
+export type OpenAICompatibleChatModelId = string
+
+export const openaiCompatibleProviderOptions = z.object({
+  /**
+   * A unique identifier representing your end-user, which can help the provider to
+   * monitor and detect abuse.
+   */
+  user: z.string().optional(),
+
+  /**
+   * Reasoning effort for reasoning models. Defaults to `medium`.
+   */
+  reasoningEffort: z.string().optional(),
+
+  /**
+   * Controls the verbosity of the generated text. Defaults to `medium`.
+   */
+  textVerbosity: z.string().optional(),
+
+  /**
+   * Copilot thinking_budget used for Anthropic models.
+   */
+  thinking_budget: z.number().optional(),
+})
+
+export type OpenAICompatibleProviderOptions = z.infer<typeof openaiCompatibleProviderOptions>
@@ -0,0 +1,44 @@
+import type { SharedV2ProviderMetadata } from "@ai-sdk/provider"
+
+/**
+Extracts provider-specific metadata from API responses.
+Used to standardize metadata handling across different LLM providers while allowing
+provider-specific metadata to be captured.
+*/
+export type MetadataExtractor = {
+  /**
+   * Extracts provider metadata from a complete, non-streaming response.
+   *
+   * @param parsedBody - The parsed response JSON body from the provider's API.
+   *
+   * @returns Provider-specific metadata or undefined if no metadata is available.
+   *          The metadata should be under a key indicating the provider id.
+   */
+  extractMetadata: ({ parsedBody }: { parsedBody: unknown }) => Promise<SharedV2ProviderMetadata | undefined>
+
+  /**
+   * Creates an extractor for handling streaming responses. The returned object provides
+   * methods to process individual chunks and build the final metadata from the accumulated
+   * stream data.
+   *
+   * @returns An object with methods to process chunks and build metadata from a stream
+   */
+  createStreamExtractor: () => {
+    /**
+     * Process an individual chunk from the stream. Called for each chunk in the response stream
+     * to accumulate metadata throughout the streaming process.
+     *
+     * @param parsedChunk - The parsed JSON response chunk from the provider's API
+     */
+    processChunk(parsedChunk: unknown): void
+
+    /**
+     * Builds the metadata object after all chunks have been processed.
+     * Called at the end of the stream to generate the complete provider metadata.
+     *
+     * @returns Provider-specific metadata or undefined if no metadata is available.
+     *          The metadata should be under a key indicating the provider id.
+     */
+    buildMetadata(): SharedV2ProviderMetadata | undefined
+  }
+}
@@ -0,0 +1,87 @@
+import {
+  type LanguageModelV2CallOptions,
+  type LanguageModelV2CallWarning,
+  UnsupportedFunctionalityError,
+} from "@ai-sdk/provider"
+
+export function prepareTools({
+  tools,
+  toolChoice,
+}: {
+  tools: LanguageModelV2CallOptions["tools"]
+  toolChoice?: LanguageModelV2CallOptions["toolChoice"]
+}): {
+  tools:
+    | undefined
+    | Array<{
+        type: "function"
+        function: {
+          name: string
+          description: string | undefined
+          parameters: unknown
+        }
+      }>
+  toolChoice: { type: "function"; function: { name: string } } | "auto" | "none" | "required" | undefined
+  toolWarnings: LanguageModelV2CallWarning[]
+} {
+  // when the tools array is empty, change it to undefined to prevent errors:
+  tools = tools?.length ? tools : undefined
+
+  const toolWarnings: LanguageModelV2CallWarning[] = []
+
+  if (tools == null) {
+    return { tools: undefined, toolChoice: undefined, toolWarnings }
+  }
+
+  const openaiCompatTools: Array<{
+    type: "function"
+    function: {
+      name: string
+      description: string | undefined
+      parameters: unknown
+    }
+  }> = []
+
+  for (const tool of tools) {
+    if (tool.type === "provider-defined") {
+      toolWarnings.push({ type: "unsupported-tool", tool })
+    } else {
+      openaiCompatTools.push({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema,
+        },
+      })
+    }
+  }
+
+  if (toolChoice == null) {
+    return { tools: openaiCompatTools, toolChoice: undefined, toolWarnings }
+  }
+
+  const type = toolChoice.type
+
+  switch (type) {
+    case "auto":
+    case "none":
+    case "required":
+      return { tools: openaiCompatTools, toolChoice: type, toolWarnings }
+    case "tool":
+      return {
+        tools: openaiCompatTools,
+        toolChoice: {
+          type: "function",
+          function: { name: toolChoice.toolName },
+        },
+        toolWarnings,
+      }
+    default: {
+      const _exhaustiveCheck: never = type
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`,
+      })
+    }
+  }
+}
@@ -1,6 +1,6 @@
 import type { LanguageModelV2 } from "@ai-sdk/provider"
-import { OpenAICompatibleChatLanguageModel } from "@ai-sdk/openai-compatible"
 import { type FetchFunction, withoutTrailingSlash, withUserAgentSuffix } from "@ai-sdk/provider-utils"
+import { OpenAICompatibleChatLanguageModel } from "./chat/openai-compatible-chat-language-model"
 import { OpenAIResponsesLanguageModel } from "./responses/openai-responses-language-model"

 // Import the version or define it
@@ -0,0 +1,2 @@
+export { createOpenaiCompatible, openaiCompatible } from "./copilot-provider"
+export type { OpenaiCompatibleProvider, OpenaiCompatibleProviderSettings } from "./copilot-provider"
@@ -0,0 +1,27 @@
+import { z, type ZodType } from "zod/v4"
+
+export const openaiCompatibleErrorDataSchema = z.object({
+  error: z.object({
+    message: z.string(),
+
+    // The additional information below is handled loosely to support
+    // OpenAI-compatible providers that have slightly different error
+    // responses:
+    type: z.string().nullish(),
+    param: z.any().nullish(),
+    code: z.union([z.string(), z.number()]).nullish(),
+  }),
+})
+
+export type OpenAICompatibleErrorData = z.infer<typeof openaiCompatibleErrorDataSchema>
+
+export type ProviderErrorStructure<T> = {
+  errorSchema: ZodType<T>
+  errorToMessage: (error: T) => string
+  isRetryable?: (response: Response, error?: T) => boolean
+}
+
+export const defaultOpenAICompatibleErrorStructure: ProviderErrorStructure<OpenAICompatibleErrorData> = {
+  errorSchema: openaiCompatibleErrorDataSchema,
+  errorToMessage: (data) => data.error.message,
+}
@@ -183,7 +183,7 @@ export async function convertToOpenAIResponsesInput({

            case "reasoning": {
              const providerOptions = await parseProviderOptions({
-                provider: "openai",
+                provider: "copilot",
                providerOptions: part.providerOptions,
                schema: openaiResponsesReasoningProviderOptionsSchema,
              })
@@ -194,7 +194,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV2 {
    }

    const openaiOptions = await parseProviderOptions({
-      provider: "openai",
+      provider: "copilot",
      providerOptions,
      schema: openaiResponsesProviderOptionsSchema,
    })
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
opencode	597ae57bb1	release: v1.1.48 nix-hashes / nix-hashes (push) Has been cancelled Details	2026-01-31 13:48:22 +00:00
Adam GitHub adamelmore	a552652fcc	Revert "feat: Transitions, spacing, scroll fade, prompt area update (#11168 )" (#11461 ) Co-authored-by: adamelmore <2363879+adamdottv@users.noreply.github.com>	2026-01-31 07:18:51 -06:00
FilipandGitHub	511c7abaca	test(app): session actions (#11386 )	2026-01-31 06:42:47 -06:00
Aiden ClineandGitHub	f834915d3f	test: fix flaky test (#11427 )	2026-01-31 01:07:22 -06:00
opencode-agent[bot]	65c21f8fe4	chore: generate	2026-01-31 06:59:18 +00:00
Dax Raad	6b972329fd	sync	2026-01-31 01:58:20 -05:00
Dax Raad	6ecd011e51	tui: allow specifying custom models file path via OPENCODE_MODELS_PATH Users can now configure their own models configuration file by setting the OPENCODE_MODELS_PATH environment variable, providing more flexibility for testing and configuration.	2026-01-31 01:53:23 -05:00
Dax Raad	8e5db3083c	ci: copy models fixture for e2e test consistency	2026-01-31 01:44:19 -05:00
Dax Raad	d005e70f50	core: ensure models configuration is not empty before loading	2026-01-31 00:57:17 -05:00
opencode-agent[bot]	46122d9a0a	chore: generate	2026-01-31 05:42:31 +00:00
DaxandGitHub	81ac41e089	feat: make skills invokable as slash commands in the TUI (#11390 )	2026-01-31 00:41:55 -05:00
Aiden ClineandGitHub	c0e71c4261	fix: don't --follow by default for grep and other things using ripgrep (#11415 )	2026-01-30 23:38:43 -06:00
Dax Raad	507f13a30c	ci: run tests automatically when code is pushed to dev branch	2026-01-31 00:37:55 -05:00
Dax Raad	90f39bf672	core: prevent parallel test runs from contaminating environment variables	2026-01-31 00:37:21 -05:00
Aiden ClineandGitHub	95bf01a757	fix: ensure the mistral ordering fixes also apply to devstral (#11412 )	2026-01-30 23:16:07 -06:00
Dax Raad	b6bbb95704	ci: remove pull-request write permissions from beta workflow	2026-01-30 23:39:01 -05:00
Dax Raad	d713026a6a	ci: remove workflow restrictions to allow all PR triggers for broader CI coverage	2026-01-30 23:36:54 -05:00
Dax Raad	73c4d3644c	ci: allow manual beta workflow trigger so users can release on demand instead of waiting for hourly schedule	2026-01-30 23:36:05 -05:00
Dax Raad	571f5b31c9	ci: schedule beta workflow hourly to automate sync runs	2026-01-30 23:33:33 -05:00
opencode-agent[bot]	644f0d4e92	chore: generate	2026-01-31 02:35:22 +00:00
Steffen Deusch GitHub Claude Opus 4.5 Aiden Cline Aiden Cline	d9f18e4006	feat(opencode): add copilot specific provider to properly handle copilot reasoning tokens (#8900 ) Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com> Co-authored-by: Aiden Cline <63023139+rekram1-node@users.noreply.github.com> Co-authored-by: Aiden Cline <aidenpcline@gmail.com>	2026-01-30 19:53:22 -06:00
Dax Raad	2f4374c829	Merge remote dev and apply revert	2026-01-30 20:38:10 -05:00
Dax Raad	3542f3e406	Revert "feat: make skills invokable as slash commands in the TUI" This reverts commit `85126556b8`.	2026-01-30 20:37:41 -05:00
Benjamin BartelsandGitHub	f1caf84064	feat(build): respect OPENCODE_MODELS_URL env var (#11384 )	2026-01-30 19:37:37 -06:00
Dax Raad	85126556b8	feat: make skills invokable as slash commands in the TUI - Add Skill.content() method to load skill template content from SKILL.md files - Modify Command.list() to include skills as invokable commands - Add 'skill' boolean property to Command.Info schema - Update autocomplete to show skills with (Skill) label in slash commands - Regenerate SDK to include skill property in Command type	2026-01-30 20:36:48 -05:00
opencode-agent[bot]	252b2c450d	chore: generate	2026-01-31 01:32:46 +00:00
Cesar GarciaandGitHub	0c32afbc35	fix(provider): use snake_case for thinking param with OpenAI-compatible APIs (#10109 )	2026-01-31 01:32:02 +00:00
Aiden Cline GitHubopencode-agent[bot] <opencode-agent[bot]@users.noreply.github.com>	aef0e58ad7	chore(deps): bump ai-sdk packages (#11383 ) Co-authored-by: opencode-agent[bot] <opencode-agent[bot]@users.noreply.github.com>	2026-01-30 17:58:02 -06:00
Aiden ClineandGitHub	1a6461e8bc	fix: ensure ask question tool isn't included when using acp (#11379 )	2026-01-30 17:32:51 -06:00
Idris GadiandGitHub	e834a2e6c9	docs: update agents options section to include color and top_p options (#11355 )	2026-01-30 17:05:01 -06:00
Aiden ClineandGitHub	9d3f32065b	test: add llm.test.ts (#11375 )	2026-01-30 17:04:32 -06:00
Patrick SchielandGitHub	e7ff7143b6	fix: handle redirected_statement treesitter node in bash permissions (#6737 )	2026-01-30 16:11:45 -06:00
Michael YochpazandGitHub	2c36cbb87c	refactor(provider): remove google-vertex-anthropic special case in ge… (#10743 )	2026-01-30 15:57:36 -06:00
Filipandopencode	77fa8ddc88	refactor(app): refactored tests + added project tests (#11349 )	2026-01-30 21:06:48 +00:00
Ryan Vogelandopencode	4a56491e42	fix(provider): exclude chat models from textVerbosity setting (#11363 )	2026-01-30 21:06:48 +00:00
Dax Raadandopencode	f51bd28ed8	ci: increase ARM runner to 8 vCPUs for faster Tauri builds	2026-01-30 21:06:48 +00:00
opencode	6cd2a68851	release: v1.1.47 nix-hashes / nix-hashes (push) Has been cancelled Details	2026-01-30 21:06:38 +00:00
Dax Raad	9259d2bf52	fix(github): add owner parameter to app token for org-wide repo access	2026-01-30 15:22:02 -05:00
Dax Raad	e94ae550ea	commit	2026-01-30 15:17:55 -05:00
opencode	e9ef94dc4d	release: v1.1.46 nix-hashes / nix-hashes (push) Has been cancelled Details	2026-01-30 19:19:34 +00:00
opencode-agent[bot]	5495fdde9d	chore: generate	2026-01-30 18:16:49 +00:00
Idris GadiandGitHub	7d0777a7ff	chore(tui): remove unused experimental keys (#11195 )	2026-01-30 12:16:01 -06:00
FilipandGitHub	f48e2e56c9	test(app): change language test (#11295 )	2026-01-30 18:04:02 +00:00
opencode-agent[bot]	fe66ca163c	chore: generate	2026-01-30 17:58:31 +00:00
Aaron Iker GitHub Github Action Copilot aaroniker	20619a6a26	feat: Transitions, spacing, scroll fade, prompt area update (#11168 ) Co-authored-by: Github Action <action@github.com> Co-authored-by: Copilot <198982749+Copilot@users.noreply.github.com> Co-authored-by: aaroniker <4730431+aaroniker@users.noreply.github.com>	2026-01-30 17:57:49 +00:00
Dax Raad	1bbe84ed8d	ci	2026-01-30 12:55:58 -05:00
Aiden ClineandGitHub	21edc00f11	ci: update pr template (#11341 )	2026-01-30 12:45:42 -05:00
opencode-agent[bot]	0b91e9087d	chore: generate	2026-01-30 17:20:20 +00:00
FrankandGitHub	7cb84f13d3	wip: zen (#11343 )	2026-01-30 12:19:36 -05:00
Dax Raad	1aade4b308	ci	2026-01-30 10:39:59 -05:00
Dax Raad	2e005de670	ci	2026-01-30 10:38:10 -05:00
Dax Raad	e80a99e7bd	ci	2026-01-30 10:36:01 -05:00
Dax Raad	9a0132e750	ci	2026-01-30 10:35:39 -05:00
Dax Raad	7fb22ab681	ci	2026-01-30 10:28:54 -05:00
Dax Raad	e4d3b961cd	ci	2026-01-30 10:28:12 -05:00
Dax Raad	9cf3e651ca	ci	2026-01-30 10:26:55 -05:00
Dax Raad	e0b60d9f34	ci	2026-01-30 10:25:10 -05:00
Dax Raad	3f57f4913d	ci	2026-01-30 10:23:19 -05:00
Dax Raad	b9e9c8c763	ci	2026-01-30 10:21:47 -05:00
Dax Raad	0d53f34c43	ci	2026-01-30 10:20:49 -05:00
Dax Raad	0a0b54aa4b	ci	2026-01-30 10:15:45 -05:00
Dax Raad	4a4fc48ee8	ci	2026-01-30 10:12:29 -05:00
Dax Raad	5e823fd208	ci	2026-01-30 10:11:05 -05:00
Dax Raad	ad5d495b2c	ci	2026-01-30 10:09:27 -05:00
Dax Raad	abb87eac8f	ci	2026-01-30 10:08:28 -05:00
Dax Raad	a530c1b5b6	ci	2026-01-30 10:02:05 -05:00
Dax Raad	601744eacd	sync	2026-01-30 09:58:54 -05:00
Dax Raad	97a428cf69	ci	2026-01-30 09:57:17 -05:00
Dax Raad	698cf6dfc1	ci	2026-01-30 09:56:21 -05:00
Dax Raad	9493316502	ci	2026-01-30 09:56:06 -05:00
Dax Raad	08fa7f7188	ci	2026-01-30 09:36:57 -05:00
Aiden Cline Dax Raadopencode-agent[bot] <opencode-agent[bot]@users.noreply.github.com>	11d486707c	fix: rm ai sdk middleware that was preventing <think> blocks from being sent back as assistant message content (#11270 ) Co-authored-by: opencode-agent[bot] <opencode-agent[bot]@users.noreply.github.com>	2026-01-30 09:36:57 -05:00
opencode	71e0ba271f	release: v1.1.45 nix-hashes / nix-hashes (push) Has been cancelled Details	2026-01-30 14:32:22 +00:00
Dax Raad	d58661d4fb	ci	2026-01-30 01:15:24 -05:00
Dax Raad	09f4ef8996	ci	2026-01-30 00:56:45 -05:00
Dax Raad	1794319a4c	ci	2026-01-30 00:48:08 -05:00
Dax Raad	8f53794017	ci	2026-01-30 00:46:12 -05:00
Dax Raad	48d6d72e25	ci	2026-01-30 00:44:58 -05:00
Dax Raad	5bef8e316a	ci	2026-01-30 00:43:36 -05:00
Dax Raad	08f11f4da6	ci	2026-01-30 00:39:49 -05:00
Dax Raad	9e0747c9b4	ci	2026-01-30 00:39:23 -05:00
Dax Raad	66ec378680	ci	2026-01-30 00:27:51 -05:00
Dax Raad	015eda36ce	ci	2026-01-30 00:25:52 -05:00
Dax Raad	e666ddb630	ci	2026-01-30 00:23:52 -05:00
Dax Raad	da7f45bd4c	ci	2026-01-30 00:21:30 -05:00
Dax Raad	273e7b8379	ci	2026-01-30 00:18:50 -05:00
Dax Raad	36041c0000	ci	2026-01-30 00:15:21 -05:00
Dax Raad	b5e5d4c92f	ci	2026-01-30 00:10:44 -05:00
Dax Raad	b109ab7830	ci	2026-01-30 00:07:56 -05:00
Dax Raad	b28891473f	ci	2026-01-30 00:05:05 -05:00
Dax Raad	5d0122b5a9	ci	2026-01-30 00:04:51 -05:00
Dax Raad	1ab4bbc275	ci	2026-01-29 23:58:39 -05:00
Dax Raad	908350c2ea	ci	2026-01-29 23:56:56 -05:00
Dax Raad	3fef490187	ci	2026-01-29 23:55:48 -05:00
Dax Raad	3ac05201c6	ci	2026-01-29 23:52:08 -05:00
Dax Raad	2d3c7a0f24	ci	2026-01-29 23:49:53 -05:00
Dax Raad	cd664a189b	ci	2026-01-29 23:17:57 -05:00
Dax Raad	849f488744	ci	2026-01-29 23:15:12 -05:00
Dax Raad	5ea1042ffb	ci	2026-01-29 23:13:07 -05:00
Dax Raad	71d280d570	ci: fix container build script Invoke docker build with Bun shell so commands run correctly, and document default automation behavior.	2026-01-29 23:10:50 -05:00
Dax Raad	5cfb5fdd06	ci: add container build workflow Add prebuilt build images and a publish workflow to speed CI by reusing heavy dependencies.	2026-01-29 23:07:58 -05:00
Dax Raad	30969dc33e	ci: cache apt packages to reduce CI build times on ubuntu	2026-01-29 21:51:53 -05:00
adamelmoreandAdam	5f282c268d	fix(app): free model layout	2026-01-29 20:44:38 -06:00