@openchambery/web 1.19.15-beta.4 → 1.19.15-beta.5

package/server/lib/assistants/service.test.js

@@ -75,6 +75,28 @@ const settleSend = async (service, assistantID, body) => {
 const assistantInput = { name: 'A', providerID: 'p', modelID: 'm' };
 
 describe('assistants service', () => {
+  it('rehydrates the saved thinking variant into contact turns and preserves it on a rejected write', async () => {
+    const directory = root();
+    const runContactTurn = vi.fn(async () => ({ text: 'done', bubbles: ['done'] }));
+    let service = setup(directory, {}, { runContactTurn });
+    try {
+      const assistant = service.createAssistant({ ...assistantInput, variant: 'high' });
+      service.close();
+      service = setup(directory, {}, { runContactTurn });
+      await settleSend(service, assistant.id, { messageID: 'variant-restored', parts: [{ type: 'text', text: 'hello' }] });
+      expect(runContactTurn.mock.calls[0][0].assistant.variant).toBe('high');
+      await expect(service.updateAssistant(assistant.id, { expectedRevision: 999, variant: 'low' })).rejects.toBeDefined();
+      await settleSend(service, assistant.id, { messageID: 'variant-after-conflict', parts: [{ type: 'text', text: 'hello' }] });
+      expect(runContactTurn.mock.calls[1][0].assistant.variant).toBe('high');
+      await service.updateAssistant(assistant.id, { expectedRevision: 1, variant: null });
+      await settleSend(service, assistant.id, { messageID: 'variant-default', parts: [{ type: 'text', text: 'hello' }] });
+      expect(runContactTurn.mock.calls[2][0].assistant.variant).toBeNull();
+    } finally {
+      service.close();
+      fs.rmSync(directory, { recursive: true, force: true });
+    }
+  });
+
   it.each(['steer', 'archive', 'delete'])('%s_session performs the real scoped SDK operation', async (operation) => {
     const directory = root();
     const mutate = vi.fn(async () => ({ data: true }));
@@ -3670,11 +3692,11 @@ describe('assistants service', () => {
     service.close();
   });
 
-  it('notifies like a contact SMS when a contact turn completes', async () => {
+  it('notifies with the latest model message without replaying progress at completion', async () => {
     const onContactTurnComplete = vi.fn();
     const service = setup(root(), {}, {
       onContactTurnComplete,
-      runContactTurn: async () => ({ text: '我去找一下', bubbles: ['我去找一下', 'Opened a coding session.'] }),
+      runContactTurn: async () => ({ text: '任务已安排。', bubbles: ['我去找一下', '任务已安排。'] }),
     });
     const assistant = service.createAssistant({ ...assistantInput, name: '大小白' });
     await settleSend(service, assistant.id, {
@@ -3686,7 +3708,7 @@ describe('assistants service', () => {
       name: '大小白',
       turnID: 'notify_1',
       status: 'complete',
-      body: '我去找一下\nOpened a coding session.',
+      body: '任务已安排。',
     });
     service.close();
   });
@@ -4341,6 +4363,56 @@ describe('read_session referenced conversation', () => {
     service.close();
   });
 
+  it('persists public model messages before generation and tool completion, with no final replay', async () => {
+    const directory = root();
+    const events = [];
+    let releaseGeneration;
+    let releaseTool;
+    const generationGate = new Promise((resolve) => { releaseGeneration = resolve; });
+    const toolGate = new Promise((resolve) => { releaseTool = resolve; });
+    const prefix = '```openchamber-message\n{"text":"我先读一下会话，确认目前的进展。"}\n```\n';
+    const tool = '```openchamber-tool\n{"name":"read_session","arguments":{"sessionID":"ses_progress"}}\n```';
+    let calls = 0;
+    const read = vi.fn(async () => {
+      await toolGate;
+      return { data: [] };
+    });
+    const service = setup(directory, {
+      get: async () => ({ data: { id: 'ses_progress', directory } }), messages: read,
+    }, {
+      onContactTurnEvent: (event) => events.push(event),
+      runContactTurn: realRunContactTurn,
+      createChatCompletion: async ({ onTextDelta }) => {
+        if (++calls === 1) {
+          onTextDelta(prefix);
+          await generationGate;
+          onTextDelta(tool);
+          return { text: prefix + tool };
+        }
+        return { text: '```openchamber-final\n{"status":"complete","text":"这个会话目前为空。"}\n```' };
+      },
+    });
+    const assistant = service.createAssistant(assistantInput);
+    try {
+      await service.send(assistant.id, { messageID: 'live_public', parts: [{ type: 'text', text: '读一下会话' }] });
+      await vi.waitFor(() => expect(service.contactMessages(assistant.id).messages.some((m) => m.text === '我先读一下会话，确认目前的进展。')).toBe(true));
+      expect(read).not.toHaveBeenCalled();
+      expect(service.snapshot().assistants.find((a) => a.id === assistant.id).working).toBe(true);
+      expect(events.some((e) => e.type === 'openchamber:contact-turn-end')).toBe(false);
+      releaseGeneration();
+      await vi.waitFor(() => expect(read).toHaveBeenCalledTimes(1));
+      // A fresh snapshot/history read while the actual tool is pending restores the same message.
+      expect(service.contactMessages(assistant.id).messages.filter((m) => m.role === 'assistant').map((m) => m.text)).toEqual(['我先读一下会话，确认目前的进展。']);
+      releaseTool();
+      await service.whenContactTurnSettled('live_public');
+      expect(service.contactMessages(assistant.id).messages.filter((m) => m.role === 'assistant').map((m) => m.text)).toEqual(['我先读一下会话，确认目前的进展。', '这个会话目前为空。']);
+      const deltas = events.filter((e) => e.type === 'openchamber:contact-bubble-delta' && e.properties.done);
+      expect(deltas.map((e) => e.properties.bubbleIndex)).toEqual([0, 1]);
+    } finally {
+      releaseGeneration(); releaseTool(); service.close();
+    }
+  });
+
   it('real harness duplicate preambles keep both lines in SSE and SQLite', async () => {
     const directory = root();
     const events = [];

package/server/lib/llm/DOCUMENTATION.md

@@ -9,7 +9,7 @@ only model path the Assistant harness (`pi-agent-core` `streamFn`) talks to.
   from OpenCode `GET /provider` (`connected`) plus `GET /config/providers`.
   Plugin adapter formats stay inside OpenCode; this route does not parse them.
 - `POST /api/openchamber/llm/chat/completions` — `{ model, messages, stream?,
-  providerID?, modelID? }` → OpenAI `chat.completion` JSON.
+  providerID?, modelID?, variant? }` → OpenAI `chat.completion` JSON.
   This **public** gateway is **non-streaming**. Bundled OpenCode 1.18.4 generate
   (`POST /generate` when present, otherwise throwaway `session.promptAsync`
   plus idle wait) returns a full assistant turn. `stream: true` is rejected with
@@ -19,6 +19,13 @@ only model path the Assistant harness (`pi-agent-core` `streamFn`) talks to.
 
 `model` may be `providerID/modelID` or a bare `modelID` paired with `providerID`.
 
+`variant` is an optional OpenCode model variant string. Null, omitted, or empty
+values preserve the provider default. Other types fail validation before a model
+call. A selected variant is forwarded unchanged to sessionless generate and to
+the throwaway `session.promptAsync` body. OpenCode owns provider-specific variant
+semantics. Variant selection changes inference configuration only; completion
+output continues to include text parts and keeps reasoning parts private.
+
 ## Internals (verified on bundled `@opencode-ai/sdk` 1.18.4)
 
 The 1.18.4 client exposes `GET /provider`, `GET /config/providers`, and

package/server/lib/llm/completions.js

@@ -96,6 +96,10 @@ export async function createChatCompletion({
   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);
+  if (body.variant != null && typeof body.variant !== 'string') {
+    throw new LlmError('validation_error', 400, 'variant must be a string or null');
+  }
+  const variant = body.variant?.trim() || undefined;
 
   const client = clientFactory?.() ?? null;
   const catalog = await loadCatalog(client ?? {
@@ -118,6 +122,7 @@ export async function createChatCompletion({
       getOpenCodeAuthHeaders,
       providerID: resolved.providerID,
       modelID: resolved.modelID,
+      ...(variant ? { variant } : {}),
       messages,
       fetchImpl,
       clientFactory,

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

@@ -2,6 +2,25 @@ import { describe, expect, it, vi } from 'vitest'
 import { LlmError, createChatCompletion } from './completions.js'
 
 describe('createChatCompletion', () => {
+  it.each(['high', 'medium', null, ''])('forwards variant %s with default compatibility', async (variant) => {
+    const generateText = vi.fn(async () => ({ text: 'done' }));
+    await createChatCompletion({
+      generateText,
+      loadCatalog: async () => ({ models: [{ providerID: 'p', modelID: 'm' }] }),
+      body: { model: 'p/m', variant, messages: [{ role: 'user', content: 'hi' }] },
+    });
+    expect(generateText.mock.calls[0][0].variant).toBe(variant || undefined);
+  });
+
+  it('rejects malformed variants before a model call', async () => {
+    const generateText = vi.fn();
+    await expect(createChatCompletion({
+      generateText,
+      body: { model: 'p/m', variant: { high: true }, messages: [{ role: 'user', content: 'hi' }] },
+    })).rejects.toMatchObject({ code: 'validation_error', statusCode: 400 });
+    expect(generateText).not.toHaveBeenCalled();
+  });
+
   it('rejects when the requested model is not connected', async () => {
     const generateText = vi.fn()
     await expect(createChatCompletion({

package/server/lib/llm/generate.js

@@ -350,12 +350,13 @@ const filesForPrompt = (files, forwardImageParts) => {
   return files.filter((part) => !String(part?.mime || '').startsWith('image/'));
 };
 
-async function generateViaSessionless({ fetchImpl, url, headers, providerID, modelID, messages, signal }) {
+async function generateViaSessionless({ fetchImpl, url, headers, providerID, modelID, variant, messages, signal }) {
   const response = await fetchImpl(url, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json', Accept: 'application/json', ...headers },
     body: JSON.stringify({
       model: { providerID, modelID },
+      ...(variant ? { variant } : {}),
       messages,
     }),
     signal,
@@ -451,6 +452,7 @@ export async function generateOpenCodeText({
   providerID,
   modelID,
   messages,
+  variant,
   fetchImpl = globalThis.fetch.bind(globalThis),
   clientFactory,
   ensureTempDirectory,
@@ -508,6 +510,7 @@ export async function generateOpenCodeText({
         headers,
         providerID,
         modelID,
+        variant,
         messages: forwardImageParts
           ? messages
           : messages.map((message) => {
@@ -586,6 +589,7 @@ export async function generateOpenCodeText({
         directory: workingDirectory,
         agent: LLM_AGENT_NAME,
         model: { providerID, modelID },
+        ...(variant ? { variant } : {}),
         ...(flattened.system ? { system: flattened.system } : {}),
         tools,
         parts: [

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

@@ -113,6 +113,29 @@ describe('detectSessionlessGenerate', () => {
 })
 
 describe('generateOpenCodeText', () => {
+  it.each(['high', undefined])('passes variant %s to the upstream prompt and returns only text parts', async (variant) => {
+    const client = throwawayClient({
+      status: async () => ({ data: {} }),
+      messages: async () => ({ data: [{
+        ...completedAssistant('public reply'),
+        parts: [{ type: 'reasoning', text: 'private reasoning' }, { type: 'text', text: 'public reply' }],
+      }] }),
+    });
+    client.session.promptAsync = vi.fn(async () => ({ response: { status: 204 } }));
+    const result = await throwawayGenerate(client, { variant });
+    expect(client.session.promptAsync.mock.calls[0][0].variant).toBe(variant);
+    expect(result.text).toBe('public reply');
+  });
+
+  it('passes variant to sessionless generation', async () => {
+    const fetchImpl = vi.fn(async () => new Response(JSON.stringify({ text: 'reply' })));
+    await throwawayGenerate({}, {
+      variant: 'high', fetchImpl,
+      detect: async () => ({ available: true, mode: 'http', url: 'http://localhost:1/generate' }),
+    });
+    expect(JSON.parse(fetchImpl.mock.calls[0][1].body).variant).toBe('high');
+  });
+
   it('uses promptAsync with model+parts, waits for idle messages, and never calls v2 session.prompt', async () => {
     const create = vi.fn(async () => ({ data: { id: 'ses_tmp' } }))
     const update = vi.fn(async () => ({ data: { id: 'ses_tmp' } }))