@openchambery/web 1.19.7-beta.8 → 1.19.7

package/server/lib/llm/completions.js

@@ -0,0 +1,151 @@
+import { isConnectedModel, loadConnectedCatalog, parseModelRef } from './catalog.js';
+import { generateOpenCodeText } from './generate.js';
+
+const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+
+export class LlmError extends Error {
+  constructor(code, statusCode, message) {
+    super(message || code);
+    this.code = code;
+    this.statusCode = statusCode;
+  }
+}
+
+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;
+  return {
+    type: 'file',
+    mime: part.mime.trim(),
+    url: part.url.trim(),
+    ...(typeof part.filename === 'string' && part.filename.trim() ? { filename: part.filename.trim() } : {}),
+  };
+};
+
+const normalizeMessages = (messages) => {
+  if (!Array.isArray(messages) || messages.length === 0) {
+    throw new LlmError('validation_error', 400, 'messages is required');
+  }
+  return messages.map((message) => {
+    if (!isRecord(message) || typeof message.content !== 'string') {
+      throw new LlmError('validation_error', 400, 'each message needs role and string content');
+    }
+    const role = message.role;
+    if (role !== 'system' && role !== 'user' && role !== 'assistant') {
+      throw new LlmError('validation_error', 400, 'message role must be system, user, or assistant');
+    }
+    const parts = Array.isArray(message.parts)
+      ? message.parts.map(normalizeCompletionFilePart).filter(Boolean)
+      : [];
+    return parts.length > 0 ? { role, content: message.content, parts } : { role, content: message.content };
+  });
+};
+
+const completionId = () => `chatcmpl_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
+
+export function toOpenAICompletion({ id, model, text, created = Math.floor(Date.now() / 1000) }) {
+  return {
+    id,
+    object: 'chat.completion',
+    created,
+    model,
+    choices: [{
+      index: 0,
+      message: { role: 'assistant', content: text },
+      finish_reason: 'stop',
+    }],
+    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.
+ */
+export async function createChatCompletion({
+  body,
+  buildOpenCodeUrl,
+  getOpenCodeAuthHeaders,
+  clientFactory,
+  loadCatalog = loadConnectedCatalog,
+  generateText = generateOpenCodeText,
+  ensureTempDirectory,
+  fetchImpl,
+  onTextDelta = null,
+  globalEventHub = null,
+}) {
+  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.
+  // In-process onTextDelta (optional) is a separate internal callback path.
+  if (body.stream === true) {
+    throw new LlmError(
+      'validation_error',
+      400,
+      'This gateway is non-streaming; omit stream or set stream:false',
+    );
+  }
+  const resolved = parseModelRef(body.model, body.providerID, body.modelID);
+  if (!resolved) throw new LlmError('validation_error', 400, 'model or providerID/modelID is required');
+  const messages = normalizeMessages(body.messages);
+
+  const client = clientFactory?.() ?? null;
+  const catalog = await loadCatalog(client ?? {
+    provider: { list: async () => ({ error: { status: 500 } }) },
+    config: { providers: async () => ({ error: { status: 500 } }) },
+  });
+  if (!isConnectedModel(catalog, resolved.providerID, resolved.modelID)) {
+    throw new LlmError(
+      'no_provider',
+      400,
+      `No connected OpenCode provider for ${resolved.providerID}/${resolved.modelID}`,
+    );
+  }
+
+  let generated;
+  try {
+    generated = await generateText({
+      buildOpenCodeUrl,
+      getOpenCodeAuthHeaders,
+      providerID: resolved.providerID,
+      modelID: resolved.modelID,
+      messages,
+      fetchImpl,
+      clientFactory,
+      ensureTempDirectory,
+      forwardImageParts: Boolean(catalog.models.find((entry) => (
+        entry.providerID === resolved.providerID && entry.modelID === resolved.modelID
+      ))?.acceptsImages),
+      onTextDelta,
+      globalEventHub,
+    });
+  } catch (error) {
+    if (error instanceof LlmError) throw error;
+    if (error?.code === 'validation_error') {
+      throw new LlmError('validation_error', 400, error.message || 'validation_error');
+    }
+    throw new LlmError(
+      'upstream_error',
+      502,
+      typeof error?.message === 'string' && error.message.trim()
+        ? error.message
+        : 'OpenCode generate failed',
+    );
+  }
+  const text = typeof generated?.text === 'string' ? generated.text.trim() : '';
+  if (!text) throw new LlmError('upstream_error', 502, 'OpenCode returned no assistant text');
+
+  const model = `${resolved.providerID}/${resolved.modelID}`;
+  return {
+    completion: toOpenAICompletion({ id: completionId(), model, text }),
+    providerID: resolved.providerID,
+    modelID: resolved.modelID,
+    source: generated.source,
+  };
+}

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

@@ -0,0 +1,127 @@
+import { describe, expect, it, vi } from 'vitest'
+import { LlmError, createChatCompletion } from './completions.js'
+
+describe('createChatCompletion', () => {
+  it('rejects when the requested model is not connected', async () => {
+    const generateText = vi.fn()
+    await expect(createChatCompletion({
+      generateText,
+      loadCatalog: async () => ({
+        models: [{ providerID: 'openai', modelID: 'gpt-5.2' }],
+        connected: ['openai'],
+      }),
+      body: { model: 'anthropic/claude-sonnet-4', messages: [{ role: 'user', content: 'hi' }] },
+    })).rejects.toMatchObject({ code: 'no_provider' })
+    expect(generateText).not.toHaveBeenCalled()
+  })
+
+  it('rejects stream:true instead of faking SSE after a full generate', async () => {
+    const generateText = vi.fn()
+    await expect(createChatCompletion({
+      generateText,
+      loadCatalog: async () => ({
+        models: [{ providerID: 'openai', modelID: 'gpt-5.2' }],
+        connected: ['openai'],
+      }),
+      body: {
+        model: 'openai/gpt-5.2',
+        stream: true,
+        messages: [{ role: 'user', content: 'hi' }],
+      },
+    })).rejects.toMatchObject({ code: 'validation_error', statusCode: 400 })
+    expect(generateText).not.toHaveBeenCalled()
+  })
+
+  it('returns a non-stream completion from generateText', async () => {
+    const generateText = vi.fn(async () => ({ text: 'done', source: 'throwaway-session' }))
+    const result = await createChatCompletion({
+      generateText,
+      loadCatalog: async () => ({
+        models: [{ providerID: 'openai', modelID: 'gpt-5.2' }],
+        connected: ['openai'],
+      }),
+      body: { model: 'openai/gpt-5.2', messages: [{ role: 'user', content: 'hi' }] },
+    })
+    expect(result.completion.choices[0].message.content).toBe('done')
+    expect(result.providerID).toBe('openai')
+    expect(result.modelID).toBe('gpt-5.2')
+  })
+
+  it('forwards in-process onTextDelta and globalEventHub to generateText', async () => {
+    const generateText = vi.fn(async () => ({ text: 'streamed', source: 'throwaway-session' }))
+    const onTextDelta = vi.fn()
+    const globalEventHub = { subscribeEvent: vi.fn() }
+    await createChatCompletion({
+      generateText,
+      loadCatalog: async () => ({
+        models: [{ providerID: 'openai', modelID: 'gpt-5.2' }],
+        connected: ['openai'],
+      }),
+      body: { model: 'openai/gpt-5.2', messages: [{ role: 'user', content: 'hi' }] },
+      onTextDelta,
+      globalEventHub,
+    })
+    expect(generateText.mock.calls[0][0].onTextDelta).toBe(onTextDelta)
+    expect(generateText.mock.calls[0][0].globalEventHub).toBe(globalEventHub)
+  })
+
+  it('forwards optional file parts on user messages', async () => {
+    const generateText = vi.fn(async () => ({ text: 'saw it', source: 'throwaway-session' }))
+    const image = { type: 'file', mime: 'image/png', url: 'data:image/png;base64,aa', filename: 'shot.png' }
+    await 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: [image] }],
+      },
+    })
+    expect(generateText.mock.calls[0][0].messages).toEqual([
+      { role: 'user', content: 'look', parts: [image] },
+    ])
+    expect(generateText.mock.calls[0][0].forwardImageParts).toBe(true)
+  })
+
+  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' }))
+    await createChatCompletion({
+      generateText,
+      loadCatalog: async () => ({
+        models: [{ providerID: 'opencode', modelID: 'deepseek-v4-flash', acceptsImages: false }],
+        connected: ['opencode'],
+      }),
+      body: { model: 'opencode/deepseek-v4-flash', messages: [{ role: 'user', content: 'look' }] },
+    })
+    expect(generateText.mock.calls[0][0].forwardImageParts).toBe(false)
+  })
+
+  it('LlmError carries a stable code', () => {
+    expect(new LlmError('no_provider', 400, 'missing')).toMatchObject({
+      code: 'no_provider',
+      statusCode: 400,
+    })
+  })
+
+  it('wraps generate failures as 502 with the OpenCode error message', async () => {
+    const generateText = vi.fn(async () => {
+      const error = new Error('model refused the request')
+      error.code = 'upstream_error'
+      throw error
+    })
+    await expect(createChatCompletion({
+      generateText,
+      loadCatalog: async () => ({
+        models: [{ providerID: 'opencode', modelID: 'gpt-5-nano' }],
+        connected: ['opencode'],
+      }),
+      body: { model: 'opencode/gpt-5-nano', messages: [{ role: 'user', content: 'hi' }] },
+    })).rejects.toMatchObject({
+      code: 'upstream_error',
+      statusCode: 502,
+      message: 'model refused the request',
+    })
+  })
+})