llm-stream-assemble 1.0.1 → 1.2.0

package/dist/index.cjs

@@ -1051,6 +1051,9 @@ var OpenAIChatLikeParser = class {
     }
     const looseError = providerErrorPayload(payload, this.options);
     if (looseError) return openAIProviderErrorChunks(looseError, false, this.options);
+    if (!this.options.looseErrorShape && asString(payload.error) && !isRecord(payload.error)) {
+      return [];
+    }
     if (this.options.rejectUnrecognizedPayloads && !this.isRecognizableChunk(payload)) {
       throwUnrecognizedChunkError(this.options);
     }
@@ -1313,18 +1316,30 @@ var DEFAULT_PRESET = {
   reasoningFieldAliases: ["thinking", "thinking_content"]
 };
 var PRESET_OVERRIDES = {
+  deepseek: { reasoningFieldAliases: ["reasoning_content", "reasoning", "thinking"] },
   openrouter: { reasoningFieldAliases: ["reasoning"] },
-  together: { reasoningFieldAliases: ["reasoning", "reasoning_delta"] }
+  together: { reasoningFieldAliases: ["reasoning", "reasoning_delta"] },
+  azure: {
+    looseErrorShape: false,
+    allowMissingMetadata: false,
+    useChoicePositionFallback: true,
+    reasoningFieldAliases: []
+  }
 };
 function openaiCompatibleAdapter(options = {}) {
   const preset = providerPreset(options.provider ?? "generic");
+  const resolvedAllowMissingMetadata = options.allowMissingMetadata ?? preset.allowMissingMetadata ?? DEFAULT_PRESET.allowMissingMetadata;
+  const resolvedLooseErrorShape = options.looseErrorShape ?? preset.looseErrorShape ?? DEFAULT_PRESET.looseErrorShape;
+  const resolvedUseChoicePositionFallback = options.useChoicePositionFallback ?? preset.useChoicePositionFallback ?? DEFAULT_PRESET.useChoicePositionFallback;
   return createOpenAIChatLikeAdapter({
-    ...preset,
     ...options,
+    looseErrorShape: resolvedLooseErrorShape,
+    allowMissingMetadata: resolvedAllowMissingMetadata,
+    useChoicePositionFallback: resolvedUseChoicePositionFallback,
     errorPrefix: "openaiCompatibleAdapter",
     usageInputTokenFields: ["prompt_tokens", "input_tokens"],
     usageOutputTokenFields: ["completion_tokens", "output_tokens"],
-    rejectUnrecognizedPayloads: options.allowMissingMetadata === false,
+    rejectUnrecognizedPayloads: resolvedAllowMissingMetadata === false,
     reasoningFieldAliases: [
       ...preset.reasoningFieldAliases ?? [],
       ...options.reasoningFieldAliases ?? []
@@ -1976,6 +1991,312 @@ function toolId(payload, item) {
   return callId ?? itemId ?? `response_tool:${index ?? 0}`;
 }
 
+// src/adapters/gemini.ts
+function geminiAdapter(options = {}) {
+  const parser = new GeminiStreamParser(options);
+  return createStreamAdapter({
+    parser,
+    parseResponse: parseResponse4,
+    options
+  });
+}
+var GeminiStreamParser = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  metadataEmitted = false;
+  tools = /* @__PURE__ */ new Map();
+  openToolByChoice = /* @__PURE__ */ new Map();
+  toolCounter = 0;
+  parseChunk(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0 || trimmed === "[DONE]") return [];
+    const payload = parseAdapterJSON(trimmed, "geminiAdapter.parseChunk");
+    if (!isRecord(payload)) {
+      throw libraryError("geminiAdapter.parseChunk expected a JSON object");
+    }
+    if (isRecord(payload.error)) {
+      return providerErrorChunksFromPayload(
+        payload.error,
+        "geminiAdapter.parseChunk",
+        false,
+        "Gemini provider error"
+      );
+    }
+    const chunks = [];
+    const feedback = isRecord(payload.promptFeedback) ? payload.promptFeedback : void 0;
+    const blockReason = feedback ? asString(feedback.blockReason) : void 0;
+    if (blockReason) {
+      return providerErrorChunksFromMessage(`Gemini prompt blocked: ${blockReason}`, false);
+    }
+    chunks.push(...this.metadataChunks(payload));
+    const usage = usageChunk3(payload.usageMetadata);
+    if (usage) chunks.push(usage);
+    const candidates = Array.isArray(payload.candidates) ? payload.candidates : [];
+    for (const candidate of candidates) {
+      if (!isRecord(candidate)) continue;
+      chunks.push(...this.candidateChunks(candidate));
+    }
+    return chunks;
+  }
+  metadataChunks(payload) {
+    if (this.metadataEmitted) return [];
+    const responseId = asString(payload.responseId);
+    const model = asString(payload.modelVersion);
+    if (!responseId && !model) return [];
+    this.metadataEmitted = true;
+    const chunks = [];
+    if (responseId) chunks.push({ kind: "message-start", id: responseId });
+    chunks.push(
+      optionalRawChunk({
+        kind: "metadata",
+        responseId,
+        model,
+        raw: { responseId, modelVersion: model }
+      })
+    );
+    return chunks;
+  }
+  candidateChunks(candidate) {
+    const chunks = [];
+    const choiceIndex = asNumber(candidate.index) ?? 0;
+    const citation = candidate.citationMetadata;
+    const grounding = candidate.groundingMetadata;
+    if (citation !== void 0 || grounding !== void 0) {
+      chunks.push(
+        optionalRawChunk({
+          kind: "metadata",
+          raw: { citationMetadata: citation, groundingMetadata: grounding }
+        })
+      );
+    }
+    const content = isRecord(candidate.content) ? candidate.content : void 0;
+    const parts = content && Array.isArray(content.parts) ? content.parts : [];
+    for (let partIndex = 0; partIndex < parts.length; partIndex += 1) {
+      const part = parts[partIndex];
+      if (!isRecord(part)) continue;
+      chunks.push(...this.partChunks(part, partIndex, choiceIndex));
+    }
+    const finishReason2 = asString(candidate.finishReason);
+    if (finishReason2) {
+      const mapped = mapFinishReason(finishReason2);
+      if (mapped === "error") {
+        chunks.push(
+          ...providerErrorChunksFromMessage(`Gemini finishReason: ${finishReason2}`, false)
+        );
+      } else {
+        chunks.push({ kind: "finish", reason: mapped, choiceIndex });
+      }
+    }
+    return chunks;
+  }
+  partChunks(part, partIndex, choiceIndex) {
+    if (isRecord(part.functionResponse)) return [];
+    if (part.inlineData !== void 0 || part.fileData !== void 0) return [];
+    if (part.executableCode !== void 0 || part.codeExecutionResult !== void 0) return [];
+    const thought = part.thought === true;
+    const text = asString(part.text);
+    if (thought && text) {
+      return [{ kind: "reasoning-delta", text, variant: "detail" }];
+    }
+    if (thought && !text) return [];
+    if (text !== void 0) {
+      if (text.length === 0) return [];
+      if (this.options.jsonMode) return [{ kind: "json-delta", delta: text }];
+      return [{ kind: "text-delta", text, choiceIndex }];
+    }
+    const functionCall = isRecord(part.functionCall) ? part.functionCall : void 0;
+    if (functionCall) return this.functionCallChunks(functionCall, partIndex, choiceIndex);
+    if (Object.keys(part).length === 0) return [];
+    return [];
+  }
+  functionCallChunks(functionCall, partIndex, choiceIndex) {
+    const chunks = [];
+    const explicitId = asString(functionCall.id);
+    const name = asString(functionCall.name);
+    let toolKey2 = this.resolveToolKey(explicitId, partIndex, choiceIndex, name);
+    if (name && !this.tools.has(toolKey2)) {
+      toolKey2 = explicitId ?? `${choiceIndex}:${partIndex}`;
+      const id = explicitId ?? `gemini:${choiceIndex}:${this.toolCounter++}`;
+      this.tools.set(toolKey2, {
+        id,
+        name,
+        index: partIndex,
+        choiceIndex,
+        lastArgsJson: "",
+        open: true
+      });
+      this.openToolByChoice.set(choiceIndex, toolKey2);
+      chunks.push(
+        optionalRawChunk({
+          kind: "tool-start",
+          id,
+          name,
+          index: partIndex,
+          choiceIndex
+        })
+      );
+    }
+    const current = this.tools.get(toolKey2);
+    if (!current) return chunks;
+    const partialArgs = Array.isArray(functionCall.partialArgs) ? functionCall.partialArgs : [];
+    for (const item of partialArgs) {
+      if (!isRecord(item)) continue;
+      const delta = partialArgDelta(item);
+      if (delta) {
+        chunks.push(
+          optionalRawChunk({
+            kind: "tool-args-delta",
+            id: current.id,
+            delta,
+            index: current.index,
+            choiceIndex
+          })
+        );
+      }
+    }
+    if (isRecord(functionCall.args)) {
+      const delta = this.argsObjectDelta(toolKey2, functionCall.args);
+      if (delta) {
+        chunks.push(
+          optionalRawChunk({
+            kind: "tool-args-delta",
+            id: current.id,
+            delta,
+            index: current.index,
+            choiceIndex
+          })
+        );
+      }
+    }
+    const willContinue = functionCall.willContinue === true;
+    const hasPartialArgs = partialArgs.length > 0;
+    const hasArgs = isRecord(functionCall.args) && Object.keys(functionCall.args).length > 0;
+    if (!willContinue && !hasPartialArgs && (hasArgs || name && isRecord(functionCall.args))) {
+      chunks.push(
+        optionalRawChunk({
+          kind: "tool-done",
+          id: current.id,
+          index: current.index,
+          choiceIndex
+        })
+      );
+      current.open = false;
+    } else if (!willContinue && hasPartialArgs && partialArgs.every((item) => isRecord(item) && item.willContinue !== true)) {
+      if (current.open) {
+        chunks.push(
+          optionalRawChunk({
+            kind: "tool-done",
+            id: current.id,
+            index: current.index,
+            choiceIndex
+          })
+        );
+        current.open = false;
+      }
+    }
+    return chunks;
+  }
+  resolveToolKey(explicitId, partIndex, choiceIndex, name) {
+    if (explicitId) return explicitId;
+    const openKey = this.openToolByChoice.get(choiceIndex);
+    if (openKey && this.tools.get(openKey)?.open) return openKey;
+    if (name) {
+      for (const [key, state] of this.tools) {
+        if (state.choiceIndex === choiceIndex && state.name === name && state.open) return key;
+      }
+    }
+    return `${choiceIndex}:${partIndex}`;
+  }
+  argsObjectDelta(toolKey2, args) {
+    const next = JSON.stringify(args);
+    const state = this.tools.get(toolKey2);
+    const prev = state?.lastArgsJson ?? "";
+    if (next === prev) return void 0;
+    let delta;
+    if (prev.length > 0 && next.startsWith(prev)) {
+      delta = next.slice(prev.length);
+    } else {
+      delta = next;
+    }
+    if (state) state.lastArgsJson = next;
+    return delta.length > 0 ? delta : void 0;
+  }
+};
+function parseResponse4(body, options) {
+  if (!isRecord(body)) {
+    throw libraryError("geminiAdapter.parseResponse expected a GenerateContentResponse object");
+  }
+  const parser = new GeminiStreamParser(options);
+  const chunks = [];
+  if (isRecord(body.error)) {
+    return providerErrorChunksFromPayload(
+      body.error,
+      "geminiAdapter.parseResponse",
+      false,
+      "Gemini provider error"
+    );
+  }
+  const feedback = isRecord(body.promptFeedback) ? body.promptFeedback : void 0;
+  const blockReason = feedback ? asString(feedback.blockReason) : void 0;
+  if (blockReason) {
+    return providerErrorChunksFromMessage(`Gemini prompt blocked: ${blockReason}`, false);
+  }
+  chunks.push(...parser.parseChunk(JSON.stringify(body)));
+  const hasFinish = chunks.some((chunk) => chunk.kind === "finish");
+  if (!hasFinish) {
+    chunks.push({ kind: "finish", reason: "stop" });
+  }
+  return chunks;
+}
+function partialArgDelta(arg) {
+  const stringValue = asString(arg.stringValue);
+  if (stringValue !== void 0) return stringValue;
+  const jsonPath = asString(arg.jsonPath) ?? "$";
+  const key = jsonPath.replace(/^\$\.?/, "").split(".")[0] ?? "value";
+  if (arg.numberValue !== void 0) return JSON.stringify({ [key]: arg.numberValue });
+  if (arg.boolValue !== void 0) return JSON.stringify({ [key]: arg.boolValue });
+  if (arg.nullValue !== void 0) return JSON.stringify({ [key]: null });
+  return void 0;
+}
+function mapFinishReason(value) {
+  switch (value) {
+    case "STOP":
+    case "STOP_REASON_UNSPECIFIED":
+      return "stop";
+    case "MAX_TOKENS":
+      return "length";
+    case "SAFETY":
+    case "RECITATION":
+    case "BLOCKLIST":
+    case "PROHIBITED_CONTENT":
+    case "SPII":
+    case "LANGUAGE":
+      return "content_filter";
+    case "MALFORMED_FUNCTION_CALL":
+      return "error";
+    default:
+      return "error";
+  }
+}
+function usageChunk3(value) {
+  if (!isRecord(value)) return void 0;
+  const inputTokens = asNumber(value.promptTokenCount);
+  const outputTokens = asNumber(value.candidatesTokenCount);
+  const reasoningTokens = asNumber(value.thoughtsTokenCount);
+  if (inputTokens === void 0 && outputTokens === void 0 && reasoningTokens === void 0) {
+    return void 0;
+  }
+  return optionalRawChunk({
+    kind: "usage",
+    inputTokens,
+    outputTokens,
+    reasoningTokens,
+    raw: value
+  });
+}
+
 // src/transforms/collect-stream.ts
 async function collectStream(events) {
   const result = {
@@ -2210,6 +2531,7 @@ exports.assembleResponse = assembleResponse;
 exports.assembleStream = assembleStream;
 exports.collectStream = collectStream;
 exports.createAssemblyTransform = createAssemblyTransform;
+exports.geminiAdapter = geminiAdapter;
 exports.isError = isError;
 exports.isFinish = isFinish;
 exports.isJsonDelta = isJsonDelta;