@absolutejs/ai 0.0.41 → 0.0.43

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: {
@@ -2950,57 +2951,86 @@ var streamTurns = async function* (options, renderers, messages, signal, startTi
     turn: 0
   };
   const toolDefs = options.tools ? buildToolDefinitions2(options.tools) : undefined;
-  let runningTotalTokens = 0;
-  for (;turnState.turn <= maxTurns && !signal.aborted; turnState.turn++) {
-    const chunkState = {
-      contentBlocks: [],
-      currentThinking: null,
-      pendingToolCalls: [],
-      stopReason: undefined,
-      usage: undefined
-    };
-    const responseBeforeTurn = turnState.fullResponse;
-    const stream = options.provider.stream({
-      cacheSystemPrompt: options.cacheSystemPrompt,
-      maxTokens: options.maxTokens,
-      messages: turnState.currentMessages,
-      model: options.model,
-      promptCaching: options.promptCaching,
-      reasoning: options.reasoning,
-      signal,
-      systemPrompt: options.systemPrompt,
-      tools: toolDefs
-    });
-    yield* consumeStream2(stream, chunkState, renderers, options, turnState, signal);
-    options.onTurn?.(turnState.turn, chunkState.usage, turnState.fullResponse.slice(responseBeforeTurn.length));
-    runningTotalTokens += (chunkState.usage?.inputTokens ?? 0) + (chunkState.usage?.outputTokens ?? 0);
-    if (chunkState.stopReason === "max_tokens") {
-      yield {
-        data: renderers.error(`Response truncated at max_tokens (output=${chunkState.usage?.outputTokens ?? "?"}). ` + `Raise maxTokens on the provider/options, split the request, or reduce upstream context.`),
-        event: "status"
-      };
-      return;
-    }
-    if (options.maxTotalTokens && runningTotalTokens >= options.maxTotalTokens) {
-      yield {
-        data: renderers.error(`Stopped: token budget reached (${runningTotalTokens}/${options.maxTotalTokens} tokens over ` + `${turnState.turn} turns). Narrow the request or raise maxTotalTokens.`),
-        event: "status"
-      };
-      return;
-    }
-    if (options.maxDurationMs && Date.now() - startTime >= options.maxDurationMs) {
-      yield {
-        data: renderers.error(`Stopped: time budget reached (${Math.round((Date.now() - startTime) / 1000)}s over ` + `${turnState.turn} turns). Narrow the request or raise maxDurationMs.`),
-        event: "status"
+  const aggregateUsage = { inputTokens: 0, outputTokens: 0 };
+  let finishReason = "max_turns";
+  let completedTurns = 0;
+  try {
+    for (;turnState.turn < maxTurns && !signal.aborted; turnState.turn++) {
+      const chunkState = {
+        contentBlocks: [],
+        currentThinking: null,
+        pendingToolCalls: [],
+        stopReason: undefined,
+        usage: undefined
       };
-      return;
+      const responseBeforeTurn = turnState.fullResponse;
+      const stream = options.provider.stream({
+        cacheSystemPrompt: options.cacheSystemPrompt,
+        maxTokens: options.maxTokens,
+        messages: turnState.currentMessages,
+        model: options.model,
+        promptCaching: options.promptCaching,
+        reasoning: options.reasoning,
+        signal,
+        systemPrompt: options.systemPrompt,
+        tools: toolDefs
+      });
+      yield* consumeStream2(stream, chunkState, renderers, options, turnState, signal);
+      options.onTurn?.(turnState.turn, chunkState.usage, turnState.fullResponse.slice(responseBeforeTurn.length));
+      completedTurns += 1;
+      aggregateUsage.inputTokens += chunkState.usage?.inputTokens ?? 0;
+      aggregateUsage.outputTokens += chunkState.usage?.outputTokens ?? 0;
+      aggregateUsage.cacheReadInputTokens = (aggregateUsage.cacheReadInputTokens ?? 0) + (chunkState.usage?.cacheReadInputTokens ?? 0);
+      aggregateUsage.cacheWriteInputTokens = (aggregateUsage.cacheWriteInputTokens ?? 0) + (chunkState.usage?.cacheWriteInputTokens ?? 0);
+      const runningTotalTokens = aggregateUsage.inputTokens + aggregateUsage.outputTokens;
+      if (chunkState.stopReason === "max_tokens") {
+        finishReason = "max_tokens";
+        yield {
+          data: renderers.error(`Response truncated at max_tokens (output=${chunkState.usage?.outputTokens ?? "?"}). ` + `Raise maxTokens on the provider/options, split the request, or reduce upstream context.`),
+          event: "status"
+        };
+        return;
+      }
+      if (options.maxTotalTokens && runningTotalTokens >= options.maxTotalTokens) {
+        finishReason = "max_total_tokens";
+        yield {
+          data: renderers.error(`Stopped: token budget reached (${runningTotalTokens}/${options.maxTotalTokens} tokens over ` + `${turnState.turn} turns). Narrow the request or raise maxTotalTokens.`),
+          event: "status"
+        };
+        return;
+      }
+      if (options.maxDurationMs && Date.now() - startTime >= options.maxDurationMs) {
+        finishReason = "max_duration";
+        yield {
+          data: renderers.error(`Stopped: time budget reached (${Math.round((Date.now() - startTime) / 1000)}s over ` + `${turnState.turn} turns). Narrow the request or raise maxDurationMs.`),
+          event: "status"
+        };
+        return;
+      }
+      if (shouldStopToolLoop(chunkState, turnState, signal)) {
+        finishReason = signal.aborted ? "aborted" : "complete";
+        return void (yield yieldCompletion(renderers, options, turnState.fullResponse, chunkState.usage, startTime));
+      }
+      yield* processTurn(chunkState, options, renderers, turnState);
     }
-    if (shouldStopToolLoop(chunkState, turnState, signal)) {
-      return void (yield yieldCompletion(renderers, options, turnState.fullResponse, chunkState.usage, startTime));
+    if (signal.aborted)
+      finishReason = "aborted";
+  } catch (error) {
+    finishReason = signal.aborted ? "aborted" : "error";
+    throw error;
+  } finally {
+    try {
+      await options.onFinish?.({
+        durationMs: Date.now() - startTime,
+        fullResponse: turnState.fullResponse,
+        reason: finishReason,
+        turns: completedTurns,
+        usage: aggregateUsage
+      });
+    } catch (error) {
+      console.error("[absolute-ai] onFinish rejected:", error);
     }
-    yield* processTurn(chunkState, options, renderers, turnState);
   }
-  return;
 };
 
 // src/constants.ts
@@ -3654,6 +3684,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 +5869,13 @@ export {
   serializeAIMessage,
   resolveRenderers,
   renderChartSvg,
+  remoteProvider,
   providerStatusPage,
   planCard,
   parseUiActions,
   parseTableSpec,
   parseStatTilesSpec,
+  parseProviderProxyParams,
   parsePlanSpec,
   parseFormSpec,
   parseDiffSpec,
@@ -5714,6 +5905,7 @@ export {
   credentialCard,
   createUiCards,
   createSyncConversationStore,
+  createProviderProxyResponse,
   createOAuth2ClientCredentialsTokenSource,
   createMemoryStore,
   createConversationManager,
@@ -5751,5 +5943,5 @@ export {
   BUILTIN_UI_CARDS
 };
 
-//# debugId=75AACEF004EE3AAE64756E2164756E21
+//# debugId=DACDBFA8148E663564756E2164756E21
 //# sourceMappingURL=index.js.map