@jerome-benoit/sap-ai-provider-v2 5.0.0 → 5.0.2

package/dist/chunk-QZOZ3PZT.js

@@ -0,0 +1,634 @@
+import {createRequire as __createRequire} from 'module';var require=__createRequire(import.meta.url);
+import {
+  convertToSAPMessages
+} from "./chunk-YP3AADWD.js";
+import {
+  buildAnthropicCacheMetadata,
+  buildGenerateResult,
+  buildModelParams,
+  createAISDKRequestBodySummary,
+  extractCompletionMetadata,
+  extractResponseMetadata,
+  mapFinishReason,
+  mapTokenUsage,
+  mapToolChoice,
+  mergeRequestConfig,
+  sanitizeAsJSONArray
+} from "./chunk-LEME2MFD.js";
+import {
+  VERSION,
+  convertToAISDKError,
+  getProviderName,
+  normalizeHeaders
+} from "./chunk-77JSAAPE.js";
+
+// src/stream-transformer.ts
+var StreamIdGenerator = class {
+  /**
+   * @returns A UUID string for identifying the response.
+   */
+  generateResponseId() {
+    return crypto.randomUUID();
+  }
+  /**
+   * @returns A UUID string for identifying a text block.
+   */
+  generateTextBlockId() {
+    return crypto.randomUUID();
+  }
+  /**
+   * @returns A UUID string for identifying a tool call when the API does not provide one.
+   */
+  generateToolCallId() {
+    return crypto.randomUUID();
+  }
+};
+function createAbortError(reason) {
+  const error = new Error("The operation was aborted.", { cause: reason });
+  error.name = "AbortError";
+  return error;
+}
+function createInitialStreamState() {
+  return {
+    activeText: false,
+    finishReason: {
+      raw: void 0,
+      unified: "other"
+    },
+    isFirstChunk: true,
+    usage: {
+      inputTokens: {
+        cacheRead: void 0,
+        cacheWrite: void 0,
+        noCache: void 0,
+        total: void 0
+      },
+      outputTokens: {
+        reasoning: void 0,
+        text: void 0,
+        total: void 0
+      }
+    }
+  };
+}
+function createStreamTransformer(config) {
+  const {
+    cancel,
+    convertToAISDKError: convertToAISDKError2,
+    extractChunkMetadata,
+    idGenerator,
+    includeRawChunks,
+    modelId,
+    options,
+    providerName,
+    requestId,
+    responseMetadata,
+    sdkStream,
+    streamResponseGetCitations,
+    streamResponseGetFinishReason,
+    streamResponseGetIntermediateFailures,
+    url,
+    version,
+    warnings
+  } = config;
+  let textBlockId = null;
+  const streamState = createInitialStreamState();
+  const toolCallsInProgress = /* @__PURE__ */ new Map();
+  const resolvedResponseMetadata = { ...responseMetadata };
+  let resolvedRequestId = requestId;
+  let tokenUsage;
+  let citations;
+  function collectCitations(incoming) {
+    if (!incoming?.length) return;
+    citations ??= /* @__PURE__ */ new Map();
+    for (const citation of incoming) {
+      citations.set(String(citation.ref_id ?? citation.url), citation);
+    }
+  }
+  function collectUsage(incoming) {
+    if (!incoming) return;
+    const promptDetails = tokenUsage?.prompt_tokens_details;
+    const incomingPromptDetails = incoming.prompt_tokens_details;
+    const completionDetails = tokenUsage?.completion_tokens_details;
+    const incomingCompletionDetails = incoming.completion_tokens_details;
+    const cacheDetails = promptDetails?.cache_creation_token_details;
+    const incomingCacheDetails = incomingPromptDetails?.cache_creation_token_details;
+    tokenUsage = {
+      ...tokenUsage,
+      ...incoming,
+      ...promptDetails || incomingPromptDetails ? {
+        prompt_tokens_details: {
+          ...promptDetails,
+          ...incomingPromptDetails,
+          ...cacheDetails || incomingCacheDetails ? {
+            cache_creation_token_details: { ...cacheDetails, ...incomingCacheDetails }
+          } : {}
+        }
+      } : {},
+      ...completionDetails || incomingCompletionDetails ? {
+        completion_tokens_details: { ...completionDetails, ...incomingCompletionDetails }
+      } : {}
+    };
+  }
+  function emitToolInputStart(tc, controller) {
+    if (tc.didEmitInputStart || tc.id == null) return;
+    tc.didEmitInputStart = true;
+    controller.enqueue({
+      id: tc.id,
+      toolName: tc.toolName ?? "",
+      type: "tool-input-start"
+    });
+    if (tc.arguments.length > 0) {
+      controller.enqueue({
+        delta: tc.arguments,
+        id: tc.id,
+        type: "tool-input-delta"
+      });
+    }
+  }
+  const iterator = safeIterate(sdkStream, options.abortSignal)[Symbol.asyncIterator]();
+  let canceled = false;
+  return new ReadableStream({
+    async cancel() {
+      canceled = true;
+      cancel();
+      await iterator.return(void 0);
+    },
+    async pull(controller) {
+      const { done, value } = await iterator.next();
+      if (canceled) return;
+      if (done) controller.close();
+      else controller.enqueue(value);
+    }
+  }).pipeThrough(
+    new TransformStream({
+      flush(controller) {
+        if (options.abortSignal?.aborted) {
+          handleStreamError(
+            createAbortError(options.abortSignal.reason),
+            controller,
+            convertToAISDKError2,
+            options,
+            modelId,
+            url
+          );
+          return;
+        }
+        const didEmitAnyToolCalls = finalizeToolCalls(
+          controller,
+          toolCallsInProgress,
+          idGenerator,
+          emitToolInputStart
+        );
+        if (streamState.activeText && textBlockId) {
+          controller.enqueue({ id: textBlockId, type: "text-end" });
+        }
+        const finalFinishReason = streamResponseGetFinishReason();
+        if (finalFinishReason) {
+          streamState.finishReason = mapFinishReason(finalFinishReason);
+        } else if (didEmitAnyToolCalls) {
+          streamState.finishReason = {
+            raw: void 0,
+            unified: "tool-calls"
+          };
+        }
+        streamState.usage = mapTokenUsage(tokenUsage);
+        collectCitations(streamResponseGetCitations?.());
+        if (citations) {
+          for (const citation of citations.values()) {
+            controller.enqueue({
+              id: String(citation.ref_id ?? citation.url),
+              sourceType: "url",
+              title: citation.title,
+              type: "source",
+              url: citation.url
+            });
+          }
+        }
+        const streamIntermediateFailures = streamResponseGetIntermediateFailures?.();
+        controller.enqueue({
+          finishReason: streamState.finishReason,
+          providerMetadata: {
+            [providerName]: {
+              ...buildAnthropicCacheMetadata(tokenUsage),
+              finishReason: streamState.finishReason.raw ?? "unknown",
+              finishReasonMapped: streamState.finishReason,
+              ...streamIntermediateFailures?.length ? {
+                intermediateFailures: sanitizeAsJSONArray(streamIntermediateFailures)
+              } : {},
+              ...resolvedRequestId ? { requestId: resolvedRequestId } : {},
+              responseId: resolvedResponseMetadata.id,
+              version
+            }
+          },
+          type: "finish",
+          usage: streamState.usage
+        });
+      },
+      start(controller) {
+        controller.enqueue({
+          type: "stream-start",
+          warnings: [...warnings]
+        });
+      },
+      transform(chunk, controller) {
+        if (options.abortSignal?.aborted && !(chunk instanceof Error)) {
+          chunk = createAbortError(options.abortSignal.reason);
+        }
+        if (chunk instanceof Error) {
+          handleStreamError(chunk, controller, convertToAISDKError2, options, modelId, url);
+          return;
+        }
+        if (includeRawChunks) {
+          controller.enqueue({
+            rawValue: chunk._data ?? chunk,
+            type: "raw"
+          });
+        }
+        const metadata = extractChunkMetadata(chunk);
+        if (metadata.requestId) resolvedRequestId = metadata.requestId;
+        const incomingMetadata = metadata.responseMetadata;
+        const metadataChanged = incomingMetadata.id !== void 0 && incomingMetadata.id !== resolvedResponseMetadata.id || incomingMetadata.modelId !== void 0 && incomingMetadata.modelId !== resolvedResponseMetadata.modelId || incomingMetadata.timestamp !== void 0 && incomingMetadata.timestamp.getTime() !== resolvedResponseMetadata.timestamp?.getTime();
+        Object.assign(resolvedResponseMetadata, incomingMetadata);
+        collectUsage(chunk.getTokenUsage?.());
+        collectCitations(chunk.getCitations?.());
+        if (streamState.isFirstChunk || metadataChanged) {
+          streamState.isFirstChunk = false;
+          controller.enqueue({
+            ...resolvedResponseMetadata,
+            type: "response-metadata"
+          });
+        }
+        const deltaToolCalls = chunk.getDeltaToolCalls();
+        if (Array.isArray(deltaToolCalls) && deltaToolCalls.length > 0) {
+          streamState.finishReason = {
+            raw: void 0,
+            unified: "tool-calls"
+          };
+        }
+        const deltaContent = chunk.getDeltaContent();
+        if (typeof deltaContent === "string" && deltaContent.length > 0) {
+          textBlockId = handleTextDelta(
+            deltaContent,
+            controller,
+            streamState,
+            textBlockId,
+            idGenerator
+          );
+        }
+        if (Array.isArray(deltaToolCalls) && deltaToolCalls.length > 0) {
+          handleToolCallDeltas(deltaToolCalls, controller, toolCallsInProgress, emitToolInputStart);
+        }
+        const chunkFinishReason = chunk.getFinishReason();
+        if (chunkFinishReason) {
+          streamState.finishReason = mapFinishReason(chunkFinishReason);
+          if (streamState.finishReason.unified === "tool-calls") {
+            finalizeToolCalls(controller, toolCallsInProgress, idGenerator, emitToolInputStart);
+            if (streamState.activeText && textBlockId) {
+              controller.enqueue({ id: textBlockId, type: "text-end" });
+              streamState.activeText = false;
+            }
+          }
+        }
+      }
+    })
+  );
+}
+function finalizeToolCalls(controller, toolCallsInProgress, idGenerator, emitToolInputStart) {
+  let didEmitAnyToolCalls = false;
+  for (const tc of toolCallsInProgress.values()) {
+    if (tc.didEmitCall) {
+      continue;
+    }
+    tc.id ??= idGenerator.generateToolCallId();
+    emitToolInputStart(tc, controller);
+    didEmitAnyToolCalls = true;
+    tc.didEmitCall = true;
+    controller.enqueue({ id: tc.id, type: "tool-input-end" });
+    controller.enqueue({
+      input: tc.arguments,
+      toolCallId: tc.id,
+      toolName: tc.toolName ?? "",
+      type: "tool-call"
+    });
+  }
+  return didEmitAnyToolCalls;
+}
+function handleStreamError(error, controller, convertToAISDKError2, options, modelId, url) {
+  const aiError = convertToAISDKError2(error, {
+    modelId,
+    modelType: "languageModel",
+    operation: "doStream",
+    requestBody: createAISDKRequestBodySummary(options),
+    url
+  });
+  controller.enqueue({
+    error: aiError instanceof Error ? aiError : new Error(String(aiError)),
+    type: "error"
+  });
+  controller.terminate();
+}
+function handleTextDelta(deltaContent, controller, streamState, currentTextBlockId, idGenerator) {
+  let textBlockId = currentTextBlockId;
+  if (!streamState.activeText) {
+    textBlockId = idGenerator.generateTextBlockId();
+    controller.enqueue({ id: textBlockId, type: "text-start" });
+    streamState.activeText = true;
+  }
+  if (textBlockId) {
+    controller.enqueue({
+      delta: deltaContent,
+      id: textBlockId,
+      type: "text-delta"
+    });
+    return textBlockId;
+  }
+  return currentTextBlockId ?? idGenerator.generateTextBlockId();
+}
+function handleToolCallDeltas(deltaToolCalls, controller, toolCallsInProgress, emitToolInputStart) {
+  for (const toolCallChunk of deltaToolCalls) {
+    const index = toolCallChunk.index;
+    if (typeof index !== "number" || !Number.isFinite(index)) {
+      continue;
+    }
+    if (!toolCallsInProgress.has(index)) {
+      toolCallsInProgress.set(index, {
+        arguments: "",
+        didEmitCall: false,
+        didEmitInputStart: false,
+        id: typeof toolCallChunk.id === "string" && toolCallChunk.id.length > 0 ? toolCallChunk.id : void 0,
+        toolName: toolCallChunk.function?.name
+      });
+    }
+    const tc = toolCallsInProgress.get(index);
+    if (!tc) continue;
+    if (typeof toolCallChunk.id === "string" && toolCallChunk.id.length > 0 && tc.id === void 0) {
+      tc.id = toolCallChunk.id;
+    }
+    const nextToolName = toolCallChunk.function?.name;
+    if (typeof nextToolName === "string" && nextToolName.length > 0) {
+      tc.toolName = nextToolName;
+    }
+    if (!tc.didEmitInputStart && tc.toolName != null && tc.id != null) {
+      emitToolInputStart(tc, controller);
+    }
+    const argumentsDelta = toolCallChunk.function?.arguments;
+    if (typeof argumentsDelta === "string" && argumentsDelta.length > 0) {
+      tc.arguments += argumentsDelta;
+      if (tc.didEmitInputStart && tc.id != null) {
+        controller.enqueue({
+          delta: argumentsDelta,
+          id: tc.id,
+          type: "tool-input-delta"
+        });
+      }
+    }
+  }
+}
+async function* safeIterate(iterable, abortSignal) {
+  try {
+    for await (const chunk of iterable) {
+      abortSignal?.throwIfAborted();
+      yield chunk;
+    }
+    abortSignal?.throwIfAborted();
+  } catch (error) {
+    if (abortSignal?.aborted) {
+      yield createAbortError(abortSignal.reason);
+    } else {
+      yield error instanceof Error ? error : new Error(String(error));
+    }
+  }
+}
+
+// src/base-language-model-strategy.ts
+var BaseLanguageModelStrategy = class {
+  /**
+   * Common parameter mappings for language model APIs.
+   * @internal
+   */
+  static COMMON_PARAM_MAPPINGS = [
+    { camelCaseKey: "maxTokens", optionKey: "maxOutputTokens", outputKey: "max_completion_tokens" },
+    { camelCaseKey: "temperature", optionKey: "temperature", outputKey: "temperature" },
+    { camelCaseKey: "topP", optionKey: "topP", outputKey: "top_p" },
+    {
+      camelCaseKey: "frequencyPenalty",
+      optionKey: "frequencyPenalty",
+      outputKey: "frequency_penalty"
+    },
+    {
+      camelCaseKey: "presencePenalty",
+      optionKey: "presencePenalty",
+      outputKey: "presence_penalty"
+    },
+    { camelCaseKey: "seed", optionKey: "seed", outputKey: "seed" },
+    { optionKey: "reasoning", outputKey: "reasoning_effort" },
+    { camelCaseKey: "parallel_tool_calls", outputKey: "parallel_tool_calls" }
+  ];
+  async doGenerate(config, settings, options) {
+    try {
+      if (options.abortSignal?.aborted) throw createAbortError(options.abortSignal.reason);
+      const commonParts = this.buildCommonParts(config, settings, options);
+      const { request, warnings } = this.buildRequest(config, settings, options, commonParts);
+      const client = this.createClient(config, settings, commonParts);
+      const response = await this.executeApiCall(
+        client,
+        request,
+        mergeRequestConfig(config.requestConfig, options.abortSignal, options.headers)
+      );
+      return buildGenerateResult({
+        providerName: commonParts.providerName,
+        requestBody: request,
+        requestId: response.requestId,
+        response,
+        responseHeaders: normalizeHeaders(response.rawResponse.headers),
+        version: VERSION,
+        warnings: [...commonParts.warnings, ...warnings]
+      });
+    } catch (error) {
+      throw convertToAISDKError(error, {
+        modelId: config.modelId,
+        modelType: "languageModel",
+        operation: "doGenerate",
+        requestBody: createAISDKRequestBodySummary(options),
+        url: this.getUrl()
+      });
+    }
+  }
+  async doStream(config, settings, options) {
+    try {
+      if (options.abortSignal?.aborted) throw createAbortError(options.abortSignal.reason);
+      const commonParts = this.buildCommonParts(config, settings, options);
+      const { request, warnings } = this.buildRequest(config, settings, options, commonParts);
+      const client = this.createClient(config, settings, commonParts);
+      const streamResponse = await this.executeStreamCall(
+        client,
+        request,
+        options.abortSignal ?? void 0,
+        settings,
+        mergeRequestConfig(config.requestConfig, void 0, options.headers)
+      );
+      const idGenerator = new StreamIdGenerator();
+      const streamWarnings = this.collectStreamWarnings(settings, commonParts.sapOptions);
+      const transformedStream = createStreamTransformer({
+        cancel: streamResponse.cancel,
+        convertToAISDKError,
+        extractChunkMetadata: (chunk) => this.extractMetadata(chunk),
+        idGenerator,
+        includeRawChunks: options.includeRawChunks ?? false,
+        modelId: config.modelId,
+        options,
+        providerName: commonParts.providerName,
+        requestId: streamResponse.requestId,
+        responseMetadata: {
+          ...streamResponse.responseMetadata,
+          id: streamResponse.responseMetadata?.id ?? idGenerator.generateResponseId()
+        },
+        sdkStream: streamResponse.stream,
+        streamResponseGetCitations: streamResponse.getCitations,
+        streamResponseGetFinishReason: streamResponse.getFinishReason,
+        streamResponseGetIntermediateFailures: streamResponse.getIntermediateFailures,
+        url: this.getUrl(),
+        version: VERSION,
+        warnings: [...commonParts.warnings, ...warnings, ...streamWarnings]
+      });
+      return {
+        request: {
+          body: request
+        },
+        response: {
+          headers: streamResponse.responseHeaders
+        },
+        stream: transformedStream
+      };
+    } catch (error) {
+      throw convertToAISDKError(error, {
+        modelId: config.modelId,
+        modelType: "languageModel",
+        operation: "doStream",
+        requestBody: createAISDKRequestBodySummary(options),
+        url: this.getUrl()
+      });
+    }
+  }
+  /**
+   * Builds common parts shared between doGenerate and doStream.
+   * @param config - Strategy configuration.
+   * @param settings - Model settings.
+   * @param options - AI SDK call options.
+   * @returns Common build result with typed messages and tool choice.
+   * @internal
+   */
+  buildCommonParts(config, settings, options) {
+    const providerName = getProviderName(config.provider);
+    const sapOptions = config.parsedProviderOptions;
+    const warnings = [];
+    const resolvedState = this.resolveAdditionalState(
+      config,
+      settings,
+      sapOptions,
+      options,
+      warnings
+    );
+    const messages = convertToSAPMessages(options.prompt, {
+      escapeTemplatePlaceholders: this.getEscapeTemplatePlaceholders(sapOptions, settings),
+      includeReasoning: this.getIncludeReasoning(sapOptions, settings),
+      parsePartProviderOptions: this.getPartProviderOptionsParser(),
+      warnings
+    });
+    const { modelParams, warnings: paramWarnings } = buildModelParams({
+      options,
+      paramMappings: this.getParamMappings(),
+      providerModelParams: sapOptions?.modelParams,
+      settingsModelParams: settings.modelParams
+    });
+    warnings.push(...paramWarnings);
+    const toolChoice = mapToolChoice(options.toolChoice);
+    return {
+      messages,
+      modelParams,
+      providerName,
+      resolvedState,
+      sapOptions,
+      toolChoice,
+      warnings
+    };
+  }
+  /**
+   * Collects stream-specific warnings.
+   * Override in subclasses to add API-specific streaming warnings.
+   * @param _settings - Model settings (unused in base implementation).
+   * @param _sapOptions - Provider options (unused in base implementation).
+   * @returns Array of warnings for streaming operations.
+   * @internal
+   */
+  collectStreamWarnings(_settings, _sapOptions) {
+    return [];
+  }
+  /**
+   * Resolves completion metadata, request ID, and normalised headers from an SDK response.
+   * @param response - Raw SDK response or stream response.
+   * @returns Combined metadata fragment.
+   * @internal
+   */
+  extractMetadata(response) {
+    const responseMetadata = extractCompletionMetadata(
+      response,
+      this.getCompletionDataPath()
+    );
+    const { headers, requestId } = extractResponseMetadata(response, "rawResponse");
+    return { requestId, responseHeaders: headers, responseMetadata };
+  }
+  /**
+   * Returns whether to escape template placeholders for this API.
+   * @param _sapOptions - Parsed provider options (unused in base implementation).
+   * @param _settings - Model settings (unused in base implementation).
+   * @returns false by default; the Orchestration override defaults to true unless disabled.
+   * @internal
+   */
+  getEscapeTemplatePlaceholders(_sapOptions, _settings) {
+    return false;
+  }
+  /**
+   * Returns whether assistant reasoning in the input history is forwarded as text.
+   * @param sapOptions - Parsed provider options.
+   * @param settings - Model settings.
+   * @returns Whether to forward input reasoning (checks sapOptions then settings, defaults to false).
+   * @internal
+   */
+  getIncludeReasoning(sapOptions, settings) {
+    return sapOptions?.includeReasoning ?? settings.includeReasoning ?? false;
+  }
+  /**
+   * Returns a parser for per-message-part `providerOptions['sap-ai']`.
+   *
+   * Default returns `undefined`; strategies honouring part-level directives
+   * (e.g. Anthropic `cacheControl` on orchestration) override to return a parser.
+   * @returns Parser callback, or undefined to disable per-part plumbing.
+   * @internal
+   */
+  getPartProviderOptionsParser() {
+    return void 0;
+  }
+  /**
+   * Resolves API-specific extra state shared between doGenerate and doStream
+   * (e.g. orchestration `configRef` / `promptTemplateRef` / `tools`). Override
+   * to add API-specific deprecation checks or pre-resolve auxiliary inputs.
+   * Pushed warnings flow into the shared sink.
+   * @param _config - Strategy configuration.
+   * @param _settings - Model settings.
+   * @param _sapOptions - Parsed provider options, or `undefined`.
+   * @param _options - AI SDK call options.
+   * @param _warnings - Shared warnings sink for the current call.
+   * @returns Strategy-specific resolved state, or `undefined` (default).
+   * @internal
+   */
+  resolveAdditionalState(_config, _settings, _sapOptions, _options, _warnings) {
+    return void 0;
+  }
+};
+
+export {
+  BaseLanguageModelStrategy
+};
+//# sourceMappingURL=chunk-QZOZ3PZT.js.map