@lythos/agent-adapter 0.13.1 → 0.13.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lythos/agent-adapter",
-  "version": "0.13.1",
+  "version": "0.13.3",
   "main": "./src/index.ts",
   "exports": {
     ".": "./src/index.ts",

package/src/adapters/kimi.test.ts

@@ -24,14 +24,18 @@ describe('parseKimiStreamJson', () => {
       '{"role":"assistant","content":"Hello world"}',
       '{"role":"user","content":"ignored"}',
     ].join('\n')
-    expect(parseKimiStreamJson(raw)).toBe('Hello world')
+    const result = parseKimiStreamJson(raw)
+    expect(result.text).toBe('Hello world')
+    expect(result.checkpoints).toEqual([])
   })
 
   it('extracts text from assistant message with content blocks', () => {
     const raw = [
       '{"role":"assistant","content":[{"type":"text","text":"First"},{"type":"text","text":"Second"}]}',
     ].join('\n')
-    expect(parseKimiStreamJson(raw)).toBe('First\nSecond')
+    const result = parseKimiStreamJson(raw)
+    expect(result.text).toBe('First\nSecond')
+    expect(result.checkpoints).toEqual([])
   })
 
   it('skips non-assistant roles', () => {
@@ -39,7 +43,9 @@ describe('parseKimiStreamJson', () => {
       '{"role":"system","content":"init"}',
       '{"role":"assistant","content":"only this"}',
     ].join('\n')
-    expect(parseKimiStreamJson(raw)).toBe('only this')
+    const result = parseKimiStreamJson(raw)
+    expect(result.text).toBe('only this')
+    expect(result.checkpoints).toEqual([])
   })
 
   it('skips malformed JSON lines', () => {
@@ -47,15 +53,21 @@ describe('parseKimiStreamJson', () => {
       'garbage',
       '{"role":"assistant","content":"valid"}',
     ].join('\n')
-    expect(parseKimiStreamJson(raw)).toBe('valid')
+    const result = parseKimiStreamJson(raw)
+    expect(result.text).toBe('valid')
+    expect(result.checkpoints).toEqual([])
   })
 
   it('returns empty string for empty input', () => {
-    expect(parseKimiStreamJson('')).toBe('')
+    const result = parseKimiStreamJson('')
+    expect(result.text).toBe('')
+    expect(result.checkpoints).toEqual([])
   })
 
   it('returns empty string for whitespace-only input', () => {
-    expect(parseKimiStreamJson('  \n  \n  ')).toBe('')
+    const result = parseKimiStreamJson('  \n  \n  ')
+    expect(result.text).toBe('')
+    expect(result.checkpoints).toEqual([])
   })
 
   it('concatenates multiple assistant messages', () => {
@@ -63,6 +75,24 @@ describe('parseKimiStreamJson', () => {
       '{"role":"assistant","content":"Part 1"}',
       '{"role":"assistant","content":"Part 2"}',
     ].join('\n')
-    expect(parseKimiStreamJson(raw)).toBe('Part 1\nPart 2')
+    const result = parseKimiStreamJson(raw)
+    expect(result.text).toBe('Part 1\nPart 2')
+    expect(result.checkpoints).toEqual([])
+  })
+
+  it('extracts tool_calls into checkpoints', () => {
+    const raw = [
+      '{"role":"assistant","content":"Let me check.","tool_calls":[{"type":"function","id":"tc_1","function":{"name":"Shell","arguments":"{\\"command\\":\\"ls\\"}"}}]}',
+      '{"role":"tool","tool_call_id":"tc_1","content":"agent-stdout.txt\\nreport.docx"}',
+      '{"role":"assistant","content":"Done."}',
+    ].join('\n')
+    const result = parseKimiStreamJson(raw)
+    expect(result.text).toBe('Let me check.\nDone.')
+    expect(result.checkpoints.length).toBe(2)
+    expect(result.checkpoints[0].step).toBe('tool_call')
+    expect(result.checkpoints[0].tool).toBe('Shell')
+    expect(result.checkpoints[1].step).toBe('tool_result')
+    expect(result.checkpoints[1].tool).toBe('Shell')
+    expect(result.checkpoints[1].stdout_summary).toBe('agent-stdout.txt\nreport.docx')
   })
 })

package/src/adapters/kimi.ts

@@ -1,7 +1,7 @@
 import { writeFileSync, unlinkSync } from 'node:fs'
 import { join } from 'node:path'
 import { tmpdir } from 'node:os'
-import type { AgentAdapter, AgentRunResult } from '../types'
+import type { AgentAdapter, AgentRunResult, CheckpointEntry } from '../types'
 import { readCheckpoints } from '../checkpoint'
 import { registerAgent } from '../registry'
 
@@ -13,28 +13,59 @@ export function buildKimiCommand(): string[] {
 }
 
 /**
- * Parse kimi stream-json output into plain text.
- * Each line is a JSON event; extracts text from assistant role messages.
- * content can be string or array of content blocks.
+ * Parse kimi stream-json output into plain text + checkpoint trace.
+ * Each line is a JSON event; extracts text from assistant role messages
+ * and tool_calls/tool messages into CheckpointEntry for white-box replay.
  */
-export function parseKimiStreamJson(raw: string): string {
-  const lines: string[] = []
+export function parseKimiStreamJson(raw: string): { text: string; checkpoints: CheckpointEntry[] } {
+  const textLines: string[] = []
+  const checkpoints: CheckpointEntry[] = []
+  const pendingTools = new Map<string, { name: string; args: string }>()
+
   for (const line of raw.split('\n')) {
     if (!line.trim()) continue
     try {
       const event = JSON.parse(line)
-      if (event.role !== 'assistant') continue
-      const content = event.content
-      if (typeof content === 'string') {
-        lines.push(content)
-      } else if (Array.isArray(content)) {
-        for (const block of content) {
-          if (block.type === 'text' && block.text) lines.push(block.text)
+      if (event.role === 'assistant') {
+        const content = event.content
+        if (typeof content === 'string') {
+          textLines.push(content)
+        } else if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === 'text' && block.text) textLines.push(block.text)
+          }
+        }
+
+        if (Array.isArray(event.tool_calls)) {
+          for (const tc of event.tool_calls) {
+            if (tc.type === 'function' && tc.function) {
+              checkpoints.push({
+                step: 'tool_call',
+                tool: tc.function.name,
+                args: [tc.function.arguments],
+                timestamp: new Date().toISOString(),
+              })
+              pendingTools.set(tc.id, { name: tc.function.name, args: tc.function.arguments })
+            }
+          }
+        }
+      } else if (event.role === 'tool' && event.tool_call_id) {
+        const pending = pendingTools.get(event.tool_call_id)
+        if (pending) {
+          checkpoints.push({
+            step: 'tool_result',
+            tool: pending.name,
+            args: [pending.args],
+            stdout_summary: String(event.content ?? '').slice(0, 500),
+            timestamp: new Date().toISOString(),
+          })
+          pendingTools.delete(event.tool_call_id)
         }
       }
     } catch { /* skip malformed lines */ }
   }
-  return lines.join('\n')
+
+  return { text: textLines.join('\n'), checkpoints }
 }
 
 // ── Spawn wrapper (IO, tested via BDD / arena integration) ──────────────────
@@ -67,16 +98,26 @@ async function spawnKimi(opts: {
   const stderr = await new Response(proc.stderr).text()
   const code = proc.exitCode ?? 1
 
-  let stdout: string
+  let text: string
+  let streamCheckpoints: CheckpointEntry[]
   try {
-    stdout = parseKimiStreamJson(rawStdout)
+    const parsed = parseKimiStreamJson(rawStdout)
+    text = parsed.text
+    streamCheckpoints = parsed.checkpoints
   } catch {
-    stdout = rawStdout
+    text = rawStdout
+    streamCheckpoints = []
   }
 
-  const checkpoints = readCheckpoints(opts.cwd)
+  // Preserve raw JSONL for post-hoc white-box analysis
+  try {
+    writeFileSync(join(opts.cwd, 'agent-stdout-raw.jsonl'), rawStdout, 'utf-8')
+  } catch { /* ignore write failures */ }
+
+  const fileCheckpoints = readCheckpoints(opts.cwd)
+  const checkpoints = [...streamCheckpoints, ...fileCheckpoints]
 
-  return { stdout: stdout.trim(), stderr, code, durationMs, checkpoints }
+  return { stdout: text.trim(), stderr, code, durationMs, checkpoints }
 }
 
 const kimiAdapter: AgentAdapter = {