@swarmclawai/swarmclaw 0.7.7 → 0.8.0

package/src/lib/server/openclaw-gateway.test.ts

@@ -0,0 +1,131 @@
+import assert from 'node:assert/strict'
+import { afterEach, test } from 'node:test'
+
+import type { Agent, GatewayProfile } from '@/types'
+import {
+  encryptKey,
+  loadAgents,
+  loadCredentials,
+  loadGatewayProfiles,
+  saveAgents,
+  saveCredentials,
+  saveGatewayProfiles,
+} from './storage'
+import { resolveGatewayConfig } from './openclaw-gateway'
+
+const originalCredentials = loadCredentials()
+const originalGateways = loadGatewayProfiles()
+const originalAgents = loadAgents({ includeTrashed: true })
+
+afterEach(() => {
+  saveCredentials(originalCredentials)
+  saveGatewayProfiles(originalGateways)
+  saveAgents(originalAgents)
+})
+
+function saveGatewayCredential(id: string, token: string) {
+  const credentials = loadCredentials()
+  credentials[id] = {
+    id,
+    provider: 'openclaw',
+    name: `Credential ${id}`,
+    encryptedKey: encryptKey(token),
+    createdAt: Date.now(),
+  }
+  saveCredentials(credentials)
+}
+
+function saveGatewayProfile(profile: GatewayProfile) {
+  const gateways = loadGatewayProfiles()
+  gateways[profile.id] = profile
+  saveGatewayProfiles(gateways)
+}
+
+test('resolveGatewayConfig uses the gateway profile wsUrl and decrypted token', () => {
+  saveGatewayCredential('openclaw-cred-1', 'gateway-token-1')
+  saveGatewayProfile({
+    id: 'gateway-profile-1',
+    name: 'Gateway 1',
+    provider: 'openclaw',
+    endpoint: 'http://127.0.0.1:19161/v1',
+    wsUrl: 'ws://127.0.0.1:19161',
+    credentialId: 'openclaw-cred-1',
+    status: 'healthy',
+    notes: null,
+    tags: ['smoke'],
+    lastError: null,
+    lastCheckedAt: null,
+    lastModelCount: null,
+    discoveredHost: '127.0.0.1',
+    discoveredPort: 19161,
+    deployment: null,
+    stats: null,
+    isDefault: true,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  })
+
+  const resolved = resolveGatewayConfig({ profileId: 'gateway-profile-1' })
+  assert.deepEqual(resolved, {
+    key: 'profile:gateway-profile-1',
+    profileId: 'gateway-profile-1',
+    wsUrl: 'ws://127.0.0.1:19161',
+    token: 'gateway-token-1',
+  })
+})
+
+test('resolveGatewayConfig follows an OpenClaw agent route back to its gateway profile credential', () => {
+  saveGatewayCredential('openclaw-cred-2', 'gateway-token-2')
+  saveGatewayProfile({
+    id: 'gateway-profile-2',
+    name: 'Gateway 2',
+    provider: 'openclaw',
+    endpoint: 'http://127.0.0.1:19181/v1',
+    wsUrl: 'ws://127.0.0.1:19181',
+    credentialId: 'openclaw-cred-2',
+    status: 'healthy',
+    notes: null,
+    tags: ['smoke'],
+    lastError: null,
+    lastCheckedAt: null,
+    lastModelCount: null,
+    discoveredHost: '127.0.0.1',
+    discoveredPort: 19181,
+    deployment: {
+      method: 'local',
+      managedBy: 'swarmclaw',
+      useCase: 'local-dev',
+      localInstanceId: 'smoke-app-b',
+      localPort: 19181,
+    },
+    stats: null,
+    isDefault: true,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  })
+
+  const agents = loadAgents({ includeTrashed: true })
+  agents['openclaw-agent-1'] = {
+    id: 'openclaw-agent-1',
+    name: 'Gateway Agent',
+    description: '',
+    systemPrompt: '',
+    provider: 'openclaw',
+    model: 'default',
+    credentialId: null,
+    fallbackCredentialIds: [],
+    apiEndpoint: null,
+    gatewayProfileId: 'gateway-profile-2',
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  } as Agent
+  saveAgents(agents)
+
+  const resolved = resolveGatewayConfig({ agentId: 'openclaw-agent-1' })
+  assert.deepEqual(resolved, {
+    key: 'profile:gateway-profile-2',
+    profileId: 'gateway-profile-2',
+    wsUrl: 'ws://127.0.0.1:19181',
+    token: 'gateway-token-2',
+  })
+})

package/src/lib/server/openclaw-gateway.ts

@@ -1,6 +1,7 @@
 import { WebSocket } from 'ws'
 import { randomUUID } from 'crypto'
 import { wsConnect, buildOpenClawConnectParams } from '../providers/openclaw'
+import { deriveOpenClawWsUrl } from '@/lib/openclaw-endpoint'
 import { loadAgents, loadCredentials, decryptKey } from './storage'
 import { notify, notifyWithPayload } from './ws-hub'
 import { getGatewayProfile, getGatewayProfiles, resolvePrimaryAgentRoute } from './agent-runtime-config'
@@ -71,7 +72,7 @@ export function resolveGatewayConfig(target?: {
     return {
       key: `profile:${profile.id}`,
       profileId: profile.id,
-      wsUrl: profile.wsUrl ? normalizeWsUrl(profile.wsUrl) : normalizeWsUrl(profile.endpoint),
+      wsUrl: profile.wsUrl ? normalizeWsUrl(profile.wsUrl) : deriveOpenClawWsUrl(profile.endpoint),
       token: resolveTokenForCredential(profile.credentialId),
     }
   }
@@ -82,10 +83,15 @@ export function resolveGatewayConfig(target?: {
     const agent = agents[agentId]
     const route = resolvePrimaryAgentRoute(agent)
     if (route?.provider === 'openclaw') {
+      const routeProfile = route.gatewayProfileId ? getGatewayProfile(route.gatewayProfileId) : null
       return {
         key: route.gatewayProfileId ? `profile:${route.gatewayProfileId}` : `agent:${agentId}`,
         profileId: route.gatewayProfileId ?? null,
-        wsUrl: normalizeWsUrl(route.apiEndpoint || 'ws://127.0.0.1:18789'),
+        wsUrl: routeProfile?.wsUrl
+          ? normalizeWsUrl(routeProfile.wsUrl)
+          : route.apiEndpoint
+            ? deriveOpenClawWsUrl(route.apiEndpoint)
+            : 'ws://127.0.0.1:18789',
         token: resolveTokenForCredential(route.credentialId),
       }
     }
@@ -97,7 +103,7 @@ export function resolveGatewayConfig(target?: {
     return {
       key: `profile:${profile.id}`,
       profileId: profile.id,
-      wsUrl: profile.wsUrl ? normalizeWsUrl(profile.wsUrl) : normalizeWsUrl(profile.endpoint),
+      wsUrl: profile.wsUrl ? normalizeWsUrl(profile.wsUrl) : deriveOpenClawWsUrl(profile.endpoint),
       token: resolveTokenForCredential(profile.credentialId),
     }
   }
@@ -106,7 +112,7 @@ export function resolveGatewayConfig(target?: {
   for (const agent of Object.values(agents)) {
     if (agent?.provider !== 'openclaw') continue
     const wsUrl = agent.apiEndpoint
-      ? normalizeWsUrl(agent.apiEndpoint)
+      ? deriveOpenClawWsUrl(agent.apiEndpoint)
       : 'ws://127.0.0.1:18789'
     return {
       key: `agent:${agent.id}`,

package/src/lib/server/openclaw-health.test.ts

@@ -0,0 +1,35 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import { resolveOpenClawHttpProbeStatus } from './openclaw-health'
+
+test('treats missing /v1/models as optional when chat completions works', () => {
+  const result = resolveOpenClawHttpProbeStatus({
+    modelsStatus: 404,
+    chatStatus: 200,
+    warnings: ['OpenAI-compatible models endpoint failed: OpenClaw endpoint path is invalid (404).'],
+    warningHint: 'Point to the gateway root/ws URL and let SwarmClaw normalize it, or use an explicit /v1 endpoint.',
+  })
+
+  assert.equal(result.httpCompatible, true)
+  assert.equal(result.modelsEndpointOptional, true)
+  assert.equal(result.warning, undefined)
+  assert.equal(result.hint, undefined)
+})
+
+test('keeps chat failures as real warnings even when /v1/models is missing', () => {
+  const result = resolveOpenClawHttpProbeStatus({
+    modelsStatus: 404,
+    chatStatus: 500,
+    warnings: [
+      'OpenAI-compatible models endpoint failed: OpenClaw endpoint path is invalid (404).',
+      'OpenAI-compatible chat endpoint failed: OpenClaw endpoint returned HTTP 500.',
+    ],
+    warningHint: 'Ensure this is an OpenAI-compatible chat endpoint exposed by the OpenClaw gateway.',
+  })
+
+  assert.equal(result.httpCompatible, false)
+  assert.equal(result.modelsEndpointOptional, false)
+  assert.match(result.warning || '', /chat endpoint failed/i)
+  assert.equal(result.hint, 'Ensure this is an OpenAI-compatible chat endpoint exposed by the OpenClaw gateway.')
+})

package/src/lib/server/openclaw-health.ts

@@ -1,4 +1,5 @@
 import { deriveOpenClawWsUrl, normalizeOpenClawEndpoint } from '@/lib/openclaw-endpoint'
+import { wsConnect } from '@/lib/providers/openclaw'
 import { decryptKey, loadCredentials } from './storage'
 
 export interface OpenClawHealthInput {
@@ -13,20 +14,49 @@ export interface OpenClawHealthResult {
   ok: boolean
   endpoint: string
   wsUrl: string
+  wsConnected: boolean
+  httpCompatible: boolean | null
   authProvided: boolean
   model: string | null
   models: string[]
   modelsStatus: number | null
   chatStatus: number | null
+  message: string
   completionSample?: string
+  warning?: string
   error?: string
   hint?: string
 }
 
+export interface OpenClawHttpProbeStatus {
+  httpCompatible: boolean
+  warning?: string
+  hint?: string
+  modelsEndpointOptional: boolean
+}
+
+type JsonRecord = Record<string, unknown>
+
 function normalizeToken(value: unknown): string | null {
   return typeof value === 'string' && value.trim() ? value.trim() : null
 }
 
+function asRecord(value: unknown): JsonRecord | null {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as JsonRecord : null
+}
+
+function getErrorName(err: unknown): string | undefined {
+  if (err instanceof Error) return err.name
+  const record = asRecord(err)
+  return typeof record?.name === 'string' ? record.name : undefined
+}
+
+function getErrorMessage(err: unknown): string | undefined {
+  if (err instanceof Error) return err.message
+  const record = asRecord(err)
+  return typeof record?.message === 'string' ? record.message : undefined
+}
+
 function resolveCredentialToken(credentialId?: string | null): string | null {
   const id = normalizeToken(credentialId)
   if (!id) return null
@@ -40,21 +70,30 @@ function resolveCredentialToken(credentialId?: string | null): string | null {
   }
 }
 
-function extractModels(payload: any): string[] {
-  const models = Array.isArray(payload?.data) ? payload.data : []
+function extractModels(payload: unknown): string[] {
+  const payloadRecord = asRecord(payload)
+  const models = Array.isArray(payloadRecord?.data) ? payloadRecord.data : []
   return models
-    .map((item: any) => (typeof item?.id === 'string' ? item.id.trim() : ''))
+    .map((item) => {
+      const record = asRecord(item)
+      return typeof record?.id === 'string' ? record.id.trim() : ''
+    })
     .filter(Boolean)
 }
 
-function extractChatText(payload: any): string {
-  const content = payload?.choices?.[0]?.message?.content
+function extractChatText(payload: unknown): string {
+  const payloadRecord = asRecord(payload)
+  const choices = Array.isArray(payloadRecord?.choices) ? payloadRecord.choices : []
+  const firstChoice = asRecord(choices[0])
+  const message = asRecord(firstChoice?.message)
+  const content = message?.content
   if (typeof content === 'string') return content.trim()
   if (Array.isArray(content)) {
     return content
-      .map((block: any) => {
-        if (typeof block?.text === 'string') return block.text
-        if (typeof block?.content === 'string') return block.content
+      .map((block) => {
+        const record = asRecord(block)
+        if (typeof record?.text === 'string') return record.text
+        if (typeof record?.content === 'string') return record.content
         return ''
       })
       .join(' ')
@@ -87,9 +126,105 @@ function describeHttpError(status: number): { error: string; hint?: string } {
   }
 }
 
+function describeGatewayError(errorCode: string | undefined, message: string): { error: string; hint?: string } {
+  if (errorCode === 'AUTH_TOKEN_MISSING') {
+    return {
+      error: message || 'OpenClaw gateway requires a token.',
+      hint: 'Attach an OpenClaw credential or token before running the gateway health check.',
+    }
+  }
+  if (errorCode === 'AUTH_TOKEN_INVALID') {
+    return {
+      error: message || 'OpenClaw gateway rejected the supplied token.',
+      hint: 'Update the saved OpenClaw token or re-pair this gateway with a valid operator token.',
+    }
+  }
+  if (errorCode === 'PAIRING_REQUIRED') {
+    return {
+      error: message || 'OpenClaw gateway requires device pairing.',
+      hint: 'Approve this SwarmClaw device in the OpenClaw gateway before using it from the app.',
+    }
+  }
+  if (errorCode === 'DEVICE_AUTH_INVALID') {
+    return {
+      error: message || 'OpenClaw gateway rejected the saved device identity.',
+      hint: 'Re-pair this SwarmClaw device with the gateway or reset the saved device identity and try again.',
+    }
+  }
+  return {
+    error: message || 'Failed to connect to OpenClaw gateway.',
+    hint: 'Verify the OpenClaw gateway is running and reachable at this host/port.',
+  }
+}
+
+function pushIssue(issues: string[], next: string | undefined): void {
+  if (typeof next !== 'string') return
+  const value = next.trim()
+  if (!value) return
+  issues.push(value)
+}
+
+function isModelsEndpointWarning(issue: string): boolean {
+  return issue.startsWith('OpenAI-compatible models endpoint failed:')
+    || issue.startsWith('OpenAI-compatible models probe timed out')
+}
+
+export function resolveOpenClawHttpProbeStatus(input: {
+  modelsStatus: number | null
+  chatStatus: number | null
+  warnings: string[]
+  warningHint?: string
+}): OpenClawHttpProbeStatus {
+  const modelsOk = !!input.modelsStatus && input.modelsStatus >= 200 && input.modelsStatus < 300
+  const chatOk = !!input.chatStatus && input.chatStatus >= 200 && input.chatStatus < 300
+  const modelsEndpointOptional = chatOk && input.modelsStatus === 404
+  const filteredWarnings = modelsEndpointOptional
+    ? input.warnings.filter((issue) => !isModelsEndpointWarning(issue))
+    : input.warnings
+  const warning = filteredWarnings.join(' ') || undefined
+
+  return {
+    httpCompatible: chatOk && (modelsOk || modelsEndpointOptional),
+    warning,
+    hint: warning ? input.warningHint : undefined,
+    modelsEndpointOptional,
+  }
+}
+
+function summarizeOpenClawHealth(input: {
+  ok: boolean
+  models: string[]
+  modelsStatus: number | null
+  httpCompatible: boolean | null
+  modelsEndpointOptional?: boolean
+  warning?: string
+  error?: string
+}): string {
+  if (!input.ok) return input.error || 'OpenClaw gateway health check failed.'
+  const parts = ['Connected to OpenClaw gateway via WebSocket.']
+  if (input.modelsStatus && input.modelsStatus >= 200 && input.modelsStatus < 300) {
+    parts.push(
+      input.models.length > 0
+        ? `${input.models.length} model${input.models.length === 1 ? '' : 's'} visible.`
+        : 'HTTP models endpoint responded with no models.',
+    )
+  }
+  if (input.httpCompatible === true) {
+    if (input.modelsEndpointOptional) {
+      parts.push('OpenAI-compatible chat checks passed. This gateway does not advertise `/v1/models`, which is acceptable for OpenClaw.')
+    } else {
+      parts.push('OpenAI-compatible HTTP checks passed.')
+    }
+  } else if (input.warning) {
+    parts.push(input.warning)
+    parts.push('SwarmClaw can still use this gateway over WebSocket.')
+  }
+  return parts.join(' ')
+}
+
 function createTimeoutError(message: string): Error {
-  const timeoutErr = new Error(message)
-  ;(timeoutErr as any).name = 'TimeoutError'
+  const timeoutErr = new Error(message) as Error & { name: string }
+  timeoutErr.name = 'TimeoutError'
   return timeoutErr
 }
 
@@ -116,7 +251,7 @@ async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, onTimeout?
   }
 }
 
-async function fetchJsonWithTimeout(url: string, init: RequestInit, timeoutMs: number): Promise<{ response: Response; body: any }> {
+async function fetchJsonWithTimeout(url: string, init: RequestInit, timeoutMs: number): Promise<{ response: Response; body: unknown }> {
   const controller = new AbortController()
   try {
     const response = await withTimeout(
@@ -131,7 +266,7 @@ async function fetchJsonWithTimeout(url: string, init: RequestInit, timeoutMs: n
       () => controller.abort(),
       `Response read timed out after ${timeoutMs}ms`,
     )
-    let body: any = {}
+    let body: unknown = {}
     if (text) {
       try {
         body = JSON.parse(text)
@@ -140,8 +275,8 @@ async function fetchJsonWithTimeout(url: string, init: RequestInit, timeoutMs: n
       }
     }
     return { response, body }
-  } catch (err: any) {
-    if (err?.name === 'AbortError') throw createTimeoutError(`Request timed out after ${timeoutMs}ms`)
+  } catch (err: unknown) {
+    if (getErrorName(err) === 'AbortError') throw createTimeoutError(`Request timed out after ${timeoutMs}ms`)
     throw err
   }
 }
@@ -163,8 +298,31 @@ export async function probeOpenClawHealth(input: OpenClawHealthInput): Promise<O
   let modelsStatus: number | null = null
   let chatStatus: number | null = null
   let completionSample = ''
-  let lastError = ''
-  let lastHint: string | undefined
+  let warningHint: string | undefined
+  const warnings: string[] = []
+
+  const wsResult = await wsConnect(wsUrl, token || undefined, true, timeoutMs)
+  if (wsResult.ws) {
+    try { wsResult.ws.close() } catch { /* noop */ }
+  }
+  if (!wsResult.ok) {
+    const gatewayError = describeGatewayError(wsResult.errorCode, wsResult.message)
+    return {
+      ok: false,
+      endpoint,
+      wsUrl,
+      wsConnected: false,
+      httpCompatible: null,
+      authProvided,
+      model: null,
+      models: [],
+      modelsStatus: null,
+      chatStatus: null,
+      message: gatewayError.error,
+      error: gatewayError.error,
+      hint: gatewayError.hint,
+    }
+  }
 
   try {
     const { response: modelsRes, body } = await fetchJsonWithTimeout(`${endpoint}/models`, {
@@ -176,27 +334,17 @@ export async function probeOpenClawHealth(input: OpenClawHealthInput): Promise<O
       models = extractModels(body)
     } else {
       const err = describeHttpError(modelsRes.status)
-      lastError = err.error
-      lastHint = err.hint
-    }
-  } catch (err: any) {
-    if (err?.name === 'TimeoutError') {
-      lastError = `OpenClaw models probe timed out after ${timeoutMs}ms.`
-    } else {
-      lastError = err?.message || 'Failed to connect to OpenClaw endpoint.'
-    }
-    return {
-      ok: false,
-      endpoint,
-      wsUrl,
-      authProvided,
-      model: null,
-      models: [],
-      modelsStatus: null,
-      chatStatus: null,
-      error: lastError,
-      hint: 'Verify the OpenClaw gateway is running and reachable at this host/port.',
+      pushIssue(warnings, `OpenAI-compatible models endpoint failed: ${err.error}`)
+      warningHint = err.hint || warningHint
     }
+  } catch (err: unknown) {
+    pushIssue(
+      warnings,
+      getErrorName(err) === 'TimeoutError'
+        ? `OpenAI-compatible models probe timed out after ${timeoutMs}ms.`
+        : (getErrorMessage(err) || 'Failed to connect to the OpenAI-compatible models endpoint.'),
+    )
+    warningHint = 'The gateway is reachable, but the optional HTTP `/v1/models` endpoint did not respond normally.'
   }
 
   const model = normalizeToken(input.model) || models[0] || 'default'
@@ -216,30 +364,50 @@ export async function probeOpenClawHealth(input: OpenClawHealthInput): Promise<O
     chatStatus = chatRes.status
     if (!chatRes.ok) {
       const err = describeHttpError(chatRes.status)
-      lastError = err.error
-      lastHint = err.hint || lastHint
+      pushIssue(warnings, `OpenAI-compatible chat endpoint failed: ${err.error}`)
+      warningHint = err.hint || warningHint
     } else {
       completionSample = extractChatText(body).slice(0, 240)
     }
-  } catch (err: any) {
-    if (err?.name === 'TimeoutError') {
-      lastError = `OpenClaw chat probe timed out after ${timeoutMs}ms.`
-    } else {
-      lastError = err?.message || 'OpenClaw chat probe failed.'
-    }
+  } catch (err: unknown) {
+    pushIssue(
+      warnings,
+      getErrorName(err) === 'TimeoutError'
+        ? `OpenAI-compatible chat probe timed out after ${timeoutMs}ms.`
+        : (getErrorMessage(err) || 'OpenAI-compatible chat probe failed.'),
+    )
+    warningHint = warningHint || 'The gateway is reachable, but the optional HTTP `/v1/chat/completions` endpoint did not respond normally.'
   }
 
+  const http = resolveOpenClawHttpProbeStatus({
+    modelsStatus,
+    chatStatus,
+    warnings,
+    warningHint,
+  })
+  const message = summarizeOpenClawHealth({
+    ok: true,
+    models,
+    modelsStatus,
+    httpCompatible: http.httpCompatible,
+    modelsEndpointOptional: http.modelsEndpointOptional,
+    warning: http.warning,
+  })
+
   return {
-    ok: !!chatStatus && chatStatus >= 200 && chatStatus < 300,
+    ok: true,
     endpoint,
     wsUrl,
+    wsConnected: true,
+    httpCompatible: http.httpCompatible,
     authProvided,
     model,
     models,
     modelsStatus,
     chatStatus,
+    message,
     completionSample: completionSample || undefined,
-    error: lastError || undefined,
-    hint: lastHint,
+    warning: http.warning,
+    hint: http.hint,
   }
 }

package/src/lib/server/orchestrator-lg.ts

@@ -115,6 +115,7 @@ async function executeSubTaskViaCli(agent: Agent, task: string, parentSessionId:
       claudeCode: null,
       codex: null,
       opencode: null,
+      gemini: null,
     },
     messages: [],
     createdAt: Date.now(),
@@ -398,7 +399,7 @@ export async function executeLangGraphOrchestrator(
 
   const checkpointSaver = getCheckpointSaver()
   const isStrictMode = settings.capabilityPolicyMode === 'strict'
-  const approvalInterruptsEnabled = isStrictMode && settings.approvalsEnabled !== false
+  const approvalInterruptsEnabled = isStrictMode && settings.approvalsEnabled === true
   const allTools = [delegateTool, storeMemoryTool, searchMemoryTool, getSecretTool, commentOnTaskTool, createTaskTool, markCompleteTool]
   const llmWithTools = llm.bindTools(allTools)
   const toolNode = new ToolNode(allTools)
@@ -762,7 +763,7 @@ export async function resumeLangGraphOrchestrator(
   const checkpointSaver = getCheckpointSaver()
   const settings = loadSettings()
   const isStrictMode = settings.capabilityPolicyMode === 'strict'
-  const approvalInterruptsEnabled = isStrictMode && settings.approvalsEnabled !== false
+  const approvalInterruptsEnabled = isStrictMode && settings.approvalsEnabled === true
 
   const allTools = [delegateTool, storeMemoryTool, searchMemoryTool, getSecretTool, commentOnTaskTool, createTaskTool, markCompleteTool]
   const llmWithTools = llm.bindTools(allTools)

package/src/lib/server/orchestrator.ts

@@ -47,6 +47,7 @@ export function createOrchestratorSession(
       claudeCode: null,
       codex: null,
       opencode: null,
+      gemini: null,
     },
     messages: [] as any[],
     createdAt: Date.now(),
@@ -294,6 +295,7 @@ async function executeSubTask(
       claudeCode: null,
       codex: null,
       opencode: null,
+      gemini: null,
     },
     messages: [] as any[],
     createdAt: Date.now(),