@absolutejs/ai 0.0.41 → 0.0.42

package/README.md

@@ -4,3 +4,11 @@ Standalone AI runtime and provider package extracted from AbsoluteJS.
 
 This package currently focuses on generic AI/chat/provider functionality.
 RAG remains a separate package.
+
+Provider traffic can cross a trusted control plane without reimplementing a
+vendor protocol. `remoteProvider()` carries normalized provider parameters and
+chunks over SSE, while `createProviderProxyResponse()` hosts any
+`AIProviderConfig` with pre-first-token and inter-token heartbeats. Provider
+callbacks and abort objects never cross the wire. The Anthropic provider also
+accepts an injectable `fetch`, allowing hosts to retain egress policy, tracing,
+and test transports.

package/dist/ai/index.js

@@ -1956,7 +1956,8 @@ async function* parseSSEStream4(body, signal) {
 var fetchAndStream = async function* (baseUrl, config2, params, configuredMax, promptCaching) {
   const body = buildRequestBody4(params, configuredMax, promptCaching);
   const target = `${baseUrl}/v1/messages`;
-  const response = await fetch(target, {
+  const fetchImpl = config2.fetch ?? fetch;
+  const response = await fetchImpl(target, {
     ...h2IfHttps4(target),
     body: JSON.stringify(body),
     headers: {
@@ -3654,6 +3655,165 @@ var streamAIWithTools = async function* (options) {
   yield { ...summary, type: "done" };
   return summary;
 };
+// src/ai/providerProxy.ts
+var DEFAULT_HEARTBEAT_MS2 = 5000;
+var encoder = new TextEncoder;
+var wireParams = (params) => ({
+  ...params.cacheSystemPrompt === undefined ? {} : { cacheSystemPrompt: params.cacheSystemPrompt },
+  ...params.frequencyPenalty === undefined ? {} : { frequencyPenalty: params.frequencyPenalty },
+  ...params.maxTokens === undefined ? {} : { maxTokens: params.maxTokens },
+  messages: params.messages,
+  model: params.model,
+  ...params.parallelToolCalls === undefined ? {} : { parallelToolCalls: params.parallelToolCalls },
+  ...params.presencePenalty === undefined ? {} : { presencePenalty: params.presencePenalty },
+  ...params.promptCaching === undefined ? {} : { promptCaching: params.promptCaching },
+  ...params.reasoning === undefined ? {} : { reasoning: params.reasoning },
+  ...params.responseFormat === undefined ? {} : { responseFormat: params.responseFormat },
+  ...params.seed === undefined ? {} : { seed: params.seed },
+  ...params.stopSequences === undefined ? {} : { stopSequences: params.stopSequences },
+  ...params.systemPrompt === undefined ? {} : { systemPrompt: params.systemPrompt },
+  ...params.temperature === undefined ? {} : { temperature: params.temperature },
+  ...params.toolChoice === undefined ? {} : { toolChoice: params.toolChoice },
+  ...params.tools === undefined ? {} : { tools: params.tools },
+  ...params.topP === undefined ? {} : { topP: params.topP }
+});
+var parseProviderProxyParams = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const input = value;
+  if (typeof input.model !== "string" || input.model.trim() === "")
+    return null;
+  if (!Array.isArray(input.messages))
+    return null;
+  return wireParams(input);
+};
+var encodeEvent = (event, data) => encoder.encode(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+var errorPayload = (error) => {
+  const providerError = error instanceof ProviderError ? error : ProviderError.from(error, "remote");
+  return {
+    message: providerError.message,
+    provider: providerError.provider,
+    retryable: providerError.retryable,
+    status: providerError.status,
+    type: providerError.type
+  };
+};
+var streamResponseBody = (iterator, heartbeatMs, onError) => new ReadableStream({
+  async start(controller) {
+    try {
+      for (;; ) {
+        const pending = iterator.next();
+        let next;
+        for (;; ) {
+          let timer;
+          const heartbeat = new Promise((resolve) => {
+            timer = setTimeout(() => resolve("heartbeat"), heartbeatMs);
+          });
+          const winner = heartbeatMs > 0 ? await Promise.race([pending, heartbeat]) : await pending;
+          if (timer)
+            clearTimeout(timer);
+          if (winner === "heartbeat") {
+            controller.enqueue(encoder.encode(`: ping
+
+`));
+            continue;
+          }
+          next = winner;
+          break;
+        }
+        if (next.done)
+          break;
+        controller.enqueue(encodeEvent("chunk", next.value));
+      }
+    } catch (error) {
+      await onError?.(error);
+      controller.enqueue(encodeEvent("error", errorPayload(error)));
+    } finally {
+      await iterator.return?.();
+      controller.close();
+    }
+  }
+});
+var createProviderProxyResponse = async (provider, value, options = {}) => {
+  const params = parseProviderProxyParams(value);
+  if (!params) {
+    return Response.json({ error: "invalid provider stream request" }, { status: 400 });
+  }
+  const iterator = provider.stream({ ...params, signal: options.signal })[Symbol.asyncIterator]();
+  return new Response(streamResponseBody(iterator, options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS2, options.onError), {
+    headers: {
+      "cache-control": "no-cache",
+      "content-type": "text/event-stream; charset=utf-8",
+      "x-accel-buffering": "no",
+      ...Object.fromEntries(new Headers(options.headers))
+    }
+  });
+};
+var parseRemoteStream = async function* (response) {
+  if (!response.ok) {
+    throw ProviderError.fromResponse("remote", response.status, await response.text());
+  }
+  if (!response.body)
+    throw new ProviderError({
+      message: "Remote provider returned no response body",
+      provider: "remote",
+      retryable: true
+    });
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    for (;; ) {
+      const { done, value } = await reader.read();
+      buffer += decoder.decode(value, { stream: !done });
+      const frames = buffer.split(/\r?\n\r?\n/);
+      buffer = frames.pop() ?? "";
+      for (const frame of frames) {
+        if (frame.startsWith(":"))
+          continue;
+        const event = /^event:\s*(.+)$/m.exec(frame)?.[1];
+        const data = frame.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join(`
+`);
+        if (!data)
+          continue;
+        const parsed = JSON.parse(data);
+        if (event === "error") {
+          throw new ProviderError({
+            message: "message" in parsed && typeof parsed.message === "string" ? parsed.message : "Remote provider stream failed",
+            provider: "provider" in parsed && typeof parsed.provider === "string" ? parsed.provider : "remote",
+            retryable: "retryable" in parsed && typeof parsed.retryable === "boolean" ? parsed.retryable : true,
+            status: "status" in parsed && (typeof parsed.status === "number" || parsed.status === null) ? parsed.status : null,
+            type: "type" in parsed && (typeof parsed.type === "string" || parsed.type === null) ? parsed.type : null
+          });
+        }
+        if (event === "chunk")
+          yield parsed;
+      }
+      if (done)
+        break;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+};
+var remoteProvider = (config2) => ({
+  stream: async function* (params) {
+    const headers = typeof config2.headers === "function" ? await config2.headers() : config2.headers;
+    const response = await (config2.fetch ?? fetch)(config2.url, {
+      body: JSON.stringify(wireParams(params)),
+      headers: {
+        "content-type": "application/json",
+        ...Object.fromEntries(new Headers(headers))
+      },
+      method: "POST",
+      signal: params.signal
+    });
+    yield* parseRemoteStream(response);
+  }
+});
 // src/ai/ui/uiCards.ts
 var createUiCards = (definitions) => {
   const byName = new Map(definitions.map((definition) => [definition.name, definition]));
@@ -5680,11 +5840,13 @@ export {
   serializeAIMessage,
   resolveRenderers,
   renderChartSvg,
+  remoteProvider,
   providerStatusPage,
   planCard,
   parseUiActions,
   parseTableSpec,
   parseStatTilesSpec,
+  parseProviderProxyParams,
   parsePlanSpec,
   parseFormSpec,
   parseDiffSpec,
@@ -5714,6 +5876,7 @@ export {
   credentialCard,
   createUiCards,
   createSyncConversationStore,
+  createProviderProxyResponse,
   createOAuth2ClientCredentialsTokenSource,
   createMemoryStore,
   createConversationManager,
@@ -5751,5 +5914,5 @@ export {
   BUILTIN_UI_CARDS
 };
 
-//# debugId=75AACEF004EE3AAE64756E2164756E21
+//# debugId=31B8793E47976E7B64756E2164756E21
 //# sourceMappingURL=index.js.map