npm - @openchambery/web - Versions diffs - 1.19.7-beta.13 → 1.19.7-beta.14 - Mend

@openchambery/web 1.19.7-beta.13 → 1.19.7-beta.14

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (118) hide show

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

@@ -0,0 +1,459 @@
+import { describe, expect, it, vi } from 'vitest'
+import { detectSessionlessGenerate, generateOpenCodeText, _test } from './generate.js'
+const completedAssistant = (text) => ({
+  info: {
+    role: 'assistant',
+    time: { completed: Date.now() },
+  },
+  parts: [{ type: 'text', text }],
+})
+describe('detectSessionlessGenerate', () => {
+  it('returns unavailable when the probe 404s', async () => {
+    const fetchImpl = vi.fn(async () => new Response('missing', { status: 404 }))
+    await expect(detectSessionlessGenerate({
+      fetchImpl,
+      baseUrl: 'http://127.0.0.1:4096',
+      headers: {},
+    })).resolves.toEqual({ available: false, mode: 'throwaway-session' })
+  })
+  it('returns available when the probe returns JSON', async () => {
+    const fetchImpl = vi.fn(async () => new Response(JSON.stringify({ ok: true }), {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' },
+    }))
+    await expect(detectSessionlessGenerate({
+      fetchImpl,
+      baseUrl: 'http://127.0.0.1:4096',
+      headers: {},
+    })).resolves.toMatchObject({ available: true, mode: 'http' })
+  })
+  it('treats HTML 200 on /generate as unavailable', async () => {
+    const fetchImpl = vi.fn(async (url) => {
+      expect(String(url)).toMatch(/\/generate$/)
+      return new Response('<!doctype html><html><body>OpenChamber</body></html>', {
+        status: 200,
+        headers: { 'Content-Type': 'text/html; charset=utf-8' },
+      })
+    })
+    await expect(detectSessionlessGenerate({
+      fetchImpl,
+      baseUrl: 'http://127.0.0.1:4096',
+      headers: {},
+    })).resolves.toEqual({ available: false, mode: 'throwaway-session' })
+    expect(fetchImpl).toHaveBeenCalled()
+  })
+})
+describe('generateOpenCodeText', () => {
+  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' } }))
+    const ids = vi.fn(async () => ({ data: ['bash', 'edit'] }))
+    const prompt = vi.fn(async () => {
+      throw new Error('v2 session.prompt must not be used')
+    })
+    const promptAsync = vi.fn(async () => ({ response: { status: 204 } }))
+    const status = vi.fn(async () => ({ data: { ses_tmp: { type: 'idle' } } }))
+    const messages = vi.fn(async () => ({ data: [completedAssistant('reply')] }))
+    const remove = vi.fn(async () => ({ data: true }))
+    const createOpencodeClient = vi.fn(() => ({
+      session: { create, update, prompt, promptAsync, status, messages, delete: remove },
+      tool: { ids },
+    }))
+    const result = await generateOpenCodeText({
+      buildOpenCodeUrl: () => 'http://127.0.0.1:4096',
+      getOpenCodeAuthHeaders: () => ({}),
+      providerID: 'opencode',
+      modelID: 'gpt-5-nano',
+      messages: [{ role: 'user', content: 'hi' }],
+      clientFactory: createOpencodeClient,
+      ensureTempDirectory: async () => '/tmp/openchamber-llm',
+      detect: async () => ({ available: false, mode: 'throwaway-session' }),
+    })
+    expect(create).toHaveBeenCalledWith(expect.objectContaining({
+      title: expect.stringContaining('[openchamber-llm]'),
+    }), expect.anything())
+    expect(update).toHaveBeenCalled()
+    expect(promptAsync).toHaveBeenCalledWith(expect.objectContaining({
+      sessionID: 'ses_tmp',
+      agent: 'openchamber-llm',
+      model: { providerID: 'opencode', modelID: 'gpt-5-nano' },
+      tools: { bash: false, edit: false },
+      parts: [{ type: 'text', text: 'User: hi', synthetic: false }],
+    }), expect.anything())
+    expect(prompt).not.toHaveBeenCalled()
+    expect(status).toHaveBeenCalled()
+    expect(messages).toHaveBeenCalledWith(expect.objectContaining({ sessionID: 'ses_tmp' }), expect.anything())
+    expect(remove).toHaveBeenCalled()
+    expect(result).toEqual({ text: 'reply', source: 'throwaway-session' })
+  })
+  it('forwards contact file parts on promptAsync so the model can see images', async () => {
+    const image = { type: 'file', mime: 'image/png', url: 'data:image/png;base64,aa', filename: 'shot.png' }
+    const file = { type: 'file', mime: 'text/plain', url: 'data:text/plain;base64,eA==', filename: 'notes.txt' }
+    const flattened = _test.flattenMessages([
+      { role: 'user', content: 'look', parts: [image, file] },
+    ])
+    expect(flattened.prompt).toContain('User: look')
+    expect(flattened.prompt).toContain('[image: shot.png (image/png)]')
+    expect(flattened.prompt).toContain('[file: notes.txt (text/plain)]')
+    expect(flattened.files).toEqual([image, file])
+    const promptAsync = vi.fn(async () => ({ response: { status: 204 } }))
+    const createOpencodeClient = vi.fn(() => ({
+      session: {
+        create: async () => ({ data: { id: 'ses_tmp' } }),
+        update: async () => ({ data: { id: 'ses_tmp' } }),
+        prompt: vi.fn(),
+        promptAsync,
+        status: async () => ({ data: { ses_tmp: { type: 'idle' } } }),
+        messages: async () => ({ data: [completedAssistant('saw it')] }),
+        delete: async () => ({ data: true }),
+      },
+      tool: { ids: async () => ({ data: [] }) },
+    }))
+    await generateOpenCodeText({
+      buildOpenCodeUrl: () => 'http://127.0.0.1:4096',
+      getOpenCodeAuthHeaders: () => ({}),
+      providerID: 'opencode',
+      modelID: 'gpt-5-nano',
+      messages: [{ role: 'user', content: 'look', parts: [image, file] }],
+      clientFactory: createOpencodeClient,
+      ensureTempDirectory: async () => '/tmp/openchamber-llm',
+      detect: async () => ({ available: false, mode: 'throwaway-session' }),
+      forwardImageParts: true,
+    })
+    expect(promptAsync.mock.calls[0][0].parts).toEqual([
+      expect.objectContaining({ type: 'text', synthetic: false }),
+      image,
+      file,
+    ])
+  })
+  it('skips image bytes for non-vision generate and keeps text files plus the image description', async () => {
+    const image = { type: 'file', mime: 'image/png', url: 'data:image/png;base64,aa', filename: 'shot.png' }
+    const file = { type: 'file', mime: 'text/plain', url: 'data:text/plain;base64,eA==', filename: 'notes.txt' }
+    expect(_test.filesForPrompt([image, file], false)).toEqual([file])
+    const promptAsync = vi.fn(async () => ({ response: { status: 204 } }))
+    const createOpencodeClient = vi.fn(() => ({
+      session: {
+        create: async () => ({ data: { id: 'ses_tmp' } }),
+        update: async () => ({ data: { id: 'ses_tmp' } }),
+        prompt: vi.fn(),
+        promptAsync,
+        status: async () => ({ data: { ses_tmp: { type: 'idle' } } }),
+        messages: async () => ({ data: [completedAssistant('cannot see images')] }),
+        delete: async () => ({ data: true }),
+      },
+      tool: { ids: async () => ({ data: [] }) },
+    }))
+    await generateOpenCodeText({
+      buildOpenCodeUrl: () => 'http://127.0.0.1:4096',
+      getOpenCodeAuthHeaders: () => ({}),
+      providerID: 'opencode',
+      modelID: 'deepseek-v4-flash',
+      messages: [{ role: 'user', content: 'look', parts: [image, file] }],
+      clientFactory: createOpencodeClient,
+      ensureTempDirectory: async () => '/tmp/openchamber-llm',
+      detect: async () => ({ available: false, mode: 'throwaway-session' }),
+    })
+    expect(promptAsync.mock.calls[0][0].parts).toEqual([
+      expect.objectContaining({
+        type: 'text',
+        text: expect.stringContaining('[image: shot.png (image/png)]'),
+      }),
+      file,
+    ])
+    expect(promptAsync.mock.calls[0][0].parts.some((part) => part.type === 'file' && part.mime.startsWith('image/'))).toBe(false)
+  })
+  it('surfaces the OpenCode assistant error string after promptAsync 204', async () => {
+    const promptAsync = vi.fn(async () => ({ response: { status: 204 } }))
+    const prompt = vi.fn()
+    const createOpencodeClient = vi.fn(() => ({
+      session: {
+        create: async () => ({ data: { id: 'ses_tmp' } }),
+        update: async () => ({ data: { id: 'ses_tmp' } }),
+        prompt,
+        promptAsync,
+        status: async () => ({ data: { ses_tmp: { type: 'idle' } } }),
+        messages: async () => ({
+          data: [{
+            info: { role: 'assistant', error: { message: 'model refused the request' }, time: { completed: Date.now() } },
+            parts: [],
+          }],
+        }),
+        delete: async () => ({ data: true }),
+      },
+      tool: { ids: async () => ({ data: [] }) },
+    }))
+    await expect(generateOpenCodeText({
+      buildOpenCodeUrl: () => 'http://127.0.0.1:4096',
+      getOpenCodeAuthHeaders: () => ({}),
+      providerID: 'opencode',
+      modelID: 'gpt-5-nano',
+      messages: [{ role: 'user', content: 'hi' }],
+      clientFactory: createOpencodeClient,
+      ensureTempDirectory: async () => '/tmp/openchamber-llm',
+      detect: async () => ({ available: false, mode: 'throwaway-session' }),
+    })).rejects.toMatchObject({
+      code: 'upstream_error',
+      message: 'model refused the request',
+    })
+    expect(prompt).not.toHaveBeenCalled()
+  })
+  it('falls through to promptAsync when the /generate probe returns HTML 200', async () => {
+    const fetchImpl = vi.fn(async () => new Response('<!doctype html>', {
+      status: 200,
+      headers: { 'Content-Type': 'text/html' },
+    }))
+    const promptAsync = vi.fn(async () => ({ response: { status: 204 } }))
+    const prompt = vi.fn()
+    const result = await generateOpenCodeText({
+      buildOpenCodeUrl: () => 'http://127.0.0.1:4096',
+      getOpenCodeAuthHeaders: () => ({}),
+      providerID: 'opencode',
+      modelID: 'glm-5.3-flash',
+      messages: [{ role: 'user', content: 'hi' }],
+      fetchImpl,
+      clientFactory: () => ({
+        session: {
+          create: async () => ({ data: { id: 'ses_tmp' } }),
+          update: async () => ({ data: { id: 'ses_tmp' } }),
+          prompt,
+          promptAsync,
+          status: async () => ({ data: { ses_tmp: { type: 'idle' } } }),
+          messages: async () => ({ data: [completedAssistant('reply')] }),
+          delete: async () => ({ data: true }),
+        },
+        tool: { ids: async () => ({ data: [] }) },
+      }),
+      ensureTempDirectory: async () => '/tmp/openchamber-llm',
+    })
+    expect(result).toEqual({ text: 'reply', source: 'throwaway-session' })
+    expect(promptAsync).toHaveBeenCalled()
+    expect(prompt).not.toHaveBeenCalled()
+  })
+  it('forwards filtered throwaway session text deltas via onTextDelta and still returns full text', async () => {
+    const subscribers = new Set()
+    const globalEventHub = {
+      subscribeEvent(fn) {
+        subscribers.add(fn)
+        return () => { subscribers.delete(fn) }
+      },
+      emit(event) {
+        for (const fn of Array.from(subscribers)) fn(event)
+      },
+    }
+    const deltas = []
+    const onTextDelta = vi.fn((text) => { deltas.push(text) })
+    const promptAsync = vi.fn(async () => {
+      // Same-session text deltas
+      globalEventHub.emit({
+        payload: {
+          type: 'message.part.delta',
+          properties: {
+            sessionID: 'ses_tmp',
+            messageID: 'msg_asst',
+            partID: 'prt_1',
+            field: 'text',
+            delta: 'Hel',
+          },
+        },
+      })
+      globalEventHub.emit({
+        payload: {
+          type: 'message.part.delta',
+          properties: {
+            sessionID: 'ses_tmp',
+            messageID: 'msg_asst',
+            partID: 'prt_1',
+            field: 'text',
+            delta: 'lo',
+          },
+        },
+      })
+      // Other session — must be ignored
+      globalEventHub.emit({
+        payload: {
+          type: 'message.part.delta',
+          properties: {
+            sessionID: 'ses_other',
+            messageID: 'msg_other',
+            partID: 'prt_x',
+            field: 'text',
+            delta: 'NOPE',
+          },
+        },
+      })
+      // Same session, different messageID after lock — ignored
+      globalEventHub.emit({
+        payload: {
+          type: 'message.part.delta',
+          properties: {
+            sessionID: 'ses_tmp',
+            messageID: 'msg_other_asst',
+            partID: 'prt_2',
+            field: 'text',
+            delta: 'SKIP',
+          },
+        },
+      })
+      // Non-text field — ignored
+      globalEventHub.emit({
+        payload: {
+          type: 'message.part.delta',
+          properties: {
+            sessionID: 'ses_tmp',
+            messageID: 'msg_asst',
+            partID: 'prt_1',
+            field: 'reasoning',
+            delta: 'think',
+          },
+        },
+      })
+      return { response: { status: 204 } }
+    })
+    const result = await generateOpenCodeText({
+      buildOpenCodeUrl: () => 'http://127.0.0.1:4096',
+      getOpenCodeAuthHeaders: () => ({}),
+      providerID: 'opencode',
+      modelID: 'gpt-5-nano',
+      messages: [{ role: 'user', content: 'hi' }],
+      clientFactory: () => ({
+        session: {
+          create: async () => ({ data: { id: 'ses_tmp' } }),
+          update: async () => ({ data: { id: 'ses_tmp' } }),
+          prompt: vi.fn(),
+          promptAsync,
+          status: async () => ({ data: { ses_tmp: { type: 'idle' } } }),
+          messages: async () => ({ data: [completedAssistant('Hello')] }),
+          delete: async () => ({ data: true }),
+        },
+        tool: { ids: async () => ({ data: [] }) },
+      }),
+      ensureTempDirectory: async () => '/tmp/openchamber-llm',
+      detect: async () => ({ available: false, mode: 'throwaway-session' }),
+      onTextDelta,
+      globalEventHub,
+    })
+    expect(result).toEqual({ text: 'Hello', source: 'throwaway-session' })
+    expect(deltas).toEqual(['Hel', 'lo'])
+    expect(onTextDelta).toHaveBeenCalledTimes(2)
+    // Listener removed after complete — further emits must not reach onTextDelta
+    expect(subscribers.size).toBe(0)
+    globalEventHub.emit({
+      payload: {
+        type: 'message.part.delta',
+        properties: {
+          sessionID: 'ses_tmp',
+          messageID: 'msg_asst',
+          partID: 'prt_1',
+          field: 'text',
+          delta: 'late',
+        },
+      },
+    })
+    expect(onTextDelta).toHaveBeenCalledTimes(2)
+  })
+  it('removes the hub listener when generate fails after subscribe', async () => {
+    const subscribers = new Set()
+    const globalEventHub = {
+      subscribeEvent(fn) {
+        subscribers.add(fn)
+        return () => { subscribers.delete(fn) }
+      },
+    }
+    const onTextDelta = vi.fn()
+    await expect(generateOpenCodeText({
+      buildOpenCodeUrl: () => 'http://127.0.0.1:4096',
+      getOpenCodeAuthHeaders: () => ({}),
+      providerID: 'opencode',
+      modelID: 'gpt-5-nano',
+      messages: [{ role: 'user', content: 'hi' }],
+      clientFactory: () => ({
+        session: {
+          create: async () => ({ data: { id: 'ses_tmp' } }),
+          update: async () => ({ data: { id: 'ses_tmp' } }),
+          prompt: vi.fn(),
+          promptAsync: async () => ({ response: { status: 204 } }),
+          status: async () => ({ data: { ses_tmp: { type: 'idle' } } }),
+          messages: async () => ({
+            data: [{
+              info: { role: 'assistant', error: { message: 'boom' }, time: { completed: Date.now() } },
+              parts: [],
+            }],
+          }),
+          delete: async () => ({ data: true }),
+        },
+        tool: { ids: async () => ({ data: [] }) },
+      }),
+      ensureTempDirectory: async () => '/tmp/openchamber-llm',
+      detect: async () => ({ available: false, mode: 'throwaway-session' }),
+      onTextDelta,
+      globalEventHub,
+    })).rejects.toMatchObject({ code: 'upstream_error', message: 'boom' })
+    expect(subscribers.size).toBe(0)
+  })
+  it('does not invent deltas on the sessionless /generate JSON path', async () => {
+    const onTextDelta = vi.fn()
+    const subscribers = new Set()
+    const globalEventHub = {
+      subscribeEvent(fn) {
+        subscribers.add(fn)
+        return () => { subscribers.delete(fn) }
+      },
+    }
+    const fetchImpl = vi.fn(async () => new Response(JSON.stringify({ text: 'full reply' }), {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' },
+    }))
+    const result = await generateOpenCodeText({
+      buildOpenCodeUrl: () => 'http://127.0.0.1:4096',
+      getOpenCodeAuthHeaders: () => ({}),
+      providerID: 'opencode',
+      modelID: 'gpt-5-nano',
+      messages: [{ role: 'user', content: 'hi' }],
+      fetchImpl,
+      detect: async () => ({ available: true, mode: 'http', url: 'http://127.0.0.1:4096/generate' }),
+      onTextDelta,
+      globalEventHub,
+    })
+    expect(result).toEqual({ text: 'full reply', source: 'generate' })
+    expect(onTextDelta).not.toHaveBeenCalled()
+    expect(subscribers.size).toBe(0)
+  })
+})
+describe('subscribeThrowawayTextDeltas', () => {
+  it('returns null without a callback or hub', () => {
+    expect(_test.subscribeThrowawayTextDeltas({
+      sessionID: 'ses_1',
+      onTextDelta: null,
+      globalEventHub: { subscribeEvent: () => () => {} },
+    })).toBeNull()
+    expect(_test.subscribeThrowawayTextDeltas({
+      sessionID: 'ses_1',
+      onTextDelta: () => {},
+      globalEventHub: null,
+    })).toBeNull()
+  })
+})

package/server/lib/llm/routes.js ADDED Viewed

@@ -0,0 +1,47 @@
+import { createChatCompletion, LlmError } from './completions.js';
+import { loadConnectedCatalog } from './catalog.js';
+import { createOpencodeClient } from '@opencode-ai/sdk/v2';
+import { ensureLlmTempDirectory } from './temp-directory.js';
+const fail = (res, error) => {
+  const code = error instanceof LlmError ? error.code : error?.code || 'internal_error';
+  const status = error instanceof LlmError
+    ? error.statusCode
+    : code === 'no_provider'
+      ? 400
+      : code === 'validation_error'
+        ? 400
+        : code === 'upstream_error'
+          ? 502
+          : 500;
+  res.status(status).json({ ok: false, error: code, message: error?.message || code });
+};
+export const registerLlmRoutes = (app, dependencies) => {
+  const client = () => createOpencodeClient({
+    baseUrl: dependencies.buildOpenCodeUrl('/', '').replace(/\/$/, ''),
+    headers: dependencies.getOpenCodeAuthHeaders(),
+  });
+  app.get('/api/openchamber/llm/models', (_req, res) => {
+    Promise.resolve()
+      .then(() => loadConnectedCatalog(client()))
+      .then((catalog) => res.json({ ok: true, ...catalog }))
+      .catch((error) => fail(res, error));
+  });
+  app.post('/api/openchamber/llm/chat/completions', (req, res) => {
+    Promise.resolve()
+      .then(() => createChatCompletion({
+        body: req.body,
+        buildOpenCodeUrl: dependencies.buildOpenCodeUrl,
+        getOpenCodeAuthHeaders: dependencies.getOpenCodeAuthHeaders,
+        clientFactory: client,
+        ensureTempDirectory: ensureLlmTempDirectory,
+      }))
+      .then(({ completion }) => {
+        res.status(200).json(completion);
+      })
+      .catch((error) => fail(res, error));
+  });
+};

package/server/lib/llm/temp-directory.js ADDED Viewed

@@ -0,0 +1,37 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+/** @type {string | null} */
+let tempDirectory = null;
+/** @type {Promise<string> | null} */
+let inflight = null;
+export async function ensureLlmTempDirectory({ agentName, agentMarkdown }) {
+  if (tempDirectory) return tempDirectory;
+  if (!inflight) {
+    inflight = (async () => {
+      const root = await fs.mkdtemp(path.join(os.tmpdir(), 'openchamber-llm-'));
+      const agentDir = path.join(root, '.opencode', 'agent');
+      await fs.mkdir(agentDir, { recursive: true });
+      await fs.writeFile(path.join(agentDir, `${agentName}.md`), agentMarkdown, 'utf8');
+      tempDirectory = root;
+      return root;
+    })().finally(() => {
+      inflight = null;
+    });
+  }
+  return inflight;
+}
+export async function stopLlmTempDirectory() {
+  const dir = tempDirectory;
+  tempDirectory = null;
+  inflight = null;
+  if (!dir) return;
+  try {
+    await fs.rm(dir, { recursive: true, force: true });
+  } catch {
+    // Best-effort cleanup of the throwaway generator workspace.
+  }
+}

package/server/lib/notifications/runtime.js CHANGED Viewed

@@ -693,6 +693,57 @@ export const createNotificationTriggerRuntime = (deps) => {
     );
   };
+  const contactNotificationTitle = (name) => {
+    if (typeof name !== 'string' || !name.trim()) return 'Assistant';
+    const stripped = name.replace(/^(?:\p{Extended_Pictographic}|\p{Regional_Indicator}|[\uFE0F\u200D])+\s*/u, '').trim();
+    return stripped || name.trim();
+  };
+  const sendContactTurnNotification = async ({ assistantID, name, body, status } = {}) => {
+    if (typeof assistantID !== 'string' || !assistantID.trim()) return;
+    const settings = await readSettingsFromDisk();
+    if (settings.notifyOnCompletion === false) return;
+    const title = contactNotificationTitle(name);
+    const rawBody = typeof body === 'string' ? body : '';
+    let text = '';
+    try {
+      text = await prepareNotificationLastMessage({ message: rawBody, settings });
+    } catch {
+      text = '';
+    }
+    if (!text) text = status === 'error' ? 'Something went wrong' : 'New message';
+    const tag = `contact-${assistantID.trim()}`;
+    if (settings.nativeNotificationsEnabled) {
+      const notificationPayload = {
+        title,
+        body: text,
+        tag,
+        kind: 'ready',
+        assistantID: assistantID.trim(),
+        requireHidden: false,
+      };
+      const desktopNotificationDelivered = emitDesktopNotification(notificationPayload);
+      broadcastUiNotification(notificationPayload, { desktopNotificationDelivered });
+    }
+    await fanoutPush(
+      {
+        title,
+        body: text,
+        tag,
+        data: {
+          url: `/?assistant=${encodeURIComponent(assistantID.trim())}`,
+          assistantID: assistantID.trim(),
+          sessionName: title,
+          type: 'ready',
+        },
+      },
+      { requireNoSse: true },
+    );
+  };
   return {
     maybeSendPushForTrigger,
     setAutoAcceptSession,
@@ -700,5 +751,6 @@ export const createNotificationTriggerRuntime = (deps) => {
     setGetIsSessionAutoAccepting,
     clearPendingPushBadge,
     sendGoalSettlePush,
+    sendContactTurnNotification,
   };
 };

package/server/lib/notifications/runtime.test.js CHANGED Viewed

@@ -199,6 +199,45 @@ const completionPayload = (sessionId = 'ses_root', finish = 'stop') => ({
   },
 });
+describe('contact turn notifications', () => {
+  it('sends an SMS-style title and body when a contact turn completes', async () => {
+    const { runtime, emitDesktopNotification, broadcastUiNotification, sendPushToAllUiSessions } = createRuntime();
+    await runtime.sendContactTurnNotification({
+      assistantID: 'asst_1',
+      name: '大小白',
+      body: '我去找一下',
+      status: 'complete',
+    });
+    expect(emitDesktopNotification).toHaveBeenCalledWith(expect.objectContaining({
+      title: '大小白',
+      body: '我去找一下',
+      tag: 'contact-asst_1',
+      kind: 'ready',
+      assistantID: 'asst_1',
+    }));
+    expect(broadcastUiNotification).toHaveBeenCalled();
+    expect(sendPushToAllUiSessions).toHaveBeenCalledWith(expect.objectContaining({
+      title: '大小白',
+      body: '我去找一下',
+      data: expect.objectContaining({ assistantID: 'asst_1', type: 'ready' }),
+    }), { requireNoSse: true });
+  });
+  it('skips contact notifications when completion notices are disabled', async () => {
+    const { runtime, emitDesktopNotification, sendPushToAllUiSessions } = createRuntime({
+      readSettingsFromDisk: vi.fn(async () => ({ ...defaultSettings, notifyOnCompletion: false })),
+    });
+    await runtime.sendContactTurnNotification({
+      assistantID: 'asst_1',
+      name: '大小白',
+      body: 'hi',
+      status: 'complete',
+    });
+    expect(emitDesktopNotification).not.toHaveBeenCalled();
+    expect(sendPushToAllUiSessions).not.toHaveBeenCalled();
+  });
+});
 describe('notification trigger live activity end', () => {
   it('ends the live activity on top-level completion and error', async () => {
     vi.stubGlobal('fetch', vi.fn(async () => rootSessionResponse()));