@openchambery/web 1.19.13 → 1.19.14

package/server/lib/assistants/contact-tools.test.js

@@ -13,9 +13,13 @@ import {
   NEW_CONVERSATION_CONFIRM_BUBBLE,
   NEW_CONVERSATION_TOOL_NAME,
   SCHEDULE_TASK_TOOL_NAME,
+  STOP_SESSION_TOOL_NAME,
+  STOPPED_SESSION_FALLBACK_BUBBLE,
   UPDATE_DEFAULT_PROMPT_CONFIRM_BUBBLE,
   UPDATE_DEFAULT_PROMPT_TOOL_NAME,
   UPDATE_DEFAULT_PROMPT_UNCHANGED_BUBBLE,
+  WATCH_SESSION_TOOL_NAME,
+  WATCHED_SESSION_FALLBACK_BUBBLE,
   confirmBubbleAfterContactReset,
   contactTurnHasSuccessfulReset,
   createContactTools,
@@ -35,11 +39,45 @@ import {
 import { attachmentScopeKey } from './assign.js';
 
 describe('contact tool protocol', () => {
+  it('shows current-instance models with ordered favorites and recents using exact ids', () => {
+    const prompt = formatConnectedModelsPrompt([
+      { providerID: 'p', providerName: 'Connected Provider', modelID: 'claude-sonnet-4-6', name: 'Claude Sonnet 4.6' },
+      { providerID: 'q', modelID: 'gpt-5.4', name: 'GPT 5.4' },
+    ], { preferences: {
+      favoriteModels: [{ providerID: 'q', modelID: 'gpt-5.4', variant: 'high' }, { providerID: 'gone', modelID: 'offline' }],
+      recentModels: [{ providerID: 'p', modelID: 'claude-sonnet-4-6' }, { providerID: 'q', modelID: 'gpt-5.4' }],
+    } })
+    expect(prompt).toContain('Connected Provider')
+    expect(prompt).toContain('Favorite models (saved order)')
+    expect(prompt).toContain('Recent models (most recent first)')
+    expect(prompt).toContain('variant="high"')
+    expect(prompt).not.toContain('offline')
+    const recent = prompt.split('Recent models (most recent first)')[1]
+    expect(recent.indexOf('claude-sonnet-4-6')).toBeLessThan(recent.indexOf('gpt-5.4'))
+  })
+
+  it('distinguishes unavailable model preferences from successfully empty lists', () => {
+    expect(formatConnectedModelsPrompt([], { preferences: null })).toContain('preferences unavailable')
+    expect(formatConnectedModelsPrompt([], { preferences: { favoriteModels: [], recentModels: [] } })).toContain('Favorite models (saved order): none')
+    expect(formatConnectedModelsPrompt([], { catalogAvailable: false })).toContain('catalog unavailable')
+  })
+
+  it('parses watch_session and stop_session fences', () => {
+    const watchText = '```openchamber-tool\n{"name":"watch_session","arguments":{"sessionID":"ses_w"}}\n```';
+    expect(parseContactToolCalls(watchText, [WATCH_SESSION_TOOL_NAME, STOP_SESSION_TOOL_NAME]).toolCalls).toEqual([
+      { name: WATCH_SESSION_TOOL_NAME, arguments: { sessionID: 'ses_w' } },
+    ]);
+    const stopText = '好的 {"name":"stop_session","arguments":{"sessionID":"ses_s"}}';
+    expect(parseContactToolCalls(stopText, [WATCH_SESSION_TOOL_NAME, STOP_SESSION_TOOL_NAME]).toolCalls).toEqual([
+      { name: STOP_SESSION_TOOL_NAME, arguments: { sessionID: 'ses_s' } },
+    ]);
+  });
+
   it('parses an assign_session fence and strips it from chat text', () => {
     const text = 'On it.\n\n```openchamber-tool\n{"name":"assign_session","arguments":{"prompt":"Fix login","projectPath":"/repo"}}\n```';
     const parsed = parseContactToolCalls(text, [ASSIGN_SESSION_TOOL_NAME]);
     expect(parsed.chatText).toBe('On it.');
-    expect(parsed.toolCall).toEqual({
+    expect(parsed.toolCalls[0]).toEqual({
       name: ASSIGN_SESSION_TOOL_NAME,
       arguments: { prompt: 'Fix login', projectPath: '/repo' },
     });
@@ -52,7 +90,7 @@ describe('contact tool protocol', () => {
       [CREATE_ASSISTANT_TOOL_NAME, SCHEDULE_TASK_TOOL_NAME, ASSIGN_SESSION_TOOL_NAME],
     );
     expect(create.chatText).toBe('好。');
-    expect(create.toolCall).toEqual({
+    expect(create.toolCalls[0]).toEqual({
       name: CREATE_ASSISTANT_TOOL_NAME,
       arguments: { name: 'FlowQA', model: 'opencode-go/deepseek-v4-flash' },
     });
@@ -64,11 +102,11 @@ describe('contact tool protocol', () => {
       '```openchamber-tool\n{"name":"message_assistant","arguments":{"to":"PeerQA","text":"hello-from-assistant 写好了"}}\n```',
       [MESSAGE_ASSISTANT_TOOL_NAME],
     );
-    expect(peer.toolCall).toEqual({
+    expect(peer.toolCalls[0]).toEqual({
       name: MESSAGE_ASSISTANT_TOOL_NAME,
       arguments: { to: 'PeerQA', text: 'hello-from-assistant 写好了' },
     });
-    expect(schedule.toolCall).toEqual({
+    expect(schedule.toolCalls[0]).toEqual({
       name: SCHEDULE_TASK_TOOL_NAME,
       arguments: { name: 'Daily ping', prompt: 'ping', time: '18:00', timezone: 'Asia/Shanghai' },
     });
@@ -79,7 +117,7 @@ describe('contact tool protocol', () => {
       '好的，我来直接创建这个助理，不开编码会话。\n{"name":"create_assistant","arguments":{"name":"FlowNL","model":"opencode-go/deepseek-v4-flash"}}',
       [CREATE_ASSISTANT_TOOL_NAME, ASSIGN_SESSION_TOOL_NAME],
     );
-    expect(parsed.toolCall).toEqual({
+    expect(parsed.toolCalls[0]).toEqual({
       name: CREATE_ASSISTANT_TOOL_NAME,
       arguments: { name: 'FlowNL', model: 'opencode-go/deepseek-v4-flash' },
     });
@@ -87,6 +125,94 @@ describe('contact tool protocol', () => {
     expect(parsed.chatText).not.toContain('create_assistant');
   });
 
+  it('accepts the existing single-call fence without a newline', () => {
+    expect(parseContactToolCalls('```openchamber-tool {"name":"read","arguments":{"path":"sample.md"}}```', ['read']).toolCalls)
+      .toEqual([{ name: 'read', arguments: { path: 'sample.md' } }]);
+  });
+
+  it('does not execute tool-shaped JSON inside other protocol or example fences', () => {
+    const text = '```openchamber-final\n{"status":"complete","text":"done","example":{"name":"bash","arguments":{"command":"pwd"}}}\n```';
+    expect(parseContactToolCalls(text, ['bash'])).toEqual({ chatText: text, toolCalls: [] });
+  });
+
+  it.each(['json\n', '\n', ''])('preserves complete tool payloads in generic fences: %s', (header) => {
+    const call = { name: 'read', arguments: { path: 'sample.md' } };
+    const result = parseContactToolCalls(`Before \`\`\`${header}${JSON.stringify(call)}\`\`\` After`, ['read']);
+    expect(result.toolCalls).toEqual([call]);
+    expect(result.chatText).toBe('Before  After');
+  });
+
+  it('does not run nested or partial tool examples in generic fences', () => {
+    const text = '```json\n{"example":{"name":"bash","arguments":{"command":"pwd"}}}\n```';
+    expect(parseContactToolCalls(text, ['bash'])).toEqual({ chatText: text, toolCalls: [] });
+    const prose = '```\nExample: {"name":"bash","arguments":{"command":"pwd"}}\n```';
+    expect(parseContactToolCalls(prose, ['bash'])).toEqual({ chatText: prose, toolCalls: [] });
+  });
+
+  it('retains every tool call in order across fenced and embedded JSON', () => {
+    const calls = [
+      { name: 'read', arguments: { path: 'sample.md' } },
+      { name: 'bash', arguments: { command: 'date +%F' } },
+      { name: 'write', arguments: { path: 'result.md', content: 'done' } },
+    ];
+    const text = `Before ${JSON.stringify(calls[0])}\n\n\`\`\`openchamber-tool\n${JSON.stringify(calls[1])}\n\`\`\`\nAfter ${JSON.stringify(calls[2])}`;
+    const result = parseContactToolCalls(text, ['read', 'bash', 'write']);
+    expect(result.toolCalls).toEqual(calls);
+    expect(result.chatText).toContain('Before');
+    expect(result.chatText).toContain('After');
+    expect(result.chatText).not.toContain('arguments');
+    expect(result.protocolError).toBeUndefined();
+  });
+
+  it('keeps markdown fences and escaped quotes inside JSON string arguments', () => {
+    const calls = [
+      { name: 'write', arguments: { path: 'note.md', content: '```json\n{"quoted": "value"}\n```' } },
+      { name: 'read', arguments: { path: 'note.md' } },
+    ];
+    const text = calls.map((call) => `\`\`\`openchamber-tool\n${JSON.stringify(call)}\n\`\`\``).join('\n');
+    expect(parseContactToolCalls(text, ['read', 'write'])).toEqual({ chatText: '', toolCalls: calls });
+  });
+
+  it('preserves both calls from the observed read-sample and bash-date response', () => {
+    const calls = [
+      { name: 'read', arguments: { path: 'notes/sample.md' } },
+      { name: 'bash', arguments: { command: 'date +%F' } },
+    ];
+    const text = calls.map((call) => `\`\`\`openchamber-tool\n${JSON.stringify(call)}\n\`\`\``).join('\n\n');
+    expect(parseContactToolCalls(text, ['read', 'bash'])).toEqual({ chatText: '', toolCalls: calls });
+  });
+
+  it.each([
+    '{bad json}',
+    '{"name":"unknown","arguments":{}}',
+    '{"name":"read","arguments":[]}',
+    '',
+  ])('rejects the complete batch when an explicit tool fence is invalid: %s', (invalid) => {
+    const valid = '\`\`\`openchamber-tool\n{"name":"read","arguments":{"path":"sample.md"}}\n\`\`\`';
+    const result = parseContactToolCalls(`${valid}\n\`\`\`openchamber-tool\n${invalid}\n\`\`\``, ['read']);
+    expect(result.toolCalls).toEqual([]);
+    expect(result.protocolError).toEqual(expect.any(String));
+  });
+
+  it('rejects a truncated explicit tool fence without executing an earlier call', () => {
+    const result = parseContactToolCalls('{"name":"read","arguments":{"path":"sample.md"}}\n\`\`\`openchamber-tool\n{"name":"read"', ['read']);
+    expect(result.toolCalls).toEqual([]);
+    expect(result.protocolError).toEqual(expect.any(String));
+  });
+
+  it.each(['', '{"name":"read","arguments":{"path":"sample.md"}}\n'])('rejects an unclosed outer JSON object without executing a nested call or valid prefix', (prefix) => {
+    const result = parseContactToolCalls(prefix + '{"example": {"name":"bash","arguments":{"command":"pwd"}}', ['read', 'bash']);
+    expect(result.toolCalls).toEqual([]);
+    expect(result.protocolError).toEqual(expect.any(String));
+  });
+
+  it('does not discover nested JSON arguments or strings as additional tool calls', () => {
+    const nested = { name: 'bash', arguments: { command: 'pwd' } };
+    const call = { name: 'write', arguments: { path: 'result.json', content: JSON.stringify(nested), metadata: nested } };
+    expect(parseContactToolCalls(JSON.stringify(call), ['write', 'bash']).toolCalls).toEqual([call]);
+    expect(parseContactToolCalls(JSON.stringify({ example: nested }), ['bash']).toolCalls).toEqual([]);
+  });
+
   it('detects 建助理 without treating 不要开编码 session as assign_session', () => {
     const tools = [
       NEW_CONVERSATION_TOOL_NAME,
@@ -98,6 +224,8 @@ describe('contact tool protocol', () => {
       CREATE_ASSISTANT_TOOL_NAME,
       SCHEDULE_TASK_TOOL_NAME,
       MESSAGE_ASSISTANT_TOOL_NAME,
+      WATCH_SESSION_TOOL_NAME,
+      STOP_SESSION_TOOL_NAME,
       ASSIGN_SESSION_TOOL_NAME,
     ];
     expect(detectRequestedContactTools('帮我新建一个助理，名叫 FlowNL，不要开编码 session', tools)).toEqual([
@@ -106,6 +234,14 @@ describe('contact tool protocol', () => {
     expect(detectRequestedContactTools('每天 18:00 排一个 ping 定时任务', tools)).toEqual([SCHEDULE_TASK_TOOL_NAME]);
     expect(detectRequestedContactTools('建会话写一个文件', tools)).toEqual([ASSIGN_SESSION_TOOL_NAME]);
     expect(detectRequestedContactTools('对，你直接派给那个项目组，再建个会话去修这个问题', tools)).toEqual([ASSIGN_SESSION_TOOL_NAME]);
+    expect(detectRequestedContactTools('继续这个会话修 login', tools)).toEqual([ASSIGN_SESSION_TOOL_NAME]);
+    expect(detectRequestedContactTools('监听这个会话', tools)).toEqual([WATCH_SESSION_TOOL_NAME]);
+    expect(detectRequestedContactTools('watch this session', tools)).toEqual([WATCH_SESSION_TOOL_NAME]);
+    expect(detectRequestedContactTools('停止这个会话', tools)).toEqual([STOP_SESSION_TOOL_NAME]);
+    expect(detectRequestedContactTools('stop that session', tools)).toEqual([STOP_SESSION_TOOL_NAME]);
+    // Plain @session reference is context only — not auto watch/assign/stop.
+    expect(detectRequestedContactTools('看看 @session:ses_abc 里上次说了啥', tools)).toEqual([]);
+    expect(detectRequestedContactTools('@session:ses_abc', tools)).toEqual([]);
     expect(detectRequestedContactTools('写一个文件', tools)).toEqual([]);
     expect(detectRequestedContactTools('pwd', tools)).toEqual([]);
     expect(detectRequestedContactTools('给 PeerQA 说一声 hello-from-assistant 写好了', tools)).toEqual([
@@ -141,14 +277,14 @@ describe('contact tool protocol', () => {
 
   it('parses bash fences when the pi coding tools are allowed', () => {
     const text = '```openchamber-tool\n{"name":"bash","arguments":{"command":"pwd"}}\n```';
-    expect(parseContactToolCalls(text, ['bash', ASSIGN_SESSION_TOOL_NAME]).toolCall).toEqual({
+    expect(parseContactToolCalls(text, ['bash', ASSIGN_SESSION_TOOL_NAME]).toolCalls[0]).toEqual({
       name: 'bash',
       arguments: { command: 'pwd' },
     });
     expect(parseContactToolCalls(
       '```openchamber-tool\n{"name":"glob","arguments":{"pattern":"*"}}\n```',
       ['glob', 'bash'],
-    ).toolCall).toBeNull();
+    ).toolCalls).toEqual([]);
   });
 
   it('tells DeepSeek to call tools from natural language, not slash commands', () => {
@@ -163,6 +299,8 @@ describe('contact tool protocol', () => {
     expect(prompt).toContain('schedule_task');
     expect(prompt).toContain('message_assistant');
     expect(prompt).toContain('assign_session');
+    expect(prompt).toContain('watch_session');
+    expect(prompt).toContain('stop_session');
     expect(prompt).toContain('开新对话');
     expect(prompt).toContain('清除记忆');
     expect(prompt).toContain('清空聊天记录');
@@ -173,6 +311,9 @@ describe('contact tool protocol', () => {
     expect(prompt).toContain('建助理');
     expect(prompt).toContain('排定时任务');
     expect(prompt).toContain('说一声');
+    expect(prompt).toContain('监听会话');
+    expect(prompt).toContain('停止会话');
+    expect(prompt).toContain('plain @session:id reference alone is context');
     expect(prompt).toContain('session/new');
     expect(prompt).toContain('LLM memory only');
     expect(prompt).toContain('Persists');
@@ -290,12 +431,18 @@ describe('createContactTools', () => {
       CLEAR_CHAT_HISTORY_TOOL_NAME,
       LIST_PROJECTS_TOOL_NAME,
       LIST_SESSIONS_TOOL_NAME,
+      'read_session',
       GET_ASSISTANT_SETTINGS_TOOL_NAME,
       UPDATE_DEFAULT_PROMPT_TOOL_NAME,
       CREATE_ASSISTANT_TOOL_NAME,
       SCHEDULE_TASK_TOOL_NAME,
       MESSAGE_ASSISTANT_TOOL_NAME,
       ASSIGN_SESSION_TOOL_NAME,
+      WATCH_SESSION_TOOL_NAME,
+      STOP_SESSION_TOOL_NAME,
+      'steer_session',
+      'archive_session',
+      'delete_session',
     ]);
     expect(tools.some((tool) => ['bash', 'edit', 'read', 'write'].includes(tool.name))).toBe(false);
 
@@ -374,6 +521,91 @@ describe('createContactTools', () => {
     expect(onCard).toHaveBeenCalledTimes(3);
   });
 
+  it.each(['assign_session', 'watch_session'])('%s forwards AbortSignal and drops a late card after cancellation', async (name) => {
+    const controller = new AbortController();
+    const onCard = vi.fn();
+    const action = vi.fn(async input => {
+      expect(input.signal).toBe(controller.signal);
+      controller.abort();
+      return { sessionID: 'ses_late', directory: '/project', title: 'Late', status: 'busy' };
+    });
+    const tools = createContactTools({ assignWork: action, watchSession: action, onCard });
+    const tool = tools.find(t => t.name === name);
+    const result = await tool.execute('call', { sessionID: 'ses_late', prompt: 'work' }, controller.signal);
+    expect(result.details.error).toBeDefined();
+    expect(onCard).not.toHaveBeenCalled();
+    await tool.execute('call2', { sessionID: 'ses_late', prompt: 'work' }, controller.signal);
+    expect(action).toHaveBeenCalledTimes(1);
+  });
+
+  it('recognizes explicit session mutation requests and forwards cancellation signals', async () => {
+    const action = vi.fn(async () => ({ admitted: true }));
+    const tools = createContactTools({ steerSession: action, archiveSession: action, deleteSession: action });
+    expect(detectRequestedContactTools('取消这个 session', tools.map(t => t.name))).toEqual(['stop_session']);
+    expect(detectRequestedContactTools('归档这个会话', tools.map(t => t.name))).toEqual(['archive_session']);
+    expect(detectRequestedContactTools('删除这个 session', tools.map(t => t.name))).toEqual(['delete_session']);
+    expect(detectRequestedContactTools('给这个会话插话：先运行测试', tools.map(t => t.name))).toEqual(['steer_session']);
+    const controller = new AbortController();
+    const result = await tools.find(t => t.name === 'steer_session').execute('call', { sessionID: 'ses_exact', text: '先运行测试' }, controller.signal);
+    expect(action).toHaveBeenCalledWith({ sessionID: 'ses_exact', text: '先运行测试', signal: controller.signal });
+    expect(result.terminate).toBe(true);
+    expect(result.isError).not.toBe(true);
+    const invalid = await tools.find(t => t.name === 'steer_session').execute('call2', { sessionID: 'ses_exact', text: ' ' });
+    expect(invalid.details.error).toBe('validation_error');
+    expect(action).toHaveBeenCalledTimes(1);
+  });
+
+  it('watch_session emits a baseline session card and stop_session returns true abort results', async () => {
+    const onCard = vi.fn();
+    const watchSession = vi.fn(async () => ({
+      sessionID: 'ses_watch',
+      directory: '/repo',
+      title: 'Watched',
+      status: 'complete',
+      watched: true,
+      reused: true,
+    }));
+    const stopSession = vi.fn(async () => ({
+      sessionID: 'ses_watch',
+      directory: '/repo',
+      title: 'Watched',
+      aborted: true,
+    }));
+    const tools = createContactTools({ watchSession, stopSession, onCard });
+    const watched = await tools.find((tool) => tool.name === WATCH_SESSION_TOOL_NAME).execute('call_w', {
+      sessionID: 'ses_watch',
+    });
+    expect(watchSession).toHaveBeenCalledWith({ sessionID: 'ses_watch' });
+    expect(watched.terminate).toBe(true);
+    expect(watched.content[0].text).toBe(WATCHED_SESSION_FALLBACK_BUBBLE);
+    expect(watched.details.card).toMatchObject({
+      type: 'card',
+      cardType: 'session',
+      sessionID: 'ses_watch',
+      status: 'complete',
+    });
+    expect(onCard).toHaveBeenCalledTimes(1);
+
+    const stopped = await tools.find((tool) => tool.name === STOP_SESSION_TOOL_NAME).execute('call_s', {
+      sessionID: 'ses_watch',
+    });
+    expect(stopSession).toHaveBeenCalledWith({ sessionID: 'ses_watch' });
+    expect(stopped.terminate).toBe(true);
+    expect(stopped.content[0].text).toBe(STOPPED_SESSION_FALLBACK_BUBBLE);
+    expect(stopped.details.stopped).toMatchObject({ aborted: true, sessionID: 'ses_watch' });
+
+    const failedStop = createContactTools({
+      stopSession: async () => {
+        throw new AssignError(ASSIGN_CODES.UPSTREAM, 'abort refused');
+      },
+    });
+    const failed = await failedStop.find((tool) => tool.name === STOP_SESSION_TOOL_NAME).execute('call_f', {
+      sessionID: 'ses_watch',
+    });
+    expect(failed.details.error).toBe('upstream_error');
+    expect(failed.content[0].text).toContain('abort refused');
+  });
+
   it('forwards server turn file parts on assign and keeps model selection in the tool args', async () => {
     const image = { type: 'file', mime: 'image/png', url: 'data:image/png;base64,aa', filename: 'shot.png' };
     const assignWork = vi.fn(async (params) => ({

package/server/lib/assistants/contracts.js

@@ -28,10 +28,41 @@ export const assistantContractFixtures = Object.freeze({
       text: 'Fixture reply',
       fallbackKind: null,
     }),
+    /** Countable assistant/peer replies after the shared read watermark. */
+    unreadCount: 0,
+    /** Persisted shared read watermark (multi-client). */
+    readWatermark: Object.freeze({
+      generation: 0,
+      ordinal: 2,
+      messageID: 'msg_contact_fixture',
+    }),
+    /** Highest safe mark-read tip (transcript head + generation). */
+    readTip: Object.freeze({
+      generation: 0,
+      ordinal: 2,
+      messageID: 'msg_contact_fixture',
+    }),
     createdAt: 1234,
     updatedAt: 1234,
     tombstoneAt: null,
   }),
+  /** Frozen POST /assistants/:id/contact/read response. */
+  contactReadResponse: Object.freeze({
+    assistantID: 'assistant_fixture',
+    changed: true,
+    unreadCount: 0,
+    readWatermark: Object.freeze({
+      generation: 0,
+      ordinal: 2,
+      messageID: 'msg_contact_fixture',
+    }),
+    readTip: Object.freeze({
+      generation: 0,
+      ordinal: 2,
+      messageID: 'msg_contact_fixture',
+    }),
+    revision: 4,
+  }),
   sessionBinding: Object.freeze({ sessionID: 'ses_fixture', directory: '/workspace', sessionGeneration: 4 }),
   compactResponse: Object.freeze({ binding: Object.freeze({ sessionID: 'ses_fixture', directory: '/workspace', sessionGeneration: 4 }), summarized: true }),
   messageAdmission: Object.freeze({ binding: Object.freeze({ sessionID: 'ses_fixture', directory: '/workspace', sessionGeneration: 4 }), messageID: 'msg_fixture', admitted: true, revision: 4 }),