@anvia/core 0.1.0

package/README.md

@@ -0,0 +1,101 @@
+# @anvia/core
+
+Core runtime primitives for Anvia agents, tools, structured extraction, pipelines, streaming, RAG, MCP, skills, and observability.
+
+This package is provider-neutral. Pair it with a provider adapter such as `@anvia/openai`, `@anvia/anthropic`, or `@anvia/gemini` to create runnable models.
+
+## Installation
+
+```sh
+pnpm add @anvia/core
+```
+
+In this monorepo, the package is available through the workspace:
+
+```sh
+pnpm --filter @anvia/core build
+```
+
+## Usage
+
+```ts
+import { z } from "zod";
+import { AgentBuilder, ExtractorBuilder, PipelineBuilder, createTool } from "@anvia/core";
+import { OpenAIClient } from "@anvia/openai";
+
+const client = new OpenAIClient({
+  apiKey,
+});
+
+const model = client.completionModel("gpt-5");
+
+const lookupOrder = createTool({
+  name: "lookup_order",
+  description: "Look up an order by id.",
+  input: z.object({ orderId: z.string() }),
+  execute: async ({ orderId }) => ({ orderId, status: "processing" }),
+});
+
+const agent = new AgentBuilder("support", model)
+  .instructions("Help customers with order questions.")
+  .tool(lookupOrder)
+  .defaultMaxTurns(4)
+  .build();
+
+const response = await agent.prompt("What is happening with order A123?").send();
+
+console.log(response.output);
+```
+
+## Structured Extraction
+
+```ts
+const ticketSchema = z.object({
+  customer: z.string(),
+  priority: z.enum(["low", "medium", "high"]),
+  summary: z.string(),
+});
+
+const extractor = new ExtractorBuilder(model, ticketSchema).retries(1).build();
+
+const ticket = await extractor.extract(
+  "Acme Co. reports checkout failures. Priority is high.",
+);
+```
+
+## Pipelines
+
+```ts
+const pipeline = new PipelineBuilder<string>()
+  .step((input) => `Extract this support ticket:\n\n${input}`)
+  .prompt(agent)
+  .extract(extractor)
+  .build();
+
+const result = await pipeline.run("Customer cannot complete checkout.");
+```
+
+## Public Areas
+
+- `agent`: agent runtime and `AgentBuilder`
+- `tool`: typed tool creation and tool sets
+- `completion`: provider-neutral completion request and response types
+- `extractor`: schema-first structured extraction
+- `pipeline`: typed sequential and parallel workflows
+- `embeddings`: embedding helpers and document embedding utilities
+- `vector-store`: in-memory vector search and vector search tools
+- `streaming`: normalized stream helpers
+- `mcp`: MCP server connection helpers
+- `skills`: local skill loading
+- `observability`: observer interfaces for runs, generations, and tool calls
+- `evals`: evaluation helpers and reporters
+- `loaders`: document loading utilities
+- `audio-generation`, `image-generation`, `transcription`: provider-neutral media interfaces
+
+## Development
+
+```sh
+pnpm --filter @anvia/core typecheck
+pnpm --filter @anvia/core test
+pnpm --filter @anvia/core build
+```

package/dist/agent/index.d.ts

@@ -0,0 +1,70 @@
+import { e as DynamicContextOptions, g as DynamicToolOptions, P as PromptHook, A as Agent } from '../agent-C6h6YrRU.js';
+export { a as AgentOptions, b as AgentStreamEvent, c as AgentToolOptions, C as CompletionCallHookArgs, d as CompletionResponseHookArgs, D as DEFAULT_MAX_TURNS, f as DynamicContextRegistration, h as DynamicToolRegistration, H as HookAction, i as HookResult, j as PromptRequest, k as PromptResponse, R as RunControl, T as ToolCallControl, l as ToolCallHookAction, m as ToolCallHookArgs, n as ToolCallHookResult, o as ToolHookArgs, p as ToolResultHookArgs, q as cancelPrompt, r as createHook, s as runControl, t as skipTool, u as toolCallControl } from '../agent-C6h6YrRU.js';
+import { b as CompletionModel, j as JsonValue, o as ToolChoice, M as Message } from '../types-BrxLd7ay.js';
+import { c as McpServer } from '../types-B5B8Sdl4.js';
+import { AgentObserver, ObserveOptions } from '../observability/index.js';
+import { T as ToolSearchDocument, a as ToolSet, Z as ZodSchema } from '../zod-schema-DJTEgQBq.js';
+import { b as SkillSet } from '../types-HvopERm0.js';
+import { A as AnyTool } from '../tool-DhuBQ3yb.js';
+import { VectorSearchIndex } from '../vector-store/index.js';
+import '@modelcontextprotocol/sdk/client/stdio.js';
+import '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import '../embeddings/index.js';
+import 'zod';
+
+declare class AgentBuilder<M extends CompletionModel = CompletionModel> {
+    private readonly completionModel;
+    private readonly agentId;
+    private agentName;
+    private agentDescription;
+    private instructionBlocks;
+    private contextDocs;
+    private temp;
+    private maxTokenCount;
+    private params;
+    private choice;
+    private turns;
+    private requestHook;
+    private schema;
+    private skillInstructionBlocks;
+    private observerRegistrations;
+    private dynamicContextRegistrations;
+    private dynamicToolRegistrations;
+    private activeToolSet;
+    constructor(agentId: string, completionModel: M);
+    name(name: string): this;
+    description(description: string): this;
+    instructions(instructions: string): this;
+    context(text: string, id?: string): this;
+    dynamicContext<T>(index: VectorSearchIndex<T>, options: DynamicContextOptions<T>): this;
+    dynamicTools(index: VectorSearchIndex<ToolSearchDocument>, options: DynamicToolOptions): this;
+    tool(tool: AnyTool): this;
+    tools(tools: AnyTool[]): this;
+    mcp(servers: McpServer[]): this;
+    skills(skillSet: SkillSet): this;
+    useToolSet(toolSet: ToolSet): this;
+    temperature(temperature: number): this;
+    maxTokens(maxTokens: number): this;
+    additionalParams(params: JsonValue): this;
+    toolChoice(toolChoice: ToolChoice): this;
+    defaultMaxTurns(defaultMaxTurns: number): this;
+    hook(hook: PromptHook): this;
+    observe(observer: AgentObserver, options?: ObserveOptions): this;
+    outputSchema(schema: ZodSchema): this;
+    build(): Agent<M>;
+    private buildInstructions;
+}
+
+declare class MaxTurnsError extends Error {
+    readonly maxTurns: number;
+    readonly chatHistory: Message[];
+    readonly prompt: Message;
+    constructor(maxTurns: number, chatHistory: Message[], prompt: Message);
+}
+declare class PromptCancelledError extends Error {
+    readonly chatHistory: Message[];
+    readonly reason: string;
+    constructor(chatHistory: Message[], reason: string);
+}
+
+export { Agent, AgentBuilder, DynamicContextOptions, DynamicToolOptions, MaxTurnsError, PromptCancelledError, PromptHook };

package/dist/agent/index.js

@@ -0,0 +1,31 @@
+import {
+  Agent,
+  AgentBuilder,
+  DEFAULT_MAX_TURNS,
+  MaxTurnsError,
+  PromptCancelledError,
+  PromptRequest,
+  cancelPrompt,
+  createHook,
+  runControl,
+  skipTool,
+  toolCallControl
+} from "../chunk-IQBY2GCF.js";
+import "../chunk-XUUY2L2D.js";
+import "../chunk-GNWMOSNR.js";
+import "../chunk-B4QHQN5K.js";
+import "../chunk-CP47FBJV.js";
+export {
+  Agent,
+  AgentBuilder,
+  DEFAULT_MAX_TURNS,
+  MaxTurnsError,
+  PromptCancelledError,
+  PromptRequest,
+  cancelPrompt,
+  createHook,
+  runControl,
+  skipTool,
+  toolCallControl
+};
+//# sourceMappingURL=index.js.map

package/dist/agent/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/agent-C6h6YrRU.d.ts

@@ -0,0 +1,218 @@
+import { M as Message, e as CompletionResponse, b as CompletionModel, U as Usage, l as ReasoningContentType, n as ToolCall, D as Document, j as JsonValue, o as ToolChoice, J as JsonObject } from './types-BrxLd7ay.js';
+import { AgentTraceOptions, AgentTraceInfo, AgentObserverRegistration } from './observability/index.js';
+import { a as ToolSet, T as ToolSearchDocument } from './zod-schema-DJTEgQBq.js';
+import { T as Tool, A as AnyTool } from './tool-DhuBQ3yb.js';
+import { VectorSearchIndex, VectorFilter, VectorSearchResult } from './vector-store/index.js';
+
+type HookAction = {
+    type: "continue";
+} | {
+    type: "terminate";
+    reason: string;
+};
+type ToolCallHookAction = {
+    type: "continue";
+} | {
+    type: "skip";
+    reason: string;
+} | {
+    type: "terminate";
+    reason: string;
+};
+type RunControl = {
+    continue(): HookAction;
+    cancel(reason: string): HookAction;
+};
+type ToolCallControl = {
+    run(): ToolCallHookAction;
+    skip(reason: string): ToolCallHookAction;
+    cancel(reason: string): ToolCallHookAction;
+};
+type HookResult = HookAction | undefined;
+type ToolCallHookResult = ToolCallHookAction | undefined;
+type HookCallback<Args> = (args: Args) => HookAction | Promise<HookAction | undefined> | Promise<void> | void;
+type ToolCallHookCallback<Args> = (args: Args) => ToolCallHookAction | Promise<ToolCallHookAction | undefined> | Promise<void> | void;
+type CompletionCallHookArgs = {
+    prompt: Message;
+    history: Message[];
+    run: RunControl;
+};
+type CompletionResponseHookArgs<RawResponse = unknown> = {
+    prompt: Message;
+    response: CompletionResponse<RawResponse>;
+    run: RunControl;
+};
+type ToolHookArgs = {
+    toolName: string;
+    toolCallId?: string;
+    internalCallId: string;
+    args: string;
+};
+type ToolCallHookArgs = ToolHookArgs & {
+    tool: ToolCallControl;
+};
+type ToolResultHookArgs = ToolHookArgs & {
+    result: string;
+    run: RunControl;
+};
+declare function createHook<RawResponse = unknown>(hook: PromptHook<RawResponse>): PromptHook<RawResponse>;
+declare function cancelPrompt(reason: string): HookAction;
+declare function skipTool(reason: string): ToolCallHookAction;
+declare const runControl: RunControl;
+declare const toolCallControl: ToolCallControl;
+interface PromptHook<RawResponse = unknown> {
+    onCompletionCall?: HookCallback<CompletionCallHookArgs>;
+    onCompletionResponse?: HookCallback<CompletionResponseHookArgs<RawResponse>>;
+    onToolCall?: ToolCallHookCallback<ToolCallHookArgs>;
+    onToolResult?: HookCallback<ToolResultHookArgs>;
+}
+
+type PromptResponse = {
+    output: string;
+    usage: Usage;
+    messages: Message[];
+    trace?: AgentTraceInfo | undefined;
+};
+type AgentStreamEvent<RawResponse = unknown> = {
+    type: "turn_start";
+    turn: number;
+    prompt: Message;
+    history: Message[];
+} | {
+    type: "text_delta";
+    turn: number;
+    delta: string;
+} | {
+    type: "reasoning_delta";
+    turn: number;
+    delta: string;
+    id?: string;
+    contentType?: ReasoningContentType;
+    signature?: string;
+} | {
+    type: "tool_call";
+    turn: number;
+    toolCall: ToolCall;
+} | {
+    type: "tool_result";
+    turn: number;
+    toolName: string;
+    toolCallId?: string;
+    internalCallId: string;
+    args: string;
+    result: string;
+} | {
+    type: "turn_end";
+    turn: number;
+    response: CompletionResponse<RawResponse>;
+} | {
+    type: "final";
+    output: string;
+    usage: Usage;
+    messages: Message[];
+    trace?: AgentTraceInfo | undefined;
+} | {
+    type: "error";
+    error: unknown;
+};
+declare class PromptRequest<M extends CompletionModel = CompletionModel> {
+    private readonly agent;
+    private readonly promptMessage;
+    private chatHistory;
+    private maxTurnCount;
+    private activeHook;
+    private concurrency;
+    private traceOptions;
+    private constructor();
+    static fromAgent<M extends CompletionModel>(agent: Agent<M>, prompt: string | Message): PromptRequest<M>;
+    withHistory(history: Message[]): this;
+    maxTurns(maxTurns: number): this;
+    requestHook(hook: PromptHook): this;
+    withToolConcurrency(concurrency: number): this;
+    withTrace(trace: AgentTraceOptions): this;
+    send(): Promise<PromptResponse>;
+    stream(): AsyncIterable<AgentStreamEvent>;
+    readableStream(): ReadableStream<Uint8Array>;
+    private runCompletion;
+    private executeToolCalls;
+    private startRunObservers;
+    private fetchDynamicContext;
+    private fetchToolDefinitions;
+    private recordToolError;
+    private runCompletionCallHook;
+    private runCompletionResponseHook;
+    private cancelled;
+}
+
+type AgentOptions<M extends CompletionModel = CompletionModel> = {
+    id: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    model: M;
+    instructions?: string | undefined;
+    staticContext?: Document[];
+    temperature?: number | undefined;
+    maxTokens?: number | undefined;
+    additionalParams?: JsonValue | undefined;
+    toolSet?: ToolSet | undefined;
+    toolChoice?: ToolChoice | undefined;
+    defaultMaxTurns?: number | undefined;
+    hook?: PromptHook | undefined;
+    outputSchema?: JsonObject | undefined;
+    observers?: AgentObserverRegistration[] | undefined;
+    dynamicContexts?: DynamicContextRegistration[] | undefined;
+    dynamicTools?: DynamicToolRegistration[] | undefined;
+};
+declare const DEFAULT_MAX_TURNS = 20;
+type AgentToolOptions = {
+    name: string;
+    description?: string | undefined;
+    maxTurns?: number | undefined;
+};
+type DynamicContextOptions<T = unknown> = {
+    topK: number;
+    threshold?: number | undefined;
+    filter?: VectorFilter | undefined;
+    format?: ((result: VectorSearchResult<T>) => Document) | undefined;
+};
+type DynamicContextRegistration<T = unknown> = {
+    index: VectorSearchIndex<T>;
+    options: DynamicContextOptions<T>;
+};
+type DynamicToolOptions = {
+    topK: number;
+    threshold?: number | undefined;
+    filter?: VectorFilter | undefined;
+};
+type DynamicToolRegistration = {
+    index: VectorSearchIndex<ToolSearchDocument>;
+    options: DynamicToolOptions;
+};
+declare class Agent<M extends CompletionModel = CompletionModel> {
+    readonly id: string;
+    readonly name: string | undefined;
+    readonly description: string | undefined;
+    readonly model: M;
+    readonly instructions: string | undefined;
+    readonly staticContext: Document[];
+    readonly temperature: number | undefined;
+    readonly maxTokens: number | undefined;
+    readonly additionalParams: JsonValue | undefined;
+    readonly toolSet: ToolSet;
+    readonly toolChoice: ToolChoice | undefined;
+    readonly defaultMaxTurns: number | undefined;
+    readonly hook: PromptHook | undefined;
+    readonly outputSchema: JsonObject | undefined;
+    readonly observers: AgentObserverRegistration[];
+    readonly dynamicContexts: DynamicContextRegistration[];
+    readonly dynamicTools: DynamicToolRegistration[];
+    constructor(options: AgentOptions<M>);
+    prompt(prompt: string | Message): PromptRequest<M>;
+    asTool(options: AgentToolOptions): Tool<{
+        prompt: string;
+    }, string>;
+    getTool(toolName: string): AnyTool | undefined;
+    callTool(toolName: string, args: string): Promise<string>;
+}
+
+export { Agent as A, type CompletionCallHookArgs as C, DEFAULT_MAX_TURNS as D, type HookAction as H, type PromptHook as P, type RunControl as R, type ToolCallControl as T, type AgentOptions as a, type AgentStreamEvent as b, type AgentToolOptions as c, type CompletionResponseHookArgs as d, type DynamicContextOptions as e, type DynamicContextRegistration as f, type DynamicToolOptions as g, type DynamicToolRegistration as h, type HookResult as i, PromptRequest as j, type PromptResponse as k, type ToolCallHookAction as l, type ToolCallHookArgs as m, type ToolCallHookResult as n, type ToolHookArgs as o, type ToolResultHookArgs as p, cancelPrompt as q, createHook as r, runControl as s, skipTool as t, toolCallControl as u };

package/dist/audio-generation/index.d.ts

@@ -0,0 +1,32 @@
+import { j as JsonValue } from '../types-BrxLd7ay.js';
+
+type AudioGenerationRequest = {
+    text: string;
+    voice: string;
+    speed: number;
+    additionalParams?: JsonValue | undefined;
+};
+type AudioGenerationResponse<RawResponse = unknown> = {
+    audio: Uint8Array;
+    mediaType?: string | undefined;
+    rawResponse: RawResponse;
+};
+interface AudioGenerationModel<RawResponse = unknown> {
+    readonly provider?: string | undefined;
+    readonly defaultModel?: string | undefined;
+    audioGeneration(request: AudioGenerationRequest): Promise<AudioGenerationResponse<RawResponse>>;
+}
+declare class AudioGenerationRequestBuilder<Model extends AudioGenerationModel = AudioGenerationModel> {
+    private readonly model;
+    private request;
+    constructor(model: Model);
+    text(text: string): this;
+    voice(voice: string): this;
+    speed(speed: number): this;
+    additionalParams(additionalParams: JsonValue): this;
+    build(): AudioGenerationRequest;
+    send(): Promise<Awaited<ReturnType<Model["audioGeneration"]>>>;
+}
+declare function audioGenerationRequest<Model extends AudioGenerationModel>(model: Model): AudioGenerationRequestBuilder<Model>;
+
+export { type AudioGenerationModel, type AudioGenerationRequest, AudioGenerationRequestBuilder, type AudioGenerationResponse, audioGenerationRequest };

package/dist/audio-generation/index.js

@@ -0,0 +1,9 @@
+import {
+  AudioGenerationRequestBuilder,
+  audioGenerationRequest
+} from "../chunk-I77SDTFE.js";
+export {
+  AudioGenerationRequestBuilder,
+  audioGenerationRequest
+};
+//# sourceMappingURL=index.js.map

package/dist/audio-generation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-7QI6ZAFI.js

@@ -0,0 +1,61 @@
+// src/transcription/index.ts
+var TranscriptionRequestBuilder = class {
+  constructor(model) {
+    this.model = model;
+  }
+  model;
+  request = {
+    data: new Uint8Array(),
+    filename: "file"
+  };
+  data(data) {
+    this.request = { ...this.request, data: toUint8Array(data) };
+    return this;
+  }
+  filename(filename) {
+    this.request = { ...this.request, filename };
+    return this;
+  }
+  language(language) {
+    this.request = { ...this.request, language };
+    return this;
+  }
+  prompt(prompt) {
+    this.request = { ...this.request, prompt };
+    return this;
+  }
+  temperature(temperature) {
+    this.request = { ...this.request, temperature };
+    return this;
+  }
+  additionalParams(additionalParams) {
+    this.request = { ...this.request, additionalParams };
+    return this;
+  }
+  build() {
+    if (this.request.data.byteLength === 0) {
+      throw new Error("Transcription data cannot be empty.");
+    }
+    return { ...this.request, data: toUint8Array(this.request.data) };
+  }
+  send() {
+    return this.model.transcription(this.build());
+  }
+};
+function transcriptionRequest(model) {
+  return new TranscriptionRequestBuilder(model);
+}
+function toUint8Array(bytes) {
+  if (bytes instanceof Uint8Array) {
+    return new Uint8Array(
+      bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)
+    );
+  }
+  return new Uint8Array(bytes);
+}
+
+export {
+  TranscriptionRequestBuilder,
+  transcriptionRequest
+};
+//# sourceMappingURL=chunk-7QI6ZAFI.js.map

package/dist/chunk-7QI6ZAFI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transcription/index.ts"],"sourcesContent":["import type { JsonValue } from \"../completion\";\n\nexport type TranscriptionRequest = {\n  data: Uint8Array;\n  filename: string;\n  language?: string | undefined;\n  prompt?: string | undefined;\n  temperature?: number | undefined;\n  additionalParams?: JsonValue | undefined;\n};\n\nexport type TranscriptionResponse<RawResponse = unknown> = {\n  text: string;\n  rawResponse: RawResponse;\n};\n\nexport interface TranscriptionModel<RawResponse = unknown> {\n  readonly provider?: string | undefined;\n  readonly defaultModel?: string | undefined;\n  transcription(request: TranscriptionRequest): Promise<TranscriptionResponse<RawResponse>>;\n}\n\nexport class TranscriptionRequestBuilder<Model extends TranscriptionModel = TranscriptionModel> {\n  private request: TranscriptionRequest = {\n    data: new Uint8Array(),\n    filename: \"file\",\n  };\n\n  constructor(private readonly model: Model) {}\n\n  data(data: Uint8Array | ArrayBuffer): this {\n    this.request = { ...this.request, data: toUint8Array(data) };\n    return this;\n  }\n\n  filename(filename: string): this {\n    this.request = { ...this.request, filename };\n    return this;\n  }\n\n  language(language: string): this {\n    this.request = { ...this.request, language };\n    return this;\n  }\n\n  prompt(prompt: string): this {\n    this.request = { ...this.request, prompt };\n    return this;\n  }\n\n  temperature(temperature: number): this {\n    this.request = { ...this.request, temperature };\n    return this;\n  }\n\n  additionalParams(additionalParams: JsonValue): this {\n    this.request = { ...this.request, additionalParams };\n    return this;\n  }\n\n  build(): TranscriptionRequest {\n    if (this.request.data.byteLength === 0) {\n      throw new Error(\"Transcription data cannot be empty.\");\n    }\n    return { ...this.request, data: toUint8Array(this.request.data) };\n  }\n\n  send(): Promise<Awaited<ReturnType<Model[\"transcription\"]>>> {\n    return this.model.transcription(this.build()) as Promise<\n      Awaited<ReturnType<Model[\"transcription\"]>>\n    >;\n  }\n}\n\nexport function transcriptionRequest<Model extends TranscriptionModel>(\n  model: Model,\n): TranscriptionRequestBuilder<Model> {\n  return new TranscriptionRequestBuilder(model);\n}\n\nfunction toUint8Array(bytes: Uint8Array | ArrayBuffer): Uint8Array {\n  if (bytes instanceof Uint8Array) {\n    return new Uint8Array(\n      bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength),\n    );\n  }\n  return new Uint8Array(bytes);\n}\n"],"mappings":";AAsBO,IAAM,8BAAN,MAAyF;AAAA,EAM9F,YAA6B,OAAc;AAAd;AAAA,EAAe;AAAA,EAAf;AAAA,EALrB,UAAgC;AAAA,IACtC,MAAM,IAAI,WAAW;AAAA,IACrB,UAAU;AAAA,EACZ;AAAA,EAIA,KAAK,MAAsC;AACzC,SAAK,UAAU,EAAE,GAAG,KAAK,SAAS,MAAM,aAAa,IAAI,EAAE;AAC3D,WAAO;AAAA,EACT;AAAA,EAEA,SAAS,UAAwB;AAC/B,SAAK,UAAU,EAAE,GAAG,KAAK,SAAS,SAAS;AAC3C,WAAO;AAAA,EACT;AAAA,EAEA,SAAS,UAAwB;AAC/B,SAAK,UAAU,EAAE,GAAG,KAAK,SAAS,SAAS;AAC3C,WAAO;AAAA,EACT;AAAA,EAEA,OAAO,QAAsB;AAC3B,SAAK,UAAU,EAAE,GAAG,KAAK,SAAS,OAAO;AACzC,WAAO;AAAA,EACT;AAAA,EAEA,YAAY,aAA2B;AACrC,SAAK,UAAU,EAAE,GAAG,KAAK,SAAS,YAAY;AAC9C,WAAO;AAAA,EACT;AAAA,EAEA,iBAAiB,kBAAmC;AAClD,SAAK,UAAU,EAAE,GAAG,KAAK,SAAS,iBAAiB;AACnD,WAAO;AAAA,EACT;AAAA,EAEA,QAA8B;AAC5B,QAAI,KAAK,QAAQ,KAAK,eAAe,GAAG;AACtC,YAAM,IAAI,MAAM,qCAAqC;AAAA,IACvD;AACA,WAAO,EAAE,GAAG,KAAK,SAAS,MAAM,aAAa,KAAK,QAAQ,IAAI,EAAE;AAAA,EAClE;AAAA,EAEA,OAA6D;AAC3D,WAAO,KAAK,MAAM,cAAc,KAAK,MAAM,CAAC;AAAA,EAG9C;AACF;AAEO,SAAS,qBACd,OACoC;AACpC,SAAO,IAAI,4BAA4B,KAAK;AAC9C;AAEA,SAAS,aAAa,OAA6C;AACjE,MAAI,iBAAiB,YAAY;AAC/B,WAAO,IAAI;AAAA,MACT,MAAM,OAAO,MAAM,MAAM,YAAY,MAAM,aAAa,MAAM,UAAU;AAAA,IAC1E;AAAA,EACF;AACA,SAAO,IAAI,WAAW,KAAK;AAC7B;","names":[]}

package/dist/chunk-A7VDIZQN.js

@@ -0,0 +1,145 @@
+// src/embeddings/index.ts
+async function embedText(model, text) {
+  const embeddings = await embedTexts(model, [text]);
+  const embedding = embeddings[0];
+  if (embedding === void 0) {
+    throw new Error("Embedding model returned no embeddings");
+  }
+  return embedding;
+}
+async function embedTexts(model, texts) {
+  if (texts.length === 0) {
+    return [];
+  }
+  const maxBatchSize = Math.max(1, Math.trunc(model.maxBatchSize ?? texts.length));
+  const batches = [];
+  for (let index = 0; index < texts.length; index += maxBatchSize) {
+    batches.push(texts.slice(index, index + maxBatchSize));
+  }
+  const results = await mapWithConcurrency(batches, 1, (batch) => model.embedTexts(batch));
+  const embeddings = results.flat();
+  if (embeddings.length !== texts.length) {
+    throw new Error(
+      `Embedding model returned ${embeddings.length} embeddings for ${texts.length} texts`
+    );
+  }
+  return embeddings;
+}
+async function embedDocuments(model, documents, options) {
+  const prepared = documents.map((document, index) => {
+    const content = options.content(document, index);
+    const texts = Array.isArray(content) ? content : [content];
+    return {
+      id: options.id?.(document, index) ?? `doc${index}`,
+      document,
+      metadata: options.metadata?.(document, index),
+      texts
+    };
+  });
+  const flatTexts = prepared.flatMap(
+    (item, documentIndex) => item.texts.map((text) => ({ documentIndex, text }))
+  );
+  const embeddings = await mapWithConcurrency(
+    chunk(flatTexts, Math.max(1, Math.trunc(model.maxBatchSize ?? (flatTexts.length || 1)))),
+    Math.max(1, Math.trunc(options.concurrency ?? 1)),
+    async (batch) => {
+      const batchEmbeddings = await model.embedTexts(batch.map((item) => item.text));
+      if (batchEmbeddings.length !== batch.length) {
+        throw new Error(
+          `Embedding model returned ${batchEmbeddings.length} embeddings for ${batch.length} texts`
+        );
+      }
+      return batch.map((item, index) => ({
+        documentIndex: item.documentIndex,
+        embedding: batchEmbeddings[index]
+      }));
+    }
+  );
+  const byDocument = /* @__PURE__ */ new Map();
+  for (const item of embeddings.flat()) {
+    const list = byDocument.get(item.documentIndex) ?? [];
+    list.push(item.embedding);
+    byDocument.set(item.documentIndex, list);
+  }
+  return prepared.map((item, index) => ({
+    id: item.id,
+    document: item.document,
+    ...item.metadata === void 0 ? {} : { metadata: item.metadata },
+    embeddings: byDocument.get(index) ?? []
+  }));
+}
+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}`);
+  }
+}
+function chunk(items, size) {
+  const chunks = [];
+  for (let index = 0; index < items.length; index += size) {
+    chunks.push(items.slice(index, index + size));
+  }
+  return chunks;
+}
+async function mapWithConcurrency(items, concurrency, mapper) {
+  const results = new Array(items.length);
+  let next = 0;
+  async function worker() {
+    while (next < items.length) {
+      const index = next;
+      next += 1;
+      results[index] = await mapper(items[index]);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+  return results;
+}
+
+export {
+  embedText,
+  embedTexts,
+  embedDocuments,
+  dotProduct,
+  cosineSimilarity,
+  angularDistance,
+  euclideanDistance,
+  manhattanDistance,
+  chebyshevDistance
+};
+//# sourceMappingURL=chunk-A7VDIZQN.js.map