chore: update nix node_modules hashes

bun.lock

@@ -303,7 +303,7 @@
         "@ai-sdk/google": "3.0.73",
         "@ai-sdk/google-vertex": "4.0.128",
         "@ai-sdk/groq": "3.0.31",
-        "@ai-sdk/mistral": "3.0.34",
+        "@ai-sdk/mistral": "3.0.51",
         "@ai-sdk/openai": "3.0.84",
         "@ai-sdk/openai-compatible": "2.0.41",
         "@ai-sdk/perplexity": "3.0.26",
@@ -578,7 +578,7 @@
         "@ai-sdk/google": "3.0.73",
         "@ai-sdk/google-vertex": "4.0.128",
         "@ai-sdk/groq": "3.0.31",
-        "@ai-sdk/mistral": "3.0.34",
+        "@ai-sdk/mistral": "3.0.51",
         "@ai-sdk/openai": "3.0.84",
         "@ai-sdk/openai-compatible": "2.0.41",
         "@ai-sdk/perplexity": "3.0.26",
@@ -1076,12 +1076,12 @@
     "gcp-metadata@8.1.2": "patches/gcp-metadata@8.1.2.patch",
     "@standard-community/standard-openapi@0.2.9": "patches/@standard-community%2Fstandard-openapi@0.2.9.patch",
     "effect@4.0.0-beta.83": "patches/effect@4.0.0-beta.83.patch",
-    "@npmcli/agent@4.0.2": "patches/@npmcli%2Fagent@4.0.2.patch",
+    "@ai-sdk/mistral@3.0.51": "patches/@ai-sdk%2Fmistral@3.0.51.patch",
     "@silvia-odwyer/photon-node@0.3.4": "patches/@silvia-odwyer%2Fphoton-node@0.3.4.patch",
+    "@npmcli/agent@4.0.2": "patches/@npmcli%2Fagent@4.0.2.patch",
     "solid-js@1.9.10": "patches/solid-js@1.9.10.patch",
     "@ai-sdk/google@3.0.73": "patches/@ai-sdk%2Fgoogle@3.0.73.patch",
     "pacote@21.5.0": "patches/pacote@21.5.0.patch",
-    "@ai-sdk/mistral@3.0.34": "patches/@ai-sdk%2Fmistral@3.0.34.patch",
   },
   "overrides": {
     "@opentui/core": "catalog:",
@@ -1202,7 +1202,7 @@
 
     "@ai-sdk/groq": ["@ai-sdk/groq@3.0.31", "", { "dependencies": { "@ai-sdk/provider": "3.0.8", "@ai-sdk/provider-utils": "4.0.21" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-XbbugpnFmXGu2TlXiq8KUJskP6/VVbuFcnFIGDzDIB/Chg6XHsNnqrTF80Zxkh0Pd3+NvbM+2Uqrtsndk6bDAg=="],
 
-    "@ai-sdk/mistral": ["@ai-sdk/mistral@3.0.34", "", { "dependencies": { "@ai-sdk/provider": "3.0.10", "@ai-sdk/provider-utils": "4.0.26" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-HpK28sWGdIfg1vTSScJNtzVdvNRfA4mfCmPmPR+j/MGJ0oAuEJMqxWkL96ZnGPdhZt5KdW09aKovdIe+q2zQ7A=="],
+    "@ai-sdk/mistral": ["@ai-sdk/mistral@3.0.51", "", { "dependencies": { "@ai-sdk/provider": "3.0.14", "@ai-sdk/provider-utils": "4.0.40" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-83eXY6p0lUFhSuMvNDmTKDuMciK5XDAWDlNh5c0L80tKjmtCFRItA1MZHp4IKe1r7eK8Rb5nN7qtxqMLUFRIRw=="],
 
     "@ai-sdk/openai": ["@ai-sdk/openai@3.0.48", "", { "dependencies": { "@ai-sdk/provider": "3.0.8", "@ai-sdk/provider-utils": "4.0.21" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-ALmj/53EXpcRqMbGpPJPP4UOSWw0q4VGpnDo7YctvsynjkrKDmoneDG/1a7VQnSPYHnJp6tTRMf5ZdxZ5whulg=="],
 
@@ -5702,9 +5702,9 @@
 
     "@ai-sdk/groq/@ai-sdk/provider-utils": ["@ai-sdk/provider-utils@4.0.21", "", { "dependencies": { "@ai-sdk/provider": "3.0.8", "@standard-schema/spec": "^1.1.0", "eventsource-parser": "^3.0.6" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-MtFUYI1/8mgDvRmaBDjbLJPFFrMG777AvSgyIFQtZHIMzm88R/12vYBBpnk7pfiWLFE1DSZzY4WDYzGbKAcmiw=="],
 
-    "@ai-sdk/mistral/@ai-sdk/provider": ["@ai-sdk/provider@3.0.10", "", { "dependencies": { "json-schema": "^0.4.0" } }, "sha512-Q3BZ27qfpYqnCYGvE3vt+Qi6LGOF9R5Nmzn+9JoM1lCRsD9mYaIhfJLkSunN48nfGXJ6n+XNV0J/XVpqGQl7Dw=="],
+    "@ai-sdk/mistral/@ai-sdk/provider": ["@ai-sdk/provider@3.0.14", "", { "dependencies": { "json-schema": "^0.4.0" } }, "sha512-5X1k57JBJ4H7H1QjX7CnJYAB1I19r/trVZTMcSms7/kLNZ8RaU4Nt2agcwZzv82Hfx6Q7/TOLU7agAKeFfc8cA=="],
 
-    "@ai-sdk/mistral/@ai-sdk/provider-utils": ["@ai-sdk/provider-utils@4.0.26", "", { "dependencies": { "@ai-sdk/provider": "3.0.10", "@standard-schema/spec": "^1.1.0", "eventsource-parser": "^3.0.8" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-CsKNLKsOpvPujRlIYvoz+Ybw+kGn7J4/fIZa/58+R7iWLLfwn6ifE2G6Yq8K9XvH/I/3bzaDAJ3NhRwEMsLBKQ=="],
+    "@ai-sdk/mistral/@ai-sdk/provider-utils": ["@ai-sdk/provider-utils@4.0.40", "", { "dependencies": { "@ai-sdk/provider": "3.0.14", "@standard-schema/spec": "^1.1.0", "eventsource-parser": "^3.0.8" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-OL5IrpUm9Y8Dwy+w/vvFwPotS6m52O9W0op2oXgXdCROMJIBalBI0oro6OIBYkPxvm5Xg02GSkoQN25RlR0bnw=="],
 
     "@ai-sdk/openai/@ai-sdk/provider-utils": ["@ai-sdk/provider-utils@4.0.21", "", { "dependencies": { "@ai-sdk/provider": "3.0.8", "@standard-schema/spec": "^1.1.0", "eventsource-parser": "^3.0.6" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-MtFUYI1/8mgDvRmaBDjbLJPFFrMG777AvSgyIFQtZHIMzm88R/12vYBBpnk7pfiWLFE1DSZzY4WDYzGbKAcmiw=="],
 

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-L741oedvozk0cIVnaZnujvwWrK+WXINv9KiKxYRfVwQ=",
-    "aarch64-linux": "sha256-ThzQ4nCLbaLiKA7cBHI7OMAlXb+8Hchm3HojGnIAEz0=",
-    "aarch64-darwin": "sha256-YdXOgFgYRu4tKw90+7F1reCihO+JC33dGk51J8NTRIk=",
-    "x86_64-darwin": "sha256-Ea5X2mYHGch3JyA6wC0uH3zBEzQcFT/adqJ1+7LtRdQ="
+    "x86_64-linux": "sha256-0kcwV34P2C3yKg2eG9W2nW+OedrSBb+1TdpuUeYtauY=",
+    "aarch64-linux": "sha256-yHVygApQchAB34wrtFR4GU0CkmZOlLsl3wsp15u0xzs=",
+    "aarch64-darwin": "sha256-DyalcwyK2Wn5R6249keFcNVECbgtjYNjscOFqTi88FI=",
+    "x86_64-darwin": "sha256-BkGw0GWN9W9q+/g4FYR0MqxUuFP80BPoERO+ypz/arQ="
   }
 }

package.json

@@ -149,7 +149,7 @@
     "@standard-community/standard-openapi@0.2.9": "patches/@standard-community%2Fstandard-openapi@0.2.9.patch",
     "solid-js@1.9.10": "patches/solid-js@1.9.10.patch",
     "@ai-sdk/xai@3.0.102": "patches/@ai-sdk%2Fxai@3.0.102.patch",
-    "@ai-sdk/mistral@3.0.34": "patches/@ai-sdk%2Fmistral@3.0.34.patch",
+    "@ai-sdk/mistral@3.0.51": "patches/@ai-sdk%2Fmistral@3.0.51.patch",
     "gcp-metadata@8.1.2": "patches/gcp-metadata@8.1.2.patch",
     "pacote@21.5.0": "patches/pacote@21.5.0.patch",
     "@ai-sdk/google@3.0.73": "patches/@ai-sdk%2Fgoogle@3.0.73.patch",

packages/app/e2e/performance/timeline-stability/fixture.ts

@@ -97,6 +97,7 @@ export async function setupTimeline(
     locale?: string
     deviceScaleFactor?: number
     seedHistory?: boolean
+    protocol?: "v1" | "v2"
   } = {},
 ) {
   const sessions = input.sessions ?? [session()]
@@ -114,6 +115,7 @@ export async function setupTimeline(
     retry: input.eventRetry ?? 20,
   })
   await mockOpenCodeServer(page, {
+    protocol: input.protocol,
     directory,
     project: project(),
     provider: provider(),

packages/app/e2e/performance/timeline/session-parent-hydration-benchmark.spec.ts

@@ -41,12 +41,7 @@ const assistants = Array.from({ length: 14 }, (_, index) => {
 const messages = [user, ...assistants]
 const target = fixture.sessions.find((session) => session.id === fixture.targetID)!
 const lastID = userID
-const lastAssistant = assistants.at(-1)!
-const lastPart = lastAssistant.parts.at(-1)!
-const lastPartID =
-  lastPart.type === "tool"
-    ? lastPart.id
-    : `${lastAssistant.info.id}:${lastPart.type}:${lastAssistant.parts.filter((part) => part.type === lastPart.type).length - 1}`
+const lastPartID = assistants.at(-1)!.parts.at(-1)!.id
 
 benchmark("hydrates an orphaned latest turn after a cold session click", async ({ browser, report }, testInfo) => {
   benchmark.setTimeout(180_000)
@@ -112,25 +107,9 @@ async function trial(page: Page, mode: ParentHydrationBenchmarkMode) {
       return { items: items.slice(start, end), cursor: start > 0 ? items[start]!.info.id : undefined }
     },
   })
-  await page.route(`**/session/${fixture.targetID}`, (route) => {
-    const current = new URL(route.request().url()).pathname.startsWith("/api/")
-    return route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify(
-        current
-          ? {
-              data: {
-                ...target,
-                cost: 0,
-                tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-                location: { directory: target.directory },
-              },
-            }
-          : target,
-      ),
-    })
-  })
+  await page.route(`**/session/${fixture.targetID}`, (route) =>
+    route.fulfill({ status: 200, contentType: "application/json", body: JSON.stringify(target) }),
+  )
   await installStressSessionTabs(page, { sessionIDs: [fixture.sourceID] })
   await page.goto(stressSessionHref(fixture.sourceID))
   await expectSessionTitle(page, fixture.expected.sourceTitle)
@@ -165,8 +144,8 @@ async function trial(page: Page, mode: ParentHydrationBenchmarkMode) {
     parent: requests.filter((request) => request.type === "parent").length,
   }
   if (mode === "candidate") {
-    expect(requestCounts.parent).toBe(0)
-    expect(historyGates).toBe(0)
+    expect(requestCounts.parent).toBe(1)
+    expect(historyGates).toBe(1)
   }
   return { metrics, requestCounts, historyGateCount: historyGates }
 }

packages/app/e2e/regression/cross-server-tab-close.spec.ts

@@ -1,6 +1,5 @@
 import { expect, test, type Page, type Route } from "@playwright/test"
 import { base64Encode } from "@opencode-ai/core/util/encode"
-import { currentSession } from "../utils/mock-server"
 
 const serverA = "http://127.0.0.1:4096"
 const serverB = "http://127.0.0.1:4097"
@@ -34,7 +33,7 @@ test("closing the active server's last tab opens the remaining server tab", asyn
   await tabA.locator('[data-slot="tab-close"] button').click()
 
   await expect(page).toHaveURL(new RegExp(`${hrefB.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`))
-  await expect.poll(() => requests.some((url) => url.startsWith(`${serverB}/api/session/${sessionB.id}`))).toBe(true)
+  await expect.poll(() => requests.some((url) => url.startsWith(`${serverB}/session/${sessionB.id}`))).toBe(true)
   await expect(page.getByText(sessionB.title).first()).toBeVisible()
   const sessionBRequests = requests.filter((url) => url.includes(`/session/${sessionB.id}`))
   expect(sessionBRequests.every((url) => url.startsWith(serverB))).toBe(true)
@@ -85,19 +84,16 @@ async function mockServers(page: Page, requests: string[]) {
     const current = url.origin === serverA ? sessionA : sessionB
     const directory = url.searchParams.get("directory")
     if (directory && directory !== current.directory) return json(route, { name: "InvalidDirectory" }, 500)
-    if (url.pathname === "/global/event" || url.pathname === "/event" || url.pathname === "/api/event") return sse(route)
+    if (url.pathname === "/global/event" || url.pathname === "/event") return sse(route)
     if (url.pathname === "/global/health") return json(route, { healthy: true })
-    if (url.pathname === "/api/session") return json(route, { data: [currentSession(current)], cursor: {} })
-    if (url.pathname === "/api/session/active") return json(route, { data: {} })
-    if (url.pathname === `/api/session/${current.id}`) return json(route, { data: currentSession(current) })
-    if (url.pathname === `/api/session/${current.id}/message`) return json(route, { data: [], cursor: {} })
+    if (url.pathname === "/session") return json(route, [current])
     if (url.pathname === `/session/${current.id}`) return json(route, current)
     if (/^\/session\/[^/]+$/.test(url.pathname)) return json(route, { name: "NotFoundError" }, 404)
     if (url.pathname === `/session/${current.id}/message`) return json(route, [])
     if (/^\/session\/[^/]+\/(children|todo|diff)$/.test(url.pathname)) return json(route, [])
     if (["/skill", "/command", "/lsp", "/formatter", "/permission", "/question", "/vcs/diff"].includes(url.pathname))
       return json(route, [])
-    if (["/global/config", "/config", "/provider/auth", "/mcp"].includes(url.pathname))
+    if (["/global/config", "/config", "/provider/auth", "/mcp", "/session/status"].includes(url.pathname))
       return json(route, {})
     if (url.pathname === "/provider")
       return json(route, { all: [], connected: [], default: { providerID: "", modelID: "" } })
@@ -120,17 +116,7 @@ async function mockServers(page: Page, requests: string[]) {
         directory: current.directory,
         home: current.directory,
       })
-    if (url.pathname === "/api/path")
-      return json(route, {
-        state: current.directory,
-        config: current.directory,
-        worktree: current.directory,
-        directory: current.directory,
-        home: current.directory,
-      })
     if (url.pathname === "/vcs") return json(route, { branch: "main", default_branch: "main" })
-    if (url.pathname === "/api/vcs")
-      return json(route, { location: { directory: current.directory }, data: { branch: "main", defaultBranch: "main" } })
     return json(route, {})
   })
 }

packages/app/e2e/regression/remote-tab-busy.spec.ts

@@ -1,6 +1,5 @@
 import { expect, test, type Page, type Route } from "@playwright/test"
 import { base64Encode } from "@opencode-ai/core/util/encode"
-import { currentSession } from "../utils/mock-server"
 
 const serverA = "http://127.0.0.1:4096"
 const serverB = "http://127.0.0.1:4097"
@@ -58,14 +57,11 @@ async function mockServers(page: Page) {
     const current = url.origin === serverA ? sessionA : sessionB
     const directory = url.searchParams.get("directory")
     if (directory && directory !== current.directory) return json(route, { name: "InvalidDirectory" }, 500)
-    if (url.pathname === "/global/event" || url.pathname === "/event" || url.pathname === "/api/event")
-      return sse(route, url.pathname === "/api/event")
+    if (url.pathname === "/global/event" || url.pathname === "/event") return sse(route)
     if (url.pathname === "/global/health") return json(route, { healthy: true })
-    if (url.pathname === "/api/session/active")
-      return json(route, { data: url.origin === serverB ? { [sessionB.id]: { type: "running" } } : {} })
-    if (url.pathname === "/api/session") return json(route, { data: [currentSession(current)], cursor: {} })
-    if (url.pathname === `/api/session/${current.id}`) return json(route, { data: currentSession(current) })
-    if (url.pathname === `/api/session/${current.id}/message`) return json(route, { data: [], cursor: {} })
+    if (url.pathname === "/session/status")
+      return json(route, url.origin === serverB ? { [sessionB.id]: { type: "busy" } } : {})
+    if (url.pathname === "/session") return json(route, [current])
     if (url.pathname === `/session/${current.id}`) return json(route, current)
     if (/^\/session\/[^/]+$/.test(url.pathname)) return json(route, { name: "NotFoundError" }, 404)
     if (url.pathname === `/session/${current.id}/message`) return json(route, [])
@@ -94,17 +90,7 @@ async function mockServers(page: Page) {
         directory: current.directory,
         home: current.directory,
       })
-    if (url.pathname === "/api/path")
-      return json(route, {
-        state: current.directory,
-        config: current.directory,
-        worktree: current.directory,
-        directory: current.directory,
-        home: current.directory,
-      })
     if (url.pathname === "/vcs") return json(route, { branch: "main", default_branch: "main" })
-    if (url.pathname === "/api/vcs")
-      return json(route, { location: { directory: current.directory }, data: { branch: "main", defaultBranch: "main" } })
     return json(route, {})
   })
 }
@@ -118,10 +104,6 @@ function json(route: Route, body: unknown, status = 200) {
   })
 }
 
-function sse(route: Route, current: boolean) {
-  return route.fulfill({
-    status: 200,
-    contentType: "text/event-stream",
-    body: current ? 'data: {"id":"evt_connected","type":"server.connected","data":{}}\n\n' : ": ok\n\n",
-  })
+function sse(route: Route) {
+  return route.fulfill({ status: 200, contentType: "text/event-stream", body: ": ok\n\n" })
 }

packages/app/e2e/regression/session-list-path-loading.spec.ts

@@ -16,8 +16,8 @@ test("shows loaded sessions before the directory path request resolves", async (
   const pathBlocked = new Promise<void>((resolve) => {
     releasePath = resolve
   })
-  await page.route("**/api/path?*", async (route) => {
-    if (!new URL(route.request().url()).searchParams.has("location[directory]")) return route.fallback()
+  await page.route("**/path?*", async (route) => {
+    if (!new URL(route.request().url()).searchParams.has("directory")) return route.fallback()
     await pathBlocked
     return route.fallback()
   })

packages/app/e2e/regression/session-request-docks.spec.ts

@@ -42,8 +42,7 @@ test("shows a pending question dock", async ({ page }) => {
   const rejectRequests: string[] = []
   page.on("request", (request) => {
     if (request.method() !== "POST") return
-    if (new URL(request.url()).pathname === `/api/session/${sessionID}/question/question-request/reject`)
-      rejectRequests.push(request.url())
+    if (new URL(request.url()).pathname === "/question/question-request/reject") rejectRequests.push(request.url())
   })
 
   await question.locator('[data-component="icon-button"][data-icon="chevron-down"]').click()
@@ -65,9 +64,7 @@ test("shows a pending question dock", async ({ page }) => {
 
   await question.getByRole("radio", { name: /Minimal/ }).click()
   const reply = page.waitForRequest(
-    (request) =>
-      request.method() === "POST" &&
-      new URL(request.url()).pathname === `/api/session/${sessionID}/question/question-request/reply`,
+    (request) => request.method() === "POST" && new URL(request.url()).pathname === "/question/question-request/reply",
   )
   await question.getByRole("button", { name: "Submit" }).click()
   expect((await reply).postDataJSON()).toEqual({ answers: [["Minimal"]] })
@@ -100,8 +97,8 @@ test("shows a pending permission dock", async ({ page }) => {
   const reply = page.waitForRequest((request) => request.method() === "POST")
   await permission.getByRole("button", { name: "Allow once" }).click()
   const request = await reply
-  expect(new URL(request.url()).pathname).toBe(`/api/session/${sessionID}/permission/permission-request/reply`)
-  expect(request.postDataJSON()).toEqual({ reply: "once" })
+  expect(new URL(request.url()).pathname).toBe(`/session/${sessionID}/permissions/permission-request`)
+  expect(request.postDataJSON()).toEqual({ response: "once" })
 })
 
 test("restores the draft caret before typing after a request dock closes", async ({ page }) => {

packages/app/e2e/regression/session-timeline-transport.spec.ts

@@ -90,7 +90,7 @@ test("reconnects after a stream error", async ({ page }) => {
 })
 
 test("does not request replay when reconnecting the volatile V2 event stream", async ({ page }) => {
-  const timeline = await setupTimeline(page, { eventRetry: 10 })
+  const timeline = await setupTimeline(page, { eventRetry: 10, protocol: "v2" })
   const first = await timeline.transport.send(partUpdated(textPart("prt_transport_id", "event with id")), {
     id: "timeline-event-7",
   })

packages/app/e2e/regression/subagent-child-navigation.spec.ts

@@ -1,6 +1,6 @@
 import { base64Encode } from "@opencode-ai/core/util/encode"
 import { expect, test, type Page } from "@playwright/test"
-import { currentSession, mockOpenCodeServer } from "../utils/mock-server"
+import { mockOpenCodeServer } from "../utils/mock-server"
 import { expectSessionTitle } from "../utils/waits"
 
 const directory = "C:/OpenCode/SubagentNavigation"
@@ -72,19 +72,16 @@ async function setup(page: Page, events?: () => EventPayload[]) {
     events,
     eventRetry: events ? 16 : undefined,
   })
-  // The child session resolves by ID but is absent from the session list,
+  // The child session resolves via /session/:id but is absent from the /session list,
   // matching a subagent session that has not been loaded into the list cache yet.
   await page.route(
-    (url) => url.pathname === "/api/session" && url.port === (process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"),
+    (url) => url.pathname === "/session" && url.port === (process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"),
     (route) =>
       route.fulfill({
         status: 200,
         contentType: "application/json",
         headers: { "access-control-allow-origin": "*" },
-        body: JSON.stringify({
-          data: [currentSession(session(parentID, parentTitle, 1700000000000))],
-          cursor: {},
-        }),
+        body: JSON.stringify([session(parentID, parentTitle, 1700000000000)]),
       }),
   )
   await configurePage(page)

packages/app/e2e/regression/tab-navigate-mousedown.spec.ts

@@ -1,6 +1,5 @@
 import { expect, test, type Page, type Route } from "@playwright/test"
 import { base64Encode } from "@opencode-ai/core/util/encode"
-import { currentSession } from "../utils/mock-server"
 
 const server = "http://127.0.0.1:4096"
 const sessionA = session("ses_tab_a", "Tab A session")
@@ -57,14 +56,9 @@ async function mockServer(page: Page) {
   await page.route("**/*", async (route) => {
     const url = new URL(route.request().url())
     if (url.origin !== server) return route.fallback()
-    if (url.pathname === "/global/event" || url.pathname === "/event" || url.pathname === "/api/event") return sse(route)
+    if (url.pathname === "/global/event" || url.pathname === "/event") return sse(route)
     if (url.pathname === "/global/health") return json(route, { healthy: true })
-    if (url.pathname === "/api/session") return json(route, { data: sessions.map(currentSession), cursor: {} })
-    if (url.pathname === "/api/session/active") return json(route, { data: {} })
-    const currentSessionInfo = sessions.find((item) => url.pathname === `/api/session/${item.id}`)
-    if (currentSessionInfo) return json(route, { data: currentSession(currentSessionInfo) })
-    if (sessions.some((item) => url.pathname === `/api/session/${item.id}/message`))
-      return json(route, { data: [], cursor: {} })
+    if (url.pathname === "/session") return json(route, sessions)
     const byId = sessions.find((item) => url.pathname === `/session/${item.id}`)
     if (byId) return json(route, byId)
     if (/^\/session\/[^/]+$/.test(url.pathname)) return json(route, { name: "NotFoundError" }, 404)
@@ -72,7 +66,7 @@ async function mockServer(page: Page) {
     if (/^\/session\/[^/]+\/(children|todo|diff)$/.test(url.pathname)) return json(route, [])
     if (["/skill", "/command", "/lsp", "/formatter", "/permission", "/question", "/vcs/diff"].includes(url.pathname))
       return json(route, [])
-    if (["/global/config", "/config", "/provider/auth", "/mcp"].includes(url.pathname))
+    if (["/global/config", "/config", "/provider/auth", "/mcp", "/session/status"].includes(url.pathname))
       return json(route, {})
     if (url.pathname === "/provider")
       return json(route, { all: [], connected: [], default: { providerID: "", modelID: "" } })
@@ -95,20 +89,7 @@ async function mockServer(page: Page) {
         directory: sessionA.directory,
         home: sessionA.directory,
       })
-    if (url.pathname === "/api/path")
-      return json(route, {
-        state: sessionA.directory,
-        config: sessionA.directory,
-        worktree: sessionA.directory,
-        directory: sessionA.directory,
-        home: sessionA.directory,
-      })
     if (url.pathname === "/vcs") return json(route, { branch: "main", default_branch: "main" })
-    if (url.pathname === "/api/vcs")
-      return json(route, {
-        location: { directory: sessionA.directory },
-        data: { branch: "main", defaultBranch: "main" },
-      })
     return json(route, {})
   })
 }

packages/app/e2e/utils/mock-server.ts

@@ -4,6 +4,7 @@ const emptyList = new Set(["/skill", "/command", "/lsp", "/formatter", "/vcs/sta
 const emptyObject = new Set(["/global/config", "/config", "/provider/auth", "/mcp", "/experimental/resource"])
 
 export interface MockServerConfig {
+  protocol?: "v1" | "v2"
   provider: unknown
   directory: string
   project: unknown
@@ -64,7 +65,10 @@ export async function mockOpenCodeServer(page: Page, config: MockServerConfig) {
         config.eventRetry,
       )
     }
-    if (path === "/global/health") return json(route, { healthy: true })
+    if (path === "/global/health")
+      return config.protocol === "v2" ? json(route, {}, undefined, 404) : json(route, { healthy: true })
+    if (path === "/api/health" && config.protocol === "v2")
+      return json(route, { healthy: true, version: "2.0.0", pid: 1 })
     if (path === "/experimental/capabilities") return json(route, { backgroundSubagents: true })
     if (path === "/permission")
       return json(route, typeof config.permissions === "function" ? config.permissions() : (config.permissions ?? []))
@@ -162,7 +166,12 @@ export async function mockOpenCodeServer(page: Page, config: MockServerConfig) {
         .filter((session) => parentID !== "null" || session.parentID === undefined)
         .filter((session) => {
           const search = url.searchParams.get("search")?.toLowerCase()
-          return !search || String(session.title ?? "").toLowerCase().includes(search)
+          return (
+            !search ||
+            String(session.title ?? "")
+              .toLowerCase()
+              .includes(search)
+          )
         })
       const ordered = url.searchParams.get("order") === "asc" ? sessions.toReversed() : sessions
       const data = ordered.slice(offset, offset + limit)
@@ -176,7 +185,9 @@ export async function mockOpenCodeServer(page: Page, config: MockServerConfig) {
       const statuses = (config.sessionStatus ?? {}) as Record<string, { type?: string }>
       return json(route, {
         data: Object.fromEntries(
-          Object.entries(statuses).flatMap(([id, status]) => (status.type === "idle" ? [] : [[id, { type: "running" }]])),
+          Object.entries(statuses).flatMap(([id, status]) =>
+            status.type === "idle" ? [] : [[id, { type: "running" }]],
+          ),
         ),
       })
     }
@@ -289,7 +300,8 @@ function currentPermission(value: unknown) {
     resources: permission.patterns ?? [],
     save: permission.always,
     metadata: permission.metadata,
-    source: tool?.messageID && tool.callID ? { type: "tool", messageID: tool.messageID, callID: tool.callID } : undefined,
+    source:
+      tool?.messageID && tool.callID ? { type: "tool", messageID: tool.messageID, callID: tool.callID } : undefined,
   }
 }
 

packages/app/e2e/utils/sse-transport.ts

@@ -104,7 +104,8 @@ export async function installSseTransport<T>(
           created: Date.now(),
           type: payload.type,
           data: payload.properties ?? {},
-          location: envelope.directory && envelope.directory !== "global" ? { directory: envelope.directory } : undefined,
+          location:
+            envelope.directory && envelope.directory !== "global" ? { directory: envelope.directory } : undefined,
         }
       }
       const acknowledge = (
@@ -160,9 +161,7 @@ export async function installSseTransport<T>(
         })
         encoded.forEach((item) => marker(item.delivery.options?.marker))
         if (input.burst) {
-          const bytes = encoder.encode(
-            encoded.map((item) => frame(item.payload, item.delivery.options)).join(""),
-          )
+          const bytes = encoder.encode(encoded.map((item) => frame(item.payload, item.delivery.options)).join(""))
           connection.controller.enqueue(bytes)
           return encoded.map((item) => acknowledge(connection, item.bytes.byteLength, 1, item.delivery.options?.id))
         }
@@ -196,9 +195,7 @@ export async function installSseTransport<T>(
             if (retry !== undefined) controller.enqueue(encoder.encode(`retry: ${retry}\n\n`))
             if (url.pathname === "/api/event")
               controller.enqueue(
-                encoder.encode(
-                  frame({ id: `evt_mock_connected_${id}`, type: "server.connected", data: {} }),
-                ),
+                encoder.encode(frame({ id: `evt_mock_connected_${id}`, type: "server.connected", data: {} })),
               )
             request.signal.addEventListener(
               "abort",

packages/app/src/components/command-palette.ts

@@ -1,6 +1,5 @@
 import { getFilename } from "@opencode-ai/core/util/path"
-import type { Project } from "@opencode-ai/sdk/v2/client"
-import type { SessionInfo } from "@opencode-ai/client/promise"
+import type { GlobalSession, Project } from "@opencode-ai/sdk/v2/client"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { createMemo, onCleanup } from "solid-js"
 import { commandPaletteOptions, useCommand, type CommandOption } from "@/context/command"
@@ -14,7 +13,6 @@ import { useTabs } from "@/context/tabs"
 import { displayName, projectForSession } from "@/pages/layout/helpers"
 import { createSessionTabs } from "@/pages/session/helpers"
 import { useSessionLayout } from "@/pages/session/session-layout"
-import { normalizeSessionInfo } from "@/utils/session"
 
 export type CommandPaletteEntry = {
   id: string
@@ -147,7 +145,7 @@ export function createCommandPaletteModel(props: { filesOnly?: () => boolean; on
     opened: serverCtx.projects.list,
     stored: () => serverCtx.sync.data.project,
     load: (search, signal) =>
-      serverSDK.api.session.list({ parentID: null, search, limit: 50 }, { signal }),
+      serverSDK.client.experimental.session.list({ roots: true, search, limit: 50 }, { signal }),
     untitled: () => language.t("command.session.new"),
     category: () => language.t("command.category.session"),
   })
@@ -221,7 +219,7 @@ export function createServerSessionEntries(props: {
   server: ServerConnection.Key
   opened: () => LocalProject[]
   stored: () => Project[]
-  load: (search: string, signal: AbortSignal) => Promise<{ data: SessionInfo[] }>
+  load: (search: string, signal: AbortSignal) => Promise<{ data?: GlobalSession[] }>
   untitled: () => string
   category: () => string
 }) {
@@ -257,8 +255,7 @@ export function createServerSessionEntries(props: {
     return props
       .load(search, current.signal)
       .then((result) =>
-        result.data
-          .map(normalizeSessionInfo)
+        (result.data ?? [])
           .filter((session) => !session.time.archived)
           .map((session) => {
             const project =
@@ -267,7 +264,7 @@ export function createServerSessionEntries(props: {
               id: `session:${props.server}:${session.id}`,
               type: "session" as const,
               title: session.title || props.untitled(),
-              description: project ? displayName(project) : getFilename(session.directory),
+              description: project ? displayName(project) : session.project?.name || getFilename(session.directory),
               category: props.category(),
               directory: session.directory,
               sessionID: session.id,

packages/app/src/components/dialog-command-palette-v2.tsx

@@ -80,7 +80,7 @@ export function DialogHomeCommandPaletteV2(props: {
     opened: serverCtx.projects.list,
     stored: () => serverCtx.sync.data.project,
     load: (search, signal) =>
-      serverCtx.sdk.api.session.list({ parentID: null, search, limit: 50 }, { signal }),
+      serverCtx.sdk.client.experimental.session.list({ roots: true, search, limit: 50 }, { signal }),
     untitled: () => language.t("command.session.new"),
     category: () => language.t("command.category.session"),
   })

packages/app/src/components/dialog-connect-provider.tsx

@@ -1,7 +1,4 @@
-import type {
-  IntegrationMethod,
-  IntegrationOauthConnectOutput,
-} from "@opencode-ai/client/promise"
+import type { ProviderAuthAuthorization, ProviderAuthMethod } from "@opencode-ai/sdk/v2/client"
 import { Button } from "@opencode-ai/ui/button"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { Dialog } from "@opencode-ai/ui/dialog"
@@ -31,8 +28,6 @@ import {
   Switch,
 } from "solid-js"
 import { createStore, produce } from "solid-js/store"
-import { useQueryClient } from "@tanstack/solid-query"
-import { useParams } from "@solidjs/router"
 import { Link } from "@/components/link"
 import { useServerSDK } from "@/context/server-sdk"
 import { useServerSync } from "@/context/server-sync"
@@ -40,11 +35,8 @@ import { useLanguage } from "@/context/language"
 import { useSettings } from "@/context/settings"
 import { popularProviders, useProviders } from "@/hooks/use-providers"
 import { CustomProviderForm } from "./dialog-custom-provider"
-import { decode64 } from "@/utils/base64"
-import { pathKey } from "@/utils/path-key"
 
 const CUSTOM_ID = "_custom"
-type ConnectMethod = Extract<IntegrationMethod, { type: "key" | "oauth" }>
 
 export function useProviderConnectController(options: { onBack?: () => void } = {}) {
   const [store, setStore] = createStore({ selected: undefined as string | undefined })
@@ -236,6 +228,8 @@ function ProviderPickerV2(props: {
 }) {
   const providers = useProviders(props.directory)
   const language = useLanguage()
+  const serverSync = useServerSync()
+  const serverSDK = useServerSDK()
   const [store, setStore] = createStore({
     filter: "",
     active: undefined as string | undefined,
@@ -272,7 +266,19 @@ function ProviderPickerV2(props: {
 
   const connect = (provider: string) => {
     props.onPrepare?.()
-    props.onSelect(provider)
+    if (provider === CUSTOM_ID || serverSync().data.provider_auth[provider]) {
+      props.onSelect(provider)
+      return
+    }
+    if (store.connecting) return
+    setStore("connecting", provider)
+    void serverSDK()
+      .client.provider.auth()
+      .then((response) => {
+        serverSync().set("provider_auth", response.data ?? {})
+        props.onSelect(provider)
+      })
+      .catch(() => props.onSelect(provider))
   }
 
   const move = (event: KeyboardEvent, direction: number) => {
@@ -389,17 +395,10 @@ function ProviderConnection(props: {
   const dialog = useDialog()
   const serverSync = useServerSync()
   const serverSDK = useServerSDK()
-  const queryClient = useQueryClient()
-  const params = useParams()
   const language = useLanguage()
   const settings = useSettings()
   const newLayout = settings.general.newLayoutDesigns
   const providers = useProviders(props.directory)
-  const directory = () => props.directory?.() ?? decode64(params.dir)
-  const location = () => {
-    const value = directory()
-    return value ? { directory: value } : undefined
-  }
 
   const alive = { value: true }
   const timer = { current: undefined as ReturnType<typeof setTimeout> | undefined }
@@ -414,34 +413,38 @@ function ProviderConnection(props: {
   const provider = createMemo(
     () => providers.all().get(props.provider) ?? serverSync().data.provider.all.get(props.provider)!,
   )
-  const fallback = createMemo<ConnectMethod[]>(() => [
+  const fallback = createMemo<ProviderAuthMethod[]>(() => [
     {
-      type: "key" as const,
+      type: "api" as const,
       label: language.t("provider.connect.method.apiKey"),
     },
   ])
-  const [integration] = createResource(
-    () => ({ provider: props.provider, directory: directory() }),
-    (input) =>
-      serverSDK()
-        .api.integration.get({
-          integrationID: input.provider,
-          location: input.directory ? { directory: input.directory } : undefined,
-        })
-        .then((result) => result.data),
+  const [auth] = createResource(
+    () => props.provider,
+    async () => {
+      const cached = serverSync().data.provider_auth[props.provider]
+      if (cached) return cached
+      const res = await serverSDK().client.provider.auth()
+      if (!alive.value) return fallback()
+      serverSync().set("provider_auth", res.data ?? {})
+      return res.data?.[props.provider] ?? fallback()
+    },
   )
-  const loading = createMemo(() => integration.loading)
-  const methods = createMemo<ConnectMethod[]>(() => {
-    const values = integration.latest?.methods.filter(
-      (method): method is ConnectMethod => method.type === "key" || method.type === "oauth",
-    )
-    return values?.length ? values : fallback()
-  })
+  const loading = createMemo(() => auth.loading && !serverSync().data.provider_auth[props.provider])
+  const methods = createMemo(() => auth.latest ?? serverSync().data.provider_auth[props.provider] ?? fallback())
+  const cachedMethods = serverSync().data.provider_auth[props.provider]
+  const directMethod =
+    cachedMethods?.length === 1 && cachedMethods[0].type === "api" && !cachedMethods[0].prompts?.length ? 0 : undefined
   const [store, setStore] = createStore({
-    methodIndex: undefined as undefined | number,
-    authorization: undefined as undefined | IntegrationOauthConnectOutput["data"],
+    methodIndex: directMethod as undefined | number,
+    authorization: undefined as undefined | ProviderAuthAuthorization,
     promptInputs: undefined as undefined | Record<string, string>,
-    state: "pending" as undefined | "pending" | "complete" | "error" | "prompt",
+    state: (directMethod === undefined ? "pending" : undefined) as
+      | undefined
+      | "pending"
+      | "complete"
+      | "error"
+      | "prompt",
     error: undefined as string | undefined,
   })
 
@@ -451,7 +454,7 @@ function ProviderConnection(props: {
     | { type: "auth.prompt" }
     | { type: "auth.inputs"; inputs: Record<string, string> }
     | { type: "auth.pending" }
-    | { type: "auth.complete"; authorization: IntegrationOauthConnectOutput["data"] }
+    | { type: "auth.complete"; authorization: ProviderAuthAuthorization }
     | { type: "auth.error"; error: string }
 
   function dispatch(action: Action) {
@@ -505,7 +508,7 @@ function ProviderConnection(props: {
 
   const methodLabel = (value?: { type?: string; label?: string }) => {
     if (!value) return ""
-    if (value.type === "key") return language.t("provider.connect.method.apiKey")
+    if (value.type === "api") return language.t("provider.connect.method.apiKey")
     return value.label ?? ""
   }
 
@@ -515,7 +518,7 @@ function ProviderConnection(props: {
     const hint = suffix?.[1]
     return {
       label: suffix ? label.slice(0, -suffix[0].length) : label,
-      hint: hint ? hint[0].toUpperCase() + hint.slice(1) : value?.type === "key" ? "Browser" : undefined,
+      hint: hint ? hint[0].toUpperCase() + hint.slice(1) : value?.type === "api" ? "Browser" : undefined,
     }
   }
 
@@ -546,22 +549,46 @@ function ProviderConnection(props: {
     const method = methods()[index]
     dispatch({ type: "method.select", index })
 
+    if (method.type === "api" && method.prompts?.length) {
+      if (!inputs) {
+        dispatch({ type: "auth.prompt" })
+        return
+      }
+      dispatch({ type: "auth.inputs", inputs })
+      return
+    }
+
     if (method.type === "oauth") {
       if (method.prompts?.length && !inputs) {
         dispatch({ type: "auth.prompt" })
         return
       }
       dispatch({ type: "auth.pending" })
+      const start = Date.now()
       await serverSDK()
-        .api.integration.oauth.connect({
-          integrationID: props.provider,
-          methodID: method.id,
-          inputs: inputs ?? {},
-          location: location(),
-        })
+        .client.provider.oauth.authorize(
+          {
+            providerID: props.provider,
+            method: index,
+            inputs,
+          },
+          { throwOnError: true },
+        )
         .then((x) => {
           if (!alive.value) return
-          dispatch({ type: "auth.complete", authorization: x.data })
+          const elapsed = Date.now() - start
+          const delay = 1000 - elapsed
+
+          if (delay > 0) {
+            if (timer.current !== undefined) clearTimeout(timer.current)
+            timer.current = setTimeout(() => {
+              timer.current = undefined
+              if (!alive.value) return
+              dispatch({ type: "auth.complete", authorization: x.data! })
+            }, delay)
+            return
+          }
+          dispatch({ type: "auth.complete", authorization: x.data! })
         })
         .catch((e) => {
           if (!alive.value) return
@@ -576,9 +603,9 @@ function ProviderConnection(props: {
       index: 0,
     })
 
-    const prompts = createMemo(() => {
+    const prompts = createMemo<NonNullable<ProviderAuthMethod["prompts"]>>(() => {
       const value = method()
-      return value?.type === "oauth" ? (value.prompts ?? []) : []
+      return value?.prompts ?? []
     })
     const matches = (prompt: NonNullable<ReturnType<typeof prompts>[number]>, value: Record<string, string>) => {
       if (!prompt.when) return true
@@ -609,6 +636,10 @@ function ProviderConnection(props: {
         setFormStore("index", next)
         return
       }
+      if (method()?.type === "api") {
+        dispatch({ type: "auth.inputs", inputs: value })
+        return
+      }
       await selectMethod(store.methodIndex, value)
     }
 
@@ -710,10 +741,7 @@ function ProviderConnection(props: {
   })
 
   async function complete() {
-    const value = directory()
-    await queryClient
-      .refetchQueries(serverSync().queryOptions.providers(value ? pathKey(value) : null))
-      .catch(() => undefined)
+    await serverSDK().client.global.dispose()
     dialog.close()
     showToast({
       variant: "success",
@@ -777,7 +805,7 @@ function ProviderConnection(props: {
               listRef = ref
             }}
             items={methods}
-            key={(m) => m?.label ?? m?.type}
+            key={(m) => m?.label}
             onSelect={async (selected, index) => {
               if (!selected) return
               void selectMethod(index)
@@ -823,10 +851,13 @@ function ProviderConnection(props: {
       }
 
       setFormStore("error", undefined)
-      await serverSDK().api.integration.connect.key({
-        integrationID: props.provider,
-        location: location(),
-        key: apiKey,
+      await serverSDK().client.auth.set({
+        providerID: props.provider,
+        auth: {
+          type: "api",
+          key: apiKey,
+          ...(store.promptInputs ? { metadata: store.promptInputs } : {}),
+        },
       })
       await complete()
     }
@@ -953,13 +984,12 @@ function ProviderConnection(props: {
 
       setFormStore("error", undefined)
       const result = await serverSDK()
-        .api.integration.oauth.complete({
-          integrationID: props.provider,
-          attemptID: store.authorization!.attemptID,
-          location: location(),
+        .client.provider.oauth.callback({
+          providerID: props.provider,
+          method: store.methodIndex,
           code,
         })
-        .then(() => ({ ok: true as const }))
+        .then((value) => (value.error ? { ok: false as const, error: value.error } : { ok: true as const }))
         .catch((error) => ({ ok: false as const, error }))
       if (result.ok) {
         await complete()
@@ -1046,37 +1076,25 @@ function ProviderConnection(props: {
     })
 
     onMount(() => {
-      const poll = async () => {
-        const authorization = store.authorization
-        if (!authorization || !alive.value) return
+      void (async () => {
         const result = await serverSDK()
-          .api.integration.oauth.status({
-            integrationID: props.provider,
-            attemptID: authorization.attemptID,
-            location: location(),
+          .client.provider.oauth.callback({
+            providerID: props.provider,
+            method: store.methodIndex,
           })
-          .then((value) => ({ ok: true as const, status: value.data }))
+          .then((value) => (value.error ? { ok: false as const, error: value.error } : { ok: true as const }))
           .catch((error) => ({ ok: false as const, error }))
+
         if (!alive.value) return
+
         if (!result.ok) {
-          dispatch({ type: "auth.error", error: formatError(result.error, language.t("common.requestFailed")) })
+          const message = formatError(result.error, language.t("common.requestFailed"))
+          dispatch({ type: "auth.error", error: message })
           return
         }
-        if (result.status.status === "complete") {
-          await complete()
-          return
-        }
-        if (result.status.status === "failed") {
-          dispatch({ type: "auth.error", error: result.status.message })
-          return
-        }
-        if (result.status.status === "expired") {
-          dispatch({ type: "auth.error", error: language.t("common.requestFailed") })
-          return
-        }
-        timer.current = setTimeout(poll, 1_000)
-      }
-      void poll()
+
+        await complete()
+      })()
     })
 
     return (
@@ -1160,15 +1178,15 @@ function ProviderConnection(props: {
                 </div>
               </div>
             </Match>
-            <Match when={method()?.type === "key"}>
+            <Match when={method()?.type === "api"}>
               <ApiAuthView />
             </Match>
             <Match when={method()?.type === "oauth"}>
               <Switch>
-                <Match when={store.authorization?.mode === "code"}>
+                <Match when={store.authorization?.method === "code"}>
                   <OAuthCodeView />
                 </Match>
-                <Match when={store.authorization?.mode === "auto"}>
+                <Match when={store.authorization?.method === "auto"}>
                   <OAuthAutoView />
                 </Match>
               </Switch>

packages/app/src/components/dialog-fork.tsx

@@ -69,11 +69,15 @@ export const DialogFork: Component = () => {
     const dir = base64Encode(sdk().directory)
 
     sdk()
-      .api.session.fork({ sessionID, messageID: item.id })
+      .client.session.fork({ sessionID, messageID: item.id })
       .then((forked) => {
+        if (!forked.data) {
+          showToast({ title: language.t("common.requestFailed") })
+          return
+        }
         dialog.close()
-        prompt.set(restored, undefined, { dir, id: forked.id })
-        navigate(`/${dir}/session/${forked.id}`)
+        prompt.set(restored, undefined, { dir, id: forked.data.id })
+        navigate(`/${dir}/session/${forked.data.id}`)
       })
       .catch((err: unknown) => {
         const message = err instanceof Error ? err.message : String(err)

packages/app/src/components/dialog-select-directory-v2.tsx

@@ -28,7 +28,6 @@ import {
 } from "./directory-picker-domain"
 import "./dialog-select-directory-v2.css"
 import { DividerV2 } from "@opencode-ai/ui/v2/divider-v2"
-import { getFilename } from "@opencode-ai/core/util/path"
 
 interface DialogSelectDirectoryV2Props {
   title?: string
@@ -69,8 +68,9 @@ export function DialogSelectDirectoryV2(props: DialogSelectDirectoryV2Props) {
   const [fallbackPath] = createResource(
     () => (missingBase() ? true : undefined),
     () =>
-      sdk.api.path
+      sdk.client.path
         .get()
+        .then((result) => result.data)
         .catch(() => undefined),
     { initialValue: undefined },
   )
@@ -85,26 +85,18 @@ export function DialogSelectDirectoryV2(props: DialogSelectDirectoryV2Props) {
   )
   const search = createDirectorySearch({ sdk, home, base: () => root() || start() })
   const [suggestions] = createResource(input, async (value) => {
-    const cleaned = cleanPickerInput(value)
-    const typed = cleaned.replace(/\/+$/, "")
+    const typed = cleanPickerInput(value).replace(/\/+$/, "")
     const current = displayPickerPath(root(), value, home()).replace(/\/+$/, "")
-    if (!cleaned || (root() && typed === current)) return { query: value, items: [] }
+    if (!typed || typed === current) return { query: value, items: [] }
     const directories = (await search(value)).map((absolute) => ({ absolute, type: "directory" as const }))
     if (!policy.includeFiles) return { query: value, items: directories.slice(0, 5) }
-    const base = pickerRoot(cleaned) || root() || start()
-    if (!base) return { query: value, items: directories.slice(0, 5) }
-    const files = await sdk.api.file
-      .find({
-        location: { directory: base },
-        query: pickerFileSearchQuery(base, value, home()),
-        type: "file",
-        limit: 20,
-      })
-      .then((result) => result.data)
+    const files = await sdk.client.find
+      .files({ directory: root(), query: pickerFileSearchQuery(root(), value, home()), type: "file", limit: 20 })
+      .then((result) => result.data ?? [])
       .catch(() => [])
     const results = [
       ...directories,
-      ...files.map((entry) => ({ absolute: absoluteTreePath(base, entry.path), type: "file" as const })),
+      ...files.map((path) => ({ absolute: absoluteTreePath(root(), path), type: "file" as const })),
     ]
     return {
       query: value,
@@ -123,14 +115,9 @@ export function DialogSelectDirectoryV2(props: DialogSelectDirectoryV2Props) {
       existing ??
       loads.schedule(`${generation}:${key}`, eager ? "background" : "user", () => {
         if (!activeTreeNavigation(generation, navigation)) return Promise.resolve(undefined)
-        return sdk.api.file
-          .list({ location: { directory: absolute } })
-          .then((result) =>
-            result.data.map((entry) => ({
-              name: getFilename(entry.path.replace(/[\\/]+$/, "")),
-              type: entry.type,
-            })),
-          )
+        return sdk.client.file
+          .list({ directory: absolute, path: "" })
+          .then((result) => result.data ?? [])
           .catch(() => undefined)
       })
     listings.set(key, request)

packages/app/src/components/dialog-select-directory.tsx

@@ -60,8 +60,9 @@ export function DialogSelectDirectory(props: DialogSelectDirectoryProps) {
   const [fallbackPath] = createResource(
     () => (missingBase() ? true : undefined),
     async () => {
-      return sdk.api.path
+      return sdk.client.path
         .get()
+        .then((x) => x.data)
         .catch(() => undefined)
     },
     { initialValue: undefined },

packages/app/src/components/dialog-select-mcp.tsx

@@ -43,7 +43,7 @@ export const DialogSelectMcp: Component = () => {
         filterKeys={["name", "status"]}
         sortBy={(a, b) => a.name.localeCompare(b.name)}
         onSelect={(x) => {
-          if (!x || x.status === "pending" || toggle.isPending) return
+          if (!x || toggle.isPending) return
           toggle.mutate(x.name)
         }}
       >
@@ -76,7 +76,7 @@ export const DialogSelectMcp: Component = () => {
               <div onClick={(e) => e.stopPropagation()}>
                 <Switch
                   checked={enabled()}
-                  disabled={status() === "pending" || (toggle.isPending && toggle.variables === i.name)}
+                  disabled={toggle.isPending && toggle.variables === i.name}
                   onChange={() => {
                     if (toggle.isPending) return
                     toggle.mutate(i.name)

packages/app/src/components/directory-picker-domain.test.ts

@@ -133,10 +133,10 @@ test("scopes file autocomplete to the current browser root", () => {
 test("resolves directory autocomplete from the current browser root", async () => {
   const directories: string[] = []
   const sdk = {
-    api: {
-      file: {
-        find: (input: { location?: { directory?: string } }) => {
-          directories.push(input.location?.directory ?? "")
+    client: {
+      find: {
+        files: (input: { directory: string }) => {
+          directories.push(input.directory)
           return Promise.resolve({ data: [] })
         },
       },
@@ -152,29 +152,6 @@ test("resolves directory autocomplete from the current browser root", async () =
   expect(directories).toEqual(["/repo", "/repo/src"])
 })
 
-test("searches from an absolute root without a default base", async () => {
-  const directories: string[] = []
-  const sdk = {
-    api: {
-      file: {
-        list: (input: { location?: { directory?: string } }) => {
-          directories.push(input.location?.directory ?? "")
-          return Promise.resolve({
-            data: [
-              { path: "Users/", type: "directory" },
-              { path: "tmp/", type: "directory" },
-            ],
-          })
-        },
-      },
-    },
-  } as unknown as Parameters<typeof createDirectorySearch>[0]["sdk"]
-  const search = createDirectorySearch({ sdk, home: () => "", base: () => undefined })
-
-  expect(await search("/")).toEqual(["/Users", "/tmp"])
-  expect(directories).toEqual(["/"])
-})
-
 test("identifies the next directory level to preload", () => {
   expect(
     preloadTreeDirectories("src/", [

packages/app/src/components/directory-picker-domain.ts

@@ -326,15 +326,15 @@ export function createDirectorySearch(args: { sdk: ServerSDK; base: () => string
   let current = 0
 
   const scoped = (value: string) => {
-    const raw = normalizePickerDrive(value)
-    const root = pickerRoot(raw)
-    if (root) return { directory: trimPickerPath(root), path: raw.slice(root.length) }
     const base = args.base()
     if (!base) return
+    const raw = normalizePickerDrive(value)
     if (!raw) return { directory: trimPickerPath(base), path: "" }
     const home = args.home()
     if (raw === "~") return { directory: trimPickerPath(home || base), path: "" }
     if (raw.startsWith("~/")) return { directory: trimPickerPath(home || base), path: raw.slice(2) }
+    const root = pickerRoot(raw)
+    if (root) return { directory: trimPickerPath(root), path: raw.slice(root.length) }
     return { directory: trimPickerPath(base), path: raw }
   }
 
@@ -342,17 +342,14 @@ export function createDirectorySearch(args: { sdk: ServerSDK; base: () => string
     const key = trimPickerPath(directory)
     const existing = cache.get(key)
     if (existing) return existing
-    const request = args.sdk.api.file
-      .list({ location: { directory: key } })
-      .then((result) => result.data)
+    const request = args.sdk.client.file
+      .list({ directory: key, path: "" })
+      .then((result) => result.data ?? [])
       .catch(() => [])
       .then((nodes) =>
         nodes
           .filter((node) => node.type === "directory")
-          .map((node) => {
-            const relative = trimPickerPath(normalizePickerDrive(node.path))
-            return { name: getFilename(relative), absolute: joinPickerPath(key, relative) }
-          }),
+          .map((node) => ({ name: node.name, absolute: trimPickerPath(normalizePickerDrive(node.absolute)) })),
       )
     cache.set(key, request)
     return request
@@ -374,9 +371,9 @@ export function createDirectorySearch(args: { sdk: ServerSDK; base: () => string
     const pathInput = raw.startsWith("~") || !!pickerRoot(raw) || raw.includes("/")
     const query = normalizePickerDrive(input.path)
     if (!pathInput) {
-      const results = await args.sdk.api.file
-        .find({ location: { directory: input.directory }, query, type: "directory", limit: 50 })
-        .then((result) => result.data.map((entry) => entry.path))
+      const results = await args.sdk.client.find
+        .files({ directory: input.directory, query, type: "directory", limit: 50 })
+        .then((result) => result.data ?? [])
         .catch(() => [])
       if (!active()) return []
       return results.map((path) => joinPickerPath(input.directory, path)).slice(0, 50)

packages/app/src/components/edit-project.ts

@@ -1,7 +1,6 @@
 import { getFilename } from "@opencode-ai/core/util/path"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { useMutation } from "@tanstack/solid-query"
-import { normalizeProjectInfo } from "@/context/global-sync/utils"
 import { createMemo } from "solid-js"
 import { createStore } from "solid-js/store"
 import { useGlobal } from "@/context/global"
@@ -71,15 +70,13 @@ export function createEditProjectModel(props: { project: LocalProject; server: S
       const start = store.startup.trim()
 
       if (props.project.id && props.project.id !== "global") {
-        const project = await serverCtx().sdk.api.project.update({
+        await serverCtx().sdk.client.project.update({
           projectID: props.project.id,
+          directory: props.project.worktree,
           name,
           icon: { color: store.color || "", override: store.iconOverride || "" },
           commands: { start },
         })
-        serverCtx().sync.set("project", (items) =>
-          items.map((item) => (item.id === project.id ? normalizeProjectInfo(project) : item)),
-        )
         serverCtx().sync.project.icon(props.project.worktree, store.iconOverride || undefined)
         dialog.close()
         return

packages/app/src/components/prompt-input-v2.tsx

@@ -310,7 +310,7 @@ export function usePromptInputV2Controller(props: PromptInputV2ControllerProps):
   )
   const resources = createMemo(() =>
     Object.values(sync().data.mcp_resource).map((resource) => ({
-      id: `resource:${resource.server}:${resource.uri}`,
+      id: `resource:${resource.client}:${resource.uri}`,
       kind: "resource" as const,
       label: `@${resource.name}`,
       path: resource.uri,
@@ -327,7 +327,7 @@ export function usePromptInputV2Controller(props: PromptInputV2ControllerProps):
         source: {
           type: "resource" as const,
           text: { value: `@${resource.name}`, start: 0, end: resource.name.length + 1 },
-          clientName: resource.server,
+          clientName: resource.client,
           uri: resource.uri,
         },
       },

packages/app/src/components/prompt-input.tsx

@@ -591,7 +591,7 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
         type: "resource",
         name: resource.name,
         uri: resource.uri,
-        client: resource.server,
+        client: resource.client,
         display: resource.name,
         description: resource.description,
         mime: resource.mimeType,

packages/app/src/components/prompt-input/submit.test.ts

@@ -7,11 +7,6 @@ let createPromptSubmit: typeof import("./submit").createPromptSubmit
 
 const createdClients: string[] = []
 const createdSessions: string[] = []
-const sessionCreateInputs: Array<{
-  agent?: string
-  model?: { id: string; providerID: string; variant?: string }
-  location?: { directory: string }
-}> = []
 const enabledAutoAccept: Array<{ server: string; sessionID: string; directory: string }> = []
 const optimistic: Array<{
   directory?: string
@@ -25,14 +20,9 @@ const optimistic: Array<{
 const optimisticSeeded: boolean[] = []
 const storedSessions: Record<string, Array<{ id: string; title?: string }>> = {}
 const promoted: Array<{ directory: string; sessionID: string }> = []
-const sentShell: Array<{ sessionID: string; id?: string; command: string }> = []
+const sentShell: string[] = []
 const syncedDirectories: string[] = []
 const promotedDrafts: Array<{ draftID: string; server: string; sessionId: string }> = []
-const sentPrompts: string[] = []
-const promptInputs: unknown[] = []
-const sentCommands: unknown[] = []
-const commands: Array<{ name: string }> = []
-let serverSessionSyncs = 0
 
 let params: { id?: string } = {}
 let search: { draftId?: string } = {}
@@ -41,7 +31,7 @@ let variant: string | undefined
 let permissionServer = "server-a"
 let createSessionGate: Promise<void> | undefined
 
-let promptValue: Prompt = [{ type: "text", content: "ls", start: 0, end: 2 }]
+const promptValue: Prompt = [{ type: "text", content: "ls", start: 0, end: 2 }]
 const [promptStore, setPromptStore] = createStore<PromptStore>({
   prompt: promptValue,
   cursor: 0,
@@ -73,39 +63,23 @@ const prompt = {
 const clientFor = (directory: string) => {
   createdClients.push(directory)
   return {
-    api: {
-      session: {
-        create: async (input: (typeof sessionCreateInputs)[number]) => {
-          await createSessionGate
-          const location = input.location?.directory ?? directory
-          createdSessions.push(location)
-          sessionCreateInputs.push(input)
-          return {
-            id: `session-${createdSessions.length}`,
-            projectID: "project",
-            agent: input.agent,
-            model: input.model,
-            cost: 0,
-            tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-            time: { created: 1, updated: 1 },
-            title: `New session ${createdSessions.length}`,
-            location: { directory: location },
-          }
-        },
-        prompt: async (input: unknown) => {
-          sentPrompts.push(directory)
-          promptInputs.push(input)
-          return { data: undefined }
-        },
-        command: async (input: unknown) => {
-          sentCommands.push(input)
-        },
-        shell: async (input: { sessionID: string; id?: string; command: string }) => {
-          sentShell.push(input)
-        },
-      },
-    },
     session: {
+      create: async () => {
+        await createSessionGate
+        createdSessions.push(directory)
+        return {
+          data: {
+            id: `session-${createdSessions.length}`,
+            title: `New session ${createdSessions.length}`,
+          },
+        }
+      },
+      shell: async () => {
+        sentShell.push(directory)
+        return { data: undefined }
+      },
+      prompt: async () => ({ data: undefined }),
+      promptAsync: async () => ({ data: undefined }),
       command: async () => ({ data: undefined }),
       abort: async () => ({ data: undefined }),
     },
@@ -198,7 +172,6 @@ beforeAll(async () => {
         scope: "local",
         directory: "/repo/main",
         client: rootClient,
-        api: rootClient.api,
         url: "http://localhost:4096",
         createClient(opts: any) {
           return clientFor(opts.directory)
@@ -210,7 +183,7 @@ beforeAll(async () => {
 
   mock.module("@/context/sync", () => ({
     useSync: () => () => ({
-      data: { command: commands },
+      data: { command: [] },
       session: {
         optimistic: {
           add: (value: {
@@ -237,9 +210,6 @@ beforeAll(async () => {
       session: {
         remember: () => undefined,
         set: () => undefined,
-        sync: async () => {
-          serverSessionSyncs++
-        },
       },
       child: (directory: string) => {
         syncedDirectories.push(directory)
@@ -281,17 +251,11 @@ beforeAll(async () => {
 beforeEach(() => {
   createdClients.length = 0
   createdSessions.length = 0
-  sessionCreateInputs.length = 0
   enabledAutoAccept.length = 0
   optimistic.length = 0
   optimisticSeeded.length = 0
   promoted.length = 0
   promotedDrafts.length = 0
-  sentPrompts.length = 0
-  promptInputs.length = 0
-  sentCommands.length = 0
-  commands.length = 0
-  promptValue = [{ type: "text", content: "ls", start: 0, end: 2 }]
   params = {}
   search = {}
   sentShell.length = 0
@@ -300,7 +264,6 @@ beforeEach(() => {
   variant = undefined
   permissionServer = "server-a"
   createSessionGate = undefined
-  serverSessionSyncs = 0
   for (const key of Object.keys(storedSessions)) delete storedSessions[key]
 })
 
@@ -334,24 +297,8 @@ describe("prompt submit worktree selection", () => {
 
     expect(createdClients).toEqual(["/repo/worktree-a", "/repo/worktree-b"])
     expect(createdSessions).toEqual(["/repo/worktree-a", "/repo/worktree-b"])
-    expect(sessionCreateInputs).toEqual([
-      {
-        agent: "agent",
-        model: { id: "model", providerID: "provider", variant: undefined },
-        location: { directory: "/repo/worktree-a" },
-      },
-      {
-        agent: "agent",
-        model: { id: "model", providerID: "provider", variant: undefined },
-        location: { directory: "/repo/worktree-b" },
-      },
-    ])
-    expect(sentShell).toEqual([
-      expect.objectContaining({ sessionID: "session-1", id: expect.stringMatching(/^evt_/), command: "ls" }),
-      expect.objectContaining({ sessionID: "session-2", id: expect.stringMatching(/^evt_/), command: "ls" }),
-    ])
+    expect(sentShell).toEqual(["/repo/worktree-a", "/repo/worktree-b"])
     expect(syncedDirectories).toEqual(["/repo/worktree-a", "/repo/worktree-a", "/repo/worktree-b", "/repo/worktree-b"])
-    expect(serverSessionSyncs).toBe(0)
     expect(promoted).toEqual([
       { directory: "/repo/worktree-a", sessionID: "session-1" },
       { directory: "/repo/worktree-b", sessionID: "session-2" },
@@ -472,7 +419,6 @@ describe("prompt submit worktree selection", () => {
     const event = { preventDefault: () => undefined } as unknown as Event
 
     await submit.handleSubmit(event)
-    await Bun.sleep(0)
 
     expect(optimistic).toHaveLength(1)
     expect(optimistic[0]).toMatchObject({
@@ -481,53 +427,6 @@ describe("prompt submit worktree selection", () => {
         model: { providerID: "provider", modelID: "model", variant: "high" },
       },
     })
-    expect(sentPrompts).toEqual(["/repo/main"])
-    expect(promptInputs[0]).toMatchObject({
-      sessionID: "session-1",
-      text: "ls",
-      files: [],
-      agents: [],
-    })
-    expect((promptInputs[0] as { id?: string }).id).toStartWith("msg_")
-  })
-
-  test("submits slash commands through the current session API", async () => {
-    params = { id: "session-1" }
-    variant = "high"
-    commands.push({ name: "review" })
-    promptValue = [{ type: "text", content: "/review staged changes", start: 0, end: 22 }]
-
-    const submit = createPromptSubmit({
-      prompt,
-      info: () => ({ id: "session-1" }),
-      imageAttachments: () => [],
-      commentCount: () => 0,
-      autoAccept: () => false,
-      mode: () => "normal",
-      working: () => false,
-      editor: () => undefined,
-      queueScroll: () => undefined,
-      promptLength: (value) => value.reduce((sum, part) => sum + ("content" in part ? part.content.length : 0), 0),
-      addToHistory: () => undefined,
-      resetHistoryNavigation: () => undefined,
-      setMode: () => undefined,
-      setPopover: () => undefined,
-    })
-
-    await submit.handleSubmit({ preventDefault: () => undefined } as unknown as Event)
-
-    expect(sentCommands).toEqual([
-      {
-        sessionID: "session-1",
-        id: expect.stringMatching(/^msg_/),
-        command: "review",
-        arguments: "staged changes",
-        agent: "agent",
-        model: { id: "model", providerID: "provider", variant: "high" },
-        files: [],
-      },
-    ])
-    expect(serverSessionSyncs).toBe(0)
   })
 
   test("uses an injected model selection", async () => {
@@ -588,8 +487,7 @@ describe("prompt submit worktree selection", () => {
 
     await submit.handleSubmit(event)
 
-    expect(storedSessions["/repo/worktree-a"]).toHaveLength(1)
-    expect(storedSessions["/repo/worktree-a"]?.[0]).toMatchObject({ id: "session-1", title: "New session 1" })
+    expect(storedSessions["/repo/worktree-a"]).toEqual([{ id: "session-1", title: "New session 1" }])
     expect(optimisticSeeded).toEqual([true])
   })
 })

packages/app/src/components/prompt-input/submit.ts

@@ -20,8 +20,6 @@ import { setCursorPosition } from "./editor-dom"
 import { formatServerError } from "@/utils/server-errors"
 import { ScopedKey } from "@/utils/server-scope"
 import { createPromptSubmissionState } from "./submission-state"
-import { normalizeSessionInfo } from "@/utils/session"
-import { Event } from "@opencode-ai/schema/event"
 
 type PendingPrompt = {
   abort: AbortController
@@ -41,7 +39,7 @@ export type FollowupDraft = {
 }
 
 type FollowupSendInput = {
-  api: DirectorySDK["api"]["session"]
+  client: DirectorySDK["client"]
   serverSync: ServerSync
   sync: DirectorySync
   draft: FollowupDraft
@@ -83,21 +81,19 @@ export async function sendFollowupDraft(input: FollowupSendInput) {
         return false
       }
 
-      const messageID = Identifier.ascending("message")
-      await input.api.command({
+      await input.client.session.command({
         sessionID: input.draft.sessionID,
-        id: messageID,
         command: cmd,
         arguments: tail.join(" "),
         agent: input.draft.agent,
-        model: {
-          id: input.draft.model.modelID,
-          providerID: input.draft.model.providerID,
-          variant: input.draft.variant,
-        },
-        files: images.map((attachment) => ({
-          uri: attachment.dataUrl,
-          name: attachment.filename,
+        model: `${input.draft.model.providerID}/${input.draft.model.modelID}`,
+        variant: input.draft.variant,
+        parts: images.map((attachment) => ({
+          id: Identifier.ascending("part"),
+          type: "file" as const,
+          mime: attachment.mime,
+          url: attachment.dataUrl,
+          filename: attachment.filename,
         })),
       })
       return true
@@ -156,36 +152,13 @@ export async function sendFollowupDraft(input: FollowupSendInput) {
       return false
     }
 
-    await input.api.prompt({
+    await input.client.session.promptAsync({
       sessionID: input.draft.sessionID,
-      id: messageID,
       agent: input.draft.agent,
       model: input.draft.model,
+      messageID,
+      parts: requestParts,
       variant: input.draft.variant,
-      text: requestParts.flatMap((part) => (part.type === "text" ? [part.text] : [])).join("\n"),
-      files: requestParts.flatMap((part) => {
-        if (part.type !== "file") return []
-        const text = part.source?.text
-        return [
-          {
-            uri: part.url,
-            name: part.filename,
-            mention: text ? { start: text.start, end: text.end, text: text.value } : undefined,
-          },
-        ]
-      }),
-      agents: requestParts.flatMap((part) =>
-        part.type === "agent"
-          ? [
-              {
-                name: part.name,
-                mention: part.source
-                  ? { start: part.source.start, end: part.source.end, text: part.source.value }
-                  : undefined,
-              },
-            ]
-          : [],
-      ),
     })
     return true
   } catch (err) {
@@ -237,7 +210,6 @@ export function createPromptSubmit(input: PromptSubmitInput) {
   const pendingKey = (sessionID: string) => ScopedKey.from(sdk().scope, sessionID)
 
   const errorMessage = (err: unknown) => {
-    if (err && typeof err === "object" && "message" in err && typeof err.message === "string") return err.message
     if (err && typeof err === "object" && "data" in err) {
       const data = (err as { data?: { message?: string } }).data
       if (data?.message) return data.message
@@ -263,7 +235,9 @@ export function createPromptSubmit(input: PromptSubmitInput) {
       return Promise.resolve()
     }
     return sdk()
-      .api.session.interrupt({ sessionID })
+      .client.session.abort({
+        sessionID,
+      })
       .catch(() => {})
   }
 
@@ -390,13 +364,9 @@ export function createPromptSubmit(input: PromptSubmitInput) {
 
     let session = input.info()
     if (!session && isNewSession) {
-      const created = await sdk()
-        .api.session.create({
-          agent: currentAgent.name,
-          model: { id: currentModel.id, providerID: currentModel.provider.id, variant },
-          location: { directory: sessionDirectory },
-        })
-        .then(normalizeSessionInfo)
+      const created = await client.session
+        .create()
+        .then((x) => x.data ?? undefined)
         .catch((err) => {
           showToast({
             title: language.t("prompt.toast.sessionCreateFailed.title"),
@@ -480,14 +450,12 @@ export function createPromptSubmit(input: PromptSubmitInput) {
 
     if (mode === "shell") {
       clearInput()
-      const eventID = Event.ID.create()
-      sdk()
-        .api.session.shell({
+      client.session
+        .shell({
           sessionID: session.id,
-          id: eventID,
-          command: text,
           agent,
           model,
+          command: text,
         })
         .catch((err) => {
           showToast({
@@ -505,23 +473,23 @@ export function createPromptSubmit(input: PromptSubmitInput) {
       const customCommand = sync().data.command.find((c) => c.name === commandName)
       if (customCommand) {
         clearInput()
-        const messageID = Identifier.ascending("message")
-        serverSync().session.set("session_status", session.id, { type: "busy" })
-        sdk()
-          .api.session.command({
+        client.session
+          .command({
             sessionID: session.id,
-            id: messageID,
             command: commandName,
             arguments: args.join(" "),
             agent,
-            model: { id: model.modelID, providerID: model.providerID, variant },
-            files: images.map((attachment) => ({
-              uri: attachment.dataUrl,
-              name: attachment.filename,
+            model: `${model.providerID}/${model.modelID}`,
+            variant,
+            parts: images.map((attachment) => ({
+              id: Identifier.ascending("part"),
+              type: "file" as const,
+              mime: attachment.mime,
+              url: attachment.dataUrl,
+              filename: attachment.filename,
             })),
           })
           .catch((err) => {
-            serverSync().session.set("session_status", session.id, { type: "idle" })
             showToast({
               title: language.t("prompt.toast.commandSendFailed.title"),
               description: formatServerError(err, language.t, language.t("common.requestFailed")),
@@ -605,7 +573,7 @@ export function createPromptSubmit(input: PromptSubmitInput) {
     }
 
     void sendFollowupDraft({
-      api: sdk().api.session,
+      client,
       sync: sync(),
       serverSync: serverSync(),
       draft,

packages/app/src/components/status-popover-indicator.test.ts

@@ -26,7 +26,7 @@ describe("hasNonBlockingServiceIssue", () => {
     expect(hasNonBlockingServiceIssue({ mcp: ["failed"], lsp: [] })).toBe(true)
     expect(hasNonBlockingServiceIssue({ mcp: ["needs_auth"], lsp: [] })).toBe(true)
     expect(hasNonBlockingServiceIssue({ mcp: ["needs_client_registration"], lsp: [] })).toBe(true)
-    expect(hasNonBlockingServiceIssue({ mcp: ["connected", "pending", "disabled"], lsp: [] })).toBe(false)
+    expect(hasNonBlockingServiceIssue({ mcp: ["connected", "disabled"], lsp: [] })).toBe(false)
   })
 
   test("detects LSP failures that do not block chatting", () => {

packages/app/src/components/status-popover-indicator.ts

@@ -1,12 +1,11 @@
-import type { LspStatus } from "@opencode-ai/sdk/v2/client"
-import type { McpServer } from "@opencode-ai/client/promise"
+import type { LspStatus, McpStatus } from "@opencode-ai/sdk/v2/client"
 
 export function hasNonBlockingServiceIssue(input: {
-  mcp: Array<McpServer["status"]["status"]>
+  mcp: Array<McpStatus["status"]>
   lsp: Array<LspStatus["status"]>
 }) {
   return (
-    input.mcp.some((status) => status !== "connected" && status !== "pending" && status !== "disabled") ||
+    input.mcp.some((status) => status !== "connected" && status !== "disabled") ||
     input.lsp.some((status) => status === "error")
   )
 }

packages/app/src/components/titlebar-tab-nav.tsx

@@ -120,7 +120,8 @@ export function TabNavItem(props: {
     const ctx = serverCtx()
     const session = props.session()
     if (!ctx || !session) return
-    await ctx.sdk.api.session.rename({ sessionID: session.id, title })
+    const client = ctx.sdk.createClient({ directory: session.directory, throwOnError: true })
+    await client.session.update({ sessionID: session.id, title })
   }
 
   const closeRename = async (save: boolean) => {

packages/app/src/components/titlebar.tsx

@@ -28,7 +28,6 @@ import { tabKey, useTabs } from "@/context/tabs"
 import type { PromptSession } from "@/context/prompt"
 import "./titlebar.css"
 import { newTabTooltipKeybind } from "./command-tooltip-keybind"
-import { normalizeSessionInfo } from "@/utils/session"
 
 type TauriDesktopWindow = {
   startDragging?: () => Promise<void>
@@ -268,9 +267,9 @@ export function Titlebar(props: { update?: TitlebarUpdate; debugTools?: { visibl
                 return conn ? { route, sdk: global.ensureServerCtx(conn).sdk } : undefined
               },
               ({ route, sdk }) =>
-                sdk.api.session
+                sdk.client.session
                   .get({ sessionID: route.sessionId })
-                  .then(normalizeSessionInfo)
+                  .then((x) => x.data)
                   .catch(() => {}),
             )
 

packages/app/src/context/directory-sync.ts

@@ -5,7 +5,6 @@ import { produce, reconcile, type SetStoreFunction } from "solid-js/store"
 import type { createServerSdkContext } from "./server-sdk"
 import type { createServerSyncContextInner } from "./server-sync"
 import type { State } from "./global-sync/types"
-import { normalizeSessionInfo } from "@/utils/session"
 
 const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)
 const sessionFields = new Set([
@@ -16,7 +15,6 @@ const sessionFields = new Set([
   "permission",
   "question",
   "message",
-  "session_message",
   "part",
   "part_text_accum_delta",
 ])
@@ -116,6 +114,7 @@ export const createDirSyncContext = (
         await serverSync.session.sync(sessionID, options)
         index(sessionID)
       },
+      diff: serverSync.session.diff,
       todo: serverSync.session.todo,
       history: serverSync.session.history,
       evict(sessionID: string) {
@@ -124,9 +123,9 @@ export const createDirSyncContext = (
       fetch: async (count = 10) => {
         const [store, setStore] = current()
         setStore("limit", (value) => value + count)
-        const response = await serverSDK.api.session.list({ directory, limit: store.limit, order: "desc" })
-        const sessions = response.data
-          .map(normalizeSessionInfo)
+        const response = await client.session.list()
+        const sessions = (response.data ?? [])
+          .filter((session) => !!session?.id)
           .sort((a, b) => cmp(a.id, b.id))
           .slice(0, store.limit)
         sessions.forEach(serverSync.session.remember)
@@ -134,7 +133,7 @@ export const createDirSyncContext = (
       },
       more: createMemo(() => current()[0].session.length >= current()[0].limit),
       archive: async (sessionID: string) => {
-        await serverSDK.api.session.archive({ sessionID, directory })
+        await serverSDK.client.session.update({ sessionID, time: { archived: Date.now() } })
         current()[1](
           "session",
           produce((draft) => {

packages/app/src/context/file.tsx

@@ -204,18 +204,10 @@ export const { use: useFile, provider: FileProvider } = createSimpleContext({
     }
 
     const search = (query: string, dirs: "true" | "false", options?: { limit?: number; signal?: AbortSignal }) =>
-      serverSDK()
-        .api.file.find(
-          {
-            location: { directory: sdk().directory },
-            query,
-            type: dirs === "true" ? "directory" : "file",
-            limit: options?.limit,
-          },
-          { signal: options?.signal },
-        )
+      sdk()
+        .client.find.files({ query, dirs, limit: options?.limit }, { signal: options?.signal })
         .then(
-          (x) => x.data.map((entry) => path.normalize(entry.path)),
+          (x) => (x.data ?? []).map(path.normalize),
           (error) => {
             if (options?.signal?.aborted) throw error
             return []

packages/app/src/context/global-sync/bootstrap.test.ts

@@ -1,39 +1,14 @@
 import { describe, expect, test } from "bun:test"
 import { createStore } from "solid-js/store"
 import { QueryClient } from "@tanstack/solid-query"
-import type { Config, OpencodeClient, Project } from "@opencode-ai/sdk/v2/client"
-import type { AgentApi, CatalogApi, CommandApi, ProjectApi, ReferenceApi } from "@opencode-ai/client/promise"
+import type { Config, OpencodeClient, Project, Session } from "@opencode-ai/sdk/v2/client"
 import type { NormalizedProviderListResponse } from "@opencode-ai/session-ui/context"
-import {
-  bootstrapDirectory,
-  loadAgentsQuery,
-  loadCommands,
-  loadPathQuery,
-  loadProjectsQuery,
-  loadProvidersQuery,
-  loadReferencesQuery,
-} from "./bootstrap"
+import { bootstrapDirectory, loadPathQuery, loadProvidersQuery } from "./bootstrap"
 import type { State, VcsCache } from "./types"
+import { createServerSession } from "../server-session"
 import { ServerScope } from "@/utils/server-scope"
-import type { ServerApi } from "@/utils/server"
 
 const provider = { all: new Map(), connected: [], default: {} } satisfies NormalizedProviderListResponse
-const api = {
-  agent: { list: async () => ({ location: {}, data: [] }) },
-  provider: { list: async () => ({ location: {}, data: [] }) },
-  model: {
-    list: async () => ({ location: {}, data: [] }),
-    default: async () => ({ location: {}, data: null }),
-  },
-  permission: { request: { list: async () => ({ location: {}, data: [] }) } },
-  project: {
-    list: async () => [],
-    current: async () => ({ id: "project", directory: "/project" }),
-  },
-  question: { request: { list: async () => ({ location: {}, data: [] }) } },
-  reference: { list: async () => ({ location: {}, data: [] }) },
-  vcs: { get: async () => ({ location: {}, data: {} }) },
-} as unknown as ServerApi
 
 function directoryState() {
   return createStore<State>({
@@ -66,7 +41,6 @@ function directoryState() {
     vcs: undefined,
     limit: 5,
     message: {},
-    session_message: {},
     part: {},
     part_text_accum_delta: {},
   })
@@ -90,6 +64,7 @@ describe("bootstrapDirectory", () => {
       sdk: {
         app: { agents: async () => ({ data: [{ name: "build", mode: "primary" }] }) },
         config: { get: async () => ({ data: {} }) },
+        session: { status: async () => ({ data: {} }) },
         vcs: { get: async () => ({ data: undefined }) },
         command: {
           list: async () => {
@@ -108,7 +83,6 @@ describe("bootstrapDirectory", () => {
         },
         provider: { list: async () => ({ data: { all: [], connected: [], default: {} } }) },
       } as unknown as OpencodeClient,
-      api,
       store,
       setStore,
       vcsCache: { setStore() {} } as unknown as VcsCache,
@@ -125,108 +99,78 @@ describe("bootstrapDirectory", () => {
     expect(mcpReads).toEqual([])
   })
 
+  test("seeds session status even while warming session info stalls", async () => {
+    const [store, setStore] = directoryState()
+    const stalled = Promise.withResolvers<never>()
+    const client = {
+      app: { agents: async () => ({ data: [{ name: "build", mode: "primary" }] }) },
+      config: { get: async () => ({ data: {} }) },
+      session: {
+        status: async () => ({ data: { ses_busy: { type: "busy" } } }),
+        get: () => stalled.promise,
+      },
+      vcs: { get: async () => ({ data: undefined }) },
+      command: { list: async () => ({ data: [] }) },
+      permission: { list: async () => ({ data: [] }) },
+      question: { list: async () => ({ data: [] }) },
+      v2: { reference: { list: async () => ({ data: { data: [] } }) } },
+      mcp: { status: async () => ({ data: {} }) },
+      provider: { list: async () => ({ data: { all: [], connected: [], default: {} } }) },
+    } as unknown as OpencodeClient
+    const session = createServerSession(client)
+    const stale: Session = {
+      id: "ses_stale",
+      slug: "ses_stale",
+      projectID: "project",
+      directory: "/project",
+      title: "stale",
+      version: "1",
+      time: { created: 1, updated: 1 },
+    }
+    session.remember(stale)
+    session.set("session_status", stale.id, { type: "busy" })
+
+    await bootstrapDirectory({
+      directory: "/project",
+      scope: ServerScope.local,
+      mcp: false,
+      global: {
+        config: {} satisfies Config,
+        path: { state: "", config: "", worktree: "/project", directory: "/project", home: "/home" },
+        project: [{ id: "project", worktree: "/project" } as Project],
+        provider,
+      },
+      sdk: client,
+      store,
+      setStore,
+      vcsCache: { setStore() {} } as unknown as VcsCache,
+      loadSessions() {},
+      translate: (key) => key,
+      queryClient: new QueryClient(),
+      session,
+    })
+
+    const deadline = Date.now() + 500
+    while (!session.data.session_working("ses_busy") && Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, 10))
+    }
+
+    expect(session.data.session_status["ses_busy"]?.type).toBe("busy")
+    expect(session.data.session_status[stale.id]).toBeUndefined()
+  })
 })
 
 describe("query keys", () => {
   test("partitions identical directories by server scope", () => {
-    const client = {} as Parameters<typeof loadPathQuery>[2]
-    const api = {} as CatalogApi
+    const client = {} as OpencodeClient
     const remote = "https://debian.example" as typeof ServerScope.local
 
     expect([...loadPathQuery(ServerScope.local, "/repo", client).queryKey]).toEqual(["local", "/repo", "path"])
     expect([...loadPathQuery(remote, "/repo", client).queryKey]).toEqual(["https://debian.example", "/repo", "path"])
-    expect([...loadProvidersQuery(remote, null, api).queryKey]).toEqual(["https://debian.example", null, "providers"])
-  })
-
-  test("loads the current provider and model catalog", async () => {
-    const calls: unknown[] = []
-    const api = {
-      provider: {
-        list: async (input: unknown) => {
-          calls.push(["provider", input])
-          return { location: {}, data: [{ id: "openai", name: "OpenAI", package: "@ai-sdk/openai" }] }
-        },
-      },
-      model: {
-        list: async (input: unknown) => {
-          calls.push(["model", input])
-          return { location: {}, data: [] }
-        },
-        default: async (input: unknown) => {
-          calls.push(["default", input])
-          return { location: {}, data: null }
-        },
-      },
-    } as unknown as CatalogApi
-
-    const result = await new QueryClient().fetchQuery(loadProvidersQuery(ServerScope.local, "/repo", api))
-
-    expect(calls).toEqual([
-      ["provider", { location: { directory: "/repo" } }],
-      ["model", { location: { directory: "/repo" } }],
-      ["default", { location: { directory: "/repo" } }],
+    expect([...loadProvidersQuery(remote, null, client).queryKey]).toEqual([
+      "https://debian.example",
+      null,
+      "providers",
     ])
-    expect(result.connected).toEqual(["openai"])
-  })
-
-  test("loads agents from the current location-scoped endpoint", async () => {
-    const calls: unknown[] = []
-    const api = {
-      list: async (input: unknown) => {
-        calls.push(input)
-        return { location: {}, data: [] }
-      },
-    } as unknown as AgentApi
-
-    const result = await new QueryClient().fetchQuery(loadAgentsQuery(ServerScope.local, "/repo", api))
-
-    expect(calls).toEqual([{ location: { directory: "/repo" } }])
-    expect(result).toEqual([])
-  })
-
-  test("loads commands from the current location-scoped endpoint", async () => {
-    const calls: unknown[] = []
-    const api = {
-      list: async (input: unknown) => {
-        calls.push(input)
-        return {
-          location: {},
-          data: [{ name: "review", template: "Review files", source: "command" as const }],
-        }
-      },
-    } as unknown as CommandApi
-
-    const result = await loadCommands("/repo", api)
-
-    expect(calls).toEqual([{ location: { directory: "/repo" } }])
-    expect(result).toEqual([{ name: "review", template: "Review files", source: "command" }])
-  })
-
-  test("loads projects from the current endpoint", async () => {
-    const api = {
-      list: async () => [
-        { id: "b", worktree: "/b", time: { created: 1, updated: 1 }, sandboxes: [] },
-        { id: "a", worktree: "/a", time: { created: 1, updated: 1 }, sandboxes: [] },
-      ],
-    } as unknown as ProjectApi
-
-    const result = await new QueryClient().fetchQuery(loadProjectsQuery(ServerScope.local, api))
-
-    expect(result.map((project) => project.id)).toEqual(["a", "b"])
-  })
-
-  test("loads references from the current location-scoped endpoint", async () => {
-    const calls: unknown[] = []
-    const api = {
-      list: async (input: unknown) => {
-        calls.push(input)
-        return { location: {}, data: [{ name: "AGENTS.md", path: "/repo/AGENTS.md", source: "instructions" }] }
-      },
-    } as unknown as ReferenceApi
-
-    const result = await new QueryClient().fetchQuery(loadReferencesQuery(ServerScope.local, "/repo", api))
-
-    expect(calls).toEqual([{ location: { directory: "/repo" } }])
-    expect(result).toHaveLength(1)
   })
 })

packages/app/src/context/global-sync/bootstrap.ts

@@ -9,26 +9,6 @@ import type {
   ReferenceInfo,
   Session,
 } from "@opencode-ai/sdk/v2/client"
-import type {
-  AgentListInput,
-  AgentListOutput,
-  CatalogApi,
-  CommandInfo,
-  CommandListInput,
-  CommandListOutput,
-  McpApi,
-  PathGetInput,
-  PathGetOutput,
-  PermissionApi,
-  ProjectCurrentInput,
-  ProjectCurrentOutput,
-  ProjectListOutput,
-  QuestionApi,
-  ReferenceListInput,
-  ReferenceListOutput,
-  SessionApi,
-  VcsApi,
-} from "@opencode-ai/client/promise"
 import { showToast } from "@/utils/toast"
 import { getFilename } from "@opencode-ai/core/util/path"
 import { retry } from "@opencode-ai/core/util/retry"
@@ -36,20 +16,12 @@ import { batch } from "solid-js"
 import { produce, reconcile, type SetStoreFunction, type Store } from "solid-js/store"
 import type { State, VcsCache } from "./types"
 import type { ServerSession } from "../server-session"
-import {
-  cmp,
-  normalizeAgentList,
-  normalizePermissionRequest,
-  normalizeProjectInfo,
-  normalizeProviderList,
-} from "./utils"
+import { cmp, normalizeAgentList, normalizeProviderList } from "./utils"
 import { formatServerError } from "@/utils/server-errors"
 import { QueryClient, queryOptions } from "@tanstack/solid-query"
 import { loadMcpQuery, loadMcpResourcesQuery } from "../server-sync"
 import { NormalizedProviderListResponse } from "@opencode-ai/session-ui/context"
 import { ScopedKey, type ServerScope } from "@/utils/server-scope"
-import { normalizeSessionInfo } from "@/utils/session"
-import type { ServerProtocol } from "@/utils/server-protocol"
 
 type GlobalStore = {
   ready: boolean
@@ -116,25 +88,15 @@ export const loadGlobalConfigQuery = (scope: ServerScope, sdk: OpencodeClient) =
     queryFn: () => retry(() => sdk.global.config.get().then((x) => x.data!)),
   })
 
-type ProjectApi = {
-  readonly list: () => Promise<ProjectListOutput>
-  readonly current: (input?: ProjectCurrentInput) => Promise<ProjectCurrentOutput>
-}
-
-type PathApi = {
-  readonly get: (input?: PathGetInput) => Promise<PathGetOutput>
-}
-
-export const loadProjectsQuery = (scope: ServerScope, api: ProjectApi) =>
+export const loadProjectsQuery = (scope: ServerScope, sdk: OpencodeClient) =>
   queryOptions({
     queryKey: [scope, "project"],
     queryFn: () =>
       retry(() =>
-        api.list().then((projects) => {
-          return projects
+        sdk.project.list().then((x) => {
+          return (x.data ?? [])
             .filter((p) => !!p?.id)
             .filter((p) => !!p.worktree && !p.worktree.includes("opencode-test"))
-            .map(normalizeProjectInfo)
             .slice()
             .sort((a, b) => cmp(a.id, b.id))
         }),
@@ -143,8 +105,6 @@ export const loadProjectsQuery = (scope: ServerScope, api: ProjectApi) =>
 
 export async function bootstrapGlobal(input: {
   serverSDK: OpencodeClient
-  serverAPI: CatalogApi & { readonly path: PathApi; readonly project: ProjectApi }
-  protocol?: Promise<ServerProtocol>
   scope: ServerScope
   requestFailedTitle: string
   translate: (key: string, vars?: Record<string, string | number>) => string
@@ -154,14 +114,11 @@ export async function bootstrapGlobal(input: {
 }) {
   const slow = [
     () => input.queryClient.fetchQuery(loadGlobalConfigQuery(input.scope, input.serverSDK)),
-    () =>
-      input.queryClient.fetchQuery(
-        loadProvidersQuery(input.scope, null, input.serverAPI, input.serverSDK, input.protocol),
-      ),
-    () => input.queryClient.fetchQuery(loadPathQuery(input.scope, null, input.serverAPI.path)),
+    () => input.queryClient.fetchQuery(loadProvidersQuery(input.scope, null, input.serverSDK)),
+    () => input.queryClient.fetchQuery(loadPathQuery(input.scope, null, input.serverSDK)),
     () =>
       input.queryClient
-        .fetchQuery(loadProjectsQuery(input.scope, input.serverAPI.project))
+        .fetchQuery(loadProjectsQuery(input.scope, input.serverSDK))
         .then((data) => input.setGlobalStore("project", data)),
   ]
   await runAll(slow)
@@ -205,117 +162,44 @@ function warmSessions(input: {
   ids: string[]
   store: Store<State>
   setStore: SetStoreFunction<State>
-  api: SessionApi
+  sdk: OpencodeClient
 }) {
   const known = new Set(input.store.session.map((item) => item.id))
   const ids = [...new Set(input.ids)].filter((id) => !!id && !known.has(id))
   if (ids.length === 0) return Promise.resolve()
   return Promise.all(
     ids.map((sessionID) =>
-      retry(() => input.api.get({ sessionID })).then((session) =>
-        mergeSession(input.setStore, normalizeSessionInfo(session)),
-      ),
+      retry(() => input.sdk.session.get({ sessionID })).then((x) => {
+        const session = x.data
+        if (!session?.id) return
+        mergeSession(input.setStore, session)
+      }),
     ),
   ).then(() => undefined)
 }
 
-export const loadProvidersQuery = (
-  scope: ServerScope,
-  directory: string | null,
-  sdk: CatalogApi,
-  legacy?: OpencodeClient,
-  protocol?: Promise<ServerProtocol>,
-) =>
+export const loadProvidersQuery = (scope: ServerScope, directory: string | null, sdk: OpencodeClient) =>
   queryOptions({
     queryKey: [scope, directory, "providers"],
-    queryFn: () =>
-      retry(async () => {
-        if ((await protocol) === "v1" && legacy) {
-          const result = await legacy.provider.list()
-          return normalizeProviderList(result.data!)
-        }
-        const location = directory ? { location: { directory } } : undefined
-        const [providers, models, defaultModel] = await Promise.all([
-          sdk.provider.list(location),
-          sdk.model.list(location),
-          sdk.model.default(location),
-        ])
-        return normalizeProviderList(providers.data, models.data, defaultModel.data)
-      }),
+    queryFn: () => retry(() => sdk.provider.list().then((x) => normalizeProviderList(x.data!))),
   })
 
-type AgentListApi = {
-  readonly list: (input?: AgentListInput) => Promise<AgentListOutput>
-}
-
-type CommandListApi = {
-  readonly list: (input?: CommandListInput) => Promise<CommandListOutput>
-}
-
-type ReferenceListApi = {
-  readonly list: (input?: ReferenceListInput) => Promise<ReferenceListOutput>
-}
-
-export const loadAgentsQuery = (
-  scope: ServerScope,
-  directory: string,
-  sdk: AgentListApi,
-  legacy?: OpencodeClient,
-  protocol?: Promise<ServerProtocol>,
-) =>
+export const loadAgentsQuery = (scope: ServerScope, directory: string | null, sdk: OpencodeClient) =>
   queryOptions({
     queryKey: [scope, directory, "agents"],
-    queryFn: () =>
-      retry(async () => {
-        if ((await protocol) === "v1" && legacy) return normalizeAgentList((await legacy.app.agents()).data ?? [])
-        return sdk.list({ location: { directory } }).then((result) => normalizeAgentList(result.data))
-      }),
+    queryFn: () => retry(() => sdk.app.agents().then((x) => normalizeAgentList(x.data))),
   })
 
-export const loadCommands = (
-  directory: string,
-  api: CommandListApi,
-  legacy?: OpencodeClient,
-  protocol?: Promise<ServerProtocol>,
-): Promise<CommandInfo[]> =>
-  retry(async () => {
-    if ((await protocol) === "v1" && legacy) {
-      return ((await legacy.command.list()).data ?? []).map((command) => {
-        const [providerID, id] = command.model?.split("/") ?? []
-        return {
-          name: command.name,
-          template: command.template,
-          description: command.description,
-          agent: command.agent,
-          model: providerID && id ? { providerID, id } : undefined,
-          subtask: command.subtask,
-          source: command.source === "skill" ? undefined : command.source,
-        }
-      })
-    }
-    return api.list({ location: { directory } }).then((result) => result.data)
-  })
-
-export const loadPathQuery = (scope: ServerScope, directory: string | null, api: PathApi) =>
+export const loadPathQuery = (scope: ServerScope, directory: string | null, sdk: OpencodeClient) =>
   queryOptions<Path>({
     queryKey: [scope, directory, "path"],
-    queryFn: () => retry(() => api.get(directory ? { location: { directory } } : undefined)),
+    queryFn: () => retry(() => sdk.path.get().then((x) => x.data!)),
   })
 
-export const loadReferencesQuery = (
-  scope: ServerScope,
-  directory: string,
-  api: ReferenceListApi,
-  legacy?: OpencodeClient,
-  protocol?: Promise<ServerProtocol>,
-) =>
+export const loadReferencesQuery = (scope: ServerScope, directory: string, sdk: OpencodeClient) =>
   queryOptions<ReferenceInfo[]>({
     queryKey: [scope, directory, "references"] as const,
-    queryFn: () =>
-      retry(async () => {
-        if ((await protocol) === "v1" && legacy) return (await legacy.v2.reference.list()).data?.data ?? []
-        return api.list({ location: { directory } }).then((result) => result.data)
-      }).catch(() => []),
+    queryFn: () => retry(() => sdk.v2.reference.list().then((x) => x.data?.data ?? [])).catch(() => []),
     placeholderData: [],
   })
 
@@ -324,18 +208,6 @@ export async function bootstrapDirectory(input: {
   scope: ServerScope
   mcp: boolean
   sdk: OpencodeClient
-  api: CatalogApi & {
-    readonly agent: AgentListApi
-    readonly command: CommandListApi
-    readonly mcp: McpApi
-    readonly path: PathApi
-    readonly permission: PermissionApi
-    readonly project: ProjectApi
-    readonly question: QuestionApi
-    readonly reference: ReferenceListApi
-    readonly session: SessionApi
-    readonly vcs: VcsApi
-  }
   store: Store<State>
   setStore: SetStoreFunction<State>
   vcsCache: VcsCache
@@ -349,7 +221,6 @@ export async function bootstrapDirectory(input: {
   }
   queryClient: QueryClient
   session?: ServerSession
-  protocol?: Promise<ServerProtocol>
 }) {
   const loading = input.store.status !== "complete"
   const seededProject = projectID(input.directory, input.global.project)
@@ -369,55 +240,66 @@ export async function bootstrapDirectory(input: {
       () => Promise.resolve(input.loadSessions(input.directory)),
       () =>
         input.queryClient
-          .ensureQueryData(loadAgentsQuery(input.scope, input.directory, input.api.agent, input.sdk, input.protocol))
+          .ensureQueryData(loadAgentsQuery(input.scope, input.directory, input.sdk))
           .then((data) => input.setStore("agent", data)),
       () =>
         retry(() => input.sdk.config.get().then((x) => input.setStore("config", reconcile(x.data!, { merge: false })))),
-      !seededProject &&
-        (() =>
-          retry(() => input.api.project.current({ location: { directory: input.directory } })).then((project) =>
-            input.setStore("project", project.id),
-          )),
-      !seededPath &&
-        (() =>
-          input.queryClient
-            .ensureQueryData(loadPathQuery(input.scope, input.directory, input.api.path))
-            .then((data) => {
-              const next = projectID(data.directory ?? input.directory, input.global.project)
-              if (next) input.setStore("project", next)
-            })),
       () =>
         retry(() =>
-          input.api.vcs.get({ location: { directory: input.directory } }).then((result) => {
-            const next = { branch: result.data.branch, default_branch: result.data.defaultBranch }
+          input.sdk.session.status().then(async (x) => {
+            if (!input.session) {
+              input.setStore("session_status", x.data!)
+              return
+            }
+            const statuses = x.data ?? {}
+            input.session.set(
+              "session_status",
+              produce((draft) => {
+                for (const sessionID of Object.keys(draft)) {
+                  if (statuses[sessionID]) continue
+                  if (input.session?.get(sessionID)?.directory === input.directory) delete draft[sessionID]
+                }
+              }),
+            )
+            for (const [sessionID, status] of Object.entries(statuses)) {
+              input.session.set("session_status", sessionID, reconcile(status))
+            }
+            // Warm session info only after seeding statuses so a stalled session
+            // fetch cannot park busy indicators behind it, mirroring how live
+            // session.status events apply first and resolve info in the background.
+            await Promise.all(
+              Object.keys(statuses).map((sessionID) => input.session!.resolve(sessionID).catch(() => undefined)),
+            )
+          }),
+        ),
+      !seededProject &&
+        (() => retry(() => input.sdk.project.current()).then((x) => input.setStore("project", x.data!.id))),
+      !seededPath &&
+        (() =>
+          input.queryClient.ensureQueryData(loadPathQuery(input.scope, input.directory, input.sdk)).then((data) => {
+            const next = projectID(data.directory ?? input.directory, input.global.project)
+            if (next) input.setStore("project", next)
+          })),
+      () =>
+        retry(() =>
+          input.sdk.vcs.get().then((x) => {
+            const next = x.data ?? input.store.vcs
             input.setStore("vcs", next)
             if (next) input.vcsCache.setStore("value", next)
           }),
         ),
-      input.mcp &&
-        (() =>
-          loadCommands(input.directory, input.api.command, input.sdk, input.protocol).then((commands) =>
-            input.setStore("command", commands),
-          )),
-      () =>
-        input.queryClient.fetchQuery(
-          loadReferencesQuery(input.scope, input.directory, input.api.reference, input.sdk, input.protocol),
-        ),
+      input.mcp && (() => retry(() => input.sdk.command.list().then((x) => input.setStore("command", x.data ?? [])))),
+      () => input.queryClient.fetchQuery(loadReferencesQuery(input.scope, input.directory, input.sdk)),
       () =>
         retry(() =>
-          (async () => {
-            if ((await input.protocol) === "v1") return (await input.sdk.permission.list()).data ?? []
-            return input.api.permission.request
-              .list({ location: { directory: input.directory } })
-              .then((result) => result.data.map(normalizePermissionRequest))
-          })().then((permissions) => {
-            const ids = permissions.map((permission) => permission.sessionID)
+          input.sdk.permission.list().then((x) => {
+            const ids = (x.data ?? []).map((perm) => perm?.sessionID).filter((id): id is string => !!id)
             const grouped = groupBySession(
-              permissions.filter((permission) => !!permission.id && !!permission.sessionID),
+              (x.data ?? []).filter((perm): perm is PermissionRequest => !!perm?.id && !!perm.sessionID),
             )
             const warm = input.session
               ? Promise.all(ids.map((sessionID) => input.session!.resolve(sessionID))).then(() => undefined)
-              : warmSessions({ ids, store: input.store, setStore: input.setStore, api: input.api.session })
+              : warmSessions({ ids, store: input.store, setStore: input.setStore, sdk: input.sdk })
             return warm.then(() =>
               batch(() => {
                 const current = input.session?.data.permission ?? input.store.permission
@@ -441,19 +323,12 @@ export async function bootstrapDirectory(input: {
         ),
       () =>
         retry(() =>
-          (async () => {
-            if ((await input.protocol) === "v1") return (await input.sdk.question.list()).data ?? []
-            return input.api.question.request
-              .list({ location: { directory: input.directory } })
-              .then((result) => result.data)
-          })().then((questions) => {
-            const ids = questions.map((question) => question.sessionID)
-            const grouped = groupBySession(
-              questions.filter((question) => !!question.id && !!question.sessionID) as QuestionRequest[],
-            )
+          input.sdk.question.list().then((x) => {
+            const ids = (x.data ?? []).map((question) => question?.sessionID).filter((id): id is string => !!id)
+            const grouped = groupBySession((x.data ?? []).filter((q): q is QuestionRequest => !!q?.id && !!q.sessionID))
             const warm = input.session
               ? Promise.all(ids.map((sessionID) => input.session!.resolve(sessionID))).then(() => undefined)
-              : warmSessions({ ids, store: input.store, setStore: input.setStore, api: input.api.session })
+              : warmSessions({ ids, store: input.store, setStore: input.setStore, sdk: input.sdk })
             return warm.then(() =>
               batch(() => {
                 const current = input.session?.data.question ?? input.store.question
@@ -476,20 +351,17 @@ export async function bootstrapDirectory(input: {
           }),
         ),
       () => Promise.resolve(input.loadSessions(input.directory)),
-      input.mcp && (() => input.queryClient.fetchQuery(loadMcpQuery(input.scope, input.directory, input.api.mcp))),
-      input.mcp &&
-        (() => input.queryClient.fetchQuery(loadMcpResourcesQuery(input.scope, input.directory, input.api.mcp))),
+      input.mcp && (() => input.queryClient.fetchQuery(loadMcpQuery(input.scope, input.directory, input.sdk))),
+      input.mcp && (() => input.queryClient.fetchQuery(loadMcpResourcesQuery(input.scope, input.directory, input.sdk))),
       () =>
-        input.queryClient
-          .fetchQuery(loadProvidersQuery(input.scope, input.directory, input.api, input.sdk, input.protocol))
-          .catch((err) => {
-            const project = getFilename(input.directory)
-            showToast({
-              variant: "error",
-              title: input.translate("toast.project.reloadFailed.title", { project }),
-              description: formatServerError(err, input.translate),
-            })
-          }),
+        input.queryClient.fetchQuery(loadProvidersQuery(input.scope, input.directory, input.sdk)).catch((err) => {
+          const project = getFilename(input.directory)
+          showToast({
+            variant: "error",
+            title: input.translate("toast.project.reloadFailed.title", { project }),
+            description: formatServerError(err, input.translate),
+          })
+        }),
     ].filter(Boolean) as (() => Promise<any>)[]
 
     await waitForPaint()

packages/app/src/context/global-sync/child-store.ts

@@ -255,7 +255,6 @@ export function createChildStoreManager(input: {
             vcs: vcsStore.value,
             limit: 5,
             message: {},
-            session_message: {},
             part: {},
             part_text_accum_delta: {},
           })

packages/app/src/context/global-sync/event-reducer.test.ts

@@ -80,7 +80,6 @@ const baseState = (input: Partial<State> = {}) =>
     vcs: undefined,
     limit: 10,
     message: {},
-    session_message: {},
     part: {},
     part_text_accum_delta: {},
     ...input,
@@ -262,8 +261,8 @@ describe("applyDirectoryEvent", () => {
 
   test("cleans session caches when deleted and decrements only root totals", () => {
     const cases = [
-      { info: rootSession({ id: "ses_1" }), expectedTotal: 1, current: false },
-      { info: rootSession({ id: "ses_2", parentID: "ses_1" }), expectedTotal: 2, current: true },
+      { info: rootSession({ id: "ses_1" }), expectedTotal: 1 },
+      { info: rootSession({ id: "ses_2", parentID: "ses_1" }), expectedTotal: 2 },
     ]
 
     for (const item of cases) {
@@ -287,10 +286,7 @@ describe("applyDirectoryEvent", () => {
       )
 
       applyDirectoryEvent({
-        event: {
-          type: "session.deleted",
-          properties: item.current ? { sessionID: item.info.id } : { info: item.info },
-        },
+        event: { type: "session.deleted", properties: { info: item.info } },
         store,
         setStore,
         push() {},

packages/app/src/context/global-sync/event-reducer.ts

@@ -8,9 +8,9 @@ import type {
   QuestionRequest,
   Session,
   SessionStatus,
+  SnapshotFileDiff,
   Todo,
 } from "@opencode-ai/sdk/v2/client"
-import type { FileDiffInfo } from "@opencode-ai/client/promise"
 import type { State, VcsCache } from "./types"
 import { trimSessions } from "./session-trim"
 import { dropSessionCaches } from "./session-cache"
@@ -171,11 +171,8 @@ export function applyDirectoryEvent(input: {
       break
     }
     case "session.deleted": {
-      const properties = event.properties as { sessionID?: string; info?: Session }
-      const sessionID = properties.info?.id ?? properties.sessionID
-      if (!sessionID) break
-      const result = Binary.search(input.store.session, sessionID, (s) => s.id)
-      const info = properties.info ?? (result.found ? input.store.session[result.index] : undefined)
+      const info = (event.properties as { info: Session }).info
+      const result = Binary.search(input.store.session, info.id, (s) => s.id)
       if (result.found) {
         input.setStore(
           "session",
@@ -184,77 +181,14 @@ export function applyDirectoryEvent(input: {
           }),
         )
       }
-      cleanupSessionCaches(input.setStore, sessionID, input.setSessionTodo)
-      if (info?.parentID) break
+      cleanupSessionCaches(input.setStore, info.id, input.setSessionTodo)
+      if (info.parentID) break
       input.setStore("sessionTotal", (value) => Math.max(0, value - 1))
       break
     }
-    case "session.renamed": {
-      const properties = event.properties as { sessionID: string; title: string }
-      const result = Binary.search(input.store.session, properties.sessionID, (session) => session.id)
-      if (!result.found) break
-      input.setStore("session", result.index, (session) => ({
-        ...session,
-        title: properties.title,
-        time: { ...session.time, updated: Date.now() },
-      }))
-      break
-    }
-    case "session.usage.updated": {
-      const properties = event.properties as Pick<Session, "cost" | "tokens"> & { sessionID: string }
-      const result = Binary.search(input.store.session, properties.sessionID, (session) => session.id)
-      if (!result.found) break
-      input.setStore("session", result.index, (session) => ({
-        ...session,
-        cost: properties.cost,
-        tokens: properties.tokens,
-      }))
-      break
-    }
-    case "session.archived": {
-      const properties = event.properties as { sessionID: string }
-      const result = Binary.search(input.store.session, properties.sessionID, (session) => session.id)
-      if (!result.found) break
-      const info = input.store.session[result.index]
-      input.setStore(
-        "session",
-        produce((draft) => void draft.splice(result.index, 1)),
-      )
-      cleanupSessionCaches(input.setStore, properties.sessionID)
-      if (!info?.parentID) input.setStore("sessionTotal", (value) => Math.max(0, value - 1))
-      break
-    }
-    case "session.moved": {
-      const properties = event.properties as {
-        sessionID: string
-        location: { directory: string; workspaceID?: string }
-        projectID?: string
-        subpath?: string
-      }
-      const result = Binary.search(input.store.session, properties.sessionID, (session) => session.id)
-      if (!result.found) break
-      if (properties.location.directory === input.directory) {
-        input.setStore("session", result.index, (session) => ({
-          ...session,
-          projectID: properties.projectID ?? session.projectID,
-          workspaceID: properties.location.workspaceID,
-          directory: properties.location.directory,
-          path: properties.subpath,
-          time: { ...session.time, updated: Date.now() },
-        }))
-        break
-      }
-      const info = input.store.session[result.index]
-      input.setStore(
-        "session",
-        produce((draft) => void draft.splice(result.index, 1)),
-      )
-      if (!info?.parentID) input.setStore("sessionTotal", (value) => Math.max(0, value - 1))
-      break
-    }
     case "session.diff": {
-      const props = event.properties as { sessionID: string; diff: FileDiffInfo[] }
-      input.setStore("session_diff", props.sessionID, reconcile(list(props.diff) as FileDiffInfo[], { key: "file" }))
+      const props = event.properties as { sessionID: string; diff: SnapshotFileDiff[] }
+      input.setStore("session_diff", props.sessionID, reconcile(list(props.diff), { key: "file" }))
       break
     }
     case "todo.updated": {

packages/app/src/context/global-sync/mcp.test.ts

@@ -31,24 +31,4 @@ describe("toggleMcp", () => {
     await toggleMcp(input("disabled"))
     expect(calls).toEqual(["connect", "refresh"])
   })
-
-  test("does not toggle a server while its connection is pending", async () => {
-    const calls: string[] = []
-    await toggleMcp({
-      status: "pending",
-      connect: async () => {
-        calls.push("connect")
-      },
-      disconnect: async () => {
-        calls.push("disconnect")
-      },
-      authenticate: async () => {
-        calls.push("authenticate")
-      },
-      refresh: async () => {
-        calls.push("refresh")
-      },
-    })
-    expect(calls).toEqual([])
-  })
 })

packages/app/src/context/global-sync/mcp.ts

@@ -1,13 +1,12 @@
-import type { McpServer } from "@opencode-ai/client/promise"
+import type { McpStatus } from "@opencode-ai/sdk/v2/client"
 
 export async function toggleMcp(input: {
-  status: McpServer["status"]["status"]
+  status: McpStatus["status"]
   connect: () => Promise<void>
   disconnect: () => Promise<void>
   authenticate: () => Promise<void>
   refresh: () => Promise<void>
 }) {
-  if (input.status === "pending") return
   await {
     connected: input.disconnect,
     needs_auth: input.authenticate,

packages/app/src/context/global-sync/session-cache.test.ts

@@ -1,6 +1,13 @@
 import { describe, expect, test } from "bun:test"
-import type { Message, Part, PermissionRequest, QuestionRequest, SessionStatus, Todo } from "@opencode-ai/sdk/v2/client"
-import type { FileDiffInfo } from "@opencode-ai/client/promise"
+import type {
+  Message,
+  Part,
+  PermissionRequest,
+  QuestionRequest,
+  SessionStatus,
+  SnapshotFileDiff,
+  Todo,
+} from "@opencode-ai/sdk/v2/client"
 import { dropSessionCaches, pickSessionCacheEvictions } from "./session-cache"
 
 const msg = (id: string, sessionID: string) =>
@@ -26,10 +33,9 @@ describe("app session cache", () => {
   test("dropSessionCaches clears orphaned parts without message rows", () => {
     const store: {
       session_status: Record<string, SessionStatus | undefined>
-      session_diff: Record<string, FileDiffInfo[] | undefined>
+      session_diff: Record<string, SnapshotFileDiff[] | undefined>
       todo: Record<string, Todo[] | undefined>
       message: Record<string, Message[] | undefined>
-      session_message: Record<string, never[] | undefined>
       part: Record<string, Part[] | undefined>
       permission: Record<string, PermissionRequest[] | undefined>
       question: Record<string, QuestionRequest[] | undefined>
@@ -39,7 +45,6 @@ describe("app session cache", () => {
       session_diff: { ses_1: [] },
       todo: { ses_1: [] as Todo[] },
       message: {},
-      session_message: {},
       part: { msg_1: [part("prt_1", "ses_1", "msg_1")] },
       permission: { ses_1: [] as PermissionRequest[] },
       question: { ses_1: [] as QuestionRequest[] },
@@ -62,10 +67,9 @@ describe("app session cache", () => {
     const m = msg("msg_1", "ses_1")
     const store: {
       session_status: Record<string, SessionStatus | undefined>
-      session_diff: Record<string, FileDiffInfo[] | undefined>
+      session_diff: Record<string, SnapshotFileDiff[] | undefined>
       todo: Record<string, Todo[] | undefined>
       message: Record<string, Message[] | undefined>
-      session_message: Record<string, never[] | undefined>
       part: Record<string, Part[] | undefined>
       permission: Record<string, PermissionRequest[] | undefined>
       question: Record<string, QuestionRequest[] | undefined>
@@ -75,7 +79,6 @@ describe("app session cache", () => {
       session_diff: {},
       todo: {},
       message: { ses_1: [m] },
-      session_message: {},
       part: { [m.id]: [part("prt_1", "ses_1", m.id)] },
       permission: {},
       question: {},

packages/app/src/context/global-sync/session-cache.ts

@@ -1,15 +1,20 @@
-import type { Message, Part, PermissionRequest, QuestionRequest, SessionStatus, Todo } from "@opencode-ai/sdk/v2/client"
-import type { FileDiffInfo } from "@opencode-ai/client/promise"
-import type { SessionMessageInfo } from "@opencode-ai/client/promise"
+import type {
+  Message,
+  Part,
+  PermissionRequest,
+  QuestionRequest,
+  SessionStatus,
+  SnapshotFileDiff,
+  Todo,
+} from "@opencode-ai/sdk/v2/client"
 
 export const SESSION_CACHE_LIMIT = 40
 
 type SessionCache = {
   session_status: Record<string, SessionStatus | undefined>
-  session_diff: Record<string, FileDiffInfo[] | undefined>
+  session_diff: Record<string, SnapshotFileDiff[] | undefined>
   todo: Record<string, Todo[] | undefined>
   message: Record<string, Message[] | undefined>
-  session_message: Record<string, SessionMessageInfo[] | undefined>
   part: Record<string, Part[] | undefined>
   permission: Record<string, PermissionRequest[] | undefined>
   question: Record<string, QuestionRequest[] | undefined>
@@ -32,7 +37,6 @@ export function dropSessionCaches(store: SessionCache, sessionIDs: Iterable<stri
   for (const sessionID of stale) {
     delete store.message[sessionID]
     delete store.todo[sessionID]
-    delete store.session_message[sessionID]
     delete store.session_diff[sessionID]
     delete store.session_status[sessionID]
     delete store.permission[sessionID]

packages/app/src/context/global-sync/session-load.ts

@@ -1,28 +1,20 @@
-import type { SessionApi } from "@opencode-ai/client/promise"
-import { normalizeSessionInfo } from "@/utils/session"
-import type { OpencodeClient } from "@opencode-ai/sdk/v2/client"
+import type { RootLoadArgs } from "./types"
 
-export async function loadRootSessions(input: { api: Pick<SessionApi, "list">; directory: string; limit: number }) {
-  const result = await input.api.list({
-    directory: input.directory,
-    parentID: null,
-    limit: input.limit,
-    order: "desc",
-  })
-  return {
-    data: result.data.map(normalizeSessionInfo),
-    limit: input.limit,
-    limited: true,
-  } as const
-}
-
-export async function loadRootSessionsV1(input: { client: OpencodeClient; directory: string; limit: number }) {
+export async function loadRootSessionsWithFallback(input: RootLoadArgs) {
   try {
-    const result = await input.client.session.list({ directory: input.directory, roots: true, limit: input.limit })
-    return { data: result.data, limit: input.limit, limited: true } as const
+    const result = await input.list({ directory: input.directory, roots: true, limit: input.limit })
+    return {
+      data: result.data,
+      limit: input.limit,
+      limited: true,
+    } as const
   } catch {
-    const result = await input.client.session.list({ directory: input.directory, roots: true })
-    return { data: result.data, limit: input.limit, limited: false } as const
+    const result = await input.list({ directory: input.directory, roots: true })
+    return {
+      data: result.data,
+      limit: input.limit,
+      limited: false,
+    } as const
   }
 }
 

packages/app/src/context/global-sync/types.ts

@@ -1,7 +1,10 @@
 import type {
   Agent,
+  Command,
   Config,
   LspStatus,
+  McpResource,
+  McpStatus,
   Message,
   Part,
   Path,
@@ -10,12 +13,11 @@ import type {
   ReferenceInfo,
   Session,
   SessionStatus,
+  SnapshotFileDiff,
   Todo,
   VcsInfo,
 } from "@opencode-ai/sdk/v2/client"
-import type { FileDiffInfo } from "@opencode-ai/client/promise"
 import { NormalizedProviderListResponse } from "@opencode-ai/session-ui/context"
-import type { CommandInfo, McpResource, McpServer, SessionMessageInfo } from "@opencode-ai/client/promise"
 import type { Accessor } from "solid-js"
 import type { SetStoreFunction, Store } from "solid-js/store"
 
@@ -33,7 +35,7 @@ export type ProjectMeta = {
 export type State = {
   status: "loading" | "partial" | "complete"
   agent: Agent[]
-  command: CommandInfo[]
+  command: Command[]
   reference: ReferenceInfo[]
   project: string
   projectMeta: ProjectMeta | undefined
@@ -49,7 +51,7 @@ export type State = {
   }
   session_working(id: string): boolean
   session_diff: {
-    [sessionID: string]: FileDiffInfo[]
+    [sessionID: string]: SnapshotFileDiff[]
   }
   todo: {
     [sessionID: string]: Todo[]
@@ -62,7 +64,7 @@ export type State = {
   }
   mcp_ready: boolean
   mcp: {
-    [name: string]: McpServer["status"]
+    [name: string]: McpStatus
   }
   mcp_resource: {
     [key: string]: McpResource
@@ -74,9 +76,6 @@ export type State = {
   message: {
     [sessionID: string]: Message[]
   }
-  session_message: {
-    [sessionID: string]: SessionMessageInfo[]
-  }
   part: {
     [messageID: string]: Part[]
   }
@@ -129,6 +128,18 @@ export type DisposeCheck = {
   loadingSessions: boolean
 }
 
+export type RootLoadArgs = {
+  directory: string
+  limit: number
+  list: (query: { directory: string; roots: true; limit?: number }) => Promise<{ data?: Session[] }>
+}
+
+export type RootLoadResult = {
+  data?: Session[]
+  limit: number
+  limited: boolean
+}
+
 export const MAX_DIR_STORES = 30
 export const DIR_IDLE_TTL_MS = 20 * 60 * 1000
 export const SESSION_RECENT_WINDOW = 4 * 60 * 60 * 1000

packages/app/src/context/global-sync/utils.test.ts

@@ -1,112 +1,36 @@
 import { describe, expect, test } from "bun:test"
-import type { AgentListOutput, ModelDefaultOutput, ModelListOutput, ProviderListOutput } from "@opencode-ai/client/promise"
-import { directoryKey, normalizeAgentList, normalizePermissionRequest, normalizeProviderList } from "./utils"
+import type { Agent } from "@opencode-ai/sdk/v2/client"
+import { directoryKey, normalizeAgentList } from "./utils"
+
+const agent = (name = "build") =>
+  ({
+    name,
+    mode: "primary",
+    permission: {},
+    options: {},
+  }) as Agent
 
 describe("normalizeAgentList", () => {
-  test("adapts current agents to the app agent shape", () => {
-    const result = normalizeAgentList([
-      {
-        id: "build",
-        name: "Build",
-        mode: "primary",
-        hidden: false,
-        color: "primary",
-        model: { id: "gpt-5", providerID: "openai", variant: "high" },
-        request: { settings: { temperature: 0.2, topP: 0.9 }, headers: {}, body: {} },
-        system: "Build software",
-        permissions: [{ action: "read", resource: "*", effect: "allow" }],
-      },
-    ] as AgentListOutput["data"])
-
-    expect(result).toEqual([
-      {
-        name: "build",
-        description: undefined,
-        mode: "primary",
-        hidden: false,
-        temperature: 0.2,
-        topP: 0.9,
-        color: "primary",
-        permission: [{ permission: "read", pattern: "*", action: "allow" }],
-        model: { providerID: "openai", modelID: "gpt-5" },
-        variant: "high",
-        prompt: "Build software",
-        options: { temperature: 0.2, topP: 0.9 },
-        steps: undefined,
-      },
-    ])
+  test("keeps array payloads", () => {
+    expect(normalizeAgentList([agent("build"), agent("docs")])).toEqual([agent("build"), agent("docs")])
   })
-})
 
-describe("normalizePermissionRequest", () => {
-  test("adapts the current permission request to app state", () => {
+  test("wraps a single agent payload", () => {
+    expect(normalizeAgentList(agent("docs"))).toEqual([agent("docs")])
+  })
+
+  test("extracts agents from keyed objects", () => {
     expect(
-      normalizePermissionRequest({
-        id: "permission-1",
-        sessionID: "session-1",
-        action: "read",
-        resources: ["README.md"],
-        save: ["*.md"],
-        metadata: { path: "README.md" },
-        source: { type: "tool", messageID: "message-1", callID: "call-1" },
+      normalizeAgentList({
+        build: agent("build"),
+        docs: agent("docs"),
       }),
-    ).toEqual({
-      id: "permission-1",
-      sessionID: "session-1",
-      permission: "read",
-      patterns: ["README.md"],
-      always: ["*.md"],
-      metadata: { path: "README.md" },
-      tool: { messageID: "message-1", callID: "call-1" },
-    })
+    ).toEqual([agent("build"), agent("docs")])
   })
-})
 
-describe("normalizeProviderList", () => {
-  test("groups current models into the app provider catalog", () => {
-    const result = normalizeProviderList(
-      [{ id: "openai", name: "OpenAI", package: "@ai-sdk/openai" }] as ProviderListOutput["data"],
-      [
-        {
-          id: "gpt-5",
-          modelID: "gpt-5",
-          providerID: "openai",
-          name: "GPT-5",
-          capabilities: { tools: true, input: ["text", "image"], output: ["text"] },
-          variants: [{ id: "high" }],
-          time: { released: 1 },
-          cost: [{ input: 1, output: 2, cache: { read: 0.1, write: 0.2 } }],
-          status: "active",
-          enabled: true,
-          limit: { context: 128_000, output: 8_192 },
-        },
-        {
-          id: "gpt-old",
-          modelID: "gpt-old",
-          providerID: "openai",
-          name: "GPT Old",
-          capabilities: { tools: false, input: ["text"], output: ["text"] },
-          variants: [],
-          time: { released: 0 },
-          cost: [],
-          status: "deprecated",
-          enabled: true,
-          limit: { context: 1, output: 1 },
-        },
-      ] as ModelListOutput["data"],
-      { id: "gpt-5", providerID: "openai" } as ModelDefaultOutput["data"],
-    )
-
-    expect(result.connected).toEqual(["openai"])
-    expect(result.default).toEqual({ openai: "gpt-5" })
-    expect(result.all.get("openai")?.models["gpt-old"]).toBeUndefined()
-    expect(result.all.get("openai")?.models["gpt-5"]).toMatchObject({
-      id: "gpt-5",
-      providerID: "openai",
-      capabilities: { toolcall: true, attachment: true },
-      cost: { input: 1, output: 2 },
-      variants: { high: {} },
-    })
+  test("drops invalid payloads", () => {
+    expect(normalizeAgentList({ name: "AbortError" })).toEqual([])
+    expect(normalizeAgentList([{ name: "build" }, agent("docs")])).toEqual([agent("docs")])
   })
 })
 

packages/app/src/context/global-sync/utils.ts

@@ -1,152 +1,39 @@
-import type {
-  AgentListOutput,
-  ModelDefaultOutput,
-  ModelListOutput,
-  PermissionV2Request,
-  ProviderListOutput,
-} from "@opencode-ai/client/promise"
-import type { Agent, PermissionRequest, Project, Provider, ProviderListResponse } from "@opencode-ai/sdk/v2/client"
-import type { Project as CurrentProject } from "@opencode-ai/client/promise"
+import type { Agent, Project, ProviderListResponse } from "@opencode-ai/sdk/v2/client"
 import { NormalizedProviderListResponse } from "@opencode-ai/session-ui/context"
 export { pathKey as directoryKey, type PathKey as DirectoryKey } from "@/utils/path-key"
 
 export const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)
 
-export function normalizeAgentList(input: AgentListOutput["data"] | Agent[]): Agent[] {
-  if (input.every((agent) => !("request" in agent))) return input as Agent[]
-  return (input as AgentListOutput["data"]).map((agent) => ({
-    name: agent.id,
-    description: agent.description,
-    mode: agent.mode,
-    hidden: agent.hidden,
-    temperature:
-      typeof agent.request.settings.temperature === "number" ? agent.request.settings.temperature : undefined,
-    topP: typeof agent.request.settings.topP === "number" ? agent.request.settings.topP : undefined,
-    color: agent.color,
-    permission: agent.permissions.map((rule) => ({
-      permission: rule.action,
-      pattern: rule.resource,
-      action: rule.effect,
-    })),
-    model: agent.model && { providerID: agent.model.providerID, modelID: agent.model.id },
-    variant: agent.model?.variant,
-    prompt: agent.system,
-    options: agent.request.settings,
-    steps: agent.steps,
-  }))
+function isAgent(input: unknown): input is Agent {
+  if (!input || typeof input !== "object") return false
+  const item = input as { name?: unknown; mode?: unknown }
+  if (typeof item.name !== "string") return false
+  return item.mode === "subagent" || item.mode === "primary" || item.mode === "all"
 }
 
-export function normalizePermissionRequest(input: PermissionV2Request | PermissionRequest): PermissionRequest {
-  if ("permission" in input) return input
+export function normalizeAgentList(input: unknown): Agent[] {
+  if (Array.isArray(input)) return input.filter(isAgent)
+  if (isAgent(input)) return [input]
+  if (!input || typeof input !== "object") return []
+  return Object.values(input).filter(isAgent)
+}
+
+export function normalizeProviderList(input: ProviderListResponse): NormalizedProviderListResponse {
   return {
-    id: input.id,
-    sessionID: input.sessionID,
-    permission: input.action,
-    patterns: input.resources,
-    always: input.save ?? [],
-    metadata: input.metadata ?? {},
-    tool:
-      input.source?.type === "tool" ? { messageID: input.source.messageID, callID: input.source.callID } : undefined,
-  }
-}
-
-export function normalizeProviderList(
-  providers: ProviderListOutput["data"] | ProviderListResponse,
-  models?: ModelListOutput["data"],
-  defaultModel?: ModelDefaultOutput["data"],
-): NormalizedProviderListResponse {
-  if (!Array.isArray(providers)) {
-    return {
-      ...providers,
-      all: new Map(
-        providers.all.map((provider) => [
-          provider.id,
-          {
-            ...provider,
-            models: Object.fromEntries(
-              Object.entries(provider.models).filter(([, model]) => model.status !== "deprecated"),
-            ),
-          },
-        ]),
+    ...input,
+    all: new Map(
+      input.all.map(
+        (provider) =>
+          [
+            provider.id,
+            {
+              ...provider,
+              models: Object.fromEntries(
+                Object.entries(provider.models).filter(([, info]) => info.status !== "deprecated"),
+              ),
+            },
+          ] as const,
       ),
-    }
-  }
-  const all = new Map<string, Provider>()
-
-  for (const provider of providers) {
-    all.set(provider.id, {
-      id: provider.id,
-      name: provider.name,
-      source: "custom",
-      env: [],
-      options: provider.settings ?? {},
-      models: {},
-    })
-  }
-
-  for (const model of models ?? []) {
-    const provider = all.get(model.providerID)
-    if (!provider || model.status === "deprecated") continue
-    const cost = model.cost.find((item) => item.tier === undefined) ?? model.cost[0]
-    provider.models[model.id] = {
-      id: model.id,
-      providerID: model.providerID,
-      api: {
-        id: model.modelID,
-        url: "",
-        npm: model.package ?? provider.id,
-      },
-      name: model.name,
-      family: model.family,
-      capabilities: {
-        temperature: false,
-        reasoning: false,
-        attachment: model.capabilities.input.some((item) => item !== "text"),
-        toolcall: model.capabilities.tools,
-        input: {
-          text: model.capabilities.input.includes("text"),
-          audio: model.capabilities.input.includes("audio"),
-          image: model.capabilities.input.includes("image"),
-          video: model.capabilities.input.includes("video"),
-          pdf: model.capabilities.input.includes("pdf"),
-        },
-        output: {
-          text: model.capabilities.output.includes("text"),
-          audio: model.capabilities.output.includes("audio"),
-          image: model.capabilities.output.includes("image"),
-          video: model.capabilities.output.includes("video"),
-          pdf: model.capabilities.output.includes("pdf"),
-        },
-        interleaved: false,
-      },
-      cost: {
-        input: cost?.input ?? 0,
-        output: cost?.output ?? 0,
-        cache: {
-          read: cost?.cache.read ?? 0,
-          write: cost?.cache.write ?? 0,
-        },
-      },
-      limit: model.limit,
-      status: model.status,
-      options: model.settings ?? {},
-      headers: model.headers ?? {},
-      release_date: new Date(model.time.released).toISOString().slice(0, 10),
-      variants: Object.fromEntries(model.variants.map((variant) => [variant.id, variant.settings ?? {}])),
-    }
-  }
-
-  return {
-    all,
-    connected: providers.map((provider) => provider.id),
-    default: Object.fromEntries(
-      providers.flatMap((provider) => {
-        const model =
-          defaultModel?.providerID === provider.id
-            ? defaultModel
-            : models?.find((item) => item.providerID === provider.id && item.status !== "deprecated")
-        return model ? [[provider.id, model.id]] : []
-      }),
     ),
   }
 }
@@ -162,10 +49,3 @@ export function sanitizeProject(project: Project) {
     },
   }
 }
-
-export function normalizeProjectInfo(project: Project | CurrentProject): Project {
-  return {
-    ...project,
-    vcs: project.vcs === "git" ? "git" : undefined,
-  }
-}

packages/app/src/context/layout.tsx

@@ -8,7 +8,6 @@ import { useServerSDK } from "./server-sdk"
 import { RECENTLY_CLOSED_DISPLAY_LIMIT, ServerConnection, useServer } from "./server"
 import { usePlatform } from "./platform"
 import { Project } from "@opencode-ai/sdk/v2"
-import { normalizeProjectInfo } from "./global-sync/utils"
 import { Persist, persisted, removePersisted } from "@/utils/persist"
 import { pathKey } from "@/utils/path-key"
 import { decode64 } from "@/utils/base64"
@@ -571,12 +570,7 @@ export const { use: useLayout, provider: LayoutProvider } = createSimpleContext(
         }
 
         void serverSdk()
-          .api.project.update({ projectID: project.id, icon: { color } })
-          .then((result) =>
-            serverSync().set("project", (items) =>
-              items.map((item) => (item.id === result.id ? normalizeProjectInfo(result) : item)),
-            ),
-          )
+          .client.project.update({ projectID: project.id, directory: worktree, icon: { color } })
           .catch(() => {
             if (colorRequested.get(worktree) === color) colorRequested.delete(worktree)
           })

packages/app/src/context/permission.tsx

@@ -13,7 +13,6 @@ import { type DraftTab, useTabs } from "./tabs"
 import { useSettings } from "./settings"
 import { requireServerKey } from "@/utils/session-route"
 import type { ServerScope } from "@/utils/server-scope"
-import { normalizePermissionRequest } from "./global-sync/utils"
 import {
   acceptKey,
   directoryAcceptKey,
@@ -244,20 +243,9 @@ function createServerPermissionState(input: { sdk: ServerSDK; sync: ServerSync }
 
   const respond: PermissionRespondFn = (request) => {
     if (meta.disposed) return
-    input.sdk.api.permission
-      .reply({ sessionID: request.sessionID, requestID: request.permissionID, reply: request.response })
-      .catch(() => {
-        responded.delete(request.permissionID)
-      })
-  }
-
-  const list = async (directory: string) => {
-    if ((await input.sdk.protocol) === "v1") {
-      return (await input.sdk.client.permission.list({ directory })).data ?? []
-    }
-    return input.sdk.api.permission.request
-      .list({ location: { directory } })
-      .then((result) => result.data.map(normalizePermissionRequest))
+    input.sdk.client.permission.respond(request).catch(() => {
+      responded.delete(request.permissionID)
+    })
   }
 
   function respondOnce(permission: PermissionRequest, directory?: string) {
@@ -355,12 +343,14 @@ function createServerPermissionState(input: { sdk: ServerSDK; sync: ServerSync }
       }),
     )
 
-    list(directory)
-      .then((permissions) => {
+    input.sdk.client.permission
+      .list({ directory })
+      .then((x) => {
         if (meta.disposed) return
         if (!isAutoAcceptingDirectory(directory)) return
-        for (const permission of permissions) {
-          void respondPending(permission, directory, () => isAutoAcceptingDirectory(directory))
+        for (const perm of x.data ?? []) {
+          if (!perm?.id) continue
+          void respondPending(perm, directory, () => isAutoAcceptingDirectory(directory))
         }
       })
       .catch(() => undefined)
@@ -387,14 +377,16 @@ function createServerPermissionState(input: { sdk: ServerSDK; sync: ServerSync }
       }),
     )
 
-    list(directory)
-      .then((permissions) => {
+    input.sdk.client.permission
+      .list({ directory })
+      .then((x) => {
         if (meta.disposed) return
         if (enableVersion.get(key) !== version) return
         if (!isAutoAccepting(sessionID, directory)) return
-        for (const permission of permissions) {
+        for (const perm of x.data ?? []) {
+          if (!perm?.id) continue
           void respondPending(
-            permission,
+            perm,
             directory,
             () => enableVersion.get(key) === version && isAutoAccepting(sessionID, directory),
           )

packages/app/src/context/server-sdk.test.ts

@@ -53,13 +53,14 @@ describe("coalesceServerEvents", () => {
   })
 
   test("merges adjacent current text deltas", () => {
-    const current = (id: string, value: string) => adaptServerEvent({
-      id,
-      created: 1,
-      type: "session.text.delta",
-      location: { directory: "/repo" },
-      data: { sessionID: "ses", assistantMessageID: "msg", ordinal: 0, delta: value },
-    } as OpenCodeEvent)
+    const current = (id: string, value: string) =>
+      adaptServerEvent({
+        id,
+        created: 1,
+        type: "session.text.delta",
+        location: { directory: "/repo" },
+        data: { sessionID: "ses", assistantMessageID: "msg", ordinal: 0, delta: value },
+      } as OpenCodeEvent)
     const result = coalesceServerEvents([
       { directory: "/repo", payload: current("evt_1", "hello ") },
       { directory: "/repo", payload: current("evt_2", "world") },

packages/app/src/context/server-sdk.tsx

@@ -4,15 +4,15 @@ import { createSimpleContext } from "@opencode-ai/ui/context"
 import { createGlobalEmitter } from "@solid-primitives/event-bus"
 import { makeEventListener } from "@solid-primitives/event-listener"
 import { type Accessor, batch, createMemo, onCleanup, onMount } from "solid-js"
-import { createApiForServer, createSdkForServer } from "@/utils/server"
+import { createApiForServer, createSdkForServer, type ServerApi } from "@/utils/server"
 import { useLanguage } from "./language"
 import { usePlatform } from "./platform"
 import { ServerConnection, useServer } from "./server"
 import { createRefCountMap } from "@/utils/refcount"
 import { useGlobal } from "./global"
 import { ServerScope } from "@/utils/server-scope"
-import { detectServerProtocol } from "@/utils/server-protocol"
-import { createCompatibleApi } from "@/utils/server-compat"
+import { detectServerProtocol, type ServerProtocol } from "@/utils/server-protocol"
+import { createCompatibleApi, type CompatibleApi } from "@/utils/server-compat"
 
 const isAbortError = (error: unknown) =>
   error !== null && typeof error === "object" && "name" in error && error.name === "AbortError"
@@ -164,7 +164,26 @@ export function resumeStreamAfterPageShow(event: PageTransitionEvent, start: ()
   start()
 }
 
-function createServerSdkContextBase(server: ServerConnection.Any, scope: ServerScope) {
+type ServerEventEmitter = ReturnType<typeof createGlobalEmitter<{ [key: string]: ServerEvent }>>
+type ServerSDKBase = {
+  server: ServerConnection.Any
+  scope: ServerScope
+  protocol: Promise<ServerProtocol>
+  url: string
+  client: ReturnType<typeof createSdkForServer>
+  api: CompatibleApi
+  currentApi: ServerApi
+  event: {
+    on: ServerEventEmitter["on"]
+    listen: ServerEventEmitter["listen"]
+    start: () => Promise<void> | undefined
+  }
+  createClient: (
+    opts: Omit<Parameters<typeof createSdkForServer>[0], "server" | "fetch">,
+  ) => ReturnType<typeof createSdkForServer>
+}
+
+function createServerSdkContextBase(server: ServerConnection.Any, scope: ServerScope): ServerSDKBase {
   const platform = usePlatform()
   const abort = new AbortController()
 
@@ -314,7 +333,7 @@ function createServerSdkContextBase(server: ServerConnection.Any, scope: ServerS
     fetch: platform.fetch,
     throwOnError: true,
   })
-  const currentApi = createApiForServer({ server: server.http, fetch: platform.fetch })
+  const currentApi: ServerApi = createApiForServer({ server: server.http, fetch: platform.fetch })
   const legacy = (directory?: string) =>
     createSdkForServer({
       server: server.http,
@@ -347,7 +366,6 @@ function createServerSdkContextBase(server: ServerConnection.Any, scope: ServerS
   }
 }
 
-type ServerSDKBase = ReturnType<typeof createServerSdkContextBase>
 export type ServerSDK = ServerSDKBase & {
   ensureDirSdkContext: (directory: string) => ReturnType<typeof createDirSdkContext>
 }

packages/app/src/context/server-session-v2-reducer.test.ts

@@ -1,148 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import type { OpenCodeEvent, SessionMessageInfo } from "@opencode-ai/client/promise"
-import { createV2SessionReducer } from "./server-session-v2-reducer"
-
-const event = (input: object) => input as OpenCodeEvent
-const base = { created: 1, location: { directory: "/repo" }, durable: { aggregateID: "ses_1", seq: 1, version: 1 } }
-
-describe("v2 session reducer", () => {
-  test("projects promoted input and streaming assistant content", () => {
-    const reducer = createV2SessionReducer()
-    let messages: SessionMessageInfo[] = []
-    const apply = (input: object) => {
-      const result = reducer.reduce(messages, event(input))
-      if (result) messages = result.messages
-      return result
-    }
-
-    apply({
-      ...base,
-      id: "evt_admitted",
-      type: "session.input.admitted",
-      data: {
-        sessionID: "ses_1",
-        inputID: "msg_user",
-        input: { type: "user", delivery: "steer", data: { text: "hello" } },
-      },
-    })
-    apply({ ...base, id: "evt_promoted", type: "session.input.promoted", data: { sessionID: "ses_1", inputID: "msg_user" } })
-    apply({
-      ...base,
-      id: "evt_step",
-      type: "session.step.started",
-      data: {
-        sessionID: "ses_1",
-        assistantMessageID: "msg_assistant",
-        agent: "build",
-        model: { id: "model", providerID: "provider" },
-      },
-    })
-    apply({
-      ...base,
-      id: "evt_text_start",
-      type: "session.text.started",
-      data: { sessionID: "ses_1", assistantMessageID: "msg_assistant", ordinal: 0 },
-    })
-    apply({
-      ...base,
-      id: "evt_text_delta",
-      type: "session.text.delta",
-      data: { sessionID: "ses_1", assistantMessageID: "msg_assistant", ordinal: 0, delta: "hel" },
-    })
-    apply({
-      ...base,
-      id: "evt_text_end",
-      type: "session.text.ended",
-      data: { sessionID: "ses_1", assistantMessageID: "msg_assistant", ordinal: 0, text: "hello" },
-    })
-
-    expect(messages[0]).toMatchObject({ id: "msg_user", type: "user", text: "hello" })
-    expect(messages[1]).toMatchObject({
-      id: "msg_assistant",
-      type: "assistant",
-      content: [{ type: "text", text: "hello" }],
-    })
-  })
-
-  test("folds tool, retry, and completion events", () => {
-    const reducer = createV2SessionReducer()
-    let messages: SessionMessageInfo[] = []
-    const apply = (input: object) => {
-      const result = reducer.reduce(messages, event(input))
-      if (result) messages = result.messages
-    }
-
-    apply({
-      ...base,
-      id: "evt_step",
-      type: "session.step.started",
-      data: {
-        sessionID: "ses_1",
-        assistantMessageID: "msg_assistant",
-        agent: "build",
-        model: { id: "model", providerID: "provider" },
-      },
-    })
-    apply({
-      ...base,
-      id: "evt_tool_start",
-      type: "session.tool.input.started",
-      data: { sessionID: "ses_1", assistantMessageID: "msg_assistant", callID: "call_1", name: "bash" },
-    })
-    apply({
-      ...base,
-      id: "evt_tool_delta",
-      type: "session.tool.input.delta",
-      data: { sessionID: "ses_1", assistantMessageID: "msg_assistant", callID: "call_1", delta: "{}" },
-    })
-    apply({
-      ...base,
-      id: "evt_tool_called",
-      type: "session.tool.called",
-      data: { sessionID: "ses_1", assistantMessageID: "msg_assistant", callID: "call_1", input: {}, executed: true },
-    })
-    apply({
-      ...base,
-      id: "evt_tool_success",
-      type: "session.tool.success",
-      data: {
-        sessionID: "ses_1",
-        assistantMessageID: "msg_assistant",
-        callID: "call_1",
-        structured: {},
-        content: [{ type: "text", text: "done" }],
-        executed: true,
-      },
-    })
-    apply({
-      ...base,
-      id: "evt_retry",
-      type: "session.retry.scheduled",
-      data: {
-        sessionID: "ses_1",
-        assistantMessageID: "msg_assistant",
-        attempt: 2,
-        at: 10,
-        error: { type: "ProviderError", message: "retry" },
-      },
-    })
-    apply({ ...base, id: "evt_done", type: "session.execution.succeeded", data: { sessionID: "ses_1" } })
-
-    expect(messages[0]).toMatchObject({
-      type: "assistant",
-      retry: undefined,
-      content: [{ type: "tool", id: "call_1", state: { status: "completed", content: [{ text: "done" }] } }],
-    })
-  })
-
-  test("requests hydration when promotion admission was missed", () => {
-    const result = createV2SessionReducer().reduce([], event({
-      ...base,
-      id: "evt_promoted",
-      type: "session.input.promoted",
-      data: { sessionID: "ses_1", inputID: "msg_user" },
-    }))
-
-    expect(result).toMatchObject({ sessionID: "ses_1", missing: "msg_user", touched: [] })
-  })
-})

packages/app/src/context/server-session-v2-reducer.ts

@@ -1,434 +0,0 @@
-import type { OpenCodeEvent, SessionMessageInfo, SessionPendingMessage } from "@opencode-ai/client/promise"
-
-type Assistant = Extract<SessionMessageInfo, { type: "assistant" }>
-type Compaction = Extract<SessionMessageInfo, { type: "compaction" }>
-type Shell = Extract<SessionMessageInfo, { type: "shell" }>
-
-export type V2SessionReduction = {
-  sessionID: string
-  messages: SessionMessageInfo[]
-  touched: string[]
-  missing?: string
-}
-
-export function createV2SessionReducer() {
-  const pending = new Map<string, SessionPendingMessage>()
-
-  const reduce = (source: readonly SessionMessageInfo[], event: OpenCodeEvent): V2SessionReduction | undefined => {
-    if (!("data" in event) || !("sessionID" in event.data) || typeof event.data.sessionID !== "string") return
-    const sessionID = event.data.sessionID
-    const result = (messages: SessionMessageInfo[], touched: string[] = []): V2SessionReduction => ({
-      sessionID,
-      messages,
-      touched,
-    })
-    const append = (message: SessionMessageInfo) =>
-      result(source.some((item) => item.id === message.id) ? [...source] : [...source, message], [message.id])
-
-    switch (event.type) {
-      case "session.input.admitted":
-        pending.set(key(sessionID, event.data.inputID), event.data.input)
-        return result([...source])
-      case "session.input.promoted": {
-        const input = pending.get(key(sessionID, event.data.inputID))
-        pending.delete(key(sessionID, event.data.inputID))
-        if (!input) return { ...result([...source]), missing: event.data.inputID }
-        if (input.type === "user")
-          return append({
-            id: event.data.inputID,
-            type: "user",
-            metadata: input.data.metadata,
-            text: input.data.text,
-            files: input.data.files,
-            agents: input.data.agents,
-            time: { created: event.created },
-          })
-        return append({
-          id: event.data.inputID,
-          type: "synthetic",
-          metadata: input.data.metadata,
-          text: input.data.text,
-          description: input.data.description,
-          time: { created: event.created },
-        })
-      }
-      case "session.agent.selected":
-        return append({
-          id: messageID(event.id),
-          type: "agent-switched",
-          metadata: event.metadata,
-          agent: event.data.agent,
-          time: { created: event.created },
-        })
-      case "session.model.selected":
-        return append({
-          id: messageID(event.id),
-          type: "model-switched",
-          metadata: event.metadata,
-          model: event.data.model,
-          previous: source.findLast(
-            (item): item is Extract<SessionMessageInfo, { type: "model-switched" | "assistant" }> =>
-              item.type === "model-switched" || item.type === "assistant",
-          )?.model,
-          time: { created: event.created },
-        })
-      case "session.synthetic":
-        return append({
-          id: messageID(event.id),
-          type: "synthetic",
-          metadata: event.data.metadata,
-          text: event.data.text,
-          description: event.data.description,
-          time: { created: event.created },
-        })
-      case "session.skill.activated":
-        return append({
-          id: messageID(event.id),
-          type: "skill",
-          metadata: event.metadata,
-          skill: event.data.id,
-          name: event.data.name,
-          text: event.data.text,
-          time: { created: event.created },
-        })
-      case "session.shell.started":
-        return append({
-          id: messageID(event.id),
-          type: "shell",
-          metadata: event.metadata,
-          shellID: event.data.shell.id,
-          command: event.data.shell.command,
-          status: event.data.shell.status,
-          exit: event.data.shell.exit,
-          time: { created: event.created },
-        })
-      case "session.shell.ended":
-        return updateMessage<Shell>(source, (item): item is Shell => item.type === "shell" && item.shellID === event.data.shell.id, (item) => ({
-          ...item,
-          status: event.data.shell.status,
-          exit: event.data.shell.exit,
-          output: event.data.output,
-          time: { ...item.time, completed: event.created },
-        }), sessionID)
-      case "session.step.started": {
-        const current = source.findLast((item): item is Assistant => item.type === "assistant" && !item.time.completed)
-        const completed = current && current.id !== event.data.assistantMessageID
-          ? update(source, current.id, (item) => item.type === "assistant" ? { ...item, retry: undefined, time: { ...item.time, completed: event.created } } : item)
-          : [...source]
-        const existing = completed.find((item) => item.id === event.data.assistantMessageID)
-        if (existing?.type === "assistant")
-          return result(update(completed, existing.id, (item) => item.type === "assistant" ? {
-            ...item,
-            agent: event.data.agent,
-            model: event.data.model,
-            retry: undefined,
-            error: undefined,
-            finish: undefined,
-            snapshot: event.data.snapshot ? { ...item.snapshot, start: event.data.snapshot } : item.snapshot,
-            time: { ...item.time, completed: undefined },
-          } : item), current && current.id !== existing.id ? [current.id, existing.id] : [existing.id])
-        return result([...completed, {
-          id: event.data.assistantMessageID,
-          type: "assistant",
-          metadata: event.metadata,
-          agent: event.data.agent,
-          model: event.data.model,
-          content: [],
-          snapshot: event.data.snapshot ? { start: event.data.snapshot } : undefined,
-          time: { created: event.created },
-        }], current ? [current.id, event.data.assistantMessageID] : [event.data.assistantMessageID])
-      }
-      case "session.step.ended":
-        return updateAssistant(source, event.data.assistantMessageID, sessionID, (item) => ({
-          ...item,
-          finish: event.data.finish,
-          cost: event.data.cost,
-          tokens: event.data.tokens,
-          snapshot: event.data.snapshot || event.data.files
-            ? { ...item.snapshot, end: event.data.snapshot, files: event.data.files }
-            : item.snapshot,
-          time: { ...item.time, completed: event.created },
-        }))
-      case "session.step.failed":
-        return updateAssistant(source, event.data.assistantMessageID, sessionID, (item) => ({
-          ...item,
-          finish: "error",
-          error: event.data.error,
-          retry: undefined,
-          cost: event.data.cost ?? item.cost,
-          tokens: event.data.tokens ?? item.tokens,
-          snapshot: event.data.snapshot || event.data.files
-            ? { ...item.snapshot, end: event.data.snapshot, files: event.data.files }
-            : item.snapshot,
-          time: { ...item.time, completed: event.created },
-        }))
-      case "session.text.started":
-        return updateAssistant(source, event.data.assistantMessageID, sessionID, (item) => ({
-          ...item,
-          content: insertOrdinal(item.content, "text", event.data.ordinal, { type: "text", text: "" }),
-        }))
-      case "session.text.delta":
-        return updateContent(source, event.data.assistantMessageID, sessionID, "text", event.data.ordinal, (item) => ({
-          ...item,
-          text: item.text + event.data.delta,
-        }))
-      case "session.text.ended":
-        return updateContent(source, event.data.assistantMessageID, sessionID, "text", event.data.ordinal, (item) => ({
-          ...item,
-          text: event.data.text,
-        }))
-      case "session.reasoning.started":
-        return updateAssistant(source, event.data.assistantMessageID, sessionID, (item) => ({
-          ...item,
-          content: insertOrdinal(item.content, "reasoning", event.data.ordinal, {
-            type: "reasoning",
-            text: "",
-            state: event.data.state,
-            time: { created: event.created },
-          }),
-        }))
-      case "session.reasoning.delta":
-        return updateContent(source, event.data.assistantMessageID, sessionID, "reasoning", event.data.ordinal, (item) => ({
-          ...item,
-          text: item.text + event.data.delta,
-        }))
-      case "session.reasoning.ended":
-        return updateContent(source, event.data.assistantMessageID, sessionID, "reasoning", event.data.ordinal, (item) => ({
-          ...item,
-          text: event.data.text,
-          state: event.data.state ?? item.state,
-          time: { created: item.time?.created ?? event.created, completed: event.created },
-        }))
-      case "session.tool.input.started":
-        return updateAssistant(source, event.data.assistantMessageID, sessionID, (item) => ({
-          ...item,
-          content: item.content.some((content) => content.type === "tool" && content.id === event.data.callID)
-            ? item.content
-            : [...item.content, {
-                type: "tool",
-                id: event.data.callID,
-                name: event.data.name,
-                state: { status: "streaming", input: "" },
-                time: { created: event.created },
-              }],
-        }))
-      case "session.tool.input.delta":
-        return updateTool(source, event.data.assistantMessageID, event.data.callID, sessionID, (tool) =>
-          tool.state.status === "streaming"
-            ? { ...tool, state: { ...tool.state, input: tool.state.input + event.data.delta } }
-            : tool,
-        )
-      case "session.tool.input.ended":
-        return updateTool(source, event.data.assistantMessageID, event.data.callID, sessionID, (tool) =>
-          tool.state.status === "streaming" ? { ...tool, state: { ...tool.state, input: event.data.text } } : tool,
-        )
-      case "session.tool.called":
-        return updateTool(source, event.data.assistantMessageID, event.data.callID, sessionID, (tool) => ({
-          ...tool,
-          executed: event.data.executed,
-          providerState: event.data.state,
-          state: { status: "running", input: event.data.input, structured: {}, content: [] },
-          time: { ...tool.time, ran: event.created },
-        }))
-      case "session.tool.progress":
-        return updateTool(source, event.data.assistantMessageID, event.data.callID, sessionID, (tool) =>
-          tool.state.status === "running"
-            ? { ...tool, state: { ...tool.state, structured: event.data.structured, content: event.data.content } }
-            : tool,
-        )
-      case "session.tool.success":
-        return updateTool(source, event.data.assistantMessageID, event.data.callID, sessionID, (tool) => {
-          if (tool.state.status !== "running") return tool
-          return {
-            ...tool,
-            executed: event.data.executed || tool.executed === true,
-            providerResultState: event.data.resultState,
-            state: {
-              status: "completed",
-              input: tool.state.input,
-              structured: event.data.structured,
-              content: event.data.content,
-              result: event.data.result,
-            },
-            time: { ...tool.time, completed: event.created },
-          }
-        })
-      case "session.tool.failed":
-        return updateTool(source, event.data.assistantMessageID, event.data.callID, sessionID, (tool) => {
-          if (tool.state.status !== "streaming" && tool.state.status !== "running") return tool
-          return {
-            ...tool,
-            executed: event.data.executed || tool.executed === true,
-            providerResultState: event.data.resultState,
-            state: {
-              status: "error",
-              input: typeof tool.state.input === "string" ? {} : tool.state.input,
-              structured: tool.state.status === "running" ? tool.state.structured : {},
-              content: tool.state.status === "running" ? tool.state.content : [],
-              error: event.data.error,
-              result: event.data.result,
-            },
-            time: { ...tool.time, completed: event.created },
-          }
-        })
-      case "session.retry.scheduled":
-        return updateAssistant(source, event.data.assistantMessageID, sessionID, (item) => ({
-          ...item,
-          retry: { attempt: event.data.attempt, at: event.data.at, error: event.data.error },
-        }))
-      case "session.execution.succeeded":
-      case "session.execution.failed":
-      case "session.execution.interrupted": {
-        const current = source.findLast((item): item is Assistant => item.type === "assistant" && !item.time.completed)
-        if (!current?.retry) return result([...source])
-        return updateAssistant(source, current.id, sessionID, (item) => ({ ...item, retry: undefined }))
-      }
-      case "session.compaction.started":
-        return append({
-          id: event.data.inputID ?? messageID(event.id),
-          type: "compaction",
-          status: "running",
-          metadata: event.metadata,
-          reason: event.data.reason,
-          summary: "",
-          recent: event.data.recent,
-          time: { created: event.created },
-        })
-      case "session.compaction.delta":
-        return updateMessage<Extract<Compaction, { status: "running" }>>(source, (item): item is Extract<Compaction, { status: "running" }> => item.type === "compaction" && item.status === "running", (item) => ({
-          ...item,
-          summary: item.summary + event.data.text,
-        }), sessionID)
-      case "session.compaction.ended": {
-        const current = source.findLast((item): item is Extract<Compaction, { status: "running" }> => item.type === "compaction" && item.status === "running")
-        if (!current)
-          return append({
-            id: messageID(event.id),
-            type: "compaction",
-            status: "completed",
-            metadata: event.metadata,
-            reason: event.data.reason,
-            summary: event.data.text,
-            recent: event.data.recent,
-            time: { created: event.created },
-          })
-        return result(update(source, current.id, () => ({
-          ...current,
-          status: "completed",
-          reason: event.data.reason,
-          summary: event.data.text,
-          recent: event.data.recent,
-        })), [current.id])
-      }
-      case "session.compaction.failed": {
-        const current = source.findLast((item): item is Extract<Compaction, { status: "running" }> => item.type === "compaction" && item.status === "running")
-        const failed: Extract<Compaction, { status: "failed" }> = {
-          id: current?.id ?? event.data.inputID ?? messageID(event.id),
-          type: "compaction",
-          status: "failed",
-          metadata: current?.metadata ?? event.metadata,
-          reason: event.data.reason,
-          error: event.data.error,
-          time: current?.time ?? { created: event.created },
-        }
-        if (!current) return append(failed)
-        return result(update(source, current.id, () => failed), [failed.id])
-      }
-      default:
-        return
-    }
-  }
-
-  return {
-    reduce,
-    clear(sessionID: string) {
-      for (const id of pending.keys()) {
-        if (id.startsWith(`${sessionID}:`)) pending.delete(id)
-      }
-    },
-  }
-}
-
-function key(sessionID: string, inputID: string) {
-  return `${sessionID}:${inputID}`
-}
-
-function messageID(eventID: string) {
-  return eventID.replace(/^evt_/, "msg_")
-}
-
-function update(
-  source: readonly SessionMessageInfo[],
-  id: string,
-  apply: (item: SessionMessageInfo) => SessionMessageInfo,
-) {
-  return source.map((item) => item.id === id ? apply(item) : item)
-}
-
-function updateMessage<T extends SessionMessageInfo>(
-  source: readonly SessionMessageInfo[],
-  matches: (item: SessionMessageInfo) => item is T,
-  apply: (item: T) => T,
-  sessionID: string,
-): V2SessionReduction {
-  const current = source.findLast(matches)
-  if (!current) return { sessionID, messages: [...source], touched: [] }
-  return { sessionID, messages: update(source, current.id, (item) => matches(item) ? apply(item) : item), touched: [current.id] }
-}
-
-function updateAssistant(
-  source: readonly SessionMessageInfo[],
-  id: string,
-  sessionID: string,
-  apply: (item: Assistant) => Assistant,
-): V2SessionReduction {
-  return {
-    sessionID,
-    messages: update(source, id, (item) => item.type === "assistant" ? apply(item) : item),
-    touched: source.some((item) => item.id === id && item.type === "assistant") ? [id] : [],
-  }
-}
-
-function updateContent<T extends "text" | "reasoning">(
-  source: readonly SessionMessageInfo[],
-  messageID: string,
-  sessionID: string,
-  type: T,
-  ordinal: number,
-  apply: (item: Extract<Assistant["content"][number], { type: T }>) => Extract<Assistant["content"][number], { type: T }>,
-) {
-  return updateAssistant(source, messageID, sessionID, (assistant) => {
-    let index = -1
-    return {
-      ...assistant,
-      content: assistant.content.map((item) => {
-        if (item.type !== type || ++index !== ordinal) return item
-        return apply(item as Extract<Assistant["content"][number], { type: T }>)
-      }),
-    }
-  })
-}
-
-function updateTool(
-  source: readonly SessionMessageInfo[],
-  messageID: string,
-  callID: string,
-  sessionID: string,
-  apply: (item: Extract<Assistant["content"][number], { type: "tool" }>) => Extract<Assistant["content"][number], { type: "tool" }>,
-) {
-  return updateAssistant(source, messageID, sessionID, (assistant) => ({
-    ...assistant,
-    content: assistant.content.map((item) => item.type === "tool" && item.id === callID ? apply(item) : item),
-  }))
-}
-
-function insertOrdinal<T extends Assistant["content"][number]["type"]>(
-  source: Assistant["content"],
-  type: T,
-  ordinal: number,
-  item: Extract<Assistant["content"][number], { type: T }>,
-) {
-  const matches = source.filter((content) => content.type === type)
-  if (matches[ordinal]) return source
-  return [...source, item]
-}

packages/app/src/context/server-session.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect, test } from "bun:test"
 import type { retry } from "@opencode-ai/core/util/retry"
-import type { MessageApi, OpenCodeEvent, SessionApi } from "@opencode-ai/client/promise"
 import type { Message, OpencodeClient, Part, Session } from "@opencode-ai/sdk/v2/client"
 import { createServerSession } from "./server-session"
 
@@ -159,57 +158,6 @@ function setup(sessions: Record<string, Session>) {
 }
 
 describe("server session", () => {
-  test("projects V2 session events into current and legacy message state", () => {
-    const ctx = setup({ child: session("child") })
-    ctx.store.remember(session("child"))
-    ctx.store.set("session_message", "child", [
-      {
-        id: "msg_1_user",
-        type: "user",
-        text: "hello",
-        time: { created: 1 },
-      },
-    ])
-    const apply = (input: object) => ctx.store.applyV2(input as OpenCodeEvent)
-
-    apply({
-      id: "evt_step",
-      created: 2,
-      type: "session.step.started",
-      durable: { aggregateID: "child", seq: 1, version: 1 },
-      location: { directory: "/repo" },
-      data: {
-        sessionID: "child",
-        assistantMessageID: "msg_2_assistant",
-        agent: "build",
-        model: { id: "model", providerID: "provider" },
-      },
-    })
-    apply({
-      id: "evt_text_start",
-      created: 3,
-      type: "session.text.started",
-      durable: { aggregateID: "child", seq: 2, version: 1 },
-      location: { directory: "/repo" },
-      data: { sessionID: "child", assistantMessageID: "msg_2_assistant", ordinal: 0 },
-    })
-    apply({
-      id: "evt_text_delta",
-      created: 4,
-      type: "session.text.delta",
-      location: { directory: "/repo" },
-      data: { sessionID: "child", assistantMessageID: "msg_2_assistant", ordinal: 0, delta: "world" },
-    })
-
-    expect(ctx.store.data.session_message.child?.at(-1)).toMatchObject({
-      id: "msg_2_assistant",
-      type: "assistant",
-      content: [{ type: "text", text: "world" }],
-    })
-    expect(ctx.store.data.message.child?.map((message) => message.id)).toEqual(["msg_1_user", "msg_2_assistant"])
-    expect(ctx.store.data.part.msg_2_assistant).toMatchObject([{ type: "text", text: "world" }])
-  })
-
   test("resolves lineage by session ID without directory", async () => {
     const ctx = setup({ child: session("child", "root"), root: session("root") })
 
@@ -230,111 +178,6 @@ describe("server session", () => {
     expect(ctx.store.data.message.root).toEqual([])
   })
 
-  test("loads current session content through the current message API", async () => {
-    const requests: unknown[] = []
-    const user = { id: "msg_z_user", type: "user", text: "hello", time: { created: 1 } }
-    const assistant = {
-      id: "msg_a_assistant",
-      type: "assistant",
-      agent: "build",
-      model: { id: "model", providerID: "provider" },
-      content: [{ type: "text", text: "hi" }],
-      time: { created: 2, completed: 3 },
-    }
-    const client = {
-      session: {
-        messages: () => {
-          throw new Error("legacy message endpoint called")
-        },
-      },
-    } as unknown as OpencodeClient
-    const messageApi = {
-      list: async (input: unknown) => {
-        requests.push(input)
-        return { data: [assistant, user], cursor: { previous: null, next: null } }
-      },
-    } as unknown as MessageApi
-    const store = createServerSession(client, {} as SessionApi, messageApi)
-    store.remember(session("root"))
-
-    await store.sync("root")
-
-    expect(requests).toEqual([{ sessionID: "root", limit: 20, order: "desc" }])
-    expect(store.data.session_message.root.map((message) => message.id)).toEqual([user.id, assistant.id])
-  })
-
-  test("reprojects current assistants when an older page supplies their user", async () => {
-    const user = { id: "msg_1_user", type: "user", text: "hello", time: { created: 1 } } as const
-    const assistant = (id: string, created: number) => ({
-      id,
-      type: "assistant" as const,
-      agent: "build",
-      model: { id: "model", providerID: "provider" },
-      content: [{ type: "text" as const, text: id }],
-      time: { created, completed: created },
-    })
-    const assistants = [
-      assistant("msg_2_assistant", 2),
-      assistant("msg_3_assistant", 3),
-      assistant("msg_4_assistant", 4),
-    ]
-    const pages = [
-      { data: assistants.slice(1).toReversed(), cursor: { previous: null, next: "older" } },
-      { data: [assistants[0], user], cursor: { previous: null, next: null } },
-    ]
-    const messageApi = {
-      list: async () => pages.shift()!,
-    } as unknown as MessageApi
-    const store = createServerSession({} as OpencodeClient, {} as SessionApi, messageApi)
-    store.remember(session("root"))
-
-    await store.sync("root")
-    expect(store.data.message.root).toEqual([])
-
-    await store.history.loadMore("root")
-
-    expect(store.data.message.root.map((message) => message.id)).toEqual([
-      user.id,
-      ...assistants.map((item) => item.id),
-    ])
-    expect(assistants.map((item) => store.data.part[item.id]?.[0]?.type)).toEqual(["text", "text", "text"])
-  })
-
-  test("indexes V1 messages for the current timeline projection", async () => {
-    const user = userMessage("message-1", { sessionID: "root" })
-    const assistant = assistantMessage("message-2", user.id, { sessionID: "root" })
-    const client = messageClient(
-      response([
-        { info: user, parts: [textPart(user.id, { sessionID: "root" })] },
-        { info: assistant, parts: [textPart(assistant.id, { sessionID: "root" })] },
-      ]),
-    )
-    const messageApi = {
-      list: () => {
-        throw new Error("current message endpoint called")
-      },
-    } as unknown as MessageApi
-    const store = createServerSession(client, {} as SessionApi, messageApi, {
-      protocol: Promise.resolve("v1"),
-    })
-    store.remember(session("root"))
-
-    await store.sync("root")
-
-    expect(store.data.message.root.map((message) => message.id)).toEqual([user.id, assistant.id])
-    expect(store.data.session_message.root).toMatchObject([
-      { id: user.id, type: "user", text: "text" },
-      { id: assistant.id, type: "assistant" },
-    ])
-
-    const next = userMessage("message-3", { sessionID: "root" })
-    store.apply({ type: "message.updated", properties: { info: next } })
-    expect(store.data.session_message.root.map((message) => message.id)).toEqual([user.id, assistant.id, next.id])
-
-    store.apply({ type: "message.removed", properties: { sessionID: "root", messageID: next.id } })
-    expect(store.data.session_message.root.map((message) => message.id)).toEqual([user.id, assistant.id])
-  })
-
   test("backfills an assistant-only initial page through its user root", async () => {
     const user = userMessage("message-1")
     const assistants = [assistantMessage("message-2", user.id), assistantMessage("message-3", user.id)]

packages/app/src/context/server-session.ts

@@ -1,6 +1,5 @@
 import { Binary } from "@opencode-ai/core/util/binary"
 import { retry } from "@opencode-ai/core/util/retry"
-import type { MessageApi, OpenCodeEvent, SessionApi, SessionMessageInfo } from "@opencode-ai/client/promise"
 import type {
   Message,
   OpencodeClient,
@@ -9,18 +8,15 @@ import type {
   QuestionRequest,
   Session,
   SessionStatus,
+  SnapshotFileDiff,
   Todo,
 } from "@opencode-ai/sdk/v2/client"
-import type { FileDiffInfo } from "@opencode-ai/client/promise"
 import { batch } from "solid-js"
 import { createStore, produce, reconcile } from "solid-js/store"
-import { message as cleanMessage } from "@/utils/diffs"
+import { diffs as cleanDiffs, message as cleanMessage } from "@/utils/diffs"
 import { sessionNotFoundError } from "@/utils/server-errors"
 import { rootSession } from "@/utils/session-route"
-import { normalizeSessionInfo } from "@/utils/session"
-import { normalizeSessionMessages } from "@/utils/session-message"
 import { dropSessionCaches, pickSessionCacheEvictions, SESSION_CACHE_LIMIT } from "./global-sync/session-cache"
-import { createV2SessionReducer, type V2SessionReduction } from "./server-session-v2-reducer"
 
 const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)
 const cmpMessage = (a: Message, b: Message) => a.time.created - b.time.created || cmp(a.id, b.id)
@@ -40,37 +36,10 @@ type OptimisticItem = {
 type MessagePage = {
   session: Message[]
   part: { id: string; part: Part[] }[]
-  source?: SessionMessageInfo[]
-  sourceMode?: "latest" | "older"
-  projectSource?: boolean
   cursor?: string
   complete: boolean
 }
 
-function legacyMessageSource(items: { info: Message; parts: Part[] }[]): SessionMessageInfo[] {
-  return items
-    .slice()
-    .sort((a, b) => cmp(a.info.id, b.info.id))
-    .map((item) => {
-      if (item.info.role === "user") {
-        return {
-          id: item.info.id,
-          type: "user" as const,
-          text: item.parts.flatMap((part) => (part.type === "text" ? [part.text] : [])).join("\n"),
-          time: item.info.time,
-        }
-      }
-      return {
-        id: item.info.id,
-        type: "assistant" as const,
-        agent: item.info.agent ?? item.info.mode,
-        model: { id: item.info.modelID, providerID: item.info.providerID, variant: item.info.variant },
-        content: [],
-        time: item.info.time,
-      }
-    })
-}
-
 // Most markers describe the current HTTP attempt; deltaParts persists non-durable stream state across retries.
 type MessageLoadState = {
   touchedMessages: Set<string>
@@ -83,7 +52,6 @@ type MessageLoadState = {
   optimisticParts: Map<string, Set<string>>
   orphanParents: Set<string>
   clearedMessageParts: Set<string>
-  touchedSource: Set<string>
 }
 
 type MessageLoadBaseline = Pick<
@@ -169,25 +137,15 @@ function reconcileFetched<T extends { id: string }>(
   return [...result.values()].sort((a, b) => cmp(a.id, b.id))
 }
 
-type ServerSessionOptions = { retry?: typeof retry; protocol?: Promise<"v1" | "v2"> }
-
-export function createServerSession(
-  client: OpencodeClient,
-  sessionApiOrOptions?: SessionApi | ServerSessionOptions,
-  messageApi?: MessageApi,
-  currentOptions?: ServerSessionOptions,
-) {
-  const sessionApi = messageApi ? (sessionApiOrOptions as SessionApi) : undefined
-  const options = messageApi ? currentOptions : (sessionApiOrOptions as ServerSessionOptions | undefined)
+export function createServerSession(client: OpencodeClient, options?: { retry?: typeof retry }) {
   const [data, setData] = createStore({
     info: {} as Record<string, Session | undefined>,
     session_status: {} as Record<string, SessionStatus>,
-    session_diff: {} as Record<string, FileDiffInfo[]>,
+    session_diff: {} as Record<string, SnapshotFileDiff[]>,
     todo: {} as Record<string, Todo[]>,
     permission: {} as Record<string, PermissionRequest[]>,
     question: {} as Record<string, QuestionRequest[]>,
     message: {} as Record<string, Message[]>,
-    session_message: {} as Record<string, SessionMessageInfo[]>,
     part: {} as Record<string, Part[]>,
     part_text_accum_delta: {} as Record<string, string>,
     session_working(id: string) {
@@ -196,9 +154,9 @@ export function createServerSession(
   })
   const requests = new Map<string, Promise<Session>>()
   const inflight = new Map<string, Promise<void>>()
+  const inflightDiff = new Map<string, Promise<void>>()
   const inflightTodo = new Map<string, Promise<void>>()
   const optimistic = new Map<string, Map<string, OptimisticItem>>()
-  const v2 = createV2SessionReducer()
   const messageLoads = new Map<string, MessageLoadState>()
   const pendingParts = new Map<string, Map<string, Set<string>>>()
   const orphanParts = new Map<string, Set<string>>()
@@ -233,16 +191,6 @@ export function createServerSession(
     at: {} as Record<string, number | undefined>,
   })
 
-  const indexLegacyMessage = (message: Message) => {
-    const current = data.session_message[message.sessionID] ?? []
-    if (current.some((item) => item.id === message.id)) return
-    setData(
-      "session_message",
-      message.sessionID,
-      reconcile([...current, ...legacyMessageSource([{ info: message, parts: [] }])]),
-    )
-  }
-
   const remember = (session: Session) => {
     setData("info", session.id, reconcile(session))
     infoSeen.delete(session.id)
@@ -252,6 +200,7 @@ export function createServerSession(
         ...pinned.keys(),
         ...requests.keys(),
         ...inflight.keys(),
+        ...inflightDiff.keys(),
         ...inflightTodo.keys(),
         ...messageLoads.keys(),
         ...optimistic.keys(),
@@ -293,31 +242,27 @@ export function createServerSession(
     const pending = requests.get(sessionID)
     if (pending) return pending
     const active = generation(sessionID)
-    const request = sessionApi
-      ? sessionApi.get({ sessionID }).then(normalizeSessionInfo)
-      : client.session.get({ sessionID }).then((result) => {
-          if (!result.data) throw sessionNotFoundError(sessionID)
-          return result.data
-        })
-    const resolved = request.then((result) => {
-      if (generations.get(sessionID) !== active) return result
-      return remember(result)
+    const request = client.session.get({ sessionID }).then((result) => {
+      if (!result.data) throw sessionNotFoundError(sessionID)
+      if (generations.get(sessionID) !== active) return result.data
+      return remember(result.data)
     })
-    requests.set(sessionID, resolved)
+    requests.set(sessionID, request)
     const cleanup = () => {
-      if (requests.get(sessionID) === resolved) requests.delete(sessionID)
+      if (requests.get(sessionID) === request) requests.delete(sessionID)
       if (
         generations.get(sessionID) === active &&
         !data.info[sessionID] &&
         !requests.has(sessionID) &&
         !messageLoads.has(sessionID) &&
         !inflight.has(sessionID) &&
+        !inflightDiff.has(sessionID) &&
         !inflightTodo.has(sessionID)
       )
         generations.delete(sessionID)
     }
-    void resolved.then(cleanup, cleanup)
-    return resolved
+    void request.then(cleanup, cleanup)
+    return request
   }
 
   const peekLineage = (sessionID: string) => {
@@ -474,9 +419,9 @@ export function createServerSession(
       clearOptimistic(sessionID)
       requests.delete(sessionID)
       inflight.delete(sessionID)
+      inflightDiff.delete(sessionID)
       inflightTodo.delete(sessionID)
       messageLoads.delete(sessionID)
-      v2.clear(sessionID)
       pendingParts.delete(sessionID)
       orphanParts.delete(sessionID)
       removedMessages.delete(sessionID)
@@ -504,6 +449,7 @@ export function createServerSession(
       ...pinned.keys(),
       ...requests.keys(),
       ...inflight.keys(),
+      ...inflightDiff.keys(),
       ...inflightTodo.keys(),
       ...messageLoads.keys(),
       ...optimistic.keys(),
@@ -524,25 +470,6 @@ export function createServerSession(
     )
 
   const fetchMessages = async (sessionID: string, limit: number, before?: string, onAttempt?: () => void) => {
-    if (messageApi && (await options?.protocol) !== "v1") {
-      const response = await (options?.retry ?? retry)(() => {
-        onAttempt?.()
-        return messageApi.list(before ? { sessionID, limit, cursor: before } : { sessionID, limit, order: "desc" })
-      })
-      const source = [...response.data].reverse()
-      const normalized = normalizeSessionMessages(sessionID, source)
-      return {
-        session: normalized.messages.sort((a, b) => cmp(a.id, b.id)),
-        part: [...normalized.parts.entries()]
-          .map(([id, part]) => ({ id, part: part.sort((a, b) => cmp(a.id, b.id)) }))
-          .sort((a, b) => cmp(a.id, b.id)),
-        source,
-        sourceMode: before ? ("older" as const) : ("latest" as const),
-        projectSource: true,
-        cursor: response.cursor.next ?? undefined,
-        complete: response.data.length === 0,
-      }
-    }
     const response = await (options?.retry ?? retry)(() => {
       onAttempt?.()
       return client.session.messages({ sessionID, limit, before })
@@ -554,24 +481,12 @@ export function createServerSession(
         id: item.info.id,
         part: item.parts.filter((part) => !!part?.id).sort((a, b) => cmp(a.id, b.id)),
       })),
-      source: legacyMessageSource(items),
-      sourceMode: before ? ("older" as const) : ("latest" as const),
       cursor: response.response.headers.get("x-next-cursor") ?? undefined,
       complete: !response.response.headers.get("x-next-cursor"),
     }
   }
 
   const fetchMessage = async (sessionID: string, messageID: string, onAttempt?: () => void) => {
-    if (sessionApi && (await options?.protocol) !== "v1") {
-      const response = await (options?.retry ?? retry)(() => {
-        onAttempt?.()
-        return sessionApi.message({ sessionID, messageID })
-      })
-      const normalized = normalizeSessionMessages(sessionID, [response])
-      const message = normalized.messages[0]
-      if (!message) throw new Error(`Message not found: ${messageID}`)
-      return { message, parts: normalized.parts.get(messageID) ?? [] }
-    }
     const response = await (options?.retry ?? retry)(() => {
       onAttempt?.()
       return client.session.message({ sessionID, messageID })
@@ -656,31 +571,7 @@ export function createServerSession(
     preserveUnfetched: boolean | ((message: Message) => boolean),
     cleanupOrphans: boolean,
   ) => {
-    const source = page.source
-      ? (() => {
-          const incoming = new Map(page.source.map((message) => [message.id, message]))
-          const existing = data.session_message[sessionID] ?? []
-          const current = existing.filter((message) => !incoming.has(message.id))
-          const live = new Map(existing.map((message) => [message.id, message]))
-          return (page.sourceMode === "older" ? [...page.source, ...current] : [...current, ...page.source]).map(
-            (message) => (load?.touchedSource.has(message.id) ? (live.get(message.id) ?? message) : message),
-          )
-        })()
-      : undefined
-    const projected =
-      page.projectSource && source
-        ? (() => {
-            const normalized = normalizeSessionMessages(sessionID, source)
-            return {
-              ...page,
-              session: normalized.messages.sort((a, b) => cmp(a.id, b.id)),
-              part: [...normalized.parts.entries()]
-                .map(([id, part]) => ({ id, part: part.sort((a, b) => cmp(a.id, b.id)) }))
-                .sort((a, b) => cmp(a.id, b.id)),
-            }
-          })()
-        : page
-    const merged = mergeOptimisticPage(projected, [...(optimistic.get(sessionID)?.values() ?? [])])
+    const merged = mergeOptimisticPage(page, [...(optimistic.get(sessionID)?.values() ?? [])])
     merged.observed.forEach((item) => {
       if (!load?.clearedMessageParts.has(item.messageID)) confirmOptimistic(sessionID, item.messageID, item.parts)
     })
@@ -692,7 +583,6 @@ export function createServerSession(
       preserveUnfetched,
     })
     batch(() => {
-      if (source) setData("session_message", sessionID, reconcile(source))
       const messageIDs = replaceMessages(sessionID, messages)
       replaceParts(sessionID, merged.part, messageIDs, load)
       const orphans = orphanParts.get(sessionID)
@@ -723,7 +613,6 @@ export function createServerSession(
       optimisticParts: new Map(),
       orphanParents: new Set(),
       clearedMessageParts: new Set(),
-      touchedSource: new Set(),
     }
     messageLoads.set(sessionID, load)
     setMeta("loading", sessionID, true)
@@ -858,109 +747,6 @@ export function createServerSession(
       return properties.part.sessionID
   }
 
-  const projectV2 = (reduction: V2SessionReduction) => {
-    reduction.touched.forEach((messageID) => messageLoads.get(reduction.sessionID)?.touchedSource.add(messageID))
-    setData("session_message", reduction.sessionID, reconcile(reduction.messages))
-    if (reduction.touched.length === 0) return
-
-    const touched = new Set(reduction.touched)
-    let parentID: string | undefined
-    for (const message of reduction.messages) {
-      if (message.type === "user" || (message.type === "synthetic" && message.description?.trim()))
-        parentID = message.id
-      if (message.type === "shell") {
-        if (touched.has(message.id)) touched.add(`${message.id}:assistant`)
-        parentID = undefined
-      }
-      if (message.type === "assistant" && touched.has(message.id) && parentID) touched.add(parentID)
-      if (message.type === "compaction" && touched.has(message.id) && parentID) touched.add(parentID)
-    }
-
-    const normalized = normalizeSessionMessages(reduction.sessionID, reduction.messages)
-    batch(() => {
-      for (const message of normalized.messages) {
-        if (!touched.has(message.id)) continue
-        apply({ type: "message.updated", properties: { sessionID: reduction.sessionID, info: message } })
-      }
-      for (const messageID of touched) {
-        const next = normalized.parts.get(messageID) ?? []
-        const nextIDs = new Set(next.map((part) => part.id))
-        for (const part of next) {
-          apply({ type: "message.part.updated", properties: { sessionID: reduction.sessionID, part } })
-        }
-        for (const part of data.part[messageID] ?? []) {
-          if (nextIDs.has(part.id)) continue
-          apply({
-            type: "message.part.removed",
-            properties: { sessionID: reduction.sessionID, messageID, partID: part.id },
-          })
-        }
-      }
-    })
-  }
-
-  const hydrateV2Message = (sessionID: string, messageID: string) => {
-    if (!sessionApi) return
-    void sessionApi
-      .message({ sessionID, messageID })
-      .then((message) => {
-        const current = data.session_message[sessionID] ?? []
-        const messages = [...current.filter((item) => item.id !== message.id), message].sort((a, b) => cmp(a.id, b.id))
-        projectV2({ sessionID, messages, touched: [message.id] })
-      })
-      .catch(() => {})
-  }
-
-  const applyV2 = (event: OpenCodeEvent) => {
-    if (!("data" in event) || !("sessionID" in event.data) || typeof event.data.sessionID !== "string") return
-    const sessionID = event.data.sessionID
-    const reduction = v2.reduce(data.session_message[sessionID] ?? [], event)
-    if (reduction) {
-      projectV2(reduction)
-      if (reduction.missing) hydrateV2Message(sessionID, reduction.missing)
-    }
-
-    const info = data.info[sessionID]
-    if (event.type === "session.renamed" && info)
-      remember({ ...info, title: event.data.title, time: { ...info.time, updated: event.created } })
-    if (event.type === "session.moved" && info)
-      remember({
-        ...info,
-        projectID: event.data.projectID ?? info.projectID,
-        workspaceID: event.data.location.workspaceID,
-        directory: event.data.location.directory,
-        path: event.data.subpath,
-        time: { ...info.time, updated: event.created },
-      })
-    if (event.type === "session.usage.updated" && info)
-      remember({ ...info, cost: event.data.cost, tokens: event.data.tokens })
-    if (event.type === "session.archived") {
-      if (info) remember({ ...info, time: { ...info.time, archived: event.created, updated: event.created } })
-      evict([sessionID])
-    }
-    if (event.type === "session.execution.started") setData("session_status", sessionID, { type: "busy" })
-    if (
-      event.type === "session.execution.succeeded" ||
-      event.type === "session.execution.failed" ||
-      event.type === "session.execution.interrupted"
-    )
-      setData("session_status", sessionID, { type: "idle" })
-    if (event.type === "session.retry.scheduled")
-      setData("session_status", sessionID, {
-        type: "retry",
-        attempt: event.data.attempt,
-        message: event.data.error.message,
-        next: event.data.at,
-      })
-    if (event.type === "session.forked") void resolve(sessionID, { force: true }).catch(() => {})
-    if (
-      event.type === "session.revert.staged" ||
-      event.type === "session.revert.cleared" ||
-      event.type === "session.revert.committed"
-    )
-      void resolve(sessionID, { force: true }).catch(() => {})
-  }
-
   const apply = (event: { type: string; properties?: unknown }) => {
     const eventID = eventSessionID(event)
     if (eventID) {
@@ -984,9 +770,7 @@ export function createServerSession(
         return
       }
       case "session.deleted": {
-        const properties = event.properties as { sessionID?: string; info?: Session }
-        const sessionID = properties.info?.id ?? properties.sessionID
-        if (!sessionID) return
+        const sessionID = (event.properties as { info: Session }).info.id
         infoSeen.delete(sessionID)
         setData(
           "info",
@@ -995,6 +779,11 @@ export function createServerSession(
         evict([sessionID])
         return
       }
+      case "session.diff": {
+        const props = event.properties as { sessionID: string; diff: SnapshotFileDiff[] }
+        setData("session_diff", props.sessionID, reconcile(cleanDiffs(props.diff), { key: "file" }))
+        return
+      }
       case "todo.updated": {
         const props = event.properties as { sessionID: string; todos: Todo[] }
         setData("todo", props.sessionID, reconcile(props.todos, { key: "id" }))
@@ -1007,7 +796,6 @@ export function createServerSession(
       }
       case "message.updated": {
         const info = cleanMessage((event.properties as { info: Message }).info)
-        indexLegacyMessage(info)
         const load = messageLoads.get(info.sessionID)
         load?.touchedMessages.add(info.id)
         load?.removedMessages.delete(info.id)
@@ -1040,9 +828,6 @@ export function createServerSession(
       }
       case "message.removed": {
         const props = event.properties as { sessionID: string; messageID: string }
-        setData("session_message", props.sessionID, (messages) =>
-          messages?.filter((message) => message.id !== props.messageID),
-        )
         const load = messageLoads.get(props.sessionID)
         load?.touchedMessages.add(props.messageID)
         load?.removedMessages.add(props.messageID)
@@ -1355,16 +1140,23 @@ export function createServerSession(
         setData(produce((draft) => deleteMessageParts(draft, input.messageID)))
       },
     },
-    async todo(sessionID: string, request?: { force?: boolean }) {
+    diff(sessionID: string, options?: { force?: boolean }) {
       touch(sessionID)
-      if (data.todo[sessionID] !== undefined && !request?.force) return
-      if ((await options?.protocol) === "v2") {
-        setData("todo", sessionID, [])
-        return
-      }
+      if (data.session_diff[sessionID] !== undefined && !options?.force) return Promise.resolve()
+      return runInflight(inflightDiff, sessionID, () => {
+        const active = generation(sessionID)
+        return retry(() => client.session.diff({ sessionID })).then((result) => {
+          if (generations.get(sessionID) !== active) return
+          setData("session_diff", sessionID, reconcile(cleanDiffs(result.data), { key: "file" }))
+        })
+      })
+    },
+    todo(sessionID: string, options?: { force?: boolean }) {
+      touch(sessionID)
+      if (data.todo[sessionID] !== undefined && !options?.force) return Promise.resolve()
       return runInflight(inflightTodo, sessionID, () => {
         const active = generation(sessionID)
-        return (options?.retry ?? retry)(() => client.session.todo({ sessionID })).then((result) => {
+        return retry(() => client.session.todo({ sessionID })).then((result) => {
           if (generations.get(sessionID) !== active) return
           setData("todo", sessionID, reconcile(result.data ?? [], { key: "id" }))
         })
@@ -1398,7 +1190,6 @@ export function createServerSession(
       if (count && count > 1) pinned.set(sessionID, count - 1)
     },
     apply,
-    applyV2,
   }
 }
 

packages/app/src/context/server-sync.test.ts

@@ -1,108 +1,6 @@
 import { describe, expect, test } from "bun:test"
-import type { OpencodeClient } from "@opencode-ai/sdk/v2/client"
-import type {
-  McpApi,
-  McpListInput,
-  McpResourceCatalogInput,
-  SessionApi,
-  SessionInfo,
-  SessionListInput,
-} from "@opencode-ai/client/promise"
-import { QueryClient } from "@tanstack/solid-query"
 import { canDisposeDirectory, pickDirectoriesToEvict } from "./global-sync/eviction"
-import { estimateRootSessionTotal, loadRootSessions } from "./global-sync/session-load"
-import {
-  loadActiveSessionsQuery,
-  loadMcpQuery,
-  loadMcpResourcesQuery,
-  seedActiveSessionStatuses,
-} from "./server-sync"
-import { ServerScope } from "@/utils/server-scope"
-import { createServerSession } from "./server-session"
-
-describe("MCP queries", () => {
-  test("loads current servers for the requested location", async () => {
-    const calls: unknown[] = []
-    const queryClient = new QueryClient()
-    const result = await queryClient.fetchQuery(
-      loadMcpQuery(ServerScope.local, "/project", {
-        list: async (input: McpListInput = {}) => {
-          calls.push(input)
-          return {
-            location: { directory: "/project", project: { id: "project", directory: "/project" } },
-            data: [
-              { name: "docs", status: { status: "connected" } },
-              { name: "search", status: { status: "pending" } },
-            ],
-          }
-        },
-      } as unknown as McpApi),
-    )
-
-    expect(calls).toEqual([{ location: { directory: "/project" } }])
-    expect(result).toEqual({ docs: { status: "connected" }, search: { status: "pending" } })
-  })
-
-  test("loads and keys the current resource catalog", async () => {
-    const calls: unknown[] = []
-    const queryClient = new QueryClient()
-    const result = await queryClient.fetchQuery(
-      loadMcpResourcesQuery(ServerScope.local, "/project", {
-        resource: {
-          catalog: async (input: McpResourceCatalogInput = {}) => {
-            calls.push(input)
-            return {
-              location: { directory: "/project", project: { id: "project", directory: "/project" } },
-              data: {
-                resources: [{ server: "docs", name: "Guide", uri: "docs://guide" }],
-                templates: [],
-              },
-            }
-          },
-        },
-      } as unknown as McpApi),
-    )
-
-    expect(calls).toEqual([{ location: { directory: "/project" } }])
-    expect(result).toEqual({ "docs:docs://guide": { server: "docs", name: "Guide", uri: "docs://guide" } })
-  })
-})
-
-describe("active session query", () => {
-  test("loads active sessions once per server cache", async () => {
-    let calls = 0
-    const queryClient = new QueryClient()
-    const options = loadActiveSessionsQuery(ServerScope.local, {
-      active: async () => {
-        calls++
-        return { ses_running: { type: "running" } }
-      },
-    })
-
-    expect(await queryClient.fetchQuery(options)).toEqual({ ses_running: { type: "running" } })
-    expect(await queryClient.fetchQuery(options)).toEqual({ ses_running: { type: "running" } })
-    expect(calls).toBe(1)
-    expect([...options.queryKey]).toEqual([ServerScope.local, "activeSessions"])
-  })
-
-  test("does not overwrite statuses already written by events", () => {
-    const session = createServerSession({} as OpencodeClient)
-    session.set("session_status", "ses_retry", { type: "retry", attempt: 2, message: "retrying", next: 10 })
-
-    seedActiveSessionStatuses(session, {
-      ses_running: { type: "running" },
-      ses_retry: { type: "running" },
-    })
-
-    expect(session.data.session_status.ses_running).toEqual({ type: "busy" })
-    expect(session.data.session_status.ses_retry).toEqual({
-      type: "retry",
-      attempt: 2,
-      message: "retrying",
-      next: 10,
-    })
-  })
-})
+import { estimateRootSessionTotal, loadRootSessionsWithFallback } from "./global-sync/session-load"
 
 describe("pickDirectoriesToEvict", () => {
   test("keeps pinned stores and evicts idle stores", () => {
@@ -125,57 +23,46 @@ describe("pickDirectoriesToEvict", () => {
   })
 })
 
-describe("loadRootSessions", () => {
-  test("loads and normalizes a limited page of root sessions", async () => {
-    const calls: SessionListInput[] = []
+describe("loadRootSessionsWithFallback", () => {
+  test("uses limited roots query when supported", async () => {
+    const calls: Array<{ directory: string; roots: true; limit?: number }> = []
 
-    const result = await loadRootSessions({
-      api: {
-        list: async (query = {}) => {
-          calls.push(query)
-          return { data: [sessionInfo("session-1")], cursor: {} }
-        },
-      } satisfies Pick<SessionApi, "list">,
+    const result = await loadRootSessionsWithFallback({
       directory: "dir",
       limit: 10,
+      list: async (query) => {
+        calls.push(query)
+        return { data: [] }
+      },
     })
 
-    expect(result.data).toEqual([
-      expect.objectContaining({ id: "session-1", directory: "dir", slug: "session-1", version: "" }),
-    ])
+    expect(result.data).toEqual([])
     expect(result.limited).toBe(true)
-    expect(calls).toEqual([{ directory: "dir", parentID: null, limit: 10, order: "desc" }])
+    expect(calls).toEqual([{ directory: "dir", roots: true, limit: 10 }])
   })
 
-  test("propagates list failures", () => {
-    expect(
-      loadRootSessions({
-        api: {
-          list: async () => {
-            throw new Error("failed")
-          },
-        } satisfies Pick<SessionApi, "list">,
-        directory: "dir",
-        limit: 25,
-      }),
-    ).rejects.toThrow("failed")
+  test("falls back to full roots query on limited-query failure", async () => {
+    const calls: Array<{ directory: string; roots: true; limit?: number }> = []
+
+    const result = await loadRootSessionsWithFallback({
+      directory: "dir",
+      limit: 25,
+      list: async (query) => {
+        calls.push(query)
+        if (query.limit) throw new Error("unsupported")
+        return { data: [] }
+      },
+    })
+
+    expect(result.data).toEqual([])
+    expect(result.limited).toBe(false)
+    expect(calls).toEqual([
+      { directory: "dir", roots: true, limit: 25 },
+      { directory: "dir", roots: true },
+    ])
   })
 })
 
-function sessionInfo(id: string) {
-  return {
-    id,
-    projectID: "project-1",
-    agent: "build",
-    model: { id: "model-1", providerID: "provider-1" },
-    cost: 0,
-    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-    time: { created: 1, updated: 1 },
-    title: id,
-    location: { directory: "dir" },
-  } as SessionInfo
-}
-
 describe("estimateRootSessionTotal", () => {
   test("keeps exact total for full fetches", () => {
     expect(estimateRootSessionTotal({ count: 42, limit: 10, limited: false })).toBe(42)

packages/app/src/context/server-sync.tsx

@@ -1,10 +1,10 @@
 import type {
   Config,
+  McpResource,
   OpencodeClient,
   Path,
   Project,
   ProviderAuthResponse,
-  SessionStatus,
 } from "@opencode-ai/sdk/v2/client"
 import { showToast } from "@/utils/toast"
 import { getFilename } from "@opencode-ai/core/util/path"
@@ -18,7 +18,6 @@ import {
   bootstrapGlobal,
   clearProviderRev,
   loadAgentsQuery,
-  loadCommands,
   loadGlobalConfigQuery,
   loadPathQuery,
   loadProjectsQuery,
@@ -27,13 +26,12 @@ import {
 } from "./global-sync/bootstrap"
 import { createChildStoreManager } from "./global-sync/child-store"
 import { applyDirectoryEvent, applyGlobalEvent } from "./global-sync/event-reducer"
-import { estimateRootSessionTotal, loadRootSessions, loadRootSessionsV1 } from "./global-sync/session-load"
+import { estimateRootSessionTotal, loadRootSessionsWithFallback } from "./global-sync/session-load"
 import { trimSessions } from "./global-sync/session-trim"
 import type { ProjectMeta } from "./global-sync/types"
 import { SESSION_RECENT_LIMIT } from "./global-sync/types"
 import { formatServerError } from "@/utils/server-errors"
 import { queryOptions, useMutation, useQueries, useQuery, useQueryClient } from "@tanstack/solid-query"
-import type { SolidQueryOptions } from "@tanstack/solid-query"
 import { createRefreshQueue } from "./global-sync/queue"
 import { directoryKey } from "./global-sync/utils"
 import { PathKey } from "@/utils/path-key"
@@ -47,18 +45,8 @@ import { retry } from "@opencode-ai/core/util/retry"
 import type { ServerScope } from "@/utils/server-scope"
 import { createHomeSessionIndexCache } from "./global-sync/home-session-index"
 import { persisted } from "@/utils/persist"
-import type { ServerApi } from "@/utils/server"
-import type {
-  McpListInput,
-  McpListOutput,
-  McpResource,
-  McpResourceCatalogInput,
-  McpResourceCatalogOutput,
-  McpServer,
-  SessionActiveOutput,
-} from "@opencode-ai/client/promise"
 import { toggleMcp } from "./global-sync/mcp"
-import { createServerSession, type ServerSession } from "./server-session"
+import { createServerSession } from "./server-session"
 
 type GlobalStore = {
   ready: boolean
@@ -71,76 +59,16 @@ type GlobalStore = {
   reload: undefined | "pending" | "complete"
 }
 
-type McpListApi = {
-  readonly list: (input?: McpListInput) => Promise<McpListOutput>
-}
-
-type McpResourceApi = {
-  readonly resource: {
-    readonly catalog: (input?: McpResourceCatalogInput) => Promise<McpResourceCatalogOutput>
-  }
-}
-
-type ApiQueryOptions<T, K extends readonly unknown[]> = SolidQueryOptions<T, Error, T, K> & {
-  initialData?: undefined
-  queryKey: K
-}
-
-type SessionActiveApi = {
-  readonly active: () => Promise<SessionActiveOutput>
-}
-
-export const loadMcpQuery = (
-  scope: ServerScope,
-  directory: string,
-  api: McpListApi,
-  legacy?: OpencodeClient,
-  protocol?: Promise<"v1" | "v2">,
-): ApiQueryOptions<Record<string, McpServer["status"]>, readonly [ServerScope, string, "mcp"]> =>
-  queryOptions<
-    Record<string, McpServer["status"]>,
-    Error,
-    Record<string, McpServer["status"]>,
-    readonly [ServerScope, string, "mcp"]
-  >({
+export const loadMcpQuery = (scope: ServerScope, directory: string, sdk: OpencodeClient) =>
+  queryOptions({
     queryKey: [scope, directory, "mcp"] as const,
-    queryFn: async () => {
-      if ((await protocol) === "v1" && legacy) return (await legacy.mcp.status()).data ?? {}
-      return api
-        .list({ location: { directory } })
-        .then((result) => Object.fromEntries(result.data.map((server) => [server.name, server.status])))
-    },
+    queryFn: () => sdk.mcp.status().then((r) => r.data ?? {}),
   })
 
-export const loadMcpResourcesQuery = (
-  scope: ServerScope,
-  directory: string,
-  api: McpResourceApi,
-  legacy?: OpencodeClient,
-  protocol?: Promise<"v1" | "v2">,
-): ApiQueryOptions<Record<string, McpResource>, readonly [ServerScope, string, "mcpResources"]> =>
-  queryOptions<
-    Record<string, McpResource>,
-    Error,
-    Record<string, McpResource>,
-    readonly [ServerScope, string, "mcpResources"]
-  >({
+export const loadMcpResourcesQuery = (scope: ServerScope, directory: string, sdk: OpencodeClient) =>
+  queryOptions<Record<string, McpResource>>({
     queryKey: [scope, directory, "mcpResources"] as const,
-    queryFn: async () => {
-      if ((await protocol) === "v1" && legacy) {
-        return Object.fromEntries(
-          Object.entries((await legacy.experimental.resource.list()).data ?? {}).map(([key, resource]) => [
-            key,
-            { ...resource, server: resource.client },
-          ]),
-        )
-      }
-      return api.resource
-        .catalog({ location: { directory } })
-        .then((result) =>
-          Object.fromEntries(result.data.resources.map((resource) => [`${resource.server}:${resource.uri}`, resource])),
-        )
-    },
+    queryFn: () => sdk.experimental.resource.list().then((r) => r.data ?? {}),
     placeholderData: {},
   })
 
@@ -150,51 +78,22 @@ export const loadLspQuery = (scope: ServerScope, directory: string, sdk: Opencod
     queryFn: () => sdk.lsp.status().then((r) => r.data ?? []),
   })
 
-export const loadActiveSessionsQuery = (
-  scope: ServerScope,
-  api: SessionActiveApi,
-): ApiQueryOptions<SessionActiveOutput, readonly [ServerScope, "activeSessions"]> =>
-  queryOptions<SessionActiveOutput, Error, SessionActiveOutput, readonly [ServerScope, "activeSessions"]>({
-    queryKey: [scope, "activeSessions"] as const,
-    queryFn: () => api.active(),
-    enabled: false,
-    staleTime: Number.POSITIVE_INFINITY,
-    gcTime: Number.POSITIVE_INFINITY,
-    refetchOnMount: false,
-    refetchOnReconnect: false,
-    refetchOnWindowFocus: false,
-  })
-
-export function seedActiveSessionStatuses(
-  session: Pick<ServerSession, "data" | "set">,
-  active: SessionActiveOutput | Record<string, SessionStatus>,
-) {
-  for (const sessionID of Object.keys(active)) {
-    if (session.data.session_status[sessionID] !== undefined) continue
-    const status = active[sessionID]
-    session.set("session_status", sessionID, status?.type === "running" ? { type: "busy" } : status)
-  }
-}
-
 function makeQueryOptionsApi(
   scope: ServerScope,
   serverSDK: () => OpencodeClient,
-  serverAPI: ServerApi,
   sdkFor: (dir: PathKey) => OpencodeClient,
-  protocol: Promise<"v1" | "v2">,
 ) {
   return {
     globalConfig: () => loadGlobalConfigQuery(scope, serverSDK()),
-    projects: () => loadProjectsQuery(scope, serverAPI.project),
+    projects: () => loadProjectsQuery(scope, serverSDK()),
     providers: (directory: PathKey | null) =>
-      loadProvidersQuery(scope, directory, serverAPI, directory ? sdkFor(directory) : serverSDK(), protocol),
-    path: (directory: PathKey | null) => loadPathQuery(scope, directory, serverAPI.path),
-    agents: (directory: PathKey) => loadAgentsQuery(scope, directory, serverAPI.agent, sdkFor(directory), protocol),
-    references: (directory: PathKey) =>
-      loadReferencesQuery(scope, directory, serverAPI.reference, sdkFor(directory), protocol),
-    mcp: (directory: PathKey) => loadMcpQuery(scope, directory, serverAPI.mcp, sdkFor(directory), protocol),
-    mcpResources: (directory: PathKey) =>
-      loadMcpResourcesQuery(scope, directory, serverAPI.mcp, sdkFor(directory), protocol),
+      loadProvidersQuery(scope, directory, directory === null ? serverSDK() : sdkFor(directory)),
+    path: (directory: PathKey | null) =>
+      loadPathQuery(scope, directory, directory === null ? serverSDK() : sdkFor(directory)),
+    agents: (directory: PathKey) => loadAgentsQuery(scope, directory, sdkFor(directory)),
+    references: (directory: PathKey) => loadReferencesQuery(scope, directory, sdkFor(directory)),
+    mcp: (directory: PathKey) => loadMcpQuery(scope, directory, sdkFor(directory)),
+    mcpResources: (directory: PathKey) => loadMcpResourcesQuery(scope, directory, sdkFor(directory)),
     lsp: (directory: PathKey) => loadLspQuery(scope, directory, sdkFor(directory)),
     sessions: (directory: PathKey) => ({ queryKey: [scope, directory, "loadSessions"] as const }),
   }
@@ -223,44 +122,11 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
     return sdk
   }
 
-  const session = createServerSession(serverSDK.client, serverSDK.api.session, serverSDK.api.message, {
-    protocol: serverSDK.protocol,
-  })
-  const queryOptionsApi = makeQueryOptionsApi(
-    serverSDK.scope,
-    () => serverSDK.client,
-    serverSDK.api,
-    sdkFor,
-    serverSDK.protocol,
-  )
+  const queryOptionsApi = makeQueryOptionsApi(serverSDK.scope, () => serverSDK.client, sdkFor)
 
   const [configQuery, providerQuery, pathQuery] = useQueries(() => ({
     queries: [queryOptionsApi.globalConfig(), queryOptionsApi.providers(null), queryOptionsApi.path(null)],
   }))
-  const activeSessionsQuery = useQuery(() =>
-    loadActiveSessionsQuery(serverSDK.scope, {
-      active: async () => {
-        if ((await serverSDK.protocol) === "v1") {
-          const statuses = (await serverSDK.client.session.status()).data ?? {}
-          for (const [sessionID, status] of Object.entries(statuses)) {
-            session.set("session_status", sessionID, reconcile(status))
-            void session.resolve(sessionID).catch(() => undefined)
-          }
-          return Object.fromEntries(
-            Object.entries(statuses).flatMap(([sessionID, status]) =>
-              status.type === "idle" ? [] : [[sessionID, { type: "running" as const }]],
-            ),
-          )
-        }
-        const active = await serverSDK.api.session.active()
-        seedActiveSessionStatuses(session, active)
-        for (const sessionID of Object.keys(active)) {
-          void session.resolve(sessionID).catch(() => undefined)
-        }
-        return active
-      },
-    }),
-  )
 
   const [globalStore, setGlobalStore] = createStore<GlobalStore>({
     get ready() {
@@ -317,8 +183,6 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
     queryFn: async () => {
       await bootstrapGlobal({
         serverSDK: serverSDK.client,
-        serverAPI: serverSDK.api,
-        protocol: serverSDK.protocol,
         scope: serverSDK.scope,
         requestFailedTitle: language.t("common.requestFailed"),
         translate: language.t,
@@ -348,6 +212,8 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
     bootstrapInstance,
   })
 
+  const session = createServerSession(serverSDK.client)
+
   const children = createChildStoreManager({
     owner,
     scope: serverSDK.scope,
@@ -358,15 +224,17 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
       void bootstrapInstance(directory)
     },
     onMcp: (directory, setStore) => {
-      void loadCommands(directory, serverSDK.api.command, sdkFor(directory), serverSDK.protocol)
-        .then((commands) => setStore("command", commands))
-        .catch((err) => {
-          showToast({
-            variant: "error",
-            title: language.t("toast.project.reloadFailed.title", { project: getFilename(directory) }),
-            description: formatServerError(err, language.t),
-          })
+      void retry(() =>
+        sdkFor(directory)
+          .command.list()
+          .then((x) => setStore("command", x.data ?? [])),
+      ).catch((err) => {
+        showToast({
+          variant: "error",
+          title: language.t("toast.project.reloadFailed.title", { project: getFilename(directory) }),
+          description: formatServerError(err, language.t),
         })
+      })
     },
     onDispose: (directory) => {
       const key = directoryKey(directory)
@@ -411,12 +279,11 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
       .fetchQuery({
         ...queryOptionsApi.sessions(key),
         queryFn: () =>
-          serverSDK.protocol
-            .then((protocol) =>
-              protocol === "v1"
-                ? loadRootSessionsV1({ client: sdkFor(directory), directory, limit })
-                : loadRootSessions({ api: serverSDK.api.session, directory, limit }),
-            )
+          loadRootSessionsWithFallback({
+            directory,
+            limit,
+            list: (query) => serverSDK.client.session.list(query),
+          })
             .then((x) => {
               const nonArchived = (x.data ?? [])
                 .filter((s) => !!s?.id)
@@ -486,7 +353,6 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
           provider: globalStore.provider,
         },
         sdk,
-        api: serverSDK.api,
         store: child[0],
         setStore: child[1],
         vcsCache: cache,
@@ -494,7 +360,6 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
         translate: language.t,
         queryClient,
         session,
-        protocol: serverSDK.protocol,
       })
     })
 
@@ -506,31 +371,12 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
     return promise
   }
 
-  const indexSession = (info: Parameters<typeof session.remember>[0]) => {
-    const key = directoryKey(info.directory)
-    const existing = children.children[key]
-    if (!existing) return
-    applyDirectoryEvent({
-      event: { type: "session.created", properties: { info } },
-      directory: key,
-      store: existing[0],
-      setStore: existing[1],
-      push: queue.push,
-      retainedLimit: sessionMeta.get(key)?.limit,
-      sessionContent: false,
-      permission: session.data.permission,
-      loadLsp() {},
-    })
-  }
-
   const unsub = serverSDK.event.listen((e) => {
     const directory = e.name
     const key = directoryKey(directory)
     const event = e.details
-    const eventType: string = event.type
     const recent = bootingRoot || Date.now() - bootedAt < 1500
 
-    if (event.current) session.applyV2(event.current)
     session.apply(event)
     if (event.type === "session.created" || event.type === "session.updated" || event.type === "session.deleted") {
       homeSessions.apply(event)
@@ -538,8 +384,6 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
     homeSessions.refresh(event.type)
 
     if (directory === "global") {
-      if (eventType === "server.connected" && activeSessionsQuery.data === undefined && !activeSessionsQuery.isFetching)
-        void activeSessionsQuery.refetch()
       applyGlobalEvent({
         event,
         project: globalStore.project,
@@ -549,14 +393,7 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
         },
         setGlobalProject: setProjects,
       })
-      if (
-        eventType === "config.updated" ||
-        eventType === "catalog.updated" ||
-        eventType === "agent.updated" ||
-        eventType === "project.directories.updated"
-      )
-        bootstrap.refetch()
-      if (eventType === "server.connected" || eventType === "global.disposed") {
+      if (event.type === "server.connected" || event.type === "global.disposed") {
         if (recent) return
         for (const directory of Object.keys(children.children)) {
           if (!children.active(directory)) continue
@@ -566,30 +403,9 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
       return
     }
 
-    if (event.current?.type === "session.moved") {
-      const info = session.get(event.current.data.sessionID)
-      if (info) indexSession(info)
-    }
-    if (event.current?.type === "session.forked")
-      void session
-        .resolve(event.current.data.sessionID, { force: true })
-        .then(indexSession)
-        .catch(() => {})
-
     const existing = children.children[key]
     if (!existing) return
     children.mark(key)
-    if (
-      event.current?.type === "session.moved" ||
-      event.current?.type === "session.archived" ||
-      event.current?.type === "session.forked" ||
-      eventType === "command.updated" ||
-      eventType === "config.updated" ||
-      eventType === "agent.updated"
-    )
-      queue.push(key)
-    if (eventType === "mcp.status.changed") void queryClient.invalidateQueries(queryOptionsApi.mcp(key))
-    if (eventType === "mcp.resources.changed") void queryClient.invalidateQueries(queryOptionsApi.mcpResources(key))
     const [store, setStore] = existing
     applyDirectoryEvent({
       event,
@@ -686,23 +502,14 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
       toggle: async (directory: string, name: string) => {
         const key = directoryKey(directory)
         const sdk = sdkFor(key)
-        const status = children.child(key, { bootstrap: false })[0].mcp[name]?.status
-        if (!status) return
+        const status = children.child(key, { bootstrap: false })[0].mcp[name].status
         await toggleMcp({
           status,
           connect: async () => {
-            if ((await serverSDK.protocol) === "v1") {
-              await sdk.mcp.connect({ name })
-              return
-            }
-            await serverSDK.api.mcp.connect({ server: name, location: { directory: key } })
+            await sdk.mcp.connect({ name })
           },
           disconnect: async () => {
-            if ((await serverSDK.protocol) === "v1") {
-              await sdk.mcp.disconnect({ name })
-              return
-            }
-            await serverSDK.api.mcp.disconnect({ server: name, location: { directory: key } })
+            await sdk.mcp.disconnect({ name })
           },
           authenticate: async () => {
             await sdk.mcp.auth.authenticate({ name })

packages/app/src/pages/home-session-archive.test.ts

@@ -19,7 +19,7 @@ test("archiving a Home session removes its open titlebar tab", async () => {
   await archiveHomeSession({
     server: remote,
     session: { id: "ses_1", directory: "/workspace" },
-    archive: async () => undefined,
+    update: async () => undefined,
     remove: () => {
       removed = true
     },
@@ -37,7 +37,7 @@ test("reports archive failures without removing the session", async () => {
   await archiveHomeSession({
     server: remote,
     session: { id: "ses_1", directory: "/workspace" },
-    archive: async () => Promise.reject(failure),
+    update: async () => Promise.reject(failure),
     remove: () => {
       removed = true
     },

packages/app/src/pages/home-session-archive.ts

@@ -6,15 +6,25 @@ type HomeSession = {
   directory: string
 }
 
+type SessionUpdate = {
+  directory: string
+  sessionID: string
+  time: { archived: number }
+}
+
 export async function archiveHomeSession(input: {
   server: ServerConnection.Key
   session: HomeSession
-  archive: (sessionID: string) => Promise<unknown>
+  update: (value: SessionUpdate) => Promise<unknown>
   remove: () => void
   onError?: (error: unknown) => void
 }) {
   await input
-    .archive(input.session.id)
+    .update({
+      directory: input.session.directory,
+      sessionID: input.session.id,
+      time: { archived: Date.now() },
+    })
     .then(() => {
       input.remove()
       notifySessionTabsRemoved({

packages/app/src/pages/home.tsx

@@ -606,7 +606,7 @@ export function NewHome() {
     await archiveHomeSession({
       server: ServerConnection.key(conn),
       session,
-      archive: (sessionID) => ctx.sdk.api.session.archive({ sessionID, directory: session.directory }),
+      update: (value) => ctx.sdk.client.session.update(value),
       remove: () =>
         setStore(
           produce((draft) => {

packages/app/src/pages/layout.tsx

@@ -36,7 +36,6 @@ import { useProviders } from "@/hooks/use-providers"
 import { toaster } from "@opencode-ai/ui/toast"
 import { setV2Toast, showToast, ToastRegion } from "@/utils/toast"
 import { useServerSDK } from "@/context/server-sdk"
-import { normalizeProjectInfo } from "@/context/global-sync/utils"
 import { clearWorkspaceTerminals } from "@/context/terminal"
 import { pickSessionCacheEvictions } from "@/context/global-sync/session-cache"
 import { useNotification } from "@/context/notification"
@@ -49,7 +48,6 @@ import { setNavigate } from "@/utils/notification-click"
 import { Worktree as WorktreeState } from "@/utils/worktree"
 import { setSessionHandoff } from "@/pages/session/handoff"
 import { SessionRouteKey, SessionStateKey } from "@/utils/server-scope"
-import { listAllSessions } from "@/utils/session"
 
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { useTheme, type ColorScheme } from "@opencode-ai/ui/theme/context"
@@ -877,7 +875,11 @@ export default function LegacyLayout(props: ParentProps) {
     const index = sessions.findIndex((s) => s.id === session.id)
     const nextSession = sessions[index + 1] ?? sessions[index - 1]
 
-    await serverSDK().api.session.archive({ sessionID: session.id, directory: session.directory })
+    await serverSDK().client.session.update({
+      directory: session.directory,
+      sessionID: session.id,
+      time: { archived: Date.now() },
+    })
     setStore(
       produce((draft) => {
         const match = Binary.search(draft.session, session.id, (s) => s.id)
@@ -1183,12 +1185,9 @@ export default function LegacyLayout(props: ParentProps) {
     }
     const refreshDirs = async (target?: string) => {
       if (!target || target === root || canOpen(target)) return canOpen(target)
-      const listed = await Promise.resolve(
-        project?.id ?? serverSDK().api.project.current({ location: { directory: root } }),
-      )
-        .then((value) => (typeof value === "string" ? value : value.id))
-        .then((projectID) => serverSDK().api.project.directories({ projectID, location: { directory: root } }))
-        .then((items) => items.map((item) => item.directory).filter((item) => pathKey(item) !== pathKey(root)))
+      const listed = await serverSDK()
+        .client.worktree.list({ directory: root })
+        .then((x) => x.data ?? [])
         .catch(() => [] as string[])
       dirs = effectiveWorkspaceOrder(root, [root, ...listed], store.workspaceOrder[root])
       return canOpen(target)
@@ -1232,11 +1231,10 @@ export default function LegacyLayout(props: ParentProps) {
       await Promise.all(
         dirs.map(async (item) => ({
           path: { directory: item },
-          session: await listAllSessions(serverSDK().api.session, {
-            directory: item,
-            parentID: null,
-            order: "desc",
-          }).catch(() => []),
+          session: await serverSDK()
+            .client.session.list({ directory: item })
+            .then((x) => x.data ?? [])
+            .catch(() => []),
         })),
       ),
       Date.now(),
@@ -1296,10 +1294,7 @@ export default function LegacyLayout(props: ParentProps) {
     const name = next === getFilename(project.worktree) ? "" : next
 
     if (project.id && project.id !== "global") {
-      const result = await serverSDK().api.project.update({ projectID: project.id, name })
-      serverSync().set("project", (items) =>
-        items.map((item) => (item.id === result.id ? normalizeProjectInfo(result) : item)),
-      )
+      await serverSDK().client.project.update({ projectID: project.id, directory: project.worktree, name })
       return
     }
 
@@ -1450,7 +1445,10 @@ export default function LegacyLayout(props: ParentProps) {
     })
     const dismiss = () => toaster.dismiss(progress)
 
-    const sessions = await listAllSessions(serverSDK().api.session, { directory, order: "desc" }).catch(() => [])
+    const sessions: Session[] = await serverSDK()
+      .client.session.list({ directory })
+      .then((x) => x.data ?? [])
+      .catch(() => [])
 
     clearWorkspaceTerminals(
       directory,
@@ -1479,12 +1477,17 @@ export default function LegacyLayout(props: ParentProps) {
       return
     }
 
+    const archivedAt = Date.now()
     await Promise.all(
       sessions
         .filter((session) => session.time.archived === undefined)
         .map((session) =>
           serverSDK()
-            .api.session.archive({ sessionID: session.id, directory: session.directory })
+            .client.session.update({
+              sessionID: session.id,
+              directory: session.directory,
+              time: { archived: archivedAt },
+            })
             .catch(() => undefined),
         ),
     )
@@ -1521,9 +1524,9 @@ export default function LegacyLayout(props: ParentProps) {
 
     onMount(() => {
       serverSDK()
-        .api.vcs.status({ location: { directory: props.directory } })
-        .then((result) => {
-          const files = result.data
+        .client.vcs.status({ directory: props.directory })
+        .then((x) => {
+          const files = x.data ?? []
           const dirty = files.length > 0
           setData({ status: "ready", dirty })
         })
@@ -1579,19 +1582,19 @@ export default function LegacyLayout(props: ParentProps) {
     })
 
     const refresh = async () => {
-      const sessions = await listAllSessions(serverSDK().api.session, {
-        directory: props.directory,
-        order: "desc",
-      }).catch(() => [])
+      const sessions = await serverSDK()
+        .client.session.list({ directory: props.directory })
+        .then((x) => x.data ?? [])
+        .catch(() => [])
       const active = sessions.filter((session) => session.time.archived === undefined)
       setState({ sessions: active })
     }
 
     onMount(() => {
       serverSDK()
-        .api.vcs.status({ location: { directory: props.directory } })
-        .then((result) => {
-          const files = result.data
+        .client.vcs.status({ directory: props.directory })
+        .then((x) => {
+          const files = x.data ?? []
           const dirty = files.length > 0
           setState({ status: "ready", dirty })
           void refresh()

packages/app/src/pages/session.tsx

@@ -532,6 +532,7 @@ export default function Page() {
 
   const info = createMemo(() => (params.id ? sync().session.get(params.id) : undefined))
   const isChildSession = createMemo(() => !!info()?.parentID)
+  const diffs = createMemo(() => (params.id ? list(sync().data.session_diff[params.id]) : []))
   const canReview = createMemo(() => !!sync().project)
   const reviewTab = createMemo(() => isDesktop())
   const tabState = createSessionTabs({
@@ -689,8 +690,8 @@ export default function Page() {
       queryFn: mode
         ? () =>
             sdk()
-              .api.vcs.diff({ location: { directory: sdk().directory }, mode: mode === "git" ? "working" : mode })
-              .then((result) => result.data)
+              .client.vcs.diff({ mode })
+              .then((result) => list(result.data))
               .catch((error) => {
                 console.debug("[session-review] failed to load vcs diff", { mode, error })
                 return []
@@ -737,12 +738,8 @@ export default function Page() {
           retry: 2,
           queryFn: () =>
             sdk()
-              .api.vcs.diff({
-                location: { directory: scope },
-                mode: mode === "git" ? "working" : mode,
-                context,
-              })
-              .then((result) => result.data),
+              .client.vcs.diff({ mode, directory: scope, context })
+              .then((result) => result.data ?? []),
         })
         .then((diffs) => diffs.find((diff) => diff.file === file))
 
@@ -949,11 +946,10 @@ export default function Page() {
   )
 
   const stopVcs = sdk().event.listen((evt) => {
-    const details = evt.details as { type: string; properties?: unknown }
-    if (details.type !== "file.watcher.updated" && details.type !== "filesystem.changed") return
+    if (evt.details.type !== "file.watcher.updated") return
     const props =
-      typeof details.properties === "object" && details.properties
-        ? (details.properties as Record<string, unknown>)
+      typeof evt.details.properties === "object" && evt.details.properties
+        ? (evt.details.properties as Record<string, unknown>)
         : undefined
     const file = typeof props?.file === "string" ? props.file : undefined
     if (!file || file.startsWith(".git/")) return
@@ -1468,6 +1464,44 @@ export default function Page() {
     requestAnimationFrame(() => attempt(0))
   })
 
+  createEffect(() => {
+    const id = params.id
+    if (!id) return
+
+    if (!wantsReview()) return
+    if (sync().data.session_diff[id] !== undefined) return
+    if (sync().status === "loading") return
+
+    void sync().session.diff(id)
+  })
+
+  createEffect(
+    on(
+      () => [sessionKey(), wantsReview()] as const,
+      ([key, wants]) => {
+        if (diffFrame !== undefined) cancelAnimationFrame(diffFrame)
+        if (diffTimer !== undefined) window.clearTimeout(diffTimer)
+        diffFrame = undefined
+        diffTimer = undefined
+        if (!wants) return
+
+        const id = params.id
+        if (!id) return
+        if (!untrack(() => sync().data.session_diff[id] !== undefined)) return
+
+        diffFrame = requestAnimationFrame(() => {
+          diffFrame = undefined
+          diffTimer = window.setTimeout(() => {
+            diffTimer = undefined
+            if (sessionKey() !== key) return
+            void sync().session.diff(id, { force: true })
+          }, 0)
+        })
+      },
+      { defer: true },
+    ),
+  )
+
   let treeDir: string | undefined
   createEffect(() => {
     const dir = sdk().directory
@@ -1723,7 +1757,7 @@ export default function Page() {
       setFollowup("failed", input.sessionID, undefined)
 
       const ok = await sendFollowupDraft({
-        api: sdk().api.session,
+        client: sdk().client,
         sync: sync(),
         serverSync: serverSync(),
         draft: item,
@@ -1819,13 +1853,13 @@ export default function Page() {
   const halt = (sessionID: string) =>
     busy(sessionID)
       ? sdk()
-          .api.session.interrupt({ sessionID })
+          .client.session.abort({ sessionID })
           .catch(() => {})
       : Promise.resolve()
 
   const revertMutation = useMutation(() => ({
     mutationFn: async (input: { sessionID: string; messageID: string }) => {
-      const session = sdk().api.session
+      const client = sdk().client
       const target = sync()
       const last = target.session.get(input.sessionID)?.revert
       const value = draft(input.messageID)
@@ -1835,8 +1869,10 @@ export default function Page() {
           roll(input.sessionID, { messageID: input.messageID }, target)
           prompt.set(value)
         },
-        request: () => halt(input.sessionID).then(() => session.revert.stage(input)),
-        complete: () => undefined,
+        request: () => halt(input.sessionID).then(() => client.session.revert(input)),
+        complete: (result) => {
+          if (result.data) merge(result.data, target)
+        },
         rollback: () => roll(input.sessionID, last, target),
         fail,
       })
@@ -1848,7 +1884,7 @@ export default function Page() {
       const sessionID = params.id
       if (!sessionID) return
 
-      const session = sdk().api.session
+      const client = sdk().client
       const target = sync()
       const next = userMessages().find((item) => item.id > id)
       const last = target.session.get(sessionID)?.revert
@@ -1865,9 +1901,11 @@ export default function Page() {
         },
         request: () =>
           !next
-            ? halt(sessionID).then(() => session.revert.clear({ sessionID }))
-            : halt(sessionID).then(() => session.revert.stage({ sessionID, messageID: next.id }).then(() => undefined)),
-        complete: () => undefined,
+            ? halt(sessionID).then(() => client.session.unrevert({ sessionID }))
+            : halt(sessionID).then(() => client.session.revert({ sessionID, messageID: next.id })),
+        complete: (result) => {
+          if (result.data) merge(result.data, target)
+        },
         rollback: () => roll(sessionID, last, target),
         fail,
       })

packages/app/src/pages/session/composer/session-composer-controls.ts

@@ -45,8 +45,7 @@ export function createPromptInputController(input: {
     model: {
       selection: input.model ?? local.model,
       paid: providers.paid().length > 0,
-      loading:
-        (local.agent.visible() && agentsQuery.isLoading) || providersQuery.isLoading || globalProvidersQuery.isLoading,
+      loading: agentsQuery.isLoading || providersQuery.isLoading || globalProvidersQuery.isLoading,
     },
     session: {
       id: input.sessionID(),

packages/app/src/pages/session/composer/session-composer-state.ts

@@ -82,7 +82,7 @@ export function createSessionComposerController(options?: { closeMs?: number | (
 
     setStore("responding", perm.id)
     sdk()
-      .api.permission.reply({ sessionID: perm.sessionID, requestID: perm.id, reply: response })
+      .client.permission.respond({ sessionID: perm.sessionID, permissionID: perm.id, response })
       .catch((err: unknown) => {
         const description = err instanceof Error ? err.message : String(err)
         showToast({ title: language.t("common.requestFailed"), description })

packages/app/src/pages/session/composer/session-question-dock.tsx

@@ -223,8 +223,7 @@ export const SessionQuestionDock: Component<{ request: QuestionRequest; onSubmit
   }
 
   const replyMutation = useMutation(() => ({
-    mutationFn: (answers: QuestionAnswer[]) =>
-      sdk().api.question.reply({ sessionID: props.request.sessionID, requestID: props.request.id, answers }),
+    mutationFn: (answers: QuestionAnswer[]) => sdk().client.question.reply({ requestID: props.request.id, answers }),
     onMutate: () => {
       props.onSubmit()
     },
@@ -236,7 +235,7 @@ export const SessionQuestionDock: Component<{ request: QuestionRequest; onSubmit
   }))
 
   const rejectMutation = useMutation(() => ({
-    mutationFn: () => sdk().api.question.reject({ sessionID: props.request.sessionID, requestID: props.request.id }),
+    mutationFn: () => sdk().client.question.reject({ requestID: props.request.id }),
     onMutate: () => {
       props.onSubmit()
     },

packages/app/src/pages/session/timeline/message-timeline.tsx

@@ -283,14 +283,6 @@ export function MessageTimeline(props: {
     return sync().data.session_status[id] ?? idle
   })
   const sessionMessages = createMemo(() => (sessionID() ? (sync().data.message[sessionID()!] ?? []) : []))
-  const projectedMessages = createMemo(() => {
-    const id = sessionID()
-    if (!id) return []
-    const visible = new Set(props.userMessages.map((message) => message.id))
-    const boundary = sessionMessages().find((message) => message.role === "user" && !visible.has(message.id))?.id
-    const messages = sync().data.session_message[id] ?? []
-    return boundary ? messages.filter((message) => message.id < boundary) : messages
-  })
   const info = createMemo(() => {
     const id = sessionID()
     if (!id) return
@@ -332,7 +324,7 @@ export function MessageTimeline(props: {
   const showHeader = createMemo(() => !!(titleValue() || parentID()))
   const projection = createTimelineProjection({
     messages: sessionMessages,
-    sessionMessages: projectedMessages,
+    userMessages: () => props.userMessages,
     parts: getMsgParts,
     status: sessionStatus,
     showReasoningSummaries: settings.general.showReasoningSummaries,
@@ -672,7 +664,8 @@ export function MessageTimeline(props: {
   }))
 
   const titleMutation = useMutation(() => ({
-    mutationFn: (input: { id: string; title: string }) => sdk().api.session.rename({ sessionID: input.id, title: input.title }),
+    mutationFn: (input: { id: string; title: string }) =>
+      sdk().client.session.update({ sessionID: input.id, title: input.title }),
     onSuccess: (_, input) => {
       sync().set(
         produce((draft) => {
@@ -816,7 +809,7 @@ export function MessageTimeline(props: {
     const nextSession = index === -1 ? undefined : (sessions[index + 1] ?? sessions[index - 1])
 
     await sdk()
-      .api.session.archive({ sessionID })
+      .client.session.update({ sessionID, time: { archived: Date.now() } })
       .then(() => {
         sync().set(
           produce((draft) => {
@@ -845,8 +838,8 @@ export function MessageTimeline(props: {
     const nextSession = index === -1 ? undefined : (sessions[index + 1] ?? sessions[index - 1])
 
     const result = await sdk()
-      .api.session.remove({ sessionID })
-      .then(() => true)
+      .client.session.delete({ sessionID })
+      .then((x) => x.data)
       .catch((err) => {
         showToast({
           title: language.t("session.delete.failed.title"),

packages/app/src/pages/session/timeline/projection.ts

@@ -1,14 +1,16 @@
-import type { SessionMessageInfo } from "@opencode-ai/client/promise"
+import { Binary } from "@opencode-ai/core/util/binary"
 import type { AssistantMessage, Message, Part, SessionStatus, UserMessage } from "@opencode-ai/sdk/v2"
-import { createMemo, type Accessor } from "solid-js"
+import { createMemo, mapArray, type Accessor } from "solid-js"
 import { reuseTimelineRows } from "./row-reconciliation"
 import { Timeline, TimelineRow } from "./rows"
 
 export { reuseTimelineRows } from "./row-reconciliation"
 
+const emptyAssistantMessages: AssistantMessage[] = []
+
 export function createTimelineProjection(input: {
   messages: Accessor<Message[]>
-  sessionMessages: Accessor<SessionMessageInfo[]>
+  userMessages: Accessor<UserMessage[]>
   parts: (messageID: string) => Part[]
   status: Accessor<SessionStatus>
   showReasoningSummaries: Accessor<boolean>
@@ -28,19 +30,47 @@ export function createTimelineProjection(input: {
     })
     return result
   })
-  const projection = createMemo(() =>
-    Timeline.constructSessionMessageRows(
-      input.sessionMessages(),
-      (messageID) => messageByID().get(messageID) as UserMessage | AssistantMessage | undefined,
-      input.parts,
-      input.showReasoningSummaries(),
-      input.status().type,
-      input.inlineComments(),
+  const activeMessageID = createMemo(() => {
+    const parentID = input
+      .messages()
+      .findLast(
+        (message): message is AssistantMessage =>
+          message.role === "assistant" && typeof message.time.completed !== "number",
+      )?.parentID
+    if (parentID) {
+      const messages = input.messages()
+      const result = Binary.search(messages, parentID, (message) => message.id)
+      const message = result.found ? messages[result.index] : messages.find((item) => item.id === parentID)
+      if (message?.role === "user") return message.id
+    }
+
+    if (input.status().type === "idle") return
+    return input.messages().findLast((message) => message.role === "user")?.id
+  })
+  const messageRowMemos = createMemo(
+    mapArray(input.userMessages, (userMessage, indexAccessor) =>
+      createMemo((previous: TimelineRow.TimelineRow[] | undefined) =>
+        reuseTimelineRows(
+          previous,
+          Timeline.constructMessageRows(
+            userMessage,
+            input.parts,
+            assistantMessagesByParent().get(userMessage.id) ?? emptyAssistantMessages,
+            indexAccessor(),
+            input.showReasoningSummaries(),
+            input.status().type,
+            activeMessageID() === userMessage.id,
+            input.inlineComments(),
+          ),
+        ),
+      ),
     ),
   )
-  const activeMessageID = createMemo(() => projection().activeMessageID)
   const rows = createMemo((previous: TimelineRow.TimelineRow[] | undefined) =>
-    reuseTimelineRows(previous, projection().rows),
+    reuseTimelineRows(
+      previous,
+      messageRowMemos().flatMap((memo) => memo()),
+    ),
   )
   const rowByKey = createMemo(() => new Map(rows().map((row) => [TimelineRow.key(row), row] as const)))
   const messageRowIndex = createMemo(() => {

packages/app/src/pages/session/timeline/rows-current.test.ts

@@ -1,92 +0,0 @@
-import { describe, expect, mock, test } from "bun:test"
-import type { SessionMessageInfo } from "@opencode-ai/client/promise"
-import { normalizeSessionMessages } from "@/utils/session-message"
-
-mock.module("@opencode-ai/session-ui/message-part", () => ({
-  renderable: () => true,
-  groupParts: (refs: Array<{ messageID: string; part: { id: string } }>) =>
-    refs.map((ref) => ({
-      type: "part" as const,
-      key: ref.part.id,
-      ref: { messageID: ref.messageID, partID: ref.part.id },
-    })),
-}))
-
-const { Timeline, TimelineRow } = await import("./rows")
-
-describe("current session timeline rows", () => {
-  test("derives turns and tagged rows from chronological current messages", () => {
-    const source = [
-      { id: "msg_1", type: "user", text: "first", time: { created: 1 } },
-      {
-        id: "msg_2",
-        type: "assistant",
-        agent: "build",
-        model: { id: "model", providerID: "provider" },
-        content: [{ type: "text", text: "answer" }],
-        time: { created: 2, completed: 3 },
-      },
-      { id: "msg_3", type: "user", text: "second", time: { created: 4 } },
-      {
-        id: "msg_4",
-        type: "assistant",
-        agent: "build",
-        model: { id: "model", providerID: "provider" },
-        content: [{ type: "reasoning", text: "working" }],
-        time: { created: 5 },
-      },
-    ] satisfies SessionMessageInfo[]
-    const normalized = normalizeSessionMessages("ses_1", source)
-    const messages = new Map(normalized.messages.map((message) => [message.id, message]))
-
-    const result = Timeline.constructSessionMessageRows(
-      source,
-      (messageID) => messages.get(messageID),
-      (messageID) => normalized.parts.get(messageID) ?? [],
-      true,
-      "busy",
-      true,
-    )
-
-    expect(result.activeMessageID).toBe("msg_3")
-    expect(result.rows.map(TimelineRow.key)).toEqual([
-      "user-message:msg_1",
-      "assistant-part:msg_1:msg_2:text:0",
-      "turn-gap:msg_3",
-      "user-message:msg_3",
-      "assistant-part:msg_3:msg_4:reasoning:0",
-    ])
-  })
-
-  test("renders a current shell message as a standalone turn", () => {
-    const source = [
-      {
-        id: "msg_shell",
-        type: "shell",
-        shellID: "shell_1",
-        command: "pwd",
-        status: "exited",
-        exit: 0,
-        output: { output: "/repo", cursor: 5, size: 5, truncated: false },
-        time: { created: 1, completed: 2 },
-      },
-    ] satisfies SessionMessageInfo[]
-    const normalized = normalizeSessionMessages("ses_1", source)
-    const messages = new Map(normalized.messages.map((message) => [message.id, message]))
-
-    const result = Timeline.constructSessionMessageRows(
-      source,
-      (messageID) => messages.get(messageID),
-      (messageID) => normalized.parts.get(messageID) ?? [],
-      true,
-      "idle",
-      true,
-    )
-
-    expect(result.activeMessageID).toBe("msg_shell")
-    expect(result.rows.map(TimelineRow.key)).toEqual([
-      "user-message:msg_shell",
-      "assistant-part:msg_shell:msg_shell:tool",
-    ])
-  })
-})

packages/app/src/pages/session/timeline/rows.ts

@@ -1,5 +1,4 @@
 import { parseCommentNote, readCommentMetadata } from "@/utils/comment-note"
-import type { SessionMessageInfo } from "@opencode-ai/client/promise"
 import { AssistantMessage, Part, SessionStatus, UserMessage } from "@opencode-ai/sdk/v2"
 import { groupParts, renderable, type PartGroup } from "@opencode-ai/session-ui/message-part"
 import { TimelineRow, type SummaryDiff } from "./timeline-row"
@@ -32,47 +31,6 @@ export type TimelineRowMap = {
 }
 
 export namespace Timeline {
-  export function constructSessionMessageRows(
-    messages: SessionMessageInfo[],
-    getMessage: (messageID: string) => UserMessage | AssistantMessage | undefined,
-    getMessageParts: (messageID: string) => Part[],
-    showReasoning: boolean,
-    status: SessionStatus["type"],
-    inlineComments: boolean,
-  ) {
-    const turns = messages.reduce<{ user: UserMessage; assistants: AssistantMessage[] }[]>((result, message) => {
-      const projected = getMessage(message.id)
-      if (message.type === "shell" && projected?.role === "user") {
-        const assistant = getMessage(`${message.id}:assistant`)
-        result.push({ user: projected, assistants: assistant?.role === "assistant" ? [assistant] : [] })
-        return result
-      }
-      if (projected?.role === "user") {
-        result.push({ user: projected, assistants: [] })
-        return result
-      }
-      if (projected?.role !== "assistant") return result
-      result.at(-1)?.assistants.push(projected)
-      return result
-    }, [])
-    const activeMessageID = turns.at(-1)?.user.id
-    return {
-      activeMessageID,
-      rows: turns.flatMap((turn, index) =>
-        constructMessageRows(
-          turn.user,
-          getMessageParts,
-          turn.assistants,
-          index,
-          showReasoning,
-          status,
-          turn.user.id === activeMessageID,
-          inlineComments,
-        ),
-      ),
-    }
-  }
-
   export function constructMessageRows(
     userMessage: UserMessage,
     getMessageParts: (messageID: string) => Part[],

packages/app/src/pages/session/use-session-commands.tsx

@@ -5,6 +5,7 @@ import { previewSelectedLines } from "@opencode-ai/session-ui/pierre/selection-b
 import { useFile, selectionFromLines, type FileSelection, type SelectedLineRange } from "@/context/file"
 import { useLanguage } from "@/context/language"
 import { useLayout } from "@/context/layout"
+import { useLocal } from "@/context/local"
 import { usePermission } from "@/context/permission"
 import { usePrompt } from "@/context/prompt"
 import { useSDK } from "@/context/sdk"
@@ -18,7 +19,6 @@ import { extractPromptFromParts } from "@/utils/prompt"
 import { UserMessage } from "@opencode-ai/sdk/v2"
 import { useSessionLayout } from "@/pages/session/session-layout"
 import { createSessionOwnership } from "./session-ownership"
-import { useLocal } from "@/context/local"
 
 export type SessionCommandContext = {
   navigateMessageByOffset: (offset: number) => void
@@ -40,6 +40,7 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
   const dialog = useDialog()
   const file = useFile()
   const language = useLanguage()
+  const local = useLocal()
   const permission = usePermission()
   const prompt = usePrompt()
   const sdk = useSDK()
@@ -47,7 +48,6 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
   const sync = useSync()
   const terminal = useTerminal()
   const layout = useLayout()
-  const local = useLocal()
   const navigate = useNavigate()
   const { params, sessionKey, tabs, view } = useSessionLayout()
   const sessionOwnership = createSessionOwnership(sessionKey)
@@ -306,7 +306,7 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
     const sessionID = params.id
     if (!sessionID) return
     const owner = sessionOwnership.capture()
-    const session = sdk().api.session
+    const client = sdk().client
     const directory = sdk().directory
     const promptSession = prompt.capture()
     const revert = info()?.revert?.messageID
@@ -316,13 +316,13 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
     const parts = sync().data.part[message.id]
 
     if (sync().data.session_working(sessionID)) {
-      await session.interrupt({ sessionID }).catch(() => {})
+      await client.session.abort({ sessionID }).catch(() => {})
     }
 
     await runCommand({
       owner,
       prompt: promptSession,
-      request: () => session.revert.stage({ sessionID, messageID: message.id }),
+      request: () => client.session.revert({ sessionID, messageID: message.id }),
       updatePrompt: (promptSession) => {
         if (parts) promptSession.set(extractPromptFromParts(parts, { directory }))
       },
@@ -334,7 +334,7 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
     const sessionID = params.id
     if (!sessionID) return
     const owner = sessionOwnership.capture()
-    const session = sdk().api.session
+    const client = sdk().client
     const messages = userMessages()
     const promptSession = prompt.capture()
 
@@ -346,7 +346,7 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
       await runCommand({
         owner,
         prompt: promptSession,
-        request: () => session.revert.clear({ sessionID }),
+        request: () => client.session.unrevert({ sessionID }),
         updatePrompt: (promptSession) => promptSession.reset(),
         updateViewport: () => setActiveMessage(findLast(messages, (x) => x.id >= revertMessageID)),
       })
@@ -356,7 +356,7 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
     await runCommand({
       owner,
       prompt: promptSession,
-      request: () => session.revert.stage({ sessionID, messageID: next.id }),
+      request: () => client.session.revert({ sessionID, messageID: next.id }),
       updatePrompt: () => undefined,
       updateViewport: () => setActiveMessage(findLast(messages, (x) => x.id < next.id)),
     })
@@ -375,9 +375,10 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
       return
     }
 
-    await sdk().api.session.compact({
+    await sdk().client.session.summarize({
       sessionID,
-      model: { providerID: model.provider.id, modelID: model.id },
+      modelID: model.id,
+      providerID: model.provider.id,
     })
   }
 

packages/app/src/utils/server-compat.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test"
 import { createApiForServer, createSdkForServer } from "./server"
 import { createCompatibleApi } from "./server-compat"
 
-function setup(protocol: "v1" | "v2") {
+function setup(protocol: "v1" | "v2" | Promise<"v1" | "v2">) {
   const requests: Request[] = []
   const fetcher = Object.assign(
     async (input: string | URL | Request, init?: RequestInit) => {
@@ -21,7 +21,7 @@ function setup(protocol: "v1" | "v2") {
       }
       if (request.method === "POST" && request.url.endsWith("/prompt_async"))
         return new Response(undefined, { status: 204 })
-    if (request.method === "POST" && request.url.endsWith("/prompt")) {
+      if (request.method === "POST" && request.url.endsWith("/prompt")) {
         return Response.json({
           admittedSeq: 1,
           id: "msg_1",
@@ -30,16 +30,16 @@ function setup(protocol: "v1" | "v2") {
           type: "user",
           data: { text: "hello" },
           delivery: "steer",
-      })
-    }
-    if (request.method === "GET") return Response.json([])
-    return new Response(undefined, { status: 204 })
+        })
+      }
+      if (request.method === "GET") return Response.json([])
+      return new Response(undefined, { status: 204 })
     },
     { preconnect: globalThis.fetch.preconnect },
   )
   const server = { url: "http://localhost:4096" }
   const api = createCompatibleApi({
-    protocol: Promise.resolve(protocol),
+    protocol: typeof protocol === "string" ? Promise.resolve(protocol) : protocol,
     current: createApiForServer({ server, fetch: fetcher }),
     legacy: (directory) => createSdkForServer({ server, fetch: fetcher, directory, throwOnError: true }),
     directory: "/repo",
@@ -86,6 +86,24 @@ describe("createCompatibleApi", () => {
     expect(requests[0]!.method).toBe("POST")
   })
 
+  test("resolves protocol detection once across implementation methods", async () => {
+    let detections = 0
+    const resolved = Promise.resolve<"v1" | "v2">("v2")
+    const protocol = new Proxy(resolved, {
+      get(target, property) {
+        if (property !== "then") return Reflect.get(target, property, target)
+        detections++
+        return target.then.bind(target)
+      },
+    })
+    const { api } = setup(protocol)
+
+    await api.session.archive({ sessionID: "ses_1" })
+    await api.session.list()
+
+    expect(detections).toBe(1)
+  })
+
   test("uses the global V1 session search endpoint", async () => {
     const { api, requests } = setup("v1")
     await api.session.list({ parentID: null, search: "session", limit: 50 })

packages/app/src/utils/server-compat.ts

@@ -37,6 +37,12 @@ type LegacyPrompt = {
   variant?: string
 }
 type LegacyLocation = { directory?: string }
+type CompatibleInput = {
+  protocol: Promise<ServerProtocol>
+  current: ServerApi
+  legacy: LegacyFor
+  directory?: string
+}
 
 function mime(uri: string) {
   const match = /^data:([^;,]+)/.exec(uri)
@@ -68,15 +74,48 @@ function sessionInfo(session: Session): SessionInfo {
   }
 }
 
-export function createCompatibleApi(input: {
-  protocol: Promise<ServerProtocol>
-  current: ServerApi
-  legacy: LegacyFor
-  directory?: string
-}): CompatibleApi {
+export function createCompatibleApi(input: CompatibleInput): CompatibleApi {
+  const v1 = createV1Api(input)
+  return lazyApi(
+    input.protocol.then((protocol) => (protocol === "v1" ? v1 : input.current)),
+    input.current,
+  )
+}
+
+function lazyApi<T extends object>(implementation: Promise<T>, shape: T): T {
+  const cache = new Map<PropertyKey, unknown>()
+  return new Proxy(shape, {
+    get(target, property, receiver) {
+      const sample = Reflect.get(target, property, receiver)
+      if (typeof sample === "function") {
+        return (...args: unknown[]) =>
+          implementation.then((value) => {
+            const method = Reflect.get(value, property)
+            if (typeof method !== "function") throw new Error(`API method unavailable: ${String(property)}`)
+            return Reflect.apply(method, value, args)
+          })
+      }
+      if (sample === null || typeof sample !== "object") return sample
+      if (cache.has(property)) return cache.get(property)
+      const nested = lazyApi(
+        implementation.then((value) => {
+          const result = Reflect.get(value, property)
+          if (result === null || typeof result !== "object") {
+            throw new Error(`API namespace unavailable: ${String(property)}`)
+          }
+          return result
+        }),
+        sample,
+      )
+      cache.set(property, nested)
+      return nested
+    },
+  })
+}
+
+function createV1Api(input: CompatibleInput): CompatibleApi {
   const directory = (location?: { directory?: string }) => location?.directory ?? input.directory
   const legacy = (location?: { directory?: string }) => input.legacy(directory(location))
-  const isV1 = () => input.protocol.then((protocol) => protocol === "v1")
   const located = <T>(data: T, value?: { directory?: string }) => ({
     location: {
       directory: directory(value) ?? "",
@@ -93,7 +132,6 @@ export function createCompatibleApi(input: {
         value?: Parameters<ServerApi["session"]["list"]>[0],
         options?: Parameters<ServerApi["session"]["list"]>[1],
       ) {
-        if (!(await isV1())) return input.current.session.list(value, options)
         if (!value?.directory && value?.search !== undefined) {
           const result = await legacy().experimental.session.list(
             {
@@ -114,7 +152,6 @@ export function createCompatibleApi(input: {
         return { data: (result.data ?? []).map(sessionInfo), cursor: {} }
       },
       async create(value?: Parameters<ServerApi["session"]["create"]>[0]) {
-        if (!(await isV1())) return input.current.session.create(value)
         const result = await legacy(value?.location ?? undefined).session.create({
           directory: directory(value?.location ?? undefined),
         })
@@ -122,13 +159,11 @@ export function createCompatibleApi(input: {
         return sessionInfo(result.data)
       },
       async get(value: Parameters<ServerApi["session"]["get"]>[0]) {
-        if (!(await isV1())) return input.current.session.get(value)
         const result = await legacy().session.get(value)
         if (!result.data) throw new Error(`Session not found: ${value.sessionID}`)
         return sessionInfo(result.data)
       },
       async active() {
-        if (!(await isV1())) return input.current.session.active()
         const result = await legacy().session.status()
         return Object.fromEntries(
           Object.entries(result.data ?? {}).flatMap(([sessionID, status]) =>
@@ -137,29 +172,23 @@ export function createCompatibleApi(input: {
         )
       },
       async rename(value: Parameters<ServerApi["session"]["rename"]>[0] & LegacyLocation) {
-        if (!(await isV1())) return input.current.session.rename(value)
         await legacy(value).session.update({ sessionID: value.sessionID, title: value.title })
       },
       async archive(value: Parameters<ServerApi["session"]["archive"]>[0] & LegacyLocation) {
-        if (!(await isV1())) return input.current.session.archive(value)
         await legacy(value).session.update({ sessionID: value.sessionID, time: { archived: Date.now() } })
       },
       async remove(value: Parameters<ServerApi["session"]["remove"]>[0] & LegacyLocation) {
-        if (!(await isV1())) return input.current.session.remove(value)
         await legacy(value).session.delete(value)
       },
       async fork(value: Parameters<ServerApi["session"]["fork"]>[0]) {
-        if (!(await isV1())) return input.current.session.fork(value)
         const result = await legacy().session.fork(value)
         if (!result.data) throw new Error("Failed to fork session")
         return sessionInfo(result.data)
       },
       async interrupt(value: Parameters<ServerApi["session"]["interrupt"]>[0]) {
-        if (!(await isV1())) return input.current.session.interrupt(value)
         await legacy().session.abort(value)
       },
       async prompt(value: SessionPromptInput & LegacyPrompt) {
-        if (!(await isV1())) return input.current.session.prompt(value)
         await legacy().session.promptAsync({
           sessionID: value.sessionID,
           messageID: value.id ?? undefined,
@@ -194,7 +223,6 @@ export function createCompatibleApi(input: {
         }
       },
       async command(value: SessionCommandInput) {
-        if (!(await isV1())) return input.current.session.command(value)
         await legacy().session.command({
           sessionID: value.sessionID,
           messageID: value.id ?? undefined,
@@ -221,7 +249,6 @@ export function createCompatibleApi(input: {
         }
       },
       async shell(value: SessionShellInput & LegacyPrompt) {
-        if (!(await isV1())) return input.current.session.shell(value)
         await legacy().session.shell({
           sessionID: value.sessionID,
           command: value.command,
@@ -230,7 +257,6 @@ export function createCompatibleApi(input: {
         })
       },
       compact: async (value: SessionCompactInput & { model?: LegacyPrompt["model"] }) => {
-        if (!(await isV1())) return input.current.session.compact(value)
         if (!value.model) throw new Error("A model is required to compact a V1 session")
         await legacy().session.summarize({
           sessionID: value.sessionID,
@@ -247,12 +273,10 @@ export function createCompatibleApi(input: {
       },
       revert: {
         stage: async (value: Parameters<ServerApi["session"]["revert"]["stage"]>[0]) => {
-          if (!(await isV1())) return input.current.session.revert.stage(value)
           await legacy().session.revert(value)
           return { messageID: value.messageID }
         },
         clear: async (value: Parameters<ServerApi["session"]["revert"]["clear"]>[0]) => {
-          if (!(await isV1())) return input.current.session.revert.clear(value)
           await legacy().session.unrevert(value)
         },
         commit: input.current.session.revert.commit,
@@ -261,17 +285,14 @@ export function createCompatibleApi(input: {
     project: {
       ...input.current.project,
       async list() {
-        if (!(await isV1())) return input.current.project.list()
         return ((await legacy().project.list()).data ?? []) as Project[]
       },
       async current(value?: Parameters<ServerApi["project"]["current"]>[0]) {
-        if (!(await isV1())) return input.current.project.current(value)
         const result = await legacy(value?.location).project.current()
         if (!result.data) throw new Error("Project not found")
         return { id: result.data.id, directory: result.data.worktree } satisfies ProjectCurrent
       },
       async update(value: Parameters<ServerApi["project"]["update"]>[0]) {
-        if (!(await isV1())) return input.current.project.update(value)
         const project = (await legacy().project.list()).data?.find((item) => item.id === value.projectID)
         const result = await legacy({ directory: project?.worktree }).project.update({
           ...value,
@@ -281,7 +302,6 @@ export function createCompatibleApi(input: {
         return result.data as Project
       },
       async directories(value: Parameters<ServerApi["project"]["directories"]>[0]) {
-        if (!(await isV1())) return input.current.project.directories(value)
         const result = await legacy(value.location).worktree.list()
         return (result.data ?? []).map((item) => ({ directory: item }))
       },
@@ -289,7 +309,6 @@ export function createCompatibleApi(input: {
     path: {
       ...input.current.path,
       async get(value?: Parameters<ServerApi["path"]["get"]>[0]) {
-        if (!(await isV1())) return input.current.path.get(value)
         const result = await legacy(value?.location).path.get()
         if (!result.data) throw new Error("Path unavailable")
         return result.data
@@ -298,17 +317,14 @@ export function createCompatibleApi(input: {
     vcs: {
       ...input.current.vcs,
       async get(value?: Parameters<ServerApi["vcs"]["get"]>[0]) {
-        if (!(await isV1())) return input.current.vcs.get(value)
         const result = await legacy(value?.location).vcs.get()
         return located({ branch: result.data?.branch, defaultBranch: undefined }, value?.location)
       },
       async status(value?: Parameters<ServerApi["vcs"]["status"]>[0]) {
-        if (!(await isV1())) return input.current.vcs.status(value)
         const result = await legacy(value?.location).vcs.status()
         return located(result.data ?? [], value?.location)
       },
       async diff(value: Parameters<ServerApi["vcs"]["diff"]>[0]) {
-        if (!(await isV1())) return input.current.vcs.diff(value)
         const result = await legacy(value.location).vcs.diff({
           mode: value.mode === "working" ? "git" : value.mode,
           context: value.context,
@@ -328,12 +344,10 @@ export function createCompatibleApi(input: {
     file: {
       ...input.current.file,
       async list(value?: Parameters<ServerApi["file"]["list"]>[0]) {
-        if (!(await isV1())) return input.current.file.list(value)
         const result = await legacy(value?.location).file.list({ path: value?.path ?? "" })
         return located(result.data ?? [], value?.location)
       },
       async find(value: Parameters<ServerApi["file"]["find"]>[0]) {
-        if (!(await isV1())) return input.current.file.find(value)
         const result = await legacy(value.location).find.files({
           query: value.query,
           type: value.type,
@@ -348,7 +362,6 @@ export function createCompatibleApi(input: {
     integration: {
       ...input.current.integration,
       async get(value: Parameters<ServerApi["integration"]["get"]>[0]) {
-        if (!(await isV1())) return input.current.integration.get(value)
         const methods = ((await legacy(value.location).provider.auth()).data?.[value.integrationID] ?? []).map(
           (method, index) =>
             method.type === "api"
@@ -368,7 +381,6 @@ export function createCompatibleApi(input: {
       connect: {
         ...input.current.integration.connect,
         key: async (value: Parameters<ServerApi["integration"]["connect"]["key"]>[0]) => {
-          if (!(await isV1())) return input.current.integration.connect.key(value)
           await legacy(value.location).auth.set({
             providerID: value.integrationID,
             auth: { type: "api", key: value.key },
@@ -378,7 +390,6 @@ export function createCompatibleApi(input: {
       oauth: {
         ...input.current.integration.oauth,
         connect: async (value: Parameters<ServerApi["integration"]["oauth"]["connect"]>[0]) => {
-          if (!(await isV1())) return input.current.integration.oauth.connect(value)
           const method = Number(value.methodID)
           const result = await legacy(value.location).provider.oauth.authorize(
             { providerID: value.integrationID, method, inputs: value.inputs },
@@ -397,7 +408,6 @@ export function createCompatibleApi(input: {
           )
         },
         complete: async (value: Parameters<ServerApi["integration"]["oauth"]["complete"]>[0]) => {
-          if (!(await isV1())) return input.current.integration.oauth.complete(value)
           const method = Number(value.attemptID.split(":").at(-1))
           await legacy(value.location).provider.oauth.callback(
             { providerID: value.integrationID, method, code: value.code },
@@ -405,7 +415,6 @@ export function createCompatibleApi(input: {
           )
         },
         status: async (value: Parameters<ServerApi["integration"]["oauth"]["status"]>[0]) => {
-          if (!(await isV1())) return input.current.integration.oauth.status(value)
           const method = Number(value.attemptID.split(":").at(-1))
           await legacy(value.location).provider.oauth.callback(
             { providerID: value.integrationID, method },
@@ -421,15 +430,12 @@ export function createCompatibleApi(input: {
     pty: {
       ...input.current.pty,
       async shells(value?: Parameters<ServerApi["pty"]["shells"]>[0]) {
-        if (!(await isV1())) return input.current.pty.shells(value)
         return located((await legacy(value?.location).pty.shells()).data ?? [], value?.location)
       },
       async list(value?: Parameters<ServerApi["pty"]["list"]>[0]) {
-        if (!(await isV1())) return input.current.pty.list(value)
         return located((await legacy(value?.location).pty.list()).data ?? [], value?.location)
       },
       async create(value?: Parameters<ServerApi["pty"]["create"]>[0]) {
-        if (!(await isV1())) return input.current.pty.create(value)
         const result = await legacy(value?.location).pty.create({
           command: value?.command,
           args: value?.args ? [...value.args] : undefined,
@@ -441,13 +447,11 @@ export function createCompatibleApi(input: {
         return located(result.data, value?.location)
       },
       async get(value: Parameters<ServerApi["pty"]["get"]>[0]) {
-        if (!(await isV1())) return input.current.pty.get(value)
         const result = await legacy(value.location).pty.get({ ptyID: value.ptyID })
         if (!result.data) throw new Error(`Terminal not found: ${value.ptyID}`)
         return located(result.data, value.location)
       },
       async update(value: Parameters<ServerApi["pty"]["update"]>[0]) {
-        if (!(await isV1())) return input.current.pty.update(value)
         const result = await legacy(value.location).pty.update({
           ptyID: value.ptyID,
           title: value.title,
@@ -457,11 +461,9 @@ export function createCompatibleApi(input: {
         return located(result.data, value.location)
       },
       async remove(value: Parameters<ServerApi["pty"]["remove"]>[0]) {
-        if (!(await isV1())) return input.current.pty.remove(value)
         await legacy(value.location).pty.remove({ ptyID: value.ptyID })
       },
       async connectToken(value: Parameters<ServerApi["pty"]["connectToken"]>[0]) {
-        if (!(await isV1())) return input.current.pty.connectToken(value)
         const result = await legacy(value.location).pty.connectToken({ ptyID: value.ptyID })
         if (!result.data) throw new Error(`Failed to connect terminal: ${value.ptyID}`)
         return located(result.data, value.location)
@@ -470,7 +472,6 @@ export function createCompatibleApi(input: {
     permission: {
       ...input.current.permission,
       async reply(value: Parameters<ServerApi["permission"]["reply"]>[0]) {
-        if (!(await isV1())) return input.current.permission.reply(value)
         await legacy().permission.respond({
           sessionID: value.sessionID,
           permissionID: value.requestID,
@@ -481,14 +482,12 @@ export function createCompatibleApi(input: {
     question: {
       ...input.current.question,
       async reply(value: Parameters<ServerApi["question"]["reply"]>[0]) {
-        if (!(await isV1())) return input.current.question.reply(value)
         await legacy().question.reply({
           requestID: value.requestID,
           answers: value.answers.map((answer) => [...answer]),
         })
       },
       async reject(value: Parameters<ServerApi["question"]["reject"]>[0]) {
-        if (!(await isV1())) return input.current.question.reject(value)
         await legacy().question.reject({ requestID: value.requestID })
       },
     },

packages/app/src/utils/server-health.test.ts

@@ -42,6 +42,19 @@ describe("checkServerHealth", () => {
     expect(paths).toEqual(["/api/health", "/global/health"])
   })
 
+  test("falls back when the current health response is malformed", async () => {
+    const paths: string[] = []
+    const fetch = (async (input: RequestInfo | URL) => {
+      const url = input instanceof URL ? input : new URL(input instanceof Request ? input.url : input)
+      paths.push(url.pathname)
+      if (url.pathname === "/api/health") return Response.json({})
+      return Response.json({ healthy: true, version: "1.18.4" })
+    }) as unknown as typeof globalThis.fetch
+
+    expect(await checkServerHealth(server, fetch)).toEqual({ healthy: true, version: "1.18.4" })
+    expect(paths).toEqual(["/api/health", "/global/health"])
+  })
+
   test("allows slow servers thirty seconds by default", async () => {
     const timeout = Object.getOwnPropertyDescriptor(AbortSignal, "timeout")
     let timeoutMs = 0

packages/app/src/utils/server-health.ts

@@ -95,9 +95,13 @@ export async function checkServerHealth(
         : undefined,
     })
       .health.get({ signal })
-      .then((x) => ({ data: { healthy: x.healthy === true, version: x.version } }))
+      .then((x) =>
+        typeof x.healthy === "boolean"
+          ? { data: { healthy: x.healthy, version: x.version } }
+          : { error: new Error("Invalid health response") },
+      )
       .catch((error) => ({ error }))
-    if ("data" in current) return current.data
+    if ("data" in current && current.data) return current.data
     if (signal?.aborted) return { healthy: false }
 
     return createSdkForServer({ server, fetch, signal })

packages/app/src/utils/server.ts

@@ -1,23 +1,5 @@
 import { createOpencodeClient } from "@opencode-ai/sdk/v2/client"
-import { OpenCode } from "@opencode-ai/client/promise"
-import type {
-  AgentApi,
-  CatalogApi,
-  CommandApi,
-  EventApi,
-  FileApi,
-  IntegrationApi,
-  McpApi,
-  MessageApi,
-  PathApi,
-  PermissionApi,
-  ProjectApi,
-  PtyApi,
-  QuestionApi,
-  ReferenceApi,
-  SessionApi,
-  VcsApi,
-} from "@opencode-ai/client/promise"
+import { OpenCode, type OpenCodeClient } from "@opencode-ai/client/promise"
 import type { ServerConnection } from "@/context/server"
 import { decode64 } from "@/utils/base64"
 
@@ -59,28 +41,10 @@ export function createSdkForServer({
   })
 }
 
-export interface ServerApi extends CatalogApi {
-  readonly agent: AgentApi
-  readonly command: CommandApi
-  readonly event: EventApi
-  readonly file: FileApi
-  readonly integration: IntegrationApi
-  readonly mcp: McpApi
-  readonly message: MessageApi
-  readonly path: PathApi
-  readonly permission: PermissionApi
-  readonly project: ProjectApi
-  readonly pty: PtyApi
-  readonly question: QuestionApi
-  readonly reference: ReferenceApi
-  readonly session: SessionApi
-  readonly vcs: VcsApi
-}
-
 export function createApiForServer(input: {
   server: ServerConnection.HttpBase
   fetch?: typeof globalThis.fetch
-}): ServerApi {
+}): OpenCodeClient {
   return OpenCode.make({
     baseUrl: input.server.url,
     fetch: input.fetch,
@@ -94,3 +58,5 @@ export function createApiForServer(input: {
       : undefined,
   })
 }
+
+export type ServerApi = OpenCodeClient

packages/app/src/utils/session-message.test.ts

@@ -1,200 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import type { SessionMessageInfo } from "@opencode-ai/client/promise"
-import { normalizeSessionMessages } from "./session-message"
-
-describe("normalizeSessionMessages", () => {
-  test("projects current turns into stable legacy rendering records", () => {
-    const source = [
-      { id: "msg_1", type: "agent-switched", agent: "build", time: { created: 1 } },
-      {
-        id: "msg_2",
-        type: "model-switched",
-        model: { id: "claude", providerID: "anthropic", variant: "high" },
-        time: { created: 2 },
-      },
-      {
-        id: "msg_3",
-        type: "user",
-        text: "inspect this",
-        files: [
-          {
-            data: "aGVsbG8=",
-            mime: "text/plain",
-            name: "note.txt",
-            source: { type: "inline" },
-          },
-        ],
-        agents: [{ name: "review", mention: { text: "@review", start: 0, end: 7 } }],
-        time: { created: 3 },
-      },
-      {
-        id: "msg_4",
-        type: "assistant",
-        agent: "build",
-        model: { id: "claude", providerID: "anthropic", variant: "high" },
-        content: [
-          { type: "reasoning", text: "Thinking", time: { created: 4, completed: 5 } },
-          { type: "text", text: "Result" },
-          {
-            type: "tool",
-            id: "call_1",
-            name: "read",
-            state: {
-              status: "completed",
-              input: { filePath: "note.txt" },
-              structured: { title: "note.txt" },
-              content: [{ type: "text", text: "hello" }],
-            },
-            time: { created: 5, ran: 6, completed: 7 },
-          },
-        ],
-        cost: 0.1,
-        tokens: { input: 10, output: 5, reasoning: 2, cache: { read: 1, write: 0 } },
-        time: { created: 4, completed: 7 },
-      },
-      {
-        id: "msg_5",
-        type: "compaction",
-        status: "completed",
-        reason: "auto",
-        summary: "summary",
-        recent: "recent",
-        time: { created: 8 },
-      },
-    ] satisfies SessionMessageInfo[]
-
-    const result = normalizeSessionMessages("ses_1", source)
-
-    expect(result.messages).toHaveLength(2)
-    expect(result.messages[0]).toMatchObject({
-      id: "msg_3",
-      role: "user",
-      agent: "build",
-      model: { providerID: "anthropic", modelID: "claude", variant: "high" },
-    })
-    expect(result.messages[1]).toMatchObject({ id: "msg_4", role: "assistant", parentID: "msg_3", cost: 0.1 })
-    expect(result.parts.get("msg_3")?.map((part) => part.id)).toEqual([
-      "msg_3:text:0",
-      "msg_3:file:0",
-      "msg_3:agent:0",
-      "msg_5:compaction",
-    ])
-    expect(result.parts.get("msg_4")?.map((part) => part.id)).toEqual(["msg_4:reasoning:0", "msg_4:text:0", "call_1"])
-    expect(result.parts.get("msg_4")?.[2]).toMatchObject({
-      type: "tool",
-      tool: "read",
-      state: { status: "completed", output: "hello" },
-    })
-  })
-
-  test("does not invent a parent for an assistant-only page", () => {
-    const source = [
-      {
-        id: "msg_2",
-        type: "assistant",
-        agent: "build",
-        model: { id: "model", providerID: "provider" },
-        content: [{ type: "text", text: "orphan" }],
-        time: { created: 2 },
-      },
-    ] satisfies SessionMessageInfo[]
-
-    expect(normalizeSessionMessages("ses_1", source).messages).toEqual([])
-  })
-
-  test("projects a current shell message into a renderable standalone turn", () => {
-    const source = [
-      {
-        id: "msg_shell",
-        type: "shell",
-        shellID: "shell_1",
-        command: "printf hello",
-        status: "exited",
-        exit: 0,
-        output: { output: "hello", cursor: 5, size: 5, truncated: false },
-        time: { created: 1, completed: 2 },
-      },
-    ] satisfies SessionMessageInfo[]
-
-    const result = normalizeSessionMessages("ses_1", source)
-
-    expect(result.messages).toEqual([
-      expect.objectContaining({ id: "msg_shell", role: "user" }),
-      expect.objectContaining({ id: "msg_shell:assistant", role: "assistant", parentID: "msg_shell" }),
-    ])
-    expect(result.parts.get("msg_shell")).toEqual([
-      expect.objectContaining({ type: "text", text: "printf hello" }),
-    ])
-    expect(result.parts.get("msg_shell:assistant")).toEqual([
-      expect.objectContaining({
-        type: "tool",
-        tool: "bash",
-        state: expect.objectContaining({
-          status: "completed",
-          input: { command: "printf hello" },
-          output: "hello",
-          title: "Shell",
-        }),
-      }),
-    ])
-  })
-
-  test("adapts current edit fields for the legacy edit renderer", () => {
-    const source = [
-      { id: "msg_user", type: "user", text: "edit it", time: { created: 1 } },
-      {
-        id: "msg_assistant",
-        type: "assistant",
-        agent: "build",
-        model: { id: "model", providerID: "provider" },
-        content: [
-          {
-            type: "tool",
-            id: "call_edit",
-            name: "edit",
-            state: {
-              status: "completed",
-              input: { path: "/repo/README.md", oldString: "old", newString: "new" },
-              content: [{ type: "text", text: "Edited file successfully" }],
-              structured: {
-                files: [
-                  {
-                    file: "README.md",
-                    patch: "@@ -1 +1 @@\n-old\n+new",
-                    additions: 1,
-                    deletions: 1,
-                    status: "modified",
-                  },
-                ],
-                replacements: 1,
-              },
-            },
-            time: { created: 2, ran: 3, completed: 4 },
-          },
-        ],
-        time: { created: 2, completed: 4 },
-      },
-    ] satisfies SessionMessageInfo[]
-
-    const result = normalizeSessionMessages("ses_1", source)
-
-    expect(result.parts.get("msg_assistant")).toEqual([
-      expect.objectContaining({
-        type: "tool",
-        tool: "edit",
-        state: expect.objectContaining({
-          status: "completed",
-          input: expect.objectContaining({ path: "/repo/README.md", filePath: "/repo/README.md" }),
-          metadata: expect.objectContaining({
-            filediff: {
-              file: "README.md",
-              patch: "@@ -1 +1 @@\n-old\n+new",
-              additions: 1,
-              deletions: 1,
-            },
-          }),
-        }),
-      }),
-    ])
-  })
-})

packages/app/src/utils/session-message.ts

@@ -1,348 +0,0 @@
-import type {
-  SessionMessageAssistant,
-  SessionMessageAssistantTool,
-  SessionMessageInfo,
-  SessionMessageShell,
-  SessionMessageUser,
-} from "@opencode-ai/client/promise"
-import type { AssistantMessage, FilePart, Message, Part, ToolPart, UserMessage } from "@opencode-ai/sdk/v2"
-import { Option, Schema } from "effect"
-
-const emptyTokens = { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }
-const emptyModel: { id: string; providerID: string; variant?: string } = { id: "", providerID: "" }
-const decodeToolInput = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
-
-function record(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === "object" && !Array.isArray(value)
-}
-
-function normalizeToolInput(name: string, input: Record<string, unknown>) {
-  if (!["edit", "write"].includes(name) || typeof input.path !== "string" || typeof input.filePath === "string")
-    return input
-  return { ...input, filePath: input.path }
-}
-
-function normalizeToolMetadata(name: string, metadata: Record<string, unknown>) {
-  if (name !== "edit" || !Array.isArray(metadata.files)) return metadata
-  const file = metadata.files.find(record)
-  if (!file || typeof file.file !== "string") return metadata
-  return {
-    ...metadata,
-    filediff: {
-      file: file.file,
-      patch: typeof file.patch === "string" ? file.patch : undefined,
-      additions: typeof file.additions === "number" ? file.additions : 0,
-      deletions: typeof file.deletions === "number" ? file.deletions : 0,
-    },
-  }
-}
-
-export function normalizeSessionMessages(sessionID: string, source: readonly SessionMessageInfo[]) {
-  const messages: Message[] = []
-  const parts = new Map<string, Part[]>()
-  let agent = ""
-  let model = emptyModel
-  let parentID: string | undefined
-
-  source.forEach((message) => {
-    if (message.type === "agent-switched") {
-      agent = message.agent
-      return
-    }
-    if (message.type === "model-switched") {
-      model = message.model
-      return
-    }
-    if (message.type === "user") {
-      parentID = message.id
-      messages.push(userMessage(sessionID, message, agent, model))
-      parts.set(message.id, userParts(sessionID, message))
-      return
-    }
-    if (message.type === "synthetic" && message.description?.trim()) {
-      parentID = message.id
-      messages.push({
-        id: message.id,
-        sessionID,
-        role: "user",
-        time: message.time,
-        agent,
-        model: { providerID: model.providerID, modelID: model.id, variant: model.variant },
-      })
-      parts.set(message.id, [textPart(sessionID, message.id, 0, message.description, true)])
-      return
-    }
-    if (message.type === "shell") {
-      messages.push(...shellMessages(sessionID, message, agent, model))
-      parts.set(message.id, [textPart(sessionID, message.id, 0, message.command)])
-      parts.set(`${message.id}:assistant`, [shellPart(sessionID, message)])
-      parentID = undefined
-      return
-    }
-    if (message.type === "assistant") {
-      agent = message.agent
-      model = message.model
-      if (!parentID) return
-      const parent = messages.findLast((item) => item.id === parentID)
-      if (parent?.role === "user") {
-        parent.agent = message.agent
-        parent.model = {
-          providerID: message.model.providerID,
-          modelID: message.model.id,
-          variant: message.model.variant,
-        }
-      }
-      messages.push(assistantMessage(sessionID, parentID, message))
-      parts.set(message.id, assistantParts(sessionID, message))
-      return
-    }
-    if (message.type !== "compaction" || !parentID) return
-    parts.set(parentID, [
-      ...(parts.get(parentID) ?? []),
-      {
-        id: `${message.id}:compaction`,
-        sessionID,
-        messageID: parentID,
-        type: "compaction",
-        auto: message.reason === "auto",
-      },
-    ])
-  })
-
-  return { messages, parts }
-}
-
-function shellMessages(
-  sessionID: string,
-  message: SessionMessageShell,
-  agent: string,
-  model: { id: string; providerID: string; variant?: string },
-): [UserMessage, AssistantMessage] {
-  return [
-    {
-      id: message.id,
-      sessionID,
-      role: "user",
-      time: { created: message.time.created },
-      agent,
-      model: { providerID: model.providerID, modelID: model.id, variant: model.variant },
-    },
-    {
-      id: `${message.id}:assistant`,
-      sessionID,
-      role: "assistant",
-      time: message.time,
-      parentID: message.id,
-      modelID: model.id,
-      providerID: model.providerID,
-      variant: model.variant,
-      mode: agent,
-      agent,
-      path: { cwd: "", root: "" },
-      cost: 0,
-      tokens: emptyTokens,
-    },
-  ]
-}
-
-function shellPart(sessionID: string, message: SessionMessageShell): ToolPart {
-  const input = { command: message.command }
-  const start = message.time.created
-  const state: ToolPart["state"] =
-    message.status === "running"
-      ? { status: "running", input, time: { start } }
-      : {
-          status: "completed",
-          input,
-          output: message.output?.output ?? "",
-          title: "Shell",
-          metadata: {
-            status: message.status,
-            exit: message.exit,
-            truncated: message.output?.truncated,
-          },
-          time: { start, end: message.time.completed ?? start },
-        }
-  return {
-    id: `${message.id}:tool`,
-    sessionID,
-    messageID: `${message.id}:assistant`,
-    type: "tool",
-    callID: message.shellID,
-    tool: "bash",
-    state,
-  }
-}
-
-export function sessionMessagePartID(messageID: string, type: "text" | "reasoning", ordinal: number) {
-  return `${messageID}:${type}:${ordinal}`
-}
-
-function userMessage(
-  sessionID: string,
-  message: SessionMessageUser,
-  agent: string,
-  model: { id: string; providerID: string; variant?: string },
-): UserMessage {
-  return {
-    id: message.id,
-    sessionID,
-    role: "user",
-    time: message.time,
-    agent,
-    model: { providerID: model.providerID, modelID: model.id, variant: model.variant },
-  }
-}
-
-function userParts(sessionID: string, message: SessionMessageUser): Part[] {
-  return [
-    textPart(sessionID, message.id, 0, message.text),
-    ...(message.files ?? []).map(
-      (file, index): FilePart => ({
-        id: `${message.id}:file:${index}`,
-        sessionID,
-        messageID: message.id,
-        type: "file",
-        mime: file.mime,
-        filename: file.name,
-        url: file.source.type === "uri" ? file.source.uri : `data:${file.mime};base64,${file.data}`,
-      }),
-    ),
-    ...(message.agents ?? []).map(
-      (item, index): Part => ({
-        id: `${message.id}:agent:${index}`,
-        sessionID,
-        messageID: message.id,
-        type: "agent",
-        name: item.name,
-        source: item.mention
-          ? { value: item.mention.text, start: item.mention.start, end: item.mention.end }
-          : undefined,
-      }),
-    ),
-  ]
-}
-
-function assistantMessage(sessionID: string, parentID: string, message: SessionMessageAssistant): AssistantMessage {
-  const error = message.error
-    ? message.error.type.toLowerCase().includes("abort") || message.error.type.toLowerCase().includes("interrupt")
-      ? { name: "MessageAbortedError" as const, data: { message: message.error.message } }
-      : { name: "UnknownError" as const, data: { message: message.error.message } }
-    : undefined
-  return {
-    id: message.id,
-    sessionID,
-    role: "assistant",
-    time: message.time,
-    error,
-    parentID,
-    modelID: message.model.id,
-    providerID: message.model.providerID,
-    variant: message.model.variant,
-    mode: message.agent,
-    agent: message.agent,
-    path: { cwd: "", root: "" },
-    cost: message.cost ?? 0,
-    tokens: message.tokens ?? emptyTokens,
-    finish: message.finish,
-  }
-}
-
-function assistantParts(sessionID: string, message: SessionMessageAssistant): Part[] {
-  const ordinals = { text: 0, reasoning: 0 }
-  return message.content.flatMap((content): Part[] => {
-    if (content.type === "text") {
-      const part = textPart(sessionID, message.id, ordinals.text++, content.text)
-      return content.text.trim() ? [part] : []
-    }
-    if (content.type === "reasoning") {
-      const part: Part = {
-        id: sessionMessagePartID(message.id, "reasoning", ordinals.reasoning++),
-        sessionID,
-        messageID: message.id,
-        type: "reasoning",
-        text: content.text,
-        metadata: content.state,
-        time: {
-          start: content.time?.created ?? message.time.created,
-          end: content.time?.completed,
-        },
-      }
-      return content.text.trim() ? [part] : []
-    }
-    return [toolPart(sessionID, message.id, content)]
-  })
-}
-
-function textPart(sessionID: string, messageID: string, ordinal: number, text: string, synthetic?: boolean): Part {
-  return {
-    id: sessionMessagePartID(messageID, "text", ordinal),
-    sessionID,
-    messageID,
-    type: "text",
-    text,
-    synthetic,
-  }
-}
-
-function toolPart(sessionID: string, messageID: string, tool: SessionMessageAssistantTool): ToolPart {
-  const start = tool.time.ran ?? tool.time.created
-  const state = (() => {
-    if (tool.state.status === "streaming") {
-      const value = Option.getOrUndefined(decodeToolInput(tool.state.input))
-      const input = normalizeToolInput(tool.name, record(value) ? value : {})
-      return { status: "pending" as const, input, raw: tool.state.input }
-    }
-    if (tool.state.status === "running") {
-      return {
-        status: "running" as const,
-        input: normalizeToolInput(tool.name, tool.state.input),
-        metadata: normalizeToolMetadata(tool.name, tool.state.structured),
-        time: { start },
-      }
-    }
-    if (tool.state.status === "error") {
-      return {
-        status: "error" as const,
-        input: normalizeToolInput(tool.name, tool.state.input),
-        error: tool.state.error.message,
-        metadata: normalizeToolMetadata(tool.name, tool.state.structured),
-        time: { start, end: tool.time.completed ?? start },
-      }
-    }
-    const attachments = tool.state.content.flatMap((item, index): FilePart[] =>
-      item.type === "file"
-        ? [
-            {
-              id: `${tool.id}:file:${index}`,
-              sessionID,
-              messageID,
-              type: "file",
-              mime: item.mime,
-              filename: item.name,
-              url: item.uri,
-            },
-          ]
-        : [],
-    )
-    return {
-      status: "completed" as const,
-      input: normalizeToolInput(tool.name, tool.state.input),
-      output: tool.state.content.flatMap((item) => (item.type === "text" ? [item.text] : [])).join("\n"),
-      title: tool.name,
-      metadata: normalizeToolMetadata(tool.name, tool.state.structured),
-      time: { start, end: tool.time.completed ?? start },
-      attachments: attachments.length ? attachments : undefined,
-    }
-  })()
-  return {
-    id: tool.id,
-    sessionID,
-    messageID,
-    type: "tool",
-    callID: tool.id,
-    tool: tool.name,
-    state,
-    metadata: { providerState: tool.providerState, providerResultState: tool.providerResultState },
-  }
-}

packages/app/src/utils/session.test.ts

@@ -1,94 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import type { SessionApi, SessionInfo, SessionListInput } from "@opencode-ai/client/promise"
-import { listAllSessions, normalizeSessionInfo } from "./session"
-
-describe("normalizeSessionInfo", () => {
-  test("adapts a current session to the app session shape", () => {
-    const result = normalizeSessionInfo({
-      id: "session-1",
-      projectID: "project-1",
-      agent: "build",
-      model: { id: "gpt-5", providerID: "openai", variant: "high" },
-      cost: 0,
-      tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-      time: { created: 1, updated: 1 },
-      title: "New session",
-      location: { directory: "/repo/worktree", workspaceID: "workspace-1" },
-      subpath: "worktree",
-      revert: { messageID: "message-1", partID: "part-1", snapshot: "snapshot", files: [] },
-    } as SessionInfo)
-
-    expect(result).toEqual({
-      id: "session-1",
-      slug: "session-1",
-      projectID: "project-1",
-      workspaceID: "workspace-1",
-      directory: "/repo/worktree",
-      path: "worktree",
-      parentID: undefined,
-      cost: 0,
-      tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-      title: "New session",
-      agent: "build",
-      model: { id: "gpt-5", providerID: "openai", variant: "high" },
-      version: "",
-      time: { created: 1, updated: 1 },
-      revert: { messageID: "message-1", partID: "part-1", snapshot: "snapshot" },
-    })
-  })
-})
-
-describe("listAllSessions", () => {
-  test("loads every page in server order and retains the query", async () => {
-    const calls: SessionListInput[] = []
-    const pages = new Map<string | undefined, { data: SessionInfo[]; cursor: { next?: string } }>([
-      [undefined, { data: [sessionInfo("session-3"), sessionInfo("session-2")], cursor: { next: "next" } }],
-      ["next", { data: [sessionInfo("session-1", true)], cursor: {} }],
-    ])
-    const api = {
-      list: async (query = {}) => {
-        calls.push(query)
-        return pages.get(query.cursor) ?? { data: [], cursor: {} }
-      },
-    } satisfies Pick<SessionApi, "list">
-
-    const result = await listAllSessions(api, { directory: "/repo", order: "desc" })
-
-    expect(result.map((session) => session.id)).toEqual(["session-3", "session-2", "session-1"])
-    expect(result[2]?.time.archived).toBe(2)
-    expect(calls).toEqual([
-      { directory: "/repo", order: "desc", limit: 100, cursor: undefined },
-      { directory: "/repo", order: "desc", limit: 100, cursor: "next" },
-    ])
-  })
-
-  test("requests the terminal empty page when the server returns a next cursor", async () => {
-    const cursors: Array<string | undefined> = []
-    const api = {
-      list: async (query = {}) => {
-        cursors.push(query.cursor)
-        if (query.cursor) return { data: [], cursor: { next: "unused" } }
-        return { data: [sessionInfo("session-1")], cursor: { next: "terminal" } }
-      },
-    } satisfies Pick<SessionApi, "list">
-
-    const result = await listAllSessions(api, { directory: "/repo", limit: 25 })
-
-    expect(result.map((session) => session.id)).toEqual(["session-1"])
-    expect(cursors).toEqual([undefined, "terminal"])
-  })
-})
-
-function sessionInfo(id: string, archived = false) {
-  return {
-    id,
-    projectID: "project-1",
-    agent: "build",
-    model: { id: "model-1", providerID: "provider-1" },
-    cost: 0,
-    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-    time: { created: 1, updated: 1, archived: archived ? 2 : undefined },
-    title: id,
-    location: { directory: "/repo" },
-  } as SessionInfo
-}

packages/app/src/utils/session.ts

@@ -1,37 +0,0 @@
-import type { SessionApi, SessionInfo, SessionListInput } from "@opencode-ai/client/promise"
-import type { Session } from "@opencode-ai/sdk/v2/client"
-
-export function normalizeSessionInfo(input: SessionInfo | Session): Session {
-  if (!("location" in input)) return input
-  return {
-    id: input.id,
-    slug: input.id,
-    projectID: input.projectID,
-    workspaceID: input.location.workspaceID,
-    directory: input.location.directory,
-    path: input.subpath,
-    parentID: input.parentID,
-    cost: input.cost,
-    tokens: input.tokens,
-    title: input.title,
-    agent: input.agent,
-    model: input.model,
-    version: "",
-    time: input.time,
-    revert: input.revert && {
-      messageID: input.revert.messageID,
-      partID: input.revert.partID,
-      snapshot: input.revert.snapshot,
-    },
-  }
-}
-
-export async function listAllSessions(api: Pick<SessionApi, "list">, input: Omit<SessionListInput, "cursor">) {
-  const load = async (cursor?: string): Promise<Session[]> => {
-    const result = await api.list({ ...input, limit: input.limit ?? 100, cursor })
-    const sessions = result.data.map(normalizeSessionInfo)
-    if (result.data.length === 0 || !result.cursor.next) return sessions
-    return [...sessions, ...(await load(result.cursor.next))]
-  }
-  return load()
-}

packages/app/test-browser/command-palette.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import type { Project } from "@opencode-ai/sdk/v2/client"
-import type { SessionInfo } from "@opencode-ai/client/promise"
+import type { GlobalSession, Project } from "@opencode-ai/sdk/v2/client"
 import { createRoot } from "solid-js"
 import { createServerSessionEntries } from "@/components/command-palette"
 import type { LocalProject } from "@/context/layout"
@@ -15,16 +14,15 @@ const stored: Project = {
   time: { created: 1, updated: 1 },
 }
 
-const session: SessionInfo = {
+const session: GlobalSession = {
   id: "session-1",
+  slug: "session-1",
   projectID: stored.id,
-  agent: "build",
-  model: { id: "model-1", providerID: "provider-1" },
-  cost: 0,
-  tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-  location: { directory: stored.worktree },
+  directory: stored.worktree,
   title: "Palette session",
+  version: "1",
   time: { created: 1, updated: 2 },
+  project: { id: stored.id, name: stored.name, worktree: stored.worktree },
 }
 
 describe("command palette sessions", () => {

packages/core/package.json

@@ -72,7 +72,7 @@
     "@ai-sdk/google": "3.0.73",
     "@ai-sdk/google-vertex": "4.0.128",
     "@ai-sdk/groq": "3.0.31",
-    "@ai-sdk/mistral": "3.0.34",
+    "@ai-sdk/mistral": "3.0.51",
     "@ai-sdk/openai": "3.0.84",
     "@ai-sdk/openai-compatible": "2.0.41",
     "@ai-sdk/perplexity": "3.0.26",

packages/core/test/provider-mistral.test.ts

@@ -26,3 +26,257 @@ test("Mistral sends promptCacheKey as prompt_cache_key", async () => {
 
   expect(body?.prompt_cache_key).toBe("session-123")
 })
+
+test("Mistral round-trips native reasoning in assistant history", async () => {
+  let body: { messages?: unknown[] } | undefined
+  const mockFetch = Object.assign(
+    async (_input: Parameters<typeof fetch>[0], init?: RequestInit) => {
+      body = JSON.parse(String(init?.body))
+      return Response.json({
+        id: "response-1",
+        created: 0,
+        model: "mistral-small-latest",
+        object: "chat.completion",
+        choices: [
+          {
+            index: 0,
+            message: {
+              role: "assistant",
+              content: [
+                {
+                  type: "thinking",
+                  thinking: [
+                    { type: "text", text: "The user is greeting me." },
+                    {
+                      type: "tool_reference",
+                      tool: "web_search",
+                      title: "Example result",
+                      url: "https://example.com/tool",
+                      favicon: "https://example.com/favicon.ico",
+                      description: "Example description",
+                    },
+                    { type: "reference", reference_ids: [1, "source-2"] },
+                  ],
+                  closed: true,
+                  signature: "sig-123",
+                },
+                { type: "text", text: "Hi" },
+              ],
+            },
+            finish_reason: "stop",
+          },
+        ],
+        usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+      })
+    },
+    { preconnect: fetch.preconnect },
+  )
+  const model = createMistral({ apiKey: "test", fetch: mockFetch })("mistral-small-latest")
+
+  const first = await model.doGenerate({
+    prompt: [{ role: "user", content: [{ type: "text", text: "Hello" }] }],
+  })
+  const reasoning = first.content.find((part) => part.type === "reasoning")
+  const text = first.content.find((part) => part.type === "text")
+  if (!reasoning || !text) throw new Error("expected reasoning and text")
+
+  await model.doGenerate({
+    prompt: [
+      { role: "user", content: [{ type: "text", text: "Hello" }] },
+      {
+        role: "assistant",
+        content: [{ ...reasoning, providerOptions: reasoning.providerMetadata }, text],
+      },
+      { role: "user", content: [{ type: "text", text: "Hello again" }] },
+    ],
+  })
+
+  expect(body?.messages?.[1]).toEqual({
+    role: "assistant",
+    content: [
+      {
+        type: "thinking",
+        thinking: [
+          { type: "text", text: "The user is greeting me." },
+          {
+            type: "tool_reference",
+            tool: "web_search",
+            title: "Example result",
+            url: "https://example.com/tool",
+            favicon: "https://example.com/favicon.ico",
+            description: "Example description",
+          },
+          { type: "reference", reference_ids: [1, "source-2"] },
+        ],
+        closed: true,
+        signature: "sig-123",
+      },
+      { type: "text", text: "Hi" },
+    ],
+  })
+
+  await model.doGenerate({
+    prompt: [
+      { role: "user", content: [{ type: "text", text: "Hello" }] },
+      {
+        role: "assistant",
+        content: [
+          { type: "reasoning", text: "thinking" },
+          { type: "text", text: "Hi" },
+        ],
+      },
+      { role: "user", content: [{ type: "text", text: "Hello again" }] },
+    ],
+  })
+  expect(body?.messages?.[1]).toEqual({ role: "assistant", content: "thinkingHi" })
+})
+
+test("Mistral preserves native reasoning metadata while streaming", async () => {
+  const chunks = [
+    {
+      id: "response-1",
+      created: 0,
+      model: "mistral-small-latest",
+      choices: [
+        {
+          index: 0,
+          delta: {
+            role: "assistant",
+            content: [
+              {
+                type: "thinking",
+                thinking: [
+                  { type: "text", text: "thinking" },
+                  {
+                    type: "tool_reference",
+                    tool: "web_search",
+                    title: "Example result",
+                    url: "https://example.com/tool",
+                    favicon: "https://example.com/favicon.ico",
+                    description: "Example description",
+                  },
+                ],
+              },
+            ],
+          },
+        },
+      ],
+    },
+    {
+      id: "response-1",
+      created: 0,
+      model: "mistral-small-latest",
+      choices: [
+        {
+          index: 0,
+          delta: {
+            content: [
+              {
+                type: "thinking",
+                thinking: [{ type: "reference", reference_ids: [1, "source-2"] }],
+                closed: true,
+                signature: "sig-123",
+              },
+            ],
+          },
+        },
+      ],
+    },
+    {
+      id: "response-1",
+      created: 0,
+      model: "mistral-small-latest",
+      choices: [{ index: 0, delta: { content: [{ type: "text", text: "answer" }] } }],
+    },
+    {
+      id: "response-1",
+      created: 0,
+      model: "mistral-small-latest",
+      choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+      usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+    },
+  ]
+  const mockFetch = Object.assign(
+    async () =>
+      new Response(chunks.map((chunk) => `data: ${JSON.stringify(chunk)}\n\n`).join(""), {
+        headers: { "Content-Type": "text/event-stream" },
+      }),
+    { preconnect: fetch.preconnect },
+  )
+  const model = createMistral({ apiKey: "test", fetch: mockFetch })("mistral-small-latest")
+  const result = await model.doStream({
+    prompt: [{ role: "user", content: [{ type: "text", text: "Hello" }] }],
+  })
+  const events = []
+  for await (const event of result.stream) events.push(event)
+
+  expect(events.find((event) => event.type === "reasoning-end")?.providerMetadata).toEqual({
+    mistral: {
+      thinking: {
+        type: "thinking",
+        thinking: [
+          { type: "text", text: "thinking" },
+          {
+            type: "tool_reference",
+            tool: "web_search",
+            title: "Example result",
+            url: "https://example.com/tool",
+            favicon: "https://example.com/favicon.ico",
+            description: "Example description",
+          },
+          { type: "reference", reference_ids: [1, "source-2"] },
+        ],
+        closed: true,
+        signature: "sig-123",
+      },
+    },
+  })
+  expect(
+    events
+      .filter((event) => event.type === "reasoning-start" || event.type === "reasoning-delta")
+      .every((event) => event.providerMetadata === undefined),
+  ).toBe(true)
+})
+
+test("Mistral preserves metadata-only thinking chunks", async () => {
+  const thinking = {
+    type: "thinking" as const,
+    thinking: [
+      {
+        type: "tool_reference",
+        tool: "web_search",
+        title: "Example result",
+        url: "https://example.com/tool",
+        favicon: "https://example.com/favicon.ico",
+        description: "Example description",
+      },
+      { type: "reference", reference_ids: [1, "source-2"] },
+    ],
+    closed: true,
+    signature: "sig-123",
+  }
+  const mockFetch = Object.assign(
+    async () =>
+      Response.json({
+        id: "response-1",
+        created: 0,
+        model: "mistral-small-latest",
+        object: "chat.completion",
+        choices: [{ index: 0, message: { role: "assistant", content: [thinking] }, finish_reason: "stop" }],
+        usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+      }),
+    { preconnect: fetch.preconnect },
+  )
+  const model = createMistral({ apiKey: "test", fetch: mockFetch })("mistral-small-latest")
+  const result = await model.doGenerate({
+    prompt: [{ role: "user", content: [{ type: "text", text: "Hello" }] }],
+  })
+
+  expect(result.content).toEqual([
+    {
+      type: "reasoning",
+      text: "",
+      providerMetadata: { mistral: { thinking } },
+    },
+  ])
+})

packages/opencode/package.json

@@ -66,7 +66,7 @@
     "@ai-sdk/google": "3.0.73",
     "@ai-sdk/google-vertex": "4.0.128",
     "@ai-sdk/groq": "3.0.31",
-    "@ai-sdk/mistral": "3.0.34",
+    "@ai-sdk/mistral": "3.0.51",
     "@ai-sdk/openai": "3.0.84",
     "@ai-sdk/openai-compatible": "2.0.41",
     "@ai-sdk/perplexity": "3.0.26",

packages/opencode/test/session/llm.test.ts

@@ -906,6 +906,117 @@ describe("session.llm.stream", () => {
     },
   )
 
+  const mistralFixture = { providerID: "mistral", modelID: "mistral-small-latest" }
+  it.instance(
+    "replays native Mistral reasoning from chat history",
+    () =>
+      Effect.gen(function* () {
+        const fixture = loadFixture(mistralFixture.providerID, mistralFixture.modelID)
+        const request = waitRequest(
+          "/chat/completions",
+          createEventResponse(
+            [
+              {
+                id: "chatcmpl-mistral",
+                object: "chat.completion.chunk",
+                created: 0,
+                model: fixture.model.id,
+                choices: [{ index: 0, delta: { role: "assistant", content: "Hello" } }],
+              },
+              {
+                id: "chatcmpl-mistral",
+                object: "chat.completion.chunk",
+                created: 0,
+                model: fixture.model.id,
+                choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+              },
+            ],
+            true,
+          ),
+        )
+
+        const resolved = yield* Provider.use.getModel(
+          ProviderV2.ID.make(mistralFixture.providerID),
+          ModelV2.ID.make(fixture.model.id),
+        )
+        const sessionID = SessionID.make("session-test-mistral-reasoning")
+        const agent = {
+          name: "test",
+          mode: "primary",
+          options: {},
+          permission: [{ permission: "*", pattern: "*", action: "allow" }],
+        } satisfies Agent.Info
+
+        const user = {
+          id: MessageID.make("msg_user-mistral-reasoning"),
+          sessionID,
+          role: "user",
+          time: { created: Date.now() },
+          agent: agent.name,
+          model: { providerID: ProviderV2.ID.make(mistralFixture.providerID), modelID: resolved.id },
+        } satisfies SessionV1.User
+
+        const thinking = {
+          type: "thinking",
+          thinking: [
+            { type: "text", text: "thinking" },
+            {
+              type: "tool_reference",
+              tool: "web_search",
+              title: "Example result",
+              url: "https://example.com/tool",
+              favicon: "https://example.com/favicon.ico",
+              description: "Example description",
+            },
+            { type: "reference", reference_ids: [1, "source-2"] },
+          ],
+          closed: true,
+          signature: "sig-123",
+        }
+
+        yield* drain({
+          user,
+          sessionID,
+          model: resolved,
+          agent,
+          system: ["You are a helpful assistant."],
+          messages: [
+            { role: "user", content: "Hello" },
+            {
+              role: "assistant",
+              content: [
+                {
+                  type: "reasoning",
+                  text: "thinking",
+                  providerOptions: { mistral: { thinking } },
+                },
+                { type: "text", text: "Previous answer" },
+              ],
+            },
+            { role: "user", content: "Continue" },
+          ] satisfies ModelMessage[],
+          tools: {},
+        })
+
+        const capture = yield* Effect.promise(() => request)
+        const messages = capture.body.messages as Array<Record<string, unknown>>
+        expect(messages.find((message) => message.role === "assistant")).toEqual({
+          role: "assistant",
+          content: [thinking, { type: "text", text: "Previous answer" }],
+        })
+      }),
+    {
+      config: () => ({
+        enabled_providers: [mistralFixture.providerID],
+        provider: {
+          [mistralFixture.providerID]: {
+            options: { apiKey: "test-key", baseURL: `${state.server!.url.origin}/v1` },
+          },
+        },
+      }),
+    },
+  )
+
   const alibabaQwenFixture = { providerID: "alibaba", modelID: "qwen-plus" }
   it.instance(
     "service stream cancellation cancels provider response body promptly",

packages/session-ui/src/components/message-part.tsx

@@ -521,7 +521,6 @@ export function getToolInfo(
       }
     }
     case "bash":
-    case "shell":
       return {
         icon: "console",
         title: i18n.t("ui.tool.shell"),
@@ -539,7 +538,6 @@ export function getToolInfo(
         title: i18n.t("ui.messagePart.title.write"),
         subtitle: input.filePath ? getFilename(input.filePath) : undefined,
       }
-    case "patch":
     case "apply_patch":
       return {
         icon: "code-lines",
@@ -731,8 +729,8 @@ export function renderable(part: PartType, showReasoningSummaries = true) {
 }
 
 function toolDefaultOpen(tool: string, shell = false, edit = false) {
-  if (tool === "bash" || tool === "shell") return shell
-  if (tool === "edit" || tool === "write" || tool === "patch" || tool === "apply_patch") return edit
+  if (tool === "bash") return shell
+  if (tool === "edit" || tool === "write" || tool === "apply_patch") return edit
 }
 
 export function partDefaultOpen(part: PartType, shell = false, edit = false) {
@@ -1508,7 +1506,7 @@ export function registerTool(input: { name: string; render?: ToolComponent }) {
 }
 
 export function getTool(name: string) {
-  return state[name === "apply_patch" ? "patch" : name === "bash" ? "shell" : name]?.render
+  return state[name]?.render
 }
 
 export const ToolRegistry = {
@@ -2103,7 +2101,7 @@ ToolRegistry.register({
 })
 
 ToolRegistry.register({
-  name: "shell",
+  name: "bash",
   render(props) {
     const i18n = useI18n()
     const pending = () => props.status === "pending" || props.status === "running"
@@ -2339,7 +2337,7 @@ ToolRegistry.register({
 })
 
 ToolRegistry.register({
-  name: "patch",
+  name: "apply_patch",
   render(props) {
     const i18n = useI18n()
     const fileComponent = useFileComponent()

packages/session-ui/src/components/tool-error-card.tsx

@@ -51,8 +51,6 @@ export function ToolErrorCard(props: ToolErrorCardProps) {
       webfetch: "ui.tool.webfetch",
       websearch: "ui.tool.websearch",
       bash: "ui.tool.shell",
-      shell: "ui.tool.shell",
-      patch: "ui.tool.patch",
       apply_patch: "ui.tool.patch",
       question: "ui.tool.questions",
     }

patches/@ai-sdk%2Fmistral@3.0.34.patch

@@ -1,84 +0,0 @@
-diff --git a/dist/index.d.ts b/dist/index.d.ts
-index 1ca9113bed2728a616db773a8e08d8d6957447d7..15408ec429dc210b5fa43589d81b69c93bf27b2d 100644
---- a/dist/index.d.ts
-+++ b/dist/index.d.ts
-@@ -14,6 +14,7 @@ declare const mistralLanguageModelOptions: z.ZodObject<{
-         none: "none";
-         high: "high";
-     }>>;
-+    promptCacheKey: z.ZodOptional<z.ZodString>;
- }, z.core.$strip>;
- type MistralLanguageModelOptions = z.infer<typeof mistralLanguageModelOptions>;
- 
-diff --git a/dist/index.js b/dist/index.js
-index 45735e524aaff54ea058c99c729c5ffd3c507058..6aca5f6f13da0054ede31c1f1a692e4eaed37d34 100644
---- a/dist/index.js
-+++ b/dist/index.js
-@@ -268,7 +268,8 @@ var mistralLanguageModelOptions = import_v4.z.object({
-    * - `'high'`: Enable reasoning
-    * - `'none'`: Disable reasoning
-    */
--  reasoningEffort: import_v4.z.enum(["high", "none"]).optional()
-+  reasoningEffort: import_v4.z.enum(["high", "none"]).optional(),
-+  promptCacheKey: import_v4.z.string().optional()
- });
- 
- // src/mistral-error.ts
-@@ -413,6 +414,7 @@ var MistralChatLanguageModel = class {
-       top_p: topP,
-       random_seed: seed,
-       reasoning_effort: options.reasoningEffort,
-+      prompt_cache_key: options.promptCacheKey,
-       // response format:
-       response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? structuredOutputs && (responseFormat == null ? void 0 : responseFormat.schema) != null ? {
-         type: "json_schema",
-diff --git a/dist/index.mjs b/dist/index.mjs
-index 4c22df1cd78a1ba81309c8a86ceecefef4ba4aea..30cd3b1f503860109b7fa2107cd1eb17b70c96be 100644
---- a/dist/index.mjs
-+++ b/dist/index.mjs
-@@ -256,7 +256,8 @@ var mistralLanguageModelOptions = z.object({
-    * - `'high'`: Enable reasoning
-    * - `'none'`: Disable reasoning
-    */
--  reasoningEffort: z.enum(["high", "none"]).optional()
-+  reasoningEffort: z.enum(["high", "none"]).optional(),
-+  promptCacheKey: z.string().optional()
- });
- 
- // src/mistral-error.ts
-@@ -403,6 +404,7 @@ var MistralChatLanguageModel = class {
-       top_p: topP,
-       random_seed: seed,
-       reasoning_effort: options.reasoningEffort,
-+      prompt_cache_key: options.promptCacheKey,
-       // response format:
-       response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? structuredOutputs && (responseFormat == null ? void 0 : responseFormat.schema) != null ? {
-         type: "json_schema",
-diff --git a/src/mistral-chat-language-model.ts b/src/mistral-chat-language-model.ts
-index 480c472d534bedbe8897979673453bd1c29a70b7..e46496da94f7d4af9822897202ca6baae67dae3a 100644
---- a/src/mistral-chat-language-model.ts
-+++ b/src/mistral-chat-language-model.ts
-@@ -129,6 +129,7 @@ export class MistralChatLanguageModel implements LanguageModelV3 {
-       top_p: topP,
-       random_seed: seed,
-       reasoning_effort: options.reasoningEffort,
-+      prompt_cache_key: options.promptCacheKey,
- 
-       // response format:
-       response_format:
-diff --git a/src/mistral-chat-options.ts b/src/mistral-chat-options.ts
-index 80fff45fba2c378fa06962f071946bcd2b882a0b..b4fdfa51f3bf11a4220e010c8aca92482cb0c3db 100644
---- a/src/mistral-chat-options.ts
-+++ b/src/mistral-chat-options.ts
-@@ -62,6 +62,11 @@ export const mistralLanguageModelOptions = z.object({
-    * - `'none'`: Disable reasoning
-    */
-   reasoningEffort: z.enum(['high', 'none']).optional(),
-+
-+  /**
-+   * A stable identifier used to route requests with shared prompt prefixes.
-+   */
-+  promptCacheKey: z.string().optional(),
- });
- 
- export type MistralLanguageModelOptions = z.infer<

patches/@ai-sdk%2Fmistral@3.0.51.patch

@@ -0,0 +1,709 @@
+diff --git a/dist/index.d.mts b/dist/index.d.mts
+index 1bde0b9f8cbe6771a52c1041095c9dddfe8e5b6c..0ca2ffb2a0c9327aed5ddcf0004500dc8b42569f 100644
+--- a/dist/index.d.mts
++++ b/dist/index.d.mts
+@@ -14,6 +14,7 @@ declare const mistralLanguageModelOptions: z.ZodObject<{
+         none: "none";
+         high: "high";
+     }>>;
++    promptCacheKey: z.ZodOptional<z.ZodString>;
+ }, z.core.$strip>;
+ type MistralLanguageModelOptions = z.infer<typeof mistralLanguageModelOptions>;
+ 
+diff --git a/dist/index.d.ts b/dist/index.d.ts
+index 1bde0b9f8cbe6771a52c1041095c9dddfe8e5b6c..0ca2ffb2a0c9327aed5ddcf0004500dc8b42569f 100644
+--- a/dist/index.d.ts
++++ b/dist/index.d.ts
+@@ -14,6 +14,7 @@ declare const mistralLanguageModelOptions: z.ZodObject<{
+         none: "none";
+         high: "high";
+     }>>;
++    promptCacheKey: z.ZodOptional<z.ZodString>;
+ }, z.core.$strip>;
+ type MistralLanguageModelOptions = z.infer<typeof mistralLanguageModelOptions>;
+ 
+diff --git a/dist/index.js b/dist/index.js
+index d3f904c12a1d582cc7b9e9a2d30273e1a8505b28..267f34e20ea392b7a85ad5259d72d50605a6f971 100644
+--- a/dist/index.js
++++ b/dist/index.js
+@@ -128,11 +128,14 @@ function convertToMistralChatMessages(prompt) {
+       }
+       case "assistant": {
+         let text = "";
++        const structuredContent = [];
++        let hasNativeReasoning = false;
+         const toolCalls = [];
+         for (const part of content) {
+           switch (part.type) {
+             case "text": {
+               text += part.text;
++              structuredContent.push({ type: "text", text: part.text });
+               break;
+             }
+             case "tool-call": {
+@@ -148,6 +151,13 @@ function convertToMistralChatMessages(prompt) {
+             }
+             case "reasoning": {
+               text += part.text;
++              const native = part.providerOptions?.mistral?.thinking;
++              if (native?.type === "thinking") {
++                hasNativeReasoning = true;
++                structuredContent.push(native);
++                break;
++              }
++              structuredContent.push({ type: "text", text: part.text });
+               break;
+             }
+             default: {
+@@ -159,7 +169,7 @@ function convertToMistralChatMessages(prompt) {
+         }
+         messages.push({
+           role: "assistant",
+-          content: text,
++          content: hasNativeReasoning ? structuredContent : text,
+           prefix: isLastMessage ? true : void 0,
+           tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+         });
+@@ -268,7 +278,8 @@ var mistralLanguageModelOptions = import_v4.z.object({
+    * - `'high'`: Enable reasoning
+    * - `'none'`: Disable reasoning
+    */
+-  reasoningEffort: import_v4.z.enum(["high", "none"]).optional()
++  reasoningEffort: import_v4.z.enum(["high", "none"]).optional(),
++  promptCacheKey: import_v4.z.string().optional()
+ });
+ 
+ // src/mistral-error.ts
+@@ -407,6 +418,7 @@ var MistralChatLanguageModel = class {
+       stop: stopSequences,
+       random_seed: seed,
+       reasoning_effort: options.reasoningEffort,
++      prompt_cache_key: options.promptCacheKey,
+       // response format:
+       response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? structuredOutputs && (responseFormat == null ? void 0 : responseFormat.schema) != null ? {
+         type: "json_schema",
+@@ -465,9 +477,11 @@ var MistralChatLanguageModel = class {
+       for (const part of choice.message.content) {
+         if (part.type === "thinking") {
+           const reasoningText = extractReasoningContent(part.thinking);
+-          if (reasoningText.length > 0) {
+-            content.push({ type: "reasoning", text: reasoningText });
+-          }
++          content.push({
++            type: "reasoning",
++            text: reasoningText,
++            providerMetadata: { mistral: { thinking: part } }
++          });
+         } else if (part.type === "text") {
+           if (part.text.length > 0) {
+             content.push({ type: "text", text: part.text });
+@@ -528,6 +542,7 @@ var MistralChatLanguageModel = class {
+     let isFirstChunk = true;
+     let activeText = false;
+     let activeReasoningId = null;
++    let activeThinking = null;
+     const generateId2 = this.generateId;
+     return {
+       stream: response.pipeThrough(
+@@ -561,18 +576,19 @@ var MistralChatLanguageModel = class {
+               for (const part of delta.content) {
+                 if (part.type === "thinking") {
+                   const reasoningDelta = extractReasoningContent(part.thinking);
+-                  if (reasoningDelta.length > 0) {
+-                    if (activeReasoningId == null) {
+-                      if (activeText) {
+-                        controller.enqueue({ type: "text-end", id: "0" });
+-                        activeText = false;
+-                      }
+-                      activeReasoningId = generateId2();
+-                      controller.enqueue({
+-                        type: "reasoning-start",
+-                        id: activeReasoningId
+-                      });
++                  activeThinking = mergeThinking(activeThinking, part);
++                  if (activeReasoningId == null) {
++                    if (activeText) {
++                      controller.enqueue({ type: "text-end", id: "0" });
++                      activeText = false;
+                     }
++                    activeReasoningId = generateId2();
++                    controller.enqueue({
++                      type: "reasoning-start",
++                      id: activeReasoningId
++                    });
++                  }
++                  if (reasoningDelta.length > 0) {
+                     controller.enqueue({
+                       type: "reasoning-delta",
+                       id: activeReasoningId,
+@@ -587,9 +603,11 @@ var MistralChatLanguageModel = class {
+                 if (activeReasoningId != null) {
+                   controller.enqueue({
+                     type: "reasoning-end",
+-                    id: activeReasoningId
++                    id: activeReasoningId,
++                    providerMetadata: { mistral: { thinking: activeThinking } }
+                   });
+                   activeReasoningId = null;
++                  activeThinking = null;
+                 }
+                 controller.enqueue({ type: "text-start", id: "0" });
+                 activeText = true;
+@@ -638,7 +656,8 @@ var MistralChatLanguageModel = class {
+             if (activeReasoningId != null) {
+               controller.enqueue({
+                 type: "reasoning-end",
+-                id: activeReasoningId
++                id: activeReasoningId,
++                providerMetadata: { mistral: { thinking: activeThinking } }
+               });
+             }
+             if (activeText) {
+@@ -660,6 +679,13 @@ var MistralChatLanguageModel = class {
+ function extractReasoningContent(thinking) {
+   return thinking.filter((chunk) => chunk.type === "text").map((chunk) => chunk.text).join("");
+ }
++function mergeThinking(current, next) {
++  if (current === null) return { ...next, thinking: [...next.thinking] };
++  current.thinking.push(...next.thinking);
++  if (next.closed !== void 0) current.closed = next.closed;
++  if (next.signature !== void 0) current.signature = next.signature;
++  return current;
++}
+ function extractTextContent(content) {
+   if (typeof content === "string") {
+     return content;
+@@ -686,6 +712,30 @@ function extractTextContent(content) {
+   }
+   return textContent.length ? textContent.join("") : void 0;
+ }
++var mistralThinkingContentSchema = import_v43.z.discriminatedUnion("type", [
++  import_v43.z.object({
++    type: import_v43.z.literal("text"),
++    text: import_v43.z.string()
++  }),
++  import_v43.z.object({
++    type: import_v43.z.literal("tool_reference"),
++    tool: import_v43.z.string(),
++    title: import_v43.z.string(),
++    url: import_v43.z.string().nullish(),
++    favicon: import_v43.z.string().nullish(),
++    description: import_v43.z.string().nullish()
++  }),
++  import_v43.z.object({
++    type: import_v43.z.literal("reference"),
++    reference_ids: import_v43.z.array(import_v43.z.union([import_v43.z.string(), import_v43.z.number().int()]))
++  })
++]);
++var mistralThinkChunkSchema = import_v43.z.object({
++  type: import_v43.z.literal("thinking"),
++  thinking: import_v43.z.array(mistralThinkingContentSchema),
++  closed: import_v43.z.boolean().optional(),
++  signature: import_v43.z.string().nullish()
++});
+ var mistralContentSchema = import_v43.z.union([
+   import_v43.z.string(),
+   import_v43.z.array(
+@@ -708,15 +758,7 @@ var mistralContentSchema = import_v43.z.union([
+         type: import_v43.z.literal("reference"),
+         reference_ids: import_v43.z.array(import_v43.z.union([import_v43.z.string(), import_v43.z.number()]))
+       }),
+-      import_v43.z.object({
+-        type: import_v43.z.literal("thinking"),
+-        thinking: import_v43.z.array(
+-          import_v43.z.object({
+-            type: import_v43.z.literal("text"),
+-            text: import_v43.z.string()
+-          })
+-        )
+-      })
++      mistralThinkChunkSchema
+     ])
+   )
+ ]).nullish();
+diff --git a/dist/index.mjs b/dist/index.mjs
+index d2eff622c1b84a96bdeb4012cb0206a33012a04d..3bff11ddd6136ada45809568828cbc8f2493a42a 100644
+--- a/dist/index.mjs
++++ b/dist/index.mjs
+@@ -116,11 +116,14 @@ function convertToMistralChatMessages(prompt) {
+       }
+       case "assistant": {
+         let text = "";
++        const structuredContent = [];
++        let hasNativeReasoning = false;
+         const toolCalls = [];
+         for (const part of content) {
+           switch (part.type) {
+             case "text": {
+               text += part.text;
++              structuredContent.push({ type: "text", text: part.text });
+               break;
+             }
+             case "tool-call": {
+@@ -136,6 +139,13 @@ function convertToMistralChatMessages(prompt) {
+             }
+             case "reasoning": {
+               text += part.text;
++              const native = part.providerOptions?.mistral?.thinking;
++              if (native?.type === "thinking") {
++                hasNativeReasoning = true;
++                structuredContent.push(native);
++                break;
++              }
++              structuredContent.push({ type: "text", text: part.text });
+               break;
+             }
+             default: {
+@@ -147,7 +157,7 @@ function convertToMistralChatMessages(prompt) {
+         }
+         messages.push({
+           role: "assistant",
+-          content: text,
++          content: hasNativeReasoning ? structuredContent : text,
+           prefix: isLastMessage ? true : void 0,
+           tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+         });
+@@ -256,7 +266,8 @@ var mistralLanguageModelOptions = z.object({
+    * - `'high'`: Enable reasoning
+    * - `'none'`: Disable reasoning
+    */
+-  reasoningEffort: z.enum(["high", "none"]).optional()
++  reasoningEffort: z.enum(["high", "none"]).optional(),
++  promptCacheKey: z.string().optional()
+ });
+ 
+ // src/mistral-error.ts
+@@ -397,6 +408,7 @@ var MistralChatLanguageModel = class {
+       stop: stopSequences,
+       random_seed: seed,
+       reasoning_effort: options.reasoningEffort,
++      prompt_cache_key: options.promptCacheKey,
+       // response format:
+       response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? structuredOutputs && (responseFormat == null ? void 0 : responseFormat.schema) != null ? {
+         type: "json_schema",
+@@ -455,9 +467,11 @@ var MistralChatLanguageModel = class {
+       for (const part of choice.message.content) {
+         if (part.type === "thinking") {
+           const reasoningText = extractReasoningContent(part.thinking);
+-          if (reasoningText.length > 0) {
+-            content.push({ type: "reasoning", text: reasoningText });
+-          }
++          content.push({
++            type: "reasoning",
++            text: reasoningText,
++            providerMetadata: { mistral: { thinking: part } }
++          });
+         } else if (part.type === "text") {
+           if (part.text.length > 0) {
+             content.push({ type: "text", text: part.text });
+@@ -518,6 +532,7 @@ var MistralChatLanguageModel = class {
+     let isFirstChunk = true;
+     let activeText = false;
+     let activeReasoningId = null;
++    let activeThinking = null;
+     const generateId2 = this.generateId;
+     return {
+       stream: response.pipeThrough(
+@@ -551,18 +566,19 @@ var MistralChatLanguageModel = class {
+               for (const part of delta.content) {
+                 if (part.type === "thinking") {
+                   const reasoningDelta = extractReasoningContent(part.thinking);
+-                  if (reasoningDelta.length > 0) {
+-                    if (activeReasoningId == null) {
+-                      if (activeText) {
+-                        controller.enqueue({ type: "text-end", id: "0" });
+-                        activeText = false;
+-                      }
+-                      activeReasoningId = generateId2();
+-                      controller.enqueue({
+-                        type: "reasoning-start",
+-                        id: activeReasoningId
+-                      });
++                  activeThinking = mergeThinking(activeThinking, part);
++                  if (activeReasoningId == null) {
++                    if (activeText) {
++                      controller.enqueue({ type: "text-end", id: "0" });
++                      activeText = false;
+                     }
++                    activeReasoningId = generateId2();
++                    controller.enqueue({
++                      type: "reasoning-start",
++                      id: activeReasoningId
++                    });
++                  }
++                  if (reasoningDelta.length > 0) {
+                     controller.enqueue({
+                       type: "reasoning-delta",
+                       id: activeReasoningId,
+@@ -577,9 +593,11 @@ var MistralChatLanguageModel = class {
+                 if (activeReasoningId != null) {
+                   controller.enqueue({
+                     type: "reasoning-end",
+-                    id: activeReasoningId
++                    id: activeReasoningId,
++                    providerMetadata: { mistral: { thinking: activeThinking } }
+                   });
+                   activeReasoningId = null;
++                  activeThinking = null;
+                 }
+                 controller.enqueue({ type: "text-start", id: "0" });
+                 activeText = true;
+@@ -628,7 +646,8 @@ var MistralChatLanguageModel = class {
+             if (activeReasoningId != null) {
+               controller.enqueue({
+                 type: "reasoning-end",
+-                id: activeReasoningId
++                id: activeReasoningId,
++                providerMetadata: { mistral: { thinking: activeThinking } }
+               });
+             }
+             if (activeText) {
+@@ -650,6 +669,13 @@ var MistralChatLanguageModel = class {
+ function extractReasoningContent(thinking) {
+   return thinking.filter((chunk) => chunk.type === "text").map((chunk) => chunk.text).join("");
+ }
++function mergeThinking(current, next) {
++  if (current === null) return { ...next, thinking: [...next.thinking] };
++  current.thinking.push(...next.thinking);
++  if (next.closed !== void 0) current.closed = next.closed;
++  if (next.signature !== void 0) current.signature = next.signature;
++  return current;
++}
+ function extractTextContent(content) {
+   if (typeof content === "string") {
+     return content;
+@@ -676,6 +702,30 @@ function extractTextContent(content) {
+   }
+   return textContent.length ? textContent.join("") : void 0;
+ }
++var mistralThinkingContentSchema = z3.discriminatedUnion("type", [
++  z3.object({
++    type: z3.literal("text"),
++    text: z3.string()
++  }),
++  z3.object({
++    type: z3.literal("tool_reference"),
++    tool: z3.string(),
++    title: z3.string(),
++    url: z3.string().nullish(),
++    favicon: z3.string().nullish(),
++    description: z3.string().nullish()
++  }),
++  z3.object({
++    type: z3.literal("reference"),
++    reference_ids: z3.array(z3.union([z3.string(), z3.number().int()]))
++  })
++]);
++var mistralThinkChunkSchema = z3.object({
++  type: z3.literal("thinking"),
++  thinking: z3.array(mistralThinkingContentSchema),
++  closed: z3.boolean().optional(),
++  signature: z3.string().nullish()
++});
+ var mistralContentSchema = z3.union([
+   z3.string(),
+   z3.array(
+@@ -698,15 +748,7 @@ var mistralContentSchema = z3.union([
+         type: z3.literal("reference"),
+         reference_ids: z3.array(z3.union([z3.string(), z3.number()]))
+       }),
+-      z3.object({
+-        type: z3.literal("thinking"),
+-        thinking: z3.array(
+-          z3.object({
+-            type: z3.literal("text"),
+-            text: z3.string()
+-          })
+-        )
+-      })
++      mistralThinkChunkSchema
+     ])
+   )
+ ]).nullish();
+diff --git a/src/convert-to-mistral-chat-messages.ts b/src/convert-to-mistral-chat-messages.ts
+index 3c6914f8da615d7517bc43dd56198298d0a50247..8cd6f4c7577f746ef41e8a0aee682234c473667a 100644
+--- a/src/convert-to-mistral-chat-messages.ts
++++ b/src/convert-to-mistral-chat-messages.ts
+@@ -3,7 +3,11 @@ import {
+   type LanguageModelV3DataContent,
+   type LanguageModelV3Prompt,
+ } from '@ai-sdk/provider';
+-import type { MistralPrompt } from './mistral-chat-prompt';
++import type {
++  MistralAssistantMessageContent,
++  MistralPrompt,
++  MistralThinkChunk,
++} from './mistral-chat-prompt';
+ import { convertToBase64 } from '@ai-sdk/provider-utils';
+ 
+ function formatFileUrl({
+@@ -76,6 +80,8 @@ export function convertToMistralChatMessages(
+ 
+       case 'assistant': {
+         let text = '';
++        const structuredContent: Array<MistralAssistantMessageContent> = [];
++        let hasNativeReasoning = false;
+         const toolCalls: Array<{
+           id: string;
+           type: 'function';
+@@ -86,6 +92,7 @@ export function convertToMistralChatMessages(
+           switch (part.type) {
+             case 'text': {
+               text += part.text;
++              structuredContent.push({ type: 'text', text: part.text });
+               break;
+             }
+             case 'tool-call': {
+@@ -101,6 +108,14 @@ export function convertToMistralChatMessages(
+             }
+             case 'reasoning': {
+               text += part.text;
++              const native = part.providerOptions?.mistral
++                ?.thinking as MistralThinkChunk | undefined;
++              if (native?.type === 'thinking') {
++                hasNativeReasoning = true;
++                structuredContent.push(native);
++                break;
++              }
++              structuredContent.push({ type: 'text', text: part.text });
+               break;
+             }
+             default: {
+@@ -113,7 +128,7 @@ export function convertToMistralChatMessages(
+ 
+         messages.push({
+           role: 'assistant',
+-          content: text,
++          content: hasNativeReasoning ? structuredContent : text,
+           prefix: isLastMessage ? true : undefined,
+           tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+         });
+diff --git a/src/mistral-chat-language-model.ts b/src/mistral-chat-language-model.ts
+index 7e4a7ab552f1b41b7074e1b3cada8a51d791268d..847d26f9dfe03572a969a122f8c96b8bbfda8066 100644
+--- a/src/mistral-chat-language-model.ts
++++ b/src/mistral-chat-language-model.ts
+@@ -122,6 +122,7 @@ export class MistralChatLanguageModel implements LanguageModelV3 {
+       stop: stopSequences,
+       random_seed: seed,
+       reasoning_effort: options.reasoningEffort,
++      prompt_cache_key: options.promptCacheKey,
+ 
+       // response format:
+       response_format:
+@@ -201,9 +202,11 @@ export class MistralChatLanguageModel implements LanguageModelV3 {
+       for (const part of choice.message.content) {
+         if (part.type === 'thinking') {
+           const reasoningText = extractReasoningContent(part.thinking);
+-          if (reasoningText.length > 0) {
+-            content.push({ type: 'reasoning', text: reasoningText });
+-          }
++          content.push({
++            type: 'reasoning',
++            text: reasoningText,
++            providerMetadata: { mistral: { thinking: part } },
++          });
+         } else if (part.type === 'text') {
+           if (part.text.length > 0) {
+             content.push({ type: 'text', text: part.text });
+@@ -278,6 +281,7 @@ export class MistralChatLanguageModel implements LanguageModelV3 {
+     let isFirstChunk = true;
+     let activeText = false;
+     let activeReasoningId: string | null = null;
++    let activeThinking: z.infer<typeof mistralThinkChunkSchema> | null = null;
+ 
+     const generateId = this.generateId;
+ 
+@@ -326,20 +330,21 @@ export class MistralChatLanguageModel implements LanguageModelV3 {
+               for (const part of delta.content) {
+                 if (part.type === 'thinking') {
+                   const reasoningDelta = extractReasoningContent(part.thinking);
+-                  if (reasoningDelta.length > 0) {
+-                    if (activeReasoningId == null) {
+-                      // end any active text before starting reasoning
+-                      if (activeText) {
+-                        controller.enqueue({ type: 'text-end', id: '0' });
+-                        activeText = false;
+-                      }
+-
+-                      activeReasoningId = generateId();
+-                      controller.enqueue({
+-                        type: 'reasoning-start',
+-                        id: activeReasoningId,
+-                      });
++                  activeThinking = mergeThinking(activeThinking, part);
++                  if (activeReasoningId == null) {
++                    // end any active text before starting reasoning
++                    if (activeText) {
++                      controller.enqueue({ type: 'text-end', id: '0' });
++                      activeText = false;
+                     }
++
++                    activeReasoningId = generateId();
++                    controller.enqueue({
++                      type: 'reasoning-start',
++                      id: activeReasoningId,
++                    });
++                  }
++                  if (reasoningDelta.length > 0) {
+                     controller.enqueue({
+                       type: 'reasoning-delta',
+                       id: activeReasoningId,
+@@ -357,8 +362,12 @@ export class MistralChatLanguageModel implements LanguageModelV3 {
+                   controller.enqueue({
+                     type: 'reasoning-end',
+                     id: activeReasoningId,
++                    providerMetadata: {
++                      mistral: { thinking: activeThinking },
++                    },
+                   });
+                   activeReasoningId = null;
++                  activeThinking = null;
+                 }
+                 controller.enqueue({ type: 'text-start', id: '0' });
+                 activeText = true;
+@@ -416,6 +425,9 @@ export class MistralChatLanguageModel implements LanguageModelV3 {
+               controller.enqueue({
+                 type: 'reasoning-end',
+                 id: activeReasoningId,
++                providerMetadata: {
++                  mistral: { thinking: activeThinking },
++                },
+               });
+             }
+             if (activeText) {
+@@ -437,7 +449,7 @@ export class MistralChatLanguageModel implements LanguageModelV3 {
+ }
+ 
+ function extractReasoningContent(
+-  thinking: Array<{ type: string; text: string }>,
++  thinking: Array<z.infer<typeof mistralThinkingContentSchema>>,
+ ) {
+   return thinking
+     .filter(chunk => chunk.type === 'text')
+@@ -445,6 +457,17 @@ function extractReasoningContent(
+     .join('');
+ }
+ 
++function mergeThinking(
++  current: z.infer<typeof mistralThinkChunkSchema> | null,
++  next: z.infer<typeof mistralThinkChunkSchema>,
++) {
++  if (current === null) return { ...next, thinking: [...next.thinking] };
++  current.thinking.push(...next.thinking);
++  if (next.closed !== undefined) current.closed = next.closed;
++  if (next.signature !== undefined) current.signature = next.signature;
++  return current;
++}
++
+ function extractTextContent(content: z.infer<typeof mistralContentSchema>) {
+   if (typeof content === 'string') {
+     return content;
+@@ -478,6 +501,32 @@ function extractTextContent(content: z.infer<typeof mistralContentSchema>) {
+   return textContent.length ? textContent.join('') : undefined;
+ }
+ 
++const mistralThinkingContentSchema = z.discriminatedUnion('type', [
++  z.object({
++    type: z.literal('text'),
++    text: z.string(),
++  }),
++  z.object({
++    type: z.literal('tool_reference'),
++    tool: z.string(),
++    title: z.string(),
++    url: z.string().nullish(),
++    favicon: z.string().nullish(),
++    description: z.string().nullish(),
++  }),
++  z.object({
++    type: z.literal('reference'),
++    reference_ids: z.array(z.union([z.string(), z.number().int()])),
++  }),
++]);
++
++const mistralThinkChunkSchema = z.object({
++  type: z.literal('thinking'),
++  thinking: z.array(mistralThinkingContentSchema),
++  closed: z.boolean().optional(),
++  signature: z.string().nullish(),
++});
++
+ const mistralContentSchema = z
+   .union([
+     z.string(),
+@@ -501,15 +550,7 @@ const mistralContentSchema = z
+           type: z.literal('reference'),
+           reference_ids: z.array(z.union([z.string(), z.number()])),
+         }),
+-        z.object({
+-          type: z.literal('thinking'),
+-          thinking: z.array(
+-            z.object({
+-              type: z.literal('text'),
+-              text: z.string(),
+-            }),
+-          ),
+-        }),
++        mistralThinkChunkSchema,
+       ]),
+     ),
+   ])
+diff --git a/src/mistral-chat-options.ts b/src/mistral-chat-options.ts
+index 54b29c08517d348995b6ca093b11160e453d5c8b..de30c3e7d924889339e38b1067cb26e9ada05d11 100644
+--- a/src/mistral-chat-options.ts
++++ b/src/mistral-chat-options.ts
+@@ -64,6 +64,11 @@ export const mistralLanguageModelOptions = z.object({
+    * - `'none'`: Disable reasoning
+    */
+   reasoningEffort: z.enum(['high', 'none']).optional(),
++
++  /**
++   * A stable identifier used to route requests with shared prompt prefixes.
++   */
++  promptCacheKey: z.string().optional(),
+ });
+ 
+ export type MistralLanguageModelOptions = z.infer<
+diff --git a/src/mistral-chat-prompt.ts b/src/mistral-chat-prompt.ts
+index 13f1dced55ac4be084128127a57fbdd58115bc28..172b11dde3dd326c2f3befd99237474ed8c79285 100644
+--- a/src/mistral-chat-prompt.ts
++++ b/src/mistral-chat-prompt.ts
+@@ -23,7 +23,7 @@ export type MistralUserMessageContent =
+ 
+ export interface MistralAssistantMessage {
+   role: 'assistant';
+-  content: string;
++  content: string | Array<MistralAssistantMessageContent>;
+   prefix?: boolean;
+   tool_calls?: Array<{
+     id: string;
+@@ -32,6 +32,29 @@ export interface MistralAssistantMessage {
+   }>;
+ }
+ 
++export type MistralAssistantMessageContent =
++  | { type: 'text'; text: string }
++  | MistralThinkChunk;
++
++export type MistralThinkChunk = {
++  type: 'thinking';
++  thinking: Array<MistralThinkingContent>;
++  closed?: boolean;
++  signature?: string | null;
++};
++
++export type MistralThinkingContent =
++  | { type: 'text'; text: string }
++  | {
++      type: 'tool_reference';
++      tool: string;
++      title: string;
++      url?: string | null;
++      favicon?: string | null;
++      description?: string | null;
++    }
++  | { type: 'reference'; reference_ids: Array<string | number> };
++
+ export interface MistralToolMessage {
+   role: 'tool';
+   name: string;