@open-mercato/ai-assistant 0.4.11-develop.2384.32517eccbc → 0.4.11-develop.2516.30653cfe18

package/src/modules/ai_assistant/lib/__tests__/opencode-client.test.ts

@@ -0,0 +1,76 @@
+import { OpenCodeClient } from '../opencode-client'
+
+describe('OpenCodeClient.subscribeToEvents', () => {
+  const originalFetch = global.fetch
+  let originalSseEnv: string | undefined
+
+  beforeEach(() => {
+    originalSseEnv = process.env.OPENCODE_SSE_CONNECT_TIMEOUT_MS
+    process.env.OPENCODE_SSE_CONNECT_TIMEOUT_MS = '25'
+  })
+
+  afterEach(() => {
+    global.fetch = originalFetch
+    if (originalSseEnv === undefined) {
+      delete process.env.OPENCODE_SSE_CONNECT_TIMEOUT_MS
+    } else {
+      process.env.OPENCODE_SSE_CONNECT_TIMEOUT_MS = originalSseEnv
+    }
+  })
+
+  const waitFor = async (predicate: () => boolean, timeoutMs = 500): Promise<void> => {
+    const deadline = Date.now() + timeoutMs
+    while (!predicate()) {
+      if (Date.now() > deadline) throw new Error('waitFor: predicate never became true')
+      await new Promise((r) => setTimeout(r, 10))
+    }
+  }
+
+  it('invokes onError with the connect-timeout reason when the deadline elapses before the SSE handshake', async () => {
+    global.fetch = jest.fn((_input, init) => {
+      return new Promise((_resolve, reject) => {
+        const signal = (init as RequestInit | undefined)?.signal
+        if (!signal) return
+        signal.addEventListener('abort', () => {
+          const err = new Error('Aborted')
+          ;(err as Error & { name: string }).name = 'AbortError'
+          reject(err)
+        })
+      })
+    }) as unknown as typeof fetch
+
+    const client = new OpenCodeClient({ baseUrl: 'http://opencode.local' })
+    const onError = jest.fn()
+
+    client.subscribeToEvents(() => {}, onError)
+
+    await waitFor(() => onError.mock.calls.length > 0)
+
+    expect(onError).toHaveBeenCalledTimes(1)
+    const err = onError.mock.calls[0][0] as Error
+    expect(err.message).toMatch(/OpenCode SSE connection timed out after \d+ms/)
+  })
+
+  it('does not invoke onError when the caller disposes the stream before it connects', async () => {
+    global.fetch = jest.fn((_input, init) => {
+      return new Promise((_resolve, reject) => {
+        const signal = (init as RequestInit | undefined)?.signal
+        if (!signal) return
+        signal.addEventListener('abort', () => {
+          const err = new Error('Aborted')
+          ;(err as Error & { name: string }).name = 'AbortError'
+          reject(err)
+        })
+      })
+    }) as unknown as typeof fetch
+
+    const client = new OpenCodeClient({ baseUrl: 'http://opencode.local' })
+    const onError = jest.fn()
+
+    const dispose = client.subscribeToEvents(() => {}, onError)
+    dispose()
+    await new Promise((r) => setTimeout(r, 10))
+
+    expect(onError).not.toHaveBeenCalled()
+  })
+})

package/src/modules/ai_assistant/lib/api-discovery-tools.ts

@@ -16,6 +16,15 @@ import {
   searchEndpoints,
   simplifyRequestBodySchema,
 } from './api-endpoint-index'
+import { fetchWithTimeout, resolveTimeoutMs } from '@open-mercato/shared/lib/http/fetchWithTimeout'
+
+const DEFAULT_AI_API_REQUEST_TIMEOUT_MS = 30_000
+
+function resolveAiApiRequestTimeoutMs(): number {
+  const raw = process.env.AI_API_REQUEST_TIMEOUT_MS
+  const parsed = raw ? Number.parseInt(raw, 10) : undefined
+  return resolveTimeoutMs(parsed, DEFAULT_AI_API_REQUEST_TIMEOUT_MS)
+}
 
 /**
  * Load API discovery tools into the registry
@@ -194,10 +203,11 @@ Confirm with user before POST/PUT/DELETE operations.`,
 
         // Execute request
         try {
-          const response = await fetch(url, {
+          const response = await fetchWithTimeout(url, {
             method,
             headers,
             body: requestBody ? JSON.stringify(requestBody) : undefined,
+            timeoutMs: resolveAiApiRequestTimeoutMs(),
           })
 
           const responseText = await response.text()

package/src/modules/ai_assistant/lib/api-endpoint-index.ts

@@ -9,6 +9,7 @@ import { buildOpenApiDocument } from '@open-mercato/shared/lib/openapi'
 import type { Module } from '@open-mercato/shared/modules/registry'
 import type { SearchService } from '@open-mercato/search/service'
 import type { IndexableRecord } from '@open-mercato/search/types'
+import { fetchWithTimeout, resolveTimeoutMs } from '@open-mercato/shared/lib/http/fetchWithTimeout'
 import {
   API_ENDPOINT_ENTITY_ID,
   GLOBAL_TENANT_ID,
@@ -17,6 +18,14 @@ import {
   computeEndpointsChecksum,
 } from './api-endpoint-index-config'
 
+const DEFAULT_OPENAPI_FETCH_TIMEOUT_MS = 10_000
+
+function resolveOpenapiFetchTimeoutMs(): number {
+  const raw = process.env.AI_OPENAPI_FETCH_TIMEOUT_MS
+  const parsed = raw ? Number.parseInt(raw, 10) : undefined
+  return resolveTimeoutMs(parsed, DEFAULT_OPENAPI_FETCH_TIMEOUT_MS)
+}
+
 /**
  * Indexed API endpoint structure
  */
@@ -208,7 +217,9 @@ async function loadRawOpenApiSpec(): Promise<OpenApiDocument | null> {
     'http://localhost:3000'
 
   try {
-    const response = await fetch(`${baseUrl}/api/docs/openapi`)
+    const response = await fetchWithTimeout(`${baseUrl}/api/docs/openapi`, {
+      timeoutMs: resolveOpenapiFetchTimeoutMs(),
+    })
     if (response.ok) {
       const doc = (await response.json()) as OpenApiDocument
       console.error('[API Index] Raw OpenAPI spec fetched via HTTP')
@@ -320,7 +331,9 @@ async function parseApiEndpointsFromHttp(): Promise<ApiEndpoint[]> {
 
   try {
     console.error(`[API Index] Fetching OpenAPI spec from ${openApiUrl}...`)
-    const response = await fetch(openApiUrl)
+    const response = await fetchWithTimeout(openApiUrl, {
+      timeoutMs: resolveOpenapiFetchTimeoutMs(),
+    })
 
     if (!response.ok) {
       console.error(`[API Index] Failed to fetch OpenAPI spec: ${response.status} ${response.statusText}`)

package/src/modules/ai_assistant/lib/codemode-tools.ts

@@ -28,6 +28,15 @@ import {
   buildSearchLabel,
   incrementToolCallCount,
 } from './session-memory'
+import { fetchWithTimeout, resolveTimeoutMs } from '@open-mercato/shared/lib/http/fetchWithTimeout'
+
+const DEFAULT_AI_API_REQUEST_TIMEOUT_MS = 30_000
+
+function resolveAiApiRequestTimeoutMs(): number {
+  const raw = process.env.AI_API_REQUEST_TIMEOUT_MS
+  const parsed = raw ? Number.parseInt(raw, 10) : undefined
+  return resolveTimeoutMs(parsed, DEFAULT_AI_API_REQUEST_TIMEOUT_MS)
+}
 
 /**
  * Cached spec object combining OpenAPI paths + entity schemas.
@@ -823,10 +832,11 @@ function createApiRequestFn(
     if (ctx.organizationId) headers['X-Organization-Id'] = ctx.organizationId
 
     // Execute request using host fetch (not sandbox)
-    const response = await globalThis.fetch(url, {
+    const response = await fetchWithTimeout(url, {
       method: normalizedMethod,
       headers,
       body: requestBody ? JSON.stringify(requestBody) : undefined,
+      timeoutMs: resolveAiApiRequestTimeoutMs(),
     })
 
     const responseText = await response.text()

package/src/modules/ai_assistant/lib/opencode-client.ts

@@ -5,6 +5,16 @@
  * OpenCode is used as an AI agent that can execute MCP tools.
  */
 import { readJsonSafe } from '@open-mercato/shared/lib/http/readJsonSafe'
+import { fetchWithTimeout, resolveTimeoutMs } from '@open-mercato/shared/lib/http/fetchWithTimeout'
+
+const DEFAULT_OPENCODE_REQUEST_TIMEOUT_MS = 30_000
+const DEFAULT_OPENCODE_SSE_CONNECT_TIMEOUT_MS = 15_000
+
+function resolveOpencodeTimeoutMs(envVar: string, fallback: number): number {
+  const raw = process.env[envVar]
+  const parsed = raw ? Number.parseInt(raw, 10) : undefined
+  return resolveTimeoutMs(parsed, fallback)
+}
 
 export type OpenCodeClientConfig = {
   baseUrl: string
@@ -132,6 +142,22 @@ export class OpenCodeClient {
     onError?: (error: Error) => void
   ): () => void {
     const controller = new AbortController()
+    const connectTimeoutMs = resolveOpencodeTimeoutMs(
+      'OPENCODE_SSE_CONNECT_TIMEOUT_MS',
+      DEFAULT_OPENCODE_SSE_CONNECT_TIMEOUT_MS,
+    )
+    const connectTimeoutReason = new Error(
+      `OpenCode SSE connection timed out after ${connectTimeoutMs}ms`,
+    )
+    let connectTimer: ReturnType<typeof setTimeout> | null = setTimeout(() => {
+      controller.abort(connectTimeoutReason)
+    }, connectTimeoutMs)
+    const clearConnectTimer = () => {
+      if (connectTimer !== null) {
+        clearTimeout(connectTimer)
+        connectTimer = null
+      }
+    }
 
     const connect = async () => {
       try {
@@ -142,6 +168,7 @@ export class OpenCodeClient {
           },
           signal: controller.signal,
         })
+        clearConnectTimer()
 
         if (!res.ok || !res.body) {
           throw new Error(`SSE connection failed: ${res.status}`)
@@ -173,23 +200,33 @@ export class OpenCodeClient {
           }
         }
       } catch (error) {
-        if ((error as Error).name !== 'AbortError') {
-          onError?.(error as Error)
+        clearConnectTimer()
+        if ((error as Error).name === 'AbortError') {
+          const reason = (controller.signal as AbortSignal & { reason?: unknown }).reason
+          if (reason === connectTimeoutReason) {
+            onError?.(connectTimeoutReason)
+          }
+          return
         }
+        onError?.(error as Error)
       }
     }
 
     connect()
 
-    return () => controller.abort()
+    return () => {
+      clearConnectTimer()
+      controller.abort()
+    }
   }
 
   /**
    * Check OpenCode server health.
    */
   async health(): Promise<OpenCodeHealth> {
-    const res = await fetch(`${this.baseUrl}/global/health`, {
+    const res = await fetchWithTimeout(`${this.baseUrl}/global/health`, {
       headers: this.headers,
+      timeoutMs: resolveOpencodeTimeoutMs('OPENCODE_REQUEST_TIMEOUT_MS', DEFAULT_OPENCODE_REQUEST_TIMEOUT_MS),
     })
 
     if (!res.ok) {
@@ -205,8 +242,9 @@ export class OpenCodeClient {
    * Get MCP server connection status.
    */
   async mcpStatus(): Promise<OpenCodeMcpStatus> {
-    const res = await fetch(`${this.baseUrl}/mcp`, {
+    const res = await fetchWithTimeout(`${this.baseUrl}/mcp`, {
       headers: this.headers,
+      timeoutMs: resolveOpencodeTimeoutMs('OPENCODE_REQUEST_TIMEOUT_MS', DEFAULT_OPENCODE_REQUEST_TIMEOUT_MS),
     })
 
     if (!res.ok) {
@@ -222,10 +260,11 @@ export class OpenCodeClient {
    * Create a new conversation session.
    */
   async createSession(): Promise<OpenCodeSession> {
-    const res = await fetch(`${this.baseUrl}/session`, {
+    const res = await fetchWithTimeout(`${this.baseUrl}/session`, {
       method: 'POST',
       headers: this.headers,
       body: JSON.stringify({}),
+      timeoutMs: resolveOpencodeTimeoutMs('OPENCODE_REQUEST_TIMEOUT_MS', DEFAULT_OPENCODE_REQUEST_TIMEOUT_MS),
     })
 
     if (!res.ok) {
@@ -242,8 +281,9 @@ export class OpenCodeClient {
    * Get an existing session by ID.
    */
   async getSession(sessionId: string): Promise<OpenCodeSession> {
-    const res = await fetch(`${this.baseUrl}/session/${sessionId}`, {
+    const res = await fetchWithTimeout(`${this.baseUrl}/session/${sessionId}`, {
       headers: this.headers,
+      timeoutMs: resolveOpencodeTimeoutMs('OPENCODE_REQUEST_TIMEOUT_MS', DEFAULT_OPENCODE_REQUEST_TIMEOUT_MS),
     })
 
     if (!res.ok) {
@@ -273,10 +313,14 @@ export class OpenCodeClient {
       body.model = options.model
     }
 
-    const res = await fetch(`${this.baseUrl}/session/${sessionId}/message`, {
+    const res = await fetchWithTimeout(`${this.baseUrl}/session/${sessionId}/message`, {
       method: 'POST',
       headers: this.headers,
       body: JSON.stringify(body),
+      timeoutMs: resolveOpencodeTimeoutMs(
+        'OPENCODE_SEND_MESSAGE_TIMEOUT_MS',
+        resolveOpencodeTimeoutMs('OPENCODE_REQUEST_TIMEOUT_MS', DEFAULT_OPENCODE_REQUEST_TIMEOUT_MS),
+      ),
     })
 
     if (!res.ok) {
@@ -293,10 +337,11 @@ export class OpenCodeClient {
    * Set authentication credentials for a provider.
    */
   async setAuth(providerId: string, apiKey: string): Promise<void> {
-    const res = await fetch(`${this.baseUrl}/auth/${providerId}`, {
+    const res = await fetchWithTimeout(`${this.baseUrl}/auth/${providerId}`, {
       method: 'PUT',
       headers: this.headers,
       body: JSON.stringify({ type: 'api', key: apiKey }),
+      timeoutMs: resolveOpencodeTimeoutMs('OPENCODE_REQUEST_TIMEOUT_MS', DEFAULT_OPENCODE_REQUEST_TIMEOUT_MS),
     })
 
     if (!res.ok) {
@@ -308,8 +353,9 @@ export class OpenCodeClient {
    * Get current configuration.
    */
   async getConfig(): Promise<Record<string, unknown>> {
-    const res = await fetch(`${this.baseUrl}/config`, {
+    const res = await fetchWithTimeout(`${this.baseUrl}/config`, {
       headers: this.headers,
+      timeoutMs: resolveOpencodeTimeoutMs('OPENCODE_REQUEST_TIMEOUT_MS', DEFAULT_OPENCODE_REQUEST_TIMEOUT_MS),
     })
 
     if (!res.ok) {
@@ -325,8 +371,9 @@ export class OpenCodeClient {
    * Get pending questions that need user response.
    */
   async getPendingQuestions(): Promise<OpenCodeQuestion[]> {
-    const res = await fetch(`${this.baseUrl}/question`, {
+    const res = await fetchWithTimeout(`${this.baseUrl}/question`, {
       headers: this.headers,
+      timeoutMs: resolveOpencodeTimeoutMs('OPENCODE_REQUEST_TIMEOUT_MS', DEFAULT_OPENCODE_REQUEST_TIMEOUT_MS),
     })
 
     if (!res.ok) {
@@ -366,10 +413,11 @@ export class OpenCodeClient {
 
     console.log('[OpenCode Client] Answering question', questionId, 'with body:', JSON.stringify(body))
 
-    const res = await fetch(`${this.baseUrl}/question/${questionId}/reply`, {
+    const res = await fetchWithTimeout(`${this.baseUrl}/question/${questionId}/reply`, {
       method: 'POST',
       headers: this.headers,
       body: JSON.stringify(body),
+      timeoutMs: resolveOpencodeTimeoutMs('OPENCODE_REQUEST_TIMEOUT_MS', DEFAULT_OPENCODE_REQUEST_TIMEOUT_MS),
     })
 
     const responseText = await res.text()
@@ -386,9 +434,10 @@ export class OpenCodeClient {
   async rejectQuestion(questionId: string): Promise<void> {
     console.log('[OpenCode Client] Rejecting question', questionId)
 
-    const res = await fetch(`${this.baseUrl}/question/${questionId}/reject`, {
+    const res = await fetchWithTimeout(`${this.baseUrl}/question/${questionId}/reject`, {
       method: 'POST',
       headers: this.headers,
+      timeoutMs: resolveOpencodeTimeoutMs('OPENCODE_REQUEST_TIMEOUT_MS', DEFAULT_OPENCODE_REQUEST_TIMEOUT_MS),
     })
 
     if (!res.ok) {
@@ -403,8 +452,9 @@ export class OpenCodeClient {
    */
   async getSessionStatus(sessionId: string): Promise<{ status: string; questionId?: string }> {
     try {
-      const res = await fetch(`${this.baseUrl}/session/${sessionId}/status`, {
+      const res = await fetchWithTimeout(`${this.baseUrl}/session/${sessionId}/status`, {
         headers: this.headers,
+        timeoutMs: resolveOpencodeTimeoutMs('OPENCODE_REQUEST_TIMEOUT_MS', DEFAULT_OPENCODE_REQUEST_TIMEOUT_MS),
       })
 
       if (res.ok) {