refactor(core): centralize session message rows

Co-authored-by: Aiden Cline <rekram1-node@users.noreply.github.com>

packages/console/app/src/routes/api/usage.ts

@@ -1,75 +0,0 @@
-import type { APIEvent } from "@solidjs/start/server"
-import { and, Database, eq, isNull } from "@opencode-ai/console-core/drizzle/index.js"
-import { BillingTable, LiteTable } from "@opencode-ai/console-core/schema/billing.sql.js"
-import { KeyTable } from "@opencode-ai/console-core/schema/key.sql.js"
-import { LiteData } from "@opencode-ai/console-core/lite.js"
-import { Subscription } from "@opencode-ai/console-core/subscription.js"
-
-export async function GET(input: APIEvent) {
-  const token = input.request.headers.get("authorization")?.match(/^Bearer (.+)$/)?.[1]
-  if (!token) return Response.json({ error: "Unauthorized" }, { status: 401 })
-
-  const row = await Database.use((tx) =>
-    tx
-      .select({
-        balance: BillingTable.balance,
-        monthlyLimit: BillingTable.monthlyLimit,
-        monthlyUsage: BillingTable.monthlyUsage,
-        useBalance: BillingTable.lite,
-        rollingUsage: LiteTable.rollingUsage,
-        weeklyUsage: LiteTable.weeklyUsage,
-        goMonthlyUsage: LiteTable.monthlyUsage,
-        timeRollingUpdated: LiteTable.timeRollingUpdated,
-        timeWeeklyUpdated: LiteTable.timeWeeklyUpdated,
-        timeMonthlyUpdated: LiteTable.timeMonthlyUpdated,
-        timeSubscribed: LiteTable.timeCreated,
-      })
-      .from(KeyTable)
-      .innerJoin(BillingTable, eq(BillingTable.workspaceID, KeyTable.workspaceID))
-      .leftJoin(
-        LiteTable,
-        and(
-          eq(LiteTable.workspaceID, KeyTable.workspaceID),
-          eq(LiteTable.userID, KeyTable.userID),
-          isNull(LiteTable.timeDeleted),
-        ),
-      )
-      .where(and(eq(KeyTable.key, token), isNull(KeyTable.timeDeleted)))
-      .then((rows) => rows[0]),
-  )
-  if (!row) return Response.json({ error: "Unauthorized" }, { status: 401 })
-
-  const limits = row.timeSubscribed ? LiteData.getLimits() : undefined
-  return Response.json({
-    go:
-      limits && row.timeSubscribed
-        ? {
-            useBalance: row.useBalance?.useBalance ?? false,
-            rolling: Subscription.analyzeRollingUsage({
-              limit: limits.rollingLimit,
-              window: limits.rollingWindow,
-              usage: row.rollingUsage ?? 0,
-              timeUpdated: row.timeRollingUpdated ?? new Date(),
-            }),
-            weekly: Subscription.analyzeWeeklyUsage({
-              limit: limits.weeklyLimit,
-              usage: row.weeklyUsage ?? 0,
-              timeUpdated: row.timeWeeklyUpdated ?? new Date(),
-            }),
-            monthly: Subscription.analyzeMonthlyUsage({
-              limit: limits.monthlyLimit,
-              usage: row.goMonthlyUsage ?? 0,
-              timeUpdated: row.timeMonthlyUpdated ?? new Date(),
-              timeSubscribed: row.timeSubscribed,
-            }),
-          }
-        : undefined,
-    zen: {
-      balance: row.balance / 100_000_000,
-      monthly: {
-        usage: (row.monthlyUsage ?? 0) / 100_000_000,
-        limit: row.monthlyLimit ?? undefined,
-      },
-    },
-  })
-}

packages/core/src/config/normalize.ts

@@ -83,8 +83,14 @@ export function normalize(input: unknown): Result {
   if (legacySnapshots !== undefined) encoded.snapshots = legacySnapshots
   if (legacyShare !== undefined) encoded.share = legacyShare
 
-  const legacyReferences = decodeEncodedMap(input.reference, ConfigReference.Entry, ["reference"], diagnostics)
-  const nativeReferences = decodeEncodedMap(input.references, ConfigReference.Entry, ["references"], diagnostics)
+  const legacyReferences = decodeMap(input.reference, ConfigReference.Entry, ["reference"], diagnostics, decodeEncoded)
+  const nativeReferences = decodeMap(
+    input.references,
+    ConfigReference.Entry,
+    ["references"],
+    diagnostics,
+    decodeEncoded,
+  )
   mergeMap(
     encoded,
     "references",
@@ -94,13 +100,13 @@ export function normalize(input: unknown): Result {
     diagnostics,
   )
 
-  const legacyCommands = decodeMap(input.command, ConfigCommandV1.Info, ["command"], diagnostics)
+  const legacyCommands = decodeMap(input.command, ConfigCommandV1.Info, ["command"], diagnostics, decodeValue)
   diagnoseSelectionMap(input.command, ["command"], diagnostics)
   const migratedCommands = mapValues(legacyCommands, (value) => {
     const migrated = ConfigMigrateV1.commands({ value })?.value
     return migrated === undefined ? undefined : canonical(ConfigCommand.Info, migrated)
   })
-  const nativeCommands = decodeEncodedMap(input.commands, ConfigCommand.Info, ["commands"], diagnostics)
+  const nativeCommands = decodeMap(input.commands, ConfigCommand.Info, ["commands"], diagnostics, decodeEncoded)
   mergeMap(
     encoded,
     "commands",
@@ -110,8 +116,9 @@ export function normalize(input: unknown): Result {
     diagnostics,
   )
 
-  const legacyAgents = mapValues(decodeMap(input.agent, ConfigAgentV1.Info, ["agent"], diagnostics), (value) =>
-    canonical(ConfigAgent.Info, ConfigMigrateV1.migrateAgent(value)),
+  const legacyAgents = mapValues(
+    decodeMap(input.agent, ConfigAgentV1.Info, ["agent"], diagnostics, decodeValue),
+    (value) => canonical(ConfigAgent.Info, ConfigMigrateV1.migrateAgent(value)),
   )
   const legacySmallModel = own(input, "small_model")
     ? decodeValue(Schema.String, input.small_model, ["small_model"], diagnostics)
@@ -130,11 +137,11 @@ export function normalize(input: unknown): Result {
       model: migratedSmallModel,
       ...legacyAgents.title,
     }
-  const modeAgents = mapValues(decodeMap(input.mode, ConfigAgentV1.Info, ["mode"], diagnostics), (value) =>
+  const modeAgents = mapValues(decodeMap(input.mode, ConfigAgentV1.Info, ["mode"], diagnostics, decodeValue), (value) =>
     canonical(ConfigAgent.Info, ConfigMigrateV1.migrateAgent({ ...value, mode: "primary" })),
   )
   const migratedAgents = mergeMaps(legacyAgents, modeAgents, ["agents"], diagnostics)
-  const nativeAgents = decodeEncodedMap(input.agents, ConfigAgent.Info, ["agents"], diagnostics)
+  const nativeAgents = decodeMap(input.agents, ConfigAgent.Info, ["agents"], diagnostics, decodeEncoded)
   diagnoseAgentUnsupported(input.agent, ["agent"], diagnostics)
   diagnoseAgentUnsupported(input.mode, ["mode"], diagnostics)
   mergeMap(
@@ -147,7 +154,7 @@ export function normalize(input: unknown): Result {
   )
 
   const legacyProviders = migrateProviders(input.provider, diagnostics)
-  const nativeProviders = decodeEncodedMap(input.providers, ConfigProvider.Info, ["providers"], diagnostics)
+  const nativeProviders = decodeMap(input.providers, ConfigProvider.Info, ["providers"], diagnostics, decodeEncoded)
   mergeMap(
     encoded,
     "providers",
@@ -159,14 +166,14 @@ export function normalize(input: unknown): Result {
 
   const toolRules = migrateTools(input.tools, diagnostics)
   const permissionRules = migratePermissions(input.permission, diagnostics)
-  const nativePermissions = decodeEncodedList(input.permissions, Permission.Rule, ["permissions"], diagnostics)
+  const nativePermissions = decodeList(input.permissions, Permission.Rule, ["permissions"], diagnostics, decodeEncoded)
   const permissions = [...toolRules, ...permissionRules, ...nativePermissions]
   if (permissions.length || Array.isArray(input.permissions)) encoded.permissions = permissions
 
-  const legacyPlugins = decodeList(input.plugin, ConfigPluginV1.Spec, ["plugin"], diagnostics).map((plugin) =>
-    typeof plugin === "string" ? plugin : { package: plugin[0], options: plugin[1] },
+  const legacyPlugins = decodeList(input.plugin, ConfigPluginV1.Spec, ["plugin"], diagnostics, decodeValue).map(
+    (plugin) => (typeof plugin === "string" ? plugin : { package: plugin[0], options: plugin[1] }),
   )
-  const nativePlugins = decodeEncodedList(input.plugins, ConfigPlugin.Plugin, ["plugins"], diagnostics)
+  const nativePlugins = decodeList(input.plugins, ConfigPlugin.Plugin, ["plugins"], diagnostics, decodeEncoded)
   if (legacyPlugins.length || nativePlugins.length || Array.isArray(input.plugin) || Array.isArray(input.plugins))
     encoded.plugins = [...legacyPlugins, ...nativePlugins]
 
@@ -200,7 +207,7 @@ export function normalize(input: unknown): Result {
     overlay(encoded, key, value, [key], diagnostics)
   })
 
-  const instructions = decodeEncodedList(input.instructions, Schema.String, ["instructions"], diagnostics)
+  const instructions = decodeList(input.instructions, Schema.String, ["instructions"], diagnostics, decodeEncoded)
   if (instructions.length || Array.isArray(input.instructions)) encoded.instructions = instructions
 
   return { type: "normalized", encoded, diagnostics }
@@ -209,7 +216,7 @@ export function normalize(input: unknown): Result {
 function normalizeSkills(input: Record<string, unknown>, encoded: Record<string, unknown>, diagnostics: Diagnostic[]) {
   if (!own(input, "skills")) return
   if (Array.isArray(input.skills)) {
-    encoded.skills = decodeEncodedList(input.skills, Schema.String, ["skills"], diagnostics)
+    encoded.skills = decodeList(input.skills, Schema.String, ["skills"], diagnostics, decodeEncoded)
     return
   }
   if (!isRecord(input.skills)) {
@@ -217,8 +224,8 @@ function normalizeSkills(input: Record<string, unknown>, encoded: Record<string,
     return
   }
   encoded.skills = [
-    ...decodeEncodedList(input.skills.paths, Schema.String, ["skills", "paths"], diagnostics),
-    ...decodeEncodedList(input.skills.urls, Schema.String, ["skills", "urls"], diagnostics),
+    ...decodeList(input.skills.paths, Schema.String, ["skills", "paths"], diagnostics, decodeEncoded),
+    ...decodeList(input.skills.urls, Schema.String, ["skills", "urls"], diagnostics, decodeEncoded),
   ]
 }
 
@@ -248,8 +255,8 @@ function normalizeMcp(input: Record<string, unknown>, encoded: Record<string, un
           return
         }
         if (name === "servers" && !isDirectLegacyMcp(value)) {
-          Object.entries(decodeEncodedMap(value, ConfigMCP.Server, path, diagnostics)).forEach(([key, server]) =>
-            setOwn(nativeServers, key, server),
+          Object.entries(decodeMap(value, ConfigMCP.Server, path, diagnostics, decodeEncoded)).forEach(
+            ([key, server]) => setOwn(nativeServers, key, server),
           )
           return
         }
@@ -404,7 +411,13 @@ function normalizeExperimental(
         if (value !== undefined) result.subagent_depth = value
       }
       native.push(
-        ...decodeEncodedList(experimental.policies, ConfigPolicy.Info, ["experimental", "policies"], diagnostics),
+        ...decodeList(
+          experimental.policies,
+          ConfigPolicy.Info,
+          ["experimental", "policies"],
+          diagnostics,
+          decodeEncoded,
+        ),
       )
     }
   }
@@ -420,7 +433,7 @@ function normalizeWatcher(input: Record<string, unknown>, encoded: Record<string
     invalid(["watcher"], diagnostics)
     return
   }
-  const ignore = decodeEncodedList(input.watcher.ignore, Schema.String, ["watcher", "ignore"], diagnostics)
+  const ignore = decodeList(input.watcher.ignore, Schema.String, ["watcher", "ignore"], diagnostics, decodeEncoded)
   encoded.watcher = ignore.length || Array.isArray(input.watcher.ignore) ? { ignore } : {}
 }
 
@@ -435,7 +448,7 @@ function normalizeFormatter(
     if (value !== undefined) encoded.formatter = value
     return
   }
-  const entries = decodeEncodedMap(input.formatter, ConfigFormatter.Entry, ["formatter"], diagnostics)
+  const entries = decodeMap(input.formatter, ConfigFormatter.Entry, ["formatter"], diagnostics, decodeEncoded)
   if (isRecord(input.formatter) && (!Object.keys(input.formatter).length || Object.keys(entries).length))
     encoded.formatter = entries
 }
@@ -447,7 +460,7 @@ function normalizeLsp(input: Record<string, unknown>, encoded: Record<string, un
     if (value !== undefined) encoded.lsp = value
     return
   }
-  const entries = decodeEncodedMap(input.lsp, ConfigLSP.Entry, ["lsp"], diagnostics)
+  const entries = decodeMap(input.lsp, ConfigLSP.Entry, ["lsp"], diagnostics, decodeEncoded)
   if (isRecord(input.lsp) && (!Object.keys(input.lsp).length || Object.keys(entries).length)) encoded.lsp = entries
 }
 
@@ -597,78 +610,44 @@ function decodeProviderList(
   return {
     present: true,
     nonEmpty: input[key].length > 0,
-    values: decodeList(input[key], Schema.String, [key], diagnostics),
+    values: decodeList(input[key], Schema.String, [key], diagnostics, decodeValue),
   }
 }
 
-function decodeEncodedMap<S extends Schema.Codec<unknown, unknown, never, never>>(
+function decodeMap<S extends Schema.Codec<unknown, unknown, never>, A>(
   value: unknown,
   schema: S,
   path: string[],
   diagnostics: Diagnostic[],
-) {
+  decode: (schema: S, value: unknown, path: string[], diagnostics: Diagnostic[]) => A | undefined,
+): Record<string, A> {
   if (value === undefined) return {}
   if (!isRecord(value)) {
     invalid(path, diagnostics)
     return {}
   }
   return Object.fromEntries(
-    Object.entries(value).flatMap(([name, raw]) => {
-      const decoded = decodeEncoded(schema, raw, [...path, name], diagnostics)
+    Object.entries(value).flatMap(([name, raw]): [string, A][] => {
+      const decoded = decode(schema, raw, [...path, name], diagnostics)
       return decoded === undefined ? [] : [[name, decoded]]
     }),
   )
 }
 
-function decodeMap<S extends Schema.Codec<unknown, unknown, never, never>>(
+function decodeList<S extends Schema.Codec<unknown, unknown, never>, A>(
   value: unknown,
   schema: S,
   path: string[],
   diagnostics: Diagnostic[],
-) {
-  if (value === undefined) return {} as Record<string, S["Type"]>
-  if (!isRecord(value)) {
-    invalid(path, diagnostics)
-    return {} as Record<string, S["Type"]>
-  }
-  return Object.fromEntries(
-    Object.entries(value).flatMap(([name, raw]) => {
-      const decoded = decodeValue(schema, raw, [...path, name], diagnostics)
-      return decoded === undefined ? [] : [[name, decoded]]
-    }),
-  ) as Record<string, S["Type"]>
-}
-
-function decodeEncodedList<S extends Schema.Codec<unknown, unknown, never, never>>(
-  value: unknown,
-  schema: S,
-  path: string[],
-  diagnostics: Diagnostic[],
-) {
-  if (value === undefined) return [] as S["Encoded"][]
+  decode: (schema: S, value: unknown, path: string[], diagnostics: Diagnostic[]) => A | undefined,
+): A[] {
+  if (value === undefined) return []
   if (!Array.isArray(value)) {
     invalid(path, diagnostics)
-    return [] as S["Encoded"][]
+    return []
   }
   return value.flatMap((item, index) => {
-    const decoded = decodeEncoded(schema, item, [...path, String(index)], diagnostics)
-    return decoded === undefined ? [] : [decoded]
-  })
-}
-
-function decodeList<S extends Schema.Codec<unknown, unknown, never, never>>(
-  value: unknown,
-  schema: S,
-  path: string[],
-  diagnostics: Diagnostic[],
-) {
-  if (value === undefined) return [] as S["Type"][]
-  if (!Array.isArray(value)) {
-    invalid(path, diagnostics)
-    return [] as S["Type"][]
-  }
-  return value.flatMap((item, index) => {
-    const decoded = decodeValue(schema, item, [...path, String(index)], diagnostics)
+    const decoded = decode(schema, item, [...path, String(index)], diagnostics)
     return decoded === undefined ? [] : [decoded]
   })
 }

packages/core/src/filesystem/fff.bun.ts

@@ -1,102 +1,15 @@
-import {
-  FileFinder,
-  type DirItem,
-  type DirSearchResult,
-  type FileItem,
-  type InitOptions,
-  type MixedItem,
-  type MixedSearchResult,
-  type SearchResult,
-} from "@ff-labs/fff-bun"
+import { FileFinder } from "@ff-labs/fff-bun"
+import { bind } from "./fff"
+
+export type { Directory, DirSearch, File, Init, Mixed, MixedSearch, Picker, Result, Search } from "./fff"
 
 declare global {
   const FFF_LIBC: "gnu" | "musl"
 }
 
-export type Result<T> = { ok: true; value: T } | { ok: false; error: string }
+const adapter = bind(FileFinder)
 
-export type Init = InitOptions
-
-export interface Search {
-  items: FileItem[]
-  scores: SearchResult["scores"]
-  totalMatched: number
-  totalFiles: number
-}
-
-export interface DirSearch {
-  items: DirItem[]
-  scores: DirSearchResult["scores"]
-  totalMatched: number
-  totalDirs: number
-}
-
-export interface MixedSearch {
-  items: MixedItem[]
-  scores: MixedSearchResult["scores"]
-  totalMatched: number
-  totalFiles: number
-  totalDirs: number
-}
-
-export type File = FileItem
-export type Directory = DirItem
-export type Mixed = MixedItem
-export interface Picker {
-  destroy(): void
-  isScanning(): boolean
-  waitForScan(timeoutMs?: number): Promise<Result<boolean>>
-  refreshGitStatus(): Result<number>
-  fileSearch(
-    query: string,
-    opts?: {
-      currentFile?: string
-      pageIndex?: number
-      pageSize?: number
-    },
-  ): Result<Search>
-  directorySearch(
-    query: string,
-    opts?: {
-      currentFile?: string
-      pageIndex?: number
-      pageSize?: number
-    },
-  ): Result<DirSearch>
-  mixedSearch(
-    query: string,
-    opts?: {
-      currentFile?: string
-      pageIndex?: number
-      pageSize?: number
-    },
-  ): Result<MixedSearch>
-  trackQuery(query: string, file: string): Result<boolean>
-  getHistoricalQuery(offset: number): Result<string | null>
-}
-
-export function available() {
-  return FileFinder.isAvailable()
-}
-
-export function create(opts: Init): Result<Picker> {
-  const made = FileFinder.create(opts)
-  if (!made.ok) return made
-  const pick = made.value
-  return {
-    ok: true,
-    value: {
-      destroy: () => pick.destroy(),
-      isScanning: () => pick.isScanning(),
-      waitForScan: (timeoutMs) => pick.waitForScan(timeoutMs),
-      refreshGitStatus: () => pick.refreshGitStatus(),
-      fileSearch: (query, next) => pick.fileSearch(query, next),
-      directorySearch: (query, next) => pick.directorySearch(query, next),
-      mixedSearch: (query, next) => pick.mixedSearch(query, next),
-      trackQuery: (query, file) => pick.trackQuery(query, file),
-      getHistoricalQuery: (offset) => pick.getHistoricalQuery(offset),
-    },
-  }
-}
+export const available = adapter.available
+export const create = adapter.create
 
 export * as Fff from "./fff.bun"

packages/core/src/filesystem/fff.node.ts

@@ -1,100 +1,12 @@
-import type {
-  DirItem,
-  DirSearchResult,
-  FileItem,
-  InitOptions,
-  MixedItem,
-  MixedSearchResult,
-  SearchResult,
-} from "@ff-labs/fff-node"
+import { bind } from "./fff"
+
+export type { Directory, DirSearch, File, Init, Mixed, MixedSearch, Picker, Result, Search } from "./fff"
 
 const { FileFinder } = await import("@ff-labs/fff-node").catch(() => ({ FileFinder: undefined }))
 
-export type Result<T> = { ok: true; value: T } | { ok: false; error: string }
+const adapter = bind(FileFinder, "fff unavailable on node runtime")
 
-export type Init = InitOptions
-
-export interface Search {
-  items: FileItem[]
-  scores: SearchResult["scores"]
-  totalMatched: number
-  totalFiles: number
-}
-
-export interface DirSearch {
-  items: DirItem[]
-  scores: DirSearchResult["scores"]
-  totalMatched: number
-  totalDirs: number
-}
-
-export interface MixedSearch {
-  items: MixedItem[]
-  scores: MixedSearchResult["scores"]
-  totalMatched: number
-  totalFiles: number
-  totalDirs: number
-}
-
-export type File = FileItem
-export type Directory = DirItem
-export type Mixed = MixedItem
-export interface Picker {
-  destroy(): void
-  isScanning(): boolean
-  waitForScan(timeoutMs?: number): Promise<Result<boolean>>
-  refreshGitStatus(): Result<number>
-  fileSearch(
-    query: string,
-    opts?: {
-      currentFile?: string
-      pageIndex?: number
-      pageSize?: number
-    },
-  ): Result<Search>
-  directorySearch(
-    query: string,
-    opts?: {
-      currentFile?: string
-      pageIndex?: number
-      pageSize?: number
-    },
-  ): Result<DirSearch>
-  mixedSearch(
-    query: string,
-    opts?: {
-      currentFile?: string
-      pageIndex?: number
-      pageSize?: number
-    },
-  ): Result<MixedSearch>
-  trackQuery(query: string, file: string): Result<boolean>
-  getHistoricalQuery(offset: number): Result<string | null>
-}
-
-export function available() {
-  return FileFinder?.isAvailable() ?? false
-}
-
-export function create(opts: Init): Result<Picker> {
-  if (!FileFinder) return { ok: false, error: "fff unavailable on node runtime" }
-  const made = FileFinder.create(opts)
-  if (!made.ok) return made
-  const pick = made.value
-  return {
-    ok: true,
-    value: {
-      destroy: () => pick.destroy(),
-      isScanning: () => pick.isScanning(),
-      waitForScan: (timeoutMs) => pick.waitForScan(timeoutMs),
-      refreshGitStatus: () => pick.refreshGitStatus(),
-      fileSearch: (query, next) => pick.fileSearch(query, next),
-      directorySearch: (query, next) => pick.directorySearch(query, next),
-      mixedSearch: (query, next) => pick.mixedSearch(query, next),
-      trackQuery: (query, file) => pick.trackQuery(query, file),
-      getHistoricalQuery: (offset) => pick.getHistoricalQuery(offset),
-    },
-  }
-}
+export const available = adapter.available
+export const create = adapter.create
 
 export * as Fff from "./fff.node"

packages/core/src/filesystem/fff.ts

@@ -0,0 +1,66 @@
+export type Result<T> = { ok: true; value: T } | { ok: false; error: string }
+
+export interface Init {
+  basePath: string
+  aiMode?: boolean
+  disableMmapCache?: boolean
+  disableContentIndexing?: boolean
+}
+
+export interface SearchOptions {
+  currentFile?: string
+  pageIndex?: number
+  pageSize?: number
+}
+
+export interface File {
+  relativePath: string
+}
+
+export interface Directory {
+  relativePath: string
+}
+
+export type Mixed = { type: "file"; item: File } | { type: "directory"; item: Directory }
+
+export interface Score {
+  total: number
+}
+
+export interface Search {
+  items: File[]
+  scores: Score[]
+}
+
+export interface DirSearch {
+  items: Directory[]
+  scores: Score[]
+}
+
+export interface MixedSearch {
+  items: Mixed[]
+  scores: Score[]
+}
+
+export interface Picker {
+  destroy(): void
+  fileSearch(query: string, options?: SearchOptions): Result<Search>
+  directorySearch(query: string, options?: SearchOptions): Result<DirSearch>
+  mixedSearch(query: string, options?: SearchOptions): Result<MixedSearch>
+}
+
+export interface Backend {
+  isAvailable(): boolean
+  create(options: Init): Result<Picker>
+}
+
+export function bind(backend: Backend | undefined, unavailable = "fff unavailable") {
+  return {
+    available: () => backend?.isAvailable() ?? false,
+    create: (options: Init): Result<Picker> =>
+      backend?.create(options) ?? {
+        ok: false,
+        error: unavailable,
+      },
+  }
+}

packages/core/src/plugin/websearch/exa.ts

@@ -30,7 +30,7 @@ export const Plugin = define<HttpClient.HttpClient | Scope.Scope>({
       draft.update("exa", (integration) => (integration.name = "Exa"))
       draft.method.update({
         integrationID: "exa",
-        method: { type: "key", label: "API key (optional)" },
+        method: { type: "key" },
       })
       draft.method.update({
         integrationID: "exa",

packages/core/src/plugin/websearch/firecrawl.ts

@@ -41,7 +41,7 @@ export const Plugin = define<HttpClient.HttpClient | Scope.Scope>({
       draft.update("firecrawl", (integration) => (integration.name = "Firecrawl"))
       draft.method.update({
         integrationID: "firecrawl",
-        method: { type: "key", label: "API key (optional)" },
+        method: { type: "key" },
       })
       draft.method.update({
         integrationID: "firecrawl",

packages/core/src/plugin/websearch/parallel.ts

@@ -56,7 +56,7 @@ export const Plugin = define<HttpClient.HttpClient | Scope.Scope>({
       draft.update("parallel", (integration) => (integration.name = "Parallel"))
       draft.method.update({
         integrationID: "parallel",
-        method: { type: "key", label: "API key (optional)" },
+        method: { type: "key" },
       })
       draft.method.update({
         integrationID: "parallel",

packages/core/src/session/history.ts

@@ -1,8 +1,9 @@
 import { and, asc, desc, eq, gte, sql } from "drizzle-orm"
-import { Effect, Schema } from "effect"
+import { Effect } from "effect"
 import { Database } from "../database/database"
 import { MessageDecodeError } from "./error"
 import { SessionMessage } from "./message"
+import { SessionMessageRow } from "./message-row"
 import { SessionSchema } from "./schema"
 import { Instructions } from "../instructions/index"
 import { InstructionState } from "./instruction-state"
@@ -10,8 +11,6 @@ import { SessionMessageTable } from "./sql"
 
 type DatabaseService = Database.Interface["db"]
 
-const decode = Schema.decodeUnknownEffect(SessionMessage.Info)
-
 export const latestCompaction = Effect.fnUntraced(function* (db: DatabaseService, sessionID: SessionSchema.ID) {
   return yield* db
     .select({ seq: SessionMessageTable.seq })
@@ -50,7 +49,7 @@ const messageRows = Effect.fnUntraced(function* (
 })
 
 const decodeMessageRow = (row: typeof SessionMessageTable.$inferSelect) =>
-  decode({ ...row.data, id: row.id, type: row.type }).pipe(
+  SessionMessageRow.decode(row).pipe(
     Effect.mapError(
       () =>
         new MessageDecodeError({

packages/core/src/session/message-row.ts

@@ -0,0 +1,20 @@
+export * as SessionMessageRow from "./message-row"
+
+import { Schema } from "effect"
+import { SessionMessage } from "./message"
+import type { SessionMessageTable } from "./sql"
+
+export type Representation = Pick<typeof SessionMessageTable.$inferSelect, "id" | "type" | "data">
+
+const decodeMessage = Schema.decodeUnknownEffect(SessionMessage.Info)
+const decodeMessageSync = Schema.decodeUnknownSync(SessionMessage.Info)
+const encodeMessage = Schema.encodeSync(SessionMessage.Info)
+
+export const decode = (row: Representation) => decodeMessage({ ...row.data, id: row.id, type: row.type })
+
+export const decodeSync = (row: Representation) => decodeMessageSync({ ...row.data, id: row.id, type: row.type })
+
+export function encode(message: SessionMessage.Info): Representation {
+  const { id, type, ...data } = encodeMessage(message)
+  return { id: SessionMessage.ID.make(id), type, data }
+}

packages/core/src/session/pending.ts

@@ -17,6 +17,7 @@ import { Bus } from "../bus"
 import { KeyedMutex } from "../effect/keyed-mutex"
 import { SessionEvent } from "./event"
 import { SessionMessage } from "./message"
+import { SessionMessageRow } from "./message-row"
 import { SessionSchema } from "./schema"
 import { SessionMessageTable, SessionPendingTable } from "./sql"
 
@@ -35,7 +36,6 @@ const decodeUser = Schema.decodeUnknownSync(UserData)
 const encodeUser = Schema.encodeSync(UserData)
 const decodeSynthetic = Schema.decodeUnknownSync(SyntheticData)
 const encodeSynthetic = Schema.encodeSync(SyntheticData)
-const decodeMessage = Schema.decodeUnknownSync(SessionMessage.Info)
 const inboxLocks = KeyedMutex.makeUnsafe<SessionSchema.ID>()
 type PendingRef = { readonly id: SessionMessage.ID; readonly sessionID: SessionSchema.ID }
 
@@ -113,7 +113,7 @@ const promotedFromMessage = Effect.fn("SessionPending.promotedFromMessage")(func
   if (row === undefined) return undefined
   if (row.session_id !== sessionID || (row.type !== "user" && row.type !== "synthetic"))
     return yield* Effect.die(new LifecycleConflict({ id }))
-  const message = decodeMessage({ ...row.data, id: row.id, type: row.type })
+  const message = SessionMessageRow.decodeSync(row)
   const base = { id, sessionID, timeCreated: message.time.created, delivery }
   if (message.type === "user")
     return User.make({

packages/core/src/session/projector.ts

@@ -9,6 +9,7 @@ import { Agent } from "../agent"
 import { Model } from "../model"
 import { SessionEvent } from "./event"
 import { SessionMessage } from "./message"
+import { SessionMessageRow } from "./message-row"
 import { SessionMessageUpdater } from "./message-updater"
 import { SessionPending } from "./pending"
 import { Workspace } from "../workspace"
@@ -22,9 +23,6 @@ type DatabaseService = Database.Interface["db"]
 type CurrentDurableEvent = Extract<SessionEvent.Event, { readonly durable: object }>
 type MessageEvent = Exclude<CurrentDurableEvent, typeof SessionEvent.Forked.Type | typeof SessionEvent.Deleted.Type>
 
-const decodeMessage = Schema.decodeUnknownSync(SessionMessage.Info)
-const encodeMessage = Schema.encodeSync(SessionMessage.Info)
-
 export class SessionAlreadyProjected extends Error {}
 
 type Usage = {
@@ -210,22 +208,15 @@ const projectFork = Effect.fn("SessionProjector.projectFork")(function* (
 
 function run(db: DatabaseService, event: MessageEvent) {
   return Effect.gen(function* () {
-    const decodeRow = (row: typeof SessionMessageTable.$inferSelect) =>
-      decodeMessage({ ...row.data, id: row.id, type: row.type })
+    const decodeRow = (row: typeof SessionMessageTable.$inferSelect) => SessionMessageRow.decodeSync(row)
     const updateMessage = (message: SessionMessage.Info) => {
       if (event.durable === undefined)
         return Effect.die(new Error("Durable Session event is missing aggregate sequence"))
-      const encoded = encodeMessage(message)
-      const { id, type, ...data } = encoded
+      const row = SessionMessageRow.encode(message)
       return db
         .update(SessionMessageTable)
-        .set({ type, time_created: DateTime.toEpochMillis(message.time.created), data })
-        .where(
-          and(
-            eq(SessionMessageTable.id, SessionMessage.ID.make(id)),
-            eq(SessionMessageTable.session_id, event.data.sessionID),
-          ),
-        )
+        .set({ type: row.type, time_created: DateTime.toEpochMillis(message.time.created), data: row.data })
+        .where(and(eq(SessionMessageTable.id, row.id), eq(SessionMessageTable.session_id, event.data.sessionID)))
         .run()
         .pipe(Effect.orDie)
     }
@@ -343,17 +334,16 @@ function run(db: DatabaseService, event: MessageEvent) {
 
 function insertMessage(db: DatabaseService, event: SessionEvent.DurableEvent, message: SessionMessage.Info) {
   if (event.durable === undefined) return Effect.die(new Error("Durable Session event is missing aggregate sequence"))
-  const encoded = encodeMessage(message)
-  const { id, type, ...data } = encoded
+  const row = SessionMessageRow.encode(message)
   return db
     .insert(SessionMessageTable)
     .values({
-      id: SessionMessage.ID.make(id),
+      id: row.id,
       session_id: event.data.sessionID,
-      type,
+      type: row.type,
       seq: event.durable.seq,
       time_created: DateTime.toEpochMillis(message.time.created),
-      data,
+      data: row.data,
     })
     .run()
     .pipe(Effect.orDie)

packages/core/src/session/revert.ts

@@ -8,6 +8,7 @@ import { RelativePath } from "../schema"
 import { Snapshot } from "../snapshot"
 import { SessionEvent } from "./event"
 import { SessionMessage } from "./message"
+import { SessionMessageRow } from "./message-row"
 import { SessionSchema } from "./schema"
 import { SessionMessageTable } from "./sql"
 
@@ -46,10 +47,9 @@ const plan = Effect.fn("SessionRevert.plan")(function* (input: BoundaryInput) {
     .orderBy(asc(SessionMessageTable.seq))
     .all()
     .pipe(Effect.orDie)
-  const decode = Schema.decodeUnknownEffect(SessionMessage.Info)
   const files = new Map<RelativePath, Snapshot.ID>()
   for (const row of rows) {
-    const message = yield* decode({ ...row.data, id: row.id, type: row.type }).pipe(Effect.orDie)
+    const message = yield* SessionMessageRow.decode(row).pipe(Effect.orDie)
     if (message.type !== "assistant" || !message.snapshot?.start) continue
     for (const file of message.snapshot.files ?? [])
       if (!files.has(file)) files.set(file, Snapshot.ID.make(message.snapshot.start))

packages/core/src/session/store.ts

@@ -1,12 +1,13 @@
 export * as SessionStore from "./store"
 
 import { and, eq, isNotNull, isNull, sql } from "drizzle-orm"
-import { Context, Effect, Layer, Schema } from "effect"
+import { Context, Effect, Layer } from "effect"
 import { Database } from "../database/database"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { SessionHistory } from "./history"
 import { MessageDecodeError } from "./error"
 import { SessionMessage } from "./message"
+import { SessionMessageRow } from "./message-row"
 import { Session } from "@opencode-ai/schema/session"
 import { SessionMessageTable, SessionTable } from "./sql"
 import { fromRow } from "./info"
@@ -51,8 +52,6 @@ const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const { db } = yield* Database.Service
-    const decodeMessage = Schema.decodeUnknownEffect(SessionMessage.Info)
-
     return Service.of({
       get: Effect.fn("SessionStore.get")(function* (sessionID) {
         const row = yield* db.select().from(SessionTable).where(eq(SessionTable.id, sessionID)).get().pipe(Effect.orDie)
@@ -71,7 +70,7 @@ const layer = Layer.effect(
         return row
           ? {
               sessionID: Session.ID.make(row.session_id),
-              message: yield* decodeMessage({ ...row.data, id: row.id, type: row.type }).pipe(Effect.orDie),
+              message: yield* SessionMessageRow.decode(row).pipe(Effect.orDie),
             }
           : undefined
       }),

packages/core/src/session/transfer.ts

@@ -18,6 +18,7 @@ import { Session } from "../session"
 import { Slug } from "../util/slug"
 import { SessionEvent } from "./event"
 import { SessionMessage } from "./message"
+import { SessionMessageRow } from "./message-row"
 import { SessionProjector } from "./projector"
 import { SessionMessageTable, SessionTable } from "./sql"
 
@@ -47,8 +48,6 @@ const layer = Layer.effect(
     const { db } = yield* Database.Service
     const projects = yield* Project.Service
     const sessions = yield* Session.Service
-    const encodeMessage = Schema.encodeSync(SessionMessage.Info)
-
     const persistProject = (project: Project.Resolved) => upsertProject(db, project).pipe(Effect.orDie)
 
     return Service.of({
@@ -71,15 +70,14 @@ const layer = Layer.effect(
         const project = yield* projects.resolve(input.location.directory)
         yield* persistProject(project)
         const messages = input.data.messages.map((message, index) => {
-          const encoded = encodeMessage(message)
-          const { id: _, type, ...data } = encoded
+          const row = SessionMessageRow.encode(message)
           return {
             id: message.id,
             session_id: sessionID,
-            type,
+            type: row.type,
             seq: index + 1,
             time_created: DateTime.toEpochMillis(message.time.created),
-            data,
+            data: row.data,
           }
         })
         yield* bus

packages/core/test/plugin/websearch.test.ts

@@ -3,6 +3,7 @@ import { Effect } from "effect"
 import { Integration } from "@opencode-ai/core/integration"
 import { WebSearch } from "@opencode-ai/core/websearch"
 import { WebSearchExa } from "@opencode-ai/core/plugin/websearch/exa"
+import { WebSearchFirecrawl } from "@opencode-ai/core/plugin/websearch/firecrawl"
 import { WebSearchParallel } from "@opencode-ai/core/plugin/websearch/parallel"
 import { host, integrationHost, webSearchHost } from "./host"
 import { requests, resetWebSearchFixture, webSearchIntegrationTest } from "./websearch-fixture"
@@ -53,6 +54,22 @@ describe("built-in web search providers", () => {
     }),
   )
 
+  it.effect("registers Firecrawl with the standard key method", () =>
+    Effect.gen(function* () {
+      const integrations = yield* Integration.Service
+      const websearch = yield* WebSearch.Service
+      yield* WebSearchFirecrawl.Plugin.effect(
+        host({ integration: integrationHost(integrations), websearch: webSearchHost(websearch) }),
+      )
+
+      expect(yield* integrations.get(Integration.ID.make("firecrawl"))).toMatchObject({
+        id: "firecrawl",
+        name: "Firecrawl",
+        methods: [{ type: "key" }, { type: "env", names: ["FIRECRAWL_API_KEY"] }],
+      })
+    }),
+  )
+
   it.effect("registers Exa with its MCP schema", () =>
     Effect.gen(function* () {
       const integrations = yield* Integration.Service
@@ -129,6 +146,9 @@ describe("built-in web search providers", () => {
       yield* WebSearchParallel.Plugin.effect(
         host({ integration: integrationHost(integrations), websearch: webSearchHost(websearch) }),
       )
+      expect(yield* integrations.get(Integration.ID.make("parallel"))).toMatchObject({
+        methods: [{ type: "key" }, { type: "env", names: ["PARALLEL_API_KEY"] }],
+      })
       yield* integrations.connection.key({
         integrationID: Integration.ID.make("parallel"),
         key: "parallel-secret",

packages/core/test/session-message-row.test.ts

@@ -0,0 +1,33 @@
+import { expect, test } from "bun:test"
+import { DateTime, Effect } from "effect"
+import { SessionMessage } from "@opencode-ai/core/session/message"
+import { SessionMessageRow } from "@opencode-ai/core/session/message-row"
+
+const message = SessionMessage.Synthetic.make({
+  id: SessionMessage.ID.make("msg_row"),
+  type: "synthetic",
+  text: "hello",
+  time: { created: DateTime.makeUnsafe(1_000) },
+})
+
+test("round trips the persisted message representation", async () => {
+  const row = SessionMessageRow.encode(message)
+
+  expect(row.id).toBe(message.id)
+  expect(row.type).toBe(message.type)
+  expect(row.data).toHaveProperty("text", message.text)
+  expect(row.data).toHaveProperty("time.created", 1_000)
+  expect(await Effect.runPromise(SessionMessageRow.decode(row))).toEqual(message)
+  expect(SessionMessageRow.decodeSync(row)).toEqual(message)
+})
+
+test("canonical columns override stale values in message data", () => {
+  const row = SessionMessageRow.encode(message)
+  const data = {
+    ...row.data,
+    id: SessionMessage.ID.make("msg_stale"),
+    type: "system" as const,
+  }
+
+  expect(SessionMessageRow.decodeSync({ ...row, data })).toEqual(message)
+})

packages/core/test/tool-shell.test.ts

@@ -27,6 +27,7 @@ import { SessionMessage } from "@opencode-ai/core/session/message"
 import { SessionStore } from "@opencode-ai/core/session/store"
 import { Permission } from "@opencode-ai/core/permission"
 import { PluginRuntime } from "@opencode-ai/core/plugin/runtime"
+import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor"
 import { Shell } from "@opencode-ai/core/shell"
 import { Shell as ShellSchema } from "@opencode-ai/schema/shell"
 import { ShellTool } from "@opencode-ai/core/tool/plugin/shell"
@@ -35,7 +36,7 @@ import { Tool } from "@opencode-ai/core/tool"
 import { tmpdir } from "./fixture/tmpdir"
 import { tempGlobalLayer } from "./fixture/global"
 import { testEffect } from "./lib/effect"
-import { toolIdentity, executeTool, toolDefinitions, waitForTool } from "./lib/tool"
+import { toolIdentity, executeTool, toolDefinitions } from "./lib/tool"
 
 const sessionID = Session.ID.make("ses_shell_tool_test")
 const sessionModel = Model.Ref.make({ id: Model.ID.make("test"), providerID: Provider.ID.make("test") })
@@ -195,8 +196,8 @@ const withSession = <A, E, R>(directory: string, body: (registry: Tool.Interface
     const locations = yield* LocationServiceMap.Service
     const locationLayer = locations.get(location)
     return yield* Effect.gen(function* () {
+      yield* (yield* PluginSupervisor.Service).flush
       const registry = yield* Tool.Service
-      yield* waitForTool(registry, ShellTool.name)
       return yield* body(registry)
     }).pipe(Effect.provide(locationLayer), Effect.ensuring(locations.invalidate(location)))
   })