@anvia/core 0.26.0 → 1.0.0-rc.10

package/dist/chunk-X4LK4ODN.js

@@ -0,0 +1,86 @@
+// src/agent/errors.ts
+var AgentStructuredOutputError = class extends Error {
+  phase;
+  attempt;
+  maxAttempts;
+  outputLength;
+  normalizedLength;
+  outputFormat;
+  attemptUsage;
+  usage;
+  finishReason;
+  providerFinishReason;
+  constructor(options) {
+    const failure = options.phase === "truncated" ? "because the provider reached its output limit" : options.phase === "content-filter" ? "because the provider filtered the response" : options.phase === "parse" ? "during JSON parsing" : "during schema validation";
+    const errorOptions = options.cause === void 0 ? void 0 : { cause: options.cause };
+    super(
+      `Agent structured output failed ${failure} on attempt ${options.attempt} of ${options.maxAttempts}.`,
+      errorOptions
+    );
+    this.name = "AgentStructuredOutputError";
+    this.phase = options.phase;
+    this.attempt = options.attempt;
+    this.maxAttempts = options.maxAttempts;
+    this.outputLength = options.outputLength;
+    this.normalizedLength = options.normalizedLength;
+    this.outputFormat = options.outputFormat;
+    this.attemptUsage = options.attemptUsage;
+    this.usage = options.usage;
+    this.finishReason = options.finishReason;
+    this.providerFinishReason = options.providerFinishReason;
+  }
+};
+var MaxTurnsError = class extends Error {
+  constructor(maxTurns, chatHistory, prompt) {
+    super(`Reached max turn limit: ${maxTurns}`);
+    this.maxTurns = maxTurns;
+    this.chatHistory = chatHistory;
+    this.prompt = prompt;
+    this.name = "MaxTurnsError";
+  }
+  maxTurns;
+  chatHistory;
+  prompt;
+};
+var AgentRunCancelledError = class extends Error {
+  constructor(chatHistory, reason, options) {
+    super(`Agent run cancelled: ${reason}`, options);
+    this.chatHistory = chatHistory;
+    this.reason = reason;
+    this.name = "AgentRunCancelledError";
+  }
+  chatHistory;
+  reason;
+};
+var AgentRunBlockedError = class extends Error {
+  constructor(result) {
+    super(`Agent run was blocked by an ${result.stage} guardrail.`);
+    this.result = result;
+    this.name = "AgentRunBlockedError";
+  }
+  result;
+};
+var AgentStreamClosedError = class extends Error {
+  constructor() {
+    super("Agent stream is no longer accepting steering input.");
+    this.name = "AgentStreamClosedError";
+  }
+};
+var AgentToolSuspensionError = class extends Error {
+  constructor(result) {
+    super("Agent tool execution suspended for human interaction.");
+    this.result = result;
+    this.name = "AgentToolSuspensionError";
+  }
+  result;
+};
+
+export {
+  AgentStructuredOutputError,
+  MaxTurnsError,
+  AgentRunCancelledError,
+  AgentRunBlockedError,
+  AgentStreamClosedError,
+  AgentToolSuspensionError
+};
+//# sourceMappingURL=chunk-X4LK4ODN.js.map

package/dist/chunk-X4LK4ODN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/agent/errors.ts"],"sourcesContent":["import type { CompletionFinishReason, Message, Usage } from \"../completion/index\";\nimport type { AgentBlockedResult, AgentSuspendedResult } from \"./run-types\";\n\nexport type AgentStructuredOutputPhase = \"truncated\" | \"content-filter\" | \"parse\" | \"schema\";\n\nexport type AgentStructuredOutputFormat = \"raw\" | \"json-fence\" | \"unlabeled-fence\";\n\nexport class AgentStructuredOutputError extends Error {\n  readonly phase: AgentStructuredOutputPhase;\n  readonly attempt: number;\n  readonly maxAttempts: number;\n  readonly outputLength: number;\n  readonly normalizedLength: number;\n  readonly outputFormat: AgentStructuredOutputFormat;\n  readonly attemptUsage: Usage;\n  readonly usage: Usage;\n  readonly finishReason: CompletionFinishReason | undefined;\n  readonly providerFinishReason: string | undefined;\n\n  constructor(options: {\n    phase: AgentStructuredOutputPhase;\n    attempt: number;\n    maxAttempts: number;\n    outputLength: number;\n    normalizedLength: number;\n    outputFormat: AgentStructuredOutputFormat;\n    attemptUsage: Usage;\n    usage: Usage;\n    finishReason?: CompletionFinishReason | undefined;\n    providerFinishReason?: string | undefined;\n    cause?: unknown;\n  }) {\n    const failure =\n      options.phase === \"truncated\"\n        ? \"because the provider reached its output limit\"\n        : options.phase === \"content-filter\"\n          ? \"because the provider filtered the response\"\n          : options.phase === \"parse\"\n            ? \"during JSON parsing\"\n            : \"during schema validation\";\n    const errorOptions = options.cause === undefined ? undefined : { cause: options.cause };\n    super(\n      `Agent structured output failed ${failure} on attempt ${options.attempt} of ${options.maxAttempts}.`,\n      errorOptions,\n    );\n    this.name = \"AgentStructuredOutputError\";\n    this.phase = options.phase;\n    this.attempt = options.attempt;\n    this.maxAttempts = options.maxAttempts;\n    this.outputLength = options.outputLength;\n    this.normalizedLength = options.normalizedLength;\n    this.outputFormat = options.outputFormat;\n    this.attemptUsage = options.attemptUsage;\n    this.usage = options.usage;\n    this.finishReason = options.finishReason;\n    this.providerFinishReason = options.providerFinishReason;\n  }\n}\n\nexport class MaxTurnsError extends Error {\n  constructor(\n    readonly maxTurns: number,\n    readonly chatHistory: Message[],\n    readonly prompt: Message,\n  ) {\n    super(`Reached max turn limit: ${maxTurns}`);\n    this.name = \"MaxTurnsError\";\n  }\n}\n\nexport class AgentRunCancelledError extends Error {\n  constructor(\n    readonly chatHistory: Message[],\n    readonly reason: string,\n    options?: ErrorOptions,\n  ) {\n    super(`Agent run cancelled: ${reason}`, options);\n    this.name = \"AgentRunCancelledError\";\n  }\n}\n\nexport class AgentRunBlockedError extends Error {\n  constructor(readonly result: AgentBlockedResult) {\n    super(`Agent run was blocked by an ${result.stage} guardrail.`);\n    this.name = \"AgentRunBlockedError\";\n  }\n}\n\nexport class AgentStreamClosedError extends Error {\n  constructor() {\n    super(\"Agent stream is no longer accepting steering input.\");\n    this.name = \"AgentStreamClosedError\";\n  }\n}\n\nexport class AgentToolSuspensionError extends Error {\n  constructor(readonly result: AgentSuspendedResult) {\n    super(\"Agent tool execution suspended for human interaction.\");\n    this.name = \"AgentToolSuspensionError\";\n  }\n}\n"],"mappings":";AAOO,IAAM,6BAAN,cAAyC,MAAM;AAAA,EAC3C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,SAYT;AACD,UAAM,UACJ,QAAQ,UAAU,cACd,kDACA,QAAQ,UAAU,mBAChB,+CACA,QAAQ,UAAU,UAChB,wBACA;AACV,UAAM,eAAe,QAAQ,UAAU,SAAY,SAAY,EAAE,OAAO,QAAQ,MAAM;AACtF;AAAA,MACE,kCAAkC,OAAO,eAAe,QAAQ,OAAO,OAAO,QAAQ,WAAW;AAAA,MACjG;AAAA,IACF;AACA,SAAK,OAAO;AACZ,SAAK,QAAQ,QAAQ;AACrB,SAAK,UAAU,QAAQ;AACvB,SAAK,cAAc,QAAQ;AAC3B,SAAK,eAAe,QAAQ;AAC5B,SAAK,mBAAmB,QAAQ;AAChC,SAAK,eAAe,QAAQ;AAC5B,SAAK,eAAe,QAAQ;AAC5B,SAAK,QAAQ,QAAQ;AACrB,SAAK,eAAe,QAAQ;AAC5B,SAAK,uBAAuB,QAAQ;AAAA,EACtC;AACF;AAEO,IAAM,gBAAN,cAA4B,MAAM;AAAA,EACvC,YACW,UACA,aACA,QACT;AACA,UAAM,2BAA2B,QAAQ,EAAE;AAJlC;AACA;AACA;AAGT,SAAK,OAAO;AAAA,EACd;AAAA,EANW;AAAA,EACA;AAAA,EACA;AAKb;AAEO,IAAM,yBAAN,cAAqC,MAAM;AAAA,EAChD,YACW,aACA,QACT,SACA;AACA,UAAM,wBAAwB,MAAM,IAAI,OAAO;AAJtC;AACA;AAIT,SAAK,OAAO;AAAA,EACd;AAAA,EANW;AAAA,EACA;AAMb;AAEO,IAAM,uBAAN,cAAmC,MAAM;AAAA,EAC9C,YAAqB,QAA4B;AAC/C,UAAM,+BAA+B,OAAO,KAAK,aAAa;AAD3C;AAEnB,SAAK,OAAO;AAAA,EACd;AAAA,EAHqB;AAIvB;AAEO,IAAM,yBAAN,cAAqC,MAAM;AAAA,EAChD,cAAc;AACZ,UAAM,qDAAqD;AAC3D,SAAK,OAAO;AAAA,EACd;AACF;AAEO,IAAM,2BAAN,cAAuC,MAAM;AAAA,EAClD,YAAqB,QAA8B;AACjD,UAAM,uDAAuD;AAD1C;AAEnB,SAAK,OAAO;AAAA,EACd;AAAA,EAHqB;AAIvB;","names":[]}

package/dist/chunk-ZA564323.js

@@ -0,0 +1,331 @@
+import {
+  mapWithConcurrency
+} from "./chunk-3RM57ZT2.js";
+import {
+  resolveRetryOptions,
+  runWithRetries,
+  throwIfAborted
+} from "./chunk-3RWESPUG.js";
+
+// src/embeddings/distance.ts
+function dotProduct(left, right) {
+  assertSameDimensions(left, right);
+  return left.reduce((sum, value, index) => sum + value * right[index], 0);
+}
+function cosineSimilarity(left, right) {
+  assertSameDimensions(left, right);
+  const leftMagnitude = magnitude(left);
+  const rightMagnitude = magnitude(right);
+  if (leftMagnitude === 0 || rightMagnitude === 0) {
+    return 0;
+  }
+  return dotProduct(left, right) / (leftMagnitude * rightMagnitude);
+}
+function angularDistance(left, right) {
+  const similarity = Math.max(-1, Math.min(1, cosineSimilarity(left, right)));
+  return Math.acos(similarity) / Math.PI;
+}
+function euclideanDistance(left, right) {
+  assertSameDimensions(left, right);
+  return Math.sqrt(
+    left.reduce((sum, value, index) => sum + (value - right[index]) ** 2, 0)
+  );
+}
+function manhattanDistance(left, right) {
+  assertSameDimensions(left, right);
+  return left.reduce((sum, value, index) => sum + Math.abs(value - right[index]), 0);
+}
+function chebyshevDistance(left, right) {
+  assertSameDimensions(left, right);
+  return left.reduce(
+    (max, value, index) => Math.max(max, Math.abs(value - right[index])),
+    0
+  );
+}
+function magnitude(vector) {
+  return Math.sqrt(vector.reduce((sum, value) => sum + value ** 2, 0));
+}
+function assertSameDimensions(left, right) {
+  if (left.length !== right.length) {
+    throw new Error(`Vector dimension mismatch: ${left.length} !== ${right.length}`);
+  }
+}
+
+// src/embeddings/embed.ts
+async function embedText(options) {
+  const { embeddings } = await embedTexts({
+    model: options.model,
+    texts: [options.text],
+    retries: options.retries,
+    abortSignal: options.abortSignal
+  });
+  const embedding = embeddings[0];
+  if (embedding === void 0) throw new Error("Embedding model returned no embeddings");
+  return { embedding };
+}
+async function embedTexts(options) {
+  throwIfAborted(options.abortSignal);
+  if (options.texts.length === 0) return { embeddings: [] };
+  const batches = chunk(options.texts, batchSize(options.model.maxBatchSize, options.texts.length));
+  const results = await mapWithConcurrency(
+    batches,
+    concurrency(options.concurrency),
+    (batch) => embedDenseBatch(options.model, batch, options)
+  );
+  const embeddings = results.flat();
+  if (embeddings.length !== options.texts.length) {
+    throw new Error(
+      `Embedding model returned ${embeddings.length} embeddings for ${options.texts.length} texts`
+    );
+  }
+  return { embeddings };
+}
+async function embedSparseTexts(options) {
+  throwIfAborted(options.abortSignal);
+  if (options.texts.length === 0) return { embeddings: [] };
+  const batches = chunk(options.texts, batchSize(options.model.maxBatchSize, options.texts.length));
+  const results = await mapWithConcurrency(
+    batches,
+    concurrency(options.concurrency),
+    (batch) => embedSparseBatch(options.model, batch, options)
+  );
+  const embeddings = results.flat();
+  if (embeddings.length !== options.texts.length) {
+    throw new Error(
+      `Sparse embedding model returned ${embeddings.length} embeddings for ${options.texts.length} texts`
+    );
+  }
+  return { embeddings };
+}
+async function embedSparseQuery(options) {
+  throwIfAborted(options.abortSignal);
+  const embedding = await runWithRetries(
+    () => {
+      throwIfAborted(options.abortSignal);
+      return options.model.embedQuery(options.query, modelCallOptions(options.abortSignal));
+    },
+    resolveRetries(options),
+    { streaming: false, abortSignal: options.abortSignal }
+  );
+  throwIfAborted(options.abortSignal);
+  validateSparseEmbedding(embedding, "query");
+  return { embedding };
+}
+async function embedDocuments(options) {
+  throwIfAborted(options.abortSignal);
+  const prepared = prepareDocuments(options.documents, options);
+  const flatTexts = prepared.flatMap(
+    (item, documentIndex) => item.texts.map((text) => ({ documentIndex, text }))
+  );
+  const concurrencyLimit = concurrency(options.concurrency);
+  if ("model" in options && options.model !== void 0) {
+    const batches = chunk(flatTexts, batchSize(options.model.maxBatchSize, flatTexts.length || 1));
+    const results = await mapWithConcurrency(batches, concurrencyLimit, async (batch) => {
+      const embeddings = await embedDenseBatch(
+        options.model,
+        batch.map((item) => item.text),
+        options
+      );
+      assertBatchLength("Embedding", embeddings.length, batch.length);
+      return batch.map((item, index) => ({
+        documentIndex: item.documentIndex,
+        embedding: embeddings[index]
+      }));
+    });
+    const byDocument = groupEmbeddings(results.flat());
+    return {
+      documents: prepared.map((item, index) => embeddedDocument(item, byDocument.get(index) ?? []))
+    };
+  }
+  const { dense, sparse } = options.models;
+  const [denseResults, sparseResults] = await Promise.all([
+    mapWithConcurrency(
+      chunk(flatTexts, batchSize(dense.maxBatchSize, flatTexts.length || 1)),
+      concurrencyLimit,
+      async (batch) => {
+        const embeddings = await embedDenseBatch(
+          dense,
+          batch.map((item) => item.text),
+          options
+        );
+        assertBatchLength("Embedding", embeddings.length, batch.length);
+        return batch.map((item, index) => ({
+          documentIndex: item.documentIndex,
+          embedding: embeddings[index]
+        }));
+      }
+    ),
+    mapWithConcurrency(
+      chunk(flatTexts, batchSize(sparse.maxBatchSize, flatTexts.length || 1)),
+      concurrencyLimit,
+      async (batch) => {
+        const embeddings = await embedSparseBatch(
+          sparse,
+          batch.map((item) => item.text),
+          options
+        );
+        assertBatchLength("Sparse embedding", embeddings.length, batch.length);
+        return batch.map((item, index) => ({
+          documentIndex: item.documentIndex,
+          embedding: embeddings[index]
+        }));
+      }
+    )
+  ]);
+  const denseByDocument = groupEmbeddings(denseResults.flat());
+  const sparseByDocument = groupEmbeddings(sparseResults.flat());
+  return {
+    documents: prepared.map((item, index) => {
+      const embeddings = denseByDocument.get(index) ?? [];
+      const sparseEmbeddings = sparseByDocument.get(index) ?? [];
+      if (embeddings.length !== sparseEmbeddings.length) {
+        throw new Error(
+          `Hybrid embedding produced ${embeddings.length} dense and ${sparseEmbeddings.length} sparse vectors for document ${item.id}`
+        );
+      }
+      return embeddedDocument(item, embeddings, sparseEmbeddings);
+    })
+  };
+}
+async function embedDenseBatch(model, texts, options) {
+  throwIfAborted(options.abortSignal);
+  const embeddings = await runWithRetries(
+    () => model.embedTexts(texts, modelCallOptions(options.abortSignal)),
+    resolveRetries(options),
+    { streaming: false, abortSignal: options.abortSignal }
+  );
+  throwIfAborted(options.abortSignal);
+  for (const [index, embedding] of embeddings.entries()) {
+    validateDenseEmbedding(embedding, model.dimensions, index);
+  }
+  return embeddings;
+}
+async function embedSparseBatch(model, texts, options) {
+  throwIfAborted(options.abortSignal);
+  const embeddings = await runWithRetries(
+    () => model.embedTexts(texts, modelCallOptions(options.abortSignal)),
+    resolveRetries(options),
+    { streaming: false, abortSignal: options.abortSignal }
+  );
+  throwIfAborted(options.abortSignal);
+  for (const [index, embedding] of embeddings.entries()) validateSparseEmbedding(embedding, index);
+  return embeddings;
+}
+function prepareDocuments(documents, options) {
+  const ids = /* @__PURE__ */ new Set();
+  return documents.map((document, index) => {
+    const id = options.id?.(document, index) ?? `doc${index}`;
+    if (id.length === 0) throw new TypeError("Embedded document ids must not be empty");
+    if (ids.has(id)) throw new TypeError(`Duplicate embedded document id: ${id}`);
+    ids.add(id);
+    const content = options.content(document, index);
+    if (Array.isArray(content) && content.length === 0)
+      throw new TypeError(`Embedded document ${id} must contain at least one text chunk`);
+    return {
+      id,
+      document,
+      metadata: options.metadata?.(document, index),
+      texts: Array.isArray(content) ? content : [content]
+    };
+  });
+}
+function embeddedDocument(item, embeddings, sparseEmbeddings) {
+  let result = {
+    id: item.id,
+    document: item.document,
+    embeddings
+  };
+  if (item.metadata !== void 0) {
+    result = { ...result, metadata: item.metadata };
+  }
+  if (sparseEmbeddings !== void 0) {
+    result = { ...result, sparseEmbeddings };
+  }
+  return result;
+}
+function groupEmbeddings(items) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const list = groups.get(item.documentIndex) ?? [];
+    list.push(item.embedding);
+    groups.set(item.documentIndex, list);
+  }
+  return groups;
+}
+function assertBatchLength(name, actual, expected) {
+  if (actual !== expected)
+    throw new Error(`${name} model returned ${actual} embeddings for ${expected} texts`);
+}
+function resolveRetries(options) {
+  return options.retries === void 0 || options.retries === false ? void 0 : resolveRetryOptions(options.retries);
+}
+function modelCallOptions(abortSignal) {
+  return abortSignal === void 0 ? void 0 : { abortSignal };
+}
+function chunk(items, size) {
+  const chunks = [];
+  for (let index = 0; index < items.length; index += size)
+    chunks.push(items.slice(index, index + size));
+  return chunks;
+}
+function batchSize(configured, fallback) {
+  if (configured === void 0) return fallback;
+  if (!Number.isSafeInteger(configured) || configured < 1) {
+    throw new RangeError("Embedding model maxBatchSize must be a positive safe integer");
+  }
+  return configured;
+}
+function concurrency(configured) {
+  if (configured === void 0) return 1;
+  if (!Number.isSafeInteger(configured) || configured < 1) {
+    throw new RangeError("Embedding concurrency must be a positive safe integer");
+  }
+  return configured;
+}
+function validateDenseEmbedding(embedding, dimensions, index) {
+  if (embedding.vector.length === 0) {
+    throw new TypeError(`Embedding model returned an empty vector at index ${index}`);
+  }
+  if (!embedding.vector.every(Number.isFinite)) {
+    throw new TypeError(`Embedding model returned a non-finite vector at index ${index}`);
+  }
+  if (dimensions !== void 0) {
+    if (!Number.isSafeInteger(dimensions) || dimensions < 1)
+      throw new TypeError("Embedding model dimensions must be a positive safe integer");
+    if (embedding.vector.length !== dimensions) {
+      throw new Error(
+        `Embedding model returned ${embedding.vector.length} dimensions at index ${index}; expected ${dimensions}`
+      );
+    }
+  }
+}
+function validateSparseEmbedding(embedding, index) {
+  const { indices, values } = embedding.vector;
+  if (indices.length !== values.length) {
+    throw new Error(`Sparse embedding at ${index} has mismatched indices and values`);
+  }
+  if (!indices.every((value) => Number.isSafeInteger(value) && value >= 0)) {
+    throw new TypeError(`Sparse embedding at ${index} has an invalid index`);
+  }
+  if (new Set(indices).size !== indices.length) {
+    throw new TypeError(`Sparse embedding at ${index} has duplicate indices`);
+  }
+  if (!values.every(Number.isFinite)) {
+    throw new TypeError(`Sparse embedding at ${index} has a non-finite value`);
+  }
+}
+
+export {
+  dotProduct,
+  cosineSimilarity,
+  angularDistance,
+  euclideanDistance,
+  manhattanDistance,
+  chebyshevDistance,
+  embedText,
+  embedTexts,
+  embedSparseTexts,
+  embedSparseQuery,
+  embedDocuments
+};
+//# sourceMappingURL=chunk-ZA564323.js.map

package/dist/chunk-ZA564323.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/embeddings/distance.ts","../src/embeddings/embed.ts"],"sourcesContent":["export function dotProduct(left: number[], right: number[]): number {\n  assertSameDimensions(left, right);\n  return left.reduce((sum, value, index) => sum + value * (right[index] as number), 0);\n}\n\nexport function cosineSimilarity(left: number[], right: number[]): number {\n  assertSameDimensions(left, right);\n  const leftMagnitude = magnitude(left);\n  const rightMagnitude = magnitude(right);\n  if (leftMagnitude === 0 || rightMagnitude === 0) {\n    return 0;\n  }\n  return dotProduct(left, right) / (leftMagnitude * rightMagnitude);\n}\n\nexport function angularDistance(left: number[], right: number[]): number {\n  const similarity = Math.max(-1, Math.min(1, cosineSimilarity(left, right)));\n  return Math.acos(similarity) / Math.PI;\n}\n\nexport function euclideanDistance(left: number[], right: number[]): number {\n  assertSameDimensions(left, right);\n  return Math.sqrt(\n    left.reduce((sum, value, index) => sum + (value - (right[index] as number)) ** 2, 0),\n  );\n}\n\nexport function manhattanDistance(left: number[], right: number[]): number {\n  assertSameDimensions(left, right);\n  return left.reduce((sum, value, index) => sum + Math.abs(value - (right[index] as number)), 0);\n}\n\nexport function chebyshevDistance(left: number[], right: number[]): number {\n  assertSameDimensions(left, right);\n  return left.reduce(\n    (max, value, index) => Math.max(max, Math.abs(value - (right[index] as number))),\n    0,\n  );\n}\n\nfunction magnitude(vector: number[]): number {\n  return Math.sqrt(vector.reduce((sum, value) => sum + value ** 2, 0));\n}\n\nfunction assertSameDimensions(left: number[], right: number[]): void {\n  if (left.length !== right.length) {\n    throw new Error(`Vector dimension mismatch: ${left.length} !== ${right.length}`);\n  }\n}\n","import { throwIfAborted } from \"../internal/abort\";\nimport { mapWithConcurrency } from \"../internal/concurrency\";\nimport type { ModelCallOptions } from \"../model-call-options\";\nimport { type ResolvedRetryOptions, resolveRetryOptions, runWithRetries } from \"../retry\";\nimport type {\n  EmbedDocumentsOptions,\n  EmbedDocumentsResult,\n  EmbeddedDocument,\n  Embedding,\n  EmbeddingOperationOptions,\n  EmbedHybridDocumentsOptions,\n  EmbedSparseQueryOptions,\n  EmbedSparseQueryResult,\n  EmbedSparseTextsOptions,\n  EmbedSparseTextsResult,\n  EmbedTextOptions,\n  EmbedTextResult,\n  EmbedTextsOptions,\n  EmbedTextsResult,\n  SparseEmbedding,\n  VectorMetadata,\n} from \"./types\";\n\nexport async function embedText(options: EmbedTextOptions): Promise<EmbedTextResult> {\n  const { embeddings } = await embedTexts({\n    model: options.model,\n    texts: [options.text],\n    retries: options.retries,\n    abortSignal: options.abortSignal,\n  });\n  const embedding = embeddings[0];\n  if (embedding === undefined) throw new Error(\"Embedding model returned no embeddings\");\n  return { embedding };\n}\n\nexport async function embedTexts(options: EmbedTextsOptions): Promise<EmbedTextsResult> {\n  throwIfAborted(options.abortSignal);\n  if (options.texts.length === 0) return { embeddings: [] };\n  const batches = chunk(options.texts, batchSize(options.model.maxBatchSize, options.texts.length));\n  const results = await mapWithConcurrency(batches, concurrency(options.concurrency), (batch) =>\n    embedDenseBatch(options.model, batch, options),\n  );\n  const embeddings = results.flat();\n  if (embeddings.length !== options.texts.length) {\n    throw new Error(\n      `Embedding model returned ${embeddings.length} embeddings for ${options.texts.length} texts`,\n    );\n  }\n  return { embeddings };\n}\n\nexport async function embedSparseTexts(\n  options: EmbedSparseTextsOptions,\n): Promise<EmbedSparseTextsResult> {\n  throwIfAborted(options.abortSignal);\n  if (options.texts.length === 0) return { embeddings: [] };\n  const batches = chunk(options.texts, batchSize(options.model.maxBatchSize, options.texts.length));\n  const results = await mapWithConcurrency(batches, concurrency(options.concurrency), (batch) =>\n    embedSparseBatch(options.model, batch, options),\n  );\n  const embeddings = results.flat();\n  if (embeddings.length !== options.texts.length) {\n    throw new Error(\n      `Sparse embedding model returned ${embeddings.length} embeddings for ${options.texts.length} texts`,\n    );\n  }\n  return { embeddings };\n}\n\nexport async function embedSparseQuery(\n  options: EmbedSparseQueryOptions,\n): Promise<EmbedSparseQueryResult> {\n  throwIfAborted(options.abortSignal);\n  const embedding = await runWithRetries(\n    () => {\n      throwIfAborted(options.abortSignal);\n      return options.model.embedQuery(options.query, modelCallOptions(options.abortSignal));\n    },\n    resolveRetries(options),\n    { streaming: false, abortSignal: options.abortSignal },\n  );\n  throwIfAborted(options.abortSignal);\n  validateSparseEmbedding(embedding, \"query\");\n  return { embedding };\n}\n\nexport function embedDocuments<T, Metadata extends VectorMetadata = VectorMetadata>(\n  options: EmbedDocumentsOptions<T, Metadata>,\n): Promise<EmbedDocumentsResult<T, Metadata>>;\nexport function embedDocuments<T, Metadata extends VectorMetadata = VectorMetadata>(\n  options: EmbedHybridDocumentsOptions<T, Metadata>,\n): Promise<EmbedDocumentsResult<T, Metadata>>;\nexport async function embedDocuments<T, Metadata extends VectorMetadata = VectorMetadata>(\n  options: EmbedDocumentsOptions<T, Metadata> | EmbedHybridDocumentsOptions<T, Metadata>,\n): Promise<EmbedDocumentsResult<T, Metadata>> {\n  throwIfAborted(options.abortSignal);\n  const prepared = prepareDocuments(options.documents, options);\n  const flatTexts = prepared.flatMap((item, documentIndex) =>\n    item.texts.map((text) => ({ documentIndex, text })),\n  );\n  const concurrencyLimit = concurrency(options.concurrency);\n\n  if (\"model\" in options && options.model !== undefined) {\n    const batches = chunk(flatTexts, batchSize(options.model.maxBatchSize, flatTexts.length || 1));\n    const results = await mapWithConcurrency(batches, concurrencyLimit, async (batch) => {\n      const embeddings = await embedDenseBatch(\n        options.model,\n        batch.map((item) => item.text),\n        options,\n      );\n      assertBatchLength(\"Embedding\", embeddings.length, batch.length);\n      return batch.map((item, index) => ({\n        documentIndex: item.documentIndex,\n        embedding: embeddings[index] as Embedding,\n      }));\n    });\n    const byDocument = groupEmbeddings(results.flat());\n    return {\n      documents: prepared.map((item, index) => embeddedDocument(item, byDocument.get(index) ?? [])),\n    };\n  }\n\n  const { dense, sparse } = options.models;\n  const [denseResults, sparseResults] = await Promise.all([\n    mapWithConcurrency(\n      chunk(flatTexts, batchSize(dense.maxBatchSize, flatTexts.length || 1)),\n      concurrencyLimit,\n      async (batch) => {\n        const embeddings = await embedDenseBatch(\n          dense,\n          batch.map((item) => item.text),\n          options,\n        );\n        assertBatchLength(\"Embedding\", embeddings.length, batch.length);\n        return batch.map((item, index) => ({\n          documentIndex: item.documentIndex,\n          embedding: embeddings[index] as Embedding,\n        }));\n      },\n    ),\n    mapWithConcurrency(\n      chunk(flatTexts, batchSize(sparse.maxBatchSize, flatTexts.length || 1)),\n      concurrencyLimit,\n      async (batch) => {\n        const embeddings = await embedSparseBatch(\n          sparse,\n          batch.map((item) => item.text),\n          options,\n        );\n        assertBatchLength(\"Sparse embedding\", embeddings.length, batch.length);\n        return batch.map((item, index) => ({\n          documentIndex: item.documentIndex,\n          embedding: embeddings[index] as SparseEmbedding,\n        }));\n      },\n    ),\n  ]);\n  const denseByDocument = groupEmbeddings(denseResults.flat());\n  const sparseByDocument = groupEmbeddings(sparseResults.flat());\n  return {\n    documents: prepared.map((item, index) => {\n      const embeddings = denseByDocument.get(index) ?? [];\n      const sparseEmbeddings = sparseByDocument.get(index) ?? [];\n      if (embeddings.length !== sparseEmbeddings.length) {\n        throw new Error(\n          `Hybrid embedding produced ${embeddings.length} dense and ${sparseEmbeddings.length} sparse vectors for document ${item.id}`,\n        );\n      }\n      return embeddedDocument(item, embeddings, sparseEmbeddings);\n    }),\n  };\n}\n\nasync function embedDenseBatch(\n  model: EmbedTextOptions[\"model\"],\n  texts: string[],\n  options: EmbeddingOperationOptions,\n): Promise<Embedding[]> {\n  throwIfAborted(options.abortSignal);\n  const embeddings = await runWithRetries(\n    () => model.embedTexts(texts, modelCallOptions(options.abortSignal)),\n    resolveRetries(options),\n    { streaming: false, abortSignal: options.abortSignal },\n  );\n  throwIfAborted(options.abortSignal);\n  for (const [index, embedding] of embeddings.entries()) {\n    validateDenseEmbedding(embedding, model.dimensions, index);\n  }\n  return embeddings;\n}\n\nasync function embedSparseBatch(\n  model: EmbedSparseTextsOptions[\"model\"],\n  texts: string[],\n  options: EmbeddingOperationOptions,\n): Promise<SparseEmbedding[]> {\n  throwIfAborted(options.abortSignal);\n  const embeddings = await runWithRetries(\n    () => model.embedTexts(texts, modelCallOptions(options.abortSignal)),\n    resolveRetries(options),\n    { streaming: false, abortSignal: options.abortSignal },\n  );\n  throwIfAborted(options.abortSignal);\n  for (const [index, embedding] of embeddings.entries()) validateSparseEmbedding(embedding, index);\n  return embeddings;\n}\n\nfunction prepareDocuments<T, Metadata extends VectorMetadata>(\n  documents: T[],\n  options: Pick<EmbedDocumentsOptions<T, Metadata>, \"id\" | \"content\" | \"metadata\">,\n) {\n  const ids = new Set<string>();\n  return documents.map((document, index) => {\n    const id = options.id?.(document, index) ?? `doc${index}`;\n    if (id.length === 0) throw new TypeError(\"Embedded document ids must not be empty\");\n    if (ids.has(id)) throw new TypeError(`Duplicate embedded document id: ${id}`);\n    ids.add(id);\n    const content = options.content(document, index);\n    if (Array.isArray(content) && content.length === 0)\n      throw new TypeError(`Embedded document ${id} must contain at least one text chunk`);\n    return {\n      id,\n      document,\n      metadata: options.metadata?.(document, index),\n      texts: Array.isArray(content) ? content : [content],\n    };\n  });\n}\n\nfunction embeddedDocument<T, Metadata extends VectorMetadata>(\n  item: { id: string; document: T; metadata: Metadata | undefined },\n  embeddings: Embedding[],\n  sparseEmbeddings?: SparseEmbedding[],\n): EmbeddedDocument<T, Metadata> {\n  let result: EmbeddedDocument<T, Metadata> = {\n    id: item.id,\n    document: item.document,\n    embeddings,\n  };\n  if (item.metadata !== undefined) {\n    result = { ...result, metadata: item.metadata };\n  }\n  if (sparseEmbeddings !== undefined) {\n    result = { ...result, sparseEmbeddings };\n  }\n  return result;\n}\n\nfunction groupEmbeddings<E>(\n  items: Array<{ documentIndex: number; embedding: E }>,\n): Map<number, E[]> {\n  const groups = new Map<number, E[]>();\n  for (const item of items) {\n    const list = groups.get(item.documentIndex) ?? [];\n    list.push(item.embedding);\n    groups.set(item.documentIndex, list);\n  }\n  return groups;\n}\n\nfunction assertBatchLength(name: string, actual: number, expected: number): void {\n  if (actual !== expected)\n    throw new Error(`${name} model returned ${actual} embeddings for ${expected} texts`);\n}\n\nfunction resolveRetries(options: EmbeddingOperationOptions): ResolvedRetryOptions | undefined {\n  return options.retries === undefined || options.retries === false\n    ? undefined\n    : resolveRetryOptions(options.retries);\n}\n\nfunction modelCallOptions(abortSignal: AbortSignal | undefined): ModelCallOptions | undefined {\n  return abortSignal === undefined ? undefined : { abortSignal };\n}\n\nfunction chunk<T>(items: T[], size: number): T[][] {\n  const chunks: T[][] = [];\n  for (let index = 0; index < items.length; index += size)\n    chunks.push(items.slice(index, index + size));\n  return chunks;\n}\n\nfunction batchSize(configured: number | undefined, fallback: number): number {\n  if (configured === undefined) return fallback;\n  if (!Number.isSafeInteger(configured) || configured < 1) {\n    throw new RangeError(\"Embedding model maxBatchSize must be a positive safe integer\");\n  }\n  return configured;\n}\n\nfunction concurrency(configured: number | undefined): number {\n  if (configured === undefined) return 1;\n  if (!Number.isSafeInteger(configured) || configured < 1) {\n    throw new RangeError(\"Embedding concurrency must be a positive safe integer\");\n  }\n  return configured;\n}\n\nfunction validateDenseEmbedding(\n  embedding: Embedding,\n  dimensions: number | undefined,\n  index: number,\n): void {\n  if (embedding.vector.length === 0) {\n    throw new TypeError(`Embedding model returned an empty vector at index ${index}`);\n  }\n  if (!embedding.vector.every(Number.isFinite)) {\n    throw new TypeError(`Embedding model returned a non-finite vector at index ${index}`);\n  }\n  if (dimensions !== undefined) {\n    if (!Number.isSafeInteger(dimensions) || dimensions < 1)\n      throw new TypeError(\"Embedding model dimensions must be a positive safe integer\");\n    if (embedding.vector.length !== dimensions) {\n      throw new Error(\n        `Embedding model returned ${embedding.vector.length} dimensions at index ${index}; expected ${dimensions}`,\n      );\n    }\n  }\n}\n\nfunction validateSparseEmbedding(embedding: SparseEmbedding, index: number | \"query\"): void {\n  const { indices, values } = embedding.vector;\n  if (indices.length !== values.length) {\n    throw new Error(`Sparse embedding at ${index} has mismatched indices and values`);\n  }\n  if (!indices.every((value) => Number.isSafeInteger(value) && value >= 0)) {\n    throw new TypeError(`Sparse embedding at ${index} has an invalid index`);\n  }\n  if (new Set(indices).size !== indices.length) {\n    throw new TypeError(`Sparse embedding at ${index} has duplicate indices`);\n  }\n  if (!values.every(Number.isFinite)) {\n    throw new TypeError(`Sparse embedding at ${index} has a non-finite value`);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/completion/index.d.ts

@@ -1,42 +1,12 @@
-export { C as CreateCompletionBaseOptions, a as CreateCompletionInput, b as CreateCompletionOptions, c as CreateCompletionResult, d as CreateCompletionStreamOptions, e as CreateParsedCompletionOptions, f as CreateParsedCompletionResult, g as createCompletion, h as createCompletionStream, i as createParsedCompletion, j as isJsonValue, k as isStreamingCompletionModel } from '../json-BVPssigK.js';
-import { D as Document, M as Message, C as CompletionModel, i as CompletionTool, L as ToolChoice, l as JsonValue, J as JsonObject, f as CompletionRequest, g as CompletionResponse } from '../types-G12i56s2.js';
-export { A as AssistantContent, a as AssistantGenerationMetadata, b as AssistantMessage, c as AssistantMessageOptions, N as CompletionCapabilityError, O as CompletionModelCapabilities, d as CompletionModelInfo, e as CompletionModelMetadataOptions, h as CompletionSource, Q as CompletionStreamEvent, j as ContextUsage, R as DocumentContent, I as ImageContent, V as ImageDetail, k as JsonPrimitive, m as MessageOptions, n as ModelContextLimits, P as ProviderTool, o as ProviderToolCall, W as Reasoning, X as ReasoningContent, Y as ReasoningContentType, Z as StreamingCompletionModel, S as SystemMessage, T as Text, p as ToolCall, _ as ToolCallArgumentsMode, q as ToolContent, r as ToolDefinition, $ as ToolFunction, s as ToolMessage, t as ToolResult, u as ToolResultContent, v as ToolResultMessageOptions, w as ToolResultOptions, U as Usage, a0 as UsageDetails, x as UserContent, y as UserMessage, a1 as assertCompletionRequestSupported, z as calculateContextUsage, B as getAssistantGenerationMetadata, E as isProviderTool, H as isToolResultContentArray, a2 as reasoningDisplayText, F as resolveCompletionModelInfo, K as serializeToolResultOutput, a3 as textFromAssistantContent, G as withContextUsage } from '../types-G12i56s2.js';
+export { M as ModelCallOptions } from '../model-call-options-CZkSw_xN.js';
+export { R as RetryContext, a as RetryOptions, b as RetrySetting } from '../retry-CjvSlKGW.js';
+import { D as Document, M as Message } from '../types-DgvozfPc.js';
+export { A as AssistantContentPart, a as AssistantGenerationMetadata, b as AssistantMessage, Q as CompletionCapabilityError, C as CompletionFinishReason, c as CompletionModel, V as CompletionModelCapabilities, d as CompletionModelInfo, e as CompletionModelStreamEvent, f as CompletionRequest, g as CompletionResponse, h as CompletionResult, i as CompletionSource, j as CompletionStreamEvent, W as CompletionStreamPart, k as CompletionTool, l as ContextUsage, F as FileData, m as FilePart, I as ImageDetail, n as ImagePart, J as JsonObject, o as JsonPrimitive, p as JsonValue, q as ModelContextLimits, P as ProviderTool, r as ProviderToolCall, R as ReasoningContentType, s as ReasoningDetail, t as ReasoningPart, X as StreamingCompletionModel, S as SystemMessage, T as TextPart, Y as ToolApprovalResponsePart, Z as ToolCallArgumentsMode, u as ToolCallPart, v as ToolChoice, w as ToolDefinition, _ as ToolInteractionResponsePart, x as ToolMessage, $ as ToolQuestionAnswer, a0 as ToolQuestionResponsePart, y as ToolResultContentPart, z as ToolResultOutput, B as ToolResultPart, U as Usage, a1 as UsageDetails, E as UserContentPart, G as UserMessage, a2 as assertCompletionRequestSupported, H as calculateContextUsage, K as getAssistantGenerationMetadata, L as isProviderTool, a3 as reasoningDisplayText, N as resolveModelContextLimits, a4 as textFromAssistantContent, O as withContextUsage } from '../types-DgvozfPc.js';
+export { C as COMPLETION_PROVIDER_OUTPUT_ERROR_CODE, a as CompletionBaseOptions, b as CompletionInput, c as CompletionProviderOutputError, d as CompletionProviderOutputErrorKind, e as CompletionProviderOutputErrorOptions, f as CompletionStructuredOutputError, g as CompletionStructuredOutputPhase, G as GenerateCompletionOptions, h as GenerateStructuredCompletionOptions, M as MessageMetadataSchema, S as StreamCompletionOptions, i as StreamStructuredCompletionOptions, j as createMessageSchema, k as generateCompletion, l as isJsonValue, m as isMessage, r as isStreamingCompletionModel, n as messageSchema, o as messagesSchema, p as parseMessage, q as parseMessages, s as streamCompletion } from '../provider-output-error-BEwDgVv3.js';
 import '../zod-schema-C7F4clpm.js';
 import 'zod';
 
 declare function normalizeDocuments(documents: Document[]): Message | undefined;
 declare function formatDocument(document: Document): string;
 
-type ModelNameOf<M extends CompletionModel> = M extends CompletionModel<unknown, infer ModelName> ? ModelName : string;
-type RawResponseOf<M extends CompletionModel> = M extends CompletionModel<infer RawResponse, infer _ModelName> ? RawResponse : unknown;
-declare class CompletionRequestBuilder<M extends CompletionModel = CompletionModel> {
-    private readonly model;
-    private readonly promptMessage;
-    private requestModel;
-    private instructionBlocks;
-    private history;
-    private docs;
-    private toolDefs;
-    private providerToolDefs;
-    private temp;
-    private maxTokenCount;
-    private choice;
-    private params;
-    private schema;
-    constructor(model: M, promptMessage: Message);
-    modelOverride(model: ModelNameOf<M> | undefined): this;
-    instructions(instructions: string | undefined): this;
-    messages(messages: Message[]): this;
-    documents(documents: Document[]): this;
-    tools(tools: CompletionTool[]): this;
-    temperature(temperature: number | undefined): this;
-    maxTokens(maxTokens: number | undefined): this;
-    toolChoice(toolChoice: ToolChoice | undefined): this;
-    additionalParams(additionalParams: JsonValue | undefined): this;
-    outputSchema(outputSchema: JsonObject | undefined): this;
-    build(): CompletionRequest<ModelNameOf<M>>;
-    send(): Promise<CompletionResponse<RawResponseOf<M>>>;
-    private buildInstructions;
-}
-
-export { CompletionModel, CompletionRequest, CompletionRequestBuilder, CompletionResponse, CompletionTool, Document, JsonObject, JsonValue, Message, ToolChoice, formatDocument, normalizeDocuments };
+export { Document, Message, formatDocument, normalizeDocuments };

package/dist/completion/index.js

@@ -1,57 +1,62 @@
 import {
-  CompletionRequestBuilder,
   formatDocument,
   normalizeDocuments
-} from "../chunk-Q25IWLBT.js";
+} from "../chunk-D4PACGPA.js";
 import {
-  createCompletion,
-  createCompletionStream,
-  createParsedCompletion,
-  isStreamingCompletionModel
-} from "../chunk-MC3CCKEB.js";
-import {
-  AssistantContent,
+  COMPLETION_PROVIDER_OUTPUT_ERROR_CODE,
   CompletionCapabilityError,
-  Message,
-  ToolContent,
+  CompletionProviderOutputError,
+  CompletionStructuredOutputError,
   Usage,
-  UserContent,
   assertCompletionRequestSupported,
   calculateContextUsage,
+  generateCompletion,
   getAssistantGenerationMetadata,
-  isJsonValue,
   isProviderTool,
-  isToolResultContentArray,
+  isStreamingCompletionModel,
   reasoningDisplayText,
-  resolveCompletionModelInfo,
-  serializeToolResultOutput,
+  resolveModelContextLimits,
+  streamCompletion,
   textFromAssistantContent,
   withContextUsage
-} from "../chunk-ADH7NNCS.js";
-import "../chunk-WQKHFADH.js";
+} from "../chunk-7PHMK7W4.js";
+import "../chunk-7JLAIN6E.js";
+import {
+  createMessageSchema,
+  isMessage,
+  messageSchema,
+  messagesSchema,
+  parseMessage,
+  parseMessages
+} from "../chunk-QGX73TSQ.js";
+import {
+  isJsonValue
+} from "../chunk-3XQGVDU5.js";
+import "../chunk-3RWESPUG.js";
 export {
-  AssistantContent,
+  COMPLETION_PROVIDER_OUTPUT_ERROR_CODE,
   CompletionCapabilityError,
-  CompletionRequestBuilder,
-  Message,
-  ToolContent,
+  CompletionProviderOutputError,
+  CompletionStructuredOutputError,
   Usage,
-  UserContent,
   assertCompletionRequestSupported,
   calculateContextUsage,
-  createCompletion,
-  createCompletionStream,
-  createParsedCompletion,
+  createMessageSchema,
   formatDocument,
+  generateCompletion,
   getAssistantGenerationMetadata,
   isJsonValue,
+  isMessage,
   isProviderTool,
   isStreamingCompletionModel,
-  isToolResultContentArray,
+  messageSchema,
+  messagesSchema,
   normalizeDocuments,
+  parseMessage,
+  parseMessages,
   reasoningDisplayText,
-  resolveCompletionModelInfo,
-  serializeToolResultOutput,
+  resolveModelContextLimits,
+  streamCompletion,
   textFromAssistantContent,
   withContextUsage
 };

package/dist/documents/index.d.ts

@@ -0,0 +1,34 @@
+type TextChunk = Readonly<{
+    index: number;
+    text: string;
+    start: number;
+    end: number;
+}>;
+type ChunkTextOptions = Readonly<{
+    text: string;
+    strategy: "fixed";
+    maxSize: number;
+    overlap?: number;
+}> | Readonly<{
+    text: string;
+    strategy: "recursive";
+    maxSize: number;
+    overlap?: number;
+    separators: readonly string[];
+}>;
+declare function chunkText(options: ChunkTextOptions): readonly TextChunk[];
+
+type PdfTextPage = Readonly<{
+    pageNumber: number;
+    text: string;
+}>;
+type ExtractPdfTextOptions = Readonly<{
+    data: Uint8Array;
+    abortSignal?: AbortSignal;
+}>;
+type ExtractPdfTextResult = Readonly<{
+    pages: readonly PdfTextPage[];
+}>;
+declare function extractPdfText(options: ExtractPdfTextOptions): Promise<ExtractPdfTextResult>;
+
+export { type ChunkTextOptions, type ExtractPdfTextOptions, type ExtractPdfTextResult, type PdfTextPage, type TextChunk, chunkText, extractPdfText };