@umituz/web-ai 1.0.8 → 1.0.10

package/dist/{provider.factory-CJuI08Xr.d.ts → provider.factory-B9RNUTYj.d.ts}

@@ -1,4 +1,4 @@
-import { P as ProviderHealth, T as TextRequest, G as GenerationResult, a as StructuredTextRequest, S as StructuredGeneration, d as StreamCallbacks, b as TextTier } from './index-DDzvTDg0.js';
+import { P as ProviderHealth, T as TextRequest, G as GenerationResult, a as StructuredTextRequest, S as StructuredGeneration, d as StreamCallbacks, b as TextTier } from './index-OhvYUTXf.js';
 import { T as TextGenerationRequest, I as ImageGenerationRequest, V as VideoGenerationRequest, G as GeneratedContent, a as ImageToVideoRequest, b as VideoToVideoRequest } from './ProviderConfig-DIFa9nmG.js';
 
 /**

package/dist/{provider.factory-DG2CYFgh.d.cts → provider.factory-Ce6Een1G.d.cts}

@@ -1,4 +1,4 @@
-import { P as ProviderHealth, T as TextRequest, G as GenerationResult, a as StructuredTextRequest, S as StructuredGeneration, d as StreamCallbacks, b as TextTier } from './index-DDzvTDg0.cjs';
+import { P as ProviderHealth, T as TextRequest, G as GenerationResult, a as StructuredTextRequest, S as StructuredGeneration, d as StreamCallbacks, b as TextTier } from './index-OhvYUTXf.cjs';
 import { T as TextGenerationRequest, I as ImageGenerationRequest, V as VideoGenerationRequest, G as GeneratedContent, a as ImageToVideoRequest, b as VideoToVideoRequest } from './ProviderConfig-DIFa9nmG.cjs';
 
 /**

package/dist/providers/index.cjs

@@ -246,6 +246,68 @@ async function extractErrorMessageFromResponse(response) {
   return buildHttpStatusFallback(response.status, response.statusText);
 }
 
+// src/core/errors/unified-ai-error.ts
+var STATUS_TO_CODE = {
+  400: "invalid_request",
+  401: "invalid_key",
+  403: "invalid_key",
+  404: "model_unavailable",
+  413: "invalid_request",
+  422: "invalid_request",
+  429: "rate_limited",
+  500: "upstream_error",
+  502: "upstream_error",
+  503: "capacity",
+  504: "timeout"
+};
+var CODE_MESSAGES = {
+  invalid_key: "The provider rejected the configured API key.",
+  missing_key: "The provider is not configured with an API key.",
+  rate_limited: "The provider rate limit was reached. Try again shortly.",
+  capacity: "The provider is temporarily at capacity. Try again shortly.",
+  timeout: "The model took too long to respond.",
+  invalid_request: "The request was rejected by the provider.",
+  model_unavailable: "The requested model is not available.",
+  upstream_error: "The provider returned an unexpected error.",
+  network: "Could not reach the provider.",
+  cancelled: "Generation was cancelled."
+};
+var AiError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message ?? CODE_MESSAGES[code]);
+    this.name = "AiError";
+    this.code = code;
+  }
+  get userMessage() {
+    return this.message;
+  }
+};
+function isApiKeyRejection(provider) {
+  if (provider.code === "invalid_api_key") return true;
+  return provider.type === void 0;
+}
+function errorFromStatus(status, detail, provider) {
+  let code = STATUS_TO_CODE[status] ?? "upstream_error";
+  if (status === 403 && provider && !isApiKeyRejection(provider)) {
+    code = "model_unavailable";
+  }
+  return new AiError(code, detail ? `${CODE_MESSAGES[code]} (${detail})` : void 0);
+}
+function errorFromUnknown(err) {
+  if (err instanceof AiError) return err;
+  if (err instanceof Error) {
+    if (err.name === "TimeoutError" || err.name === "AbortError") {
+      return new AiError("timeout");
+    }
+    if (err.name === "TypeError") {
+      return new AiError("network");
+    }
+    return new AiError("upstream_error", err.message);
+  }
+  return new AiError("upstream_error");
+}
+
 // src/providers/factory/provider.factory.ts
 var ProviderFactory = class {
   providers = /* @__PURE__ */ new Map();
@@ -4163,6 +4225,323 @@ function createOpenAiImageAdapter(config) {
   };
 }
 
+// src/core/sse/tool-call-accumulator.ts
+var ToolCallAccumulator = class {
+  slots = /* @__PURE__ */ new Map();
+  push(delta) {
+    const index = delta.index ?? 0;
+    const slot = this.slots.get(index) ?? { id: "", name: "", args: "" };
+    if (delta.id) slot.id = delta.id;
+    if (delta.function?.name) slot.name = delta.function.name;
+    if (delta.function?.arguments) slot.args += delta.function.arguments;
+    this.slots.set(index, slot);
+  }
+  finish() {
+    return Array.from(this.slots.entries()).sort(([a], [b]) => a - b).map(([, slot]) => ({
+      id: slot.id,
+      name: slot.name,
+      arguments: slot.args
+    })).filter((call) => call.id.length > 0 || call.name.length > 0);
+  }
+};
+
+// src/providers/adapters/openai-compatible.adapter.ts
+function toWireMessage(message) {
+  if (message.role === "tool") {
+    return { role: "tool", content: message.content, tool_call_id: message.toolCallId ?? "" };
+  }
+  if (message.role === "assistant" && message.toolCalls && message.toolCalls.length > 0) {
+    return {
+      role: "assistant",
+      content: message.content,
+      tool_calls: message.toolCalls.map((call) => ({
+        id: call.id,
+        type: "function",
+        function: { name: call.name, arguments: call.arguments }
+      }))
+    };
+  }
+  if (message.role === "user") return { role: "user", content: message.content };
+  return { role: message.role, content: message.content };
+}
+function mergeImages(messages, images) {
+  if (images.length === 0) return [...messages];
+  const parts = images.map((image) => ({
+    type: "image_url",
+    image_url: { url: `data:${image.mimeType};base64,${image.dataBase64}` }
+  }));
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message.role !== "user") continue;
+    const textParts = typeof message.content === "string" ? message.content.length > 0 ? [{ type: "text", text: message.content }] : [] : message.content;
+    return [
+      ...messages.slice(0, index),
+      { role: "user", content: [...textParts, ...parts] },
+      ...messages.slice(index + 1)
+    ];
+  }
+  return [...messages, { role: "user", content: [...parts] }];
+}
+async function extractErrorDetail(response) {
+  try {
+    const body = await response.json();
+    return body.error;
+  } catch {
+    return void 0;
+  }
+}
+async function* parseSseEvent(rawEvent, toolCallAccumulator) {
+  for (const line of rawEvent.split("\n")) {
+    if (!line.startsWith("data:")) continue;
+    const payload = line.slice(5).trim();
+    if (payload.length === 0 || payload === "[DONE]") continue;
+    let chunk;
+    try {
+      chunk = JSON.parse(payload);
+    } catch {
+      continue;
+    }
+    const delta = chunk.choices?.[0]?.delta;
+    if (delta?.reasoning) {
+      yield { type: "delta", channel: "reasoning", text: delta.reasoning };
+    }
+    if (delta?.content) {
+      yield { type: "delta", channel: "answer", text: delta.content };
+    }
+    if (delta?.tool_calls) {
+      for (const toolCallDelta of delta.tool_calls) toolCallAccumulator.push(toolCallDelta);
+    }
+    if (chunk.usage) {
+      yield {
+        type: "usage",
+        usage: {
+          inputTokens: chunk.usage.prompt_tokens ?? 0,
+          outputTokens: chunk.usage.completion_tokens ?? 0,
+          reasoningTokens: chunk.usage.completion_tokens_details?.reasoning_tokens
+        }
+      };
+    }
+  }
+}
+async function* parseSseStream(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  const toolCallAccumulator = new ToolCallAccumulator();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let separator = buffer.indexOf("\n\n");
+      while (separator !== -1) {
+        const rawEvent = buffer.slice(0, separator);
+        buffer = buffer.slice(separator + 2);
+        separator = buffer.indexOf("\n\n");
+        yield* parseSseEvent(rawEvent, toolCallAccumulator);
+      }
+    }
+  } catch (err) {
+    throw errorFromUnknown(err);
+  } finally {
+    reader.releaseLock();
+  }
+  const calls = toolCallAccumulator.finish();
+  if (calls.length > 0) yield { type: "tool_calls", calls };
+}
+function createOpenAiCompatibleAdapter(config) {
+  return {
+    async *stream(req) {
+      const timeout = AbortSignal.timeout(config.timeoutMs);
+      const signal = req.signal ? AbortSignal.any([req.signal, timeout]) : timeout;
+      let response;
+      try {
+        response = await fetch(`${config.baseUrl}/chat/completions`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${config.apiKey}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            model: req.externalModelId,
+            messages: mergeImages(req.messages.map(toWireMessage), req.images ?? []),
+            temperature: req.temperature,
+            max_completion_tokens: req.maxOutputTokens,
+            top_p: req.topP,
+            stream: true,
+            stream_options: { include_usage: true },
+            ...req.tools && req.tools.length > 0 ? {
+              tools: req.tools.map((tool) => ({ type: "function", function: tool })),
+              tool_choice: "auto"
+            } : {}
+          }),
+          signal
+        });
+      } catch (err) {
+        throw errorFromUnknown(err);
+      }
+      if (!response.ok || !response.body) {
+        const detail = await extractErrorDetail(response);
+        throw errorFromStatus(response.status, detail?.message, detail);
+      }
+      yield* parseSseStream(response.body);
+    }
+  };
+}
+
+// src/providers/adapters/anthropic.adapter.ts
+var ANTHROPIC_VERSION = "2023-06-01";
+var ERROR_TYPE_TO_CODE = {
+  invalid_request_error: "invalid_request",
+  authentication_error: "invalid_key",
+  permission_error: "invalid_key",
+  not_found_error: "model_unavailable",
+  request_too_large: "invalid_request",
+  rate_limit_error: "rate_limited",
+  overloaded_error: "capacity",
+  api_error: "upstream_error"
+};
+function mergeImages2(messages, images) {
+  if (images.length === 0) return [...messages];
+  const blocks = images.map((image) => ({
+    type: "image",
+    source: { type: "base64", media_type: image.mimeType, data: image.dataBase64 }
+  }));
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message.role !== "user") continue;
+    const textBlocks = typeof message.content === "string" ? message.content.length > 0 ? [{ type: "text", text: message.content }] : [] : message.content;
+    return [
+      ...messages.slice(0, index),
+      { role: "user", content: [...textBlocks, ...blocks] },
+      ...messages.slice(index + 1)
+    ];
+  }
+  return [...messages, { role: "user", content: [...blocks] }];
+}
+async function extractErrorDetail2(response) {
+  try {
+    const body = await response.json();
+    return body.error?.message;
+  } catch {
+    return void 0;
+  }
+}
+function wireError(error) {
+  const code = error.type && ERROR_TYPE_TO_CODE[error.type] || "upstream_error";
+  return new AiError(code, error.message);
+}
+function* parseAnthropicEvent(rawEvent) {
+  for (const line of rawEvent.split("\n")) {
+    if (!line.startsWith("data:")) continue;
+    const payload = line.slice(5).trim();
+    if (payload.length === 0) continue;
+    try {
+      yield JSON.parse(payload);
+    } catch {
+      continue;
+    }
+  }
+}
+function mergeOutputTokens(previous, outputTokens) {
+  return {
+    inputTokens: previous?.inputTokens ?? 0,
+    outputTokens,
+    reasoningTokens: previous?.reasoningTokens
+  };
+}
+async function* parseAnthropicStream(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let usage = null;
+  let usageEmitted = false;
+  const flushUsage = function* () {
+    if (usage && !usageEmitted && (usage.inputTokens > 0 || usage.outputTokens > 0)) {
+      usageEmitted = true;
+      yield { type: "usage", usage };
+    }
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let separator = buffer.indexOf("\n\n");
+      while (separator !== -1) {
+        const rawEvent = buffer.slice(0, separator);
+        buffer = buffer.slice(separator + 2);
+        separator = buffer.indexOf("\n\n");
+        for (const event of parseAnthropicEvent(rawEvent)) {
+          if (event.error) throw wireError(event.error);
+          if (event.type === "message_start" && event.message?.usage) {
+            usage = {
+              inputTokens: event.message.usage.input_tokens ?? 0,
+              outputTokens: 0,
+              reasoningTokens: void 0
+            };
+          } else if (event.type === "message_delta" && event.usage) {
+            usage = mergeOutputTokens(usage, event.usage.output_tokens ?? 0);
+          } else if (event.type === "message_stop") {
+            yield* flushUsage();
+          } else if (event.delta?.type === "text_delta" && event.delta.text) {
+            yield { type: "delta", channel: "answer", text: event.delta.text };
+          } else if (event.delta?.type === "thinking_delta" && event.delta.thinking) {
+            yield { type: "delta", channel: "reasoning", text: event.delta.thinking };
+          }
+        }
+      }
+    }
+    yield* flushUsage();
+  } catch (err) {
+    throw err instanceof AiError ? err : errorFromUnknown(err);
+  } finally {
+    reader.releaseLock();
+  }
+}
+function createAnthropicAdapter(config) {
+  return {
+    async *stream(req) {
+      const timeout = AbortSignal.timeout(config.timeoutMs);
+      const signal = req.signal ? AbortSignal.any([req.signal, timeout]) : timeout;
+      const system = req.messages.filter((message) => message.role === "system").map((message) => message.content).join("\n\n");
+      const messages = mergeImages2(
+        req.messages.filter((message) => message.role !== "system").map((message) => {
+          if (message.role === "user") return { role: "user", content: message.content };
+          return { role: "assistant", content: message.content };
+        }),
+        req.images ?? []
+      );
+      let response;
+      try {
+        response = await fetch(`${config.baseUrl}/v1/messages`, {
+          method: "POST",
+          headers: {
+            "x-api-key": config.apiKey,
+            "anthropic-version": ANTHROPIC_VERSION,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            model: req.externalModelId,
+            messages,
+            ...system.length > 0 ? { system } : {},
+            max_tokens: req.maxOutputTokens,
+            stream: true
+          }),
+          signal
+        });
+      } catch (err) {
+        throw errorFromUnknown(err);
+      }
+      if (!response.ok || !response.body) {
+        const detail = await extractErrorDetail2(response);
+        throw errorFromStatus(response.status, detail);
+      }
+      yield* parseAnthropicStream(response.body);
+    }
+  };
+}
+
 exports.ANTHROPIC_API_VERSION = ANTHROPIC_API_VERSION;
 exports.ANTHROPIC_DEFAULT_MAX_TOKENS = ANTHROPIC_DEFAULT_MAX_TOKENS;
 exports.ANTHROPIC_MODELS = ANTHROPIC_MODELS;
@@ -4205,12 +4584,14 @@ exports.configureProvider = configureProvider;
 exports.consumeAnthropicStream = consumeAnthropicStream;
 exports.consumeGroqStream = consumeGroqStream;
 exports.createAI = createAI;
+exports.createAnthropicAdapter = createAnthropicAdapter;
 exports.createAssistantMessage = createAssistantMessage;
 exports.createFalProvider = createFalProvider;
 exports.createGeminiProvider = createGeminiProvider;
 exports.createGroqProvider = createGroqProvider;
 exports.createMessage = createMessage;
 exports.createOpenAiAudioTranscriptionAdapter = createOpenAiAudioTranscriptionAdapter;
+exports.createOpenAiCompatibleAdapter = createOpenAiCompatibleAdapter;
 exports.createOpenAiEmbeddingsAdapter = createOpenAiEmbeddingsAdapter;
 exports.createOpenAiImageAdapter = createOpenAiImageAdapter;
 exports.createOpenAiSpeechAdapter = createOpenAiSpeechAdapter;