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

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

@@ -0,0 +1,328 @@
+import { describe, expect, it, vi } from 'vitest';
+import { AssignError, ASSIGN_CODES, PROJECT_REQUIRED_MESSAGE } from './assign.js';
+import {
+  ASSIGN_SESSION_TOOL_NAME,
+  CREATE_ASSISTANT_TOOL_NAME,
+  LIST_PROJECTS_TOOL_NAME,
+  LIST_SESSIONS_TOOL_NAME,
+  MESSAGE_ASSISTANT_TOOL_NAME,
+  NEW_CONVERSATION_CONFIRM_BUBBLE,
+  NEW_CONVERSATION_TOOL_NAME,
+  SCHEDULE_TASK_TOOL_NAME,
+  confirmBubbleAfterContactReset,
+  createContactTools,
+  detectRequestedContactTools,
+  filterRegisteredProjects,
+  formatContactToolsPrompt,
+  formatRegisteredProjectsPrompt,
+  matchesProjectQuery,
+  parseContactToolCalls,
+  resolveContactProviderModel,
+  resolvePeerAssistant,
+  stripContactToolFences,
+} from './contact-tools.js';
+
+describe('contact tool protocol', () => {
+  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({
+      name: ASSIGN_SESSION_TOOL_NAME,
+      arguments: { prompt: 'Fix login', projectPath: '/repo' },
+    });
+    expect(stripContactToolFences(text)).toBe('On it.');
+  });
+
+  it('parses create_assistant and schedule_task fences from natural-language replies', () => {
+    const create = parseContactToolCalls(
+      '好。\n\n```openchamber-tool\n{"name":"create_assistant","arguments":{"name":"FlowQA","model":"opencode-go/deepseek-v4-flash"}}\n```',
+      [CREATE_ASSISTANT_TOOL_NAME, SCHEDULE_TASK_TOOL_NAME, ASSIGN_SESSION_TOOL_NAME],
+    );
+    expect(create.chatText).toBe('好。');
+    expect(create.toolCall).toEqual({
+      name: CREATE_ASSISTANT_TOOL_NAME,
+      arguments: { name: 'FlowQA', model: 'opencode-go/deepseek-v4-flash' },
+    });
+    const schedule = parseContactToolCalls(
+      '```openchamber-tool\n{"name":"schedule_task","arguments":{"name":"Daily ping","prompt":"ping","time":"18:00","timezone":"Asia/Shanghai"}}\n```',
+      [CREATE_ASSISTANT_TOOL_NAME, SCHEDULE_TASK_TOOL_NAME],
+    );
+    const peer = parseContactToolCalls(
+      '```openchamber-tool\n{"name":"message_assistant","arguments":{"to":"PeerQA","text":"hello-from-assistant 写好了"}}\n```',
+      [MESSAGE_ASSISTANT_TOOL_NAME],
+    );
+    expect(peer.toolCall).toEqual({
+      name: MESSAGE_ASSISTANT_TOOL_NAME,
+      arguments: { to: 'PeerQA', text: 'hello-from-assistant 写好了' },
+    });
+    expect(schedule.toolCall).toEqual({
+      name: SCHEDULE_TASK_TOOL_NAME,
+      arguments: { name: 'Daily ping', prompt: 'ping', time: '18:00', timezone: 'Asia/Shanghai' },
+    });
+  });
+
+  it('parses a bare {name, arguments} object anywhere in the assistant text', () => {
+    const parsed = parseContactToolCalls(
+      '好的，我来直接创建这个助理，不开编码会话。\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({
+      name: CREATE_ASSISTANT_TOOL_NAME,
+      arguments: { name: 'FlowNL', model: 'opencode-go/deepseek-v4-flash' },
+    });
+    expect(parsed.chatText).toContain('好的，我来直接创建这个助理');
+    expect(parsed.chatText).not.toContain('create_assistant');
+  });
+
+  it('detects 建助理 without treating 不要开编码 session as assign_session', () => {
+    const tools = [
+      NEW_CONVERSATION_TOOL_NAME,
+      LIST_PROJECTS_TOOL_NAME,
+      LIST_SESSIONS_TOOL_NAME,
+      CREATE_ASSISTANT_TOOL_NAME,
+      SCHEDULE_TASK_TOOL_NAME,
+      MESSAGE_ASSISTANT_TOOL_NAME,
+      ASSIGN_SESSION_TOOL_NAME,
+    ];
+    expect(detectRequestedContactTools('帮我新建一个助理，名叫 FlowNL，不要开编码 session', tools)).toEqual([
+      CREATE_ASSISTANT_TOOL_NAME,
+    ]);
+    expect(detectRequestedContactTools('每天 18:00 排一个 ping 定时任务', tools)).toEqual([SCHEDULE_TASK_TOOL_NAME]);
+    expect(detectRequestedContactTools('建会话写一个文件', tools)).toEqual([ASSIGN_SESSION_TOOL_NAME]);
+    expect(detectRequestedContactTools('给 PeerQA 说一声 hello-from-assistant 写好了', tools)).toEqual([
+      MESSAGE_ASSISTANT_TOOL_NAME,
+    ]);
+    expect(detectRequestedContactTools('开新对话', tools)).toEqual([NEW_CONVERSATION_TOOL_NAME]);
+    expect(detectRequestedContactTools('new conversation please', tools)).toEqual([NEW_CONVERSATION_TOOL_NAME]);
+    expect(detectRequestedContactTools('clear chat', tools)).toEqual([NEW_CONVERSATION_TOOL_NAME]);
+    expect(detectRequestedContactTools('找项目 openchamber yee', tools)).toEqual([LIST_PROJECTS_TOOL_NAME]);
+    expect(detectRequestedContactTools('看看现有对话', tools)).toEqual([LIST_SESSIONS_TOOL_NAME]);
+    expect(detectRequestedContactTools('list sessions in that project', tools)).toEqual([LIST_SESSIONS_TOOL_NAME]);
+    expect(detectRequestedContactTools('开新对话', tools)).not.toContain(ASSIGN_SESSION_TOOL_NAME);
+    expect(detectRequestedContactTools('不要开编码 session', tools)).toEqual([]);
+  });
+
+  it('ignores bash/edit tool fences', () => {
+    const text = '```openchamber-tool\n{"name":"bash","arguments":{"command":"ls"}}\n```';
+    expect(parseContactToolCalls(text, ['bash', ASSIGN_SESSION_TOOL_NAME]).toolCall).toBeNull();
+  });
+
+  it('tells DeepSeek to call tools from natural language, not slash commands', () => {
+    const prompt = formatContactToolsPrompt(createContactTools());
+    expect(prompt).toContain('new_conversation');
+    expect(prompt).toContain('list_projects');
+    expect(prompt).toContain('list_sessions');
+    expect(prompt).toContain('create_assistant');
+    expect(prompt).toContain('schedule_task');
+    expect(prompt).toContain('message_assistant');
+    expect(prompt).toContain('assign_session');
+    expect(prompt).toContain('开新对话');
+    expect(prompt).toContain('找项目');
+    expect(prompt).toContain('现有对话');
+    expect(prompt).toContain('建助理');
+    expect(prompt).toContain('排定时任务');
+    expect(prompt).toContain('说一声');
+    expect(prompt).toContain('session/new');
+    expect(prompt).not.toContain('/card');
+    expect(prompt).not.toContain('/dm');
+    expect(prompt).toContain('A reply without the tool call does nothing');
+    expect(prompt).toContain('已创建');
+    expect(prompt).toContain('Never claim you cannot see projects');
+  });
+
+  it('fuzzy-matches project labels like openchamber yee / openchamer yee', () => {
+    const project = { id: 'p1', path: '/Users/me/Code/openchamber-yee', label: 'OpenChamber Yee' };
+    expect(matchesProjectQuery(project, 'openchamber yee')).toBe(true);
+    expect(matchesProjectQuery(project, 'openchamer yee')).toBe(true);
+    expect(matchesProjectQuery(project, 'missing')).toBe(false);
+    expect(filterRegisteredProjects([project, { id: 'p2', path: '/other' }], 'openchamber')).toEqual([
+      { id: 'p1', path: '/Users/me/Code/openchamber-yee', label: 'OpenChamber Yee' },
+    ]);
+    expect(formatRegisteredProjectsPrompt([project])).toContain('OpenChamber Yee');
+    expect(formatRegisteredProjectsPrompt([project])).toContain('never say you cannot see registered projects');
+    expect(formatRegisteredProjectsPrompt([])).toContain('none');
+  });
+
+  it('resolves provider/model from a combined OpenCode id', () => {
+    expect(resolveContactProviderModel({ model: 'opencode-go/deepseek-v4-flash' })).toEqual({
+      providerID: 'opencode-go',
+      modelID: 'deepseek-v4-flash',
+    });
+    expect(resolveContactProviderModel({}, { providerID: 'p', modelID: 'm' })).toEqual({
+      providerID: 'p',
+      modelID: 'm',
+    });
+  });
+});
+
+describe('createContactTools', () => {
+  it('exposes create_assistant, schedule_task, and assign_session and returns success cards', async () => {
+    const onCard = vi.fn();
+    const resetContact = vi.fn(async () => ({ reset: true }));
+    const tools = createContactTools({
+      resetContact,
+      createAssistant: async (input) => ({
+        id: 'asst_flow',
+        name: input.name,
+        providerID: input.providerID,
+        modelID: input.modelID,
+        mode: 'continuous',
+      }),
+      scheduleTask: async (input) => ({
+        taskID: 'task_1',
+        projectID: 'proj_1',
+        name: input.name,
+        kind: 'daily',
+        time: input.time,
+        timezone: input.timezone,
+        prompt: input.prompt,
+      }),
+      assignWork: async () => ({
+        sessionID: 'ses_1',
+        directory: '/repo',
+        title: 'Login',
+        status: 'busy',
+      }),
+      deliverPeerMessage: async (input) => ({
+        admitted: true,
+        role: 'peer',
+        toAssistantID: input.toAssistantID,
+      }),
+      listAssistants: async () => [{ id: 'asst_peer', name: 'PeerQA' }],
+      currentAssistant: { id: 'asst_host', providerID: 'p', modelID: 'm' },
+      onCard,
+    });
+    expect(tools.map((tool) => tool.name)).toEqual([
+      NEW_CONVERSATION_TOOL_NAME,
+      LIST_PROJECTS_TOOL_NAME,
+      LIST_SESSIONS_TOOL_NAME,
+      CREATE_ASSISTANT_TOOL_NAME,
+      SCHEDULE_TASK_TOOL_NAME,
+      MESSAGE_ASSISTANT_TOOL_NAME,
+      ASSIGN_SESSION_TOOL_NAME,
+    ]);
+    expect(tools.some((tool) => ['bash', 'edit', 'read', 'write'].includes(tool.name))).toBe(false);
+
+    const reset = await tools.find((tool) => tool.name === NEW_CONVERSATION_TOOL_NAME).execute('call_0', {});
+    expect(resetContact).toHaveBeenCalledTimes(1);
+    expect(reset.details.card).toBeUndefined();
+    expect(reset.details.reset).toBe(true);
+    expect(reset.terminate).toBe(true);
+    expect(reset.content[0].text).toBe(NEW_CONVERSATION_CONFIRM_BUBBLE);
+
+    const created = await tools.find((tool) => tool.name === CREATE_ASSISTANT_TOOL_NAME).execute('call_1', { name: 'FlowQA', model: 'opencode-go/deepseek-v4-flash' });
+    expect(created.details.card).toMatchObject({
+      type: 'card',
+      cardType: 'assistant',
+      assistantID: 'asst_flow',
+      name: 'FlowQA',
+      providerID: 'opencode-go',
+      modelID: 'deepseek-v4-flash',
+    });
+    expect(created.terminate).toBe(false);
+
+    const scheduled = await tools.find((tool) => tool.name === SCHEDULE_TASK_TOOL_NAME).execute('call_2', {
+      name: 'Daily ping',
+      prompt: 'ping',
+      time: '18:00',
+      timezone: 'Asia/Shanghai',
+    });
+    expect(scheduled.details.card).toMatchObject({
+      type: 'card',
+      cardType: 'schedule',
+      taskID: 'task_1',
+      name: 'Daily ping',
+      time: '18:00',
+    });
+
+    const messaged = await tools.find((tool) => tool.name === MESSAGE_ASSISTANT_TOOL_NAME).execute('call_3', {
+      to: 'PeerQA',
+      text: 'hello-from-assistant 写好了',
+    });
+    expect(messaged.details.card).toBeUndefined();
+    expect(messaged.content[0].text).toContain('Sent to PeerQA');
+    expect(messaged.details.toAssistantID).toBe('asst_peer');
+
+    const assigned = await tools.find((tool) => tool.name === ASSIGN_SESSION_TOOL_NAME).execute('call_4', { prompt: 'Fix login' });
+    expect(assigned.details.card).toMatchObject({
+      type: 'card',
+      cardType: 'session',
+      sessionID: 'ses_1',
+      title: 'Login',
+    });
+    expect(onCard).toHaveBeenCalledTimes(3);
+  });
+
+  it('resolves a peer by name and rejects a missing recipient', () => {
+    const listed = [{ id: 'asst_peer', name: 'PeerQA' }, { id: 'asst_host', name: 'DeepSeekQA' }];
+    expect(resolvePeerAssistant({ to: 'PeerQA' }, listed, { id: 'asst_host' })).toEqual(listed[0]);
+    expect(() => resolvePeerAssistant({ to: 'Missing' }, listed, { id: 'asst_host' })).toThrow(/No assistant named/);
+    expect(() => resolvePeerAssistant({ to: 'DeepSeekQA' }, listed, { id: 'asst_host' })).toThrow(/same assistant/);
+  });
+
+  it('returns a clear project_required result instead of throwing', async () => {
+    const tools = createContactTools({
+      assignWork: async () => {
+        throw new AssignError(ASSIGN_CODES.PROJECT_REQUIRED, PROJECT_REQUIRED_MESSAGE);
+      },
+    });
+    const result = await tools.find((tool) => tool.name === ASSIGN_SESSION_TOOL_NAME).execute('call_1', { prompt: 'Fix login' });
+    expect(result.details.error).toBe('project_required');
+    expect(result.content[0].text).toContain('Add a project in Settings');
+    expect(result.content[0].text).toContain('assistant-workspaces');
+  });
+
+  it('lists projects and sessions and surfaces list_sessions failure', async () => {
+    const tools = createContactTools({
+      listProjects: async () => [
+        { id: 'proj_yee', path: '/repo/openchamber-yee', label: 'OpenChamber Yee' },
+        { id: 'proj_other', path: '/repo/other', label: 'Other' },
+      ],
+      listSessions: async () => ({
+        sessions: [
+          { sessionID: 'ses_1', title: 'Login fix', directory: '/repo/openchamber-yee', updatedAt: 2 },
+        ],
+        truncated: false,
+      }),
+    });
+    const listed = await tools.find((tool) => tool.name === LIST_PROJECTS_TOOL_NAME).execute('call_p', {
+      query: 'openchamer yee',
+    });
+    expect(listed.details.projects).toEqual([
+      { id: 'proj_yee', path: '/repo/openchamber-yee', label: 'OpenChamber Yee' },
+    ]);
+    const sessions = await tools.find((tool) => tool.name === LIST_SESSIONS_TOOL_NAME).execute('call_s', {
+      projectPath: '/repo/openchamber-yee',
+    });
+    expect(sessions.details.sessions).toEqual([
+      expect.objectContaining({ sessionID: 'ses_1', title: 'Login fix' }),
+    ]);
+
+    const failing = createContactTools({
+      listSessions: async () => {
+        throw new AssignError(ASSIGN_CODES.UPSTREAM, 'Session index is unavailable.');
+      },
+    });
+    const failed = await failing.find((tool) => tool.name === LIST_SESSIONS_TOOL_NAME).execute('call_fail', {});
+    expect(failed.details.error).toBe('upstream_error');
+    expect(failed.content[0].text).toContain('Session index is unavailable');
+    expect(failed.details.sessions).toBeUndefined();
+  });
+});
+
+describe('confirmBubbleAfterContactReset', () => {
+  it('keeps the canonical confirm and drops leftover attachment bubbles', () => {
+    expect(confirmBubbleAfterContactReset([
+      NEW_CONVERSATION_CONFIRM_BUBBLE,
+      'I still see your dot.png and note.txt.',
+      'Those attachments are still in context.',
+    ])).toEqual([NEW_CONVERSATION_CONFIRM_BUBBLE]);
+  });
+
+  it('uses the canonical confirm when leftover text is the only extracted bubble', () => {
+    expect(confirmBubbleAfterContactReset([
+      'I still see your dot.png and note.txt from earlier.',
+    ])).toEqual([NEW_CONVERSATION_CONFIRM_BUBBLE]);
+  });
+});

package/server/lib/assistants/contracts.js

@@ -1,9 +1,28 @@
 export const assistantContractFixtures = Object.freeze({
-  assistant: Object.freeze({ id: 'assistant_fixture', revision: 4, enabled: true, name: 'Fixture', defaultPrompt: '', workspacePath: null, managedWorkspacePath: '/data/assistant-workspaces/assistant_fixture', effectiveWorkspacePath: '/workspace', providerID: 'provider_fixture', modelID: 'model_fixture', agent: null, variant: null, mode: 'continuous', sessionID: 'ses_fixture', sessionGeneration: 4, historySessionIDs: Object.freeze([]), historySessionCount: 0, createdAt: 1234, updatedAt: 1234, tombstoneAt: null }),
+  assistant: Object.freeze({ id: 'assistant_fixture', revision: 4, enabled: true, name: 'Fixture', defaultPrompt: '', workspacePath: null, managedWorkspacePath: '/data/assistant-workspaces/assistant_fixture', effectiveWorkspacePath: '/workspace', providerID: 'provider_fixture', modelID: 'model_fixture', agent: null, variant: null, mode: 'continuous', sessionID: 'ses_fixture', sessionGeneration: 4, historySessionIDs: Object.freeze([]), historySessionCount: 0, assignedSessionIDs: Object.freeze([]), working: false, createdAt: 1234, updatedAt: 1234, tombstoneAt: null }),
   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 }),
   abortResponse: Object.freeze({ binding: Object.freeze({ sessionID: 'ses_fixture', directory: '/workspace', sessionGeneration: 4 }), aborted: true }),
   shareOperation: Object.freeze({ operationID: 'share_fixture', assistantID: 'assistant_fixture', sessionID: 'ses_fixture', messageID: 'msg_fixture', state: 'running', phase: 'submitted', attempt: 1, leaseExpiresAt: 1234, errorCode: null }),
   historicalMessages: Object.freeze({ entries: Object.freeze([Object.freeze({ sessionID: 'ses_fixture', directory: null, info: Object.freeze({ id: 'msg_fixture', sessionID: 'ses_fixture', role: 'assistant', time: Object.freeze({ created: 1234 }) }), parts: Object.freeze([]) })]), nextCursor: null, complete: true }),
+  assistantScheduledTasks: Object.freeze({
+    tasks: Object.freeze([
+      Object.freeze({
+        assistantID: 'assistant_fixture',
+        projectID: 'proj_fixture',
+        taskID: 'task_fixture',
+        createdAt: 1234,
+        projectPath: '/workspace',
+        projectLabel: 'Fixture',
+        task: Object.freeze({
+          id: 'task_fixture',
+          name: 'Daily ping',
+          enabled: true,
+          schedule: Object.freeze({ kind: 'daily', time: '18:00', timezone: 'Asia/Shanghai' }),
+          execution: Object.freeze({ prompt: 'ping', providerID: 'provider_fixture', modelID: 'model_fixture' }),
+        }),
+      }),
+    ]),
+  }),
 });