@openchambery/web 1.19.22-beta.1 → 2.0.0-beta.3

package/server/lib/llm/catalog.test.js

@@ -76,62 +76,82 @@ describe('modelAcceptsImages', () => {
     expect(modelAcceptsImages({ attachment: true })).toBe(true)
     expect(modelAcceptsImages({ id: 'plain' })).toBe(false)
   })
+
+  it('accepts v2 list-shaped capabilities.input containing image', () => {
+    expect(modelAcceptsImages({
+      capabilities: { tools: true, input: ['text', 'image'], output: ['text'] },
+    })).toBe(true)
+    expect(modelAcceptsImages({
+      capabilities: { tools: true, input: ['text'], output: ['text'] },
+    })).toBe(false)
+  })
 })
 
 describe('projectConnectedModels', () => {
-  it('projects only connected providers', () => {
+  it('projects models from provider.list + model.list using ModelInfo.id as modelID', () => {
     const catalog = projectConnectedModels({
-      connected: ['openai'],
       providers: [
+        { id: 'openai', name: 'OpenAI' },
+        { id: 'anthropic', name: 'Anthropic' },
+      ],
+      models: [
         {
-          id: 'openai',
-          name: 'OpenAI',
-          models: {
-            'gpt-5.2': { id: 'gpt-5.2', name: 'GPT-5.2' },
-          },
+          id: 'gpt-5.2',
+          modelID: 'internal-gpt-pack',
+          providerID: 'openai',
+          name: 'GPT-5.2',
+          capabilities: { tools: true, input: ['text'], output: ['text'] },
         },
         {
-          id: 'anthropic',
-          name: 'Anthropic',
-          models: { 'claude-sonnet-4': { id: 'claude-sonnet-4', name: 'Claude' } },
+          id: 'claude-sonnet-4',
+          modelID: 'internal-claude',
+          providerID: 'anthropic',
+          name: 'Claude',
+          capabilities: { tools: true, input: ['text'], output: ['text'] },
         },
       ],
     })
     expect(catalog.models).toEqual([
       { providerID: 'openai', modelID: 'gpt-5.2', name: 'GPT-5.2', acceptsImages: false },
+      { providerID: 'anthropic', modelID: 'claude-sonnet-4', name: 'Claude', acceptsImages: false },
     ])
+    expect(catalog.connected).toEqual(['openai', 'anthropic'])
   })
 
-  it('marks vision from SDK capabilities and legacy modalities', () => {
+  it('marks vision from SDK capabilities, v2 list input, and legacy modalities', () => {
     const catalog = projectConnectedModels({
-      connected: ['openai', 'xai'],
       providers: [
+        { id: 'openai', name: 'OpenAI' },
+        { id: 'xai', name: 'xAI' },
+      ],
+      models: [
         {
-          id: 'openai',
-          name: 'OpenAI',
-          models: {
-            'gpt-4o': { id: 'gpt-4o', name: 'GPT-4o', modalities: { input: ['text', 'image'] } },
-            'deepseek-v4-flash': { id: 'deepseek-v4-flash', name: 'deepseek-v4-flash' },
-          },
+          id: 'gpt-4o',
+          modelID: 'pack-4o',
+          providerID: 'openai',
+          name: 'GPT-4o',
+          capabilities: { tools: true, input: ['text', 'image'], output: ['text'] },
         },
         {
-          id: 'xai',
-          name: 'xAI',
-          models: {
-            'grok-4.6': {
-              id: 'grok-4.6',
-              name: 'Grok 4.6',
-              // Authoritative SDK shape — no modalities.input array
-              capabilities: {
-                temperature: true,
-                reasoning: true,
-                attachment: true,
-                toolcall: true,
-                input: { text: true, audio: false, image: true, video: false, pdf: false },
-                output: { text: true, audio: false, image: false, video: false, pdf: false },
-                interleaved: false,
-              },
-            },
+          id: 'deepseek-v4-flash',
+          modelID: 'pack-ds',
+          providerID: 'openai',
+          name: 'deepseek-v4-flash',
+          capabilities: { tools: true, input: ['text'], output: ['text'] },
+        },
+        {
+          id: 'grok-4.6',
+          modelID: 'pack-grok',
+          providerID: 'xai',
+          name: 'Grok 4.6',
+          capabilities: {
+            temperature: true,
+            reasoning: true,
+            attachment: true,
+            toolcall: true,
+            input: { text: true, audio: false, image: true, video: false, pdf: false },
+            output: { text: true, audio: false, image: false, video: false, pdf: false },
+            interleaved: false,
           },
         },
       ],
@@ -141,6 +161,17 @@ describe('projectConnectedModels', () => {
     expect(catalog.models.find((model) => model.modelID === 'deepseek-v4-flash')?.acceptsImages).toBe(false)
     expect(catalog.connected).toEqual(['openai', 'xai'])
   })
+
+  it('ignores models whose provider is not in provider.list when providers are present', () => {
+    const catalog = projectConnectedModels({
+      providers: [{ id: 'openai', name: 'OpenAI' }],
+      models: [
+        { id: 'gpt-5.2', providerID: 'openai', name: 'GPT-5.2', capabilities: { input: ['text'], output: ['text'], tools: false } },
+        { id: 'other', providerID: 'missing', name: 'Other', capabilities: { input: ['text'], output: ['text'], tools: false } },
+      ],
+    })
+    expect(catalog.models.map((m) => m.modelID)).toEqual(['gpt-5.2'])
+  })
 })
 
 describe('loadConnectedCatalog', () => {
@@ -148,42 +179,73 @@ describe('loadConnectedCatalog', () => {
     vi.restoreAllMocks()
   })
 
-  it('requires both /provider and /config/providers', async () => {
+  it('requires provider.list and model.list data arrays', async () => {
     await expect(loadConnectedCatalog({
-      provider: { list: async () => ({ data: { connected: ['openai'] } }) },
-      config: { providers: async () => ({ error: { status: 500 } }) },
+      provider: { list: async () => ({ location: {}, data: [{ id: 'openai', name: 'OpenAI' }] }) },
+      model: { list: async () => ({ location: {}, data: null }) },
     })).rejects.toThrow(/provider catalog/)
   })
 
-  it('passes AbortSignal to provider.list and config.providers', async () => {
+  it('composes real client-shaped catalog responses', async () => {
+    const catalog = await loadConnectedCatalog({
+      provider: {
+        list: async () => ({
+          location: { directory: '/tmp' },
+          data: [{ id: 'openai', name: 'OpenAI' }],
+        }),
+      },
+      model: {
+        list: async () => ({
+          location: { directory: '/tmp' },
+          data: [{
+            id: 'gpt-4o',
+            modelID: 'internal',
+            providerID: 'openai',
+            name: 'GPT-4o',
+            capabilities: { tools: true, input: ['text', 'image'], output: ['text'] },
+          }],
+        }),
+      },
+    })
+    expect(catalog.models).toEqual([
+      { providerID: 'openai', modelID: 'gpt-4o', name: 'GPT-4o', acceptsImages: true },
+    ])
+  })
+
+  it('surfaces thrown client errors as upstream_error', async () => {
+    await expect(loadConnectedCatalog({
+      provider: { list: async () => { throw new Error('boom') } },
+      model: { list: async () => ({ data: [] }) },
+    })).rejects.toMatchObject({ code: 'upstream_error', message: 'boom' })
+  })
+
+  it('passes AbortSignal to provider.list and model.list', async () => {
     const signals = []
     const catalog = await loadConnectedCatalog({
       provider: {
         list: async (_params, options) => {
           signals.push(options?.signal)
-          return { data: { connected: ['xai'] } }
+          return {
+            location: {},
+            data: [{ id: 'xai', name: 'xAI' }],
+          }
         },
       },
-      config: {
-        providers: async (_params, options) => {
+      model: {
+        list: async (_params, options) => {
           signals.push(options?.signal)
           return {
-            data: {
-              providers: [{
-                id: 'xai',
-                name: 'xAI',
-                models: {
-                  'grok-4.6': {
-                    id: 'grok-4.6',
-                    name: 'Grok 4.6',
-                    capabilities: {
-                      input: { text: true, image: true },
-                      attachment: true,
-                    },
-                  },
-                },
-              }],
-            },
+            location: {},
+            data: [{
+              id: 'grok-4.6',
+              modelID: 'internal',
+              providerID: 'xai',
+              name: 'Grok 4.6',
+              capabilities: {
+                input: { text: true, image: true },
+                attachment: true,
+              },
+            }],
           }
         },
       },
@@ -209,7 +271,7 @@ describe('loadConnectedCatalog', () => {
           else options?.signal?.addEventListener('abort', onAbort, { once: true })
         }),
       },
-      config: { providers: async () => ({ data: { providers: [] } }) },
+      model: { list: async () => ({ data: [] }) },
     }, { timeoutMs: 30 })).rejects.toMatchObject({
       code: 'upstream_error',
       message: expect.stringMatching(/timed out|aborted/i),

package/server/lib/llm/completions.js

@@ -1,5 +1,5 @@
 import { isConnectedModel, loadConnectedCatalog, parseModelRef } from './catalog.js';
-import { generateOpenCodeText } from './generate.js';
+import { generateOpenCodeText, parseDataUrl, MAX_ATTACHMENT_BYTES } from './generate.js';
 
 const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
 
@@ -15,10 +15,29 @@ const normalizeCompletionFilePart = (part) => {
   if (!isRecord(part) || part.type !== 'file') return null;
   if (typeof part.mime !== 'string' || !part.mime.trim()) return null;
   if (typeof part.url !== 'string' || !part.url.trim()) return null;
+  const url = part.url.trim();
+  if (!url.startsWith('data:')) {
+    throw new LlmError('validation_error', 400, 'file part url must be a data URL');
+  }
+  let parsed;
+  try {
+    parsed = parseDataUrl(url);
+  } catch (error) {
+    if (error?.code === 'validation_error') {
+      throw new LlmError('validation_error', 400, error.message || 'attachment too large');
+    }
+    throw error;
+  }
+  if (!parsed) {
+    throw new LlmError('validation_error', 400, 'file part data URL is malformed');
+  }
+  if (parsed.byteLength > MAX_ATTACHMENT_BYTES) {
+    throw new LlmError('validation_error', 400, `Attachment exceeds ${MAX_ATTACHMENT_BYTES} byte limit`);
+  }
   return {
     type: 'file',
     mime: part.mime.trim(),
-    url: part.url.trim(),
+    url,
     ...(typeof part.filename === 'string' && part.filename.trim() ? { filename: part.filename.trim() } : {}),
   };
 };
@@ -57,15 +76,15 @@ export function toOpenAICompletion({ id, model, text, created = Math.floor(Date.
     }],
     usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
   };
-}
+};
 
 /**
  * OpenAI-shaped completions against OpenCode's already-connected providers.
  *
  * Public HTTP stays non-streaming (`stream: true` → validation_error).
  * In-process callers (Assistant contact harness) may pass `onTextDelta` and
- * `globalEventHub`; those are forwarded to generate for real throwaway-session
- * `message.part.delta` tokens only — never as fake post-hoc SSE on this route.
+ * `globalEventHub`; those are forwarded to generate for real attachment-session
+ * `session.text.delta` tokens only — never as fake post-hoc SSE on this route.
  */
 export async function createChatCompletion({
   body,
@@ -75,16 +94,16 @@ export async function createChatCompletion({
   loadCatalog = loadConnectedCatalog,
   generateText = generateOpenCodeText,
   ensureTempDirectory,
-  fetchImpl,
   onTextDelta = null,
   globalEventHub = null,
+  persistSessionMetadata = null,
+  onSystemSessionPersisted = null,
   signal = null,
 }) {
   signal?.throwIfAborted();
   if (!isRecord(body)) throw new LlmError('validation_error', 400, 'JSON body is required');
-  // Bundled OpenCode 1.18.4 generate is a full-turn JSON reply (sessionless
-  // generate or throwaway session.promptAsync). This HTTP gateway does not
-  // token-stream. Do not emit fake SSE after the fact.
+  // session.generate / attachment-session return a full turn. This HTTP gateway
+  // does not token-stream. Do not emit fake SSE after the fact.
   // In-process onTextDelta (optional) is a separate internal callback path.
   if (body.stream === true) {
     throw new LlmError(
@@ -103,8 +122,8 @@ export async function createChatCompletion({
 
   const client = clientFactory?.() ?? null;
   const catalog = await loadCatalog(client ?? {
-    provider: { list: async () => ({ error: { status: 500 } }) },
-    config: { providers: async () => ({ error: { status: 500 } }) },
+    provider: { list: async () => { throw new Error('no client'); } },
+    model: { list: async () => { throw new Error('no client'); } },
   });
   signal?.throwIfAborted();
   if (!isConnectedModel(catalog, resolved.providerID, resolved.modelID)) {
@@ -124,7 +143,6 @@ export async function createChatCompletion({
       modelID: resolved.modelID,
       ...(variant ? { variant } : {}),
       messages,
-      fetchImpl,
       clientFactory,
       ensureTempDirectory,
       forwardImageParts: Boolean(catalog.models.find((entry) => (
@@ -132,6 +150,8 @@ export async function createChatCompletion({
       ))?.acceptsImages),
       onTextDelta,
       globalEventHub,
+      persistSessionMetadata,
+      onSystemSessionPersisted,
       signal,
     });
   } catch (error) {
@@ -139,6 +159,15 @@ export async function createChatCompletion({
     if (error?.code === 'validation_error') {
       throw new LlmError('validation_error', 400, error.message || 'validation_error');
     }
+    if (error?.code === 'llm_attachment_generation_unavailable') {
+      throw new LlmError(
+        'llm_attachment_generation_unavailable',
+        502,
+        typeof error?.message === 'string' && error.message.trim()
+          ? error.message
+          : 'LLM attachment generation is unavailable',
+      );
+    }
     throw new LlmError(
       'upstream_error',
       502,

package/server/lib/llm/completions.test.js

@@ -52,7 +52,7 @@ describe('createChatCompletion', () => {
   })
 
   it('returns a non-stream completion from generateText', async () => {
-    const generateText = vi.fn(async () => ({ text: 'done', source: 'throwaway-session' }))
+    const generateText = vi.fn(async () => ({ text: 'done', source: 'session.generate' }))
     const result = await createChatCompletion({
       generateText,
       loadCatalog: async () => ({
@@ -64,10 +64,11 @@ describe('createChatCompletion', () => {
     expect(result.completion.choices[0].message.content).toBe('done')
     expect(result.providerID).toBe('openai')
     expect(result.modelID).toBe('gpt-5.2')
+    expect(result.source).toBe('session.generate')
   })
 
   it('forwards in-process onTextDelta and globalEventHub to generateText', async () => {
-    const generateText = vi.fn(async () => ({ text: 'streamed', source: 'throwaway-session' }))
+    const generateText = vi.fn(async () => ({ text: 'streamed', source: 'attachment-session' }))
     const onTextDelta = vi.fn()
     const signal = new AbortController().signal
     const globalEventHub = { subscribeEvent: vi.fn() }
@@ -88,7 +89,7 @@ describe('createChatCompletion', () => {
   })
 
   it('forwards optional file parts on user messages', async () => {
-    const generateText = vi.fn(async () => ({ text: 'saw it', source: 'throwaway-session' }))
+    const generateText = vi.fn(async () => ({ text: 'saw it', source: 'attachment-session' }))
     const image = { type: 'file', mime: 'image/png', url: 'data:image/png;base64,aa', filename: 'shot.png' }
     await createChatCompletion({
       generateText,
@@ -108,7 +109,7 @@ describe('createChatCompletion', () => {
   })
 
   it('asks generate to skip image bytes when the catalog model is not vision-capable', async () => {
-    const generateText = vi.fn(async () => ({ text: 'ok', source: 'throwaway-session' }))
+    const generateText = vi.fn(async () => ({ text: 'ok', source: 'session.generate' }))
     await createChatCompletion({
       generateText,
       loadCatalog: async () => ({
@@ -120,6 +121,26 @@ describe('createChatCompletion', () => {
     expect(generateText.mock.calls[0][0].forwardImageParts).toBe(false)
   })
 
+  it('rejects malformed data URL file parts', async () => {
+    const generateText = vi.fn()
+    await expect(createChatCompletion({
+      generateText,
+      loadCatalog: async () => ({
+        models: [{ providerID: 'openai', modelID: 'gpt-5.2', acceptsImages: true }],
+        connected: ['openai'],
+      }),
+      body: {
+        model: 'openai/gpt-5.2',
+        messages: [{
+          role: 'user',
+          content: 'look',
+          parts: [{ type: 'file', mime: 'image/png', url: 'https://example.com/x.png' }],
+        }],
+      },
+    })).rejects.toMatchObject({ code: 'validation_error', statusCode: 400 })
+    expect(generateText).not.toHaveBeenCalled()
+  })
+
   it('LlmError carries a stable code', () => {
     expect(new LlmError('no_provider', 400, 'missing')).toMatchObject({
       code: 'no_provider',
@@ -146,4 +167,24 @@ describe('createChatCompletion', () => {
       message: 'model refused the request',
     })
   })
+
+  it('maps llm_attachment_generation_unavailable before treating it as generic upstream', async () => {
+    const generateText = vi.fn(async () => {
+      const error = new Error('deny-all missing')
+      error.code = 'llm_attachment_generation_unavailable'
+      throw error
+    })
+    await expect(createChatCompletion({
+      generateText,
+      loadCatalog: async () => ({
+        models: [{ providerID: 'openai', modelID: 'gpt-4o', acceptsImages: true }],
+        connected: ['openai'],
+      }),
+      body: { model: 'openai/gpt-4o', messages: [{ role: 'user', content: 'hi' }] },
+    })).rejects.toMatchObject({
+      code: 'llm_attachment_generation_unavailable',
+      statusCode: 502,
+      message: 'deny-all missing',
+    })
+  })
 })