@codehz/ai 0.2.0 → 0.2.2

package/src/adapters/ollama.ts

@@ -16,7 +16,7 @@
  */
 
 import { AdapterBase } from "../helpers/adapter-base.js";
-import { AIRequestError } from "../core/errors.js";
+import { AIProviderError, AIRequestError, AIStreamError, WarningCode } from "../core/errors.js";
 import {
   textBlock,
   messageItem,
@@ -27,7 +27,10 @@ import {
   contentBlocksToText,
 } from "../helpers/mapping.js";
 import { emitMalformedStreamWarning } from "../helpers/adapter-auxiliary.js";
+import { assertOpaqueReplayEnvelope, providerHttpError } from "../helpers/adapter-security.js";
 import { usageFromOllama } from "../helpers/usage-mapping.js";
+import { NormalizedRequestMapper, splitLines, IncrementalStreamParser } from "../helpers/index.js";
+import type { ProviderProfile } from "../helpers/index.js";
 
 import type { NormalizedRequest, AIStreamEvent, EventFactory, OutputItem, FetchFn } from "../index.js";
 
@@ -79,45 +82,24 @@ type OllamaTool = {
   };
 };
 
-function ensureOllamaTextBlocks(
-  blocks: import("../index.js").ContentBlock[],
-  field: string,
-): import("../index.js").ContentBlock[] {
-  for (let i = 0; i < blocks.length; i++) {
-    const block = blocks[i];
-    if (!block) continue;
-    if (block.type !== "text" && block.type !== "json") {
-      throw new AIRequestError(
-        `ollama does not support ${field}[${i}] of type "${block.type}"; only text/json blocks are supported`,
-        "UNSUPPORTED_CONTENT_BLOCK",
-      );
-    }
-  }
-
-  return blocks;
-}
-
-function ensureOllamaReasoningBlocks(
-  blocks: import("../index.js").ContentBlock[],
-  field: string,
-): Array<Extract<import("../index.js").ContentBlock, { type: "text" }>> {
-  return blocks.map((block, index) => {
-    if (block.type !== "text") {
-      throw new AIRequestError(
-        `ollama does not support ${field}[${index}] of type "${block.type}"; reasoning only supports text blocks`,
-        "UNSUPPORTED_CONTENT_BLOCK",
-      );
-    }
-
-    return block;
-  });
-}
+// ── ProviderProfile & Mapper ────────────────────────────────────
+
+const profile: ProviderProfile = {
+  kind: "ollama",
+  instructionsMode: "system_message",
+  supportedBlockTypes: ["text", "json"] as const,
+  reasoningBlockTypes: ["text"] as const,
+  capabilities: {
+    textStreaming: "native",
+    reasoningStreaming: "none",
+    toolCallStreaming: "synthetic",
+    replay: "opaque",
+    usage: "final",
+    toolResultOutcomes: ["success"],
+  },
+};
 
-function instructionsToOllamaText(instructions: string | import("../index.js").InstructionBlock[]): string {
-  return typeof instructions === "string"
-    ? instructions
-    : contentBlocksToText(ensureOllamaTextBlocks(instructions, "instructions"));
-}
+const mapper = new NormalizedRequestMapper(profile);
 
 function parseOllamaToolArguments(item: import("../index.js").ToolCallItem): Record<string, unknown> {
   if (item.argumentsJson && typeof item.argumentsJson === "object" && item.argumentsJson !== null) {
@@ -139,15 +121,6 @@ function parseOllamaToolArguments(item: import("../index.js").ToolCallItem): Rec
   );
 }
 
-function assertOllamaToolResultOutcome(outcome: import("../index.js").ToolResultItem["outcome"]): void {
-  if (outcome !== "success") {
-    throw new AIRequestError(
-      `ollama does not preserve tool_result outcome "${outcome}"; only "success" is supported`,
-      "UNSUPPORTED_TOOL_RESULT_OUTCOME",
-    );
-  }
-}
-
 // ── Ollama 流式 chunk ─────────────────────────────────────────
 
 type OllamaChatChunk = {
@@ -169,50 +142,17 @@ type OllamaChatChunk = {
   eval_duration?: number;
 };
 
-// ── NDJSON 解析 ───────────────────────────────────────────────
-
-function parseOllamaNDJSON(buffer: string): { chunks: OllamaChatChunk[]; rest: string; malformedLines: number } {
-  const chunks: OllamaChatChunk[] = [];
-  let rest = buffer;
-  let malformedLines = 0;
-
-  while (true) {
-    const lineEnd = rest.indexOf("\n");
-    if (lineEnd === -1) break;
-
-    const line = rest.slice(0, lineEnd).trim();
-    rest = rest.slice(lineEnd + 1);
-
-    if (!line) continue;
-
-    try {
-      const parsed = JSON.parse(line);
-      // Ollama chunks have a "message" field in streaming mode
-      if (parsed && typeof parsed === "object" && "message" in parsed) {
-        chunks.push(parsed as OllamaChatChunk);
-      } else {
-        malformedLines++;
-      }
-    } catch {
-      malformedLines++;
-    }
-  }
-
-  return { chunks, rest, malformedLines };
-}
+/** Opaque replay may carry optional local `id`s; wire tool_calls never include them. */
+type OllamaReplayToolCall = OllamaToolCall & { id?: string };
 
-function rollbackTrailingAssistantMessages(messages: OllamaMessage[]): void {
-  while (messages.length > 0 && messages[messages.length - 1]?.role === "assistant") {
-    messages.pop();
-  }
-}
-
-function isOllamaToolCalls(value: unknown): value is OllamaToolCall[] {
+function isOllamaReplayToolCalls(value: unknown): value is OllamaReplayToolCall[] {
   return (
     Array.isArray(value) &&
     value.every((entry) => {
       if (!entry || typeof entry !== "object" || !("function" in entry)) return false;
       const fn = (entry as { function?: unknown }).function;
+      const id = (entry as { id?: unknown }).id;
+      if (id !== undefined && typeof id !== "string") return false;
       return (
         !!fn &&
         typeof fn === "object" &&
@@ -226,11 +166,20 @@ function isOllamaToolCalls(value: unknown): value is OllamaToolCall[] {
   );
 }
 
+function toWireOllamaToolCalls(toolCalls: OllamaReplayToolCall[]): OllamaToolCall[] {
+  return toolCalls.map((tc) => ({
+    function: {
+      name: tc.function.name,
+      arguments: tc.function.arguments,
+    },
+  }));
+}
+
 // ── Adapter ───────────────────────────────────────────────────
 
 export class OllamaAdapter extends AdapterBase {
   readonly kind = "ollama" as const;
-  readonly nativeStreaming = true;
+  readonly capabilities = profile.capabilities;
 
   private baseUrl: string;
   private apiKey: string | undefined;
@@ -251,10 +200,12 @@ export class OllamaAdapter extends AdapterBase {
     }
 
     const messages: OllamaMessage[] = [];
+    /** Local-only name → call id queue for best-effort tool_result association (not sent to Ollama). */
+    const callIdsByName = new Map<string, string[]>();
 
     // handle instructions → system message
     if (request.instructions) {
-      messages.push({ role: "system", content: instructionsToOllamaText(request.instructions) });
+      messages.push({ role: "system", content: mapper.mapInstructions(request.instructions) });
     }
 
     for (const item of request.input) {
@@ -263,7 +214,7 @@ export class OllamaAdapter extends AdapterBase {
           const role = item.role;
           messages.push({
             role,
-            content: contentBlocksToText(ensureOllamaTextBlocks(item.content, `input message (${item.role}) content`)),
+            content: contentBlocksToText(mapper.ensureTextBlocks(item.content, `input message (${item.role}) content`)),
           });
           break;
         }
@@ -276,6 +227,9 @@ export class OllamaAdapter extends AdapterBase {
               arguments: parseOllamaToolArguments(item),
             },
           };
+          const queue = callIdsByName.get(item.name) ?? [];
+          queue.push(item.id);
+          callIdsByName.set(item.name, queue);
           if (lastAssistant) {
             lastAssistant.tool_calls = [...(lastAssistant.tool_calls ?? []), tc];
           } else {
@@ -284,10 +238,15 @@ export class OllamaAdapter extends AdapterBase {
           break;
         }
         case "tool_result": {
-          assertOllamaToolResultOutcome(item.outcome);
+          mapper.assertToolResultOutcome(item.outcome);
+          // Best-effort: consume matching id from name queue when present (no wire call_id)
+          const queue = callIdsByName.get(item.toolName);
+          if (queue && queue.length > 0) {
+            queue.shift();
+          }
           messages.push({
             role: "tool",
-            content: contentBlocksToText(ensureOllamaTextBlocks(item.content, `tool_result ${item.callId} content`)),
+            content: contentBlocksToText(mapper.ensureTextBlocks(item.content, `tool_result ${item.callId} content`)),
           });
           break;
         }
@@ -295,27 +254,42 @@ export class OllamaAdapter extends AdapterBase {
           // Ollama doesn't support reasoning in input; convert to text message
           messages.push({
             role: "assistant",
-            content: contentBlocksToText(ensureOllamaReasoningBlocks(item.content, "reasoning content")),
+            content: contentBlocksToText(mapper.ensureReasoningBlocks(item.content, "reasoning content")),
           });
           break;
         }
         case "opaque": {
-          // Best-effort restore from opaque replay
-          if (
-            item.source === "ollama" &&
-            item.purpose === "replay" &&
-            typeof item.payload === "object" &&
-            item.payload !== null
-          ) {
-            const payload = item.payload as Record<string, unknown>;
-            if (payload.role === "assistant" && typeof payload.content === "string") {
-              rollbackTrailingAssistantMessages(messages);
-              messages.push({
-                role: "assistant",
-                content: payload.content,
-                tool_calls: isOllamaToolCalls(payload.tool_calls) ? payload.tool_calls : undefined,
-              });
+          // Best-effort restore from opaque replay (local ids stripped before wire)
+          if (item.source !== "ollama" || item.purpose !== "replay") break;
+          assertOpaqueReplayEnvelope(item.payload);
+          const payload = item.payload as Record<string, unknown>;
+          if (payload.role === "assistant" && typeof payload.content === "string") {
+            mapper.rollbackTrailingAssistantMessages(messages);
+            let replayToolCalls: OllamaReplayToolCall[] | undefined;
+            if ("tool_calls" in payload && payload.tool_calls !== undefined) {
+              if (!isOllamaReplayToolCalls(payload.tool_calls)) {
+                throw new AIRequestError(
+                  "Invalid opaque replay payload: tool_calls is not a valid ollama tool_calls array",
+                  "INVALID_OPAQUE_REPLAY",
+                );
+              }
+              replayToolCalls = payload.tool_calls;
+            }
+            // Record name → id order for best-effort tool_result correlation (local only)
+            if (replayToolCalls) {
+              for (const tc of replayToolCalls) {
+                if (tc.id) {
+                  const queue = callIdsByName.get(tc.function.name) ?? [];
+                  queue.push(tc.id);
+                  callIdsByName.set(tc.function.name, queue);
+                }
+              }
             }
+            messages.push({
+              role: "assistant",
+              content: payload.content,
+              tool_calls: replayToolCalls ? toWireOllamaToolCalls(replayToolCalls) : undefined,
+            });
           }
           break;
         }
@@ -358,6 +332,7 @@ export class OllamaAdapter extends AdapterBase {
     request: NormalizedRequest,
   ): AsyncIterable<AIStreamEvent> {
     const auxiliary = this.createAuxiliaryState(request);
+    let completedEmitted = false;
     if (request.metadata) {
       yield factory.responseWarning("Request metadata is not supported by the Ollama adapter", "UNSUPPORTED_METADATA");
     }
@@ -369,25 +344,44 @@ export class OllamaAdapter extends AdapterBase {
       headers.Authorization = `Bearer ${this.apiKey}`;
     }
 
-    const response = await this.fetchFn(`${this.baseUrl}/api/chat`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(providerRequest),
-    });
+    let response: Response;
+
+    try {
+      response = await this.fetchFn(`${this.baseUrl}/api/chat`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(providerRequest),
+      });
+    } catch (err) {
+      throw new AIProviderError(err instanceof Error ? err.message : String(err), "PROVIDER_ERROR");
+    }
 
     if (!response.ok) {
-      const errorText = await response.text().catch(() => "unknown error");
-      throw new Error(`Ollama API error ${response.status}: ${errorText}`);
+      const errorBody = await response.text().catch(() => "");
+      throw providerHttpError(response.status, errorBody);
     }
 
     const reader = response.body?.getReader();
     if (!reader) {
-      throw new Error("Response body is not readable");
+      throw new AIStreamError("Response body is not readable", "STREAM_ERROR");
     }
 
+    const parser = new IncrementalStreamParser<OllamaChatChunk>(splitLines, (item: string) => {
+      const trimmed = item.trim();
+      if (!trimmed) return { status: "ignored" };
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed && typeof parsed === "object" && "message" in parsed) {
+          return { status: "parsed", value: parsed as OllamaChatChunk };
+        }
+        return { status: "malformed" };
+      } catch {
+        return { status: "malformed" };
+      }
+    });
+
     const output: OutputItem[] = [];
-    const decoder = new TextDecoder();
-    let buffer = "";
+    let streamDone = false;
 
     // 累积状态
     let responseId: string | undefined;
@@ -397,15 +391,76 @@ export class OllamaAdapter extends AdapterBase {
 
     // tool_calls 累积（于 final chunk 到达）
     let pendingToolCalls: Array<{ id: string; name: string; argumentsText: string; argumentsJson?: unknown }> = [];
+    let toolCallIndex = 0;
+    const buildResponse = this.buildResponse.bind(this);
+
+    const emitCompleted = async function* (
+      stopReason: import("../index.js").StopReason | undefined,
+      rawResponseId: string | undefined,
+    ): AsyncIterable<AIStreamEvent> {
+      if (completedEmitted) {
+        yield factory.responseWarning("Duplicate finish signal ignored", "DUPLICATE_FINISH");
+        return;
+      }
+
+      completedEmitted = true;
+
+      const replay = replayFromOutput(output);
+
+      if (accumulatedContent || pendingToolCalls.length > 0) {
+        replay.push(
+          opaqueItem("ollama", "replay", {
+            role: "assistant",
+            content: accumulatedContent,
+            tool_calls: pendingToolCalls.map((tc) => ({
+              id: tc.id,
+              function: { name: tc.name, arguments: tc.argumentsJson },
+            })),
+          }),
+        );
+      }
+
+      const auxiliaryResult = await auxiliary.finalize(factory);
+      for (const event of auxiliaryResult.events) {
+        yield event;
+      }
+
+      const finalResponse = buildResponse(
+        request,
+        {
+          output,
+          replay,
+          stopReason,
+          usage: auxiliaryResult.usage,
+          billing: auxiliaryResult.billing,
+          auxiliary: auxiliaryResult.auxiliary,
+          warnings: auxiliaryResult.warnings,
+          metadataSources: auxiliaryResult.metadataSources,
+          rawResponseId,
+        },
+        factory,
+      );
+      yield factory.responseCompleted({
+        replay: finalResponse.replay,
+        stopReason: finalResponse.stopReason,
+        trace: finalResponse.backend,
+        usage: finalResponse.usage,
+        billing: finalResponse.billing,
+        auxiliary: finalResponse.auxiliary,
+        warnings: finalResponse.warnings,
+      });
+    };
 
     try {
       while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-
-        buffer += decoder.decode(value, { stream: true });
-        const { chunks, rest, malformedLines } = parseOllamaNDJSON(buffer);
-        buffer = rest;
+        const readResult = await reader.read().catch((err: unknown) => {
+          throw new AIStreamError(
+            `Failed to read response stream: ${err instanceof Error ? err.message : String(err)}`,
+            "STREAM_ERROR",
+          );
+        });
+        const { done, value } = readResult;
+        const { items: chunks, malformed: malformedLines } = done ? parser.flush() : parser.feed(value as Uint8Array);
 
         const malformedWarning = emitMalformedStreamWarning(factory, {
           count: malformedLines,
@@ -419,6 +474,13 @@ export class OllamaAdapter extends AdapterBase {
         for (const chunk of chunks) {
           responseId = chunk.created_at;
 
+          if (completedEmitted) {
+            if (chunk.done) {
+              yield factory.responseWarning("Duplicate finish signal ignored", "DUPLICATE_FINISH");
+            }
+            continue;
+          }
+
           const msg = chunk.message;
 
           // 处理 content delta
@@ -429,13 +491,13 @@ export class OllamaAdapter extends AdapterBase {
               yield factory.messageStarted(currentMessageId);
             }
             accumulatedContent += msg.content;
-            yield factory.messageDelta(currentMessageId, msg.content);
+            yield factory.messageDelta(currentMessageId, textBlock(msg.content));
           }
 
           // 处理 tool_calls (整块到达，在最终 chunk 中)
           if (msg.tool_calls && msg.tool_calls.length > 0) {
             for (const tc of msg.tool_calls) {
-              const tcId = `tc-${chunk.created_at}-${tc.function.name}`;
+              const tcId = `ollama-tc-${request.requestId}-${toolCallIndex++}`;
               const argsText = JSON.stringify(tc.function.arguments);
               pendingToolCalls.push({
                 id: tcId,
@@ -458,18 +520,25 @@ export class OllamaAdapter extends AdapterBase {
             // 完成消息（如果有累积的内容或正在进行的消息）
             if (hasMessageStarted) {
               const message = messageItem([textBlock(accumulatedContent)], { id: currentMessageId });
-              yield factory.messageCompleted(message);
+              yield factory.messageCompleted(currentMessageId);
               if (accumulatedContent) {
                 output.push(message);
               }
             }
 
+            if (pendingToolCalls.length > 0) {
+              yield factory.responseWarning(
+                `Ollama delivered ${pendingToolCalls.length} tool call(s) as a batch; tool_call streaming is not supported`,
+                WarningCode.TOOL_CALL_BATCHED,
+              );
+            }
+
             // 发出 tool_call 完成事件
             for (const pending of pendingToolCalls) {
               const toolCall = toolCallItem(pending.id, pending.name, pending.argumentsText, pending.argumentsJson);
               yield factory.toolCallStarted(pending.id, pending.name);
               yield factory.toolCallDelta(pending.id, { argumentsText: pending.argumentsText });
-              yield factory.toolCallCompleted(toolCall);
+              yield factory.toolCallCompleted(pending.id);
               output.push(toolCall);
             }
 
@@ -494,44 +563,7 @@ export class OllamaAdapter extends AdapterBase {
             // 构建 stop reason
             const stopReason = chunk.done_reason ? mapStopReason(chunk.done_reason) : undefined;
 
-            // 构建 replay
-            const replay = replayFromOutput(output);
-
-            // 附加 opaque replay（若有关联的 assistant 消息）
-            if (accumulatedContent || pendingToolCalls.length > 0) {
-              replay.push(
-                opaqueItem("ollama", "replay", {
-                  role: "assistant",
-                  content: accumulatedContent,
-                  tool_calls: pendingToolCalls.map((tc) => ({
-                    function: { name: tc.name, arguments: tc.argumentsJson },
-                  })),
-                }),
-              );
-            }
-
-            const auxiliaryResult = await auxiliary.finalize(factory);
-            for (const event of auxiliaryResult.events) {
-              yield event;
-            }
-
-            yield factory.responseCompleted(
-              this.buildResponse(
-                request,
-                {
-                  output,
-                  replay,
-                  stopReason,
-                  usage: auxiliaryResult.usage,
-                  billing: auxiliaryResult.billing,
-                  auxiliary: auxiliaryResult.auxiliary,
-                  warnings: auxiliaryResult.warnings,
-                  metadataSources: auxiliaryResult.metadataSources,
-                  rawResponseId: chunk.created_at,
-                },
-                factory,
-              ),
-            );
+            yield* emitCompleted(stopReason, chunk.created_at);
 
             // 重置累积状态
             accumulatedContent = "";
@@ -540,56 +572,52 @@ export class OllamaAdapter extends AdapterBase {
             pendingToolCalls = [];
           }
         }
+
+        if (done) {
+          streamDone = true;
+          break;
+        }
       }
     } finally {
-      reader.releaseLock();
+      try {
+        if (!streamDone) await reader.cancel().catch(() => undefined);
+      } finally {
+        reader.releaseLock();
+      }
     }
 
-    if (buffer.trim().length > 0) {
+    if (parser.getRemaining().trim().length > 0) {
       yield factory.responseWarning("Stream ended with an incomplete Ollama NDJSON line", "STREAM_ERROR");
     }
 
     // 流结束但无 done=true（断流保护）
-    if (hasMessageStarted || pendingToolCalls.length > 0) {
+    if (!completedEmitted && (hasMessageStarted || pendingToolCalls.length > 0)) {
       yield factory.responseWarning("Stream ended without a done signal", "INCOMPLETE_STREAM");
 
       if (hasMessageStarted) {
         const message = messageItem([textBlock(accumulatedContent)], { id: currentMessageId });
-        yield factory.messageCompleted(message);
+        yield factory.messageCompleted(currentMessageId);
         if (accumulatedContent) {
           output.push(message);
         }
       }
 
+      if (pendingToolCalls.length > 0) {
+        yield factory.responseWarning(
+          `Ollama delivered ${pendingToolCalls.length} tool call(s) as a batch; tool_call streaming is not supported`,
+          WarningCode.TOOL_CALL_BATCHED,
+        );
+      }
+
       for (const pending of pendingToolCalls) {
         const toolCall = toolCallItem(pending.id, pending.name, pending.argumentsText, pending.argumentsJson);
         yield factory.toolCallStarted(pending.id, pending.name);
         yield factory.toolCallDelta(pending.id, { argumentsText: pending.argumentsText });
-        yield factory.toolCallCompleted(toolCall);
+        yield factory.toolCallCompleted(pending.id);
         output.push(toolCall);
       }
 
-      const replay = replayFromOutput(output);
-      const auxiliaryResult = await auxiliary.finalize(factory);
-      for (const event of auxiliaryResult.events) {
-        yield event;
-      }
-      yield factory.responseCompleted(
-        this.buildResponse(
-          request,
-          {
-            output,
-            replay,
-            usage: auxiliaryResult.usage,
-            billing: auxiliaryResult.billing,
-            auxiliary: auxiliaryResult.auxiliary,
-            warnings: auxiliaryResult.warnings,
-            metadataSources: auxiliaryResult.metadataSources,
-            rawResponseId: responseId,
-          },
-          factory,
-        ),
-      );
+      yield* emitCompleted(undefined, responseId);
     }
   }
 }