@radaros/core 0.3.5 → 0.3.7

package/dist/index.d.ts

@@ -0,0 +1,1711 @@
+import * as zod from 'zod';
+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;
+    reasoningTokens?: number;
+}
+interface ModelResponse {
+    message: ChatMessage;
+    usage: TokenUsage;
+    finishReason: "stop" | "tool_calls" | "length" | "content_filter";
+    raw: unknown;
+}
+type StreamChunk = {
+    type: "text";
+    text: string;
+} | {
+    type: "thinking";
+    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 ReasoningConfig {
+    enabled: boolean;
+    /** Reasoning effort for OpenAI o-series models. */
+    effort?: "low" | "medium" | "high";
+    /** Token budget for thinking (Anthropic / Gemini). */
+    budgetTokens?: number;
+}
+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;
+    /** Enable extended thinking / reasoning. */
+    reasoning?: ReasoningConfig;
+}
+/** 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 ToolCacheConfig {
+    /** Time-to-live in milliseconds. Cached results expire after this duration. */
+    ttl: number;
+}
+interface ToolDef {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<any>;
+    execute: (args: Record<string, unknown>, ctx: RunContext) => Promise<string | ToolResult>;
+    /** Raw JSON Schema to send to the LLM, bypassing Zod-to-JSON conversion (used by MCP tools). */
+    rawJsonSchema?: Record<string, unknown>;
+    /** Enable result caching for this tool. */
+    cache?: ToolCacheConfig;
+}
+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;
+    /** LLM used to generate conversation summaries from overflow messages. */
+    model?: ModelProvider;
+    /** Maximum number of summaries kept per session (oldest dropped first). Default 20. */
+    maxSummaries?: number;
+}
+interface MemoryEntry {
+    key: string;
+    summary: string;
+    createdAt: Date;
+}
+
+/**
+ * Long-term conversation memory.
+ *
+ * Memory stores LLM-generated summaries of past conversation segments.
+ * It does NOT store raw messages — that's Session's job.
+ *
+ * Flow: Session overflows → Agent passes overflow to Memory.summarize() →
+ * Memory generates an LLM summary and persists it.
+ * On the next run, Memory.getContextString() provides past summaries as context.
+ */
+declare class Memory {
+    private storage;
+    private model?;
+    private maxSummaries;
+    private initPromise;
+    constructor(config?: MemoryConfig);
+    private ensureInitialized;
+    /**
+     * Summarize overflow messages and store the summary.
+     * Uses the configured LLM model; falls back to basic concatenation if no model.
+     */
+    summarize(sessionId: string, messages: ChatMessage[], fallbackModel?: ModelProvider): Promise<void>;
+    /** Get all stored summaries for a session. */
+    getSummaries(sessionId: string): Promise<string[]>;
+    /** Get summaries formatted as a context string for injection into the system prompt. */
+    getContextString(sessionId: string): Promise<string>;
+    /** Clear all summaries for a session. */
+    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;
+    thinking(content: string): void;
+    agentEnd(agentName: string, output: string, usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+        reasoningTokens?: number;
+    }, durationMs: number): void;
+    separator(): void;
+    private formatDuration;
+}
+
+interface UserMemoryConfig {
+    storage?: StorageDriver;
+    /** LLM used for auto-extraction of facts from conversations. */
+    model?: ModelProvider;
+    /** Maximum number of facts stored per user (default 100). */
+    maxFacts?: number;
+    /** Whether auto-extraction is enabled (default true). */
+    enabled?: boolean;
+}
+interface UserFact {
+    id: string;
+    fact: string;
+    createdAt: Date;
+    source: "auto" | "manual";
+}
+declare class UserMemory {
+    private storage;
+    private model?;
+    private maxFacts;
+    private enabled;
+    private initPromise;
+    constructor(config?: UserMemoryConfig);
+    private ensureInitialized;
+    getFacts(userId: string): Promise<UserFact[]>;
+    addFacts(userId: string, facts: string[], source?: "auto" | "manual"): Promise<void>;
+    removeFact(userId: string, factId: string): Promise<void>;
+    clear(userId: string): Promise<void>;
+    getContextString(userId: string): Promise<string>;
+    asTool(config?: {
+        name?: string;
+        description?: string;
+    }): ToolDef;
+    extractAndStore(userId: string, messages: ChatMessage[], fallbackModel?: ModelProvider): Promise<void>;
+    private extractJsonArray;
+}
+
+interface RetryConfig {
+    maxRetries: number;
+    initialDelayMs: number;
+    maxDelayMs: number;
+    retryableErrors?: (error: unknown) => boolean;
+}
+declare function withRetry<T>(fn: () => Promise<T>, config?: Partial<RetryConfig>): Promise<T>;
+
+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;
+    /** Enable extended thinking / reasoning for the model. */
+    reasoning?: ReasoningConfig;
+    /** User-scoped memory for cross-session personalization. */
+    userMemory?: UserMemory;
+    /** Retry configuration for transient LLM API failures (429, 5xx, network errors). */
+    retry?: Partial<RetryConfig>;
+    /** Maximum context window tokens. History is auto-trimmed to fit. */
+    maxContextTokens?: number;
+}
+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;
+    /** Model's internal reasoning / thinking content (when reasoning is enabled). */
+    thinking?: string;
+    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";
+    };
+    "voice.connected": {
+        agentName: string;
+    };
+    "voice.audio": {
+        agentName: string;
+        data: Buffer;
+    };
+    "voice.transcript": {
+        agentName: string;
+        text: string;
+        role: "user" | "assistant";
+    };
+    "voice.tool.call": {
+        agentName: string;
+        toolName: string;
+        args: unknown;
+    };
+    "voice.tool.result": {
+        agentName: string;
+        toolName: string;
+        result: string;
+    };
+    "voice.error": {
+        agentName: string;
+        error: Error;
+    };
+    "voice.disconnected": {
+        agentName: string;
+    };
+};
+
+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;
+    private storageInitPromise;
+    get tools(): ToolDef[];
+    get modelId(): string;
+    get providerId(): string;
+    get hasStructuredOutput(): boolean;
+    get structuredOutputSchema(): zod.ZodSchema | undefined;
+    constructor(config: AgentConfig);
+    run(input: MessageContent, opts?: RunOpts): Promise<RunOutput>;
+    stream(input: MessageContent, opts?: RunOpts): AsyncGenerator<StreamChunk>;
+    private buildMessages;
+    private estimateTokens;
+    private trimHistoryByTokens;
+}
+
+declare class ToolExecutor {
+    private tools;
+    private concurrency;
+    private cache;
+    private cachedDefs;
+    constructor(tools: ToolDef[], concurrency?: number);
+    clearCache(): void;
+    private getCacheKey;
+    private getCached;
+    private setCache;
+    executeAll(toolCalls: ToolCall[], ctx: RunContext): Promise<ToolCallResult[]>;
+    private executeSingle;
+    getToolDefinitions(): Array<{
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    }>;
+    private buildToolDefinitions;
+}
+
+declare class LLMLoop {
+    private provider;
+    private toolExecutor;
+    private maxToolRoundtrips;
+    private temperature?;
+    private maxTokens?;
+    private structuredOutput?;
+    private logger?;
+    private reasoning?;
+    private retry?;
+    constructor(provider: ModelProvider, toolExecutor: ToolExecutor | null, options: {
+        maxToolRoundtrips: number;
+        temperature?: number;
+        maxTokens?: number;
+        structuredOutput?: z.ZodSchema;
+        logger?: Logger;
+        reasoning?: ReasoningConfig;
+        retry?: Partial<RetryConfig>;
+    });
+    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;
+declare function vertex(modelId: string, config?: {
+    project?: string;
+    location?: string;
+    credentials?: 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;
+}
+
+interface VertexAIConfig {
+    project?: string;
+    location?: string;
+    /** Service account key JSON string or path (optional — uses ADC by default). */
+    credentials?: string;
+}
+/**
+ * Vertex AI provider using Google's @google/genai SDK in Vertex mode.
+ *
+ * Authentication (in order of precedence):
+ *   1. Explicit `project` + `location` in config
+ *   2. GOOGLE_CLOUD_PROJECT / GOOGLE_CLOUD_LOCATION env vars
+ *   3. Application Default Credentials (gcloud auth)
+ */
+declare class VertexAIProvider implements ModelProvider {
+    readonly providerId = "vertex";
+    readonly modelId: string;
+    private ai;
+    private GoogleGenAICtor;
+    private project;
+    private location;
+    constructor(modelId: string, config?: VertexAIConfig);
+    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;
+}
+
+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>;
+    cache?: ToolCacheConfig;
+}): 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[][]>;
+}
+
+type SearchMode = "vector" | "keyword" | "hybrid";
+interface HybridSearchConfig {
+    /** Weight for vector (semantic) results in RRF. Default 1.0. */
+    vectorWeight?: number;
+    /** Weight for keyword (BM25) results in RRF. Default 1.0. */
+    keywordWeight?: number;
+    /** RRF constant k. Higher = less rank-sensitive. Default 60. */
+    rrfK?: 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;
+    /**
+     * Default search mode.
+     * - `"vector"` — pure semantic (embedding) search (default, backward-compatible)
+     * - `"keyword"` — pure BM25 keyword search
+     * - `"hybrid"` — combines vector + keyword via Reciprocal Rank Fusion
+     */
+    searchMode?: SearchMode;
+    /** Fine-tune hybrid search behavior. */
+    hybridConfig?: HybridSearchConfig;
+}
+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>;
+    /** Override the search mode for this tool. Inherits from KB config if not set. */
+    searchMode?: SearchMode;
+    /** 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;
+    private bm25;
+    private defaultSearchMode;
+    private hybridConfig;
+    constructor(config: KnowledgeBaseConfig);
+    initialize(): Promise<void>;
+    add(doc: VectorDocument): Promise<void>;
+    addDocuments(docs: VectorDocument[]): Promise<void>;
+    search(query: string, options?: VectorSearchOptions & {
+        searchMode?: SearchMode;
+    }): 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 keywordSearch;
+    private hybridSearch;
+    private ensureInit;
+}
+
+/**
+ * Lightweight BM25 (Okapi BM25) implementation for keyword search.
+ * Maintains an in-memory inverted index for fast full-text scoring.
+ */
+interface BM25Document {
+    id: string;
+    content: string;
+    metadata?: Record<string, unknown>;
+}
+interface BM25Result {
+    id: string;
+    content: string;
+    score: number;
+    metadata?: Record<string, unknown>;
+}
+declare class BM25Index {
+    private docs;
+    private docFreqs;
+    private avgDocLength;
+    /** BM25 free parameter: term frequency saturation. */
+    private k1;
+    /** BM25 free parameter: document length normalization. */
+    private b;
+    constructor(opts?: {
+        k1?: number;
+        b?: number;
+    });
+    get size(): number;
+    add(doc: BM25Document): void;
+    addBatch(docs: BM25Document[]): void;
+    remove(id: string): void;
+    clear(): void;
+    search(query: string, opts?: {
+        topK?: number;
+        minScore?: number;
+        filter?: Record<string, unknown>;
+    }): BM25Result[];
+    private recomputeAvgLength;
+}
+
+/**
+ * Reciprocal Rank Fusion (RRF) — merges ranked result lists from different
+ * retrieval methods into a single fused ranking.
+ *
+ * RRF score for document d = sum over all lists L of: 1 / (k + rank_L(d))
+ * where k is a constant (default 60) that mitigates the impact of high
+ * rankings by outlier systems.
+ *
+ * Reference: Cormack, Clarke & Buettcher (2009)
+ */
+interface RankedItem {
+    id: string;
+    content: string;
+    score: number;
+    metadata?: Record<string, unknown>;
+}
+interface RRFOptions {
+    /** Fusion constant. Higher values dampen the effect of rank differences. Default 60. */
+    k?: number;
+    /** Maximum results to return. */
+    topK?: number;
+    /** Minimum fused score to include. */
+    minScore?: number;
+    /** Weight per ranked list. Defaults to equal weighting (1.0 each). */
+    weights?: number[];
+}
+declare function reciprocalRankFusion(rankedLists: RankedItem[][], options?: RRFOptions): RankedItem[];
+
+interface Session {
+    sessionId: string;
+    userId?: string;
+    messages: ChatMessage[];
+    state: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+interface SessionManagerConfig {
+    /** Maximum messages kept in session history. Oldest are trimmed first. Default: unlimited. */
+    maxMessages?: number;
+}
+interface AppendResult {
+    /** Messages that were trimmed from the session because maxMessages was exceeded. */
+    overflow: ChatMessage[];
+}
+declare class SessionManager {
+    private storage;
+    private maxMessages?;
+    constructor(storage: StorageDriver, config?: SessionManagerConfig);
+    getOrCreate(sessionId: string, userId?: string): Promise<Session>;
+    appendMessage(sessionId: string, msg: ChatMessage): Promise<AppendResult>;
+    appendMessages(sessionId: string, msgs: ChatMessage[]): Promise<AppendResult>;
+    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>;
+}
+
+interface MCPToolProviderConfig {
+    name: string;
+    transport: "stdio" | "http";
+    /** For stdio transport: command to spawn */
+    command?: string;
+    /** For stdio transport: args for the command */
+    args?: string[];
+    /** For stdio transport: environment variables */
+    env?: Record<string, string>;
+    /** For http transport: server URL */
+    url?: string;
+    /** For http transport: custom headers */
+    headers?: Record<string, string>;
+}
+/**
+ * Connects to an MCP (Model Context Protocol) server and exposes its tools
+ * as native RadarOS ToolDef[] that any Agent can use.
+ *
+ * Supports stdio and HTTP (Streamable HTTP) transports.
+ * Requires: npm install @modelcontextprotocol/sdk
+ */
+declare class MCPToolProvider {
+    readonly name: string;
+    private config;
+    private client;
+    private transportInstance;
+    private tools;
+    private connected;
+    constructor(config: MCPToolProviderConfig);
+    connect(): Promise<void>;
+    private discoverTools;
+    private jsonSchemaToZod;
+    /**
+     * Returns tools from this MCP server as RadarOS ToolDef[].
+     * Optionally filter by tool names to reduce token usage.
+     *
+     * @param filter - Tool names to include (without the server name prefix).
+     *                 If omitted, returns all tools.
+     *
+     * @example
+     * // All tools
+     * await mcp.getTools()
+     *
+     * // Only specific tools (pass the original MCP tool names, not prefixed)
+     * await mcp.getTools({ include: ["get_latest_release", "search_repositories"] })
+     *
+     * // Exclude specific tools
+     * await mcp.getTools({ exclude: ["push_files", "create_repository"] })
+     */
+    getTools(filter?: {
+        include?: string[];
+        exclude?: string[];
+    }): Promise<ToolDef[]>;
+    /** Refresh the tool list from the MCP server. */
+    refresh(): Promise<void>;
+    /** Disconnect from the MCP server. */
+    close(): Promise<void>;
+}
+
+/**
+ * A2A (Agent-to-Agent) Protocol types.
+ * Based on the A2A specification v0.2.
+ * https://google.github.io/A2A/specification/
+ */
+interface A2ATextPart {
+    kind: "text";
+    text: string;
+}
+interface A2AFilePart {
+    kind: "file";
+    file: {
+        name?: string;
+        mimeType?: string;
+        bytes?: string;
+        uri?: string;
+    };
+}
+interface A2ADataPart {
+    kind: "data";
+    data: Record<string, unknown>;
+}
+type A2APart = A2ATextPart | A2AFilePart | A2ADataPart;
+interface A2AMessage {
+    role: "user" | "agent";
+    parts: A2APart[];
+    messageId?: string;
+    taskId?: string;
+    referenceTaskIds?: string[];
+    metadata?: Record<string, unknown>;
+}
+type A2ATaskState = "submitted" | "working" | "input-required" | "completed" | "failed" | "canceled";
+interface A2AArtifact {
+    artifactId: string;
+    name?: string;
+    description?: string;
+    parts: A2APart[];
+    metadata?: Record<string, unknown>;
+}
+interface A2ATask {
+    id: string;
+    sessionId?: string;
+    status: {
+        state: A2ATaskState;
+        message?: A2AMessage;
+        timestamp?: string;
+    };
+    artifacts?: A2AArtifact[];
+    history?: A2AMessage[];
+    metadata?: Record<string, unknown>;
+}
+interface A2ASkill {
+    id: string;
+    name: string;
+    description?: string;
+    tags?: string[];
+    examples?: string[];
+}
+interface A2AAgentCard {
+    name: string;
+    description?: string;
+    url: string;
+    version?: string;
+    provider?: {
+        organization: string;
+        url?: string;
+    };
+    capabilities?: {
+        streaming?: boolean;
+        pushNotifications?: boolean;
+        stateTransitionHistory?: boolean;
+    };
+    authentication?: {
+        schemes?: string[];
+        credentials?: string;
+    };
+    skills?: A2ASkill[];
+    defaultInputModes?: string[];
+    defaultOutputModes?: string[];
+    supportedInputModes?: string[];
+    supportedOutputModes?: string[];
+}
+interface A2AJsonRpcRequest {
+    jsonrpc: "2.0";
+    id: string | number;
+    method: string;
+    params?: Record<string, unknown>;
+}
+interface A2AJsonRpcResponse {
+    jsonrpc: "2.0";
+    id: string | number;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+interface A2ASendParams {
+    message: A2AMessage;
+    configuration?: {
+        acceptedOutputModes?: string[];
+        blocking?: boolean;
+    };
+    metadata?: Record<string, unknown>;
+}
+interface A2ATaskQueryParams {
+    id: string;
+    historyLength?: number;
+}
+
+interface A2ARemoteAgentConfig {
+    url: string;
+    /** Custom headers for every request (e.g. auth tokens). */
+    headers?: Record<string, string>;
+    /** Override the discovered name. */
+    name?: string;
+    /** Request timeout in ms (default 60000). */
+    timeoutMs?: number;
+}
+/**
+ * A2ARemoteAgent wraps a remote A2A-compliant agent.
+ * It can be used as a tool, a Team member, or called directly.
+ */
+declare class A2ARemoteAgent {
+    readonly url: string;
+    name: string;
+    instructions: string;
+    skills: Array<{
+        id: string;
+        name: string;
+        description?: string;
+    }>;
+    private headers;
+    private timeoutMs;
+    private card;
+    private rpcId;
+    get tools(): ToolDef[];
+    get modelId(): string;
+    get providerId(): string;
+    get hasStructuredOutput(): boolean;
+    constructor(config: A2ARemoteAgentConfig);
+    /**
+     * Fetch the Agent Card from /.well-known/agent.json and populate metadata.
+     */
+    discover(): Promise<A2AAgentCard>;
+    /**
+     * Synchronous run: sends message/send and returns RunOutput.
+     */
+    run(input: string, opts?: RunOpts): Promise<RunOutput>;
+    /**
+     * Streaming run: sends message/stream and yields StreamChunks from SSE.
+     */
+    stream(input: string, opts?: RunOpts): AsyncGenerator<StreamChunk>;
+    /**
+     * Wrap this remote agent as a ToolDef so it can be used by an orchestrator agent.
+     */
+    asTool(): ToolDef;
+    getAgentCard(): A2AAgentCard | null;
+    private partsToText;
+}
+
+type AudioFormat = "pcm16" | "g711_ulaw" | "g711_alaw";
+interface TurnDetectionConfig {
+    /** Server-side VAD type. */
+    type: "server_vad";
+    /** Activation threshold (0-1). Lower = more sensitive. */
+    threshold?: number;
+    /** Duration of speech (ms) required to open the turn. */
+    prefixPaddingMs?: number;
+    /** Duration of silence (ms) required to close the turn. */
+    silenceDurationMs?: number;
+}
+interface RealtimeSessionConfig {
+    instructions?: string;
+    voice?: string;
+    tools?: ToolDefinition[];
+    inputAudioFormat?: AudioFormat;
+    outputAudioFormat?: AudioFormat;
+    turnDetection?: TurnDetectionConfig | null;
+    temperature?: number;
+    maxResponseOutputTokens?: number | "inf";
+    apiKey?: string;
+}
+interface RealtimeToolCall {
+    id: string;
+    name: string;
+    arguments: string;
+}
+type RealtimeEventMap = {
+    audio: {
+        data: Buffer;
+        mimeType?: string;
+    };
+    text: {
+        text: string;
+    };
+    transcript: {
+        text: string;
+        role: "user" | "assistant";
+    };
+    tool_call: RealtimeToolCall;
+    interrupted: {};
+    error: {
+        error: Error;
+    };
+    connected: {};
+    disconnected: {};
+};
+type RealtimeEvent = keyof RealtimeEventMap;
+interface RealtimeConnection {
+    sendAudio(data: Buffer): void;
+    sendText(text: string): void;
+    sendToolResult(callId: string, result: string): void;
+    interrupt(): void;
+    close(): Promise<void>;
+    on<K extends RealtimeEvent>(event: K, handler: (data: RealtimeEventMap[K]) => void): void;
+    off<K extends RealtimeEvent>(event: K, handler: (data: RealtimeEventMap[K]) => void): void;
+}
+interface RealtimeProvider {
+    readonly providerId: string;
+    readonly modelId: string;
+    connect(config: RealtimeSessionConfig): Promise<RealtimeConnection>;
+}
+interface VoiceAgentConfig {
+    name: string;
+    provider: RealtimeProvider;
+    instructions?: string;
+    tools?: ToolDef[];
+    voice?: string;
+    turnDetection?: TurnDetectionConfig | null;
+    inputAudioFormat?: AudioFormat;
+    outputAudioFormat?: AudioFormat;
+    temperature?: number;
+    maxResponseOutputTokens?: number | "inf";
+    eventBus?: EventBus;
+    logLevel?: LogLevel;
+    /** User-scoped memory — persists facts about a user across sessions. */
+    userMemory?: UserMemory;
+    /** LLM model used for auto-extracting user facts from transcripts (required if userMemory is set). */
+    model?: ModelProvider;
+    /** Default session ID (can be overridden per connect()). */
+    sessionId?: string;
+    /** Default user ID (can be overridden per connect()). */
+    userId?: string;
+}
+type VoiceSessionEventMap = RealtimeEventMap & {
+    tool_call_start: {
+        name: string;
+        args: unknown;
+    };
+    tool_result: {
+        name: string;
+        result: string;
+    };
+};
+type VoiceSessionEvent = keyof VoiceSessionEventMap;
+interface VoiceSession {
+    sendAudio(data: Buffer): void;
+    sendText(text: string): void;
+    interrupt(): void;
+    close(): Promise<void>;
+    on<K extends VoiceSessionEvent>(event: K, handler: (data: VoiceSessionEventMap[K]) => void): void;
+    off<K extends VoiceSessionEvent>(event: K, handler: (data: VoiceSessionEventMap[K]) => void): void;
+}
+
+declare class VoiceAgent {
+    readonly name: string;
+    private config;
+    private eventBus;
+    private logger;
+    private toolExecutor;
+    constructor(config: VoiceAgentConfig);
+    connect(opts?: {
+        apiKey?: string;
+        sessionId?: string;
+        userId?: string;
+    }): Promise<VoiceSession>;
+    /**
+     * Consolidate transcript deltas into full messages.
+     * Voice transcripts arrive as many small chunks (one per word/syllable).
+     * Consecutive entries with the same role are merged into a single message.
+     */
+    private consolidateTranscripts;
+    private persistSession;
+    private wireEvents;
+    private handleToolCall;
+}
+
+interface OpenAIRealtimeConfig {
+    apiKey?: string;
+    baseURL?: string;
+}
+declare class OpenAIRealtimeProvider implements RealtimeProvider {
+    readonly providerId = "openai-realtime";
+    readonly modelId: string;
+    private apiKey?;
+    private baseURL?;
+    constructor(modelId?: string, config?: OpenAIRealtimeConfig);
+    connect(config: RealtimeSessionConfig): Promise<RealtimeConnection>;
+    private buildSessionPayload;
+}
+
+interface GoogleLiveConfig {
+    apiKey?: string;
+}
+declare class GoogleLiveProvider implements RealtimeProvider {
+    readonly providerId = "google-live";
+    readonly modelId: string;
+    private apiKey?;
+    constructor(modelId?: string, config?: GoogleLiveConfig);
+    connect(config: RealtimeSessionConfig): Promise<RealtimeConnection>;
+}
+
+/**
+ * Base class for all RadarOS Toolkits.
+ * A Toolkit is a collection of related tools that share configuration.
+ */
+declare abstract class Toolkit {
+    abstract readonly name: string;
+    /**
+     * Returns all tools provided by this toolkit as ToolDef[].
+     * Spread them into an Agent's `tools` array.
+     */
+    abstract getTools(): ToolDef[];
+}
+
+interface WebSearchConfig {
+    /** Search provider: "tavily" or "serpapi". */
+    provider: "tavily" | "serpapi";
+    /** API key for the search provider. Falls back to TAVILY_API_KEY or SERPAPI_API_KEY env vars. */
+    apiKey?: string;
+    /** Max results to return per search (default 5). */
+    maxResults?: number;
+}
+/**
+ * Web Search Toolkit — search the web from your agent.
+ *
+ * Supports Tavily and SerpAPI backends.
+ *
+ * @example
+ * ```ts
+ * const search = new WebSearchToolkit({ provider: "tavily" });
+ * const agent = new Agent({ tools: [...search.getTools()] });
+ * ```
+ */
+declare class WebSearchToolkit extends Toolkit {
+    readonly name = "websearch";
+    private config;
+    constructor(config: WebSearchConfig);
+    private getApiKey;
+    getTools(): ToolDef[];
+    private searchTavily;
+    private searchSerpApi;
+}
+
+interface GmailConfig {
+    /** Path to OAuth2 credentials JSON file. Falls back to GMAIL_CREDENTIALS_PATH env var. */
+    credentialsPath?: string;
+    /** Path to saved token JSON file. Falls back to GMAIL_TOKEN_PATH env var. */
+    tokenPath?: string;
+    /** Pre-authenticated OAuth2 client (if you handle auth yourself). */
+    authClient?: any;
+}
+/**
+ * Gmail Toolkit — send, search, and read emails from your agent.
+ *
+ * Requires: npm install googleapis
+ *
+ * @example
+ * ```ts
+ * const gmail = new GmailToolkit({ credentialsPath: "./credentials.json", tokenPath: "./token.json" });
+ * const agent = new Agent({ tools: [...gmail.getTools()] });
+ * ```
+ */
+declare class GmailToolkit extends Toolkit {
+    readonly name = "gmail";
+    private config;
+    private gmail;
+    constructor(config?: GmailConfig);
+    private getGmailClient;
+    getTools(): ToolDef[];
+}
+
+interface WhatsAppConfig {
+    /** WhatsApp Business API access token. Falls back to WHATSAPP_ACCESS_TOKEN env var. */
+    accessToken?: string;
+    /** WhatsApp Business phone number ID. Falls back to WHATSAPP_PHONE_NUMBER_ID env var. */
+    phoneNumberId?: string;
+    /** API version (default "v22.0"). Falls back to WHATSAPP_VERSION env var. */
+    version?: string;
+    /** Default recipient WhatsApp ID. Falls back to WHATSAPP_RECIPIENT_WAID env var. */
+    recipientWaid?: string;
+}
+/**
+ * WhatsApp Toolkit — send messages via WhatsApp Business Cloud API (Meta).
+ *
+ * Uses the WhatsApp Cloud API directly (no Twilio).
+ * Setup: https://developers.facebook.com/docs/whatsapp/cloud-api/get-started
+ *
+ * @example
+ * ```ts
+ * const whatsapp = new WhatsAppToolkit({
+ *   accessToken: "...",
+ *   phoneNumberId: "...",
+ * });
+ * const agent = new Agent({ tools: [...whatsapp.getTools()] });
+ * ```
+ */
+declare class WhatsAppToolkit extends Toolkit {
+    readonly name = "whatsapp";
+    private accessToken;
+    private phoneNumberId;
+    private version;
+    private recipientWaid;
+    constructor(config?: WhatsAppConfig);
+    private getBaseUrl;
+    private validate;
+    private resolveRecipient;
+    getTools(): ToolDef[];
+}
+
+interface HackerNewsConfig {
+    /** Enable fetching top stories (default true). */
+    enableGetTopStories?: boolean;
+    /** Enable fetching user details (default true). */
+    enableGetUserDetails?: boolean;
+}
+/**
+ * Hacker News Toolkit — search top stories and user details from HN.
+ *
+ * No API key required — uses the public Hacker News API.
+ *
+ * @example
+ * ```ts
+ * const hn = new HackerNewsToolkit();
+ * const agent = new Agent({ tools: [...hn.getTools()] });
+ * ```
+ */
+declare class HackerNewsToolkit extends Toolkit {
+    readonly name = "hackernews";
+    private config;
+    constructor(config?: HackerNewsConfig);
+    getTools(): ToolDef[];
+}
+
+interface DuckDuckGoConfig {
+    /** Enable web search (default true). */
+    enableSearch?: boolean;
+    /** Enable news search (default true). */
+    enableNews?: boolean;
+    /** Fixed max results per query (default 5). */
+    maxResults?: number;
+}
+/**
+ * DuckDuckGo Toolkit — search the web and news without any API key.
+ *
+ * Uses the DuckDuckGo HTML API (no key required).
+ *
+ * @example
+ * ```ts
+ * const ddg = new DuckDuckGoToolkit();
+ * const agent = new Agent({ tools: [...ddg.getTools()] });
+ * ```
+ */
+declare class DuckDuckGoToolkit extends Toolkit {
+    readonly name = "duckduckgo";
+    private config;
+    constructor(config?: DuckDuckGoConfig);
+    getTools(): ToolDef[];
+    private buildSearchTool;
+    private buildNewsTool;
+    private search;
+    private scrapeHtmlSearch;
+    private decodeDdgUrl;
+    private searchNews;
+}
+
+export { type A2AAgentCard, type A2AArtifact, type A2ADataPart, type A2AFilePart, type A2AJsonRpcRequest, type A2AJsonRpcResponse, type A2AMessage, type A2APart, A2ARemoteAgent, type A2ARemoteAgentConfig, type A2ASendParams, type A2ASkill, type A2ATask, type A2ATaskQueryParams, type A2ATaskState, type A2ATextPart, Agent, type AgentConfig, type AgentEventMap, type AgentHooks, type AgentStep, AnthropicProvider, type AppendResult, type Artifact, type AudioFormat, type AudioPart, type BM25Document, BM25Index, type BM25Result, BaseVectorStore, type ChatMessage, type ConditionStep, type ContentPart, type DuckDuckGoConfig, DuckDuckGoToolkit, type EmbeddingProvider, EventBus, type FilePart, type FunctionStep, type GmailConfig, GmailToolkit, GoogleEmbedding, type GoogleEmbeddingConfig, type GoogleLiveConfig, GoogleLiveProvider, GoogleProvider, type GuardrailResult, type HackerNewsConfig, HackerNewsToolkit, type HybridSearchConfig, type ImagePart, InMemoryStorage, InMemoryVectorStore, type InputGuardrail, KnowledgeBase, type KnowledgeBaseConfig, type KnowledgeBaseToolConfig, LLMLoop, type LogLevel, Logger, type LoggerConfig, MCPToolProvider, type MCPToolProviderConfig, 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 OpenAIRealtimeConfig, OpenAIRealtimeProvider, type OutputGuardrail, type ParallelStep, type PgVectorConfig, PgVectorStore, PostgresStorage, type QdrantConfig, QdrantVectorStore, type RRFOptions, type RankedItem, type RealtimeConnection, type RealtimeEvent, type RealtimeEventMap, type RealtimeProvider, type RealtimeSessionConfig, type RealtimeToolCall, type ReasoningConfig, type RetryConfig, RunContext, type RunOpts, type RunOutput, type SearchMode, type Session, SessionManager, type SessionManagerConfig, SqliteStorage, type StepDef, type StepResult, type StorageDriver, type StreamChunk, Team, type TeamConfig, TeamMode, type TextPart, type TokenUsage, type ToolCacheConfig, type ToolCall, type ToolCallResult, type ToolDef, type ToolDefinition, ToolExecutor, type ToolResult, Toolkit, type TurnDetectionConfig, type UserFact, UserMemory, type UserMemoryConfig, type VectorDocument, type VectorSearchOptions, type VectorSearchResult, type VectorStore, type VertexAIConfig, VertexAIProvider, VoiceAgent, type VoiceAgentConfig, type VoiceSession, type VoiceSessionEvent, type VoiceSessionEventMap, type WebSearchConfig, WebSearchToolkit, type WhatsAppConfig, WhatsAppToolkit, Workflow, type WorkflowConfig, type WorkflowResult, anthropic, defineTool, getTextContent, google, isMultiModal, ollama, openai, reciprocalRankFusion, registry, vertex, withRetry };