@providerprotocol/ai 0.0.16 → 0.0.18

package/dist/index.js

@@ -1,3 +1,8 @@
+import {
+  aggregateUsage,
+  createTurn,
+  emptyUsage
+} from "./chunk-SKY2JLA7.js";
 import {
   createProvider
 } from "./chunk-MSR5P65T.js";
@@ -10,7 +15,7 @@ import {
   isAssistantMessage,
   isToolResultMessage,
   isUserMessage
-} from "./chunk-SVYROCLD.js";
+} from "./chunk-UMKWXGO3.js";
 import {
   ExponentialBackoff,
   LinearBackoff,
@@ -22,62 +27,11 @@ import "./chunk-Z7RBRCRN.js";
 import {
   DynamicKey,
   RoundRobinKeys,
-  UPPError,
   WeightedKeys
-} from "./chunk-MOU4U3PO.js";
-
-// src/types/turn.ts
-function createTurn(messages, toolExecutions, usage, cycles, data) {
-  const response = messages.filter((m) => m.type === "assistant").pop();
-  if (!response) {
-    throw new Error("Turn must contain at least one assistant message");
-  }
-  return {
-    messages,
-    response,
-    toolExecutions,
-    usage,
-    cycles,
-    data
-  };
-}
-function emptyUsage() {
-  return {
-    inputTokens: 0,
-    outputTokens: 0,
-    totalTokens: 0,
-    cacheReadTokens: 0,
-    cacheWriteTokens: 0,
-    cycles: []
-  };
-}
-function aggregateUsage(usages) {
-  const cycles = [];
-  let inputTokens = 0;
-  let outputTokens = 0;
-  let cacheReadTokens = 0;
-  let cacheWriteTokens = 0;
-  for (const usage of usages) {
-    inputTokens += usage.inputTokens;
-    outputTokens += usage.outputTokens;
-    cacheReadTokens += usage.cacheReadTokens;
-    cacheWriteTokens += usage.cacheWriteTokens;
-    cycles.push({
-      inputTokens: usage.inputTokens,
-      outputTokens: usage.outputTokens,
-      cacheReadTokens: usage.cacheReadTokens,
-      cacheWriteTokens: usage.cacheWriteTokens
-    });
-  }
-  return {
-    inputTokens,
-    outputTokens,
-    totalTokens: inputTokens + outputTokens,
-    cacheReadTokens,
-    cacheWriteTokens,
-    cycles
-  };
-}
+} from "./chunk-5FEAOEXV.js";
+import {
+  UPPError
+} from "./chunk-DZQHVGNV.js";
 
 // src/types/stream.ts
 function createStreamResult(generator, turnPromise, abortController) {
@@ -578,8 +532,153 @@ function validateMediaCapabilities(messages, capabilities, providerName) {
   }
 }
 
+// src/core/embedding.ts
+function embedding(options) {
+  const { model: modelRef, config = {}, params } = options;
+  const provider = modelRef.provider;
+  if (!provider.modalities.embedding) {
+    throw new UPPError(
+      `Provider '${provider.name}' does not support embedding modality`,
+      "INVALID_REQUEST",
+      provider.name,
+      "embedding"
+    );
+  }
+  const handler = provider.modalities.embedding;
+  const boundModel = handler.bind(modelRef.modelId);
+  const instance = {
+    model: boundModel,
+    params,
+    embed(input, embedOptions) {
+      const inputs = Array.isArray(input) ? input : [input];
+      if (embedOptions?.chunked) {
+        return createChunkedStream(boundModel, inputs, params, config, embedOptions);
+      }
+      return executeEmbed(boundModel, inputs, params, config, embedOptions?.signal);
+    }
+  };
+  return instance;
+}
+async function executeEmbed(model, inputs, params, config, signal) {
+  const response = await model.embed({
+    inputs,
+    params,
+    config: config ?? {},
+    signal
+  });
+  return normalizeResponse(response);
+}
+function normalizeResponse(response) {
+  return {
+    embeddings: response.embeddings.map((vec, i) => {
+      const vector = normalizeVector(vec.vector);
+      return {
+        vector,
+        dimensions: vector.length,
+        index: vec.index ?? i,
+        tokens: vec.tokens,
+        metadata: vec.metadata
+      };
+    }),
+    usage: response.usage,
+    metadata: response.metadata
+  };
+}
+function normalizeVector(vector) {
+  if (Array.isArray(vector)) {
+    return vector;
+  }
+  return decodeBase64(vector);
+}
+function decodeBase64(b64) {
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  const floats = new Float32Array(bytes.buffer);
+  return Array.from(floats);
+}
+function createChunkedStream(model, inputs, params, config, options) {
+  const abortController = new AbortController();
+  const batchSize = options.batchSize ?? model.maxBatchSize;
+  const concurrency = options.concurrency ?? 1;
+  let resolveResult;
+  let rejectResult;
+  const resultPromise = new Promise((resolve, reject) => {
+    resolveResult = resolve;
+    rejectResult = reject;
+  });
+  async function* generate() {
+    const total = inputs.length;
+    const allEmbeddings = [];
+    let totalTokens = 0;
+    const batches = [];
+    for (let i = 0; i < inputs.length; i += batchSize) {
+      batches.push(inputs.slice(i, i + batchSize));
+    }
+    try {
+      for (let i = 0; i < batches.length; i += concurrency) {
+        if (abortController.signal.aborted || options.signal?.aborted) {
+          throw new UPPError(
+            "Embedding cancelled",
+            "CANCELLED",
+            model.provider.name,
+            "embedding"
+          );
+        }
+        const chunk = batches.slice(i, i + concurrency);
+        const responses = await Promise.all(
+          chunk.map(
+            (batch) => model.embed({
+              inputs: batch,
+              params,
+              config: config ?? {},
+              signal: abortController.signal
+            })
+          )
+        );
+        const batchEmbeddings = [];
+        for (const response of responses) {
+          for (const vec of response.embeddings) {
+            const vector = normalizeVector(vec.vector);
+            const emb = {
+              vector,
+              dimensions: vector.length,
+              index: allEmbeddings.length + batchEmbeddings.length,
+              tokens: vec.tokens,
+              metadata: vec.metadata
+            };
+            batchEmbeddings.push(emb);
+          }
+          totalTokens += response.usage.totalTokens;
+        }
+        allEmbeddings.push(...batchEmbeddings);
+        yield {
+          embeddings: batchEmbeddings,
+          completed: allEmbeddings.length,
+          total,
+          percent: allEmbeddings.length / total * 100
+        };
+      }
+      resolveResult({
+        embeddings: allEmbeddings,
+        usage: { totalTokens }
+      });
+    } catch (error) {
+      rejectResult(error);
+      throw error;
+    }
+  }
+  const generator = generate();
+  return {
+    [Symbol.asyncIterator]: () => generator,
+    result: resultPromise,
+    abort: () => abortController.abort()
+  };
+}
+
 // src/core/image.ts
-import { readFile } from "fs/promises";
 var Image = class _Image {
   /** The underlying image source (bytes, base64, or URL) */
   source;
@@ -692,6 +791,7 @@ var Image = class _Image {
    * ```
    */
   static async fromPath(path) {
+    const { readFile } = await import("fs/promises");
     const data = await readFile(path);
     const mimeType = detectMimeType(path);
     return new _Image(
@@ -1074,7 +1174,9 @@ var Thread = class _Thread {
 // src/index.ts
 var ai = {
   /** LLM instance factory */
-  llm
+  llm,
+  /** Embedding instance factory */
+  embedding
 };
 export {
   AssistantMessage,
@@ -1099,6 +1201,7 @@ export {
   createProvider,
   createStreamResult,
   createTurn,
+  embedding,
   emptyUsage,
   isAssistantMessage,
   isAudioBlock,