Snapshot release v0.0.0-202509130959

.github/workflows/format.yml

@@ -1,4 +1,4 @@
-name: format
+name: Format
 
 on:
   push:

.github/workflows/typecheck.yml

@@ -1,4 +1,4 @@
-name: typecheck
+name: Typecheck
 
 on:
   pull_request:

.gitignore

@@ -8,5 +8,3 @@ node_modules
 openapi.json
 playground
 tmp
-dist
-.turbo

.opencode/tool/foo.ts

@@ -1,11 +0,0 @@
-import { tool } from "@opencode-ai/plugin"
-
-export default tool({
-  description: "call this tool when you want to give up",
-  args: {
-    message: tool.schema.string().describe("give up message"),
-  },
-  async execute(args) {
-    return "Hey fuck you!"
-  },
-})

STATS.md

@@ -77,11 +77,3 @@
 | 2025-09-10 | 307,287 (+7,251) | 233,435 (+3,647) | 540,722 (+10,898) |
 | 2025-09-11 | 314,083 (+6,796) | 237,356 (+3,921) | 551,439 (+10,717) |
 | 2025-09-12 | 321,046 (+6,963) | 240,728 (+3,372) | 561,774 (+10,335) |
-| 2025-09-13 | 324,894 (+3,848) | 245,539 (+4,811) | 570,433 (+8,659)  |
-| 2025-09-14 | 328,876 (+3,982) | 248,245 (+2,706) | 577,121 (+6,688)  |
-| 2025-09-15 | 334,201 (+5,325) | 250,983 (+2,738) | 585,184 (+8,063)  |
-| 2025-09-16 | 342,609 (+8,408) | 255,264 (+4,281) | 597,873 (+12,689) |
-| 2025-09-17 | 351,117 (+8,508) | 260,970 (+5,706) | 612,087 (+14,214) |
-| 2025-09-18 | 358,717 (+7,600) | 266,922 (+5,952) | 625,639 (+13,552) |
-| 2025-09-19 | 365,401 (+6,684) | 271,859 (+4,937) | 637,260 (+11,621) |
-| 2025-09-20 | 372,092 (+6,691) | 276,917 (+5,058) | 649,009 (+11,749) |

cloud/app/package.json

@@ -1,24 +1,23 @@
 {
-  "name": "@opencode/console-app",
+  "name": "@opencode/cloud-app",
   "type": "module",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "dev": "vinxi dev --host 0.0.0.0",
     "dev:remote": "VITE_AUTH_URL=https://auth.dev.opencode.ai bun sst shell --stage=dev bun dev",
-    "build": "vinxi build && ../../opencode/script/schema.ts ./.output/public/config.json",
+    "build": "vinxi build && ../../packages/opencode/script/schema.ts ./.output/public/config.json",
     "start": "vinxi start",
-    "version": "0.11.0"
+    "version": "0.7.9"
   },
   "dependencies": {
     "@ibm/plex": "6.4.1",
     "@openauthjs/openauth": "0.0.0-20250322224806",
-    "@opencode/console-core": "workspace:*",
     "@solidjs/meta": "^0.29.4",
     "@solidjs/router": "^0.15.0",
     "@solidjs/start": "^1.1.0",
     "solid-js": "catalog:",
     "vinxi": "^0.5.7",
-    "zod": "catalog:"
+    "@opencode/cloud-core": "workspace:*"
   },
   "engines": {
     "node": ">=22"

cloud/app/src/component/icon.tsx

@@ -69,14 +69,3 @@ export function IconCheck(props: JSX.SvgSVGAttributes<SVGSVGElement>) {
     </svg>
   )
 }
-
-export function IconCreditCard(props: JSX.SvgSVGAttributes<SVGSVGElement>) {
-  return (
-    <svg {...props} viewBox="0 0 24 24">
-      <path
-        fill="currentColor"
-        d="M20 4H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 14H4V8h16v10z"
-      />
-    </svg>
-  )
-}

cloud/app/src/context/auth.ts

@@ -1,10 +1,10 @@
 import { getRequestEvent } from "solid-js/web"
-import { and, Database, eq, inArray } from "@opencode/console-core/drizzle/index.js"
-import { WorkspaceTable } from "@opencode/console-core/schema/workspace.sql.js"
-import { UserTable } from "@opencode/console-core/schema/user.sql.js"
+import { and, Database, eq, inArray } from "@opencode/cloud-core/drizzle/index.js"
+import { WorkspaceTable } from "@opencode/cloud-core/schema/workspace.sql.js"
+import { UserTable } from "@opencode/cloud-core/schema/user.sql.js"
 import { redirect } from "@solidjs/router"
-import { AccountTable } from "@opencode/console-core/schema/account.sql.js"
-import { Actor } from "@opencode/console-core/actor.js"
+import { AccountTable } from "@opencode/cloud-core/schema/account.sql.js"
+import { Actor } from "@opencode/cloud-core/actor.js"
 
 import { createClient } from "@openauthjs/openauth/client"
 import { useAuthSession } from "./auth.session"

cloud/app/src/context/auth.withActor.ts

@@ -1,4 +1,4 @@
-import { Actor } from "@opencode/console-core/actor.js"
+import { Actor } from "@opencode/cloud-core/actor.js"
 import { getActor } from "./auth"
 
 export async function withActor<T>(fn: () => T, workspace?: string) {

cloud/app/src/routes/auth/index.ts

@@ -1,4 +1,4 @@
-import { Account } from "@opencode/console-core/account.js"
+import { Account } from "@opencode/cloud-core/account.js"
 import { redirect } from "@solidjs/router"
 import type { APIEvent } from "@solidjs/start/server"
 import { withActor } from "~/context/auth.withActor"

cloud/app/src/routes/debug/index.ts

@@ -1,7 +1,7 @@
 import type { APIEvent } from "@solidjs/start/server"
 import { json } from "@solidjs/router"
-import { Database } from "@opencode/console-core/drizzle/index.js"
-import { UserTable } from "@opencode/console-core/schema/user.sql.js"
+import { Database } from "@opencode/cloud-core/drizzle/index.js"
+import { UserTable } from "@opencode/cloud-core/schema/user.sql.js"
 
 export async function GET(evt: APIEvent) {
   return json({

cloud/app/src/routes/index.tsx

@@ -8,7 +8,7 @@ import { IconCopy, IconCheck } from "../component/icon"
 import { createAsync, query } from "@solidjs/router"
 import { getActor } from "~/context/auth"
 import { withActor } from "~/context/auth.withActor"
-import { Account } from "@opencode/console-core/account.js"
+import { Account } from "@opencode/cloud-core/account.js"
 
 function CopyStatus() {
   return (

cloud/app/src/routes/stripe/webhook.ts

@@ -1,11 +1,11 @@
-import { Billing } from "@opencode/console-core/billing.js"
+import { Billing } from "@opencode/cloud-core/billing.js"
 import type { APIEvent } from "@solidjs/start/server"
-import { Database, eq, sql } from "@opencode/console-core/drizzle/index.js"
-import { BillingTable, PaymentTable } from "@opencode/console-core/schema/billing.sql.js"
-import { Identifier } from "@opencode/console-core/identifier.js"
-import { centsToMicroCents } from "@opencode/console-core/util/price.js"
-import { Actor } from "@opencode/console-core/actor.js"
-import { Resource } from "@opencode/console-resource"
+import { Database, eq, sql } from "@opencode/cloud-core/drizzle/index.js"
+import { BillingTable, PaymentTable } from "@opencode/cloud-core/schema/billing.sql.js"
+import { Identifier } from "@opencode/cloud-core/identifier.js"
+import { centsToMicroCents } from "@opencode/cloud-core/util/price.js"
+import { Actor } from "@opencode/cloud-core/actor.js"
+import { Resource } from "@opencode/cloud-resource"
 
 export async function POST(input: APIEvent) {
   const body = await Billing.stripe().webhooks.constructEventAsync(
@@ -15,28 +15,6 @@ export async function POST(input: APIEvent) {
   )
 
   console.log(body.type, JSON.stringify(body, null, 2))
-  if (body.type === "customer.updated") {
-    // check default payment method changed
-    const prevInvoiceSettings = body.data.previous_attributes?.invoice_settings ?? {}
-    if (!("default_payment_method" in prevInvoiceSettings)) return
-
-    const customerID = body.data.object.id
-    const paymentMethodID = body.data.object.invoice_settings.default_payment_method as string
-
-    if (!customerID) throw new Error("Customer ID not found")
-    if (!paymentMethodID) throw new Error("Payment method ID not found")
-
-    const paymentMethod = await Billing.stripe().paymentMethods.retrieve(paymentMethodID)
-    await Database.use(async (tx) => {
-      await tx
-        .update(BillingTable)
-        .set({
-          paymentMethodID,
-          paymentMethodLast4: paymentMethod.card!.last4,
-        })
-        .where(eq(BillingTable.customerID, customerID))
-    })
-  }
   if (body.type === "checkout.session.completed") {
     const workspaceID = body.data.object.metadata?.workspaceID
     const customerID = body.data.object.customer as string
@@ -48,6 +26,8 @@ export async function POST(input: APIEvent) {
     if (!amount) throw new Error("Amount not found")
     if (!paymentID) throw new Error("Payment ID not found")
 
+    const chargedAmount = 2000
+
     await Actor.provide("system", { workspaceID }, async () => {
       const customer = await Billing.get()
       if (customer?.customerID && customer.customerID !== customerID) throw new Error("Customer ID mismatch")
@@ -72,19 +52,16 @@ export async function POST(input: APIEvent) {
         await tx
           .update(BillingTable)
           .set({
-            balance: sql`${BillingTable.balance} + ${centsToMicroCents(Billing.CHARGE_AMOUNT)}`,
+            balance: sql`${BillingTable.balance} + ${centsToMicroCents(chargedAmount)}`,
             customerID,
             paymentMethodID: paymentMethod.id,
             paymentMethodLast4: paymentMethod.card!.last4,
-            reload: true,
-            reloadError: null,
-            timeReloadError: null,
           })
           .where(eq(BillingTable.workspaceID, workspaceID))
         await tx.insert(PaymentTable).values({
           workspaceID,
           id: Identifier.create("payment"),
-          amount: centsToMicroCents(Billing.CHARGE_AMOUNT),
+          amount: centsToMicroCents(chargedAmount),
           paymentID,
           customerID,
         })

cloud/app/src/routes/workspace.tsx

@@ -13,8 +13,8 @@ import {
   useParams,
   A,
 } from "@solidjs/router"
-import { User } from "@opencode/console-core/user.js"
-import { Actor } from "@opencode/console-core/actor.js"
+import { User } from "@opencode/cloud-core/user.js"
+import { Actor } from "@opencode/cloud-core/actor.js"
 import { getRequestEvent } from "solid-js/web"
 
 const getUserInfo = query(async (workspaceID: string) => {

cloud/app/src/routes/workspace/[id].css

@@ -0,0 +1,630 @@
+[data-page="workspace-[id]"] {
+  max-width: 64rem;
+  padding: var(--space-10) var(--space-4);
+  margin: 0 auto;
+  width: 100%;
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-10);
+
+  @media (max-width: 30rem) {
+    padding-top: var(--space-4);
+    padding-bottom: var(--space-4);
+
+    gap: var(--space-8);
+  }
+
+  [data-slot="sections"] {
+    display: flex;
+    flex-direction: column;
+    gap: var(--space-16);
+
+    @media (max-width: 30rem) {
+      gap: var(--space-8);
+    }
+
+    section {
+      display: flex;
+      flex-direction: column;
+      gap: var(--space-6);
+
+      /* Section titles */
+      [data-slot="section-title"] {
+        display: flex;
+        flex-direction: column;
+        gap: var(--space-1);
+
+        h2 {
+          font-size: var(--font-size-md);
+          font-weight: 600;
+          line-height: 1.2;
+          letter-spacing: -0.03125rem;
+          margin: 0;
+          color: var(--color-text-secondary);
+          text-transform: uppercase;
+
+          @media (max-width: 30rem) {
+            font-size: var(--font-size-md);
+          }
+        }
+      }
+    }
+    section:not(:last-child) {
+      border-bottom: 1px solid var(--color-border);
+      padding-bottom: var(--space-16);
+
+      @media (max-width: 30rem) {
+        padding-bottom: var(--space-8);
+      }
+    }
+  }
+
+  [data-component="empty-state"] {
+    padding: var(--space-20) var(--space-6);
+    text-align: center;
+    border: 1px dashed var(--color-border);
+    border-radius: var(--border-radius-sm);
+    display: flex;
+    flex-direction: column;
+    gap: var(--space-2);
+
+    p {
+      line-height: 1.5;
+      font-size: var(--font-size-sm);
+      color: var(--color-text-muted);
+    }
+  }
+
+  /* Title section */
+  [data-component="title-section"] {
+    display: flex;
+    flex-direction: column;
+    gap: var(--space-2);
+    padding-bottom: var(--space-8);
+    border-bottom: 1px solid var(--color-border);
+
+    @media (max-width: 30rem) {
+      padding-bottom: var(--space-6);
+    }
+
+    h1 {
+      font-size: var(--font-size-2xl);
+      font-weight: 500;
+      line-height: 1.2;
+      letter-spacing: -0.03125rem;
+      margin: 0;
+      text-transform: uppercase;
+
+      @media (max-width: 30rem) {
+        font-size: var(--font-size-xl);
+      }
+    }
+
+    p {
+      line-height: 1.5;
+      font-size: var(--font-size-md);
+      color: var(--color-text-muted);
+
+      a {
+        color: var(--color-text-muted);
+      }
+    }
+  }
+
+  /* API Keys Section */
+  [data-component="api-keys-section"] {
+    [data-slot="create-form"] {
+      display: flex;
+      flex-direction: column;
+      gap: var(--space-3);
+      padding: var(--space-4);
+      border: 1px solid var(--color-border);
+      border-radius: var(--border-radius-sm);
+
+      [data-slot="input-container"] {
+        display: flex;
+        flex-direction: column;
+        gap: var(--space-1);
+      }
+
+      @media (max-width: 30rem) {
+        gap: var(--space-2);
+      }
+
+      input {
+        flex: 1;
+        padding: var(--space-2) var(--space-3);
+        border: 1px solid var(--color-border);
+        border-radius: var(--border-radius-sm);
+        background-color: var(--color-bg);
+        color: var(--color-text);
+        font-size: var(--font-size-sm);
+        font-family: var(--font-mono);
+
+        &:focus {
+          outline: none;
+          border-color: var(--color-accent);
+        }
+
+        &::placeholder {
+          color: var(--color-text-disabled);
+        }
+      }
+
+      [data-slot="form-actions"] {
+        display: flex;
+        gap: var(--space-2);
+      }
+
+      [data-slot="form-error"] {
+        color: var(--color-danger);
+        font-size: var(--font-size-sm);
+        margin-top: var(--space-1);
+        line-height: 1.4;
+      }
+    }
+
+    [data-slot="api-keys-table"] {
+      overflow-x: auto;
+    }
+
+    [data-slot="api-keys-table-element"] {
+      width: 100%;
+      border-collapse: collapse;
+      font-size: var(--font-size-sm);
+
+      thead {
+        border-bottom: 1px solid var(--color-border);
+      }
+
+      th {
+        padding: var(--space-3) var(--space-4);
+        text-align: left;
+        font-weight: normal;
+        color: var(--color-text-muted);
+        text-transform: uppercase;
+      }
+
+      td {
+        padding: var(--space-3) var(--space-4);
+        border-bottom: 1px solid var(--color-border-muted);
+        color: var(--color-text-muted);
+        font-family: var(--font-mono);
+
+        &[data-slot="key-name"] {
+          color: var(--color-text);
+          font-family: var(--font-sans);
+          font-weight: 500;
+        }
+
+        &[data-slot="key-value"] {
+          font-family: var(--font-mono);
+
+          button {
+            display: flex;
+            align-items: center;
+            gap: var(--space-2);
+            padding: var(--space-2) var(--space-3);
+            font-size: var(--font-size-sm);
+            font-weight: 400;
+            border: none;
+            background-color: transparent;
+            color: var(--color-text-muted);
+            font-family: var(--font-mono);
+            border-radius: var(--border-radius-sm);
+            cursor: pointer;
+            transition: all 0.15s ease;
+            text-transform: none;
+
+            &:hover:not(:disabled) {
+              background-color: var(--color-bg-surface);
+              color: var(--color-text);
+            }
+
+            &:disabled {
+              cursor: default;
+              color: var(--color-text);
+            }
+
+            span {
+              font-family: inherit;
+            }
+          }
+        }
+
+        &[data-slot="key-date"] {
+          color: var(--color-text);
+        }
+
+        &[data-slot="key-actions"] {
+          font-family: var(--font-sans);
+        }
+      }
+
+      tbody tr {
+        &:last-child td {
+          border-bottom: none;
+        }
+      }
+
+      @media (max-width: 40rem) {
+        th,
+        td {
+          padding: var(--space-2) var(--space-3);
+          font-size: var(--font-size-xs);
+        }
+
+        th {
+          &:nth-child(3) /* Date */ {
+            display: none;
+          }
+        }
+
+        td {
+          &:nth-child(3) /* Date */ {
+            display: none;
+          }
+        }
+      }
+    }
+  }
+
+  /* Balance Section */
+  [data-component="balance-section"] {
+    [data-slot="balance"] {
+      display: flex;
+      flex-direction: column;
+      gap: var(--space-3);
+      padding: var(--space-4);
+      border: 1px solid var(--color-border);
+      border-radius: var(--border-radius-sm);
+      min-width: 14.5rem;
+      width: fit-content;
+
+      [data-slot="amount"] {
+        padding: var(--space-3-5) var(--space-4);
+        background-color: var(--color-bg-surface);
+        border-radius: var(--border-radius-sm);
+        display: flex;
+        align-items: baseline;
+        gap: var(--space-1);
+        justify-content: flex-end;
+
+        &[data-state="danger"] {
+          [data-slot="value"] {
+            color: var(--color-danger);
+          }
+          [data-slot="currency"] {
+            color: var(--color-danger);
+          }
+        }
+
+        [data-slot="currency"] {
+          position: relative;
+          bottom: 2px;
+          font-size: var(--font-size-lg);
+          color: var(--color-text-muted);
+          font-weight: 400;
+        }
+
+        [data-slot="value"] {
+          font-size: var(--font-size-3xl);
+          font-weight: 500;
+          color: var(--color-text);
+        }
+      }
+    }
+  }
+
+  /* Payments Section */
+  [data-component="payments-section"] {
+    [data-slot="payments-table"] {
+      overflow-x: auto;
+    }
+
+    [data-slot="payments-table-element"] {
+      width: 100%;
+      border-collapse: collapse;
+      font-size: var(--font-size-sm);
+
+      thead {
+        border-bottom: 1px solid var(--color-border);
+      }
+
+      th {
+        padding: var(--space-3) var(--space-4);
+        text-align: left;
+        font-weight: normal;
+        color: var(--color-text-muted);
+        text-transform: uppercase;
+      }
+
+      td {
+        padding: var(--space-3) var(--space-4);
+        border-bottom: 1px solid var(--color-border-muted);
+        color: var(--color-text-muted);
+        font-family: var(--font-mono);
+
+        &[data-slot="payment-date"] {
+          color: var(--color-text);
+        }
+
+        &[data-slot="payment-id"] {
+          font-family: var(--font-mono);
+          font-weight: 400;
+          color: var(--color-text-muted);
+          max-width: 200px;
+          word-break: break-word;
+        }
+
+        &[data-slot="payment-amount"] {
+          color: var(--color-text);
+        }
+      }
+
+      tbody tr {
+        &:last-child td {
+          border-bottom: none;
+        }
+      }
+
+      @media (max-width: 40rem) {
+        th,
+        td {
+          padding: var(--space-2) var(--space-3);
+          font-size: var(--font-size-xs);
+        }
+
+        th {
+          &:nth-child(2) /* Payment ID */ {
+            display: none;
+          }
+        }
+
+        td {
+          &:nth-child(2) /* Payment ID */ {
+            display: none;
+          }
+        }
+      }
+    }
+  }
+
+  /* Usage Section */
+  [data-component="usage-section"] {
+    [data-slot="usage-table"] {
+      overflow-x: auto;
+    }
+
+    [data-slot="usage-table-element"] {
+      width: 100%;
+      border-collapse: collapse;
+      font-size: var(--font-size-sm);
+
+      thead {
+        border-bottom: 1px solid var(--color-border);
+      }
+
+      th {
+        padding: var(--space-3) var(--space-4);
+        text-align: left;
+        font-weight: normal;
+        color: var(--color-text-muted);
+        text-transform: uppercase;
+      }
+
+      td {
+        padding: var(--space-3) var(--space-4);
+        border-bottom: 1px solid var(--color-border-muted);
+        color: var(--color-text-muted);
+        font-family: var(--font-mono);
+
+        &[data-slot="usage-date"] {
+          color: var(--color-text);
+        }
+
+        &[data-slot="usage-model"] {
+          font-family: var(--font-sans);
+          font-weight: 400;
+          color: var(--color-text-secondary);
+          max-width: 200px;
+          word-break: break-word;
+        }
+
+        &[data-slot="usage-cost"] {
+          color: var(--color-text);
+        }
+      }
+
+      tbody tr {
+        &:last-child td {
+          border-bottom: none;
+        }
+      }
+
+      @media (max-width: 40rem) {
+        th,
+        td {
+          padding: var(--space-2) var(--space-3);
+          font-size: var(--font-size-xs);
+        }
+
+        th {
+          &:nth-child(2) /* Model */ {
+            display: none;
+          }
+        }
+
+        td {
+          &:nth-child(2) /* Model */ {
+            display: none;
+          }
+        }
+      }
+    }
+  }
+
+  [data-slot="new-user-sections"] {
+    display: flex;
+    flex-direction: column;
+    gap: var(--space-8);
+    padding: var(--space-6);
+    background-color: var(--color-bg-surface);
+    border: 1px dashed var(--color-border);
+    border-radius: var(--border-radius-sm);
+
+    @media (max-width: 30rem) {
+      gap: var(--space-8);
+      padding: var(--space-4);
+    }
+
+    [data-component="feature-grid"] {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+      gap: var(--space-6);
+
+      @media (max-width: 30rem) {
+        grid-template-columns: 1fr;
+        gap: var(--space-4);
+      }
+
+      [data-slot="feature"] {
+        display: flex;
+        flex-direction: column;
+        gap: var(--space-2);
+        padding: var(--space-4);
+        border: 1px solid var(--color-border);
+        border-radius: var(--border-radius-sm);
+
+        h3 {
+          font-size: var(--font-size-sm);
+          font-weight: 600;
+          margin: 0;
+          color: var(--color-text);
+          text-transform: uppercase;
+          letter-spacing: -0.025rem;
+        }
+
+        p {
+          font-size: var(--font-size-sm);
+          line-height: 1.5;
+          margin: 0;
+          color: var(--color-text-muted);
+        }
+      }
+    }
+
+    [data-component="api-key-highlight"] {
+      display: flex;
+      flex-direction: column;
+      gap: var(--space-6);
+
+      [data-slot="section-title"] {
+        display: flex;
+        flex-direction: column;
+        gap: var(--space-1);
+
+        h2 {
+          font-size: var(--font-size-md);
+          font-weight: 600;
+          line-height: 1.2;
+          letter-spacing: -0.03125rem;
+          margin: 0;
+          color: var(--color-text-secondary);
+          text-transform: uppercase;
+
+          @media (max-width: 30rem) {
+            font-size: var(--font-size-md);
+          }
+        }
+      }
+
+      [data-slot="key-display"] {
+        display: flex;
+        flex-direction: column;
+        gap: var(--space-3);
+
+        [data-slot="key-container"] {
+          display: flex;
+          gap: var(--space-3);
+          padding: var(--space-4);
+          border: 2px solid var(--color-accent);
+          border-radius: var(--border-radius-sm);
+          align-items: center;
+
+          @media (max-width: 40rem) {
+            flex-direction: column;
+            gap: var(--space-3);
+            align-items: stretch;
+          }
+
+          [data-slot="key-value"] {
+            flex: 1;
+            font-family: var(--font-mono);
+            font-size: var(--font-size-sm);
+            color: var(--color-text);
+            background-color: var(--color-bg);
+            padding: var(--space-3);
+            border-radius: var(--border-radius-sm);
+            border: 1px solid var(--color-border);
+            word-break: break-all;
+            line-height: 1.4;
+
+            @media (max-width: 40rem) {
+              font-size: var(--font-size-xs);
+              padding: var(--space-2-5);
+            }
+          }
+
+          button {
+            display: flex;
+            align-items: center;
+            gap: var(--space-2);
+            padding: var(--space-3) var(--space-4);
+            font-size: var(--font-size-sm);
+            font-weight: 500;
+            white-space: nowrap;
+            min-width: 130px;
+
+            @media (max-width: 40rem) {
+              justify-content: center;
+              padding: var(--space-2-5) var(--space-3);
+              font-size: var(--font-size-xs);
+              min-width: 96px;
+            }
+          }
+        }
+      }
+    }
+
+    [data-component="next-steps"] {
+      display: flex;
+      flex-direction: column;
+      gap: var(--space-6);
+
+      ol {
+        margin: 0;
+        padding-left: 0;
+        display: flex;
+        flex-direction: column;
+        gap: var(--space-2);
+        list-style-position: inside;
+
+        li {
+          font-size: var(--font-size-md);
+          line-height: 1.5;
+          color: var(--color-text-secondary);
+
+          code {
+            font-family: var(--font-mono);
+            font-size: var(--font-size-sm);
+            padding: var(--space-1) var(--space-2);
+            border: 1px solid var(--color-border);
+            border-radius: var(--border-radius-sm);
+            color: var(--color-text);
+          }
+        }
+      }
+    }
+  }
+}

cloud/app/src/routes/workspace/[id].tsx

@@ -0,0 +1,494 @@
+import "./[id].css"
+import { Billing } from "@opencode/cloud-core/billing.js"
+import { Key } from "@opencode/cloud-core/key.js"
+import { json, query, action, useParams, useAction, createAsync, useSubmission } from "@solidjs/router"
+import { createEffect, createMemo, createSignal, For, Show } from "solid-js"
+import { withActor } from "~/context/auth.withActor"
+import { IconCopy, IconCheck } from "~/component/icon"
+import { createStore } from "solid-js/store"
+
+function formatDateForTable(date: Date) {
+  const options: Intl.DateTimeFormatOptions = {
+    day: "numeric",
+    month: "short",
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true,
+  }
+  return date.toLocaleDateString("en-GB", options).replace(",", ",")
+}
+
+function formatDateUTC(date: Date) {
+  const options: Intl.DateTimeFormatOptions = {
+    weekday: "short",
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    second: "2-digit",
+    timeZoneName: "short",
+    timeZone: "UTC",
+  }
+  return date.toLocaleDateString("en-US", options)
+}
+
+/////////////////////////////////////
+// Keys related queries and actions
+/////////////////////////////////////
+
+const listKeys = query(async (workspaceID: string) => {
+  "use server"
+  return withActor(() => Key.list(), workspaceID)
+}, "key.list")
+
+const createKey = action(async (form: FormData) => {
+  "use server"
+  const name = form.get("name")?.toString().trim()
+  if (!name) return { error: "Name is required" }
+  const workspaceID = form.get("workspaceID")?.toString()
+  if (!workspaceID) return { error: "Workspace ID is required" }
+  return json(
+    await withActor(
+      () =>
+        Key.create({ name })
+          .then((data) => ({ error: undefined, data }))
+          .catch((e) => ({ error: e.message as string })),
+      workspaceID,
+    ),
+    { revalidate: listKeys.key },
+  )
+}, "key.create")
+
+const removeKey = action(async (form: FormData) => {
+  "use server"
+  const id = form.get("id")?.toString()
+  if (!id) return { error: "ID is required" }
+  const workspaceID = form.get("workspaceID")?.toString()
+  if (!workspaceID) return { error: "Workspace ID is required" }
+  return json(await withActor(() => Key.remove({ id }), workspaceID), { revalidate: listKeys.key })
+}, "key.remove")
+
+/////////////////////////////////////
+// Billing related queries and actions
+/////////////////////////////////////
+
+const getBalanceInfo = query(async (workspaceID: string) => {
+  "use server"
+  return withActor(async () => {
+    return await Billing.get()
+  }, workspaceID)
+}, "balanceInfo")
+
+const getUsageInfo = query(async (workspaceID: string) => {
+  "use server"
+  return withActor(async () => {
+    return await Billing.usages()
+  }, workspaceID)
+}, "usageInfo")
+
+const getPaymentsInfo = query(async (workspaceID: string) => {
+  "use server"
+  return withActor(async () => {
+    return await Billing.payments()
+  }, workspaceID)
+}, "paymentsInfo")
+
+const createCheckoutUrl = action(async (workspaceID: string, successUrl: string, cancelUrl: string) => {
+  "use server"
+  return withActor(() => Billing.generateCheckoutUrl({ successUrl, cancelUrl }), workspaceID)
+}, "checkoutUrl")
+
+// const createPortalUrl = action(async (workspaceID: string, returnUrl: string) => {
+//   "use server"
+//   return withActor(() => Billing.generatePortalUrl({ returnUrl }), workspaceID)
+// }, "portalUrl")
+
+function KeySection() {
+  const params = useParams()
+  const keys = createAsync(() => listKeys(params.id))
+
+  function formatKey(key: string) {
+    if (key.length <= 11) return key
+    return `${key.slice(0, 7)}...${key.slice(-4)}`
+  }
+
+  return (
+    <section data-component="api-keys-section">
+      <div data-slot="section-title">
+        <h2>API Keys</h2>
+        <p>Manage your API keys for accessing opencode services.</p>
+      </div>
+      <KeyCreateForm />
+      <div data-slot="api-keys-table">
+        <Show
+          when={keys()?.length}
+          fallback={
+            <div data-component="empty-state">
+              <p>Create an opencode Gateway API key</p>
+            </div>
+          }
+        >
+          <table data-slot="api-keys-table-element">
+            <thead>
+              <tr>
+                <th>Name</th>
+                <th>Key</th>
+                <th>Created</th>
+                <th></th>
+              </tr>
+            </thead>
+            <tbody>
+              <For each={keys()!}>
+                {(key) => {
+                  const [copied, setCopied] = createSignal(false)
+                  // const submission = useSubmission(removeKey, ([fd]) => fd.get("id")?.toString() === key.id)
+                  return (
+                    <tr>
+                      <td data-slot="key-name">{key.name}</td>
+                      <td data-slot="key-value">
+                        <button
+                          data-color="ghost"
+                          disabled={copied()}
+                          onClick={async () => {
+                            await navigator.clipboard.writeText(key.key)
+                            setCopied(true)
+                            setTimeout(() => setCopied(false), 1000)
+                          }}
+                          title="Copy API key"
+                        >
+                          <span>{formatKey(key.key)}</span>
+                          <Show when={copied()} fallback={<IconCopy style={{ width: "14px", height: "14px" }} />}>
+                            <IconCheck style={{ width: "14px", height: "14px" }} />
+                          </Show>
+                        </button>
+                      </td>
+                      <td data-slot="key-date" title={formatDateUTC(key.timeCreated)}>
+                        {formatDateForTable(key.timeCreated)}
+                      </td>
+                      <td data-slot="key-actions">
+                        <form action={removeKey} method="post">
+                          <input type="hidden" name="id" value={key.id} />
+                          <input type="hidden" name="workspaceID" value={params.id} />
+                          <button data-color="ghost">Delete</button>
+                        </form>
+                      </td>
+                    </tr>
+                  )
+                }}
+              </For>
+            </tbody>
+          </table>
+        </Show>
+      </div>
+    </section>
+  )
+}
+
+function KeyCreateForm() {
+  const params = useParams()
+  const submission = useSubmission(createKey)
+  const [store, setStore] = createStore({ show: false })
+
+  let input: HTMLInputElement
+
+  createEffect(() => {
+    if (!submission.pending && submission.result && !submission.result.error) {
+      hide()
+    }
+  })
+
+  function show() {
+    // submission.clear() does not clear the result in some cases, ie.
+    //  1. Create key with empty name => error shows
+    //  2. Put in a key name and creates the key => form hides
+    //  3. Click add key button again => form shows with the same error if
+    //     submission.clear() is called only once
+    while (true) {
+      submission.clear()
+      if (!submission.result) break
+    }
+    setStore("show", true)
+    input.focus()
+  }
+
+  function hide() {
+    setStore("show", false)
+  }
+
+  return (
+    <Show
+      when={store.show}
+      fallback={
+        <button data-color="primary" onClick={() => show()}>
+          Create API Key
+        </button>
+      }
+    >
+      <form action={createKey} method="post" data-slot="create-form">
+        <div data-slot="input-container">
+          <input ref={(r) => (input = r)} data-component="input" name="name" type="text" placeholder="Enter key name" />
+          <Show when={submission.result && submission.result.error}>
+            {(err) => <div data-slot="form-error">{err()}</div>}
+          </Show>
+        </div>
+        <input type="hidden" name="workspaceID" value={params.id} />
+        <div data-slot="form-actions">
+          <button type="reset" data-color="ghost" onClick={() => hide()}>
+            Cancel
+          </button>
+          <button type="submit" data-color="primary" disabled={submission.pending}>
+            {submission.pending ? "Creating..." : "Create"}
+          </button>
+        </div>
+      </form>
+    </Show>
+  )
+}
+
+function BalanceSection() {
+  const params = useParams()
+  const balanceInfo = createAsync(() => getBalanceInfo(params.id))
+  const createCheckoutUrlAction = useAction(createCheckoutUrl)
+  const createCheckoutUrlSubmission = useSubmission(createCheckoutUrl)
+
+  return (
+    <section data-component="balance-section">
+      <div data-slot="section-title">
+        <h2>Balance</h2>
+        <p>Add credits to your account.</p>
+      </div>
+      <div data-slot="balance">
+        <div
+          data-slot="amount"
+          data-state={(() => {
+            const balanceStr = ((balanceInfo()?.balance ?? 0) / 100000000).toFixed(2)
+            return balanceStr === "0.00" || balanceStr === "-0.00" ? "danger" : undefined
+          })()}
+        >
+          <span data-slot="currency">$</span>
+          <span data-slot="value">
+            {(() => {
+              const balanceStr = ((balanceInfo()?.balance ?? 0) / 100000000).toFixed(2)
+              return balanceStr === "-0.00" ? "0.00" : balanceStr
+            })()}
+          </span>
+        </div>
+        <button
+          data-color="primary"
+          disabled={createCheckoutUrlSubmission.pending}
+          onClick={async () => {
+            const baseUrl = window.location.href
+            const checkoutUrl = await createCheckoutUrlAction(params.id, baseUrl, baseUrl)
+            if (checkoutUrl) {
+              window.location.href = checkoutUrl
+            }
+          }}
+        >
+          {createCheckoutUrlSubmission.pending ? "Loading..." : "Buy Credits"}
+        </button>
+      </div>
+    </section>
+  )
+}
+
+function UsageSection() {
+  const params = useParams()
+  const usage = createAsync(() => getUsageInfo(params.id))
+
+  return (
+    <section data-component="usage-section">
+      <div data-slot="section-title">
+        <h2>Usage History</h2>
+        <p>Recent API usage and costs.</p>
+      </div>
+      <div data-slot="usage-table">
+        <Show
+          when={usage() && usage()!.length > 0}
+          fallback={
+            <div data-component="empty-state">
+              <p>Make your first API call to get started.</p>
+            </div>
+          }
+        >
+          <table data-slot="usage-table-element">
+            <thead>
+              <tr>
+                <th>Date</th>
+                <th>Model</th>
+                <th>Input</th>
+                <th>Output</th>
+                <th>Cost</th>
+              </tr>
+            </thead>
+            <tbody>
+              <For each={usage()!}>
+                {(usage) => {
+                  const date = createMemo(() => new Date(usage.timeCreated))
+                  return (
+                    <tr>
+                      <td data-slot="usage-date" title={formatDateUTC(date())}>
+                        {formatDateForTable(date())}
+                      </td>
+                      <td data-slot="usage-model">{usage.model}</td>
+                      <td data-slot="usage-tokens">{usage.inputTokens}</td>
+                      <td data-slot="usage-tokens">{usage.outputTokens}</td>
+                      <td data-slot="usage-cost">${((usage.cost ?? 0) / 100000000).toFixed(4)}</td>
+                    </tr>
+                  )
+                }}
+              </For>
+            </tbody>
+          </table>
+        </Show>
+      </div>
+    </section>
+  )
+}
+
+function PaymentSection() {
+  const params = useParams()
+  const payments = createAsync(() => getPaymentsInfo(params.id))
+
+  return (
+    payments() &&
+    payments()!.length > 0 && (
+      <section data-component="payments-section">
+        <div data-slot="section-title">
+          <h2>Payments History</h2>
+          <p>Recent payment transactions.</p>
+        </div>
+        <div data-slot="payments-table">
+          <table data-slot="payments-table-element">
+            <thead>
+              <tr>
+                <th>Date</th>
+                <th>Payment ID</th>
+                <th>Amount</th>
+              </tr>
+            </thead>
+            <tbody>
+              <For each={payments()!}>
+                {(payment) => {
+                  const date = new Date(payment.timeCreated)
+                  return (
+                    <tr>
+                      <td data-slot="payment-date" title={formatDateUTC(date)}>
+                        {formatDateForTable(date)}
+                      </td>
+                      <td data-slot="payment-id">{payment.id}</td>
+                      <td data-slot="payment-amount">${((payment.amount ?? 0) / 100000000).toFixed(2)}</td>
+                    </tr>
+                  )
+                }}
+              </For>
+            </tbody>
+          </table>
+        </div>
+      </section>
+    )
+  )
+}
+
+function NewUserSection() {
+  const params = useParams()
+  const [copiedKey, setCopiedKey] = createSignal(false)
+  const keys = createAsync(() => listKeys(params.id))
+  const usage = createAsync(() => getUsageInfo(params.id))
+  const isNew = createMemo(() => {
+    const keysList = keys()
+    const usageList = usage()
+    return keysList?.length === 1 && (!usageList || usageList.length === 0)
+  })
+  const defaultKey = createMemo(() => keys()?.at(-1)?.key)
+
+  return (
+    <Show when={isNew()}>
+      <div data-slot="new-user-sections">
+        <div data-component="feature-grid">
+          <div data-slot="feature">
+            <h3>Tested & Verified Models</h3>
+            <p>We've benchmarked and tested models specifically for coding agents to ensure the best performance.</p>
+          </div>
+          <div data-slot="feature">
+            <h3>Highest Quality</h3>
+            <p>Access models configured for optimal performance - no downgrades or routing to cheaper providers.</p>
+          </div>
+          <div data-slot="feature">
+            <h3>No Lock-in</h3>
+            <p>Use Zen with any coding agent, and continue using other providers with opencode whenever you want.</p>
+          </div>
+        </div>
+
+        <div data-component="api-key-highlight">
+          <Show when={defaultKey()}>
+            <div data-slot="key-display">
+              <div data-slot="key-container">
+                <code data-slot="key-value">{defaultKey()}</code>
+                <button
+                  data-color="primary"
+                  disabled={copiedKey()}
+                  onClick={async () => {
+                    await navigator.clipboard.writeText(defaultKey() ?? "")
+                    setCopiedKey(true)
+                    setTimeout(() => setCopiedKey(false), 2000)
+                  }}
+                  title="Copy API key"
+                >
+                  <Show
+                    when={copiedKey()}
+                    fallback={
+                      <>
+                        <IconCopy style={{ width: "16px", height: "16px" }} /> Copy Key
+                      </>
+                    }
+                  >
+                    <IconCheck style={{ width: "16px", height: "16px" }} /> Copied!
+                  </Show>
+                </button>
+              </div>
+            </div>
+          </Show>
+        </div>
+
+        <div data-component="next-steps">
+          <ol>
+            <li>
+              Run <code>opencode auth login</code> and select opencode
+            </li>
+            <li>Paste your API key</li>
+            <li>Start opencode</li>
+            <li>
+              Run <code>/models</code> to see available models
+            </li>
+          </ol>
+        </div>
+      </div>
+    </Show>
+  )
+}
+
+export default function () {
+  return (
+    <div data-page="workspace-[id]">
+      <section data-component="title-section">
+        <h1>Zen</h1>
+        <p>
+          Curated list of models provided by opencode.{" "}
+          <a target="_blank" href="/docs/zen">
+            Learn more
+          </a>
+          .
+        </p>
+      </section>
+
+      <div data-slot="sections">
+        <NewUserSection />
+        <KeySection />
+        <BalanceSection />
+        <UsageSection />
+        <PaymentSection />
+      </div>
+    </div>
+  )
+}

cloud/app/src/routes/zen/v1/chat/completions.ts

@@ -1,13 +1,10 @@
 import type { APIEvent } from "@solidjs/start/server"
-import { handler } from "~/routes/zen/handler"
+import { handler } from "~/util/zen"
 
 type Usage = {
   prompt_tokens?: number
   completion_tokens?: number
   total_tokens?: number
-  // used by moonshot
-  cached_tokens?: number
-  // used by xai
   prompt_tokens_details?: {
     text_tokens?: number
     audio_tokens?: number
@@ -51,7 +48,7 @@ export function POST(input: APIEvent) {
       inputTokens: usage.prompt_tokens ?? 0,
       outputTokens: usage.completion_tokens ?? 0,
       reasoningTokens: usage.completion_tokens_details?.reasoning_tokens ?? undefined,
-      cacheReadTokens: usage.cached_tokens ?? usage.prompt_tokens_details?.cached_tokens ?? undefined,
+      cacheReadTokens: usage.prompt_tokens_details?.cached_tokens ?? undefined,
     }),
   })
 }

cloud/app/src/routes/zen/v1/messages.ts

@@ -1,5 +1,5 @@
 import type { APIEvent } from "@solidjs/start/server"
-import { handler } from "~/routes/zen/handler"
+import { handler } from "~/util/zen"
 
 type Usage = {
   cache_creation?: {

cloud/app/src/routes/zen/v1/responses.ts

@@ -1,5 +1,5 @@
 import type { APIEvent } from "@solidjs/start/server"
-import { handler } from "~/routes/zen/handler"
+import { handler } from "~/util/zen"
 
 type Usage = {
   input_tokens?: number

cloud/app/src/util/zen.ts

@@ -0,0 +1,531 @@
+import type { APIEvent } from "@solidjs/start/server"
+import path from "node:path"
+import { and, Database, eq, isNull, sql } from "@opencode/cloud-core/drizzle/index.js"
+import { KeyTable } from "@opencode/cloud-core/schema/key.sql.js"
+import { BillingTable, UsageTable } from "@opencode/cloud-core/schema/billing.sql.js"
+import { centsToMicroCents } from "@opencode/cloud-core/util/price.js"
+import { Identifier } from "@opencode/cloud-core/identifier.js"
+import { Resource } from "@opencode/cloud-resource"
+
+type ModelCost = {
+  input: number
+  output: number
+  cacheRead?: number
+  cacheWrite5m?: number
+  cacheWrite1h?: number
+}
+
+type Model = {
+  id: string
+  auth: boolean
+  cost: ModelCost | ((usage: any) => ModelCost)
+  headerMappings: Record<string, string>
+  providers: Record<
+    string,
+    {
+      api: string
+      apiKey: string
+      model: string
+      weight?: number
+    }
+  >
+}
+
+export async function handler(
+  input: APIEvent,
+  opts: {
+    modifyBody?: (body: any) => any
+    setAuthHeader: (headers: Headers, apiKey: string) => void
+    parseApiKey: (headers: Headers) => string | undefined
+    onStreamPart: (chunk: string) => void
+    getStreamUsage: () => any
+    normalizeUsage: (body: any) => {
+      inputTokens: number
+      outputTokens: number
+      reasoningTokens?: number
+      cacheReadTokens?: number
+      cacheWrite5mTokens?: number
+      cacheWrite1hTokens?: number
+    }
+  },
+) {
+  class AuthError extends Error {}
+  class CreditsError extends Error {}
+  class ModelError extends Error {}
+
+  const MODELS: Record<string, Model> = {
+    "claude-opus-4-1": {
+      id: "claude-opus-4-1" as const,
+      auth: true,
+      cost: {
+        input: 0.000015,
+        output: 0.000075,
+        cacheRead: 0.0000015,
+        cacheWrite5m: 0.00001875,
+        cacheWrite1h: 0.00003,
+      },
+      headerMappings: {},
+      providers: {
+        anthropic: {
+          api: "https://api.anthropic.com",
+          apiKey: Resource.ANTHROPIC_API_KEY.value,
+          model: "claude-opus-4-1-20250805",
+        },
+      },
+    },
+    "claude-sonnet-4": {
+      id: "claude-sonnet-4" as const,
+      auth: true,
+      cost: (usage: any) => {
+        const totalInputTokens =
+          usage.inputTokens + usage.cacheReadTokens + usage.cacheWrite5mTokens + usage.cacheWrite1hTokens
+        return totalInputTokens <= 200_000
+          ? {
+              input: 0.000003,
+              output: 0.000015,
+              cacheRead: 0.0000003,
+              cacheWrite5m: 0.00000375,
+              cacheWrite1h: 0.000006,
+            }
+          : {
+              input: 0.000006,
+              output: 0.0000225,
+              cacheRead: 0.0000006,
+              cacheWrite5m: 0.0000075,
+              cacheWrite1h: 0.000012,
+            }
+      },
+      headerMappings: {},
+      providers: {
+        anthropic: {
+          api: "https://api.anthropic.com",
+          apiKey: Resource.ANTHROPIC_API_KEY.value,
+          model: "claude-sonnet-4-20250514",
+        },
+      },
+    },
+    "claude-3-5-haiku": {
+      id: "claude-3-5-haiku" as const,
+      auth: true,
+      cost: {
+        input: 0.0000008,
+        output: 0.000004,
+        cacheRead: 0.00000008,
+        cacheWrite5m: 0.000001,
+        cacheWrite1h: 0.0000016,
+      },
+      headerMappings: {},
+      providers: {
+        anthropic: {
+          api: "https://api.anthropic.com",
+          apiKey: Resource.ANTHROPIC_API_KEY.value,
+          model: "claude-3-5-haiku-20241022",
+        },
+      },
+    },
+    "gpt-5": {
+      id: "gpt-5" as const,
+      auth: true,
+      cost: {
+        input: 0.00000125,
+        output: 0.00001,
+        cacheRead: 0.000000125,
+      },
+      headerMappings: {},
+      providers: {
+        openai: {
+          api: "https://api.openai.com",
+          apiKey: Resource.OPENAI_API_KEY.value,
+          model: "gpt-5",
+        },
+      },
+    },
+    "qwen3-coder": {
+      id: "qwen3-coder" as const,
+      auth: true,
+      cost: {
+        input: 0.00000045,
+        output: 0.0000018,
+      },
+      headerMappings: {},
+      providers: {
+        baseten: {
+          api: "https://inference.baseten.co",
+          apiKey: Resource.BASETEN_API_KEY.value,
+          model: "Qwen/Qwen3-Coder-480B-A35B-Instruct",
+          weight: 4,
+        },
+        fireworks: {
+          api: "https://api.fireworks.ai/inference",
+          apiKey: Resource.FIREWORKS_API_KEY.value,
+          model: "accounts/fireworks/models/qwen3-coder-480b-a35b-instruct",
+          weight: 1,
+        },
+      },
+    },
+    "kimi-k2": {
+      id: "kimi-k2" as const,
+      auth: true,
+      cost: {
+        input: 0.0000006,
+        output: 0.0000025,
+      },
+      headerMappings: {},
+      providers: {
+        baseten: {
+          api: "https://inference.baseten.co",
+          apiKey: Resource.BASETEN_API_KEY.value,
+          model: "moonshotai/Kimi-K2-Instruct-0905",
+          weight: 4,
+        },
+        fireworks: {
+          api: "https://api.fireworks.ai/inference",
+          apiKey: Resource.FIREWORKS_API_KEY.value,
+          model: "accounts/fireworks/models/kimi-k2-instruct-0905",
+          weight: 1,
+        },
+      },
+    },
+    "grok-code": {
+      id: "grok-code" as const,
+      auth: false,
+      cost: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+      },
+      headerMappings: {
+        "x-grok-conv-id": "x-opencode-session",
+        "x-grok-req-id": "x-opencode-request",
+      },
+      providers: {
+        xai: {
+          api: "https://api.x.ai",
+          apiKey: Resource.XAI_API_KEY.value,
+          model: "grok-code",
+        },
+      },
+    },
+    // deprecated
+    "qwen/qwen3-coder": {
+      id: "qwen/qwen3-coder" as const,
+      auth: true,
+      cost: {
+        input: 0.00000038,
+        output: 0.00000153,
+      },
+      headerMappings: {},
+      providers: {
+        baseten: {
+          api: "https://inference.baseten.co",
+          apiKey: Resource.BASETEN_API_KEY.value,
+          model: "Qwen/Qwen3-Coder-480B-A35B-Instruct",
+          weight: 5,
+        },
+        fireworks: {
+          api: "https://api.fireworks.ai/inference",
+          apiKey: Resource.FIREWORKS_API_KEY.value,
+          model: "accounts/fireworks/models/qwen3-coder-480b-a35b-instruct",
+          weight: 1,
+        },
+      },
+    },
+  }
+
+  const FREE_WORKSPACES = [
+    "wrk_01K46JDFR0E75SG2Q8K172KF3Y", // frank
+  ]
+
+  const logger = {
+    metric: (values: Record<string, any>) => {
+      console.log(`_metric:${JSON.stringify(values)}`)
+    },
+    log: console.log,
+    debug: (message: string) => {
+      if (Resource.App.stage === "production") return
+      console.debug(message)
+    },
+  }
+
+  try {
+    const url = new URL(input.request.url)
+    const body = await input.request.json()
+    logger.debug(JSON.stringify(body))
+    logger.metric({
+      is_tream: !!body.stream,
+      session: input.request.headers.get("x-opencode-session"),
+      request: input.request.headers.get("x-opencode-request"),
+    })
+    const MODEL = validateModel()
+    const apiKey = await authenticate()
+    const isFree = FREE_WORKSPACES.includes(apiKey?.workspaceID ?? "")
+    await checkCredits()
+    const providerName = selectProvider()
+    const providerData = MODEL.providers[providerName]
+    logger.metric({ provider: providerName })
+
+    // Request to model provider
+    const startTimestamp = Date.now()
+    const res = await fetch(path.posix.join(providerData.api, url.pathname.replace(/^\/zen/, "") + url.search), {
+      method: "POST",
+      headers: (() => {
+        const headers = input.request.headers
+        headers.delete("host")
+        headers.delete("content-length")
+        opts.setAuthHeader(headers, providerData.apiKey)
+        Object.entries(MODEL.headerMappings ?? {}).forEach(([k, v]) => {
+          headers.set(k, headers.get(v)!)
+        })
+        return headers
+      })(),
+      body: JSON.stringify({
+        ...(opts.modifyBody?.(body) ?? body),
+        model: providerData.model,
+      }),
+    })
+
+    // Scrub response headers
+    const resHeaders = new Headers()
+    const keepHeaders = ["content-type", "cache-control"]
+    for (const [k, v] of res.headers.entries()) {
+      if (keepHeaders.includes(k.toLowerCase())) {
+        resHeaders.set(k, v)
+      }
+    }
+
+    // Handle non-streaming response
+    if (!body.stream) {
+      const json = await res.json()
+      const body = JSON.stringify(json)
+      logger.metric({ response_length: body.length })
+      logger.debug(body)
+      await trackUsage(json.usage)
+      return new Response(body, {
+        status: res.status,
+        statusText: res.statusText,
+        headers: resHeaders,
+      })
+    }
+
+    // Handle streaming response
+    const stream = new ReadableStream({
+      start(c) {
+        const reader = res.body?.getReader()
+        const decoder = new TextDecoder()
+        let buffer = ""
+        let responseLength = 0
+
+        function pump(): Promise<void> {
+          return (
+            reader?.read().then(async ({ done, value }) => {
+              if (done) {
+                logger.metric({ response_length: responseLength })
+                const usage = opts.getStreamUsage()
+                if (usage) await trackUsage(usage)
+                c.close()
+                return
+              }
+
+              if (responseLength === 0) {
+                logger.metric({ time_to_first_byte: Date.now() - startTimestamp })
+              }
+              responseLength += value.length
+              buffer += decoder.decode(value, { stream: true })
+
+              const parts = buffer.split("\n\n")
+              buffer = parts.pop() ?? ""
+
+              for (const part of parts) {
+                logger.debug(part)
+                opts.onStreamPart(part.trim())
+              }
+
+              c.enqueue(value)
+
+              return pump()
+            }) || Promise.resolve()
+          )
+        }
+
+        return pump()
+      },
+    })
+
+    return new Response(stream, {
+      status: res.status,
+      statusText: res.statusText,
+      headers: resHeaders,
+    })
+
+    function validateModel() {
+      if (!(body.model in MODELS)) {
+        throw new ModelError(`Model ${body.model} not supported`)
+      }
+      const model = MODELS[body.model as keyof typeof MODELS]
+      logger.metric({ model: model.id })
+      return model
+    }
+
+    async function authenticate() {
+      try {
+        const apiKey = opts.parseApiKey(input.request.headers)
+        if (!apiKey) throw new AuthError("Missing API key.")
+
+        const key = await Database.use((tx) =>
+          tx
+            .select({
+              id: KeyTable.id,
+              workspaceID: KeyTable.workspaceID,
+            })
+            .from(KeyTable)
+            .where(and(eq(KeyTable.key, apiKey), isNull(KeyTable.timeDeleted)))
+            .then((rows) => rows[0]),
+        )
+
+        if (!key) throw new AuthError("Invalid API key.")
+        logger.metric({
+          api_key: key.id,
+          workspace: key.workspaceID,
+        })
+        return key
+      } catch (e) {
+        // ignore error if model does not require authentication
+        if (!MODEL.auth) return
+        throw e
+      }
+    }
+
+    async function checkCredits() {
+      if (!apiKey || !MODEL.auth || isFree) return
+
+      const billing = await Database.use((tx) =>
+        tx
+          .select({
+            balance: BillingTable.balance,
+          })
+          .from(BillingTable)
+          .where(eq(BillingTable.workspaceID, apiKey.workspaceID))
+          .then((rows) => rows[0]),
+      )
+
+      if (billing.balance <= 0) throw new CreditsError("Insufficient balance")
+    }
+
+    function selectProvider() {
+      const picks = Object.entries(MODEL.providers).flatMap(([name, provider]) =>
+        Array<string>(provider.weight ?? 1).fill(name),
+      )
+      return picks[Math.floor(Math.random() * picks.length)]
+    }
+
+    async function trackUsage(usage: any) {
+      const { inputTokens, outputTokens, reasoningTokens, cacheReadTokens, cacheWrite5mTokens, cacheWrite1hTokens } =
+        opts.normalizeUsage(usage)
+
+      const modelCost = typeof MODEL.cost === "function" ? MODEL.cost(usage) : MODEL.cost
+
+      const inputCost = modelCost.input * inputTokens * 100
+      const outputCost = modelCost.output * outputTokens * 100
+      const reasoningCost = (() => {
+        if (!reasoningTokens) return undefined
+        return modelCost.output * reasoningTokens * 100
+      })()
+      const cacheReadCost = (() => {
+        if (!cacheReadTokens) return undefined
+        if (!modelCost.cacheRead) return undefined
+        return modelCost.cacheRead * cacheReadTokens * 100
+      })()
+      const cacheWrite5mCost = (() => {
+        if (!cacheWrite5mTokens) return undefined
+        if (!modelCost.cacheWrite5m) return undefined
+        return modelCost.cacheWrite5m * cacheWrite5mTokens * 100
+      })()
+      const cacheWrite1hCost = (() => {
+        if (!cacheWrite1hTokens) return undefined
+        if (!modelCost.cacheWrite1h) return undefined
+        return modelCost.cacheWrite1h * cacheWrite1hTokens * 100
+      })()
+      const totalCostInCent =
+        inputCost +
+        outputCost +
+        (reasoningCost ?? 0) +
+        (cacheReadCost ?? 0) +
+        (cacheWrite5mCost ?? 0) +
+        (cacheWrite1hCost ?? 0)
+
+      logger.metric({
+        "tokens.input": inputTokens,
+        "tokens.output": outputTokens,
+        "tokens.reasoning": reasoningTokens,
+        "tokens.cache_read": cacheReadTokens,
+        "tokens.cache_write_5m": cacheWrite5mTokens,
+        "tokens.cache_write_1h": cacheWrite1hTokens,
+        "cost.input": Math.round(inputCost),
+        "cost.output": Math.round(outputCost),
+        "cost.reasoning": reasoningCost ? Math.round(reasoningCost) : undefined,
+        "cost.cache_read": cacheReadCost ? Math.round(cacheReadCost) : undefined,
+        "cost.cache_write_5m": cacheWrite5mCost ? Math.round(cacheWrite5mCost) : undefined,
+        "cost.cache_write_1h": cacheWrite1hCost ? Math.round(cacheWrite1hCost) : undefined,
+        "cost.total": Math.round(totalCostInCent),
+      })
+
+      if (!apiKey) return
+
+      const cost = isFree ? 0 : centsToMicroCents(totalCostInCent)
+      await Database.transaction(async (tx) => {
+        await tx.insert(UsageTable).values({
+          workspaceID: apiKey.workspaceID,
+          id: Identifier.create("usage"),
+          model: MODEL.id,
+          provider: providerName,
+          inputTokens,
+          outputTokens,
+          reasoningTokens,
+          cacheReadTokens,
+          cacheWrite5mTokens,
+          cacheWrite1hTokens,
+          cost,
+        })
+        await tx
+          .update(BillingTable)
+          .set({
+            balance: sql`${BillingTable.balance} - ${cost}`,
+          })
+          .where(eq(BillingTable.workspaceID, apiKey.workspaceID))
+      })
+
+      await Database.use((tx) =>
+        tx
+          .update(KeyTable)
+          .set({ timeUsed: sql`now()` })
+          .where(eq(KeyTable.id, apiKey.id)),
+      )
+    }
+  } catch (error: any) {
+    logger.metric({
+      "error.type": error.constructor.name,
+      "error.message": error.message,
+    })
+
+    // Note: both top level "type" and "error.type" fields are used by the @ai-sdk/anthropic client to render the error message.
+    if (error instanceof AuthError || error instanceof CreditsError || error instanceof ModelError)
+      return new Response(
+        JSON.stringify({
+          type: "error",
+          error: { type: error.constructor.name, message: error.message },
+        }),
+        { status: 401 },
+      )
+
+    return new Response(
+      JSON.stringify({
+        type: "error",
+        error: {
+          type: "error",
+          message: error.message,
+        },
+      }),
+      { status: 500 },
+    )
+  }
+}

cloud/core/migrations/meta/_journal.json

@@ -57,62 +57,6 @@
       "when": 1757693869142,
       "tag": "0007_familiar_nightshade",
       "breakpoints": true
-    },
-    {
-      "idx": 8,
-      "version": "5",
-      "when": 1757885904718,
-      "tag": "0008_eminent_ultimatum",
-      "breakpoints": true
-    },
-    {
-      "idx": 9,
-      "version": "5",
-      "when": 1757888582598,
-      "tag": "0009_redundant_piledriver",
-      "breakpoints": true
-    },
-    {
-      "idx": 10,
-      "version": "5",
-      "when": 1757892305788,
-      "tag": "0010_needy_sue_storm",
-      "breakpoints": true
-    },
-    {
-      "idx": 11,
-      "version": "5",
-      "when": 1757948881012,
-      "tag": "0011_freezing_phil_sheldon",
-      "breakpoints": true
-    },
-    {
-      "idx": 12,
-      "version": "5",
-      "when": 1757956814524,
-      "tag": "0012_bright_photon",
-      "breakpoints": true
-    },
-    {
-      "idx": 13,
-      "version": "5",
-      "when": 1757956978089,
-      "tag": "0013_absurd_hobgoblin",
-      "breakpoints": true
-    },
-    {
-      "idx": 14,
-      "version": "5",
-      "when": 1758289919722,
-      "tag": "0014_demonic_princess_powerful",
-      "breakpoints": true
-    },
-    {
-      "idx": 15,
-      "version": "5",
-      "when": 1758428484500,
-      "tag": "0015_cloudy_revanche",
-      "breakpoints": true
     }
   ]
 }

cloud/core/package.json

@@ -1,12 +1,12 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "name": "@opencode/console-core",
-  "version": "0.11.0",
+  "name": "@opencode/cloud-core",
+  "version": "0.7.9",
   "private": true,
   "type": "module",
   "dependencies": {
     "@aws-sdk/client-sts": "3.782.0",
-    "@opencode/console-resource": "workspace:*",
+    "@opencode/cloud-resource": "workspace:*",
     "@planetscale/database": "1.19.0",
     "drizzle-orm": "0.41.0",
     "postgres": "3.4.7",

cloud/core/src/billing.ts

@@ -0,0 +1,120 @@
+import { Stripe } from "stripe"
+import { Database, eq, sql } from "./drizzle"
+import { BillingTable, PaymentTable, UsageTable } from "./schema/billing.sql"
+import { Actor } from "./actor"
+import { fn } from "./util/fn"
+import { z } from "zod"
+import { User } from "./user"
+import { Resource } from "@opencode/cloud-resource"
+
+export namespace Billing {
+  export const stripe = () =>
+    new Stripe(Resource.STRIPE_SECRET_KEY.value, {
+      apiVersion: "2025-03-31.basil",
+    })
+
+  export const get = async () => {
+    return Database.use(async (tx) =>
+      tx
+        .select({
+          customerID: BillingTable.customerID,
+          paymentMethodID: BillingTable.paymentMethodID,
+          balance: BillingTable.balance,
+          reload: BillingTable.reload,
+        })
+        .from(BillingTable)
+        .where(eq(BillingTable.workspaceID, Actor.workspace()))
+        .then((r) => r[0]),
+    )
+  }
+
+  export const payments = async () => {
+    return await Database.use((tx) =>
+      tx
+        .select()
+        .from(PaymentTable)
+        .where(eq(PaymentTable.workspaceID, Actor.workspace()))
+        .orderBy(sql`${PaymentTable.timeCreated} DESC`)
+        .limit(100),
+    )
+  }
+
+  export const usages = async () => {
+    return await Database.use((tx) =>
+      tx
+        .select()
+        .from(UsageTable)
+        .where(eq(UsageTable.workspaceID, Actor.workspace()))
+        .orderBy(sql`${UsageTable.timeCreated} DESC`)
+        .limit(100),
+    )
+  }
+
+  export const generateCheckoutUrl = fn(
+    z.object({
+      successUrl: z.string(),
+      cancelUrl: z.string(),
+    }),
+    async (input) => {
+      const account = Actor.assert("user")
+      const { successUrl, cancelUrl } = input
+
+      const user = await User.fromID(account.properties.userID)
+      const customer = await Billing.get()
+      const session = await Billing.stripe().checkout.sessions.create({
+        mode: "payment",
+        line_items: [
+          {
+            price_data: {
+              currency: "usd",
+              product_data: {
+                name: "opencode credits",
+              },
+              unit_amount: 2123, // $20 minimum + Stripe fee 4.4% + $0.30
+            },
+            quantity: 1,
+          },
+        ],
+        payment_intent_data: {
+          setup_future_usage: "on_session",
+        },
+        ...(customer.customerID
+          ? { customer: customer.customerID }
+          : {
+              customer_email: user.email,
+              customer_creation: "always",
+            }),
+        metadata: {
+          workspaceID: Actor.workspace(),
+        },
+        currency: "usd",
+        payment_method_types: ["card"],
+        success_url: successUrl,
+        cancel_url: cancelUrl,
+      })
+
+      return session.url
+    },
+  )
+
+  export const generatePortalUrl = fn(
+    z.object({
+      returnUrl: z.string(),
+    }),
+    async (input) => {
+      const { returnUrl } = input
+
+      const customer = await Billing.get()
+      if (!customer?.customerID) {
+        throw new Error("No stripe customer ID")
+      }
+
+      const session = await Billing.stripe().billingPortal.sessions.create({
+        customer: customer.customerID,
+        return_url: returnUrl,
+      })
+
+      return session.url
+    },
+  )
+}

cloud/core/src/drizzle/index.ts

@@ -1,5 +1,5 @@
 import { drizzle } from "drizzle-orm/planetscale-serverless"
-import { Resource } from "@opencode/console-resource"
+import { Resource } from "@opencode/cloud-resource"
 export * from "drizzle-orm"
 import { Client } from "@planetscale/database"
 

cloud/core/src/schema/billing.sql.ts

@@ -1,5 +1,5 @@
-import { bigint, boolean, int, mysqlTable, uniqueIndex, varchar } from "drizzle-orm/mysql-core"
-import { timestamps, utc, workspaceColumns } from "../drizzle/types"
+import { bigint, boolean, int, mysqlTable, varchar, json } from "drizzle-orm/mysql-core"
+import { timestamps, workspaceColumns } from "../drizzle/types"
 import { workspaceIndexes } from "./workspace.sql"
 
 export const BillingTable = mysqlTable(
@@ -11,15 +11,9 @@ export const BillingTable = mysqlTable(
     paymentMethodID: varchar("payment_method_id", { length: 255 }),
     paymentMethodLast4: varchar("payment_method_last4", { length: 4 }),
     balance: bigint("balance", { mode: "number" }).notNull(),
-    monthlyLimit: int("monthly_limit"),
-    monthlyUsage: bigint("monthly_usage", { mode: "number" }),
-    timeMonthlyUsageUpdated: utc("time_monthly_usage_updated"),
     reload: boolean("reload"),
-    reloadError: varchar("reload_error", { length: 255 }),
-    timeReloadError: utc("time_reload_error"),
-    timeReloadLockedTill: utc("time_reload_locked_till"),
   },
-  (table) => [...workspaceIndexes(table), uniqueIndex("global_customer_id").on(table.customerID)],
+  (table) => [...workspaceIndexes(table)],
 )
 
 export const PaymentTable = mysqlTable(

cloud/core/src/schema/workspace.sql.ts

@@ -1,4 +1,4 @@
-import { primaryKey, mysqlTable, uniqueIndex, varchar, boolean } from "drizzle-orm/mysql-core"
+import { primaryKey, mysqlTable, uniqueIndex, varchar } from "drizzle-orm/mysql-core"
 import { timestamps, ulid } from "../drizzle/types"
 
 export const WorkspaceTable = mysqlTable(

cloud/core/src/util/fn.ts

@@ -1,11 +1,11 @@
 import { z } from "zod"
 
-export function fn<T extends z.ZodType, Result>(schema: T, cb: (input: z.infer<T>) => Result) {
-  const result = (input: z.infer<T>) => {
+export function fn<T extends z.ZodType, Result>(schema: T, cb: (input: z.output<T>) => Result) {
+  const result = (input: z.input<T>) => {
     const parsed = schema.parse(input)
     return cb(parsed)
   }
-  result.force = (input: z.infer<T>) => cb(input)
+  result.force = (input: z.input<T>) => cb(input)
   result.schema = schema
   return result
 }