@muyichengshayu/promptx 0.2.16 → 0.2.18

package/apps/runner/src/engines/kimiCodeRunner.test.js

@@ -0,0 +1,127 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import {
+  isKimiInfoStderrLine,
+  normalizeKimiEvents,
+  createKimiNormalizationState,
+} from './kimiCodeRunner.js'
+import { AGENT_RUN_ITEM_TYPES } from '@promptx/shared'
+
+test('isKimiInfoStderrLine treats resume hints as non-error metadata', () => {
+  assert.equal(
+    isKimiInfoStderrLine('To resume this session: kimi -r ffb2f903-1173-4f8a-a49a-c8b0deae3e2d'),
+    true
+  )
+  assert.equal(
+    isKimiInfoStderrLine('To resume this session: kimi --session ffb2f903-1173-4f8a-a49a-c8b0deae3e2d'),
+    true
+  )
+})
+
+test('isKimiInfoStderrLine keeps real stderr visible', () => {
+  assert.equal(isKimiInfoStderrLine('Error: authentication failed'), false)
+})
+
+test('normalizeKimiEvents maps SetTodoList tool_call to todo_list events', () => {
+  const state = createKimiNormalizationState()
+
+  const assistantEvent = {
+    role: 'assistant',
+    content: [],
+    tool_calls: [{
+      id: 'call-1',
+      function: {
+        name: 'SetTodoList',
+        arguments: JSON.stringify({
+          todos: [
+            { title: 'Task A', status: 'in_progress' },
+            { title: 'Task B', status: 'done' },
+            { title: 'Task C', status: 'pending' },
+          ],
+        }),
+      },
+    }],
+  }
+
+  const startedEvents = normalizeKimiEvents(assistantEvent, state)
+  assert.equal(startedEvents.length, 2)
+  assert.equal(startedEvents[0].type, 'turn.started')
+
+  const todoStarted = startedEvents[1]
+  assert.equal(todoStarted.type, 'item.started')
+  assert.equal(todoStarted.item.type, AGENT_RUN_ITEM_TYPES.TODO_LIST)
+  assert.equal(todoStarted.item.items.length, 3)
+  assert.deepEqual(todoStarted.item.items[0], { text: 'Task A', status: 'in_progress', completed: false })
+  assert.deepEqual(todoStarted.item.items[1], { text: 'Task B', status: 'completed', completed: true })
+  assert.deepEqual(todoStarted.item.items[2], { text: 'Task C', status: 'pending', completed: false })
+
+  const toolEvent = {
+    role: 'tool',
+    tool_call_id: 'call-1',
+    content: 'Todo list updated',
+  }
+
+  const completedEvents = normalizeKimiEvents(toolEvent, state)
+  assert.equal(completedEvents.length, 1)
+  assert.equal(completedEvents[0].type, 'item.completed')
+  assert.equal(completedEvents[0].item.type, AGENT_RUN_ITEM_TYPES.TODO_LIST)
+  assert.equal(completedEvents[0].item.items.length, 3)
+})
+
+test('normalizeKimiEvents keeps regular tool_calls as command_execution', () => {
+  const state = createKimiNormalizationState()
+
+  const assistantEvent = {
+    role: 'assistant',
+    content: [],
+    tool_calls: [{
+      id: 'call-2',
+      function: {
+        name: 'Shell',
+        arguments: JSON.stringify({ command: 'ls' }),
+      },
+    }],
+  }
+
+  const startedEvents = normalizeKimiEvents(assistantEvent, state)
+  assert.equal(startedEvents.length, 2)
+  assert.equal(startedEvents[0].type, 'turn.started')
+
+  const cmdStarted = startedEvents[1]
+  assert.equal(cmdStarted.type, 'item.started')
+  assert.equal(cmdStarted.item.type, AGENT_RUN_ITEM_TYPES.COMMAND_EXECUTION)
+
+  const toolEvent = {
+    role: 'tool',
+    tool_call_id: 'call-2',
+    content: 'file.txt',
+  }
+
+  const completedEvents = normalizeKimiEvents(toolEvent, state)
+  assert.equal(completedEvents.length, 1)
+  assert.equal(completedEvents[0].type, 'item.completed')
+  assert.equal(completedEvents[0].item.type, AGENT_RUN_ITEM_TYPES.COMMAND_EXECUTION)
+})
+
+test('normalizeKimiEvents handles SetTodoList with empty or malformed todos', () => {
+  const state = createKimiNormalizationState()
+
+  const assistantEvent = {
+    role: 'assistant',
+    content: [],
+    tool_calls: [{
+      id: 'call-3',
+      function: {
+        name: 'SetTodoList',
+        arguments: JSON.stringify({ todos: [] }),
+      },
+    }],
+  }
+
+  const events = normalizeKimiEvents(assistantEvent, state)
+  assert.equal(events.length, 2)
+  assert.equal(events[1].type, 'item.started')
+  assert.equal(events[1].item.type, AGENT_RUN_ITEM_TYPES.TODO_LIST)
+  assert.equal(events[1].item.items.length, 0)
+})

package/apps/runner/src/engines/openCodeRunner.test.js

@@ -0,0 +1,236 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  createOpenCodeNormalizationState,
+  extractOpenCodeErrorMessage,
+  extractOpenCodeSessionId,
+  extractOpenCodeText,
+  extractOpenCodeUsage,
+  normalizeOpenCodeEvent,
+  normalizeOpenCodeEvents,
+} from './openCodeRunner.js'
+
+test('runner openCodeRunner maps sub-agent task tool_use to collaboration events', () => {
+  assert.deepEqual(
+    normalizeOpenCodeEvents({
+      type: 'tool_use',
+      sessionID: 'ses_main',
+      part: {
+        type: 'tool',
+        tool: 'task',
+        state: {
+          status: 'completed',
+          input: {
+            description: '分析 a.js 文件',
+            prompt: '请分析 /tmp/demo/a.js 文件',
+            subagent_type: 'explore',
+          },
+          output: 'task_id: ses_child_1\n\n<task_result>ok</task_result>',
+          metadata: {
+            sessionId: 'ses_child_1',
+            model: {
+              providerID: 'opencode',
+              modelID: 'minimax-m2.5-free',
+            },
+          },
+        },
+      },
+    }),
+    [
+      {
+        type: 'item.completed',
+        item: {
+          type: 'collab_tool_call',
+          tool: 'spawn_agent',
+          receiver_thread_ids: ['ses_child_1'],
+          prompt: '请分析 /tmp/demo/a.js 文件',
+          agents_states: {
+            ses_child_1: {
+              status: 'completed',
+              message: 'task_id: ses_child_1\n\n<task_result>ok</task_result>',
+              title: '分析 a.js 文件',
+              role: 'explore',
+              target: 'a.js',
+              model: 'opencode/minimax-m2.5-free',
+            },
+          },
+        },
+      },
+      {
+        type: 'item.completed',
+        item: {
+          type: 'collab_tool_call',
+          tool: 'wait',
+          receiver_thread_ids: ['ses_child_1'],
+          prompt: '请分析 /tmp/demo/a.js 文件',
+          agents_states: {
+            ses_child_1: {
+              status: 'completed',
+              message: 'task_id: ses_child_1\n\n<task_result>ok</task_result>',
+              title: '分析 a.js 文件',
+              role: 'explore',
+              target: 'a.js',
+              model: 'opencode/minimax-m2.5-free',
+            },
+          },
+        },
+      },
+    ]
+  )
+})
+
+test('extractOpenCodeSessionId reads common session id fields', () => {
+  assert.equal(extractOpenCodeSessionId({ sessionID: 'opencode-session-1' }), 'opencode-session-1')
+  assert.equal(extractOpenCodeSessionId({ sessionId: 'opencode-session-2' }), 'opencode-session-2')
+})
+
+test('extractOpenCodeText trims text payload', () => {
+  assert.equal(
+    extractOpenCodeText({
+      type: 'text',
+      part: {
+        type: 'text',
+        text: '\n\n已完成修改\n',
+      },
+    }),
+    '已完成修改'
+  )
+})
+
+test('normalizeOpenCodeEvent maps text output to agent message', () => {
+  assert.deepEqual(
+    normalizeOpenCodeEvent({
+      type: 'text',
+      part: {
+        type: 'text',
+        text: '已完成修改',
+      },
+    }),
+    {
+      type: 'item.completed',
+      item: {
+        type: 'agent_message',
+        text: '已完成修改',
+      },
+    }
+  )
+})
+
+test('normalizeOpenCodeEvents maps first step_start to turn.started only once', () => {
+  const state = createOpenCodeNormalizationState()
+
+  assert.deepEqual(
+    normalizeOpenCodeEvents({
+      type: 'step_start',
+      sessionID: 'ses_1',
+    }, state),
+    [{ type: 'turn.started' }]
+  )
+
+  assert.deepEqual(
+    normalizeOpenCodeEvents({
+      type: 'step_start',
+      sessionID: 'ses_1',
+    }, state),
+    []
+  )
+})
+
+test('normalizeOpenCodeEvents maps completed tool_use to command events', () => {
+  assert.deepEqual(
+    normalizeOpenCodeEvents({
+      type: 'tool_use',
+      sessionID: 'ses_2',
+      part: {
+        type: 'tool',
+        tool: 'read',
+        state: {
+          status: 'completed',
+          input: {
+            filePath: '/tmp/demo.txt',
+          },
+          output: '<path>/tmp/demo.txt</path>',
+        },
+      },
+    }),
+    [
+      {
+        type: 'item.started',
+        item: {
+          type: 'command_execution',
+          command: 'read: /tmp/demo.txt',
+          status: 'in_progress',
+        },
+      },
+      {
+        type: 'item.completed',
+        item: {
+          type: 'command_execution',
+          command: 'read: /tmp/demo.txt',
+          status: 'completed',
+          exit_code: 0,
+          aggregated_output: '<path>/tmp/demo.txt</path>',
+        },
+      },
+    ]
+  )
+})
+
+test('normalizeOpenCodeEvent maps step_finish stop to turn completion with usage', () => {
+  const event = normalizeOpenCodeEvent({
+    type: 'step_finish',
+    part: {
+      type: 'step-finish',
+      reason: 'stop',
+      tokens: {
+        input: 321,
+        output: 12,
+        cache: {
+          read: 256,
+        },
+      },
+    },
+  })
+
+  assert.deepEqual(event, {
+    type: 'turn.completed',
+    usage: {
+      input_tokens: 321,
+      output_tokens: 12,
+      cached_input_tokens: 256,
+    },
+  })
+
+  assert.deepEqual(extractOpenCodeUsage({
+    part: {
+      tokens: {
+        input: 321,
+        output: 12,
+        cache: {
+          read: 256,
+        },
+      },
+    },
+  }), {
+    input_tokens: 321,
+    output_tokens: 12,
+    cached_input_tokens: 256,
+  })
+})
+
+test('extractOpenCodeErrorMessage reads nested API errors', () => {
+  assert.equal(
+    extractOpenCodeErrorMessage({
+      type: 'error',
+      error: {
+        name: 'APIError',
+        data: {
+          message: 'openai_error',
+          responseBody: '{"error":{"message":"bad gateway"}}',
+        },
+      },
+    }),
+    'openai_error'
+  )
+})