@openchambery/web 1.19.11 → 1.19.13-beta.1

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

@@ -229,6 +229,10 @@ describe('runContactTurn', () => {
     const createChatCompletion = vi.fn(async ({ body }) => {
       expect(body.messages[0].content).toContain('assign_session')
       expect(body.messages[0].content).toContain('docs')
+      expect(body.messages[0].content).toContain('arguments schema:')
+      expect(body.messages[0].content).toContain('"edits"')
+      expect(body.messages[0].content).toContain('"content"')
+      expect(body.messages[0].content).toContain('not OpenCode native tools and not MCP')
       const content = replies[call++]
       if (!content) throw new Error('Unexpected completion')
       return { completion: { choices: [{ message: { content } }] } }
@@ -242,11 +246,126 @@ describe('runContactTurn', () => {
       expect(result.tools.map((tool) => tool.name)).toEqual([...PI_CODING_TOOL_NAMES, ...tools.map((tool) => tool.name)])
       expect(assignWork).toHaveBeenCalledTimes(1)
       expect(result.cards).toEqual([expect.objectContaining({ sessionID: 'ses_mixed' })])
-      expect(createChatCompletion).toHaveBeenCalledTimes(4)
+      // read → text (miss) → missed-fence retry assign; assign terminates (no post-assign LLM).
+      expect(createChatCompletion).toHaveBeenCalledTimes(3)
+      // Tool call/result association: after read, the next completion sees a named tool result.
+      const secondMessages = createChatCompletion.mock.calls[1][0].body.messages
+      const toolResultTurn = secondMessages.find((message) => (
+        message.role === 'user' && typeof message.content === 'string' && message.content.includes('tool result name=read')
+      ))
+      expect(toolResultTurn).toBeTruthy()
+      expect(toolResultTurn.content).toMatch(/Read project docs|documentation/i)
     } finally {
       fs.rmSync(workspace, { recursive: true, force: true })
     }
   })
+  it('real Agent loop: looping assign fences create only one worker + one card (terminate)', async () => {
+    const assignWork = vi.fn(async () => ({
+      sessionID: 'ses_once',
+      directory: '/repo',
+      title: 'Once',
+      status: 'busy',
+    }))
+    const tools = createContactTools({ assignWork })
+    let completions = 0
+    const createChatCompletion = vi.fn(async () => {
+      completions += 1
+      // Safety: a non-terminating loop must not mint 37 sessions in tests.
+      if (completions > 8) {
+        throw new Error('harness safety stop: too many completions without terminate')
+      }
+      return {
+        completion: {
+          choices: [{
+            message: {
+              content: '```openchamber-tool\n{"name":"assign_session","arguments":{"prompt":"Fix login","projectPath":"/repo"}}\n```',
+            },
+          }],
+        },
+      }
+    })
+    const result = await runContactTurn({
+      assistant: { providerID: 'p', modelID: 'm', defaultPrompt: '' },
+      history: [],
+      userText: '建会话修 login',
+      tools,
+      projects: [{ id: 'p1', path: '/repo', label: 'Repo' }],
+      createChatCompletion,
+    })
+    expect(assignWork).toHaveBeenCalledTimes(1)
+    expect(result.cards).toEqual([expect.objectContaining({ sessionID: 'ses_once', cardType: 'session' })])
+    expect(result.cards).toHaveLength(1)
+    expect(result.bubbles).toContain('Opened a coding session.')
+    // First completion issues assign; terminate skips the auto follow-up LLM.
+    expect(createChatCompletion).toHaveBeenCalledTimes(1)
+    expect(completions).toBe(1)
+  })
+
+  it('real Agent loop: list_projects then assign keeps prereq + one session (terminate after assign)', async () => {
+    const listProjects = vi.fn(async () => [{ id: 'p1', path: '/repo', label: 'Repo' }])
+    const assignWork = vi.fn(async () => ({
+      sessionID: 'ses_prereq',
+      directory: '/repo',
+      title: 'Prereq',
+      status: 'busy',
+    }))
+    const tools = createContactTools({ listProjects, assignWork })
+    let completions = 0
+    const createChatCompletion = vi.fn(async ({ body }) => {
+      completions += 1
+      if (completions > 6) {
+        throw new Error('harness safety stop: too many completions')
+      }
+      const last = body.messages.at(-1)
+      const lastText = typeof last?.content === 'string' ? last.content : ''
+      if (lastText.includes('tool result name=list_projects') || lastText.includes('Registered projects')) {
+        return {
+          completion: {
+            choices: [{
+              message: {
+                content: '```openchamber-tool\n{"name":"assign_session","arguments":{"prompt":"Fix","projectPath":"/repo"}}\n```',
+              },
+            }],
+          },
+        }
+      }
+      if (completions === 1) {
+        return {
+          completion: {
+            choices: [{
+              message: {
+                content: '```openchamber-tool\n{"name":"list_projects","arguments":{"query":"repo"}}\n```',
+              },
+            }],
+          },
+        }
+      }
+      // If assign did not terminate, a looping model would keep assigning — fail closed.
+      return {
+        completion: {
+          choices: [{
+            message: {
+              content: '```openchamber-tool\n{"name":"assign_session","arguments":{"prompt":"Fix again","projectPath":"/repo"}}\n```',
+            },
+          }],
+        },
+      }
+    })
+    const result = await runContactTurn({
+      assistant: { providerID: 'p', modelID: 'm', defaultPrompt: '' },
+      history: [],
+      userText: '找项目 repo 然后建会话修问题',
+      tools,
+      projects: [{ id: 'p1', path: '/repo', label: 'Repo' }],
+      createChatCompletion,
+    })
+    expect(listProjects).toHaveBeenCalledTimes(1)
+    expect(assignWork).toHaveBeenCalledTimes(1)
+    expect(result.cards).toEqual([expect.objectContaining({ sessionID: 'ses_prereq' })])
+    expect(result.cards).toHaveLength(1)
+    expect(createChatCompletion.mock.calls.length).toBeLessThanOrEqual(3)
+  })
+
   it('retries assignment after an unrelated read result', async () => {
     const prompts = []
     function AgentImpl(options) {

package/server/lib/assistants/pi-tools.js

@@ -70,21 +70,68 @@ const bindHarnessTool = (tool, context) => ({
   ),
 });
 
-export function formatPiCodingPrompt({ cwd, skillsPrompt = '' } = {}) {
+/**
+ * Serialize a tool parameter schema for the contact system prompt.
+ * Mirrors contact-tools.serializeToolParametersForPrompt without a circular import.
+ */
+const serializeParameters = (parameters) => {
+  if (parameters == null) return '{"type":"object","properties":{}}';
+  try {
+    const text = JSON.stringify(parameters, (_key, value) => {
+      if (typeof value === 'function' || typeof value === 'symbol') return undefined;
+      return value;
+    });
+    if (typeof text === 'string' && text.trim() && text !== 'undefined') return text;
+  } catch {
+    // Fall through.
+  }
+  return '{"type":"object","properties":{}}';
+};
+
+const formatCodingToolEntry = (tool) => {
+  if (!tool || typeof tool.name !== 'string' || !tool.name.trim()) return '';
+  const name = tool.name.trim();
+  const description = typeof tool.description === 'string' && tool.description.trim()
+    ? tool.description.trim()
+    : name;
+  return `- ${name}: ${description}\n  arguments schema: ${serializeParameters(tool.parameters)}`;
+};
+
+export function formatPiCodingPrompt({ cwd, skillsPrompt = '', tools = [] } = {}) {
   if (typeof cwd !== 'string' || !cwd.trim()) return '';
+  const codingTools = Array.isArray(tools)
+    ? tools.filter((tool) => isPiCodingToolName(tool?.name))
+    : [];
+  const catalog = codingTools.length > 0
+    ? codingTools.map(formatCodingToolEntry).filter(Boolean)
+    : [
+      '- bash: Execute a bash command in the working directory.\n  arguments schema: {"type":"object","required":["command"],"properties":{"command":{"type":"string"},"timeout":{"type":"number"}}}',
+      '- read: Read a file (path required; optional offset/limit).\n  arguments schema: {"type":"object","required":["path"],"properties":{"path":{"type":"string"},"offset":{"type":"number"},"limit":{"type":"number"}}}',
+      '- write: Write/create a file (path + content required).\n  arguments schema: {"type":"object","required":["path","content"],"properties":{"path":{"type":"string"},"content":{"type":"string"}}}',
+      '- edit: Exact text replacement (path + edits[{oldText,newText}] required).\n  arguments schema: {"type":"object","required":["path","edits"],"properties":{"path":{"type":"string"},"edits":{"type":"array","items":{"type":"object","required":["oldText","newText"],"properties":{"oldText":{"type":"string"},"newText":{"type":"string"}}}}}}',
+    ];
   return [
     `Working directory: ${cwd}`,
-    'You have pi coding tools in this directory: read, write, edit, bash.',
+    'You have application-owned pi coding tools in this directory: read, write, edit, bash.',
+    'These are not OpenCode native tools and not MCP. Skill directory entries below are instructions only — load a matching skill by calling read on its path; never invent skill or MCP tool names (no context7, gh_grep, webfetch, etc.).',
     'This is your working directory. Ignore any other cwd from the environment, including temporary generator workspaces under /var/folders or os.tmpdir.',
     'When the user asks pwd, the current directory, or to look at files, call bash/read yourself. Never say you have no terminal or cannot read or write files.',
     'Skills are merged from ~/.claude/skills, ~/.agents/skills, and this project\'s .claude/skills plus .agents/skills (project wins on name). Read a skill file when the task matches its description.',
-    'Call these tools with the same fenced JSON as other tools:',
+    'Call these tools with the same fenced JSON as other tools. Match the argument schemas exactly:',
     '```openchamber-tool',
     '{"name":"bash","arguments":{"command":"pwd"}}',
     '```',
     '```openchamber-tool',
     '{"name":"read","arguments":{"path":".agents/skills/example/SKILL.md"}}',
     '```',
+    '```openchamber-tool',
+    '{"name":"write","arguments":{"path":"notes.txt","content":"hello"}}',
+    '```',
+    '```openchamber-tool',
+    '{"name":"edit","arguments":{"path":"notes.txt","edits":[{"oldText":"hello","newText":"hello world"}]}}',
+    '```',
+    'Available pi coding tools (full argument schemas):',
+    ...catalog,
     typeof skillsPrompt === 'string' && skillsPrompt.trim() ? skillsPrompt.trim() : '',
   ].filter(Boolean).join('\n');
 }

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

@@ -5,6 +5,7 @@ import { afterEach, describe, expect, it } from 'vitest';
 import {
   collectAssistantSkillDirectories,
   createPiCodingRuntime,
+  formatPiCodingPrompt,
   mergeSkillsByName,
   PI_CODING_TOOL_NAMES,
   resolveAssistantCwd,
@@ -78,6 +79,30 @@ describe('mergeSkillsByName', () => {
   });
 });
 
+describe('formatPiCodingPrompt', () => {
+  it('includes full pi tool argument schemas and distinguishes skills from tools', async () => {
+    const cwd = temp();
+    const home = temp();
+    const runtime = await createPiCodingRuntime(cwd, { homeDir: home });
+    const prompt = formatPiCodingPrompt({
+      cwd: runtime.cwd,
+      skillsPrompt: runtime.skillsPrompt,
+      tools: runtime.tools,
+    });
+    expect(prompt).toContain('arguments schema:');
+    expect(prompt).toContain('"path"');
+    expect(prompt).toContain('"content"');
+    expect(prompt).toContain('"edits"');
+    expect(prompt).toContain('"oldText"');
+    expect(prompt).toContain('"newText"');
+    expect(prompt).toContain('"command"');
+    expect(prompt).toContain('not OpenCode native tools and not MCP');
+    expect(prompt).toContain('never invent skill or MCP tool names');
+    expect(prompt).toContain('context7');
+    await runtime.close();
+  });
+});
+
 describe('createPiCodingRuntime', () => {
   it('installs read/write/edit/bash and merges global plus project skills', async () => {
     const home = temp();