feat(llm): route adapters by provider

2026-07-14 21:57:52 +08:00
parent a0359bc4a9
commit e547980d77
218 changed files with 2605 additions and 1844 deletions
--- a/packages/llm/llm-pi-ai/src/stream.ts
+++ b/packages/llm/llm-pi-ai/src/stream.ts
@@ -0,0 +1,141 @@
+/**
+ * pi-ai assistant event translation into the Harness streaming protocol.
+ *
+ * pi-ai tool-call arguments are parsed objects while the Harness keeps their
+ * raw JSON representation. pi-ai also reports failures as terminal stream
+ * events, which this module maps into Harness finish chunks.
+ *
+ * @module dsh-llm-pi-ai/stream
+ */
+
+import { CallId, LlmError } from '@deepseek-ai/dsh-llm'
+import type { FinishReason, StreamChunk, TokenUsage } from '@deepseek-ai/dsh-llm'
+import type { AssistantMessage, AssistantMessageEvent, Usage as PiUsage } from '@earendil-works/pi-ai'
+import { toPiReplayState } from './replay.ts'
+
+/**
+ * Map pi-ai usage (reasoning folded into output by pi-ai).
+ * @param usage - cumulative usage from the terminal pi-ai event.
+ * @returns harness counts; cache fields appear only when non-zero (pi-ai reports zeros, not absence).
+ */
+export function mapUsage(usage: PiUsage): TokenUsage {
+  return {
+    inputTokens: usage.input,
+    outputTokens: usage.output,
+    ...usage.cacheRead > 0 ? { cacheReadTokens: usage.cacheRead } : {},
+    ...usage.cacheWrite > 0 ? { cacheWriteTokens: usage.cacheWrite } : {},
+  }
+}
+
+function classifyPiAiError(message: string): string {
+  if (/\b(?:401|403)\b/.test(message)) return 'AUTH'
+  if (/\b429\b|rate.?limit/i.test(message)) return 'RATE_LIMIT'
+  if (/\b400\b|invalid.?request/i.test(message)) return 'INVALID_REQUEST'
+  if (/\b5\d\d\b/.test(message)) return 'SERVER'
+  return 'PI_AI_ERROR'
+}
+
+/**
+ * Map a terminal pi-ai event to the harness finish reason.
+ * @param message - the assistant message carried by the `done` or `error` event.
+ * @returns the harness reason; `error` yields `{kind: 'error'}` with a code classified from the error text.
+ */
+export function mapStopReason(message: AssistantMessage): FinishReason {
+  switch (message.stopReason) {
+    case 'stop': return { kind: 'stop' }
+    case 'length': return { kind: 'max-tokens' }
+    case 'toolUse': return { kind: 'tool-calls' }
+    case 'aborted': return { kind: 'aborted' }
+    case 'error': {
+      const text = message.errorMessage ?? 'pi-ai stream error'
+      return { kind: 'error', message: text, code: classifyPiAiError(text) }
+    }
+  }
+}
+
+/**
+ * Translate the pi-ai event stream into StreamChunks. pi-ai never throws
+ * mid-stream — failures arrive as `error` events, which become error/aborted
+ * `finish` chunks (the harness protocol's other error-delivery style).
+ * @param events - one assistant turn's pi-ai event stream.
+ * @returns the harness chunks, ending with `usage` then `finish`; throws
+ *   `LlmError` (`STREAM_CLOSED`) if the source ends without a terminal event.
+ */
+export async function* toStreamChunks(events: AsyncIterable<AssistantMessageEvent>): AsyncGenerator<StreamChunk> {
+  // pi-ai contentIndex ↔ our block index map 1:1 (both count blocks from 0
+  // in stream order), but we track ids per index for tool calls.
+  const toolIds = new Map<number, { id: string; name: string }>()
+
+  for await (const event of events) {
+    switch (event.type) {
+      case 'start':
+        break
+      case 'text_start':
+        yield { type: 'block-start', index: event.contentIndex, blockType: 'text' }
+        break
+      case 'text_delta':
+        yield { type: 'text-delta', index: event.contentIndex, text: event.delta }
+        break
+      case 'text_end':
+        yield { type: 'block-end', index: event.contentIndex, block: { type: 'text', text: event.content } }
+        break
+      case 'thinking_start':
+        yield { type: 'block-start', index: event.contentIndex, blockType: 'reasoning' }
+        break
+      case 'thinking_delta':
+        yield { type: 'reasoning-delta', index: event.contentIndex, text: event.delta }
+        break
+      case 'thinking_end':
+        yield { type: 'block-end', index: event.contentIndex, block: { type: 'reasoning', text: event.content } }
+        break
+      case 'toolcall_start': {
+        // The id/name live on the partial's content at this index.
+        const partial = event.partial.content[event.contentIndex]
+        const id = partial?.type === 'toolCall' ? partial.id : ''
+        const name = partial?.type === 'toolCall' ? partial.name : ''
+        toolIds.set(event.contentIndex, { id, name })
+        yield { type: 'block-start', index: event.contentIndex, blockType: 'tool-call' }
+        break
+      }
+      case 'toolcall_delta': {
+        const known = toolIds.get(event.contentIndex)
+        yield {
+          type: 'tool-call-delta',
+          index: event.contentIndex,
+          id: CallId(known?.id ?? ''),
+          ...known?.name !== undefined && known.name.length > 0 ? { name: known.name } : {},
+          argumentsDelta: event.delta,
+        }
+        break
+      }
+      case 'toolcall_end':
+        yield {
+          type: 'block-end',
+          index: event.contentIndex,
+          block: {
+            type: 'tool-call',
+            id: CallId(event.toolCall.id),
+            name: event.toolCall.name,
+            // pi-ai hands back the PARSED arguments; the harness vocabulary
+            // keeps the raw string.
+            arguments: JSON.stringify(event.toolCall.arguments),
+          },
+        }
+        break
+      case 'done':
+        yield { type: 'usage', usage: mapUsage(event.message.usage) }
+        yield { type: 'finish', reason: mapStopReason(event.message), replayState: toPiReplayState(event.message) }
+        return
+      case 'error':
+        // In-stream error delivery (pi-ai's style) → error finish chunk
+        // (the harness's other sanctioned error path besides throwing).
+        yield { type: 'usage', usage: mapUsage(event.error.usage) }
+        yield { type: 'finish', reason: mapStopReason(event.error) }
+        return
+      // no default: AssistantMessageEvent is pi-ai's closed union; a new
+      // event type should fail compilation here via tsc's exhaustiveness
+      // when one is added (switch covers all current variants).
+    }
+  }
+  throw new LlmError('pi-ai event stream ended without done/error', 'STREAM_CLOSED')
+}