@anvia/core 0.1.0

package/dist/evals/index.js

@@ -0,0 +1,30 @@
+import {
+  EvalOutcome,
+  agentEvalTarget,
+  contains,
+  exactMatch,
+  llmJudge,
+  llmScore,
+  runEvalSuite,
+  semanticSimilarity
+} from "../chunk-LMBOJMNB.js";
+import "../chunk-IA76K5UX.js";
+import "../chunk-X6FBOU2P.js";
+import "../chunk-SRGJPXKT.js";
+import "../chunk-IQBY2GCF.js";
+import "../chunk-XUUY2L2D.js";
+import "../chunk-GNWMOSNR.js";
+import "../chunk-B4QHQN5K.js";
+import "../chunk-CP47FBJV.js";
+import "../chunk-A7VDIZQN.js";
+export {
+  EvalOutcome,
+  agentEvalTarget,
+  contains,
+  exactMatch,
+  llmJudge,
+  llmScore,
+  runEvalSuite,
+  semanticSimilarity
+};
+//# sourceMappingURL=index.js.map

package/dist/evals/index.js.map

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

package/dist/extractor/index.d.ts

@@ -0,0 +1,45 @@
+import { A as Agent } from '../agent-C6h6YrRU.js';
+import { U as Usage, M as Message, b as CompletionModel, j as JsonValue, o as ToolChoice } from '../types-BrxLd7ay.js';
+import { Z as ZodSchema } from '../zod-schema-DJTEgQBq.js';
+import '../observability/index.js';
+import '../tool-DhuBQ3yb.js';
+import '../vector-store/index.js';
+import '../embeddings/index.js';
+import 'zod';
+
+type ExtractionResponse<T> = {
+    data: T;
+    usage: Usage;
+    messages: Message[];
+};
+declare class ExtractionError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+declare class Extractor<T, M extends CompletionModel = CompletionModel> {
+    private readonly agent;
+    private readonly schema;
+    private readonly retryCount;
+    constructor(agent: Agent<M>, schema: ZodSchema<T>, retryCount: number);
+    extract(text: string | Message): Promise<T>;
+    extractWithUsage(text: string | Message): Promise<ExtractionResponse<T>>;
+    extractWithHistory(text: string | Message, history: Message[]): Promise<T>;
+    getInner(): Agent<M>;
+    private run;
+}
+declare class ExtractorBuilder<T, M extends CompletionModel = CompletionModel> {
+    private readonly schema;
+    private readonly agentBuilder;
+    private retryCount;
+    constructor(model: M, schema: ZodSchema<T>);
+    instructions(instructions: string): this;
+    context(text: string, id?: string): this;
+    temperature(temperature: number): this;
+    maxTokens(maxTokens: number): this;
+    additionalParams(params: JsonValue): this;
+    toolChoice(toolChoice: ToolChoice): this;
+    retries(retries: number): this;
+    build(): Extractor<T, M>;
+}
+
+export { ExtractionError, type ExtractionResponse, Extractor, ExtractorBuilder };

package/dist/extractor/index.js

@@ -0,0 +1,19 @@
+import {
+  ExtractionError,
+  Extractor,
+  ExtractorBuilder
+} from "../chunk-IA76K5UX.js";
+import "../chunk-X6FBOU2P.js";
+import "../chunk-SRGJPXKT.js";
+import "../chunk-IQBY2GCF.js";
+import "../chunk-XUUY2L2D.js";
+import "../chunk-GNWMOSNR.js";
+import "../chunk-B4QHQN5K.js";
+import "../chunk-CP47FBJV.js";
+import "../chunk-A7VDIZQN.js";
+export {
+  ExtractionError,
+  Extractor,
+  ExtractorBuilder
+};
+//# sourceMappingURL=index.js.map

package/dist/extractor/index.js.map

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

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

@@ -0,0 +1,37 @@
+import { j as JsonValue } from '../types-BrxLd7ay.js';
+
+type ImageGenerationRequest = {
+    prompt: string;
+    width: number;
+    height: number;
+    additionalParams?: JsonValue | undefined;
+};
+type GeneratedImage = {
+    data: Uint8Array;
+    mediaType?: string | undefined;
+};
+type ImageGenerationResponse<RawResponse = unknown> = {
+    image: Uint8Array;
+    images: GeneratedImage[];
+    mediaType?: string | undefined;
+    rawResponse: RawResponse;
+};
+interface ImageGenerationModel<RawResponse = unknown> {
+    readonly provider?: string | undefined;
+    readonly defaultModel?: string | undefined;
+    imageGeneration(request: ImageGenerationRequest): Promise<ImageGenerationResponse<RawResponse>>;
+}
+declare class ImageGenerationRequestBuilder<Model extends ImageGenerationModel = ImageGenerationModel> {
+    private readonly model;
+    private request;
+    constructor(model: Model);
+    prompt(prompt: string): this;
+    width(width: number): this;
+    height(height: number): this;
+    additionalParams(additionalParams: JsonValue): this;
+    build(): ImageGenerationRequest;
+    send(): Promise<Awaited<ReturnType<Model["imageGeneration"]>>>;
+}
+declare function imageGenerationRequest<Model extends ImageGenerationModel>(model: Model): ImageGenerationRequestBuilder<Model>;
+
+export { type GeneratedImage, type ImageGenerationModel, type ImageGenerationRequest, ImageGenerationRequestBuilder, type ImageGenerationResponse, imageGenerationRequest };

package/dist/image-generation/index.js

@@ -0,0 +1,9 @@
+import {
+  ImageGenerationRequestBuilder,
+  imageGenerationRequest
+} from "../chunk-B24Q2ZYM.js";
+export {
+  ImageGenerationRequestBuilder,
+  imageGenerationRequest
+};
+//# sourceMappingURL=index.js.map

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

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

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+export { A as Agent, a as AgentOptions, b as AgentStreamEvent, c as AgentToolOptions, C as CompletionCallHookArgs, d as CompletionResponseHookArgs, D as DEFAULT_MAX_TURNS, e as DynamicContextOptions, f as DynamicContextRegistration, g as DynamicToolOptions, h as DynamicToolRegistration, H as HookAction, i as HookResult, P as PromptHook, 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';
+export { AgentBuilder, MaxTurnsError, PromptCancelledError } from './agent/index.js';
+export { AudioGenerationModel, AudioGenerationRequest, AudioGenerationRequestBuilder, AudioGenerationResponse, audioGenerationRequest } from './audio-generation/index.js';
+export { CompletionRequestBuilder, formatDocument, normalizeDocuments } from './completion/index.js';
+export { A as AssistantContent, a as AssistantMessage, C as CompletionCapabilityError, b as CompletionModel, c as CompletionModelCapabilities, d as CompletionRequest, e as CompletionResponse, f as CompletionStreamEvent, D as Document, g as DocumentContent, I as ImageContent, h as ImageDetail, J as JsonObject, i as JsonPrimitive, j as JsonValue, M as Message, R as Reasoning, k as ReasoningContent, l as ReasoningContentType, S as StreamingCompletionModel, m as SystemMessage, T as Text, n as ToolCall, o as ToolChoice, p as ToolContent, q as ToolDefinition, r as ToolFunction, s as ToolMessage, t as ToolResult, u as ToolResultContent, U as Usage, v as UserContent, w as UserMessage, x as assertCompletionRequestSupported, y as reasoningDisplayText, z as textFromAssistantContent } from './types-BrxLd7ay.js';
+export { EmbedDocumentsOptions, EmbeddedDocument, Embedding, EmbeddingModel, VectorMetadata, VectorMetadataValue, angularDistance, chebyshevDistance, cosineSimilarity, dotProduct, embedDocuments, embedText, embedTexts, euclideanDistance, manhattanDistance } from './embeddings/index.js';
+export { AgentEvalTargetOptions, ContainsOptions, EvalCase, EvalCaseResult, EvalMetadata, EvalMetric, EvalMetricArgs, EvalMetricResult, EvalOutcome, EvalOutcomeStatus, EvalReportArgs, EvalReporter, EvalSuiteResult, EvalTarget, ExactMatchOptions, LlmJudgeOptions, LlmScoreMetricScore, LlmScoreOptions, RunEvalSuiteOptions, SelectorOrValue, SemanticSimilarityOptions, ValueSelector, agentEvalTarget, contains, exactMatch, llmJudge, llmScore, runEvalSuite, semanticSimilarity } from './evals/index.js';
+export { ExtractionError, ExtractionResponse, Extractor, ExtractorBuilder } from './extractor/index.js';
+export { GeneratedImage, ImageGenerationModel, ImageGenerationRequest, ImageGenerationRequestBuilder, ImageGenerationResponse, imageGenerationRequest } from './image-generation/index.js';
+export { connectMcp, mcp } from './mcp/index.js';
+export { M as McpClient, a as McpConnection, b as McpHttpOptions, c as McpServer, d as McpStdioOptions, e as McpToolCallContent, f as McpToolCallResult, g as McpToolDefinition } from './types-B5B8Sdl4.js';
+export { AgentGenerationEndArgs, AgentGenerationErrorArgs, AgentGenerationObserver, AgentGenerationStartArgs, AgentObserver, AgentObserverRegistration, AgentRunEndArgs, AgentRunErrorArgs, AgentRunObserver, AgentRunStartArgs, AgentToolEndArgs, AgentToolErrorArgs, AgentToolObserver, AgentToolStartArgs, AgentTraceInfo, AgentTraceOptions, ObserveOptions, createObserver } from './observability/index.js';
+export { Pipeline, PipelineBatchOptions, PipelineBuilder, PipelineOp } from './pipeline/index.js';
+export { D as DynamicToolIndex, E as EmbedToolsOptions, T as ToolSearchDocument, a as ToolSet, Z as ZodSchema, c as createToolIndex, e as embedTools, i as isDynamicToolIndex } from './zod-schema-DJTEgQBq.js';
+export { loadSkills, skill } from './skills/index.js';
+export { S as Skill, a as SkillLoader, b as SkillSet, c as SkillValidationError, d as SkillValidationIssue } from './types-HvopERm0.js';
+export { ReadableStreamOptions, toReadableStream } from './streaming/index.js';
+export { CreateThinkToolOptions, CreateToolOptions, ToolCallError, ToolJsonError, ToolNotFoundError, createThinkTool, createTool } from './tool/index.js';
+export { A as AnyTool, T as Tool, a as ToolApprovalContext, b as ToolApprovalPolicy, c as ToolApprovalRunContext, p as parseToolArgs, s as serializeToolOutput } from './tool-DhuBQ3yb.js';
+export { TranscriptionModel, TranscriptionRequest, TranscriptionRequestBuilder, TranscriptionResponse, transcriptionRequest } from './transcription/index.js';
+export { InMemoryVectorIndex, InMemoryVectorStore, IndexStrategy, VectorFilter, VectorSearchIndex, VectorSearchRequest, VectorSearchResult, VectorSearchToolOptions, createVectorSearchTool, vectorFilter } from './vector-store/index.js';
+import '@modelcontextprotocol/sdk/client/stdio.js';
+import '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import 'zod';

package/dist/index.js

@@ -0,0 +1,183 @@
+import {
+  connectMcp,
+  mcp
+} from "./chunk-WZTPK5HV.js";
+import {
+  createObserver
+} from "./chunk-S55WOHX5.js";
+import {
+  Pipeline,
+  PipelineBuilder
+} from "./chunk-FI2BTRT5.js";
+import {
+  SkillValidationError,
+  loadSkills,
+  skill
+} from "./chunk-KSIY7KJA.js";
+import {
+  TranscriptionRequestBuilder,
+  transcriptionRequest
+} from "./chunk-7QI6ZAFI.js";
+import {
+  AudioGenerationRequestBuilder,
+  audioGenerationRequest
+} from "./chunk-I77SDTFE.js";
+import {
+  EvalOutcome,
+  agentEvalTarget,
+  contains,
+  exactMatch,
+  llmJudge,
+  llmScore,
+  runEvalSuite,
+  semanticSimilarity
+} from "./chunk-LMBOJMNB.js";
+import {
+  ExtractionError,
+  Extractor,
+  ExtractorBuilder
+} from "./chunk-IA76K5UX.js";
+import {
+  createThinkTool,
+  createToolIndex,
+  embedTools,
+  isDynamicToolIndex
+} from "./chunk-X6FBOU2P.js";
+import {
+  InMemoryVectorIndex,
+  InMemoryVectorStore,
+  createVectorSearchTool,
+  vectorFilter
+} from "./chunk-SRGJPXKT.js";
+import {
+  Agent,
+  AgentBuilder,
+  DEFAULT_MAX_TURNS,
+  MaxTurnsError,
+  PromptCancelledError,
+  PromptRequest,
+  cancelPrompt,
+  createHook,
+  runControl,
+  skipTool,
+  toolCallControl
+} from "./chunk-IQBY2GCF.js";
+import {
+  toReadableStream
+} from "./chunk-XUUY2L2D.js";
+import {
+  ToolCallError,
+  ToolJsonError,
+  ToolNotFoundError,
+  ToolSet,
+  parseToolArgs,
+  serializeToolOutput
+} from "./chunk-GNWMOSNR.js";
+import {
+  createTool
+} from "./chunk-B4QHQN5K.js";
+import {
+  AssistantContent,
+  CompletionCapabilityError,
+  CompletionRequestBuilder,
+  Message,
+  ToolContent,
+  Usage,
+  UserContent,
+  assertCompletionRequestSupported,
+  formatDocument,
+  normalizeDocuments,
+  reasoningDisplayText,
+  textFromAssistantContent
+} from "./chunk-CP47FBJV.js";
+import {
+  angularDistance,
+  chebyshevDistance,
+  cosineSimilarity,
+  dotProduct,
+  embedDocuments,
+  embedText,
+  embedTexts,
+  euclideanDistance,
+  manhattanDistance
+} from "./chunk-A7VDIZQN.js";
+import {
+  ImageGenerationRequestBuilder,
+  imageGenerationRequest
+} from "./chunk-B24Q2ZYM.js";
+export {
+  Agent,
+  AgentBuilder,
+  AssistantContent,
+  AudioGenerationRequestBuilder,
+  CompletionCapabilityError,
+  CompletionRequestBuilder,
+  DEFAULT_MAX_TURNS,
+  EvalOutcome,
+  ExtractionError,
+  Extractor,
+  ExtractorBuilder,
+  ImageGenerationRequestBuilder,
+  InMemoryVectorIndex,
+  InMemoryVectorStore,
+  MaxTurnsError,
+  Message,
+  Pipeline,
+  PipelineBuilder,
+  PromptCancelledError,
+  PromptRequest,
+  SkillValidationError,
+  ToolCallError,
+  ToolContent,
+  ToolJsonError,
+  ToolNotFoundError,
+  ToolSet,
+  TranscriptionRequestBuilder,
+  Usage,
+  UserContent,
+  agentEvalTarget,
+  angularDistance,
+  assertCompletionRequestSupported,
+  audioGenerationRequest,
+  cancelPrompt,
+  chebyshevDistance,
+  connectMcp,
+  contains,
+  cosineSimilarity,
+  createHook,
+  createObserver,
+  createThinkTool,
+  createTool,
+  createToolIndex,
+  createVectorSearchTool,
+  dotProduct,
+  embedDocuments,
+  embedText,
+  embedTexts,
+  embedTools,
+  euclideanDistance,
+  exactMatch,
+  formatDocument,
+  imageGenerationRequest,
+  isDynamicToolIndex,
+  llmJudge,
+  llmScore,
+  loadSkills,
+  manhattanDistance,
+  mcp,
+  normalizeDocuments,
+  parseToolArgs,
+  reasoningDisplayText,
+  runControl,
+  runEvalSuite,
+  semanticSimilarity,
+  serializeToolOutput,
+  skill,
+  skipTool,
+  textFromAssistantContent,
+  toReadableStream,
+  toolCallControl,
+  transcriptionRequest,
+  vectorFilter
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/dist/loaders/index.d.ts

@@ -0,0 +1,82 @@
+import { D as Document } from '../types-BrxLd7ay.js';
+
+type LoaderResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: unknown;
+};
+type FileSource = {
+    path: string;
+} | {
+    path: "<memory>";
+    bytes: Uint8Array;
+};
+type FileReadWithPath = {
+    path: string;
+    text: string;
+};
+type PdfSource = {
+    path: string;
+} | {
+    path: "<memory>";
+    bytes: Uint8Array;
+};
+type PdfReadWithPath = {
+    path: string;
+    text: string;
+};
+type PdfPage = {
+    pageNumber: number;
+    text: string;
+};
+type PdfPageWithPath = {
+    path: string;
+    pageNumber: number;
+    text: string;
+};
+declare class FileLoader<T = LoaderResult<FileSource>> implements AsyncIterable<T> {
+    private readonly source;
+    private readonly mode;
+    private readonly skipErrors;
+    private constructor();
+    static withGlob(pattern: string): FileLoader<LoaderResult<FileSource>>;
+    static withDir(directory: string): FileLoader<LoaderResult<FileSource>>;
+    static fromBytes(bytes: Uint8Array | ArrayBuffer): FileLoader<LoaderResult<FileSource>>;
+    static fromBytesMany(bytes: Array<Uint8Array | ArrayBuffer>): FileLoader<LoaderResult<FileSource>>;
+    read(): FileLoader<LoaderResult<string>>;
+    readWithPath(): FileLoader<LoaderResult<FileReadWithPath>>;
+    ignoreErrors(): FileLoader<UnwrapLoaderResult<T>>;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+declare class PdfFileLoader<T = LoaderResult<PdfSource>> implements AsyncIterable<T> {
+    private readonly source;
+    private readonly mode;
+    private readonly skipErrors;
+    private constructor();
+    static withGlob(pattern: string): PdfFileLoader<LoaderResult<PdfSource>>;
+    static withDir(directory: string): PdfFileLoader<LoaderResult<PdfSource>>;
+    static fromBytes(bytes: Uint8Array | ArrayBuffer): PdfFileLoader<LoaderResult<PdfSource>>;
+    static fromBytesMany(bytes: Array<Uint8Array | ArrayBuffer>): PdfFileLoader<LoaderResult<PdfSource>>;
+    read(): PdfFileLoader<LoaderResult<string>>;
+    readWithPath(): PdfFileLoader<LoaderResult<PdfReadWithPath>>;
+    byPage(this: PdfFileLoader<LoaderResult<PdfReadWithPath>>): PdfFileLoader<LoaderResult<PdfPageWithPath>>;
+    byPage(this: PdfFileLoader<PdfReadWithPath>): PdfFileLoader<PdfPageWithPath>;
+    byPage(): PdfFileLoader<LoaderResult<PdfPage>>;
+    ignoreErrors(): PdfFileLoader<UnwrapLoaderResult<T>>;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+declare function fileToDocument(file: FileReadWithPath): Document;
+declare function fileLoaderToDocuments(loader: AsyncIterable<FileReadWithPath>): Promise<Document[]>;
+declare function pdfToDocument(pdf: PdfReadWithPath): Document;
+declare function pdfLoaderToDocuments(loader: AsyncIterable<PdfReadWithPath>): Promise<Document[]>;
+declare function pdfPageToDocument(page: PdfPageWithPath): Document;
+declare function pdfPageLoaderToDocuments(loader: AsyncIterable<PdfPageWithPath>): Promise<Document[]>;
+type LoaderValue<T> = T extends {
+    ok: true;
+    value: infer Value;
+} ? Value : never;
+type UnwrapLoaderResult<T> = [LoaderValue<T>] extends [never] ? T : LoaderValue<T>;
+
+export { FileLoader, type FileReadWithPath, type FileSource, type LoaderResult, PdfFileLoader, type PdfPage, type PdfPageWithPath, type PdfReadWithPath, type PdfSource, fileLoaderToDocuments, fileToDocument, pdfLoaderToDocuments, pdfPageLoaderToDocuments, pdfPageToDocument, pdfToDocument };