sis-tools 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,869 @@
+/**
+ * Type definitions for SIS
+ */
+interface ToolParameter {
+    type: string;
+    description?: string;
+    required?: boolean;
+    default?: unknown;
+}
+interface ToolParameters {
+    [key: string]: ToolParameter;
+}
+interface ToolExample {
+    query: string;
+    input?: Record<string, unknown>;
+    output?: unknown;
+}
+interface ToolMetadata {
+    version?: string;
+    author?: string;
+    tags?: string[];
+    priority?: number;
+    [key: string]: unknown;
+}
+interface Tool {
+    name: string;
+    description: string;
+    parameters: ToolParameters;
+    returns?: Record<string, unknown>;
+    semanticHints: string[];
+    examples: ToolExample[];
+    handler?: ToolHandler;
+    metadata: ToolMetadata;
+    embedding?: number[];
+}
+type ToolHandler = (params: Record<string, unknown>) => unknown | Promise<unknown>;
+interface ToolMatch {
+    tool: Tool;
+    score: number;
+}
+interface ResolvedTool {
+    name: string;
+    schema: ToolSchema;
+    score: number;
+    handler?: ToolHandler;
+}
+interface ToolSchema {
+    name: string;
+    description: string;
+    parameters: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required: string[];
+    };
+}
+interface OpenAIToolSchema {
+    type: "function";
+    function: ToolSchema;
+}
+interface AnthropicToolSchema {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required: string[];
+    };
+}
+/**
+ * Convert a Tool to its JSON schema representation
+ */
+declare function toSchema(tool: Tool): ToolSchema;
+/**
+ * Convert a Tool to OpenAI function calling format
+ */
+declare function toOpenAISchema(tool: Tool): OpenAIToolSchema;
+/**
+ * Convert a Tool to Anthropic tool use format
+ */
+declare function toAnthropicSchema(tool: Tool): AnthropicToolSchema;
+
+/**
+ * Base embedding provider interface
+ */
+
+interface EmbeddingProvider {
+    /**
+     * Generate embedding for a single text
+     */
+    embed(text: string): Promise<number[]>;
+    /**
+     * Generate embeddings for multiple texts
+     */
+    embedBatch(texts: string[]): Promise<number[][]>;
+    /**
+     * The dimensionality of embeddings
+     */
+    readonly dimensions: number;
+}
+
+/**
+ * OpenAI embedding provider
+ */
+
+interface OpenAIEmbeddingsOptions {
+    model?: string;
+    apiKey?: string;
+    dimensions?: number;
+}
+declare class OpenAIEmbeddings implements EmbeddingProvider {
+    private client;
+    private model;
+    private apiKey?;
+    readonly dimensions: number;
+    constructor(options?: OpenAIEmbeddingsOptions);
+    private ensureClient;
+    embed(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+}
+
+/**
+ * Cohere embedding provider
+ */
+
+interface CohereEmbeddingsOptions {
+    model?: string;
+    apiKey?: string;
+    inputType?: "search_query" | "search_document" | "classification" | "clustering";
+}
+declare class CohereEmbeddings implements EmbeddingProvider {
+    private client;
+    private model;
+    private inputType;
+    private apiKey?;
+    readonly dimensions: number;
+    constructor(options?: CohereEmbeddingsOptions);
+    private ensureClient;
+    embed(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+}
+
+/**
+ * Google embedding provider
+ */
+
+interface GoogleEmbeddingsOptions {
+    model?: string;
+    apiKey?: string;
+}
+declare class GoogleEmbeddings implements EmbeddingProvider {
+    private client;
+    private model;
+    private apiKey?;
+    readonly dimensions: number;
+    constructor(options?: GoogleEmbeddingsOptions);
+    private ensureClient;
+    embed(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+}
+
+/**
+ * Embedding providers for SIS
+ */
+
+type ProviderName = "openai" | "cohere" | "google";
+interface ProviderOptions {
+    model?: string;
+    apiKey?: string;
+    dimensions?: number;
+    [key: string]: unknown;
+}
+/**
+ * Factory to get an embedding provider by name
+ */
+declare function getProvider(name: ProviderName, options?: ProviderOptions): EmbeddingProvider;
+
+/**
+ * Similarity and scoring functions for semantic search
+ */
+
+/**
+ * Interface for custom similarity functions
+ */
+interface SimilarityFunction {
+    /**
+     * Compute similarity score between query and tool embeddings
+     * @param queryEmbedding - The query vector
+     * @param toolEmbedding - The tool's embedding vector
+     * @returns Similarity score, typically in range [0, 1]
+     */
+    compute(queryEmbedding: number[], toolEmbedding: number[]): number;
+}
+/**
+ * Interface for custom scoring/ranking functions
+ */
+interface ScoringFunction {
+    /**
+     * Apply custom scoring logic to similarity score
+     * @param similarity - Raw similarity score from SimilarityFunction
+     * @param tool - The tool being scored (access metadata here)
+     * @returns Final score for ranking. Higher is better.
+     */
+    score(similarity: number, tool: Tool): number;
+}
+/**
+ * Default cosine similarity implementation
+ */
+declare class CosineSimilarity implements SimilarityFunction {
+    compute(a: number[], b: number[]): number;
+}
+/**
+ * Euclidean distance converted to similarity score
+ * Uses: similarity = 1 / (1 + distance)
+ */
+declare class EuclideanSimilarity implements SimilarityFunction {
+    compute(a: number[], b: number[]): number;
+}
+/**
+ * Dot product similarity (unnormalized cosine)
+ */
+declare class DotProductSimilarity implements SimilarityFunction {
+    compute(a: number[], b: number[]): number;
+}
+/**
+ * Default priority-based scoring
+ * Multiplies similarity by tool's priority metadata
+ */
+declare class PriorityScoring implements ScoringFunction {
+    private maxScore;
+    constructor(maxScore?: number);
+    score(similarity: number, tool: Tool): number;
+}
+/**
+ * Weighted scoring combining multiple factors
+ */
+declare class WeightedScoring implements ScoringFunction {
+    private similarityWeight;
+    private priorityWeight;
+    private maxScore;
+    constructor(similarityWeight?: number, priorityWeight?: number, maxScore?: number);
+    score(similarity: number, tool: Tool): number;
+}
+/**
+ * Scoring that boosts tools matching specified tags
+ */
+declare class TagBoostScoring implements ScoringFunction {
+    private boostTags;
+    private boostFactor;
+    private maxScore;
+    constructor(boostTags?: string[], boostFactor?: number, maxScore?: number);
+    score(similarity: number, tool: Tool): number;
+}
+/**
+ * Combine multiple scoring functions in sequence
+ */
+declare class CompositeScoring implements ScoringFunction {
+    private scorers;
+    constructor(scorers: ScoringFunction[]);
+    score(similarity: number, tool: Tool): number;
+}
+declare const DEFAULT_SIMILARITY: CosineSimilarity;
+declare const DEFAULT_SCORING: PriorityScoring;
+
+/**
+ * Tool formatters for different LLM providers
+ */
+
+/**
+ * Interface for custom tool formatters
+ */
+interface ToolFormatter {
+    /** Format name used to identify this formatter */
+    readonly name: string;
+    /** Format a resolved tool for LLM consumption */
+    format(tool: ResolvedTool): Record<string, unknown>;
+    /** Format multiple tools (override for batch optimizations) */
+    formatBatch?(tools: ResolvedTool[]): Record<string, unknown>[];
+}
+/**
+ * Returns the tool schema as-is
+ */
+declare class RawFormatter implements ToolFormatter {
+    readonly name = "raw";
+    format(tool: ResolvedTool): Record<string, unknown>;
+}
+/**
+ * Formatter for OpenAI function calling format
+ */
+declare class OpenAIFormatter implements ToolFormatter {
+    readonly name = "openai";
+    format(tool: ResolvedTool): Record<string, unknown>;
+}
+/**
+ * Formatter for Anthropic tool use format
+ */
+declare class AnthropicFormatter implements ToolFormatter {
+    readonly name = "anthropic";
+    format(tool: ResolvedTool): Record<string, unknown>;
+}
+/**
+ * Formatter for Google Gemini function calling format
+ */
+declare class GeminiFormatter implements ToolFormatter {
+    readonly name = "gemini";
+    format(tool: ResolvedTool): Record<string, unknown>;
+}
+/**
+ * Formatter for Mistral function calling format (OpenAI-compatible)
+ */
+declare class MistralFormatter implements ToolFormatter {
+    readonly name = "mistral";
+    format(tool: ResolvedTool): Record<string, unknown>;
+}
+/**
+ * Formatter for Llama/Meta function calling format
+ */
+declare class LlamaFormatter implements ToolFormatter {
+    readonly name = "llama";
+    format(tool: ResolvedTool): Record<string, unknown>;
+}
+/**
+ * Formatter for Cohere Command R format
+ */
+declare class CohereFormatter implements ToolFormatter {
+    readonly name = "cohere";
+    format(tool: ResolvedTool): Record<string, unknown>;
+}
+/**
+ * Minimal formatter with just name and description
+ */
+declare class MinimalFormatter implements ToolFormatter {
+    readonly name = "minimal";
+    format(tool: ResolvedTool): Record<string, unknown>;
+}
+/**
+ * Verbose formatter with all available information
+ */
+declare class VerboseFormatter implements ToolFormatter {
+    readonly name = "verbose";
+    format(tool: ResolvedTool): Record<string, unknown>;
+}
+/**
+ * Register a custom formatter
+ */
+declare function registerFormatter(formatter: ToolFormatter): void;
+/**
+ * Unregister a formatter by name
+ */
+declare function unregisterFormatter(name: string): boolean;
+/**
+ * Get a formatter by name
+ */
+declare function getFormatter(name: string): ToolFormatter;
+/**
+ * List all registered formatter names
+ */
+declare function listFormatters(): string[];
+/**
+ * Check if a formatter is registered
+ */
+declare function hasFormatter(name: string): boolean;
+/**
+ * Format tools using a formatter (by name or instance)
+ */
+declare function formatTools(tools: ResolvedTool[], formatter: string | ToolFormatter): Record<string, unknown>[];
+
+/**
+ * Middleware/hooks system for SIS
+ */
+/**
+ * Types of hooks available in the SIS lifecycle
+ */
+declare enum HookType {
+    PRE_REGISTER = "pre_register",
+    POST_REGISTER = "post_register",
+    PRE_EMBED = "pre_embed",
+    POST_EMBED = "post_embed",
+    PRE_RESOLVE = "pre_resolve",
+    POST_RESOLVE = "post_resolve",
+    PRE_SEARCH = "pre_search",
+    POST_SEARCH = "post_search",
+    PRE_EXECUTE = "pre_execute",
+    POST_EXECUTE = "post_execute"
+}
+/**
+ * Context passed to hooks
+ */
+interface HookContext {
+    hookType: HookType;
+    data: Record<string, unknown>;
+    cancelled: boolean;
+    error: Error | null;
+}
+/**
+ * Create a new hook context
+ */
+declare function createContext(hookType: HookType, data?: Record<string, unknown>): HookContext;
+/**
+ * Cancel further processing
+ */
+declare function cancelContext(context: HookContext, reason?: string): void;
+/**
+ * Set an error on the context
+ */
+declare function setContextError(context: HookContext, error: Error): void;
+/**
+ * Interface for hooks
+ */
+interface Hook {
+    /** The hook type this hook handles */
+    hookType: HookType;
+    /** Hook priority. Higher priority hooks run first. */
+    priority?: number;
+    /** Execute the hook */
+    execute(context: HookContext): Promise<HookContext> | HookContext;
+}
+/**
+ * Hook function type
+ */
+type HookFunction = (context: HookContext) => Promise<HookContext> | HookContext;
+/**
+ * Create a hook from a function
+ */
+declare function createHook(hookType: HookType, fn: HookFunction, priority?: number): Hook;
+/**
+ * Registry for managing hooks
+ */
+declare class HookRegistry {
+    private hooks;
+    constructor();
+    /**
+     * Register a hook
+     */
+    register(hook: Hook): void;
+    /**
+     * Register a function as a hook
+     */
+    on(hookType: HookType, fn: HookFunction, priority?: number): Hook;
+    /**
+     * Unregister a hook
+     */
+    unregister(hook: Hook): boolean;
+    /**
+     * Clear hooks
+     */
+    clear(hookType?: HookType): void;
+    /**
+     * Get all hooks for a type
+     */
+    getHooks(hookType: HookType): Hook[];
+    /**
+     * Check if any hooks are registered for a type
+     */
+    hasHooks(hookType: HookType): boolean;
+    /**
+     * Run all hooks of a given type
+     */
+    run(hookType: HookType, context: HookContext): Promise<HookContext>;
+}
+/**
+ * Hook that logs hook execution
+ */
+declare class LoggingHook implements Hook {
+    hookType: HookType;
+    priority: number;
+    private logger;
+    constructor(hookType: HookType, logger?: (message: string) => void);
+    execute(context: HookContext): HookContext;
+}
+/**
+ * Hook that records execution time
+ */
+declare class TimingHook implements Hook {
+    hookType: HookType;
+    priority: number;
+    private preHook;
+    private postHook;
+    private timingKey;
+    constructor(preHook: HookType, postHook: HookType, timingKey?: string);
+    execute(context: HookContext): HookContext;
+}
+/**
+ * Hook that collects metrics
+ */
+declare class MetricsHook implements Hook {
+    hookType: HookType;
+    priority: number;
+    count: number;
+    errors: number;
+    constructor(hookType: HookType);
+    execute(context: HookContext): HookContext;
+    reset(): void;
+}
+/**
+ * Hook that caches resolution results
+ */
+declare class CachingHook implements Hook {
+    hookType: HookType;
+    priority: number;
+    private cache;
+    private maxSize;
+    constructor(maxSize?: number);
+    execute(context: HookContext): HookContext;
+    clearCache(): void;
+    get cacheSize(): number;
+}
+
+/**
+ * Validation system for SIS tools and parameters
+ */
+
+/**
+ * Result of a validation operation
+ */
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * Create a validation result
+ */
+declare function createValidationResult(valid: boolean, errors?: string[], warnings?: string[]): ValidationResult;
+/**
+ * Merge two validation results
+ */
+declare function mergeValidationResults(a: ValidationResult, b: ValidationResult): ValidationResult;
+/**
+ * Interface for validators
+ */
+interface Validator<T = unknown> {
+    validate(data: T): ValidationResult;
+}
+/**
+ * Validation error
+ */
+declare class ValidationError extends Error {
+    result: ValidationResult;
+    constructor(result: ValidationResult);
+}
+/**
+ * Options for ToolSchemaValidator
+ */
+interface ToolSchemaValidatorOptions {
+    requireDescription?: boolean;
+    requireParameters?: boolean;
+    minDescriptionLength?: number;
+    maxDescriptionLength?: number;
+}
+/**
+ * Validates tool definitions
+ */
+declare class ToolSchemaValidator implements Validator<Tool> {
+    private options;
+    constructor(options?: ToolSchemaValidatorOptions);
+    validate(tool: Tool): ValidationResult;
+}
+/**
+ * Options for ParameterValidator
+ */
+interface ParameterValidatorOptions {
+    strict?: boolean;
+    allowExtra?: boolean;
+}
+/**
+ * Validates execution parameters against tool schema
+ */
+declare class ParameterValidator implements Validator<{
+    tool: Tool;
+    params: Record<string, unknown>;
+}> {
+    private options;
+    constructor(options?: ParameterValidatorOptions);
+    validate(data: {
+        tool: Tool;
+        params: Record<string, unknown>;
+    }): ValidationResult;
+    private checkType;
+}
+/**
+ * Options for ResultValidator
+ */
+interface ResultValidatorOptions {
+    strict?: boolean;
+}
+/**
+ * Validates tool execution results
+ */
+declare class ResultValidator implements Validator<{
+    tool: Tool;
+    result: unknown;
+}> {
+    private options;
+    constructor(options?: ResultValidatorOptions);
+    validate(data: {
+        tool: Tool;
+        result: unknown;
+    }): ValidationResult;
+    private checkReturnType;
+}
+/**
+ * Options for EmbeddingValidator
+ */
+interface EmbeddingValidatorOptions {
+    expectedDimensions?: number;
+    checkNormalization?: boolean;
+}
+/**
+ * Validates embedding vectors
+ */
+declare class EmbeddingValidator implements Validator<number[]> {
+    private options;
+    constructor(options?: EmbeddingValidatorOptions);
+    validate(embedding: number[]): ValidationResult;
+}
+/**
+ * Combines multiple validators
+ */
+declare class CompositeValidator<T> implements Validator<T> {
+    private validators;
+    constructor(validators: Validator<T>[]);
+    validate(data: T): ValidationResult;
+}
+/**
+ * Registry for managing validators
+ */
+declare class ValidatorRegistry {
+    schemaValidators: ToolSchemaValidator[];
+    parameterValidators: ParameterValidator[];
+    resultValidators: ResultValidator[];
+    embeddingValidators: EmbeddingValidator[];
+    addSchemaValidator(validator: ToolSchemaValidator): void;
+    addParameterValidator(validator: ParameterValidator): void;
+    addResultValidator(validator: ResultValidator): void;
+    addEmbeddingValidator(validator: EmbeddingValidator): void;
+    validateTool(tool: Tool): ValidationResult;
+    validateParams(tool: Tool, params: Record<string, unknown>): ValidationResult;
+    validateResult(tool: Tool, resultValue: unknown): ValidationResult;
+    validateEmbedding(embedding: number[]): ValidationResult;
+    clear(): void;
+}
+/**
+ * Create a registry with strict validators
+ */
+declare function createStrictValidator(): ValidatorRegistry;
+/**
+ * Create a registry with lenient validators
+ */
+declare function createLenientValidator(): ValidatorRegistry;
+
+/**
+ * Core SIS implementation
+ */
+
+interface SISOptions {
+    embeddingProvider?: ProviderName | EmbeddingProvider;
+    defaultTopK?: number;
+    defaultThreshold?: number;
+    providerOptions?: ProviderOptions;
+    remoteUrl?: string;
+    projectId?: string;
+    similarity?: SimilarityFunction;
+    scoring?: ScoringFunction;
+    validators?: ValidatorRegistry;
+    validateOnRegister?: boolean;
+    validateOnExecute?: boolean;
+}
+interface RegisterOptions {
+    name: string;
+    description: string;
+    parameters?: ToolParameters;
+    handler?: ToolHandler;
+    semanticHints?: string[];
+    examples?: ToolExample[];
+    metadata?: ToolMetadata;
+}
+interface StoreOptions extends RegisterOptions {
+    embedding: number[];
+}
+type ResolveFormat = "raw" | "openai" | "anthropic" | string;
+interface ResolveOptions {
+    topK?: number;
+    threshold?: number;
+    format?: ResolveFormat | ToolFormatter;
+}
+/**
+ * Semantic Integration System - Intelligent tool resolution
+ *
+ * @example
+ * const sis = new SIS({ embeddingProvider: 'openai' });
+ *
+ * sis.register({
+ *   name: 'web_search',
+ *   description: 'Search the web for information',
+ *   parameters: { query: { type: 'string' } },
+ *   handler: async ({ query }) => searchApi(query)
+ * });
+ *
+ * await sis.initialize();
+ * const tools = await sis.resolve("what's the weather?");
+ *
+ * // With custom formatter
+ * const geminiTools = await sis.resolve("query", { format: "gemini" });
+ */
+declare class SIS {
+    private _embeddings;
+    private _vectorStore;
+    private _pendingTools;
+    private _defaultTopK;
+    private _defaultThreshold;
+    private _initialized;
+    private _remoteUrl?;
+    private _projectId?;
+    private _similarity;
+    private _scoring;
+    private _hooks;
+    private _validators?;
+    private _validateOnRegister;
+    private _validateOnExecute;
+    constructor(options?: SISOptions);
+    /** Get the hook registry for registering middleware */
+    get hooks(): HookRegistry;
+    /** Get the validator registry */
+    get validators(): ValidatorRegistry | undefined;
+    /** Get the current similarity function */
+    get similarity(): SimilarityFunction;
+    /** Set a new similarity function */
+    set similarity(fn: SimilarityFunction);
+    /** Get the current scoring function */
+    get scoring(): ScoringFunction;
+    /** Set a new scoring function */
+    set scoring(fn: ScoringFunction);
+    /** Register a hook */
+    registerHook(hook: Hook): void;
+    /** Unregister a hook */
+    unregisterHook(hook: Hook): boolean;
+    /**
+     * Register a tool programmatically
+     */
+    register(options: RegisterOptions): Tool;
+    /**
+     * Store (upsert) a tool with a precomputed embedding.
+     *
+     * This bypasses the embedding provider, allowing custom embedding workflows.
+     */
+    store(options: StoreOptions): Tool;
+    /**
+     * Initialize embeddings for all pending tools
+     */
+    initialize(): Promise<void>;
+    /**
+     * Resolve tools for a query (raw format)
+     */
+    resolve(query: string, options?: {
+        topK?: number;
+        threshold?: number;
+        format?: "raw";
+    }): Promise<ResolvedTool[]>;
+    /**
+     * Resolve tools for a query (OpenAI format)
+     */
+    resolve(query: string, options: {
+        topK?: number;
+        threshold?: number;
+        format: "openai";
+    }): Promise<OpenAIToolSchema[]>;
+    /**
+     * Resolve tools for a query (Anthropic format)
+     */
+    resolve(query: string, options: {
+        topK?: number;
+        threshold?: number;
+        format: "anthropic";
+    }): Promise<AnthropicToolSchema[]>;
+    /**
+     * Resolve tools for a query (custom format)
+     */
+    resolve(query: string, options: {
+        topK?: number;
+        threshold?: number;
+        format: string | ToolFormatter;
+    }): Promise<Record<string, unknown>[]>;
+    /**
+     * Format results based on format option
+     */
+    private formatResults;
+    /**
+     * Resolve the single best matching tool
+     */
+    resolveOne(query: string, threshold?: number): Promise<ResolvedTool | null>;
+    /**
+     * Get a registered tool by name
+     */
+    getTool(name: string): Tool | undefined;
+    /**
+     * List all registered tool names
+     */
+    listTools(): string[];
+    /**
+     * Number of registered tools
+     */
+    get toolCount(): number;
+    /**
+     * Execute a tool by name
+     */
+    execute(toolName: string, params: Record<string, unknown>): Promise<unknown>;
+}
+
+/**
+ * Vector store for tool embeddings
+ */
+
+/**
+ * In-memory vector store for tool embeddings.
+ *
+ * Uses cosine similarity by default for matching. Supports custom
+ * similarity and scoring functions for advanced use cases.
+ *
+ * For production use with many tools, consider using an external
+ * store like Pinecone, Chroma, or Qdrant.
+ */
+declare class VectorStore {
+    private tools;
+    private embeddings;
+    /**
+     * Add a tool with its embedding to the store
+     */
+    add(tool: Tool, embedding: number[]): void;
+    /**
+     * Add multiple tools with embeddings
+     */
+    addBatch(tools: Tool[], embeddings: number[][]): void;
+    /**
+     * Search for similar tools
+     *
+     * @param queryEmbedding - The query embedding vector
+     * @param topK - Maximum number of results
+     * @param threshold - Minimum score to include
+     * @param similarityFn - Custom similarity function (defaults to cosine)
+     * @param scoringFn - Custom scoring function (defaults to priority scoring)
+     */
+    search(queryEmbedding: number[], topK?: number, threshold?: number, similarityFn?: SimilarityFunction, scoringFn?: ScoringFunction): ToolMatch[];
+    /**
+     * Remove a tool by name
+     */
+    remove(toolName: string): boolean;
+    /**
+     * Remove all tools from the store
+     */
+    clear(): void;
+    /**
+     * Get a tool by name
+     */
+    get(toolName: string): Tool | undefined;
+    /**
+     * Number of tools in the store
+     */
+    get size(): number;
+    /**
+     * Check if a tool exists by name
+     */
+    has(toolName: string): boolean;
+    /**
+     * Get all tools
+     */
+    getAll(): Tool[];
+}
+
+export { AnthropicFormatter, type AnthropicToolSchema, CachingHook, CohereEmbeddings, CohereFormatter, CompositeScoring, CompositeValidator, CosineSimilarity, DEFAULT_SCORING, DEFAULT_SIMILARITY, DotProductSimilarity, type EmbeddingProvider, EmbeddingValidator, type EmbeddingValidatorOptions, EuclideanSimilarity, GeminiFormatter, GoogleEmbeddings, type Hook, type HookContext, type HookFunction, HookRegistry, HookType, LlamaFormatter, LoggingHook, MetricsHook, MinimalFormatter, MistralFormatter, OpenAIEmbeddings, OpenAIFormatter, type OpenAIToolSchema, ParameterValidator, type ParameterValidatorOptions, PriorityScoring, RawFormatter, type RegisterOptions, type ResolveFormat, type ResolveOptions, type ResolvedTool, ResultValidator, type ResultValidatorOptions, SIS, type SISOptions, type ScoringFunction, type SimilarityFunction, type StoreOptions, TagBoostScoring, TimingHook, type Tool, type ToolExample, type ToolFormatter, type ToolHandler, type ToolMatch, type ToolMetadata, type ToolParameter, type ToolParameters, type ToolSchema, ToolSchemaValidator, type ToolSchemaValidatorOptions, ValidationError, type ValidationResult, type Validator, ValidatorRegistry, VectorStore, VerboseFormatter, WeightedScoring, cancelContext, createContext, createHook, createLenientValidator, createStrictValidator, createValidationResult, formatTools, getFormatter, getProvider, hasFormatter, listFormatters, mergeValidationResults, registerFormatter, setContextError, toAnthropicSchema, toOpenAISchema, toSchema, unregisterFormatter };