@anvia/core 0.1.0

package/dist/tool-DhuBQ3yb.d.ts

@@ -0,0 +1,35 @@
+import { J as JsonObject, q as ToolDefinition, j as JsonValue } from './types-BrxLd7ay.js';
+
+type ToolApprovalRunContext = {
+    agentId: string;
+    runId: string;
+    sessionId?: string;
+    metadata?: JsonObject;
+};
+type ToolApprovalContext<Args = unknown> = {
+    toolName: string;
+    args: Args;
+    rawArgs: string;
+    toolCallId?: string;
+    internalCallId: string;
+    run: ToolApprovalRunContext;
+};
+type ToolApprovalPolicy<Args = unknown> = {
+    when(ctx: ToolApprovalContext<Args>): boolean | Promise<boolean>;
+    reason?: string | ((ctx: ToolApprovalContext<Args>) => string | Promise<string>);
+    rejectMessage?: string | ((ctx: ToolApprovalContext<Args>) => string | Promise<string>);
+};
+interface Tool<Args = unknown, Output = unknown> {
+    readonly name: string;
+    readonly approval?: ToolApprovalPolicy<Args>;
+    definition(prompt: string): ToolDefinition | Promise<ToolDefinition>;
+    call(args: Args): Output | Promise<Output>;
+    parseApprovalArgs?(args: unknown): Args;
+}
+type AnyTool = Omit<Tool<unknown, unknown>, "approval"> & {
+    readonly approval?: unknown;
+};
+declare function serializeToolOutput(output: unknown): string;
+declare function parseToolArgs(args: string): JsonValue;
+
+export { type AnyTool as A, type Tool as T, type ToolApprovalContext as a, type ToolApprovalPolicy as b, type ToolApprovalRunContext as c, parseToolArgs as p, serializeToolOutput as s };

package/dist/transcription/index.d.ts

@@ -0,0 +1,35 @@
+import { j as JsonValue } from '../types-BrxLd7ay.js';
+
+type TranscriptionRequest = {
+    data: Uint8Array;
+    filename: string;
+    language?: string | undefined;
+    prompt?: string | undefined;
+    temperature?: number | undefined;
+    additionalParams?: JsonValue | undefined;
+};
+type TranscriptionResponse<RawResponse = unknown> = {
+    text: string;
+    rawResponse: RawResponse;
+};
+interface TranscriptionModel<RawResponse = unknown> {
+    readonly provider?: string | undefined;
+    readonly defaultModel?: string | undefined;
+    transcription(request: TranscriptionRequest): Promise<TranscriptionResponse<RawResponse>>;
+}
+declare class TranscriptionRequestBuilder<Model extends TranscriptionModel = TranscriptionModel> {
+    private readonly model;
+    private request;
+    constructor(model: Model);
+    data(data: Uint8Array | ArrayBuffer): this;
+    filename(filename: string): this;
+    language(language: string): this;
+    prompt(prompt: string): this;
+    temperature(temperature: number): this;
+    additionalParams(additionalParams: JsonValue): this;
+    build(): TranscriptionRequest;
+    send(): Promise<Awaited<ReturnType<Model["transcription"]>>>;
+}
+declare function transcriptionRequest<Model extends TranscriptionModel>(model: Model): TranscriptionRequestBuilder<Model>;
+
+export { type TranscriptionModel, type TranscriptionRequest, TranscriptionRequestBuilder, type TranscriptionResponse, transcriptionRequest };

package/dist/transcription/index.js

@@ -0,0 +1,9 @@
+import {
+  TranscriptionRequestBuilder,
+  transcriptionRequest
+} from "../chunk-7QI6ZAFI.js";
+export {
+  TranscriptionRequestBuilder,
+  transcriptionRequest
+};
+//# sourceMappingURL=index.js.map

package/dist/transcription/index.js.map

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

package/dist/types-B5B8Sdl4.d.ts

@@ -0,0 +1,64 @@
+import { StdioServerParameters } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransportOptions } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { J as JsonObject } from './types-BrxLd7ay.js';
+import { A as AnyTool } from './tool-DhuBQ3yb.js';
+
+type McpToolDefinition = {
+    name: string;
+    description?: string | undefined;
+    inputSchema: JsonObject;
+};
+type McpToolCallContent = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+} | {
+    type: "resource";
+    resource: {
+        uri: string;
+        text: string;
+        mimeType?: string | undefined;
+    } | {
+        uri: string;
+        blob: string;
+        mimeType?: string | undefined;
+    };
+};
+type McpToolCallResult = {
+    content: McpToolCallContent[];
+    isError?: boolean | undefined;
+} | {
+    toolResult: unknown;
+};
+type McpClient = {
+    listTools(): Promise<{
+        tools: McpToolDefinition[];
+    }>;
+    callTool(params: {
+        name: string;
+        arguments?: Record<string, unknown>;
+    }): Promise<McpToolCallResult>;
+    close(): Promise<void>;
+};
+type McpConnection = {
+    readonly name: string;
+    connect(): Promise<McpClient>;
+};
+type McpServer = {
+    readonly name: string;
+    readonly tools: AnyTool[];
+    close(): Promise<void>;
+};
+type McpStdioOptions = StdioServerParameters & {
+    name: string;
+};
+type McpHttpOptions = {
+    name: string;
+    url: string | URL;
+    transport?: StreamableHTTPClientTransportOptions | undefined;
+};
+
+export type { McpClient as M, McpConnection as a, McpHttpOptions as b, McpServer as c, McpStdioOptions as d, McpToolCallContent as e, McpToolCallResult as f, McpToolDefinition as g };

package/dist/types-BrxLd7ay.d.ts

@@ -0,0 +1,250 @@
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+type JsonObject = {
+    [key: string]: JsonValue | undefined;
+};
+type Document = {
+    id: string;
+    text: string;
+    additionalProps?: Record<string, string>;
+};
+type Text = {
+    type: "text";
+    text: string;
+    signature?: string;
+};
+type ImageDetail = "auto" | "low" | "high";
+type ImageContent = {
+    type: "image";
+    source: {
+        type: "url";
+        url: string;
+    } | {
+        type: "base64";
+        data: string;
+        mediaType: string;
+    };
+    detail?: ImageDetail;
+};
+type DocumentContent = {
+    type: "document";
+    source: {
+        type: "url";
+        url: string;
+        mediaType: string;
+        filename?: string;
+    } | {
+        type: "base64";
+        data: string;
+        mediaType: string;
+        filename?: string;
+    } | {
+        type: "text";
+        text: string;
+        mediaType?: string;
+        filename?: string;
+    };
+};
+type Reasoning = {
+    type: "reasoning";
+    text: string;
+    id?: string;
+    content?: ReasoningContent[];
+};
+type ReasoningContent = {
+    type: "text";
+    text: string;
+    signature?: string;
+} | {
+    type: "summary";
+    text: string;
+} | {
+    type: "encrypted";
+    data: string;
+} | {
+    type: "redacted";
+    data: string;
+};
+type ReasoningContentType = ReasoningContent["type"];
+type ToolFunction = {
+    name: string;
+    arguments: JsonValue;
+};
+type ToolCall = {
+    type: "tool_call";
+    id: string;
+    callId?: string;
+    function: ToolFunction;
+    signature?: string;
+    additionalParams?: JsonValue;
+};
+type ToolResultContent = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    data: string;
+    mediaType?: string;
+};
+type ToolResult = {
+    type: "tool_result";
+    id: string;
+    callId?: string;
+    content: ToolResultContent[];
+};
+type SystemMessage = {
+    role: "system";
+    content: string;
+};
+type UserMessage = {
+    role: "user";
+    content: UserContent[];
+};
+type AssistantMessage = {
+    role: "assistant";
+    id?: string;
+    content: AssistantContent[];
+};
+type ToolMessage = {
+    role: "tool";
+    content: ToolContent[];
+};
+type UserContent = Text | ImageContent | DocumentContent;
+declare const UserContent: {
+    text(text: string): Text;
+    imageUrl(url: string, options?: {
+        detail?: ImageDetail;
+    }): ImageContent;
+    imageBase64(data: string, mediaType: string, options?: {
+        detail?: ImageDetail;
+    }): ImageContent;
+    documentUrl(url: string, mediaType: string, options?: {
+        filename?: string | undefined;
+    }): DocumentContent;
+    documentBase64(data: string, mediaType: string, options?: {
+        filename?: string | undefined;
+    }): DocumentContent;
+    documentText(text: string): Text;
+};
+type ToolContent = ToolResult;
+declare const ToolContent: {
+    toolResult(id: string, content: string | ToolResultContent[], callId?: string): ToolResult;
+};
+type AssistantContent = Text | ToolCall | Reasoning | ImageContent;
+declare const AssistantContent: {
+    text(text: string): Text;
+    imageUrl(url: string, options?: {
+        detail?: ImageDetail;
+    }): ImageContent;
+    imageBase64(data: string, mediaType: string, options?: {
+        detail?: ImageDetail;
+    }): ImageContent;
+    reasoning(text: string, id?: string): Reasoning;
+    reasoningFromContent(content: ReasoningContent[], id?: string): Reasoning;
+    reasoningSummary(text: string, id?: string): Reasoning;
+    reasoningEncrypted(data: string, id?: string): Reasoning;
+    reasoningRedacted(data: string, id?: string): Reasoning;
+    toolCall(id: string, name: string, args: JsonValue, callId?: string): ToolCall;
+};
+declare function reasoningDisplayText(reasoning: Reasoning | ReasoningContent[]): string;
+type Message = SystemMessage | UserMessage | AssistantMessage | ToolMessage;
+declare const Message: {
+    system(content: string): Message;
+    user(content: string | UserContent[]): Message;
+    assistant(content: string | AssistantContent[], id?: string): Message;
+    tool(content: ToolContent | ToolContent[]): Message;
+};
+type ToolChoice = "auto" | "required" | "none" | {
+    type: "function";
+    name: string;
+};
+type ToolDefinition = {
+    name: string;
+    description: string;
+    parameters: JsonObject;
+};
+type Usage = {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cachedInputTokens: number;
+    cacheCreationInputTokens: number;
+};
+declare const Usage: {
+    empty(): Usage;
+    add(left: Usage, right: Usage): Usage;
+};
+type CompletionRequest = {
+    model?: string;
+    instructions?: string;
+    chatHistory: Message[];
+    documents: Document[];
+    tools: ToolDefinition[];
+    temperature?: number;
+    maxTokens?: number;
+    toolChoice?: ToolChoice;
+    additionalParams?: JsonValue;
+    outputSchema?: JsonObject;
+};
+type CompletionResponse<RawResponse = unknown> = {
+    choice: AssistantContent[];
+    usage: Usage;
+    rawResponse: RawResponse;
+    messageId?: string;
+};
+type CompletionModelCapabilities = {
+    streaming: boolean;
+    tools: boolean;
+    toolChoice: boolean;
+    imageInput: boolean;
+    documentInput: boolean;
+    outputSchema: boolean;
+    reasoning: boolean;
+};
+interface CompletionModel<RawResponse = unknown> {
+    readonly provider: string;
+    readonly defaultModel: string;
+    readonly capabilities: CompletionModelCapabilities;
+    completion(request: CompletionRequest): Promise<CompletionResponse<RawResponse>>;
+}
+type CompletionStreamEvent<RawResponse = unknown> = {
+    type: "text_delta";
+    delta: string;
+} | {
+    type: "reasoning_delta";
+    delta: string;
+    id?: string;
+    contentType?: ReasoningContentType;
+    signature?: string;
+} | {
+    type: "tool_call_delta";
+    id: string;
+    callId?: string;
+    name?: string;
+    argumentsDelta?: string;
+    signature?: string;
+} | {
+    type: "tool_call";
+    toolCall: ToolCall;
+} | {
+    type: "message_id";
+    id: string;
+} | {
+    type: "final";
+    response: CompletionResponse<RawResponse>;
+} | {
+    type: "error";
+    error: unknown;
+};
+interface StreamingCompletionModel<RawResponse = unknown> extends CompletionModel<RawResponse> {
+    streamCompletion(request: CompletionRequest): AsyncIterable<CompletionStreamEvent<RawResponse>>;
+}
+declare class CompletionCapabilityError extends Error {
+    constructor(message: string);
+}
+declare function assertCompletionRequestSupported(model: CompletionModel, request: CompletionRequest, options?: {
+    streaming?: boolean | undefined;
+}): void;
+declare function textFromAssistantContent(content: AssistantContent[]): string;
+
+export { AssistantContent as A, CompletionCapabilityError as C, type Document as D, type ImageContent as I, type JsonObject as J, Message as M, type Reasoning as R, type StreamingCompletionModel as S, type Text as T, Usage as U, type AssistantMessage as a, type CompletionModel as b, type CompletionModelCapabilities as c, type CompletionRequest as d, type CompletionResponse as e, type CompletionStreamEvent as f, type DocumentContent as g, type ImageDetail as h, type JsonPrimitive as i, type JsonValue as j, type ReasoningContent as k, type ReasoningContentType as l, type SystemMessage as m, type ToolCall as n, type ToolChoice as o, ToolContent as p, type ToolDefinition as q, type ToolFunction as r, type ToolMessage as s, type ToolResult as t, type ToolResultContent as u, UserContent as v, type UserMessage as w, assertCompletionRequestSupported as x, reasoningDisplayText as y, textFromAssistantContent as z };

package/dist/types-HvopERm0.d.ts

@@ -0,0 +1,30 @@
+import { A as AnyTool } from './tool-DhuBQ3yb.js';
+
+type Skill = {
+    readonly name: string;
+    readonly description: string;
+    readonly instructions: string;
+    readonly directory: string;
+    readonly references: string[];
+    readonly scripts: string[];
+    readonly license?: string | undefined;
+    readonly metadata?: Record<string, unknown> | undefined;
+};
+type SkillLoader = {
+    load(): Promise<Skill[]>;
+};
+type SkillSet = {
+    readonly skills: Skill[];
+    readonly tools: AnyTool[];
+    readonly instructions: string;
+};
+type SkillValidationIssue = {
+    path: string;
+    message: string;
+};
+declare class SkillValidationError extends Error {
+    readonly issues: SkillValidationIssue[];
+    constructor(message: string, issues: SkillValidationIssue[]);
+}
+
+export { type Skill as S, type SkillLoader as a, type SkillSet as b, SkillValidationError as c, type SkillValidationIssue as d };

package/dist/vector-store/index.d.ts

@@ -0,0 +1,111 @@
+import { VectorMetadataValue, VectorMetadata, EmbeddingModel, EmbeddedDocument, Embedding } from '../embeddings/index.js';
+import { T as Tool } from '../tool-DhuBQ3yb.js';
+import '../types-BrxLd7ay.js';
+
+type VectorFilter = {
+    type: "eq";
+    key: string;
+    value: VectorMetadataValue;
+} | {
+    type: "gt";
+    key: string;
+    value: VectorMetadataValue;
+} | {
+    type: "lt";
+    key: string;
+    value: VectorMetadataValue;
+} | {
+    type: "and";
+    filters: [VectorFilter, VectorFilter];
+} | {
+    type: "or";
+    filters: [VectorFilter, VectorFilter];
+};
+declare const vectorFilter: {
+    eq(key: string, value: VectorMetadataValue): VectorFilter;
+    gt(key: string, value: VectorMetadataValue): VectorFilter;
+    lt(key: string, value: VectorMetadataValue): VectorFilter;
+    and(left: VectorFilter, right: VectorFilter): VectorFilter;
+    or(left: VectorFilter, right: VectorFilter): VectorFilter;
+};
+
+type LshOptions = {
+    type: "lsh";
+    numTables: number;
+    numHyperplanes: number;
+    seed?: number | undefined;
+};
+
+type IndexStrategy = {
+    type: "bruteForce";
+} | LshOptions;
+type VectorSearchRequest = {
+    query: string;
+    topK: number;
+    threshold?: number | undefined;
+    filter?: VectorFilter | undefined;
+};
+type VectorSearchResult<T = unknown, Metadata extends VectorMetadata = VectorMetadata> = {
+    score: number;
+    id: string;
+    document: T;
+    metadata?: Metadata | undefined;
+};
+interface VectorSearchIndex<T = unknown, Metadata extends VectorMetadata = VectorMetadata> {
+    search(request: VectorSearchRequest): Promise<Array<VectorSearchResult<T, Metadata>>>;
+    searchIds(request: VectorSearchRequest): Promise<Array<{
+        score: number;
+        id: string;
+    }>>;
+    asTool(options: VectorSearchToolOptions): Tool<{
+        query: string;
+        topK?: number;
+    }, unknown>;
+}
+type VectorSearchToolOptions = {
+    name: string;
+    description?: string | undefined;
+    topK?: number | undefined;
+    threshold?: number | undefined;
+    filter?: VectorFilter | undefined;
+};
+type StoredDocument<T, Metadata extends VectorMetadata> = EmbeddedDocument<T, Metadata>;
+declare class InMemoryVectorStore<T, Metadata extends VectorMetadata = VectorMetadata> {
+    private readonly documents;
+    private indexStrategy;
+    private lshIndex;
+    constructor(options?: {
+        index?: IndexStrategy;
+    });
+    static fromDocuments<T, Metadata extends VectorMetadata = VectorMetadata>(documents: Array<EmbeddedDocument<T, Metadata>>, options?: {
+        index?: IndexStrategy;
+    }): InMemoryVectorStore<T, Metadata>;
+    addDocuments(documents: Array<EmbeddedDocument<T, Metadata>>): this;
+    get(id: string): StoredDocument<T, Metadata> | undefined;
+    values(): Array<StoredDocument<T, Metadata>>;
+    len(): number;
+    isEmpty(): boolean;
+    index(model: EmbeddingModel): InMemoryVectorIndex<T, Metadata>;
+    candidates(queryEmbedding: Embedding): Array<StoredDocument<T, Metadata>>;
+    private rebuildLshIndex;
+}
+declare class InMemoryVectorIndex<T, Metadata extends VectorMetadata = VectorMetadata> implements VectorSearchIndex<T, Metadata> {
+    private readonly model;
+    private readonly store;
+    constructor(model: EmbeddingModel, store: InMemoryVectorStore<T, Metadata>);
+    search(request: VectorSearchRequest): Promise<Array<VectorSearchResult<T, Metadata>>>;
+    searchIds(request: VectorSearchRequest): Promise<Array<{
+        score: number;
+        id: string;
+    }>>;
+    asTool(options: VectorSearchToolOptions): Tool<{
+        query: string;
+        topK?: number;
+    }, unknown>;
+}
+declare function createVectorSearchTool<T, Metadata extends VectorMetadata>(index: VectorSearchIndex<T, Metadata>, options: VectorSearchToolOptions): Tool<{
+    query: string;
+    topK?: number;
+}, Array<VectorSearchResult<T, Metadata>>>;
+
+export { InMemoryVectorIndex, InMemoryVectorStore, type IndexStrategy, type VectorFilter, type VectorSearchIndex, type VectorSearchRequest, type VectorSearchResult, type VectorSearchToolOptions, createVectorSearchTool, vectorFilter };

package/dist/vector-store/index.js

@@ -0,0 +1,15 @@
+import {
+  InMemoryVectorIndex,
+  InMemoryVectorStore,
+  createVectorSearchTool,
+  vectorFilter
+} from "../chunk-SRGJPXKT.js";
+import "../chunk-B4QHQN5K.js";
+import "../chunk-A7VDIZQN.js";
+export {
+  InMemoryVectorIndex,
+  InMemoryVectorStore,
+  createVectorSearchTool,
+  vectorFilter
+};
+//# sourceMappingURL=index.js.map

package/dist/vector-store/index.js.map

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

package/dist/zod-schema-DJTEgQBq.d.ts

@@ -0,0 +1,40 @@
+import { q as ToolDefinition } from './types-BrxLd7ay.js';
+import { VectorMetadata, EmbeddingModel, EmbeddedDocument } from './embeddings/index.js';
+import { VectorSearchIndex } from './vector-store/index.js';
+import { A as AnyTool } from './tool-DhuBQ3yb.js';
+import { z } from 'zod';
+
+declare class ToolSet {
+    private readonly tools;
+    static fromTools(tools: AnyTool[]): ToolSet;
+    addTool(tool: AnyTool): this;
+    addTools(tools: AnyTool[] | ToolSet): this;
+    deleteTool(toolName: string): boolean;
+    contains(toolName: string): boolean;
+    get(toolName: string): AnyTool | undefined;
+    values(): AnyTool[];
+    getToolDefinitions(prompt?: string): Promise<ToolDefinition[]>;
+    call(toolName: string, args: string): Promise<string>;
+}
+
+type ToolSearchDocument<Metadata extends VectorMetadata = VectorMetadata> = {
+    toolName: string;
+    definition: ToolDefinition;
+    text: string;
+    metadata?: Metadata | undefined;
+};
+type EmbedToolsOptions<Metadata extends VectorMetadata = VectorMetadata> = {
+    content?: ((tool: AnyTool, definition: ToolDefinition) => string | string[]) | undefined;
+    metadata?: ((tool: AnyTool, definition: ToolDefinition) => Metadata | undefined) | undefined;
+    concurrency?: number | undefined;
+};
+interface DynamicToolIndex<Metadata extends VectorMetadata = VectorMetadata> extends VectorSearchIndex<ToolSearchDocument<Metadata>, Metadata> {
+    readonly toolSet: ToolSet;
+}
+declare function embedTools<Metadata extends VectorMetadata = VectorMetadata>(model: EmbeddingModel, tools: AnyTool[] | ToolSet, options?: EmbedToolsOptions<Metadata>): Promise<Array<EmbeddedDocument<ToolSearchDocument<Metadata>, Metadata>>>;
+declare function createToolIndex<Metadata extends VectorMetadata = VectorMetadata>(model: EmbeddingModel, tools: AnyTool[] | ToolSet, options?: EmbedToolsOptions<Metadata>): Promise<DynamicToolIndex<Metadata>>;
+declare function isDynamicToolIndex(value: unknown): value is DynamicToolIndex;
+
+type ZodSchema<T = unknown> = z.ZodType<T>;
+
+export { type DynamicToolIndex as D, type EmbedToolsOptions as E, type ToolSearchDocument as T, type ZodSchema as Z, ToolSet as a, createToolIndex as c, embedTools as e, isDynamicToolIndex as i };