@aizonaai/adk 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,3198 @@
+import { z, ZodSchema } from 'zod';
+
+/** Supported media types for multi-modal content */
+type MediaType = "image/png" | "image/jpeg" | "image/gif" | "image/webp" | "image/svg+xml" | "audio/mp3" | "audio/wav" | "audio/ogg" | "audio/webm" | "audio/mpeg" | "video/mp4" | "video/webm" | "video/ogg" | "text/html" | "text/css" | "text/javascript" | "application/json" | "application/pdf";
+/** Text content part */
+interface TextPart {
+    type: "text";
+    text: string;
+}
+/** Image content part — base64 or URL */
+interface ImagePart {
+    type: "image";
+    source: {
+        type: "base64";
+        mediaType: MediaType;
+        data: string;
+    } | {
+        type: "url";
+        url: string;
+        detail?: "auto" | "low" | "high";
+    };
+    alt?: string;
+}
+/** Audio content part — base64 or URL */
+interface AudioPart {
+    type: "audio";
+    source: {
+        type: "base64";
+        mediaType: MediaType;
+        data: string;
+    } | {
+        type: "url";
+        url: string;
+    };
+    durationSec?: number;
+    transcript?: string;
+}
+/** Video content part — base64 or URL */
+interface VideoPart {
+    type: "video";
+    source: {
+        type: "base64";
+        mediaType: MediaType;
+        data: string;
+    } | {
+        type: "url";
+        url: string;
+    };
+    durationSec?: number;
+    posterUrl?: string;
+}
+/** UI Artifact content part — rendered in sandboxed iframe */
+interface UIArtifactPart {
+    type: "ui_artifact";
+    artifactId: string;
+    version: number;
+    title: string;
+    kind: "html" | "react" | "svg" | "markdown" | "code";
+    content: string;
+    language?: string;
+    css?: string;
+}
+/** Union of all content part types */
+type ContentPart = TextPart | ImagePart | AudioPart | VideoPart | UIArtifactPart;
+/** Content can be a simple string or an array of content parts */
+type Content = string | ContentPart[];
+
+/** Chat message role */
+type ChatRole = "system" | "user" | "assistant" | "tool";
+/** Tool call within a message */
+interface ToolCall {
+    id: string;
+    name: string;
+    input: unknown;
+}
+/** Tool result within a message */
+interface ToolResult {
+    toolCallId: string;
+    name: string;
+    output: unknown;
+    isError?: boolean;
+}
+/** Chat message — extends platform version with tool support */
+interface ChatMessage {
+    role: ChatRole;
+    content: Content;
+    name?: string;
+    toolCalls?: ToolCall[];
+    toolResults?: ToolResult[];
+}
+/** Chat completion parameters */
+interface ChatParams {
+    messages: ChatMessage[];
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+    topP?: number;
+    stopSequences?: string[];
+    systemPrompt?: string;
+}
+/** Chat completion parameters with tool support */
+interface ChatParamsWithTools extends ChatParams {
+    tools?: LLMToolDefinition[];
+    toolChoice?: "auto" | "required" | "none" | {
+        name: string;
+    };
+    responseFormat?: ResponseFormat;
+}
+/** Tool definition for LLM providers */
+interface LLMToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+/** Response format for structured output */
+type ResponseFormat = {
+    type: "text";
+} | {
+    type: "json_object";
+} | {
+    type: "json_schema";
+    schema: Record<string, unknown>;
+    name?: string;
+};
+/** Chat response */
+interface ChatResponse {
+    content: string;
+    model: string;
+    providerId: string;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    latencyMs: number;
+    ttfbMs?: number;
+    costUsd: number;
+    finishReason: string;
+}
+/** Chat response with tool calls */
+interface ChatResponseWithToolCalls extends ChatResponse {
+    toolCalls?: ToolCall[];
+}
+/** Text completion parameters */
+interface CompleteParams {
+    prompt: string;
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+    topP?: number;
+    stopSequences?: string[];
+}
+/** Text completion response */
+interface CompleteResponse {
+    text: string;
+    model: string;
+    providerId: string;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    latencyMs: number;
+    costUsd: number;
+    finishReason: string;
+}
+/** Embedding parameters */
+interface EmbedParams {
+    input: string | string[];
+    model?: string;
+}
+/** Embedding response */
+interface EmbedResponse {
+    embeddings: number[][];
+    model: string;
+    providerId: string;
+    totalTokens: number;
+    latencyMs: number;
+    costUsd: number;
+}
+/** Stream chunk types from LLM providers */
+type StreamChunk = {
+    type: "text_delta";
+    content: string;
+} | {
+    type: "tool_use_start";
+    id: string;
+    name: string;
+} | {
+    type: "tool_use_delta";
+    id: string;
+    inputJson: string;
+} | {
+    type: "tool_use_end";
+    id: string;
+} | {
+    type: "message_end";
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+};
+/** Base LLM provider interface (from platform-agents) */
+interface LLMProvider {
+    readonly providerId: string;
+    readonly displayName: string;
+    readonly isLocal: boolean;
+    chat(params: ChatParams): Promise<ChatResponse>;
+    complete(params: CompleteParams): Promise<CompleteResponse>;
+    embed?(params: EmbedParams): Promise<EmbedResponse>;
+    isAvailable(): boolean;
+    getModels(): string[];
+    estimateCost(inputTokens: number, outputTokens: number, model?: string): number;
+}
+/** Extended ADK provider interface with tool calling + streaming */
+interface ADKLLMProvider extends LLMProvider {
+    chatWithTools(params: ChatParamsWithTools): Promise<ChatResponseWithToolCalls>;
+    chatStream(params: ChatParamsWithTools): AsyncGenerator<StreamChunk>;
+}
+/** Routing strategy (5 strategies from LLMRouter) */
+type RoutingStrategy = "cost-optimized" | "latency-optimized" | "quality-optimized" | "balanced" | "fallback-chain";
+/** Budget period for cost tracking */
+type BudgetPeriod = "day" | "week" | "month";
+/** Agent LLM configuration */
+interface AgentLLMConfig {
+    agentSlug: string;
+    enabledProviders: string[];
+    strategy: RoutingStrategy;
+    budgetLimitUsd?: number;
+    budgetPeriod?: BudgetPeriod;
+    maxLatencyMs?: number;
+    fallbackChain?: string[];
+    preferredModel?: string;
+}
+/** Circuit breaker state per provider */
+interface CircuitBreakerState {
+    providerId: string;
+    state: "closed" | "open" | "half-open";
+    failures: number;
+    lastFailure: number | null;
+    lastSuccess: number | null;
+    openedAt: number | null;
+}
+/** Provider metrics */
+interface ProviderMetrics {
+    providerId: string;
+    totalCalls: number;
+    successCalls: number;
+    failedCalls: number;
+    avgLatencyMs: number;
+    totalCostUsd: number;
+    lastCallAt: number | null;
+}
+/** Provider initialization configuration */
+interface ProviderInitConfig {
+    providerId: string;
+    apiKey?: string;
+    baseUrl?: string;
+    defaultModel?: string;
+    modelCosts?: Map<string, {
+        input: number;
+        output: number;
+    }>;
+    knownModels?: string[];
+}
+/** Model catalog entry */
+interface CatalogModel {
+    modelId: string;
+    providerId: string;
+    displayName: string;
+    description: string;
+    modality: "chat" | "completion" | "embedding" | "image" | "video" | "audio" | "multimodal";
+    capabilities: ModelCapability[];
+    costPerMTInput: number;
+    costPerMTOutput: number;
+    contextWindowInput: number;
+    contextWindowOutput: number;
+    releaseDate?: string;
+    deprecatedAt?: string;
+    isPreview?: boolean;
+    aliases?: string[];
+}
+/** Model capability tags */
+type ModelCapability = "text" | "code" | "vision" | "image-generation" | "video-generation" | "audio" | "embeddings" | "function-calling" | "thinking" | "streaming" | "json-mode";
+
+type SpanType = "agent" | "llm" | "tool" | "guardrail" | "handoff" | "session" | "pipeline";
+interface SpanEvent {
+    name: string;
+    timestamp: number;
+    data?: Record<string, unknown>;
+}
+interface SpanData {
+    id: string;
+    traceId: string;
+    parentSpanId?: string;
+    name: string;
+    type: SpanType;
+    startTime: number;
+    endTime?: number;
+    durationMs?: number;
+    attributes: Record<string, unknown>;
+    events: SpanEvent[];
+    status: "ok" | "error";
+    error?: string;
+}
+declare class Span {
+    readonly id: string;
+    readonly traceId: string;
+    readonly parentSpanId?: string;
+    readonly name: string;
+    readonly type: SpanType;
+    readonly startTime: number;
+    private _endTime?;
+    private _attributes;
+    private _events;
+    private _status;
+    private _error?;
+    constructor(traceId: string, name: string, type: SpanType, parentSpanId?: string);
+    setAttributes(attrs: Record<string, unknown>): void;
+    setAttribute(key: string, value: unknown): void;
+    addEvent(name: string, data?: Record<string, unknown>): void;
+    setError(error: string): void;
+    end(): void;
+    get durationMs(): number | undefined;
+    toJSON(): SpanData;
+}
+
+interface TraceData {
+    id: string;
+    name: string;
+    startTime: number;
+    endTime?: number;
+    durationMs?: number;
+    spans: SpanData[];
+    metadata: Record<string, unknown>;
+}
+interface TraceExporter {
+    export(trace: TraceData): Promise<void>;
+}
+declare class Trace {
+    readonly id: string;
+    readonly name: string;
+    readonly startTime: number;
+    private _endTime?;
+    private _spans;
+    private _metadata;
+    constructor(name: string, metadata?: Record<string, unknown>);
+    startSpan(name: string, type: SpanType, parentSpanId?: string): Span;
+    setMetadata(key: string, value: unknown): void;
+    end(): void;
+    get durationMs(): number | undefined;
+    get spans(): Span[];
+    toJSON(): TraceData;
+}
+declare class Tracer {
+    private exporters;
+    private traces;
+    addExporter(exporter: TraceExporter): void;
+    startTrace(name: string, metadata?: Record<string, unknown>): Trace;
+    endAndExport(trace: Trace): Promise<void>;
+    getTraces(): Trace[];
+}
+
+/** Stored artifact with metadata */
+interface Artifact {
+    id: string;
+    title: string;
+    kind: "html" | "react" | "svg" | "markdown" | "code";
+    content: string;
+    css?: string;
+    language?: string;
+    version: number;
+    createdAt: number;
+    updatedAt: number;
+    agentName: string;
+    runId: string;
+}
+/**
+ * In-memory artifact store. Persists artifacts created by agents
+ * during runs. Supports versioning (upsert bumps version).
+ */
+declare class ArtifactStore {
+    private artifacts;
+    /** Create or update an artifact from a UIArtifactPart */
+    upsert(part: UIArtifactPart, agentName: string, runId: string): Artifact;
+    /** Get a specific artifact by ID */
+    get(artifactId: string): Artifact | undefined;
+    /** Get all artifacts for a specific run */
+    getByRun(runId: string): Artifact[];
+    /** Get all stored artifacts */
+    getAll(): Artifact[];
+    /** Clear all artifacts */
+    clear(): void;
+    /** Get the number of stored artifacts */
+    get size(): number;
+}
+
+/** Guardrail type */
+type GuardrailType = "input" | "output" | "tool";
+/** Severity level for guardrail results */
+type GuardrailSeverity = "info" | "warning" | "error" | "critical";
+/** Guardrail result */
+interface GuardrailResult {
+    name: string;
+    type: GuardrailType;
+    passed: boolean;
+    /** If true and passed=false, immediately stop the run */
+    tripwire: boolean;
+    message?: string;
+    metadata?: Record<string, unknown>;
+    /** Severity level (default: "error" for backward compat) */
+    severity?: GuardrailSeverity;
+    /** Confidence score 0-1 */
+    score?: number;
+}
+/** Input guardrail — runs before LLM call */
+interface InputGuardrail {
+    name: string;
+    type: "input";
+    /** Whether failing this guardrail should stop execution immediately */
+    tripwire: boolean;
+    execute(input: string, messages: ChatMessage[], ctx: RunContext): Promise<GuardrailResult>;
+}
+/** Output guardrail — runs after LLM response */
+interface OutputGuardrail {
+    name: string;
+    type: "output";
+    tripwire: boolean;
+    execute(output: string, messages: ChatMessage[], ctx: RunContext): Promise<GuardrailResult>;
+}
+/** Tool guardrail — runs before tool execution */
+interface ToolGuardrail {
+    name: string;
+    type: "tool";
+    tripwire: boolean;
+    execute(toolName: string, input: unknown, ctx: RunContext): Promise<GuardrailResult>;
+}
+/**
+ * Content guardrail — forward-compatible type for multi-modal content inspection.
+ * Not wired into the engine yet. Defined here for future use by guardrail authors.
+ */
+interface ContentGuardrail {
+    name: string;
+    type: "content";
+    tripwire: boolean;
+    execute(content: Content, messages: ChatMessage[], ctx: RunContext): Promise<GuardrailResult>;
+}
+/** Union of all guardrail types */
+type Guardrail = InputGuardrail | OutputGuardrail | ToolGuardrail;
+/** Guardrail configuration (used in AgentConfig) */
+interface GuardrailConfig {
+    guardrail: Guardrail;
+    /** Override tripwire setting */
+    tripwire?: boolean;
+}
+/** Consent decision (from platform consent gate) */
+interface ConsentDecision {
+    allowed: boolean;
+    requestId?: string;
+    status: "approved" | "rejected" | "pending" | "expired" | "auto";
+    reason?: string;
+}
+/** Consent request for explicit/multi-party consent */
+interface ConsentRequest {
+    id: string;
+    agentName: string;
+    action: string;
+    consentLevel: "auto" | "notify" | "explicit" | "multi_party";
+    requiredApprovals: number;
+    currentApprovals: string[];
+    rejectedBy: string | null;
+    status: "pending" | "approved" | "rejected" | "expired";
+    createdAt: number;
+    expiresAt: number;
+    metadata?: Record<string, unknown>;
+}
+/** Consent handler (provided by caller for explicit consent flows) */
+type ConsentHandler = (request: ConsentRequest) => Promise<ConsentDecision>;
+
+/** Session state */
+type SessionStatus = "active" | "expired" | "closed";
+/** Session data */
+interface Session {
+    id: string;
+    agentName: string;
+    messages: ChatMessage[];
+    metadata: Record<string, unknown>;
+    status: SessionStatus;
+    parentId?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    expiresAt?: Date;
+}
+/** Session create options */
+interface SessionCreateOptions {
+    agentName: string;
+    metadata?: Record<string, unknown>;
+    expiresAt?: Date;
+}
+/** Session update options */
+interface SessionUpdateOptions {
+    messages?: ChatMessage[];
+    metadata?: Record<string, unknown>;
+    status?: SessionStatus;
+}
+/** Session backend interface — all backends implement this */
+interface SessionBackend {
+    /** Create a new session */
+    create(options: SessionCreateOptions): Promise<Session>;
+    /** Get a session by ID */
+    get(sessionId: string): Promise<Session | null>;
+    /** Update a session */
+    update(sessionId: string, options: SessionUpdateOptions): Promise<Session>;
+    /** Append messages to a session */
+    appendMessages(sessionId: string, messages: ChatMessage[]): Promise<Session>;
+    /** Fork a session (create a copy with new ID, reference to parent) */
+    fork(sessionId: string): Promise<Session>;
+    /** Delete a session */
+    delete(sessionId: string): Promise<void>;
+    /** List sessions (optional filter) */
+    list(filter?: SessionListFilter): Promise<Session[]>;
+}
+/** Session list filter */
+interface SessionListFilter {
+    agentName?: string;
+    status?: SessionStatus;
+    limit?: number;
+    offset?: number;
+}
+/** Context management strategy */
+type ContextStrategy = "sliding-window" | "smart-summary" | "jit";
+
+/** Feature definition for harness progress tracking */
+interface ProgressFeatureConfig {
+    id: string;
+    name: string;
+}
+/** Harness configuration for long-running agent sessions */
+interface HarnessConfig {
+    /** Enable progress tracking tools */
+    enableProgress?: boolean;
+    /** Enable note-taking tools */
+    enableNotes?: boolean;
+    /** Initial features to track (if enableProgress) */
+    features?: ProgressFeatureConfig[];
+}
+/** Run configuration — input to Runner.run() */
+interface RunConfig {
+    /** User input message (string or multi-modal ContentPart[]) */
+    input: string | ContentPart[];
+    /** Session ID to resume (optional) */
+    sessionId?: string;
+    /** Previous messages to include (if no sessionId) */
+    messages?: ChatMessage[];
+    /** Model override for this run */
+    model?: string | ModelConfig;
+    /** Max turns override */
+    maxTurns?: number;
+    /** Abort signal for cancellation */
+    signal?: AbortSignal;
+    /** Run metadata */
+    metadata?: Record<string, unknown>;
+    /** Harness tools for long-running sessions */
+    harness?: HarnessConfig;
+}
+/** Run result — output from Runner.run() */
+interface RunResult {
+    /** Text output from the agent */
+    output: string;
+    /** Multi-modal output parts (if response contains non-text content) */
+    outputParts?: ContentPart[];
+    /** Structured output (if agent has outputSchema) */
+    structuredOutput?: unknown;
+    /** Full message history */
+    messages: ChatMessage[];
+    /** Usage statistics */
+    usage: RunUsage;
+    /** Handoff chain (if multi-agent) */
+    handoffs: HandoffRecord[];
+    /** Guardrail results */
+    guardrailResults: GuardrailResult[];
+    /** Trace ID for observability */
+    traceId: string;
+    /** Session ID (if sessions enabled) */
+    sessionId?: string;
+    /** Name of the agent that produced final output */
+    finalAgent: string;
+    /** Run ID */
+    runId: string;
+    /** Total turns executed */
+    totalTurns: number;
+    /** Artifacts created during the run */
+    artifacts?: Artifact[];
+}
+/** Usage statistics for a run */
+interface RunUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalCostUsd: number;
+    latencyMs: number;
+}
+/** Record of a handoff during a run */
+interface HandoffRecord {
+    fromAgent: string;
+    toAgent: string;
+    reason: string;
+    turnNumber: number;
+}
+/** Stream events emitted during execution */
+type StreamEvent = {
+    type: "text_delta";
+    content: string;
+    agentName: string;
+} | {
+    type: "image_output";
+    image: ImagePart;
+    agentName: string;
+} | {
+    type: "audio_output";
+    audio: AudioPart;
+    agentName: string;
+} | {
+    type: "video_output";
+    video: VideoPart;
+    agentName: string;
+} | {
+    type: "ui_artifact";
+    artifact: UIArtifactPart;
+    agentName: string;
+} | {
+    type: "tool_call_start";
+    toolName: string;
+    agentName: string;
+    input: unknown;
+} | {
+    type: "tool_call_end";
+    toolName: string;
+    agentName: string;
+    output: unknown;
+} | {
+    type: "handoff";
+    fromAgent: string;
+    toAgent: string;
+    reason: string;
+} | {
+    type: "guardrail";
+    name: string;
+    passed: boolean;
+    tripwire: boolean;
+    message?: string;
+} | {
+    type: "turn_complete";
+    agentName: string;
+    turnNumber: number;
+} | {
+    type: "run_complete";
+    result: RunResult;
+} | {
+    type: "error";
+    error: string;
+    agentName: string;
+};
+/** Runner configuration */
+interface RunnerConfig {
+    /** Default model for all agents */
+    defaultModel?: string | ModelConfig;
+    /** Default max turns */
+    defaultMaxTurns?: number;
+    /** Session backend */
+    sessionBackend?: SessionBackend;
+    /** Tracing configuration */
+    tracing?: TracingConfig;
+    /** Tracer instance for structured span-based tracing */
+    tracer?: Tracer;
+    /** Model context window size override (auto-detected from model catalog if not set) */
+    modelContextWindow?: number;
+    /** Model catalog for context window lookups (optional, for auto-detection) */
+    modelCatalog?: CatalogModel[];
+    /** Artifact store for A2UI artifact persistence (optional) */
+    artifactStore?: ArtifactStore;
+    /** Enable code execution mode (programmatic tool calling) */
+    enableCodeExecution?: boolean;
+}
+/** Tracing configuration */
+interface TracingConfig {
+    enabled?: boolean;
+    exporter?: "console" | "langfuse" | "eventbus";
+    exporterConfig?: Record<string, unknown>;
+}
+/** Run context — available to agents, tools, and guardrails during execution */
+interface RunContext {
+    /** Current run ID */
+    runId: string;
+    /** Current agent name */
+    agentName: string;
+    /** Current turn number */
+    turnNumber: number;
+    /** Session ID (if sessions enabled) */
+    sessionId?: string;
+    /** Trace ID */
+    traceId: string;
+    /** Accumulated usage */
+    usage: RunUsage;
+    /** Abort signal */
+    signal?: AbortSignal;
+    /** Run metadata */
+    metadata: Record<string, unknown>;
+}
+
+/** Tool context passed to tool execute functions */
+interface ToolContext {
+    /** Current run context */
+    runContext: RunContext;
+    /** ID of the tool call (from LLM) */
+    toolCallId: string;
+    /** Agent invoking the tool */
+    agentName: string;
+}
+/** Pre-execute hook result */
+interface ToolPreHookResult {
+    /** Whether to proceed with execution */
+    allow: boolean;
+    /** Modified input (if allow=true and modification needed) */
+    modifiedInput?: unknown;
+    /** Reason for blocking (if allow=false) */
+    reason?: string;
+}
+/** Post-execute hook result */
+interface ToolPostHookResult {
+    /** Modified output (if modification needed) */
+    modifiedOutput?: unknown;
+}
+/** Tool hooks for pre/post execution */
+interface ToolHooks {
+    preExecute?: (input: unknown, ctx: ToolContext) => Promise<ToolPreHookResult> | ToolPreHookResult;
+    postExecute?: (input: unknown, output: unknown, ctx: ToolContext) => Promise<ToolPostHookResult> | ToolPostHookResult;
+}
+/** Example input for a tool (shown to LLM for better accuracy) */
+interface ToolExample {
+    /** Example input values */
+    input: Record<string, unknown>;
+    /** Description of what this example demonstrates */
+    description?: string;
+}
+/** Tool definition — unifies skills, MCP tools, and custom functions */
+interface ToolDef<TInput = unknown, TOutput = unknown> {
+    /** Unique tool name */
+    name: string;
+    /** Description shown to LLM */
+    description: string;
+    /** Input schema (Zod for validation, JSON Schema for LLM) */
+    inputSchema: z.ZodSchema<TInput> | JsonSchema;
+    /** Optional output schema */
+    outputSchema?: z.ZodSchema<TOutput> | JsonSchema;
+    /** Execute function */
+    execute: (input: TInput, ctx: ToolContext) => Promise<TOutput>;
+    /** Optional pre/post execution hooks */
+    hooks?: ToolHooks;
+    /** Tool metadata */
+    metadata?: Record<string, unknown>;
+    /** If true, tool is not sent to LLM until explicitly loaded via tool_search */
+    deferLoading?: boolean;
+    /** Example inputs to improve LLM accuracy */
+    examples?: ToolExample[];
+    /** Per-tool timeout in milliseconds (default: 30000) */
+    timeoutMs?: number;
+    /** Number of retries on failure (default: 0) */
+    retries?: number;
+}
+/** Tool definition config (for defineTool() builder) */
+interface ToolDefConfig<TInput = unknown, TOutput = unknown> {
+    name: string;
+    description: string;
+    inputSchema: z.ZodSchema<TInput> | JsonSchema;
+    outputSchema?: z.ZodSchema<TOutput> | JsonSchema;
+    execute: (input: TInput, ctx: ToolContext) => Promise<TOutput>;
+    hooks?: ToolHooks;
+    metadata?: Record<string, unknown>;
+    deferLoading?: boolean;
+    examples?: ToolExample[];
+    timeoutMs?: number;
+    retries?: number;
+}
+
+/** Tool selection strategy */
+type ToolSelectionStrategy = "all" | "keyword" | "deferred";
+/** Tool selection configuration */
+interface ToolSelectionConfig {
+    /** Max tools to send to LLM per turn (default: 20) */
+    maxToolsPerTurn?: number;
+    /** Selection strategy (default: "all") */
+    strategy?: ToolSelectionStrategy;
+    /** Minimum relevance score to include (default: 0.1) */
+    minRelevance?: number;
+    /** Boost tools used in recent turns (default: true) */
+    includeRecentlyUsed?: boolean;
+    /** How many recent turns to consider for recently-used boost (default: 3) */
+    recentTurnWindow?: number;
+    /** Tool names that are never filtered out */
+    alwaysInclude?: string[];
+}
+/** Tool relevance score */
+interface ToolRelevanceScore {
+    tool: ToolDef;
+    score: number;
+    reason: string;
+}
+/**
+ * ToolSelector — selects relevant tools for each LLM turn.
+ *
+ * Strategies:
+ * - "all": pass through all tools (no filtering)
+ * - "keyword": extract keywords from recent messages, match against tool name + description
+ */
+declare class ToolSelector {
+    private config;
+    constructor(config?: ToolSelectionConfig);
+    /** Select tools relevant to the current conversation turn */
+    selectTools(allTools: ToolDef[], messages: ChatMessage[], _turnNumber: number, recentToolCalls?: string[]): ToolDef[];
+    /** Score all tools by relevance to current messages */
+    scoreTools(allTools: ToolDef[], messages: ChatMessage[], recentToolCalls?: string[]): ToolRelevanceScore[];
+    /** Extract keywords from messages */
+    private extractKeywords;
+    /** Tokenize text into words */
+    private tokenize;
+}
+
+/** Agent consent levels (extracted from platform-agents) */
+type ConsentLevel = "auto" | "notify" | "explicit" | "multi_party";
+/** Agent autonomy levels */
+type AutonomyLevel = "autonomous" | "semi_autonomous" | "composite" | "oracle";
+/** Model configuration for multi-provider routing */
+interface ModelConfig {
+    provider?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    routingStrategy?: RoutingStrategy;
+    fallbackChain?: string[];
+}
+/** Handoff target definition */
+interface HandoffTarget {
+    agent: string | AgentConfig;
+    description: string;
+    filter?: (ctx: RunContext) => boolean | Promise<boolean>;
+}
+/** JSON Schema type for structured output */
+type JsonSchema = Record<string, unknown>;
+/** Agent configuration — the core definition */
+interface AgentConfig {
+    /** Unique agent name */
+    name: string;
+    /** System instructions — can be static or dynamic */
+    instructions: string | ((ctx: RunContext) => string | Promise<string>);
+    /** Model to use (string shorthand or full config) */
+    model?: string | ModelConfig;
+    /** Tools available to this agent */
+    tools?: ToolDef[];
+    /** Agents this agent can hand off to */
+    handoffs?: HandoffTarget[];
+    /** Structured output schema (Zod or JSON Schema) */
+    outputSchema?: z.ZodSchema | JsonSchema;
+    /** Guardrails to apply */
+    guardrails?: GuardrailConfig[];
+    /** Consent level for execution */
+    consentLevel?: ConsentLevel;
+    /** Maximum turns before stopping */
+    maxTurns?: number;
+    /** Budget limit in USD */
+    budgetLimitUsd?: number;
+    /** Agent description (for tool/handoff descriptions) */
+    description?: string;
+    /** Agent metadata */
+    metadata?: Record<string, unknown>;
+    /** Tool selection config (dynamic per-turn filtering) */
+    toolSelection?: ToolSelectionConfig;
+    /** Context management config */
+    contextConfig?: ContextConfig;
+}
+/** Context management configuration */
+interface ContextConfig {
+    /** Context trimming strategy */
+    strategy?: ContextStrategy;
+    /** Fraction of model's context window to use (default: 0.85) */
+    contextBudgetRatio?: number;
+    /** Explicit fixed token budget — overrides ratio-based calculation */
+    maxContextTokens?: number;
+    /** Always keep this many recent turns verbatim (default: 4) */
+    keepRecentTurns?: number;
+    /** Cheaper model for summarization (e.g., "claude-haiku-4-5-20251001") */
+    summaryModel?: string;
+    /** Token counting strategy */
+    tokenCounterStrategy?: "character" | "tiktoken-approx" | "provider-reported";
+}
+/** Resolved agent info for handoffs and multi-agent scenarios */
+interface AgentInfo {
+    name: string;
+    description?: string;
+    consentLevel: ConsentLevel;
+}
+
+interface TaskSubmittedEvent {
+    taskId: string;
+    agentSlug: string;
+    skill: string;
+    title: string;
+    timestamp: number;
+}
+interface TaskStartedEvent {
+    taskId: string;
+    agentSlug: string;
+    skill: string;
+    timestamp: number;
+}
+interface TaskCompletedEvent {
+    taskId: string;
+    agentSlug: string;
+    skill: string;
+    durationMs: number;
+    output?: string;
+    timestamp: number;
+}
+interface TaskFailedEvent {
+    taskId: string;
+    agentSlug: string;
+    skill: string;
+    error: string;
+    durationMs: number;
+    timestamp: number;
+}
+interface AgentStartedEvent {
+    agentSlug: string;
+    mode: "deterministic" | "llm";
+    timestamp: number;
+}
+interface AgentStoppedEvent {
+    agentSlug: string;
+    reason?: string;
+    timestamp: number;
+}
+interface AgentErrorEvent {
+    agentSlug: string;
+    error: string;
+    taskId?: string;
+    timestamp: number;
+}
+interface AgentLogEvent {
+    agentSlug: string;
+    level: "debug" | "info" | "warn" | "error";
+    message: string;
+    metadata?: Record<string, unknown>;
+    taskId?: string;
+    timestamp: number;
+}
+interface AgentHeartbeatEvent {
+    agentSlug: string;
+    queueDepth: number;
+    activeTaskId?: string;
+    memoryMb?: number;
+    timestamp: number;
+}
+interface AlertCreatedEvent {
+    alertId: string;
+    agentSlug?: string;
+    severity: "info" | "warning" | "critical";
+    title: string;
+    message: string;
+    timestamp: number;
+}
+interface AlertResolvedEvent {
+    alertId: string;
+    resolvedBy: string;
+    timestamp: number;
+}
+interface LLMCallCompletedEvent {
+    callId: string;
+    providerId: string;
+    model: string;
+    agentSlug?: string;
+    taskId?: string;
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    latencyMs: number;
+    ttfbMs?: number;
+    timestamp: number;
+}
+interface LLMCallFailedEvent {
+    callId: string;
+    providerId: string;
+    model: string;
+    agentSlug?: string;
+    taskId?: string;
+    error: string;
+    errorCode?: string;
+    latencyMs: number;
+    timestamp: number;
+}
+interface LLMProviderSwitchedEvent {
+    agentSlug: string;
+    fromProviderId: string;
+    toProviderId: string;
+    reason: string;
+    timestamp: number;
+}
+interface HealthCheckEvent {
+    healthy: string[];
+    unhealthy: string[];
+    restarted: string[];
+    staleTasks: string[];
+    timestamp: number;
+}
+interface ModelsDiscoveredEvent {
+    providerId: string;
+    modelsFound: number;
+    catalogMatches: number;
+    errors: string[];
+    timestamp: number;
+}
+interface RunStartedEvent {
+    runId: string;
+    agentName: string;
+    sessionId?: string;
+    traceId: string;
+    timestamp: number;
+}
+interface RunCompletedEvent {
+    runId: string;
+    agentName: string;
+    totalTurns: number;
+    totalCostUsd: number;
+    totalLatencyMs: number;
+    sessionId?: string;
+    traceId: string;
+    timestamp: number;
+}
+interface RunFailedEvent {
+    runId: string;
+    agentName: string;
+    error: string;
+    turnNumber: number;
+    sessionId?: string;
+    traceId: string;
+    timestamp: number;
+}
+interface HandoffEvent {
+    runId: string;
+    fromAgent: string;
+    toAgent: string;
+    reason: string;
+    turnNumber: number;
+    timestamp: number;
+}
+interface GuardrailTriggeredEvent {
+    runId: string;
+    guardrailName: string;
+    type: "input" | "output" | "tool";
+    passed: boolean;
+    tripwire: boolean;
+    agentName: string;
+    severity?: string;
+    message?: string;
+    timestamp: number;
+}
+interface ToolExecutedEvent {
+    runId: string;
+    toolName: string;
+    agentName: string;
+    latencyMs: number;
+    success: boolean;
+    error?: string;
+    timestamp: number;
+}
+interface SessionCreatedEvent {
+    sessionId: string;
+    agentName: string;
+    timestamp: number;
+}
+interface SessionResumedEvent {
+    sessionId: string;
+    agentName: string;
+    messageCount: number;
+    timestamp: number;
+}
+interface ContextTrimmedEvent {
+    runId: string;
+    agentName: string;
+    strategy: "sliding-window" | "smart-summary" | "jit";
+    originalTokens: number;
+    trimmedTokens: number;
+    messagesRemoved: number;
+    turnNumber: number;
+    timestamp: number;
+}
+interface ToolsSelectedEvent {
+    runId: string;
+    agentName: string;
+    totalTools: number;
+    selectedTools: number;
+    selectedNames: string[];
+    strategy: "all" | "keyword" | "deferred";
+    turnNumber: number;
+    timestamp: number;
+}
+interface ArtifactCreatedEvent {
+    runId: string;
+    agentName: string;
+    artifactId: string;
+    title: string;
+    kind: "html" | "react" | "svg" | "markdown" | "code";
+    version: number;
+    timestamp: number;
+}
+/** Full ADK event map — type-safe pub/sub */
+interface ADKEventMap {
+    "task.submitted": TaskSubmittedEvent;
+    "task.started": TaskStartedEvent;
+    "task.completed": TaskCompletedEvent;
+    "task.failed": TaskFailedEvent;
+    "agent.started": AgentStartedEvent;
+    "agent.stopped": AgentStoppedEvent;
+    "agent.error": AgentErrorEvent;
+    "agent.log": AgentLogEvent;
+    "agent.heartbeat": AgentHeartbeatEvent;
+    "alert.created": AlertCreatedEvent;
+    "alert.resolved": AlertResolvedEvent;
+    "llm.call.completed": LLMCallCompletedEvent;
+    "llm.call.failed": LLMCallFailedEvent;
+    "llm.provider.switched": LLMProviderSwitchedEvent;
+    "health.check": HealthCheckEvent;
+    "models.discovered": ModelsDiscoveredEvent;
+    "run.started": RunStartedEvent;
+    "run.completed": RunCompletedEvent;
+    "run.failed": RunFailedEvent;
+    handoff: HandoffEvent;
+    "guardrail.triggered": GuardrailTriggeredEvent;
+    "tool.executed": ToolExecutedEvent;
+    "session.created": SessionCreatedEvent;
+    "session.resumed": SessionResumedEvent;
+    "context.trimmed": ContextTrimmedEvent;
+    "tools.selected": ToolsSelectedEvent;
+    "artifact.created": ArtifactCreatedEvent;
+}
+/** Event name type */
+type ADKEventName = keyof ADKEventMap;
+/** Event listener type */
+type ADKEventListener<K extends ADKEventName> = (data: ADKEventMap[K]) => void;
+
+declare class ADKEventBus {
+    private listeners;
+    /** Subscribe to an event. Returns unsubscribe function. */
+    on<K extends ADKEventName>(event: K, listener: ADKEventListener<K>): () => void;
+    /** Subscribe to an event once. Auto-unsubscribes after first emit. */
+    once<K extends ADKEventName>(event: K, listener: ADKEventListener<K>): () => void;
+    /** Unsubscribe a specific listener. */
+    off<K extends ADKEventName>(event: K, listener: ADKEventListener<K>): void;
+    /** Emit an event to all listeners. */
+    emit<K extends ADKEventName>(event: K, data: ADKEventMap[K]): void;
+    /** Get the number of listeners for an event. */
+    listenerCount(event: ADKEventName): number;
+    /** Get all events with active listeners. */
+    activeEvents(): ADKEventName[];
+    /** Remove all listeners for all events. */
+    removeAllListeners(): void;
+}
+
+/** Agent class — wraps config with utility methods */
+declare class Agent {
+    readonly name: string;
+    readonly config: Readonly<AgentConfig>;
+    private runtimeTools;
+    constructor(config: AgentConfig);
+    /** Resolve instructions (handles static string or dynamic function) */
+    getInstructions(ctx: RunContext): Promise<string>;
+    /** Get tool definitions (config tools + runtime-injected tools) */
+    getTools(): ToolDef[];
+    /** Add a tool at runtime (e.g., harness tools injected by Runner) */
+    addTool(tool: ToolDef<any, any>): void;
+    /** Get handoff targets */
+    getHandoffs(): HandoffTarget[];
+    /** Get output schema (Zod or JSON Schema) */
+    getOutputSchema(): z.ZodSchema | JsonSchema | undefined;
+    /** Get consent level */
+    getConsentLevel(): ConsentLevel;
+    /** Get max turns */
+    getMaxTurns(): number;
+    /** Get budget limit */
+    getBudgetLimit(): number | undefined;
+    /** Get tool selection config */
+    getToolSelection(): ToolSelectionConfig | undefined;
+    /** Get context config */
+    getContextConfig(): ContextConfig | undefined;
+    /** Clone agent with config overrides */
+    clone(overrides?: Partial<AgentConfig>): Agent;
+}
+/** Define an agent from config */
+declare function defineAgent(config: AgentConfig): Agent;
+
+/** Define a tool from config */
+declare function defineTool<TInput = unknown, TOutput = unknown>(config: ToolDefConfig<TInput, TOutput>): ToolDef<TInput, TOutput>;
+
+/** Search result from the tool registry */
+interface ToolSearchResult {
+    name: string;
+    description: string;
+    score: number;
+}
+/**
+ * ToolRegistry — central store for all tools with BM25-style search.
+ * Supports deferred loading: tools marked `deferLoading: true` are stored
+ * but not returned to the LLM until explicitly loaded via search.
+ */
+declare class ToolRegistry {
+    private tools;
+    private loadedDeferred;
+    /** Register a tool */
+    register(tool: ToolDef): void;
+    /** Register multiple tools */
+    registerAll(tools: ToolDef[]): void;
+    /** Get a tool by name */
+    get(name: string): ToolDef | undefined;
+    /** Check if a tool exists */
+    has(name: string): boolean;
+    /** Search tools by query using BM25-style keyword matching */
+    search(query: string, limit?: number): ToolSearchResult[];
+    /** Load a deferred tool (mark it as available for LLM) */
+    load(name: string): ToolDef | undefined;
+    /** Get all eager (non-deferred) tools */
+    getEager(): ToolDef[];
+    /** Get all tools that should be sent to LLM (eager + loaded deferred) */
+    getAvailable(): ToolDef[];
+    /** Check if a deferred tool has been loaded */
+    isLoaded(name: string): boolean;
+    /** Get all registered tool names */
+    getAllNames(): string[];
+    /** Clear all tools and loaded state */
+    clear(): void;
+    private tokenize;
+}
+
+/**
+ * Create a tool_search tool bound to a specific ToolRegistry.
+ * Agents use this to discover and load deferred tools at runtime.
+ */
+declare function createToolSearchTool(registry: ToolRegistry): ToolDef<{
+    query: string;
+}, {
+    tools: {
+        name: string;
+        description: string;
+    }[];
+}>;
+
+/** Convert a Zod schema to JSON Schema */
+declare function zodToJsonSchema(schema: ZodSchema): JsonSchema;
+/** Check if a value is a Zod schema */
+declare function isZodSchema(value: unknown): value is ZodSchema;
+/** Ensure we have a JSON Schema (convert Zod if needed) */
+declare function ensureJsonSchema(schema: ZodSchema | JsonSchema): JsonSchema;
+
+/** Validate output against a Zod schema */
+declare function validateOutput<T>(output: string, schema: ZodSchema<T>): {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: string;
+};
+/** Anthropic structured output: use tool_use with forced single-tool call */
+declare function toAnthropicToolSchema(schema: ZodSchema | JsonSchema, name?: string): {
+    name: string;
+    description: string;
+    input_schema: JsonSchema;
+};
+/** OpenAI structured output: response_format with json_schema */
+declare function toOpenAIResponseFormat(schema: ZodSchema | JsonSchema, name?: string): {
+    type: "json_schema";
+    json_schema: {
+        name: string;
+        strict: boolean;
+        schema: JsonSchema;
+    };
+};
+/** Google structured output: generation_config.response_schema */
+declare function toGoogleSchemaFormat(schema: ZodSchema | JsonSchema): {
+    responseMimeType: string;
+    responseSchema: JsonSchema;
+};
+/** Convert a schema (Zod or JSON) to LLM tool definition format */
+declare function schemaToToolInput(schema: ZodSchema | JsonSchema): Record<string, unknown>;
+
+/** Error thrown when a tripwire guardrail fails */
+declare class GuardrailTripwireError extends Error {
+    readonly guardrailName: string;
+    readonly result: GuardrailResult;
+    constructor(guardrailName: string, result: GuardrailResult);
+}
+declare class GuardrailEngine {
+    private eventBus?;
+    /** Attach an ADKEventBus for guardrail audit events */
+    setEventBus(bus: ADKEventBus): void;
+    /**
+     * Determine whether a guardrail result should block execution.
+     * - info/warning: never block (soft constraints)
+     * - critical: always block regardless of tripwire
+     * - error (default): block only if tripwire is true (backward compatible)
+     */
+    private shouldBlock;
+    /** Emit guardrail.triggered events for each result */
+    private emitGuardrailEvents;
+    /** Run all input guardrails. Throws GuardrailTripwireError if a tripwire fails. */
+    runInputGuardrails(input: string, messages: ChatMessage[], ctx: RunContext, guardrails: GuardrailConfig[]): Promise<GuardrailResult[]>;
+    /** Run all output guardrails. Throws GuardrailTripwireError if a tripwire fails. */
+    runOutputGuardrails(output: string, messages: ChatMessage[], ctx: RunContext, guardrails: GuardrailConfig[]): Promise<GuardrailResult[]>;
+    /** Run tool guardrails before tool execution. Throws on tripwire failure. */
+    runToolGuardrails(toolName: string, input: unknown, ctx: RunContext, guardrails: GuardrailConfig[]): Promise<GuardrailResult[]>;
+}
+
+interface ContentFilterOptions {
+    /** Block patterns (regex) */
+    blockedPatterns?: RegExp[];
+    /** Block keywords (case-insensitive) */
+    blockedKeywords?: string[];
+    /** Max content length */
+    maxLength?: number;
+    /** Whether to tripwire on failure (default: true) */
+    tripwire?: boolean;
+}
+/** Creates a content filter guardrail (input guardrail) */
+declare function contentFilter(options?: ContentFilterOptions): InputGuardrail;
+
+/** Creates a consent gate guardrail */
+declare function consentGate(level: ConsentLevel, handler?: ConsentHandler): InputGuardrail;
+
+/** Creates a budget limit guardrail (checks accumulated cost after each LLM call) */
+declare function budgetLimit(maxUsd: number): OutputGuardrail;
+
+/** Budget check data injected into RunContext.metadata.budgetCheck */
+interface BudgetCheckData {
+    allowed: boolean;
+    usagePercent: number;
+    remainingUsd: number;
+}
+declare const budgetGateGuardrail: InputGuardrail;
+
+interface TokenLimitConfig {
+    /** Max total tokens (input + output) before triggering */
+    maxTotalTokens?: number;
+    /** Max cost USD before triggering */
+    maxCostUsd?: number;
+    /** Severity when limit exceeded (default: "warning") */
+    severity?: GuardrailSeverity;
+}
+declare function tokenLimit(config: TokenLimitConfig): OutputGuardrail;
+
+interface PIIFilterConfig {
+    /** PII types to detect */
+    detect?: ("email" | "phone" | "ssn" | "credit_card")[];
+    /** Severity when PII detected (default: "warning") */
+    severity?: GuardrailSeverity;
+}
+declare function piiFilter(config?: PIIFilterConfig): OutputGuardrail;
+
+declare class Runner {
+    private config;
+    private turnExecutor;
+    private provider?;
+    private eventBus?;
+    private tracer?;
+    private agents;
+    private contextManager?;
+    private modelContextWindow?;
+    private modelCatalog?;
+    private tokenCounter;
+    constructor(config?: RunnerConfig & {
+        provider?: ADKLLMProvider;
+        eventBus?: ADKEventBus;
+    });
+    /** Register an agent (for handoff resolution) */
+    registerAgent(agent: Agent): void;
+    /** Set the LLM provider */
+    setProvider(provider: ADKLLMProvider): void;
+    /** Run an agent to completion */
+    run(agent: Agent, input: RunConfig): Promise<RunResult>;
+    /** Stream events from an agent run — yields events during the turn loop */
+    stream(agent: Agent, input: RunConfig): AsyncGenerator<StreamEvent>;
+    /** Resolve context manager from agent config or runner config */
+    private resolveContextManager;
+    /** Resolve context budget from agent config, model catalog, or defaults */
+    private resolveContextBudget;
+    /** Look up model context window from catalog */
+    private lookupModelContextWindow;
+    /** Estimate total tokens for all tool definitions */
+    private estimateToolTokens;
+    /** Configure tool selection for an agent's turn executor */
+    private configureToolSelection;
+    /** Extract non-text content parts from the final assistant message */
+    private extractOutputParts;
+    /** Build harness tools (progress + notes) if configured */
+    private buildHarnessTools;
+    private buildHandoffTools;
+}
+
+/** Result of a single turn */
+interface TurnResult {
+    /** New messages produced this turn (assistant response + tool results) */
+    newMessages: ChatMessage[];
+    /** Whether the agent has finished (no tool calls, text response) */
+    finished: boolean;
+    /** Text output (if finished) */
+    output?: string;
+    /** Handoff target (if handoff tool was called) */
+    handoffTarget?: string;
+    /** Handoff reason */
+    handoffReason?: string;
+    /** Guardrail results from this turn */
+    guardrailResults: GuardrailResult[];
+}
+declare class TurnExecutor {
+    private guardrailEngine;
+    private toolSelector?;
+    private eventBus?;
+    private toolRegistry?;
+    private currentTrace?;
+    /** Set a tool selector for dynamic per-turn tool filtering */
+    setToolSelector(selector: ToolSelector): void;
+    /** Set event bus for observability */
+    setEventBus(eventBus: ADKEventBus): void;
+    /** Set tool registry for deferred tool loading */
+    setToolRegistry(registry: ToolRegistry): void;
+    /** Set trace for span-based tracing */
+    setTrace(trace?: Trace): void;
+    /**
+     * Execute a single turn.
+     * @param agent The current agent
+     * @param messages All messages so far (including system)
+     * @param provider The LLM provider to use
+     * @param ctx The run context
+     * @param onEvent Optional stream event callback
+     */
+    executeTurn(agent: Agent, messages: ChatMessage[], provider: ADKLLMProvider, ctx: RunContext, guardrails: GuardrailConfig[], handoffToolDefs?: LLMToolDefinition[], onEvent?: (event: StreamEvent) => void): Promise<TurnResult>;
+    /** Execute a single tool call with timeout and retry support */
+    private executeToolCall;
+    /** Run a promise with a timeout */
+    private withTimeout;
+    private buildToolDefs;
+    /** Extract tool names from recent tool call messages */
+    private extractRecentToolCalls;
+}
+
+declare function createRunId(): string;
+declare function createTraceId(): string;
+declare function createRunContext(opts: {
+    runId?: string;
+    agentName: string;
+    sessionId?: string;
+    traceId?: string;
+    signal?: AbortSignal;
+    metadata?: Record<string, unknown>;
+}): RunContext;
+
+/** Configuration for the code executor */
+interface CodeExecutorConfig {
+    /** Timeout in milliseconds (default: 30000) */
+    timeoutMs?: number;
+}
+/** Result of code execution */
+interface CodeExecutionResult {
+    success: boolean;
+    result: unknown;
+    error?: string;
+    toolCallsPerformed: string[];
+}
+/**
+ * CodeExecutor — sandboxed JavaScript executor with tool bindings.
+ * Agent code can call tools via `tools.toolName(input)` which returns a Promise.
+ * No filesystem, network, or process access from the sandbox.
+ */
+declare class CodeExecutor {
+    private timeoutMs;
+    constructor(config?: CodeExecutorConfig);
+    /**
+     * Execute code in a sandbox with tool bindings.
+     * @param code JavaScript code to execute
+     * @param tools Available tools that the code can call
+     * @param toolCtx Tool context for tool calls
+     */
+    execute(code: string, tools: ToolDef[], toolCtx: ToolContext): Promise<CodeExecutionResult>;
+}
+
+interface ExecuteCodeInput {
+    code: string;
+    description?: string;
+}
+/**
+ * Create an execute_code tool that runs agent-written JavaScript
+ * in a sandboxed environment with access to all available tools.
+ */
+declare function createExecuteCodeTool(availableTools: ToolDef[], config?: {
+    timeoutMs?: number;
+}): ToolDef<ExecuteCodeInput>;
+
+type ADKProviderErrorCode = "RATE_LIMITED" | "CONTEXT_LENGTH_EXCEEDED" | "INVALID_API_KEY" | "MODEL_NOT_FOUND" | "CONTENT_FILTERED" | "SERVICE_UNAVAILABLE" | "TIMEOUT" | "NETWORK_ERROR" | "INSUFFICIENT_QUOTA" | "UNKNOWN";
+declare class ADKProviderError extends Error {
+    readonly code: ADKProviderErrorCode;
+    readonly providerId: string;
+    readonly model?: string;
+    readonly retryable: boolean;
+    readonly retryAfterMs?: number;
+    readonly statusCode?: number;
+    readonly raw?: unknown;
+    constructor(params: {
+        code: ADKProviderErrorCode;
+        message: string;
+        providerId: string;
+        model?: string;
+        retryable?: boolean;
+        retryAfterMs?: number;
+        statusCode?: number;
+        raw?: unknown;
+    });
+    static rateLimited(providerId: string, retryAfterMs?: number, raw?: unknown): ADKProviderError;
+    static contextExceeded(providerId: string, model?: string, raw?: unknown): ADKProviderError;
+    static invalidApiKey(providerId: string, raw?: unknown): ADKProviderError;
+    static modelNotFound(providerId: string, model: string, raw?: unknown): ADKProviderError;
+    static contentFiltered(providerId: string, raw?: unknown): ADKProviderError;
+    static serviceUnavailable(providerId: string, raw?: unknown): ADKProviderError;
+    static timeout(providerId: string, raw?: unknown): ADKProviderError;
+    static networkError(providerId: string, raw?: unknown): ADKProviderError;
+    static insufficientQuota(providerId: string, raw?: unknown): ADKProviderError;
+    static unknown(providerId: string, raw?: unknown): ADKProviderError;
+}
+
+declare abstract class BaseProvider implements ADKLLMProvider {
+    abstract readonly providerId: string;
+    abstract readonly displayName: string;
+    abstract readonly isLocal: boolean;
+    protected apiKey?: string;
+    protected baseUrl?: string;
+    protected defaultModel: string;
+    protected modelCosts: Map<string, {
+        input: number;
+        output: number;
+    }>;
+    constructor(config: ProviderInitConfig);
+    abstract chat(params: ChatParams): Promise<ChatResponse>;
+    abstract complete(params: CompleteParams): Promise<CompleteResponse>;
+    abstract chatWithTools(params: ChatParamsWithTools): Promise<ChatResponseWithToolCalls>;
+    abstract chatStream(params: ChatParamsWithTools): AsyncGenerator<StreamChunk>;
+    embed?(_params: EmbedParams): Promise<EmbedResponse>;
+    abstract isAvailable(): boolean;
+    abstract getModels(): string[];
+    abstract estimateCost(inputTokens: number, outputTokens: number, model?: string): number;
+    /** Update model costs (for hot-update from discovery) */
+    updateModelCosts(costs: Map<string, {
+        input: number;
+        output: number;
+    }>): void;
+    /**
+     * Health check — sends a minimal chat request to verify provider reachability.
+     * Subclasses can override for more specific checks (e.g., model listing).
+     * Returns healthy status, latency, and optional error message.
+     */
+    isHealthy(): Promise<{
+        healthy: boolean;
+        latencyMs: number;
+        error?: string;
+    }>;
+    /** Normalize any thrown error into a structured ADKProviderError */
+    protected normalizeError(err: unknown, model?: string): ADKProviderError;
+    protected getModelCost(model?: string): {
+        input: number;
+        output: number;
+    };
+    protected calculateCost(inputTokens: number, outputTokens: number, model?: string): number;
+}
+
+declare class AnthropicProvider extends BaseProvider {
+    readonly providerId = "anthropic";
+    readonly displayName = "Anthropic";
+    readonly isLocal = false;
+    constructor(config: ProviderInitConfig);
+    isAvailable(): boolean;
+    getModels(): string[];
+    estimateCost(inputTokens: number, outputTokens: number, model?: string): number;
+    chat(params: ChatParams): Promise<ChatResponse>;
+    complete(params: CompleteParams): Promise<CompleteResponse>;
+    chatWithTools(params: ChatParamsWithTools): Promise<ChatResponseWithToolCalls>;
+    chatStream(params: ChatParamsWithTools): AsyncGenerator<StreamChunk>;
+}
+
+declare class OpenAIProvider extends BaseProvider {
+    readonly providerId: string;
+    readonly displayName: string;
+    readonly isLocal: boolean;
+    constructor(config: ProviderInitConfig);
+    isAvailable(): boolean;
+    getModels(): string[];
+    estimateCost(inputTokens: number, outputTokens: number, model?: string): number;
+    chat(params: ChatParams): Promise<ChatResponse>;
+    complete(params: CompleteParams): Promise<CompleteResponse>;
+    chatWithTools(params: ChatParamsWithTools): Promise<ChatResponseWithToolCalls>;
+    embed(params: EmbedParams): Promise<EmbedResponse>;
+    chatStream(params: ChatParamsWithTools): AsyncGenerator<StreamChunk>;
+}
+
+declare class GoogleProvider extends BaseProvider {
+    readonly providerId = "google";
+    readonly displayName = "Google";
+    readonly isLocal = false;
+    constructor(config: ProviderInitConfig);
+    isAvailable(): boolean;
+    getModels(): string[];
+    estimateCost(inputTokens: number, outputTokens: number, model?: string): number;
+    chat(params: ChatParams): Promise<ChatResponse>;
+    complete(params: CompleteParams): Promise<CompleteResponse>;
+    chatWithTools(params: ChatParamsWithTools): Promise<ChatResponseWithToolCalls>;
+    chatStream(params: ChatParamsWithTools): AsyncGenerator<StreamChunk>;
+}
+
+declare class XAIProvider extends OpenAIProvider {
+    readonly providerId = "xai";
+    readonly displayName = "xAI";
+    constructor(config: ProviderInitConfig);
+    getModels(): string[];
+}
+
+declare class OllamaProvider extends BaseProvider {
+    readonly providerId = "ollama";
+    readonly displayName = "Ollama";
+    readonly isLocal = true;
+    private knownModels;
+    constructor(config: ProviderInitConfig);
+    isAvailable(): boolean;
+    getModels(): string[];
+    estimateCost(): number;
+    updateKnownModels(models: string[]): void;
+    chat(params: ChatParams): Promise<ChatResponse>;
+    complete(params: CompleteParams): Promise<CompleteResponse>;
+    chatWithTools(params: ChatParamsWithTools): Promise<ChatResponseWithToolCalls>;
+    chatStream(params: ChatParamsWithTools): AsyncGenerator<StreamChunk>;
+}
+
+declare class LMStudioProvider extends OpenAIProvider {
+    readonly providerId = "lmstudio";
+    readonly displayName = "LM Studio";
+    readonly isLocal: boolean;
+    constructor(config: ProviderInitConfig);
+    isAvailable(): boolean;
+    estimateCost(): number;
+    getModels(): string[];
+    private knownModels?;
+    updateKnownModels(models: string[]): void;
+}
+
+/** Create a provider from config. Returns null if required API key is missing for cloud providers. */
+declare function createProvider(config: ProviderInitConfig): ADKLLMProvider | null;
+
+interface RedactOptions {
+    /** Additional patterns to match (merged with defaults unless `patternsOnly` is set) */
+    patterns?: RegExp[];
+    /** Fixed replacement string — if omitted, values are partially masked */
+    replacement?: string;
+}
+/**
+ * Redact sensitive information from a text string.
+ * By default masks API keys, connection strings, emails, and JWTs.
+ */
+declare function redact(text: string, options?: RedactOptions): string;
+
+declare class ADKLLMAdapter {
+    private providers;
+    private circuitBreakers;
+    private metrics;
+    private eventBus?;
+    constructor(eventBus?: ADKEventBus);
+    registerProvider(provider: ADKLLMProvider): void;
+    unregisterProvider(providerId: string): void;
+    getProvider(providerId: string): ADKLLMProvider | undefined;
+    getAllProviders(): ADKLLMProvider[];
+    getAvailableProviders(): ADKLLMProvider[];
+    getCircuitState(providerId: string): CircuitBreakerState;
+    getProviderMetrics(providerId: string): ProviderMetrics | undefined;
+    getAllMetrics(): ProviderMetrics[];
+    chat(providerId: string, params: ChatParams, context?: {
+        agentSlug?: string;
+        taskId?: string;
+    }): Promise<ChatResponse>;
+    chatWithTools(providerId: string, params: ChatParamsWithTools, context?: {
+        agentSlug?: string;
+        taskId?: string;
+    }): Promise<ChatResponseWithToolCalls>;
+    chatStream(providerId: string, params: ChatParamsWithTools): AsyncGenerator<StreamChunk>;
+    complete(providerId: string, params: CompleteParams): Promise<CompleteResponse>;
+    embed(providerId: string, params: EmbedParams): Promise<EmbedResponse>;
+    private checkCircuitBreaker;
+    private recordSuccess;
+    private recordFailure;
+    private emitCallCompleted;
+    private emitCallFailed;
+    reset(): void;
+}
+
+declare class ADKRouter {
+    private configs;
+    private budgetUsage;
+    private adapter;
+    constructor(adapter: ADKLLMAdapter);
+    setConfig(agentSlug: string, config: AgentLLMConfig): void;
+    getConfig(agentSlug: string): AgentLLMConfig;
+    route(agentSlug: string, params: ChatParamsWithTools, context?: {
+        taskId?: string;
+    }): Promise<ChatResponseWithToolCalls>;
+    private selectProvider;
+    private selectCheapest;
+    private selectFastest;
+    private selectHighestQuality;
+    private selectBalanced;
+    private selectFromChain;
+    resetBudget(agentSlug: string): void;
+    resetAllBudgets(): void;
+    getBudgetUsage(agentSlug: string): number;
+    reset(): void;
+}
+
+/** Create a controllable async generator from events */
+declare function createAsyncEventStream(): {
+    push: (event: StreamEvent) => void;
+    close: () => void;
+    error: (err: Error) => void;
+    stream: AsyncGenerator<StreamEvent>;
+};
+
+/** Encode a StreamEvent as an SSE data line */
+declare function encodeSSE(event: StreamEvent): string;
+/** Convert an AsyncGenerator<StreamEvent> to a ReadableStream<Uint8Array> for SSE */
+declare function streamToSSE(generator: AsyncGenerator<StreamEvent>): ReadableStream<Uint8Array>;
+
+/** Minimal WebSocket interface (works with ws, browser WebSocket, etc.) */
+interface WSLike {
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    readyState: number;
+}
+/** Relay stream events to a WebSocket connection */
+declare function relayToWebSocket(generator: AsyncGenerator<StreamEvent>, ws: WSLike): Promise<void>;
+
+interface BackpressureOptions {
+    /** Max items in buffer before dropping oldest (default: 100) */
+    bufferLimit?: number;
+    /** SSE keepalive interval in ms (default: 15000) */
+    keepaliveIntervalMs?: number;
+}
+declare class BackpressuredStream<T> {
+    private options;
+    private buffer;
+    private resolve;
+    private done;
+    private keepaliveTimer;
+    private readonly bufferLimit;
+    constructor(options?: BackpressureOptions);
+    /**
+     * Push an item into the stream.
+     * If a consumer is waiting, delivers directly.
+     * If buffer is full, drops the oldest item (lossy backpressure).
+     * Returns false if stream is already ended.
+     */
+    push(item: T): boolean;
+    /** Signal end-of-stream. Resolves any waiting consumer. */
+    end(): void;
+    /** Start an interval that calls onKeepalive periodically (for SSE `:keepalive` comments). */
+    startKeepalive(onKeepalive: () => void): void;
+    /** Stop the keepalive timer. */
+    stopKeepalive(): void;
+    /** Current number of buffered items. */
+    get bufferSize(): number;
+    /** True when buffer has reached its limit. */
+    get isFull(): boolean;
+    /** Whether the stream has been ended. */
+    get isDone(): boolean;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+
+/** Create a stream adapter from an AsyncGenerator<StreamEvent> */
+declare function createStreamAdapter(generator: AsyncGenerator<StreamEvent>): {
+    toSSE(): ReadableStream<Uint8Array>;
+    toWebSocket(ws: WSLike): Promise<void>;
+    toAsyncIterable(): AsyncIterable<StreamEvent>;
+};
+
+/** Generate a new API key */
+declare function generateApiKey(type?: "live" | "test"): {
+    key: string;
+    hash: string;
+    prefix: string;
+};
+/** Hash an API key (for storage — never store the raw key) */
+declare function hashApiKey(key: string): string;
+/** Parse an API key into its parts */
+declare function parseApiKey(key: string): {
+    type: "live" | "test";
+    prefix: string;
+    hash: string;
+} | null;
+/** Validate API key format */
+declare function validateApiKeyFormat(key: string): boolean;
+
+interface ADKApiKey {
+    id: string;
+    keyHash: string;
+    type: "live" | "test";
+    permissions: string[];
+    active: boolean;
+    ownerId: string;
+}
+/** Proxy router: resolves an ADK API key to underlying provider credentials */
+declare class ProxyRouter {
+    private providerCredentials;
+    constructor(providerCredentials: Map<string, string>);
+    /**
+     * Resolve a validated API key to provider credentials.
+     * Returns the provider's API key and optional base URL.
+     */
+    resolve(_apiKey: ADKApiKey, providerId: string): {
+        apiKey: string;
+        baseUrl?: string;
+    } | null;
+    /** Check if a provider has credentials configured */
+    hasProvider(providerId: string): boolean;
+    /** Get all configured provider IDs */
+    getConfiguredProviders(): string[];
+}
+
+declare class MemorySessionBackend implements SessionBackend {
+    private sessions;
+    create(options: SessionCreateOptions): Promise<Session>;
+    get(sessionId: string): Promise<Session | null>;
+    update(sessionId: string, options: SessionUpdateOptions): Promise<Session>;
+    appendMessages(sessionId: string, messages: ChatMessage[]): Promise<Session>;
+    fork(sessionId: string): Promise<Session>;
+    delete(sessionId: string): Promise<void>;
+    list(filter?: SessionListFilter): Promise<Session[]>;
+}
+
+declare class PrismaSessionBackend implements SessionBackend {
+    private db;
+    constructor(db: unknown);
+    create(options: SessionCreateOptions): Promise<Session>;
+    get(sessionId: string): Promise<Session | null>;
+    update(sessionId: string, options: SessionUpdateOptions): Promise<Session>;
+    appendMessages(sessionId: string, messages: ChatMessage[]): Promise<Session>;
+    fork(sessionId: string): Promise<Session>;
+    delete(sessionId: string): Promise<void>;
+    list(filter?: SessionListFilter): Promise<Session[]>;
+    /** Convert a Prisma record to Session interface */
+    private toSession;
+    /** Safely parse JSON — handles both string and pre-parsed values */
+    private parseJson;
+}
+
+/** Summarization configuration */
+interface SummarizationConfig {
+    /** LLM provider for summarization */
+    provider?: ADKLLMProvider;
+    /** Model to use for summarization (cheap/fast model recommended) */
+    model?: string;
+    /** Max tokens for the summary (default: 500) */
+    maxSummaryTokens?: number;
+}
+/** Partition result: messages to summarize vs. messages to keep */
+interface MessagePartition {
+    /** Older messages to be summarized */
+    summarize: ChatMessage[];
+    /** Recent messages to keep verbatim */
+    keep: ChatMessage[];
+}
+/**
+ * ContextSummarizer — summarizes older messages to reduce context size.
+ *
+ * Uses an LLM provider if available, otherwise falls back to extractive
+ * summarization (first + last sentence per message).
+ */
+declare class ContextSummarizer {
+    private config;
+    constructor(config?: SummarizationConfig);
+    /**
+     * Summarize messages into a condensed context message.
+     * Falls back to extractive summarization if no LLM provider is available.
+     */
+    summarize(messages: ChatMessage[]): Promise<ChatMessage>;
+    /**
+     * Split messages: keep recent N turns verbatim, summarize the rest.
+     * A "turn" is a user message + assistant response pair.
+     */
+    partitionMessages(messages: ChatMessage[], keepRecentTurns: number): MessagePartition;
+    /** LLM-powered summarization */
+    private llmSummarize;
+    /** Extractive fallback: first + last sentence per message */
+    private extractiveSummarize;
+}
+
+/** Token counting strategy */
+type TokenCounterStrategy = "character" | "tiktoken-approx" | "provider-reported";
+/** Token counter configuration */
+interface TokenCounterConfig {
+    strategy?: TokenCounterStrategy;
+}
+/**
+ * TokenCounter — estimates token counts without external dependencies.
+ *
+ * Strategies:
+ * - "character": simple `Math.ceil(text.length / 4)` (cheapest, ~70% accuracy)
+ * - "tiktoken-approx": BPE-approximation without external deps (~85% accuracy)
+ * - "provider-reported": starts with tiktoken-approx, calibrates from actual provider counts
+ */
+declare class TokenCounter {
+    private strategy;
+    private calibrationFactor;
+    constructor(config?: TokenCounterConfig);
+    /** Count tokens in a text string */
+    countText(text: string): number;
+    /** Count tokens in a single message (content + overhead) */
+    countMessage(msg: ChatMessage): number;
+    /** Count tokens across multiple messages */
+    countMessages(messages: ChatMessage[]): number;
+    /** Count tokens for a single tool definition */
+    countToolDef(tool: LLMToolDefinition): number;
+    /** Count tokens for all tool definitions */
+    countToolDefs(tools: LLMToolDefinition[]): number;
+    /** Calibrate from actual provider-reported token count */
+    calibrate(text: string, actualTokens: number): void;
+    /** Get current calibration factor */
+    getCalibrationFactor(): number;
+    /** Estimate image tokens based on detail level */
+    private estimateImageTokens;
+    /** Estimate audio tokens from duration or base64 size */
+    private estimateAudioTokens;
+    /** Estimate video tokens from duration or base64 size */
+    private estimateVideoTokens;
+    /**
+     * BPE-approximation: split on whitespace, count sub-word splits for long words,
+     * account for punctuation. ~85% accuracy without external deps.
+     */
+    private bpeApprox;
+}
+
+/** Context manager configuration */
+interface ContextManagerConfig {
+    /** Token counting strategy */
+    tokenCounterStrategy?: TokenCounterStrategy;
+    /** Summarization config (provider, model, maxSummaryTokens) */
+    summarization?: SummarizationConfig;
+    /** Number of recent turns to always keep verbatim (default: 4) */
+    keepRecentTurns?: number;
+}
+declare class ContextManager {
+    private tokenCounter;
+    private summarizer?;
+    private keepRecentTurns;
+    constructor(config?: ContextManagerConfig);
+    /**
+     * Trim messages to fit within a token budget.
+     * Always preserves the system message (first) and most recent messages.
+     */
+    trimToFit(messages: ChatMessage[], maxTokens: number, strategy?: ContextStrategy): Promise<ChatMessage[]>;
+    /** Get total token count for messages */
+    getTokenCount(messages: ChatMessage[]): number;
+    private smartSummary;
+    /**
+     * JIT (Just-In-Time) strategy: keep only system prompt + last N messages.
+     * Older messages are dropped (they can be recalled via a recall_context tool).
+     */
+    private jitTrim;
+    private slidingWindow;
+}
+
+interface CompactionOptions {
+    /** Maximum number of messages to retain */
+    maxMessages: number;
+    /** Compaction strategy — truncate keeps most recent messages */
+    strategy: "truncate" | "summarize";
+    /** Whether to always preserve the system message(s) at the start */
+    keepSystemMessage: boolean;
+}
+/**
+ * Compact a message array to fit within maxMessages.
+ *
+ * With strategy="truncate", system messages are preserved at the front
+ * and the most recent non-system messages are kept.
+ *
+ * With strategy="summarize", falls back to truncate for now (future:
+ * will insert an LLM-generated summary of trimmed messages).
+ */
+declare function compactMessages(messages: ChatMessage[], options?: Partial<CompactionOptions>): ChatMessage[];
+
+/** Backend interface for pluggable persistence */
+interface AgenticMemoryBackend {
+    get(key: string): Promise<string | undefined>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    list(prefix?: string): Promise<string[]>;
+}
+/** In-memory backend (default) */
+declare class InMemoryBackend implements AgenticMemoryBackend {
+    private store;
+    get(key: string): Promise<string | undefined>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    list(prefix?: string): Promise<string[]>;
+}
+/**
+ * AgenticMemory — simple persistent key-value store for agents.
+ * Persists state across run calls when the same store instance is reused.
+ */
+declare class AgenticMemory {
+    private backend;
+    constructor(backend?: AgenticMemoryBackend);
+    get(key: string): Promise<string | undefined>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    search(prefix: string): Promise<Array<{
+        key: string;
+        value: string;
+    }>>;
+    list(): Promise<string[]>;
+}
+
+declare function createMemoryWriteTool(memory: AgenticMemory): ToolDef<{
+    key: string;
+    value: string;
+}>;
+declare function createMemoryReadTool(memory: AgenticMemory): ToolDef<{
+    key: string;
+}>;
+declare function createMemorySearchTool(memory: AgenticMemory): ToolDef<{
+    prefix: string;
+}>;
+
+declare class ConsoleExporter implements TraceExporter {
+    export(trace: TraceData): Promise<void>;
+}
+
+declare class EventBusExporter implements TraceExporter {
+    private eventBus;
+    constructor(eventBus: ADKEventBus);
+    export(trace: TraceData): Promise<void>;
+}
+
+interface LangfuseConfig {
+    publicKey: string;
+    secretKey: string;
+    baseUrl?: string;
+}
+declare class LangfuseExporter implements TraceExporter {
+    private config;
+    constructor(config: LangfuseConfig);
+    export(trace: TraceData): Promise<void>;
+}
+
+declare const HANDOFF_PREFIX = "transfer_to_";
+/** Record of a handoff registration */
+interface HandoffRegistration {
+    from: Agent;
+    to: Agent;
+    description: string;
+    filter?: (ctx: RunContext) => boolean | Promise<boolean>;
+}
+/** Manages handoff registrations and tool generation */
+declare class HandoffManager {
+    private registrations;
+    private circularGuard;
+    /** Register a handoff from one agent to another */
+    registerHandoff(from: Agent, to: Agent, description: string, filter?: (ctx: RunContext) => boolean | Promise<boolean>): void;
+    /** Auto-register handoffs from an agent's config.handoffs */
+    registerFromConfig(agent: Agent, agentMap: Map<string, Agent>): void;
+    /** Get handoff tools for a given agent (as ToolDefs) */
+    getHandoffTools(agent: Agent): ToolDef[];
+    /** Get handoff LLMToolDefinitions for a given agent */
+    getHandoffToolDefs(agent: Agent): LLMToolDefinition[];
+    /** Execute a handoff (validates, checks circular, emits) */
+    executeHandoff(from: Agent, to: Agent, ctx: RunContext, reason: string): Promise<void>;
+    /** Get all registered handoffs for a given agent */
+    getHandoffsForAgent(agent: Agent): HandoffRegistration[];
+    /** Reset circular guard (call between runs) */
+    resetCircularGuard(): void;
+    /** Clear all registrations */
+    clear(): void;
+}
+
+interface AgentAsToolConfig {
+    /** Custom tool name (defaults to agent name) */
+    name?: string;
+    /** Custom description (defaults to agent description or instructions summary) */
+    description?: string;
+    /** Provider to use for the inner run */
+    provider?: ADKLLMProvider;
+    /** Max turns for the inner run */
+    maxTurns?: number;
+    /** Whether to return full RunResult or just output text */
+    fullResult?: boolean;
+}
+/**
+ * Wrap an Agent as a ToolDef. When another agent calls this tool,
+ * it runs the wrapped agent as a sub-agent and returns the output.
+ */
+declare function agentAsTool(agent: Agent, config?: AgentAsToolConfig): ToolDef;
+
+interface ParallelRunnerConfig {
+    /** LLM provider to use */
+    provider: ADKLLMProvider;
+}
+declare class ParallelRunner {
+    private provider;
+    constructor(config: ParallelRunnerConfig);
+    /**
+     * Run all agents concurrently. Returns all results.
+     * All agents receive the same input.
+     */
+    runAll(agents: Agent[], input: RunConfig): Promise<RunResult[]>;
+    /**
+     * Race agents. Returns the first result that completes.
+     * Other runs are aborted.
+     */
+    race(agents: Agent[], input: RunConfig): Promise<RunResult>;
+    /**
+     * Run agents in pipeline — output of one becomes input of the next.
+     * The first agent gets the original input; subsequent agents get the
+     * previous agent's output as their input.
+     */
+    pipeline(agents: Agent[], input: RunConfig): Promise<RunResult>;
+}
+
+/** Team consensus types */
+type ConsensusType = "coordinator_decides" | "majority" | "unanimous" | "weighted";
+/** Team configuration */
+interface TeamConfig {
+    /** Team name */
+    name: string;
+    /** Coordinator agent — orchestrates the team */
+    coordinator: Agent;
+    /** Team member agents */
+    members: Agent[];
+    /** How decisions are made */
+    consensusType?: ConsensusType;
+    /** Maximum coordination rounds */
+    maxRounds?: number;
+    /** LLM provider */
+    provider: ADKLLMProvider;
+    /** Event bus (optional) */
+    eventBus?: ADKEventBus;
+}
+/** Team execution result */
+interface TeamResult extends RunResult {
+    /** Individual member results */
+    memberResults: {
+        agentName: string;
+        result: RunResult;
+    }[];
+    /** Number of coordination rounds */
+    rounds: number;
+}
+declare class Team {
+    private config;
+    constructor(config: TeamConfig);
+    /** Run the team: coordinator delegates to members, aggregates results */
+    run(input: RunConfig): Promise<TeamResult>;
+    /** Stream events from a team run */
+    stream(input: RunConfig): AsyncGenerator<StreamEvent>;
+}
+
+/** Pipeline task definition */
+interface PipelineTask {
+    /** Task ID */
+    id: string;
+    /** Task description / instructions */
+    description: string;
+    /** File context (paths, diffs, etc.) */
+    context?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/** Pipeline step type */
+type PipelineStepType = "workspace" | "agent" | "validate" | "report";
+/** Pipeline step result */
+interface PipelineStepResult {
+    step: PipelineStepType;
+    success: boolean;
+    output: string;
+    durationMs: number;
+    error?: string;
+}
+/** Full pipeline result */
+interface PipelineResult {
+    taskId: string;
+    success: boolean;
+    steps: PipelineStepResult[];
+    agentResult?: RunResult;
+    totalDurationMs: number;
+    output: string;
+}
+/** Pipeline configuration */
+interface PipelineConfig {
+    /** LLM provider */
+    provider: ADKLLMProvider;
+    /** Event bus (optional) */
+    eventBus?: ADKEventBus;
+    /** Workspace setup function (optional — returns context string) */
+    workspaceSetup?: (task: PipelineTask) => Promise<string>;
+    /** Validation function (optional — returns { valid, errors }) */
+    validator?: (output: string, task: PipelineTask) => Promise<{
+        valid: boolean;
+        errors: string[];
+    }>;
+    /** Report function (optional — generates report from results) */
+    reporter?: (result: PipelineResult) => Promise<string>;
+    /** Max agent turns */
+    maxTurns?: number;
+}
+declare class ADKPipeline {
+    private config;
+    constructor(config: PipelineConfig);
+    /** Execute the full pipeline */
+    execute(agent: Agent, task: PipelineTask): Promise<PipelineResult>;
+    private buildAgentInput;
+}
+
+/** Review severity levels */
+type ReviewSeverity = "info" | "warning" | "error" | "critical";
+/** Single review comment */
+interface ReviewComment {
+    file?: string;
+    line?: number;
+    severity: ReviewSeverity;
+    message: string;
+    suggestion?: string;
+    reviewer: string;
+}
+/** Individual reviewer's result */
+interface ReviewerResult {
+    reviewer: string;
+    verdict: "approve" | "request_changes" | "comment";
+    comments: ReviewComment[];
+    summary: string;
+    confidence: number;
+    runResult: RunResult;
+}
+/** Aggregated review result */
+interface ReviewResult {
+    verdict: "approve" | "request_changes" | "comment";
+    reviewers: ReviewerResult[];
+    comments: ReviewComment[];
+    summary: string;
+    totalDurationMs: number;
+}
+/** Review configuration */
+interface ReviewConfig {
+    /** LLM provider */
+    provider: ADKLLMProvider;
+    /** Event bus (optional) */
+    eventBus?: ADKEventBus;
+    /** Approval threshold (fraction of reviewers that must approve: 0.0 - 1.0) */
+    approvalThreshold?: number;
+    /** Max turns per reviewer */
+    maxTurns?: number;
+}
+declare class ADKReviewPipeline {
+    private config;
+    constructor(config: ReviewConfig);
+    /** Run a multi-agent code review */
+    review(diff: string, reviewers: Agent[], context?: string): Promise<ReviewResult>;
+    private runReviewer;
+    private parseReviewerOutput;
+    private parseSeverity;
+}
+
+/** MCP transport type */
+type MCPTransport = "stdio" | "sse" | "streamable-http";
+/** MCP auth configuration */
+interface MCPAuthConfig {
+    type: "bearer" | "basic" | "api-key";
+    token?: string;
+    username?: string;
+    password?: string;
+    apiKey?: string;
+    headerName?: string;
+}
+/** MCP server connection config */
+interface MCPServerConfig {
+    /** Server URL or command (for stdio) */
+    serverUrl: string;
+    /** Transport type */
+    transport: MCPTransport;
+    /** Auth config (optional) */
+    authConfig?: MCPAuthConfig;
+    /** Filter function to select which tools to expose */
+    toolFilter?: (tool: MCPToolInfo) => boolean;
+    /** Timeout for tool calls in ms */
+    timeoutMs?: number;
+    /** Specific tool names to load (name-based filter) */
+    toolNames?: string[];
+    /** Filter by category metadata */
+    categories?: string[];
+    /** Cap total tools returned */
+    maxTools?: number;
+}
+/** MCP tool information (from server) */
+interface MCPToolInfo {
+    name: string;
+    description: string;
+    inputSchema: JsonSchema;
+    /** Optional category metadata */
+    category?: string;
+    /** Optional tags */
+    tags?: string[];
+}
+/**
+ * Connect to an MCP server and return its tools as ToolDef[].
+ *
+ * This is a lightweight adapter that converts MCP tool definitions
+ * to ADK ToolDef format. For full MCP bridge features (rate limiting,
+ * circuit breaking, output sanitization), use @aizonaai/mcp-bridge directly.
+ */
+declare function mcpServerTools(config: MCPServerConfig): Promise<ToolDef[]>;
+/**
+ * Discover tool metadata from an MCP server without creating ToolDefs.
+ * Useful for browsing available tools before selecting specific ones.
+ */
+declare function discoverMCPTools(config: MCPServerConfig): Promise<MCPToolInfo[]>;
+/**
+ * Load only specific named tools from an MCP server.
+ * Combines discovery with name-based selection in one call.
+ */
+declare function mcpSelectTools(config: MCPServerConfig, toolNames: string[]): Promise<ToolDef[]>;
+/**
+ * MCPServerConnector — lightweight connector for MCP servers.
+ * Handles discovery and invocation.
+ */
+declare class MCPServerConnector {
+    private config;
+    private connection;
+    constructor(config: MCPServerConfig);
+    /** Discover tools from the MCP server */
+    discover(): Promise<MCPToolInfo[]>;
+    /** Convert an MCP tool to an ADK ToolDef */
+    toToolDef(tool: MCPToolInfo): ToolDef;
+    /** Discover tool metadata without creating ToolDefs */
+    discoverMetadata(): Promise<MCPToolInfo[]>;
+    /** Create ToolDefs for only the named subset of discovered tools */
+    selectTools(discovered: MCPToolInfo[], names: string[]): ToolDef[];
+    /** Invoke a tool on the MCP server */
+    invokeTool(toolName: string, input: unknown): Promise<unknown>;
+    /** Discover tools via HTTP (SSE or streamable-http) */
+    private discoverViaHttp;
+    /** Invoke a tool via HTTP */
+    private invokeViaHttp;
+    /** Discover tools via stdio (placeholder — requires child_process) */
+    private discoverViaStdio;
+    /** Invoke tool via stdio (placeholder) */
+    private invokeViaStdio;
+    /** Build auth headers */
+    private buildHeaders;
+}
+
+/** Voice options */
+type VoiceName = "alloy" | "echo" | "fable" | "onyx" | "nova" | "shimmer";
+/** Audio format */
+type AudioFormat = "pcm16" | "opus";
+/** Voice activity detection mode */
+type VADMode = "server" | "client" | "off";
+/** Realtime provider */
+type RealtimeProvider = "openai";
+/** Realtime agent configuration */
+interface RealtimeAgentConfig extends AgentConfig {
+    /** Voice to use */
+    voice?: VoiceName;
+    /** Audio format */
+    audioFormat?: AudioFormat;
+    /** VAD mode */
+    vadMode?: VADMode;
+    /** Realtime provider */
+    realtimeProvider?: RealtimeProvider;
+    /** Provider API key */
+    apiKey?: string;
+    /** WebSocket URL override */
+    wsUrl?: string;
+}
+/** Realtime connection state */
+type RealtimeState = "disconnected" | "connecting" | "connected" | "error";
+/** Realtime event types */
+type RealtimeEvent = {
+    type: "state_change";
+    state: RealtimeState;
+} | {
+    type: "audio";
+    buffer: ArrayBuffer;
+} | {
+    type: "text";
+    content: string;
+    final: boolean;
+} | {
+    type: "tool_call";
+    toolName: string;
+    input: unknown;
+    callId: string;
+} | {
+    type: "error";
+    message: string;
+};
+/**
+ * RealtimeAgent — Voice-enabled agent using WebSocket realtime APIs.
+ *
+ * Currently supports OpenAI Realtime API.
+ * Connect, send audio, and receive audio/text responses.
+ */
+declare class RealtimeAgent {
+    readonly config: RealtimeAgentConfig;
+    private state;
+    private ws;
+    private audioHandlers;
+    private textHandlers;
+    private toolCallHandlers;
+    private eventHandlers;
+    constructor(config: RealtimeAgentConfig);
+    /** Get current connection state */
+    getState(): RealtimeState;
+    /** Connect to the realtime provider */
+    connect(): Promise<void>;
+    /** Disconnect from the realtime provider */
+    disconnect(): Promise<void>;
+    /** Send an audio buffer to the realtime session */
+    sendAudio(buffer: ArrayBuffer): void;
+    /** Send a text message to the realtime session */
+    sendText(text: string): void;
+    /** Register handler for audio output */
+    onAudio(handler: (buffer: ArrayBuffer) => void): () => void;
+    /** Register handler for text output */
+    onText(handler: (text: string) => void): () => void;
+    /** Register handler for tool calls */
+    onToolCall(handler: (toolName: string, input: unknown) => Promise<unknown>): () => void;
+    /** Register handler for all events */
+    onEvent(handler: (event: RealtimeEvent) => void): () => void;
+    private setState;
+    private emitEvent;
+    private sendSessionConfig;
+    private handleMessage;
+    private sendToolResult;
+    private getProviderUrl;
+}
+
+/** Audio buffer configuration */
+interface AudioBufferConfig {
+    /** Sample rate in Hz (default: 24000) */
+    sampleRate?: number;
+    /** Number of channels (default: 1, mono) */
+    channels?: number;
+    /** Buffer size in samples (default: 4800, 200ms at 24kHz) */
+    bufferSize?: number;
+}
+/**
+ * AudioStreamBuffer — Manages a ring buffer for PCM16 audio data.
+ * Used for smoothing audio playback from realtime streams.
+ */
+declare class AudioStreamBuffer {
+    private buffer;
+    private writePos;
+    private readPos;
+    private count;
+    readonly sampleRate: number;
+    readonly channels: number;
+    constructor(config?: AudioBufferConfig);
+    /** Write PCM16 samples to the buffer */
+    write(samples: Int16Array): number;
+    /** Read PCM16 samples from the buffer */
+    read(numSamples: number): Int16Array;
+    /** Number of samples available to read */
+    get available(): number;
+    /** Whether the buffer is empty */
+    get isEmpty(): boolean;
+    /** Whether the buffer is full */
+    get isFull(): boolean;
+    /** Duration of buffered audio in milliseconds */
+    get durationMs(): number;
+    /** Clear the buffer */
+    clear(): void;
+}
+/**
+ * Convert an ArrayBuffer (raw bytes) to Int16Array (PCM16).
+ * Assumes little-endian 16-bit signed integer format.
+ */
+declare function pcm16FromArrayBuffer(buffer: ArrayBuffer): Int16Array;
+/**
+ * Convert Int16Array (PCM16) to ArrayBuffer (raw bytes).
+ */
+declare function pcm16ToArrayBuffer(samples: Int16Array): ArrayBuffer;
+/**
+ * Calculate RMS volume level from PCM16 samples.
+ * Returns a value between 0.0 (silence) and 1.0 (max volume).
+ */
+declare function calculateVolume(samples: Int16Array): number;
+
+/** A single tool definition within a skill manifest */
+interface SkillToolEntry {
+    /** Tool name */
+    name: string;
+    /** Tool description */
+    description: string;
+    /** JSON Schema for tool input */
+    inputSchema: Record<string, unknown>;
+    /** JSON Schema for tool output (optional) */
+    outputSchema?: Record<string, unknown>;
+}
+/** Skill manifest — the core portable definition */
+interface SkillManifest {
+    /** Unique skill name (scoped to community) */
+    name: string;
+    /** Semver version string */
+    version: string;
+    /** Human-readable description */
+    description: string;
+    /** Category for marketplace browsing */
+    category?: string;
+    /** Tags for search/filter */
+    tags?: string[];
+    /** Tool definitions included in this skill */
+    tools: SkillToolEntry[];
+    /** Optional agent configuration hints (model, temperature, etc.) */
+    agentConfig?: Record<string, unknown>;
+    /** Other skills this skill depends on */
+    dependencies?: string[];
+    /** Arbitrary metadata */
+    metadata?: Record<string, unknown>;
+}
+/** Zod schema for full skill manifest validation */
+declare const SkillManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodString;
+    category: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    tools: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+        outputSchema?: Record<string, unknown> | undefined;
+    }, {
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+        outputSchema?: Record<string, unknown> | undefined;
+    }>, "many">;
+    agentConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    tools: {
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+        outputSchema?: Record<string, unknown> | undefined;
+    }[];
+    description: string;
+    version: string;
+    metadata?: Record<string, unknown> | undefined;
+    category?: string | undefined;
+    tags?: string[] | undefined;
+    agentConfig?: Record<string, unknown> | undefined;
+    dependencies?: string[] | undefined;
+}, {
+    name: string;
+    tools: {
+        name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+        outputSchema?: Record<string, unknown> | undefined;
+    }[];
+    description: string;
+    version: string;
+    metadata?: Record<string, unknown> | undefined;
+    category?: string | undefined;
+    tags?: string[] | undefined;
+    agentConfig?: Record<string, unknown> | undefined;
+    dependencies?: string[] | undefined;
+}>;
+/**
+ * Define and validate a skill manifest.
+ * Throws if the manifest is invalid.
+ */
+declare function defineSkill(manifest: SkillManifest): SkillManifest;
+
+/** Result of loading a skill */
+interface LoadedSkill {
+    /** Tool definitions ready to use in an agent */
+    tools: ToolDef[];
+    /** Agent configuration hints from the manifest */
+    agentConfig?: Record<string, unknown>;
+    /** Original manifest metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Load a skill manifest and produce ToolDef instances.
+ *
+ * @param manifest - A validated SkillManifest
+ * @param toolImplementations - Optional map of tool name → execute function overrides
+ * @returns LoadedSkill with ToolDef[] and agentConfig
+ */
+declare function loadSkill(manifest: SkillManifest, toolImplementations?: Record<string, (input: unknown, ctx: ToolContext) => Promise<unknown>>): LoadedSkill;
+/**
+ * Merge tools from multiple loaded skills into a single array.
+ * Throws if tool name collisions are detected across skills.
+ */
+declare function mergeSkillTools(...loadedSkills: LoadedSkill[]): ToolDef[];
+
+/** Check if content is multi-modal (ContentPart[]) */
+declare function isMultiModalContent(content: Content): content is ContentPart[];
+/** Check if a content part is a TextPart */
+declare function isTextPart(part: ContentPart): part is TextPart;
+/** Check if a content part is an ImagePart */
+declare function isImagePart(part: ContentPart): part is ImagePart;
+/** Check if a content part is an AudioPart */
+declare function isAudioPart(part: ContentPart): part is AudioPart;
+/** Check if a content part is a VideoPart */
+declare function isVideoPart(part: ContentPart): part is VideoPart;
+/** Check if a content part is a UIArtifactPart */
+declare function isUIArtifactPart(part: ContentPart): part is UIArtifactPart;
+/**
+ * Extract text from Content. For strings, returns as-is.
+ * For ContentPart[], concatenates all TextPart.text values.
+ * Non-text parts are represented as markers.
+ */
+declare function contentToString(content: Content): string;
+/** Alias for contentToString — backward compat with plan naming */
+declare const extractText: typeof contentToString;
+/**
+ * Normalize content to ContentPart[].
+ * Strings become a single TextPart.
+ */
+declare function contentToParts(content: Content): ContentPart[];
+/**
+ * Count media parts by type.
+ */
+declare function countMediaParts(content: Content): {
+    text: number;
+    image: number;
+    audio: number;
+    video: number;
+    uiArtifact: number;
+};
+
+/**
+ * Create the built-in `create_artifact` tool.
+ * When an agent calls this tool, it creates a UIArtifactPart
+ * and optionally persists it to an ArtifactStore.
+ */
+declare function createArtifactTool(store?: ArtifactStore): ToolDef;
+
+/** Status of a progress feature */
+type FeatureStatus = "pending" | "in_progress" | "passed" | "failed";
+/** A tracked feature in the progress list */
+interface ProgressFeature {
+    id: string;
+    name: string;
+    status: FeatureStatus;
+    verifiedAt?: number;
+}
+/**
+ * ProgressTracker — tracks feature-level progress for long-running agent sessions.
+ * Serializable to/from JSON for cross-session persistence.
+ */
+declare class ProgressTracker {
+    private features;
+    /** Add a feature to track */
+    addFeature(id: string, name: string): void;
+    /** Add multiple features at once */
+    addFeatures(features: Array<{
+        id: string;
+        name: string;
+    }>): void;
+    /** Update the status of a feature */
+    updateStatus(id: string, status: FeatureStatus): boolean;
+    /** Get the next pending feature */
+    getNextPending(): ProgressFeature | undefined;
+    /** Get a feature by ID */
+    getFeature(id: string): ProgressFeature | undefined;
+    /** Get all features */
+    getAllFeatures(): ProgressFeature[];
+    /** Get a summary of progress */
+    getSummary(): {
+        total: number;
+        pending: number;
+        inProgress: number;
+        passed: number;
+        failed: number;
+        percentComplete: number;
+    };
+    /** Serialize to JSON for persistence */
+    toJSON(): ProgressFeature[];
+    /** Restore from serialized state */
+    static fromJSON(data: ProgressFeature[]): ProgressTracker;
+}
+
+/** Predefined note sections */
+type NoteSection = "findings" | "decisions" | "todo" | "questions";
+/** A single note entry */
+interface NoteEntry {
+    section: NoteSection;
+    content: string;
+    createdAt: number;
+}
+/**
+ * NotesStore — structured note-taking for agents across sessions.
+ * Notes are organized by section (Findings, Decisions, TODO, Questions).
+ * Serializable to/from JSON for cross-session persistence.
+ */
+declare class NotesStore {
+    private notes;
+    /** Add a note to a section */
+    addNote(section: NoteSection, content: string): void;
+    /** Get notes from a specific section or all notes */
+    getNotes(section?: NoteSection): NoteEntry[];
+    /** Get note count per section */
+    getCounts(): Record<NoteSection, number>;
+    /** Clear all notes or notes in a specific section */
+    clear(section?: NoteSection): void;
+    /** Serialize to JSON for persistence */
+    toJSON(): NoteEntry[];
+    /** Restore from serialized state */
+    static fromJSON(data: NoteEntry[]): NotesStore;
+}
+
+interface ProgressInput {
+    action: "add" | "update" | "get_next" | "summary";
+    featureId?: string;
+    featureName?: string;
+    status?: FeatureStatus;
+}
+declare function createProgressTool(tracker: ProgressTracker): ToolDef<ProgressInput>;
+
+interface WriteNoteInput {
+    section: NoteSection;
+    content: string;
+}
+interface ReadNotesInput {
+    section?: NoteSection;
+}
+declare function createWriteNoteTool(store: NotesStore): ToolDef<WriteNoteInput>;
+declare function createReadNotesTool(store: NotesStore): ToolDef<ReadNotesInput>;
+
+/** Memory classification types (mirrors Prisma MemoryType enum) */
+type MemoryType = "CONVERSATION" | "FACT" | "PREFERENCE" | "SKILL_LEARNED";
+/** A stored memory entry */
+interface MemoryEntry {
+    id: string;
+    agentId: string;
+    sessionId?: string;
+    content: string;
+    memoryType: MemoryType;
+    importance: number;
+    accessCount: number;
+    lastAccessedAt?: Date;
+    expiresAt?: Date;
+    metadata?: Record<string, unknown>;
+    createdAt: Date;
+}
+/** A memory entry with a relevance score from search */
+interface MemorySearchResult extends MemoryEntry {
+    /** Cosine similarity score (0-1, higher = more relevant) */
+    score: number;
+}
+/**
+ * Memory backend interface — pluggable storage for agent memories.
+ * Implementations must handle embedding storage and vector similarity search.
+ */
+interface MemoryBackend {
+    /** Store a new memory with content and type */
+    store(agentId: string, content: string, type: MemoryType, metadata?: Record<string, unknown>): Promise<MemoryEntry>;
+    /** Search memories by semantic similarity to a query */
+    search(agentId: string, query: string, limit?: number, threshold?: number): Promise<MemorySearchResult[]>;
+    /** Recall a specific memory by id, incrementing access count */
+    recall(agentId: string, memoryId: string): Promise<MemoryEntry | null>;
+    /** Forget (delete) a specific memory */
+    forget(agentId: string, memoryId: string): Promise<void>;
+    /** Get the most recent memories for an agent */
+    getRecent(agentId: string, limit: number): Promise<MemoryEntry[]>;
+    /** Decay old memory importance scores; returns count of decayed memories */
+    decay(agentId: string): Promise<number>;
+}
+/** Configuration for the embedding service */
+interface EmbeddingConfig {
+    /** Embedding provider (e.g., "openai") */
+    provider?: string;
+    /** Embedding model name (e.g., "text-embedding-3-small") */
+    model?: string;
+    /** API key for the embedding provider */
+    apiKey?: string;
+    /** Base URL for the embedding API (for custom endpoints) */
+    baseUrl?: string;
+    /** Embedding dimensions (default depends on model) */
+    dimensions?: number;
+}
+/** Raw embedding API response shape */
+interface EmbedApiResponse {
+    embeddings: number[][];
+    model: string;
+    usage: {
+        totalTokens: number;
+    };
+}
+
+declare class EmbeddingService {
+    private readonly provider;
+    private readonly model;
+    private readonly apiKey?;
+    private readonly baseUrl;
+    private readonly dimensions;
+    constructor(config?: EmbeddingConfig);
+    /**
+     * Generate embeddings for one or more texts.
+     * If no API key is configured, falls back to hash-based pseudo-embeddings.
+     */
+    embed(texts: string[]): Promise<number[][]>;
+    /**
+     * Generate a single embedding for a text string.
+     * Convenience wrapper around embed().
+     */
+    embedSingle(text: string): Promise<number[]>;
+    /** Whether the service has a real embedding provider configured */
+    get isConfigured(): boolean;
+    private embedOpenAI;
+    /**
+     * Deterministic hash-based pseudo-embedding for testing.
+     * Produces a normalized vector of the configured dimension.
+     * NOT suitable for production semantic search — only for
+     * development/testing when no embedding API is available.
+     */
+    private hashEmbed;
+    /**
+     * Create an EmbedApiResponse from raw embedding results.
+     * Useful for callers that need the full response shape.
+     */
+    embedWithResponse(texts: string[]): Promise<EmbedApiResponse>;
+}
+
+/** Configuration for the MemoryManager */
+interface MemoryManagerConfig {
+    /** Default search result limit */
+    defaultSearchLimit?: number;
+    /** Default similarity threshold (0-1) for search results */
+    defaultThreshold?: number;
+    /** Maximum number of memories to inject into context */
+    maxContextMemories?: number;
+    /** Whether to automatically extract and store facts from conversations */
+    autoExtract?: boolean;
+}
+declare class MemoryManager {
+    private readonly backend;
+    private readonly embedding;
+    private readonly config;
+    constructor(backend: MemoryBackend, embeddingService: EmbeddingService, config?: MemoryManagerConfig);
+    /**
+     * Store a new memory for an agent.
+     * Embeds the content and persists it via the backend.
+     */
+    storeMemory(agentId: string, content: string, type: MemoryType, metadata?: Record<string, unknown>): Promise<MemoryEntry>;
+    /**
+     * Search agent memories by semantic similarity.
+     */
+    searchMemories(agentId: string, query: string, limit?: number, threshold?: number): Promise<MemorySearchResult[]>;
+    /**
+     * Recall a specific memory by id.
+     */
+    recallMemory(agentId: string, memoryId: string): Promise<MemoryEntry | null>;
+    /**
+     * Forget (delete) a specific memory.
+     */
+    forgetMemory(agentId: string, memoryId: string): Promise<void>;
+    /**
+     * Get recent memories for an agent.
+     */
+    getRecentMemories(agentId: string, limit?: number): Promise<MemoryEntry[]>;
+    /**
+     * Search for memories relevant to the current conversation messages.
+     * Combines the last few messages into a query and searches for matches.
+     * Returns the top N most relevant memories for context injection.
+     */
+    getContextMemories(agentId: string, currentMessages: string[]): Promise<MemorySearchResult[]>;
+    /**
+     * Format memory search results into a string suitable for
+     * injection into a system or user prompt.
+     */
+    formatMemoriesForPrompt(memories: MemorySearchResult[]): string;
+    /**
+     * Parse a conversation summary and extract key facts, preferences,
+     * and skills learned, storing each as a separate memory.
+     *
+     * The extraction uses simple heuristics to classify content:
+     * - Lines starting with "prefers" or "likes" / "dislikes" -> PREFERENCE
+     * - Lines starting with "learned" or "can now" -> SKILL_LEARNED
+     * - Lines that are questions or conversation flow -> CONVERSATION
+     * - Everything else -> FACT
+     *
+     * Returns the list of newly created memory entries.
+     */
+    extractAndStore(agentId: string, conversationSummary: string): Promise<MemoryEntry[]>;
+    /**
+     * Run memory importance decay for an agent.
+     * Reduces importance scores for memories that haven't been
+     * accessed recently, allowing less relevant memories to fade.
+     * Returns the number of memories affected.
+     */
+    runDecay(agentId: string): Promise<number>;
+    /** Classify a line of text into a memory type using heuristics */
+    private classifyLine;
+}
+
+/**
+ * Generic database client interface — compatible with Prisma's $queryRaw
+ * but does not directly import from @aizona/db or @prisma/client.
+ */
+interface PgVectorDatabaseClient {
+    $queryRaw(sql: TemplateStringsArray, ...values: unknown[]): Promise<unknown[]>;
+}
+declare class PgVectorMemoryBackend implements MemoryBackend {
+    private readonly db;
+    private readonly embedding;
+    private readonly decayFactor;
+    private readonly decayStaleDays;
+    constructor(db: PgVectorDatabaseClient, embeddingService: EmbeddingService, options?: {
+        decayFactor?: number;
+        decayStaleDays?: number;
+    });
+    store(agentId: string, content: string, type: MemoryType, metadata?: Record<string, unknown>): Promise<MemoryEntry>;
+    search(agentId: string, query: string, limit?: number, threshold?: number): Promise<MemorySearchResult[]>;
+    recall(agentId: string, memoryId: string): Promise<MemoryEntry | null>;
+    forget(agentId: string, memoryId: string): Promise<void>;
+    getRecent(agentId: string, limit: number): Promise<MemoryEntry[]>;
+    decay(agentId: string): Promise<number>;
+    private rowToEntry;
+}
+
+type SharedMemoryScope = "agent" | "team" | "workspace";
+interface SharedMemoryNamespace {
+    namespace: string;
+    scope: SharedMemoryScope;
+    scopeId: string;
+}
+interface SharedMemoryEntry {
+    key: string;
+    value: unknown;
+    createdAt: Date;
+    updatedAt: Date;
+    expiresAt?: Date;
+}
+interface SharedMemoryStore {
+    get(ns: SharedMemoryNamespace, key: string): Promise<unknown | null>;
+    set(ns: SharedMemoryNamespace, key: string, value: unknown, ttlMs?: number): Promise<void>;
+    delete(ns: SharedMemoryNamespace, key: string): Promise<void>;
+    list(ns: SharedMemoryNamespace, prefix?: string): Promise<string[]>;
+    clear(ns: SharedMemoryNamespace): Promise<void>;
+}
+
+declare class InMemorySharedStore implements SharedMemoryStore {
+    private store;
+    private makeKey;
+    get(ns: SharedMemoryNamespace, key: string): Promise<unknown | null>;
+    set(ns: SharedMemoryNamespace, key: string, value: unknown, ttlMs?: number): Promise<void>;
+    delete(ns: SharedMemoryNamespace, key: string): Promise<void>;
+    list(ns: SharedMemoryNamespace, prefix?: string): Promise<string[]>;
+    clear(ns: SharedMemoryNamespace): Promise<void>;
+}
+
+interface DecayPolicy {
+    /** Maximum age in milliseconds before a memory entry decays */
+    maxAgeMs: number;
+    /** How often (ms) to run the decay sweep */
+    checkIntervalMs: number;
+    /** What to do with decayed entries */
+    onDecay: "delete" | "archive";
+}
+declare class MemoryDecayManager {
+    private store;
+    private namespace;
+    private policy;
+    private timer;
+    constructor(store: {
+        delete(ns: unknown, key: string): Promise<void>;
+        list(ns: unknown, prefix?: string): Promise<string[]>;
+    }, namespace: unknown, policy: DecayPolicy);
+    /** Start the periodic decay sweep. */
+    start(): void;
+    /** Stop the periodic decay sweep. */
+    stop(): void;
+    /**
+     * Run a single decay sweep.
+     *
+     * For in-memory stores, TTL-based expiry handles cleanup automatically
+     * during reads. This method is mainly useful for persistent stores
+     * where we need explicit cleanup of old entries.
+     *
+     * Returns the number of entries that were decayed.
+     */
+    runDecay(): Promise<number>;
+}
+
+/** A single evaluation test case. */
+interface EvalCase {
+    /** Human-readable name for this case. */
+    name: string;
+    /** Input to send to the agent/executor. */
+    input: string;
+    /** If set, output must exactly match this string (after trim). */
+    expectedOutput?: string;
+    /** If set, output must match this regex pattern. */
+    expectedOutputPattern?: RegExp;
+    /** If set, this function determines pass/fail. */
+    validator?: (output: string) => boolean;
+    /** Optional agent config overrides for this case. */
+    agentConfig?: Record<string, unknown>;
+    /** Optional tags for filtering/grouping. */
+    tags?: string[];
+}
+/** Result of running a single eval case. */
+interface EvalResult {
+    /** Name of the eval case. */
+    caseName: string;
+    /** Whether the case passed. */
+    passed: boolean;
+    /** Actual output from the executor. */
+    actualOutput: string;
+    /** Expected output (if specified). */
+    expectedOutput?: string;
+    /** Execution duration in milliseconds. */
+    durationMs: number;
+    /** Error message if the executor threw. */
+    error?: string;
+}
+/** A suite of eval cases. */
+interface EvalSuite {
+    /** Suite name. */
+    name: string;
+    /** Optional description. */
+    description?: string;
+    /** The eval cases to run. */
+    cases: EvalCase[];
+}
+/**
+ * Define an eval suite with validation.
+ * Throws if the suite has no name or no cases.
+ */
+declare function defineEvalSuite(config: EvalSuite): EvalSuite;
+/**
+ * Run an eval suite against an executor function.
+ * The executor receives an input string and should return the agent's output.
+ * Cases are run sequentially to avoid overwhelming LLM providers.
+ */
+declare function runEval(suite: EvalSuite, executor: (input: string) => Promise<string>): Promise<EvalResult[]>;
+
+/** Capabilities a plugin can provide */
+type PluginCapability = "tools" | "guardrails" | "providers" | "session-backends" | "exporters" | "transforms" | "commands" | "ui-panels" | "ui-widgets" | "ui-themes";
+/** UI extension slot declaration */
+interface UIExtensionSlot {
+    /** Slot identifier: "dashboard.sidebar", "agent.detail.tab", "settings.panel", "marketplace.card" */
+    slot: string;
+    /** Display label */
+    label: string;
+    /** Relative path to the component within the plugin package */
+    component: string;
+    /** Optional icon name */
+    icon?: string;
+}
+/** Plugin manifest — immutable metadata about the plugin */
+interface PluginManifest {
+    name: string;
+    version: string;
+    description: string;
+    author?: string;
+    homepage?: string;
+    capabilities: PluginCapability[];
+    uiExtensions?: UIExtensionSlot[];
+    /** JSON Schema describing the plugin's configuration shape */
+    configSchema?: Record<string, unknown>;
+}
+/** Context provided to a plugin during activation */
+interface PluginContext {
+    /** Register a tool that agents can use */
+    registerTool(tool: ToolDef<unknown, unknown>): void;
+    /** Register a guardrail */
+    registerGuardrail(config: {
+        name: string;
+        type: "input" | "output" | "tool";
+        handler: (...args: unknown[]) => Promise<unknown>;
+    }): void;
+    /** Register a trace exporter */
+    registerExporter(exporter: {
+        export(trace: unknown): Promise<void>;
+    }): void;
+    /** Access the event bus for pub/sub */
+    getEventBus(): ADKEventBus;
+    /** Get plugin configuration (type-safe with generic) */
+    getConfig<T = Record<string, unknown>>(): T;
+    /** Get plugin data directory path (for persistent storage) */
+    getDataDir(): string;
+    /** Log a message scoped to this plugin */
+    log(level: "debug" | "info" | "warn" | "error", message: string, data?: Record<string, unknown>): void;
+}
+/** Lifecycle hooks for a plugin */
+interface PluginLifecycle {
+    /** Called when plugin is activated. Register tools, guardrails, etc. */
+    activate(ctx: PluginContext): Promise<void>;
+    /** Called when plugin is deactivated. Cleanup resources. */
+    deactivate?(): Promise<void>;
+    /** Called when plugin config changes at runtime */
+    onConfigChanged?(newConfig: Record<string, unknown>): Promise<void>;
+    /** Health check — returns whether the plugin is functioning correctly */
+    onHealthCheck?(): Promise<{
+        healthy: boolean;
+        details?: Record<string, unknown>;
+    }>;
+}
+/** Complete plugin definition (manifest + lifecycle) */
+interface PluginDefinition {
+    manifest: PluginManifest;
+    lifecycle: PluginLifecycle;
+}
+
+/** Define a plugin from config — validates manifest and freezes the definition */
+declare function definePlugin(config: {
+    manifest: PluginManifest;
+    activate: PluginLifecycle["activate"];
+    deactivate?: PluginLifecycle["deactivate"];
+    onConfigChanged?: PluginLifecycle["onConfigChanged"];
+    onHealthCheck?: PluginLifecycle["onHealthCheck"];
+}): PluginDefinition;
+
+type PluginStatus = "registered" | "active" | "inactive" | "error";
+interface PluginEntry {
+    definition: PluginDefinition;
+    status: PluginStatus;
+    config: Record<string, unknown>;
+    registeredTools: string[];
+    registeredGuardrails: string[];
+    registeredExporters: number;
+    error?: string;
+    activatedAt?: Date;
+}
+declare class PluginRegistry {
+    private plugins;
+    private tools;
+    private guardrails;
+    private exporters;
+    private eventBus?;
+    private dataDir;
+    constructor(options?: {
+        eventBus?: ADKEventBus;
+        dataDir?: string;
+    });
+    /** Register a plugin definition (does not activate it) */
+    register(definition: PluginDefinition, config?: Record<string, unknown>): void;
+    /** Activate a registered plugin — calls its activate() lifecycle hook */
+    activate(name: string): Promise<void>;
+    /** Deactivate a plugin — calls deactivate() and removes all registered extensions */
+    deactivate(name: string): Promise<void>;
+    /** Unregister a plugin — must be deactivated first */
+    unregister(name: string): void;
+    /** Get a plugin entry by name */
+    getPlugin(name: string): PluginEntry | undefined;
+    /** List all registered plugins with their status */
+    listPlugins(): Array<{
+        name: string;
+        version: string;
+        status: PluginStatus;
+        capabilities: PluginCapability[];
+    }>;
+    /** Get all tools registered by plugins (namespaced as "pluginName:toolName") */
+    getRegisteredTools(): Map<string, ToolDef<unknown, unknown>>;
+    /** Get all guardrails registered by plugins */
+    getRegisteredGuardrails(): Array<{
+        pluginName: string;
+        config: unknown;
+    }>;
+    /** Get all trace exporters registered by plugins */
+    getRegisteredExporters(): Array<{
+        pluginName: string;
+        exporter: unknown;
+    }>;
+    /** Run health check on a specific plugin */
+    healthCheck(name: string): Promise<{
+        healthy: boolean;
+        details?: Record<string, unknown>;
+    }>;
+    /** Update config for a plugin and notify it if active */
+    updateConfig(name: string, newConfig: Record<string, unknown>): Promise<void>;
+    /** Create the PluginContext handed to the plugin during activation */
+    private createContext;
+}
+
+export { ADKEventBus, type ADKEventListener, type ADKEventMap, type ADKEventName, ADKLLMAdapter, type ADKLLMProvider, ADKPipeline, ADKProviderError, type ADKProviderErrorCode, ADKReviewPipeline, ADKRouter, Agent, type AgentConfig, type AgentErrorEvent, type AgentHeartbeatEvent, type AgentInfo, type AgentLLMConfig, type AgentLogEvent, type AgentStartedEvent, type AgentStoppedEvent, AgenticMemory, type AgenticMemoryBackend, type AlertCreatedEvent, type AlertResolvedEvent, AnthropicProvider, type Artifact, type ArtifactCreatedEvent, ArtifactStore, type AudioPart, AudioStreamBuffer, type AutonomyLevel, type BackpressureOptions, BackpressuredStream, BaseProvider, type BudgetCheckData, type BudgetPeriod, type CatalogModel, type ChatMessage, type ChatParams, type ChatParamsWithTools, type ChatResponse, type ChatResponseWithToolCalls, type ChatRole, type CircuitBreakerState, type CodeExecutionResult, CodeExecutor, type CodeExecutorConfig, type CompactionOptions, type CompleteParams, type CompleteResponse, type ConsentDecision, type ConsentHandler, type ConsentLevel, type ConsentRequest, ConsoleExporter, type Content, type ContentGuardrail, type ContentPart, type ContextConfig, ContextManager, type ContextManagerConfig, type ContextStrategy, ContextSummarizer, type ContextTrimmedEvent, type DecayPolicy, type EmbedApiResponse, type EmbedParams, type EmbedResponse, type EmbeddingConfig, EmbeddingService, type EvalCase, type EvalResult, type EvalSuite, EventBusExporter, type FeatureStatus, GoogleProvider, type Guardrail, type GuardrailConfig, GuardrailEngine, type GuardrailResult, type GuardrailSeverity, type GuardrailTriggeredEvent, GuardrailTripwireError, type GuardrailType, HANDOFF_PREFIX, type HandoffEvent, HandoffManager, type HandoffRecord, type HandoffTarget, type HealthCheckEvent, type ImagePart, InMemoryBackend, InMemorySharedStore, type InputGuardrail, type JsonSchema, type LLMCallCompletedEvent, type LLMCallFailedEvent, type LLMProvider, type LLMProviderSwitchedEvent, type LLMToolDefinition, LMStudioProvider, LangfuseExporter, type LoadedSkill, MCPServerConnector, type MediaType, type MemoryBackend, MemoryDecayManager, type MemoryEntry, MemoryManager, type MemoryManagerConfig, type MemorySearchResult, MemorySessionBackend, type MemoryType, type ModelCapability, type ModelConfig, type ModelsDiscoveredEvent, type NoteEntry, type NoteSection, NotesStore, OllamaProvider, OpenAIProvider, type OutputGuardrail, ParallelRunner, type PgVectorDatabaseClient, PgVectorMemoryBackend, type PluginCapability, type PluginContext, type PluginDefinition, type PluginLifecycle, type PluginManifest, PluginRegistry, type PluginStatus, PrismaSessionBackend, type ProgressFeature, ProgressTracker, type ProviderInitConfig, type ProviderMetrics, ProxyRouter, RealtimeAgent, type RedactOptions, type ResponseFormat, type RoutingStrategy, type RunCompletedEvent, type RunConfig, type RunContext, type RunFailedEvent, type RunResult, type RunStartedEvent, type RunUsage, Runner, type RunnerConfig, type Session, type SessionBackend, type SessionCreateOptions, type SessionCreatedEvent, type SessionListFilter, type SessionResumedEvent, type SessionStatus, type SessionUpdateOptions, type SharedMemoryEntry, type SharedMemoryNamespace, type SharedMemoryScope, type SharedMemoryStore, type SkillManifest, SkillManifestSchema, type SkillToolEntry, Span, type StreamChunk, type StreamEvent, type SummarizationConfig, type TaskCompletedEvent, type TaskFailedEvent, type TaskStartedEvent, type TaskSubmittedEvent, Team, type TextPart, TokenCounter, type TokenCounterConfig, type TokenCounterStrategy, type ToolCall, type ToolContext, type ToolDef, type ToolDefConfig, type ToolExecutedEvent, type ToolGuardrail, type ToolHooks, type ToolPostHookResult, type ToolPreHookResult, ToolRegistry, type ToolRelevanceScore, type ToolResult, type ToolSearchResult, type ToolSelectionConfig, type ToolSelectionStrategy, ToolSelector, type ToolsSelectedEvent, Trace, Tracer, type TracingConfig, TurnExecutor, type UIArtifactPart, type UIExtensionSlot, type VideoPart, XAIProvider, agentAsTool, budgetGateGuardrail, budgetLimit, calculateVolume, compactMessages, consentGate, contentFilter, contentToParts, contentToString, countMediaParts, createArtifactTool, createAsyncEventStream, createExecuteCodeTool, createMemoryReadTool, createMemorySearchTool, createMemoryWriteTool, createProgressTool, createProvider, createReadNotesTool, createRunContext, createRunId, createStreamAdapter, createToolSearchTool, createTraceId, createWriteNoteTool, defineAgent, defineEvalSuite, definePlugin, defineSkill, defineTool, discoverMCPTools, encodeSSE, ensureJsonSchema, extractText, generateApiKey, hashApiKey, isAudioPart, isImagePart, isMultiModalContent, isTextPart, isUIArtifactPart, isVideoPart, isZodSchema, loadSkill, mcpSelectTools, mcpServerTools, mergeSkillTools, parseApiKey, pcm16FromArrayBuffer, pcm16ToArrayBuffer, piiFilter, redact, relayToWebSocket, runEval, schemaToToolInput, streamToSSE, toAnthropicToolSchema, toGoogleSchemaFormat, toOpenAIResponseFormat, tokenLimit, validateApiKeyFormat, validateOutput, zodToJsonSchema };