@swarmclawai/swarmclaw 0.7.2 → 0.7.4

package/src/lib/server/autonomy-runtime.test.ts

@@ -0,0 +1,341 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { describe, it } from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../..')
+
+function runWithTempDataDir(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-autonomy-test-'))
+  try {
+    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        DATA_DIR: tempDir,
+        WORKSPACE_DIR: path.join(tempDir, 'workspace'),
+      },
+      encoding: 'utf-8',
+    })
+    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    const lines = (result.stdout || '')
+      .trim()
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+    const jsonLine = [...lines].reverse().find((line) => line.startsWith('{'))
+    return JSON.parse(jsonLine || '{}')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+describe('browser session persistence', () => {
+  it('isolates browser profiles by default and stores observations', () => {
+    const output = runWithTempDataDir(`
+      const storage = (await import('./src/lib/server/storage.ts')).default
+      const browserState = (await import('./src/lib/server/browser-state.ts')).default
+
+      const now = Date.now()
+      storage.saveSessions({
+        parent: {
+          id: 'parent',
+          name: 'parent',
+          cwd: process.cwd(),
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          claudeSessionId: null,
+          messages: [],
+          createdAt: now,
+          lastActiveAt: now,
+          browserProfileId: 'shared-profile',
+        },
+        child: {
+          id: 'child',
+          name: 'child',
+          cwd: process.cwd(),
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          claudeSessionId: null,
+          messages: [],
+          createdAt: now,
+          lastActiveAt: now,
+          parentSessionId: 'parent',
+        },
+      })
+
+      const resolved = browserState.ensureSessionBrowserProfileId('child')
+      browserState.upsertBrowserSessionRecord({ sessionId: 'child', status: 'active', lastAction: 'navigate' })
+      browserState.recordBrowserObservation('child', {
+        capturedAt: now,
+        url: 'https://example.com',
+        title: 'Example',
+        textPreview: 'hello world',
+        links: [],
+        forms: [],
+        tables: [],
+      })
+      browserState.markBrowserSessionClosed('child', 'finished')
+
+      console.log(JSON.stringify({
+        resolved,
+        session: storage.loadSessions().child,
+        state: browserState.loadBrowserSessionRecord('child'),
+      }))
+    `)
+
+    assert.equal(output.resolved.profileId, 'child')
+    assert.equal(output.resolved.inheritedFromSessionId, null)
+    assert.equal(output.session.browserProfileId, 'child')
+    assert.equal(output.state.currentUrl, 'https://example.com')
+    assert.equal(output.state.pageTitle, 'Example')
+    assert.equal(output.state.status, 'error')
+    assert.equal(output.state.lastError, 'finished')
+  })
+
+  it('isolates subagent browser profiles by default unless sharing is explicitly requested', () => {
+    const output = runWithTempDataDir(`
+      const mod = await import('./src/lib/server/session-tools/subagent.ts')
+      const { resolveSubagentBrowserProfileId } = mod.default || mod['module.exports'] || mod
+
+      const parent = {
+        id: 'parent-session',
+        browserProfileId: 'shared-profile',
+      }
+
+      console.log(JSON.stringify({
+        isolated: resolveSubagentBrowserProfileId(parent, 'child-session', false),
+        shared: resolveSubagentBrowserProfileId(parent, 'child-session', true),
+      }))
+    `)
+
+    assert.equal(output.isolated, 'child-session')
+    assert.equal(output.shared, 'shared-profile')
+  })
+})
+
+describe('durable watch jobs', () => {
+  it('triggers time, file, task, http, and webhook watches', () => {
+    const output = runWithTempDataDir(`
+      import fs from 'node:fs'
+      import path from 'node:path'
+      const storage = (await import('./src/lib/server/storage.ts')).default
+      const watchJobs = (await import('./src/lib/server/watch-jobs.ts')).default
+
+      const watchFile = path.join(process.env.DATA_DIR, 'watch.txt')
+      fs.writeFileSync(watchFile, 'build succeeded')
+
+      storage.saveTasks({
+        task_done: {
+          id: 'task_done',
+          title: 'Done',
+          status: 'completed',
+          result: 'ok',
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+        },
+      })
+
+      globalThis.fetch = async () => new Response('service healthy', { status: 200 })
+
+      const timeJob = await watchJobs.createWatchJob({
+        type: 'time',
+        resumeMessage: 'time wake',
+        target: {},
+        condition: {},
+        runAt: Date.now() - 1000,
+      })
+      const fileJob = await watchJobs.createWatchJob({
+        type: 'file',
+        resumeMessage: 'file wake',
+        target: { path: watchFile },
+        condition: { containsText: 'succeeded' },
+      })
+      const taskJob = await watchJobs.createWatchJob({
+        type: 'task',
+        resumeMessage: 'task wake',
+        target: { taskId: 'task_done' },
+        condition: { statusIn: ['completed'] },
+      })
+      const httpJob = await watchJobs.createWatchJob({
+        type: 'http',
+        resumeMessage: 'http wake',
+        target: { url: 'https://example.com/health' },
+        condition: { regex: 'healthy', threshold: 0 },
+      })
+      const webhookJob = await watchJobs.createWatchJob({
+        type: 'webhook',
+        resumeMessage: 'webhook wake',
+        target: { webhookId: 'wh_test' },
+        condition: { event: 'deploy.finished' },
+      })
+
+      const summary = await watchJobs.processDueWatchJobs(Date.now())
+      const webhookTriggered = watchJobs.triggerWebhookWatchJobs({
+        webhookId: 'wh_test',
+        event: 'deploy.finished',
+        payloadPreview: '{"ok":true}',
+      })
+
+      console.log(JSON.stringify({
+        summary,
+        time: watchJobs.getWatchJob(timeJob.id),
+        file: watchJobs.getWatchJob(fileJob.id),
+        task: watchJobs.getWatchJob(taskJob.id),
+        http: watchJobs.getWatchJob(httpJob.id),
+        webhook: watchJobs.getWatchJob(webhookJob.id),
+        webhookTriggeredCount: webhookTriggered.length,
+      }))
+    `)
+
+    assert.equal(output.summary.triggered >= 4, true)
+    assert.equal(output.time.status, 'triggered')
+    assert.equal(output.file.status, 'triggered')
+    assert.equal(output.task.status, 'triggered')
+    assert.equal(output.http.status, 'triggered')
+    assert.equal(output.http.result.regex, 'healthy')
+    assert.equal(output.webhook.status, 'triggered')
+    assert.equal(output.webhookTriggeredCount, 1)
+  })
+
+  it('triggers mailbox and approval waits from human-loop events', () => {
+    const output = runWithTempDataDir(`
+      const storage = (await import('./src/lib/server/storage.ts')).default
+      const watchJobs = (await import('./src/lib/server/watch-jobs.ts')).default
+      const mailboxMod = await import('./src/lib/server/session-mailbox.ts')
+      const approvalsMod = await import('./src/lib/server/approvals.ts')
+      const mailbox = mailboxMod.default || mailboxMod
+      const approvals = approvalsMod.default || approvalsMod
+
+      const now = Date.now()
+      storage.saveSessions({
+        human: {
+          id: 'human',
+          name: 'Human Session',
+          cwd: process.cwd(),
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          claudeSessionId: null,
+          messages: [],
+          mailbox: [],
+          createdAt: now,
+          lastActiveAt: now,
+        },
+      })
+
+      const mailboxJob = await watchJobs.createWatchJob({
+        type: 'mailbox',
+        resumeMessage: 'mailbox wake',
+        target: { sessionId: 'human' },
+        condition: { type: 'human_reply', correlationId: 'corr-1' },
+      })
+
+      const approval = approvals.requestApproval({
+        category: 'human_loop',
+        sessionId: 'human',
+        title: 'Approve deployment',
+        data: { env: 'prod' },
+      })
+
+      const approvalJob = await watchJobs.createWatchJob({
+        type: 'approval',
+        resumeMessage: 'approval wake',
+        target: { approvalId: approval.id },
+        condition: { statusIn: ['approved'] },
+      })
+
+      const envelope = mailbox.sendMailboxEnvelope({
+        toSessionId: 'human',
+        type: 'human_reply',
+        payload: 'ship it',
+        correlationId: 'corr-1',
+      })
+
+      await approvals.submitDecision(approval.id, true)
+      await new Promise((resolve) => setTimeout(resolve, 25))
+
+      console.log(JSON.stringify({
+        envelope,
+        mailboxJob: watchJobs.getWatchJob(mailboxJob.id),
+        approvalJob: watchJobs.getWatchJob(approvalJob.id),
+        approval: storage.loadApprovals()[approval.id],
+        mailboxState: storage.loadSessions().human.mailbox,
+      }))
+    `)
+
+    assert.equal(output.envelope.type, 'human_reply')
+    assert.equal(output.mailboxJob.status, 'triggered')
+    assert.equal(output.mailboxJob.result.type, 'human_reply')
+    assert.equal(output.approvalJob.status, 'triggered')
+    assert.equal(output.approvalJob.result.status, 'approved')
+    assert.equal(output.approval.status, 'approved')
+    assert.equal(Array.isArray(output.mailboxState), true)
+    assert.equal(output.mailboxState.length, 1)
+  })
+})
+
+describe('delegation jobs', () => {
+  it('preserves cancellation and recovers stale jobs', () => {
+    const output = runWithTempDataDir(`
+      const delegationJobs = (await import('./src/lib/server/delegation-jobs.ts')).default
+      const storage = (await import('./src/lib/server/storage.ts')).default
+
+      let cancelledCalls = 0
+      const cancelledJob = delegationJobs.createDelegationJob({
+        kind: 'delegate',
+        backend: 'codex',
+        parentSessionId: 'session-1',
+        task: 'cancel me',
+      })
+      delegationJobs.startDelegationJob(cancelledJob.id, { backend: 'codex' })
+      delegationJobs.registerDelegationRuntime(cancelledJob.id, {
+        cancel: () => { cancelledCalls += 1 },
+      })
+      delegationJobs.cancelDelegationJob(cancelledJob.id)
+      delegationJobs.completeDelegationJob(cancelledJob.id, 'should not override')
+      delegationJobs.failDelegationJob(cancelledJob.id, 'should also not override')
+
+      const completedJob = delegationJobs.createDelegationJob({
+        kind: 'subagent',
+        parentSessionId: 'session-1',
+        task: 'complete me',
+      })
+      delegationJobs.startDelegationJob(completedJob.id, { childSessionId: 'session-2' })
+      delegationJobs.completeDelegationJob(completedJob.id, 'done')
+
+      const staleJob = delegationJobs.createDelegationJob({
+        kind: 'delegate',
+        parentSessionId: 'session-1',
+        task: 'stale work',
+      })
+      delegationJobs.startDelegationJob(staleJob.id)
+      const staleRecord = delegationJobs.getDelegationJob(staleJob.id)
+      storage.upsertDelegationJob(staleJob.id, {
+        ...staleRecord,
+        updatedAt: Date.now() - 20 * 60_000,
+      })
+      const recovered = delegationJobs.recoverStaleDelegationJobs(15 * 60_000)
+
+      console.log(JSON.stringify({
+        cancelledCalls,
+        cancelled: delegationJobs.getDelegationJob(cancelledJob.id),
+        completed: delegationJobs.getDelegationJob(completedJob.id),
+        stale: delegationJobs.getDelegationJob(staleJob.id),
+        recovered,
+      }))
+    `)
+
+    assert.equal(output.cancelledCalls, 1)
+    assert.equal(output.cancelled.status, 'cancelled')
+    assert.equal(output.cancelled.result, null)
+    assert.equal(output.completed.status, 'completed')
+    assert.equal(output.completed.resultPreview, 'done')
+    assert.equal(output.stale.status, 'failed')
+    assert.equal(output.recovered, 1)
+  })
+})

package/src/lib/server/browser-state.test.ts

@@ -0,0 +1,118 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { after, before, describe, it } from 'node:test'
+
+const originalEnv = {
+  BROWSER_PROFILES_DIR: process.env.BROWSER_PROFILES_DIR,
+  DATA_DIR: process.env.DATA_DIR,
+  WORKSPACE_DIR: process.env.WORKSPACE_DIR,
+  SWARMCLAW_BUILD_MODE: process.env.SWARMCLAW_BUILD_MODE,
+}
+
+let tempDir = ''
+let browserState: typeof import('./browser-state')
+let storage: typeof import('./storage')
+
+function baseSession(id: string, extra: Record<string, unknown> = {}) {
+  const now = Date.now()
+  return {
+    id,
+    name: id,
+    cwd: process.cwd(),
+    user: 'tester',
+    provider: 'openai',
+    model: 'gpt-test',
+    claudeSessionId: null,
+    messages: [],
+    createdAt: now,
+    lastActiveAt: now,
+    ...extra,
+  }
+}
+
+before(async () => {
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-browser-state-'))
+  process.env.DATA_DIR = path.join(tempDir, 'data')
+  process.env.BROWSER_PROFILES_DIR = path.join(tempDir, 'browser-profiles')
+  process.env.WORKSPACE_DIR = path.join(tempDir, 'workspace')
+  process.env.SWARMCLAW_BUILD_MODE = '1'
+  browserState = await import('./browser-state')
+  storage = await import('./storage')
+})
+
+after(() => {
+  if (originalEnv.BROWSER_PROFILES_DIR === undefined) delete process.env.BROWSER_PROFILES_DIR
+  else process.env.BROWSER_PROFILES_DIR = originalEnv.BROWSER_PROFILES_DIR
+  if (originalEnv.DATA_DIR === undefined) delete process.env.DATA_DIR
+  else process.env.DATA_DIR = originalEnv.DATA_DIR
+  if (originalEnv.WORKSPACE_DIR === undefined) delete process.env.WORKSPACE_DIR
+  else process.env.WORKSPACE_DIR = originalEnv.WORKSPACE_DIR
+  if (originalEnv.SWARMCLAW_BUILD_MODE === undefined) delete process.env.SWARMCLAW_BUILD_MODE
+  else process.env.SWARMCLAW_BUILD_MODE = originalEnv.SWARMCLAW_BUILD_MODE
+  fs.rmSync(tempDir, { recursive: true, force: true })
+})
+
+describe('browser-state', () => {
+  it('defaults child sessions to their own browser profile id unless sharing is explicit', () => {
+    storage.saveSessions({
+      parent: baseSession('parent', { browserProfileId: 'shared-browser' }),
+      child: baseSession('child', { parentSessionId: 'parent' }),
+    })
+
+    const resolved = browserState.ensureSessionBrowserProfileId('child')
+    const sessions = storage.loadSessions()
+
+    assert.equal(resolved.profileId, 'child')
+    assert.equal(resolved.inheritedFromSessionId, null)
+    assert.equal(sessions.child.browserProfileId, 'child')
+  })
+
+  it('persists browser observations and close state', () => {
+    storage.saveSessions({
+      solo: baseSession('solo'),
+    })
+
+    const profile = browserState.ensureSessionBrowserProfileId('solo')
+    const profileDir = browserState.getBrowserProfileDir(profile.profileId)
+    assert.equal(fs.existsSync(profileDir), true)
+
+    browserState.upsertBrowserSessionRecord({
+      sessionId: 'solo',
+      profileId: profile.profileId,
+      profileDir,
+      status: 'active',
+      lastAction: 'browser_open',
+    })
+
+    browserState.recordBrowserObservation('solo', {
+      capturedAt: Date.now(),
+      url: 'https://example.com',
+      title: 'Example',
+      textPreview: 'Example domain',
+      links: [{ text: 'More information', href: 'https://iana.org/domains/example' }],
+      forms: [],
+      tables: [],
+      errors: [],
+    })
+
+    const observed = browserState.loadBrowserSessionRecord('solo')
+    assert.equal(observed?.currentUrl, 'https://example.com')
+    assert.equal(observed?.pageTitle, 'Example')
+    assert.equal(observed?.lastObservation?.links?.length, 1)
+
+    const closed = browserState.markBrowserSessionClosed('solo', 'browser crashed')
+    assert.equal(closed?.status, 'error')
+    assert.equal(closed?.lastError, 'browser crashed')
+
+    browserState.removeBrowserSessionRecord('solo')
+    assert.equal(browserState.loadBrowserSessionRecord('solo'), null)
+  })
+
+  it('creates profile directories under the configured data dir', () => {
+    const dir = browserState.getBrowserProfileDir('profile with spaces')
+    assert.equal(fs.existsSync(dir), true)
+    assert.equal(dir.startsWith(process.env.BROWSER_PROFILES_DIR!), true)
+  })
+})

package/src/lib/server/browser-state.ts

@@ -0,0 +1,123 @@
+import fs from 'fs'
+import path from 'path'
+import type { BrowserObservation, BrowserSessionRecord, Session } from '@/types'
+import { BROWSER_PROFILES_DIR } from './data-dir'
+import {
+  deleteBrowserSession,
+  loadBrowserSessions,
+  loadSessions,
+  saveSessions,
+  upsertBrowserSession,
+} from './storage'
+
+function sanitizeToken(value: string): string {
+  const trimmed = value.trim()
+  const safe = trimmed.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '')
+  return safe || 'default'
+}
+
+export function normalizeBrowserProfileId(value: unknown): string {
+  return typeof value === 'string' && value.trim() ? sanitizeToken(value) : ''
+}
+
+export function getBrowserProfileDir(profileId: string): string {
+  if (!fs.existsSync(BROWSER_PROFILES_DIR)) fs.mkdirSync(BROWSER_PROFILES_DIR, { recursive: true })
+  const dir = path.join(BROWSER_PROFILES_DIR, sanitizeToken(profileId))
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+  return dir
+}
+
+export function resolveBrowserProfileInfo(session: Session | Record<string, unknown> | null | undefined): {
+  profileId: string
+  inheritedFromSessionId: string | null
+} {
+  const current = session && typeof session === 'object' ? session as Record<string, unknown> : {}
+  const direct = normalizeBrowserProfileId(current.browserProfileId)
+  if (direct) return { profileId: direct, inheritedFromSessionId: null }
+
+  const sessionId = typeof current.id === 'string' && current.id.trim() ? current.id.trim() : 'default'
+  return { profileId: sanitizeToken(sessionId), inheritedFromSessionId: null }
+}
+
+export function ensureSessionBrowserProfileId(sessionId: string): {
+  profileId: string
+  inheritedFromSessionId: string | null
+} {
+  const sessions = loadSessions()
+  const session = sessions[sessionId]
+  if (!session) return { profileId: sanitizeToken(sessionId), inheritedFromSessionId: null }
+  const resolved = resolveBrowserProfileInfo(session)
+  if (session.browserProfileId !== resolved.profileId) {
+    session.browserProfileId = resolved.profileId
+    session.updatedAt = Date.now()
+    sessions[sessionId] = session
+    saveSessions(sessions)
+  }
+  return resolved
+}
+
+export function loadBrowserSessionRecord(sessionId: string): BrowserSessionRecord | null {
+  const all = loadBrowserSessions()
+  const raw = all[sessionId]
+  if (!raw || typeof raw !== 'object') return null
+  return raw as BrowserSessionRecord
+}
+
+function mergeArtifacts(current: BrowserSessionRecord['artifacts'], next: BrowserSessionRecord['artifacts']): BrowserSessionRecord['artifacts'] {
+  const merged = [...(current || []), ...(next || [])]
+  return merged.slice(-24)
+}
+
+export function upsertBrowserSessionRecord(input: Partial<BrowserSessionRecord> & { sessionId: string }): BrowserSessionRecord {
+  const now = Date.now()
+  const current = loadBrowserSessionRecord(input.sessionId)
+  const baseProfile = input.profileId
+    || current?.profileId
+    || ensureSessionBrowserProfileId(input.sessionId).profileId
+  const next: BrowserSessionRecord = {
+    id: input.sessionId,
+    sessionId: input.sessionId,
+    profileId: baseProfile,
+    profileDir: input.profileDir || current?.profileDir || getBrowserProfileDir(baseProfile),
+    status: input.status || current?.status || 'idle',
+    inheritedFromSessionId: input.inheritedFromSessionId ?? current?.inheritedFromSessionId ?? null,
+    currentUrl: input.currentUrl ?? current?.currentUrl ?? null,
+    pageTitle: input.pageTitle ?? current?.pageTitle ?? null,
+    activeTabIndex: input.activeTabIndex ?? current?.activeTabIndex ?? null,
+    tabs: input.tabs ?? current?.tabs ?? [],
+    lastAction: input.lastAction ?? current?.lastAction ?? null,
+    lastError: input.lastError ?? current?.lastError ?? null,
+    lastObservation: input.lastObservation ?? current?.lastObservation ?? null,
+    artifacts: mergeArtifacts(current?.artifacts, input.artifacts),
+    createdAt: current?.createdAt || input.createdAt || now,
+    updatedAt: now,
+    lastUsedAt: input.lastUsedAt || now,
+  }
+  upsertBrowserSession(next.id, next)
+  return next
+}
+
+export function recordBrowserObservation(sessionId: string, observation: BrowserObservation): BrowserSessionRecord {
+  return upsertBrowserSessionRecord({
+    sessionId,
+    currentUrl: observation.url ?? null,
+    pageTitle: observation.title ?? null,
+    activeTabIndex: observation.activeTabIndex ?? null,
+    tabs: observation.tabs ?? [],
+    lastObservation: observation,
+  })
+}
+
+export function markBrowserSessionClosed(sessionId: string, error?: string | null): BrowserSessionRecord | null {
+  const current = loadBrowserSessionRecord(sessionId)
+  if (!current) return null
+  return upsertBrowserSessionRecord({
+    sessionId,
+    status: error ? 'error' : 'closed',
+    lastError: error ?? null,
+  })
+}
+
+export function removeBrowserSessionRecord(sessionId: string): void {
+  deleteBrowserSession(sessionId)
+}

package/src/lib/server/build-llm.test.ts

@@ -0,0 +1,44 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { ChatOpenAI } from '@langchain/openai'
+import {
+  buildChatModel,
+  OPENAI_COMPAT_MODEL_MAX_RETRIES,
+  OPENAI_COMPAT_MODEL_TIMEOUT_MS,
+} from './build-llm'
+
+type ChatOpenAiInternals = ChatOpenAI & {
+  timeout?: number
+  caller?: { maxRetries?: number }
+  clientConfig?: { defaultHeaders?: Record<string, string> }
+}
+
+describe('buildChatModel', () => {
+  it('applies bounded timeout and disables internal retries for openai-compatible models', () => {
+    const llm = buildChatModel({
+      provider: 'openai',
+      model: 'gpt-4o',
+      apiKey: 'test-key',
+    })
+    const model = llm as ChatOpenAiInternals
+
+    assert.equal(llm instanceof ChatOpenAI, true)
+    assert.equal(model.timeout, OPENAI_COMPAT_MODEL_TIMEOUT_MS)
+    assert.equal(model.caller?.maxRetries, OPENAI_COMPAT_MODEL_MAX_RETRIES)
+  })
+
+  it('preserves openclaw headers while applying the same timeout policy', () => {
+    const llm = buildChatModel({
+      provider: 'openclaw',
+      model: 'gpt-4o',
+      apiKey: 'test-key',
+      apiEndpoint: 'https://example.com/v1',
+    })
+    const model = llm as ChatOpenAiInternals
+
+    assert.equal(llm instanceof ChatOpenAI, true)
+    assert.equal(model.timeout, OPENAI_COMPAT_MODEL_TIMEOUT_MS)
+    assert.equal(model.caller?.maxRetries, OPENAI_COMPAT_MODEL_MAX_RETRIES)
+    assert.deepEqual(model.clientConfig?.defaultHeaders, { 'Content-Type': 'text/plain' })
+  })
+})

package/src/lib/server/build-llm.ts

@@ -7,6 +7,8 @@ import { NON_LANGGRAPH_PROVIDER_IDS } from '../provider-sets'
 
 const OLLAMA_CLOUD_URL = 'https://ollama.com/v1'
 const OLLAMA_LOCAL_URL = 'http://localhost:11434/v1'
+export const OPENAI_COMPAT_MODEL_TIMEOUT_MS = 180_000
+export const OPENAI_COMPAT_MODEL_MAX_RETRIES = 0
 
 /**
  * Build a LangChain chat model from provider config.
@@ -50,12 +52,19 @@ export function buildChatModel(opts: {
     return new ChatOpenAI({
       model: model || 'qwen3.5',
       apiKey: apiKey || 'ollama',
+      timeout: OPENAI_COMPAT_MODEL_TIMEOUT_MS,
+      maxRetries: OPENAI_COMPAT_MODEL_MAX_RETRIES,
       configuration: { baseURL },
     })
   }
 
   // All other providers — OpenAI-compatible with their registered endpoint
-  const config: any = { model: model || 'gpt-4o', apiKey: apiKey || undefined }
+  const config: any = {
+    model: model || 'gpt-4o',
+    apiKey: apiKey || undefined,
+    timeout: OPENAI_COMPAT_MODEL_TIMEOUT_MS,
+    maxRetries: OPENAI_COMPAT_MODEL_MAX_RETRIES,
+  }
   // Map thinking level to reasoning_effort for OpenAI o-series models
   if (thinkingLevel && provider === 'openai' && /^o\d/.test(model || '')) {
     const effortMap = { minimal: 'low', low: 'low', medium: 'medium', high: 'high' }
@@ -70,9 +79,7 @@ export function buildChatModel(opts: {
       config.configuration.defaultHeaders = { 'Content-Type': 'text/plain' }
     }
   }
-  return config.configuration
-    ? new ChatOpenAI(config)
-    : new ChatOpenAI({ model: config.model, apiKey: config.apiKey })
+  return new ChatOpenAI(config)
 }
 
 function resolveApiKeyFromCredential(credentialId: string | null | undefined): string | null {