@radaros/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,887 @@
+import { z } from 'zod';
+
+type MessageRole = "system" | "user" | "assistant" | "tool";
+interface TextPart {
+    type: "text";
+    text: string;
+}
+interface ImagePart {
+    type: "image";
+    /** Base64-encoded image data OR a URL. */
+    data: string;
+    mimeType?: "image/png" | "image/jpeg" | "image/gif" | "image/webp";
+}
+interface AudioPart {
+    type: "audio";
+    /** Base64-encoded audio data. */
+    data: string;
+    mimeType?: "audio/mp3" | "audio/wav" | "audio/ogg" | "audio/webm";
+}
+interface FilePart {
+    type: "file";
+    /** Base64-encoded file data OR a URL. */
+    data: string;
+    mimeType: string;
+    filename?: string;
+}
+type ContentPart = TextPart | ImagePart | AudioPart | FilePart;
+/** Convenience: plain string, or an array of multi-modal content parts. */
+type MessageContent = string | ContentPart[];
+interface ChatMessage {
+    role: MessageRole;
+    content: MessageContent | null;
+    toolCalls?: ToolCall[];
+    toolCallId?: string;
+    name?: string;
+}
+interface ToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+}
+interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+interface ModelResponse {
+    message: ChatMessage;
+    usage: TokenUsage;
+    finishReason: "stop" | "tool_calls" | "length" | "content_filter";
+    raw: unknown;
+}
+type StreamChunk = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool_call_start";
+    toolCall: {
+        id: string;
+        name: string;
+    };
+} | {
+    type: "tool_call_delta";
+    toolCallId: string;
+    argumentsDelta: string;
+} | {
+    type: "tool_call_end";
+    toolCallId: string;
+} | {
+    type: "finish";
+    finishReason: string;
+    usage?: TokenUsage;
+};
+interface ModelConfig {
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    stop?: string[];
+    responseFormat?: "text" | "json" | {
+        type: "json_schema";
+        schema: Record<string, unknown>;
+        name?: string;
+    };
+    /** Per-request API key override. When provided, the provider uses this key instead of the one set at construction. */
+    apiKey?: string;
+}
+/** Extract the text content from a MessageContent value. */
+declare function getTextContent(content: MessageContent | null): string;
+/** Check if content has multi-modal parts. */
+declare function isMultiModal(content: MessageContent | null): content is ContentPart[];
+
+interface ModelProvider {
+    readonly providerId: string;
+    readonly modelId: string;
+    generate(messages: ChatMessage[], options?: ModelConfig & {
+        tools?: ToolDefinition[];
+    }): Promise<ModelResponse>;
+    stream(messages: ChatMessage[], options?: ModelConfig & {
+        tools?: ToolDefinition[];
+    }): AsyncGenerator<StreamChunk>;
+}
+
+declare class RunContext {
+    readonly runId: string;
+    readonly sessionId: string;
+    readonly userId?: string;
+    readonly metadata: Record<string, unknown>;
+    readonly eventBus: EventBus;
+    sessionState: Record<string, unknown>;
+    constructor(opts: {
+        sessionId: string;
+        userId?: string;
+        metadata?: Record<string, unknown>;
+        eventBus: EventBus;
+        sessionState?: Record<string, unknown>;
+        runId?: string;
+    });
+    getState<T>(key: string): T | undefined;
+    setState(key: string, value: unknown): void;
+}
+
+interface Artifact {
+    type: string;
+    data: unknown;
+    mimeType?: string;
+}
+interface ToolResult {
+    content: string;
+    artifacts?: Artifact[];
+}
+interface ToolDef {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<any>;
+    execute: (args: Record<string, unknown>, ctx: RunContext) => Promise<string | ToolResult>;
+}
+interface ToolCallResult {
+    toolCallId: string;
+    toolName: string;
+    result: string | ToolResult;
+    error?: string;
+}
+
+interface StorageDriver {
+    get<T>(namespace: string, key: string): Promise<T | null>;
+    set<T>(namespace: string, key: string, value: T): Promise<void>;
+    delete(namespace: string, key: string): Promise<void>;
+    list<T>(namespace: string, prefix?: string): Promise<Array<{
+        key: string;
+        value: T;
+    }>>;
+    close(): Promise<void>;
+}
+
+interface MemoryConfig {
+    storage?: StorageDriver;
+    maxShortTermMessages?: number;
+    enableLongTerm?: boolean;
+}
+interface MemoryEntry {
+    key: string;
+    summary: string;
+    createdAt: Date;
+}
+
+declare class Memory {
+    private storage;
+    private maxShortTermMessages;
+    private enableLongTerm;
+    constructor(config?: MemoryConfig);
+    addMessages(sessionId: string, messages: ChatMessage[]): Promise<void>;
+    getMessages(sessionId: string): Promise<ChatMessage[]>;
+    getSummaries(sessionId: string): Promise<string[]>;
+    getContextString(sessionId: string): Promise<string>;
+    private summarizeAndStore;
+    clear(sessionId: string): Promise<void>;
+}
+
+type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
+interface LoggerConfig {
+    level?: LogLevel;
+    color?: boolean;
+    prefix?: string;
+}
+declare class Logger {
+    private level;
+    private color;
+    private prefix;
+    constructor(config?: LoggerConfig);
+    private c;
+    private shouldLog;
+    private tag;
+    private timestamp;
+    private log;
+    private formatValue;
+    debug(msg: string, data?: Record<string, unknown>): void;
+    info(msg: string, data?: Record<string, unknown>): void;
+    warn(msg: string, data?: Record<string, unknown>): void;
+    error(msg: string, data?: Record<string, unknown>): void;
+    private readonly boxWidth;
+    private pipe;
+    private printBoxLine;
+    agentStart(agentName: string, input: string): void;
+    toolCall(toolName: string, args: Record<string, unknown>): void;
+    toolResult(toolName: string, result: string): void;
+    agentEnd(agentName: string, output: string, usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    }, durationMs: number): void;
+    separator(): void;
+    private formatDuration;
+}
+
+interface AgentConfig {
+    name: string;
+    model: ModelProvider;
+    tools?: ToolDef[];
+    instructions?: string | ((ctx: RunContext) => string);
+    memory?: Memory;
+    storage?: StorageDriver;
+    sessionId?: string;
+    userId?: string;
+    addHistoryToMessages?: boolean;
+    numHistoryRuns?: number;
+    maxToolRoundtrips?: number;
+    temperature?: number;
+    structuredOutput?: z.ZodSchema;
+    hooks?: AgentHooks;
+    guardrails?: {
+        input?: InputGuardrail[];
+        output?: OutputGuardrail[];
+    };
+    eventBus?: EventBus;
+    /** Logging level. Set to "debug" for tool call details, "info" for summaries, "silent" to disable. Default: "silent". */
+    logLevel?: LogLevel;
+}
+interface RunOpts {
+    sessionId?: string;
+    userId?: string;
+    metadata?: Record<string, unknown>;
+    /** Per-request API key override passed to the model provider. */
+    apiKey?: string;
+}
+interface RunOutput {
+    text: string;
+    toolCalls: ToolCallResult[];
+    usage: TokenUsage;
+    /** Parsed structured output if structuredOutput schema is set. */
+    structured?: unknown;
+    durationMs?: number;
+}
+interface AgentHooks {
+    beforeRun?: (ctx: RunContext) => Promise<void>;
+    afterRun?: (ctx: RunContext, output: RunOutput) => Promise<void>;
+    onToolCall?: (ctx: RunContext, toolName: string, args: unknown) => Promise<void>;
+    onError?: (ctx: RunContext, error: Error) => Promise<void>;
+}
+type GuardrailResult = {
+    pass: true;
+} | {
+    pass: false;
+    reason: string;
+};
+interface InputGuardrail {
+    name: string;
+    validate: (input: MessageContent, ctx: RunContext) => Promise<GuardrailResult>;
+}
+interface OutputGuardrail {
+    name: string;
+    validate: (output: RunOutput, ctx: RunContext) => Promise<GuardrailResult>;
+}
+
+type AgentEventMap = {
+    "run.start": {
+        runId: string;
+        agentName: string;
+        input: string;
+    };
+    "run.complete": {
+        runId: string;
+        output: RunOutput;
+    };
+    "run.error": {
+        runId: string;
+        error: Error;
+    };
+    "run.stream.chunk": {
+        runId: string;
+        chunk: string;
+    };
+    "tool.call": {
+        runId: string;
+        toolName: string;
+        args: unknown;
+    };
+    "tool.result": {
+        runId: string;
+        toolName: string;
+        result: unknown;
+    };
+    "team.delegate": {
+        runId: string;
+        memberId: string;
+        task: string;
+    };
+    "workflow.step": {
+        runId: string;
+        stepName: string;
+        status: "start" | "done" | "error";
+    };
+};
+
+type EventKey = keyof AgentEventMap;
+declare class EventBus {
+    private emitter;
+    constructor();
+    on<K extends EventKey>(event: K, handler: (data: AgentEventMap[K]) => void): this;
+    once<K extends EventKey>(event: K, handler: (data: AgentEventMap[K]) => void): this;
+    off<K extends EventKey>(event: K, handler: (data: AgentEventMap[K]) => void): this;
+    emit<K extends EventKey>(event: K, data: AgentEventMap[K]): boolean;
+    removeAllListeners(event?: EventKey): this;
+}
+
+declare class Agent {
+    readonly name: string;
+    readonly eventBus: EventBus;
+    readonly instructions?: string | ((ctx: RunContext) => string);
+    private config;
+    private sessionManager;
+    private llmLoop;
+    private logger;
+    get tools(): ToolDef[];
+    get modelId(): string;
+    get providerId(): string;
+    get hasStructuredOutput(): boolean;
+    constructor(config: AgentConfig);
+    run(input: MessageContent, opts?: RunOpts): Promise<RunOutput>;
+    stream(input: MessageContent, opts?: RunOpts): AsyncGenerator<StreamChunk>;
+    private buildMessages;
+}
+
+declare class ToolExecutor {
+    private tools;
+    private concurrency;
+    constructor(tools: ToolDef[], concurrency?: number);
+    executeAll(toolCalls: ToolCall[], ctx: RunContext): Promise<ToolCallResult[]>;
+    private executeSingle;
+    getToolDefinitions(): Array<{
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    }>;
+}
+
+declare class LLMLoop {
+    private provider;
+    private toolExecutor;
+    private maxToolRoundtrips;
+    private temperature?;
+    private maxTokens?;
+    private structuredOutput?;
+    private logger?;
+    constructor(provider: ModelProvider, toolExecutor: ToolExecutor | null, options: {
+        maxToolRoundtrips: number;
+        temperature?: number;
+        maxTokens?: number;
+        structuredOutput?: z.ZodSchema;
+        logger?: Logger;
+    });
+    run(messages: ChatMessage[], ctx: RunContext, apiKey?: string): Promise<RunOutput>;
+    stream(messages: ChatMessage[], ctx: RunContext, apiKey?: string): AsyncGenerator<StreamChunk>;
+    private extractJson;
+    private zodToJsonSchema;
+}
+
+declare enum TeamMode {
+    Coordinate = "coordinate",
+    Route = "route",
+    Broadcast = "broadcast",
+    Collaborate = "collaborate"
+}
+interface TeamConfig {
+    name: string;
+    mode: TeamMode;
+    model: ModelProvider;
+    members: Agent[];
+    instructions?: string;
+    sessionState?: Record<string, unknown>;
+    storage?: StorageDriver;
+    maxRounds?: number;
+    eventBus?: EventBus;
+}
+
+declare class Team {
+    readonly name: string;
+    readonly eventBus: EventBus;
+    private config;
+    constructor(config: TeamConfig);
+    run(input: string, opts?: RunOpts): Promise<RunOutput>;
+    stream(input: string, opts?: RunOpts): AsyncGenerator<StreamChunk>;
+    private runCoordinateMode;
+    private runRouteMode;
+    private runBroadcastMode;
+    private runCollaborateMode;
+    private buildMemberDescriptions;
+    private buildCoordinatorPrompt;
+    private buildSynthesisPrompt;
+    private parseDelegationPlan;
+    private findMember;
+}
+
+type StepDef<TState> = AgentStep<TState> | FunctionStep<TState> | ConditionStep<TState> | ParallelStep<TState>;
+interface AgentStep<TState> {
+    name: string;
+    agent: Agent;
+    inputFrom?: (state: TState) => string;
+}
+interface FunctionStep<TState> {
+    name: string;
+    run: (state: TState, ctx: RunContext) => Promise<Partial<TState>>;
+}
+interface ConditionStep<TState> {
+    name: string;
+    condition: (state: TState) => boolean;
+    steps: StepDef<TState>[];
+}
+interface ParallelStep<TState> {
+    name: string;
+    parallel: StepDef<TState>[];
+}
+interface WorkflowConfig<TState extends Record<string, unknown> = Record<string, unknown>> {
+    name: string;
+    initialState: TState;
+    steps: StepDef<TState>[];
+    storage?: StorageDriver;
+    retryPolicy?: {
+        maxRetries: number;
+        backoffMs: number;
+    };
+    eventBus?: EventBus;
+}
+interface WorkflowResult<TState> {
+    state: TState;
+    stepResults: StepResult[];
+}
+interface StepResult {
+    stepName: string;
+    status: "done" | "error" | "skipped";
+    error?: string;
+    durationMs: number;
+}
+
+declare class Workflow<TState extends Record<string, unknown> = Record<string, unknown>> {
+    readonly name: string;
+    readonly eventBus: EventBus;
+    private config;
+    private stepRunner;
+    constructor(config: WorkflowConfig<TState>);
+    run(opts?: {
+        sessionId?: string;
+        userId?: string;
+    }): Promise<WorkflowResult<TState>>;
+}
+
+type ProviderFactory = (modelId: string, config?: Record<string, unknown>) => ModelProvider;
+declare class ModelRegistry {
+    private factories;
+    register(providerId: string, factory: ProviderFactory): void;
+    resolve(providerId: string, modelId: string, config?: Record<string, unknown>): ModelProvider;
+    has(providerId: string): boolean;
+}
+declare const registry: ModelRegistry;
+declare function openai(modelId: string, config?: {
+    apiKey?: string;
+    baseURL?: string;
+}): ModelProvider;
+declare function anthropic(modelId: string, config?: {
+    apiKey?: string;
+}): ModelProvider;
+declare function google(modelId: string, config?: {
+    apiKey?: string;
+}): ModelProvider;
+declare function ollama(modelId: string, config?: {
+    host?: string;
+}): ModelProvider;
+
+interface OpenAIConfig {
+    apiKey?: string;
+    baseURL?: string;
+}
+declare class OpenAIProvider implements ModelProvider {
+    readonly providerId = "openai";
+    readonly modelId: string;
+    private client;
+    private OpenAICtor;
+    private baseURL?;
+    private clientCache;
+    constructor(modelId: string, config?: OpenAIConfig);
+    private getClient;
+    generate(messages: ChatMessage[], options?: ModelConfig & {
+        tools?: ToolDefinition[];
+    }): Promise<ModelResponse>;
+    stream(messages: ChatMessage[], options?: ModelConfig & {
+        tools?: ToolDefinition[];
+    }): AsyncGenerator<StreamChunk>;
+    private applyResponseFormat;
+    private toOpenAIMessages;
+    private partToOpenAI;
+    private toOpenAITools;
+    private normalizeResponse;
+}
+
+interface AnthropicConfig {
+    apiKey?: string;
+}
+declare class AnthropicProvider implements ModelProvider {
+    readonly providerId = "anthropic";
+    readonly modelId: string;
+    private client;
+    private AnthropicCtor;
+    private clientCache;
+    constructor(modelId: string, config?: AnthropicConfig);
+    private getClient;
+    generate(messages: ChatMessage[], options?: ModelConfig & {
+        tools?: ToolDefinition[];
+    }): Promise<ModelResponse>;
+    stream(messages: ChatMessage[], options?: ModelConfig & {
+        tools?: ToolDefinition[];
+    }): AsyncGenerator<StreamChunk>;
+    private toAnthropicMessages;
+    private partToAnthropic;
+    private toAnthropicTools;
+    private normalizeResponse;
+}
+
+interface GoogleConfig {
+    apiKey?: string;
+}
+declare class GoogleProvider implements ModelProvider {
+    readonly providerId = "google";
+    readonly modelId: string;
+    private ai;
+    private GoogleGenAICtor;
+    private clientCache;
+    constructor(modelId: string, config?: GoogleConfig);
+    private getClient;
+    generate(messages: ChatMessage[], options?: ModelConfig & {
+        tools?: ToolDefinition[];
+    }): Promise<ModelResponse>;
+    stream(messages: ChatMessage[], options?: ModelConfig & {
+        tools?: ToolDefinition[];
+    }): AsyncGenerator<StreamChunk>;
+    private toGoogleMessages;
+    private partToGoogle;
+    private toGoogleTools;
+    private cleanJsonSchema;
+    private normalizeResponse;
+}
+
+interface OllamaConfig {
+    host?: string;
+}
+declare class OllamaProvider implements ModelProvider {
+    readonly providerId = "ollama";
+    readonly modelId: string;
+    private client;
+    constructor(modelId: string, config?: OllamaConfig);
+    generate(messages: ChatMessage[], options?: ModelConfig & {
+        tools?: ToolDefinition[];
+    }): Promise<ModelResponse>;
+    stream(messages: ChatMessage[], options?: ModelConfig & {
+        tools?: ToolDefinition[];
+    }): AsyncGenerator<StreamChunk>;
+    private toOllamaMessages;
+    private toOllamaTools;
+    private normalizeResponse;
+}
+
+declare function defineTool<T extends z.ZodObject<any>>(config: {
+    name: string;
+    description: string;
+    parameters: T;
+    execute: (args: z.infer<T>, ctx: RunContext) => Promise<string | ToolResult>;
+}): ToolDef;
+
+declare class InMemoryStorage implements StorageDriver {
+    private store;
+    private makeKey;
+    get<T>(namespace: string, key: string): Promise<T | null>;
+    set<T>(namespace: string, key: string, value: T): Promise<void>;
+    delete(namespace: string, key: string): Promise<void>;
+    list<T>(namespace: string, prefix?: string): Promise<Array<{
+        key: string;
+        value: T;
+    }>>;
+    close(): Promise<void>;
+}
+
+declare class SqliteStorage implements StorageDriver {
+    private db;
+    constructor(dbPath: string);
+    get<T>(namespace: string, key: string): Promise<T | null>;
+    set<T>(namespace: string, key: string, value: T): Promise<void>;
+    delete(namespace: string, key: string): Promise<void>;
+    list<T>(namespace: string, prefix?: string): Promise<Array<{
+        key: string;
+        value: T;
+    }>>;
+    close(): Promise<void>;
+}
+
+declare class PostgresStorage implements StorageDriver {
+    private pool;
+    constructor(connectionString: string);
+    initialize(): Promise<void>;
+    get<T>(namespace: string, key: string): Promise<T | null>;
+    set<T>(namespace: string, key: string, value: T): Promise<void>;
+    delete(namespace: string, key: string): Promise<void>;
+    list<T>(namespace: string, prefix?: string): Promise<Array<{
+        key: string;
+        value: T;
+    }>>;
+    close(): Promise<void>;
+}
+
+declare class MongoDBStorage implements StorageDriver {
+    private uri;
+    private dbName;
+    private collectionName;
+    private client;
+    private db;
+    private collection;
+    constructor(uri: string, dbName?: string, collectionName?: string);
+    initialize(): Promise<void>;
+    get<T>(namespace: string, key: string): Promise<T | null>;
+    set<T>(namespace: string, key: string, value: T): Promise<void>;
+    delete(namespace: string, key: string): Promise<void>;
+    list<T>(namespace: string, prefix?: string): Promise<Array<{
+        key: string;
+        value: T;
+    }>>;
+    close(): Promise<void>;
+}
+
+interface VectorDocument {
+    id: string;
+    content: string;
+    embedding?: number[];
+    metadata?: Record<string, unknown>;
+}
+interface VectorSearchResult {
+    id: string;
+    content: string;
+    score: number;
+    metadata?: Record<string, unknown>;
+}
+interface VectorSearchOptions {
+    topK?: number;
+    filter?: Record<string, unknown>;
+    minScore?: number;
+}
+interface EmbeddingProvider {
+    readonly dimensions: number;
+    embed(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+}
+interface VectorStore {
+    /** Initialize collections/indexes. Call once before use. */
+    initialize(): Promise<void>;
+    /** Upsert a single document (embedding computed if not provided). */
+    upsert(collection: string, doc: VectorDocument): Promise<void>;
+    /** Upsert multiple documents in batch. */
+    upsertBatch(collection: string, docs: VectorDocument[]): Promise<void>;
+    /** Similarity search by vector or text query. */
+    search(collection: string, query: number[] | string, options?: VectorSearchOptions): Promise<VectorSearchResult[]>;
+    /** Delete a document by ID. */
+    delete(collection: string, id: string): Promise<void>;
+    /** Get a document by ID. */
+    get(collection: string, id: string): Promise<VectorDocument | null>;
+    /** Drop an entire collection. */
+    dropCollection(collection: string): Promise<void>;
+    /** Close connections. */
+    close(): Promise<void>;
+}
+
+declare abstract class BaseVectorStore implements VectorStore {
+    protected embedder?: EmbeddingProvider | undefined;
+    constructor(embedder?: EmbeddingProvider | undefined);
+    protected ensureEmbedding(doc: VectorDocument): Promise<number[]>;
+    protected ensureQueryVector(query: number[] | string): Promise<number[]>;
+    abstract initialize(): Promise<void>;
+    abstract upsert(collection: string, doc: VectorDocument): Promise<void>;
+    abstract upsertBatch(collection: string, docs: VectorDocument[]): Promise<void>;
+    abstract search(collection: string, query: number[] | string, options?: VectorSearchOptions): Promise<VectorSearchResult[]>;
+    abstract delete(collection: string, id: string): Promise<void>;
+    abstract get(collection: string, id: string): Promise<VectorDocument | null>;
+    abstract dropCollection(collection: string): Promise<void>;
+    abstract close(): Promise<void>;
+}
+
+declare class InMemoryVectorStore extends BaseVectorStore {
+    private collections;
+    constructor(embedder?: EmbeddingProvider);
+    initialize(): Promise<void>;
+    private getCol;
+    upsert(collection: string, doc: VectorDocument): Promise<void>;
+    upsertBatch(collection: string, docs: VectorDocument[]): Promise<void>;
+    search(collection: string, query: number[] | string, options?: VectorSearchOptions): Promise<VectorSearchResult[]>;
+    private cosineSimilarity;
+    delete(collection: string, id: string): Promise<void>;
+    get(collection: string, id: string): Promise<VectorDocument | null>;
+    dropCollection(collection: string): Promise<void>;
+    close(): Promise<void>;
+}
+
+interface PgVectorConfig {
+    connectionString: string;
+    dimensions?: number;
+}
+declare class PgVectorStore extends BaseVectorStore {
+    private pool;
+    private dimensions;
+    private initializedCollections;
+    constructor(config: PgVectorConfig, embedder?: EmbeddingProvider);
+    initialize(): Promise<void>;
+    private ensureCollection;
+    private sanitize;
+    private toSql;
+    upsert(collection: string, doc: VectorDocument): Promise<void>;
+    upsertBatch(collection: string, docs: VectorDocument[]): Promise<void>;
+    search(collection: string, query: number[] | string, options?: VectorSearchOptions): Promise<VectorSearchResult[]>;
+    delete(collection: string, id: string): Promise<void>;
+    get(collection: string, id: string): Promise<VectorDocument | null>;
+    dropCollection(collection: string): Promise<void>;
+    close(): Promise<void>;
+}
+
+interface QdrantConfig {
+    url?: string;
+    apiKey?: string;
+    dimensions?: number;
+    checkCompatibility?: boolean;
+}
+declare class QdrantVectorStore extends BaseVectorStore {
+    private client;
+    private dimensions;
+    private initializedCollections;
+    constructor(config?: QdrantConfig, embedder?: EmbeddingProvider);
+    initialize(): Promise<void>;
+    private ensureCollection;
+    upsert(collection: string, doc: VectorDocument): Promise<void>;
+    upsertBatch(collection: string, docs: VectorDocument[]): Promise<void>;
+    search(collection: string, query: number[] | string, options?: VectorSearchOptions): Promise<VectorSearchResult[]>;
+    delete(collection: string, id: string): Promise<void>;
+    get(collection: string, id: string): Promise<VectorDocument | null>;
+    dropCollection(collection: string): Promise<void>;
+    close(): Promise<void>;
+}
+
+interface MongoDBVectorConfig {
+    uri: string;
+    dbName?: string;
+    /** Atlas Search index name (must be pre-created for $vectorSearch). Defaults to "vector_index". */
+    indexName?: string;
+}
+declare class MongoDBVectorStore extends BaseVectorStore {
+    private client;
+    private db;
+    private indexName;
+    private dbName;
+    private useAtlas;
+    constructor(config: MongoDBVectorConfig, embedder?: EmbeddingProvider);
+    initialize(): Promise<void>;
+    private col;
+    upsert(collection: string, doc: VectorDocument): Promise<void>;
+    upsertBatch(collection: string, docs: VectorDocument[]): Promise<void>;
+    search(collection: string, query: number[] | string, options?: VectorSearchOptions): Promise<VectorSearchResult[]>;
+    private atlasSearch;
+    private localSearch;
+    private buildFilter;
+    delete(collection: string, id: string): Promise<void>;
+    get(collection: string, id: string): Promise<VectorDocument | null>;
+    dropCollection(collection: string): Promise<void>;
+    close(): Promise<void>;
+}
+
+interface OpenAIEmbeddingConfig {
+    apiKey?: string;
+    baseURL?: string;
+    model?: string;
+    dimensions?: number;
+}
+declare class OpenAIEmbedding implements EmbeddingProvider {
+    readonly dimensions: number;
+    private client;
+    private model;
+    constructor(config?: OpenAIEmbeddingConfig);
+    embed(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+}
+
+interface GoogleEmbeddingConfig {
+    apiKey?: string;
+    model?: string;
+    dimensions?: number;
+}
+declare class GoogleEmbedding implements EmbeddingProvider {
+    readonly dimensions: number;
+    private ai;
+    private model;
+    constructor(config?: GoogleEmbeddingConfig);
+    embed(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+}
+
+interface KnowledgeBaseConfig {
+    /** Display name used in tool description auto-generation. */
+    name: string;
+    /** The underlying vector store (any backend). */
+    vectorStore: VectorStore;
+    /** Collection/index name inside the vector store. */
+    collection?: string;
+}
+interface KnowledgeBaseToolConfig {
+    /** Tool name exposed to the LLM. Defaults to `search_<collection>`. */
+    toolName?: string;
+    /** Custom tool description. A sensible default is generated from the KB name. */
+    description?: string;
+    /** Number of results to return per search. Default 5. */
+    topK?: number;
+    /** Minimum similarity score to include. */
+    minScore?: number;
+    /** Metadata filter applied to every search. */
+    filter?: Record<string, unknown>;
+    /** Custom formatter for search results. Defaults to numbered list with scores. */
+    formatResults?: (results: VectorSearchResult[]) => string;
+}
+declare class KnowledgeBase {
+    readonly name: string;
+    readonly collection: string;
+    private store;
+    private initialized;
+    constructor(config: KnowledgeBaseConfig);
+    initialize(): Promise<void>;
+    add(doc: VectorDocument): Promise<void>;
+    addDocuments(docs: VectorDocument[]): Promise<void>;
+    search(query: string, options?: VectorSearchOptions): Promise<VectorSearchResult[]>;
+    get(id: string): Promise<VectorDocument | null>;
+    delete(id: string): Promise<void>;
+    clear(): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Returns a ToolDef that an Agent can use to search this knowledge base.
+     * Plug the result directly into `Agent({ tools: [kb.asTool()] })`.
+     */
+    asTool(config?: KnowledgeBaseToolConfig): ToolDef;
+    private ensureInit;
+}
+
+interface Session {
+    sessionId: string;
+    userId?: string;
+    messages: ChatMessage[];
+    state: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+declare class SessionManager {
+    private storage;
+    constructor(storage: StorageDriver);
+    getOrCreate(sessionId: string, userId?: string): Promise<Session>;
+    appendMessage(sessionId: string, msg: ChatMessage): Promise<void>;
+    appendMessages(sessionId: string, msgs: ChatMessage[]): Promise<void>;
+    getHistory(sessionId: string, limit?: number): Promise<ChatMessage[]>;
+    updateState(sessionId: string, patch: Record<string, unknown>): Promise<void>;
+    getState(sessionId: string): Promise<Record<string, unknown>>;
+    deleteSession(sessionId: string): Promise<void>;
+}
+
+export { Agent, type AgentConfig, type AgentEventMap, type AgentHooks, type AgentStep, AnthropicProvider, type Artifact, type AudioPart, BaseVectorStore, type ChatMessage, type ConditionStep, type ContentPart, type EmbeddingProvider, EventBus, type FilePart, type FunctionStep, GoogleEmbedding, type GoogleEmbeddingConfig, GoogleProvider, type GuardrailResult, type ImagePart, InMemoryStorage, InMemoryVectorStore, type InputGuardrail, KnowledgeBase, type KnowledgeBaseConfig, type KnowledgeBaseToolConfig, LLMLoop, type LogLevel, Logger, type LoggerConfig, Memory, type MemoryConfig, type MemoryEntry, type MessageContent, type MessageRole, type ModelConfig, type ModelProvider, ModelRegistry, type ModelResponse, MongoDBStorage, type MongoDBVectorConfig, MongoDBVectorStore, OllamaProvider, OpenAIEmbedding, type OpenAIEmbeddingConfig, OpenAIProvider, type OutputGuardrail, type ParallelStep, type PgVectorConfig, PgVectorStore, PostgresStorage, type QdrantConfig, QdrantVectorStore, RunContext, type RunOpts, type RunOutput, type Session, SessionManager, SqliteStorage, type StepDef, type StepResult, type StorageDriver, type StreamChunk, Team, type TeamConfig, TeamMode, type TextPart, type TokenUsage, type ToolCall, type ToolCallResult, type ToolDef, type ToolDefinition, ToolExecutor, type ToolResult, type VectorDocument, type VectorSearchOptions, type VectorSearchResult, type VectorStore, Workflow, type WorkflowConfig, type WorkflowResult, anthropic, defineTool, getTextContent, google, isMultiModal, ollama, openai, registry };