gauss-ai 4.0.0

package/dist/index-BRgqNnh3.d.cts

@@ -0,0 +1,982 @@
+import { T as Tool } from './types-CVsP7gFI.cjs';
+import { q as Plugin, aa as PluginSetupContext, e as PluginContext, Z as BeforeRunParams, _ as BeforeRunResult, W as AfterRunParams, a1 as BeforeToolParams, a2 as BeforeToolResult, Y as AfterToolParams, $ as BeforeStepParams, a0 as BeforeStepResult, X as AfterStepParams, a8 as OnErrorParams, a9 as OnErrorResult, r as PluginHooks, o as AgentRunOptions, p as AgentResult, T as TelemetryPort, n as CostTrackerPort, c as ToolCache, C as CircuitBreaker } from './agent-builder-GEMYdb1p.cjs';
+import { a as FilesystemZone } from './token-counter.port-D7BHMCRR.cjs';
+import { AgentCapability, DelegationResult } from './a2a/index.cjs';
+import { ZodType, z } from 'zod';
+import { d as WorkflowResult, h as WorkflowStep, W as WorkflowContext, a as WorkflowDefinition, b as WorkflowPort } from './workflow.port-BaCttxrw.cjs';
+import { I as ISemanticScrapingPort } from './semantic-scraping.port-CZWUea88.cjs';
+
+declare class PluginManager {
+    private readonly plugins;
+    private readonly subscriptions;
+    private initPromise?;
+    private disposed;
+    register(plugin: Plugin): void;
+    initialize(ctx: PluginSetupContext): Promise<void>;
+    private doInitialize;
+    private rollback;
+    private detachAllSubscriptions;
+    /** Collect all plugin tools with deterministic override protection. */
+    collectTools(): Record<string, Tool<any, any>>;
+    runBeforeRun(ctx: PluginContext, params: BeforeRunParams): Promise<BeforeRunResult>;
+    runAfterRun(ctx: PluginContext, params: AfterRunParams): Promise<void>;
+    runBeforeTool(ctx: PluginContext, params: BeforeToolParams): Promise<BeforeToolResult>;
+    runAfterTool(ctx: PluginContext, params: AfterToolParams): Promise<void>;
+    runBeforeStep(ctx: PluginContext, params: BeforeStepParams): Promise<BeforeStepResult>;
+    runAfterStep(ctx: PluginContext, params: AfterStepParams): Promise<void>;
+    runOnError(ctx: PluginContext, params: OnErrorParams): Promise<OnErrorResult>;
+    dispose(): Promise<void>;
+    get count(): number;
+    getPlugins(): readonly Plugin[];
+}
+
+interface McpServerPort {
+    /** Start the MCP server with the given options */
+    start(options: McpServerOptions): Promise<void>;
+    /** Stop the MCP server */
+    stop(): Promise<void>;
+    /** Return all registered tool definitions */
+    getRegisteredTools(): McpToolServerDefinition[];
+}
+interface McpServerOptions {
+    /** Server name advertised in initialize response */
+    name: string;
+    /** Server version advertised in initialize response */
+    version: string;
+    /** Transport type: stdio (line-delimited JSON-RPC) or sse (HTTP SSE) */
+    transport: "stdio" | "sse";
+    /** Port for SSE transport (default: 3100) */
+    port?: number;
+    /** Only expose tools whose names match this list */
+    toolFilter?: string[];
+}
+interface McpToolServerDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+
+interface ValidationResult<T = unknown> {
+    readonly success: boolean;
+    readonly data?: T;
+    readonly error?: string;
+}
+interface ValidationPort {
+    validate<T>(schema: unknown, data: unknown): ValidationResult<T>;
+    validateOrThrow<T>(schema: unknown, data: unknown): T;
+}
+
+interface ChunkOptions {
+    strategy: "fixed" | "sliding-window" | "semantic" | "recursive";
+    /** Max tokens per chunk (word-count proxy). Default: 512 */
+    maxTokens?: number;
+    /** Overlap in tokens for sliding-window strategy. Default: 50 */
+    overlap?: number;
+    /** Separators for recursive strategy. Default: ['\n\n', '\n', '. ', ' '] */
+    separators?: string[];
+}
+interface Chunk {
+    id: string;
+    text: string;
+    index: number;
+    metadata: {
+        startOffset: number;
+        endOffset: number;
+        tokenCount: number;
+        source?: string;
+    };
+}
+interface ChunkingPort {
+    chunk(text: string, options?: ChunkOptions): Chunk[];
+}
+
+interface SourceAttribution {
+    chunkId: string;
+    chunkIndex: number;
+    documentId?: string;
+    startOffset: number;
+    endOffset: number;
+    relevanceScore: number;
+}
+interface ScoredResult {
+    id: string;
+    text: string;
+    score: number;
+    source?: SourceAttribution;
+}
+interface ReRankingOptions {
+    strategy: "tfidf" | "bm25" | "mmr";
+    /** Lambda for MMR diversity (0 = max diversity, 1 = max relevance). Default: 0.7 */
+    lambda?: number;
+}
+interface ReRankingPort {
+    rerank(query: string, results: ScoredResult[], options?: ReRankingOptions): ScoredResult[];
+}
+
+declare abstract class BasePlugin implements Plugin {
+    abstract readonly name: string;
+    readonly version = "1.0.0";
+    readonly hooks: PluginHooks;
+    constructor();
+    protected abstract buildHooks(): PluginHooks;
+}
+
+type AgentCardSource = "manual" | "override" | "auto";
+interface AgentCardSnapshot {
+    agentsMd: string;
+    skillsMd: string;
+    source: {
+        agents: AgentCardSource;
+        skills: AgentCardSource;
+    };
+}
+interface AgentCardProvider {
+    getAgentCard(): Promise<AgentCardSnapshot>;
+}
+interface AgentCardDocument {
+    title: string;
+    name: string;
+    sessionId: string;
+    maxSteps: number;
+    summary: string;
+    instructions: string;
+    tools: string[];
+    generatedAt: string;
+}
+interface SkillsDocument {
+    title: string;
+    name: string;
+    summary: string;
+    skills: string[];
+    generatedAt: string;
+}
+interface AgentCardPluginOptions {
+    paths?: {
+        agents?: string;
+        skills?: string;
+    };
+    readZones?: FilesystemZone[];
+    overrides?: {
+        agents?: string | Partial<AgentCardDocument>;
+        skills?: string | Partial<SkillsDocument>;
+    };
+}
+declare class AgentCardPlugin implements Plugin, AgentCardProvider {
+    readonly name = "agent-card";
+    readonly version = "1.0.0";
+    readonly tools: Record<string, Tool<any, any>>;
+    private readonly options;
+    private setupCtx?;
+    private latestCtx?;
+    readonly hooks: {
+        beforeRun: (ctx: PluginContext, _params: {
+            prompt: string;
+        }) => Promise<void>;
+        afterRun: (ctx: PluginContext, _params: {
+            result: {
+                text: string;
+                steps: unknown[];
+                sessionId: string;
+            };
+        }) => Promise<void>;
+    };
+    constructor(options?: AgentCardPluginOptions);
+    setup(ctx: PluginSetupContext): void;
+    getAgentCard(): Promise<AgentCardSnapshot>;
+    private resolveAgentsMarkdown;
+    private resolveSkillsMarkdown;
+    private tryReadManual;
+    private createAutoAgentCard;
+    private createAutoSkillsCard;
+    private mergeAgentCard;
+    private mergeSkillsCard;
+    private renderAgentCard;
+    private renderSkillsCard;
+}
+declare function createAgentCardPlugin(options?: AgentCardPluginOptions): AgentCardPlugin;
+
+interface A2AJsonRpcRequest {
+    jsonrpc: "2.0";
+    id?: string | number | null;
+    method: string;
+    params?: unknown;
+}
+interface A2AJsonRpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+interface A2AJsonRpcResponse {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    result?: unknown;
+    error?: A2AJsonRpcError;
+}
+type A2ATaskStatus = "queued" | "running" | "completed" | "failed" | "cancelled";
+interface A2ATask {
+    id: string;
+    status: A2ATaskStatus;
+    prompt: string;
+    output?: string;
+    error?: string;
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+    completedAt?: string;
+}
+interface A2ATasksSendParams {
+    prompt: string;
+    taskId?: string;
+    metadata?: Record<string, unknown>;
+}
+interface A2ATaskEvent {
+    type: 'task:queued' | 'task:running' | 'task:completed' | 'task:failed' | 'task:cancelled';
+    taskId: string;
+    task: A2ATask;
+    timestamp: string;
+}
+type TaskEventListener = (event: A2ATaskEvent) => void;
+interface A2ARequestHandlers {
+    sendTask(params: A2ATasksSendParams): Promise<A2ATask>;
+    getTask(taskId: string): Promise<A2ATask | null>;
+    listTasks?(): Promise<A2ATask[]>;
+    cancelTask?(taskId: string): Promise<A2ATask | null>;
+    getAgentCard?(): Promise<unknown>;
+    sendTaskSubscribe?(params: A2ATasksSendParams): AsyncIterable<A2ATaskEvent>;
+}
+declare function createA2AJsonRpcHandler(handlers: A2ARequestHandlers): (request: A2AJsonRpcRequest) => Promise<A2AJsonRpcResponse>;
+declare function createA2AHttpHandler(jsonRpcHandler: (request: A2AJsonRpcRequest) => Promise<A2AJsonRpcResponse>, sseHandlers?: {
+    sendTaskSubscribe?: (params: A2ATasksSendParams) => AsyncIterable<A2ATaskEvent>;
+}): (request: Request) => Promise<Response>;
+declare function createA2ASseHandler(handlers: Pick<A2ARequestHandlers, 'sendTaskSubscribe'>): (params: A2ATasksSendParams) => AsyncIterable<A2ATaskEvent>;
+
+interface PushNotificationConfig {
+    url: string;
+    headers?: Record<string, string>;
+    events?: A2ATaskEvent['type'][];
+}
+declare class A2APushNotifier {
+    private readonly subscriptions;
+    private readonly fetchImpl;
+    constructor(fetchImpl?: typeof fetch);
+    private static readonly BLOCKED_HEADERS;
+    private static readonly LOCAL_HOSTS;
+    subscribe(taskId: string, config: PushNotificationConfig): void;
+    unsubscribe(taskId: string, url: string): void;
+    notify(event: A2ATaskEvent): Promise<void>;
+    cleanup(taskId: string): void;
+}
+
+interface A2ATaskRetryConfig {
+    maxAttempts: number;
+    initialBackoffMs: number;
+    backoffMultiplier: number;
+    maxBackoffMs: number;
+    jitterRatio: number;
+}
+interface A2ATaskQueueConfig {
+    leaseDurationMs: number;
+    retentionMs: number;
+    maxTerminalTasks: number;
+    retry: A2ATaskRetryConfig;
+    now?: () => number;
+    idFactory?: () => string;
+}
+interface A2ATaskLease {
+    taskId: string;
+    leaseId: string;
+    workerId: string;
+    expiresAt: string;
+    attempt: number;
+    maxAttempts: number;
+}
+interface A2ATaskFailResult {
+    task: A2ATask;
+    willRetry: boolean;
+    retryDelayMs: number;
+    attempts: number;
+    maxAttempts: number;
+}
+interface A2ATaskQueueSnapshot {
+    version: 1;
+    entries: Array<{
+        task: A2ATask;
+        attempts: number;
+        maxAttempts: number;
+        nextAttemptAt: number;
+        finishedAt?: number;
+        lease?: {
+            leaseId: string;
+            workerId: string;
+            expiresAt: number;
+        };
+    }>;
+}
+declare class A2ADurableTaskQueue {
+    private readonly entries;
+    private readonly now;
+    private readonly idFactory;
+    private readonly config;
+    constructor(config?: Partial<A2ATaskQueueConfig>);
+    get size(): number;
+    enqueue(task: A2ATask, options?: {
+        maxAttempts?: number;
+    }): A2ATask;
+    get(taskId: string): A2ATask | null;
+    list(): A2ATask[];
+    acquire(taskId: string, workerId: string): A2ATaskLease | null;
+    extendLease(taskId: string, leaseId: string, leaseDurationMs?: number): boolean;
+    complete(taskId: string, output: string, leaseId?: string): A2ATask | null;
+    fail(taskId: string, error: string, leaseId?: string): A2ATaskFailResult | null;
+    cancel(taskId: string): A2ATask | null;
+    evictExpired(): void;
+    snapshot(): A2ATaskQueueSnapshot;
+    hydrate(snapshot: A2ATaskQueueSnapshot | null | undefined): void;
+    private validateLease;
+    private resolveExpiredLeases;
+    private computeBackoffDelay;
+}
+
+interface A2AAgentRuntime {
+    sessionId: string;
+    run(prompt: string, options?: AgentRunOptions): Promise<AgentResult>;
+}
+interface A2APluginOptions {
+    fetch?: typeof fetch;
+    requestTimeoutMs?: number;
+    agentCardProvider?: AgentCardProvider;
+    retry?: Partial<A2ATaskRetryConfig>;
+    queue?: Partial<Pick<A2ATaskQueueConfig, "leaseDurationMs" | "retentionMs" | "maxTerminalTasks">>;
+    taskQueue?: A2ADurableTaskQueue;
+    persistQueueState?: boolean;
+}
+declare class A2APlugin implements Plugin {
+    readonly name = "a2a";
+    readonly version = "1.0.0";
+    readonly tools: Record<string, Tool<any, any>>;
+    private readonly fetchImpl;
+    private readonly requestTimeoutMs;
+    private readonly agentCardProvider?;
+    private readonly taskQueue;
+    private readonly persistQueueStateEnabled;
+    private readonly delegationManager;
+    private readonly pushNotifier;
+    private readonly taskEventListeners;
+    private static readonly QUEUE_SNAPSHOT_KEY;
+    private static readonly DEFAULT_MAX_TERMINAL_TASKS;
+    private static readonly DEFAULT_RETENTION_MS;
+    private evictionTimer?;
+    private queueHydrated;
+    private queueHydrationPromise;
+    private setupCtx?;
+    private latestCtx?;
+    readonly hooks: {
+        beforeRun: (ctx: PluginContext, _params: {
+            prompt: string;
+        }) => Promise<void>;
+        afterRun: (ctx: PluginContext, params: {
+            result: {
+                text: string;
+            };
+        }) => Promise<void>;
+        onError: (ctx: PluginContext, params: {
+            error: unknown;
+            phase: "run" | "stream" | "tool" | "step" | "setup";
+        }) => Promise<void>;
+    };
+    constructor(options?: A2APluginOptions);
+    setup(ctx: PluginSetupContext): void;
+    dispose(): void;
+    createJsonRpcHandler(agent: A2AAgentRuntime): (request: A2AJsonRpcRequest) => Promise<A2AJsonRpcResponse> & {
+        sendTaskSubscribe?: (params: A2ATasksSendParams) => AsyncGenerator<A2ATaskEvent, void, unknown>;
+    };
+    createHttpHandler(agent: A2AAgentRuntime): (request: Request) => Promise<Response>;
+    getTask(taskId: string): A2ATask | null;
+    listTasks(): A2ATask[];
+    registerAgent(agent: AgentCapability): void;
+    unregisterAgent(name: string): void;
+    listAgents(): AgentCapability[];
+    delegateTask(prompt: string, requiredSkills: string[]): Promise<DelegationResult>;
+    subscribeToTaskNotifications(taskId: string, config: PushNotificationConfig): void;
+    unsubscribeFromTaskNotifications(taskId: string, url: string): void;
+    private normalizeCallParams;
+    private callRemoteEndpoint;
+    private queueTask;
+    private markTaskRunning;
+    private markTaskCompleted;
+    private markTaskFailed;
+    private executeTaskWithRetry;
+    private evictStaleTasks;
+    private emitTaskEvent;
+    private createWorkerId;
+    private normalizeError;
+    private ensureQueueHydrated;
+    private hydrateQueueFromMemory;
+    private persistQueueState;
+    private sleep;
+    private discoverAgent;
+    private subscribeToTask;
+    private getTaskIdFromContext;
+    private getLeaseIdFromContext;
+    private isQueueManagedRun;
+    private resolveAgentCard;
+    private cloneTask;
+}
+declare function createA2APlugin(options?: A2APluginOptions): A2APlugin;
+
+interface ContentFilter {
+    readonly name: string;
+    test(content: string): boolean;
+}
+interface GuardrailsPluginOptions {
+    /** Zod schema to validate the input prompt */
+    inputSchema?: ZodType;
+    /** Zod schema to validate the output text */
+    outputSchema?: ZodType;
+    /** Per-tool argument validation schemas (keyed by tool name) */
+    toolSchemas?: Record<string, ZodType>;
+    /** Content filters applied to both input and output */
+    contentFilters?: ContentFilter[];
+    /** Custom input validators */
+    inputValidators?: Array<(prompt: string) => string | null>;
+    /** Custom output validators */
+    outputValidators?: Array<(output: string) => string | null>;
+    /** Action on validation failure: 'throw' (default) or 'warn' */
+    onFailure?: "throw" | "warn";
+    /** Validation adapter (defaults to ZodValidationAdapter) */
+    validator?: ValidationPort;
+}
+declare class GuardrailsError extends Error {
+    readonly code: "input_validation" | "output_validation" | "content_filter" | "tool_validation";
+    constructor(code: GuardrailsError["code"], message: string);
+}
+declare class GuardrailsPlugin extends BasePlugin {
+    readonly name = "guardrails";
+    private readonly options;
+    private readonly validator;
+    constructor(options?: GuardrailsPluginOptions);
+    protected buildHooks(): PluginHooks;
+    private beforeRun;
+    private afterRun;
+    private beforeTool;
+    private fail;
+}
+declare function createGuardrailsPlugin(options?: GuardrailsPluginOptions): GuardrailsPlugin;
+declare function createPiiFilter(): ContentFilter;
+
+interface OneCrawlPluginOptions {
+    /** onecrawl Crawler instance — if not provided, one will be created lazily */
+    crawler?: unknown;
+    /** Maximum content length per scraped page (default: 10000) */
+    maxContentLength?: number;
+    /** Timeout per request in ms (default: 30000) */
+    timeout?: number;
+    /** Validation adapter (defaults to ZodValidationAdapter) */
+    validator?: ValidationPort;
+}
+declare class OneCrawlPlugin extends BasePlugin {
+    readonly name = "crawl";
+    private readonly options;
+    private crawlerPromise;
+    private readonly validator;
+    constructor(options?: OneCrawlPluginOptions);
+    protected buildHooks(): PluginHooks;
+    private getCrawler;
+    private initCrawler;
+    get tools(): Record<string, Tool<any, any>>;
+    dispose(): Promise<void>;
+}
+declare function createOneCrawlPlugin(options?: OneCrawlPluginOptions): OneCrawlPlugin;
+
+interface VectorlessPluginOptions {
+    /** Pre-configured vectorless instance */
+    vectorless?: unknown;
+    /** Knowledge base — pre-loaded knowledge to query against */
+    knowledgeBase?: unknown;
+    /** Model to use for knowledge generation (default: uses vectorless default) */
+    model?: unknown;
+    /** Validation adapter (defaults to ZodValidationAdapter) */
+    validator?: ValidationPort;
+    /** Custom chunking adapter (defaults to DefaultChunkingAdapter) */
+    chunkingAdapter?: ChunkingPort;
+    /** Custom re-ranking adapter (defaults to DefaultReRankingAdapter) */
+    rerankingAdapter?: ReRankingPort;
+}
+declare class VectorlessPlugin extends BasePlugin {
+    readonly name = "knowledge";
+    private readonly options;
+    private vectorlessPromise;
+    private currentKnowledge;
+    private readonly validator;
+    readonly chunks: Map<string, Chunk>;
+    readonly chunkingAdapter: ChunkingPort;
+    readonly rerankingAdapter: ReRankingPort;
+    private _toolsCache?;
+    constructor(options?: VectorlessPluginOptions);
+    protected buildHooks(): PluginHooks;
+    private getVectorless;
+    private initVectorless;
+    get tools(): Record<string, Tool<any, any>>;
+    dispose(): Promise<void>;
+}
+declare function createVectorlessPlugin(options?: VectorlessPluginOptions): VectorlessPlugin;
+
+declare const EvalMetricsSchema: z.ZodObject<{
+    latencyMs: z.ZodNumber;
+    stepCount: z.ZodNumber;
+    toolCalls: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    tokenUsage: z.ZodOptional<z.ZodObject<{
+        prompt: z.ZodDefault<z.ZodNumber>;
+        completion: z.ZodDefault<z.ZodNumber>;
+        total: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        prompt: number;
+        completion: number;
+        total: number;
+    }, {
+        prompt?: number | undefined;
+        completion?: number | undefined;
+        total?: number | undefined;
+    }>>;
+    customScores: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    toolCalls: Record<string, number>;
+    latencyMs: number;
+    stepCount: number;
+    customScores: Record<string, number>;
+    tokenUsage?: {
+        prompt: number;
+        completion: number;
+        total: number;
+    } | undefined;
+}, {
+    toolCalls: Record<string, number>;
+    latencyMs: number;
+    stepCount: number;
+    tokenUsage?: {
+        prompt?: number | undefined;
+        completion?: number | undefined;
+        total?: number | undefined;
+    } | undefined;
+    customScores?: Record<string, number> | undefined;
+}>;
+type EvalMetrics = z.infer<typeof EvalMetricsSchema>;
+declare const EvalResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    sessionId: z.ZodString;
+    prompt: z.ZodString;
+    output: z.ZodString;
+    metrics: z.ZodObject<{
+        latencyMs: z.ZodNumber;
+        stepCount: z.ZodNumber;
+        toolCalls: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        tokenUsage: z.ZodOptional<z.ZodObject<{
+            prompt: z.ZodDefault<z.ZodNumber>;
+            completion: z.ZodDefault<z.ZodNumber>;
+            total: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            prompt: number;
+            completion: number;
+            total: number;
+        }, {
+            prompt?: number | undefined;
+            completion?: number | undefined;
+            total?: number | undefined;
+        }>>;
+        customScores: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        toolCalls: Record<string, number>;
+        latencyMs: number;
+        stepCount: number;
+        customScores: Record<string, number>;
+        tokenUsage?: {
+            prompt: number;
+            completion: number;
+            total: number;
+        } | undefined;
+    }, {
+        toolCalls: Record<string, number>;
+        latencyMs: number;
+        stepCount: number;
+        tokenUsage?: {
+            prompt?: number | undefined;
+            completion?: number | undefined;
+            total?: number | undefined;
+        } | undefined;
+        customScores?: Record<string, number> | undefined;
+    }>;
+    createdAt: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    id: string;
+    output: string;
+    createdAt: number;
+    sessionId: string;
+    metrics: {
+        toolCalls: Record<string, number>;
+        latencyMs: number;
+        stepCount: number;
+        customScores: Record<string, number>;
+        tokenUsage?: {
+            prompt: number;
+            completion: number;
+            total: number;
+        } | undefined;
+    };
+}, {
+    prompt: string;
+    id: string;
+    output: string;
+    sessionId: string;
+    metrics: {
+        toolCalls: Record<string, number>;
+        latencyMs: number;
+        stepCount: number;
+        tokenUsage?: {
+            prompt?: number | undefined;
+            completion?: number | undefined;
+            total?: number | undefined;
+        } | undefined;
+        customScores?: Record<string, number> | undefined;
+    };
+    createdAt?: number | undefined;
+}>;
+type EvalResult = z.infer<typeof EvalResultSchema>;
+
+interface EvalScorer {
+    readonly name: string;
+    score(prompt: string, output: string, metrics: EvalMetrics): Promise<number> | number;
+}
+interface EvalsPluginOptions {
+    /** Custom scoring functions */
+    scorers?: EvalScorer[];
+    /** Whether to persist results via MemoryPort metadata (default: false) */
+    persist?: boolean;
+    /** Callback invoked after each evaluation */
+    onEval?: (result: EvalResult) => void | Promise<void>;
+}
+declare class EvalsPlugin extends BasePlugin {
+    readonly name = "evals";
+    private readonly options;
+    private readonly results;
+    private readonly runStates;
+    constructor(options?: EvalsPluginOptions);
+    protected buildHooks(): PluginHooks;
+    private beforeRun;
+    private afterRun;
+    private afterTool;
+    private onError;
+    /** Get all collected eval results */
+    getResults(): readonly EvalResult[];
+    /** Get the most recent eval result */
+    getLastResult(): EvalResult | undefined;
+    /** Clear collected results */
+    clearResults(): void;
+}
+declare function createEvalsPlugin(options?: EvalsPluginOptions): EvalsPlugin;
+
+interface WorkflowPluginConfig {
+    steps: WorkflowStep[];
+    initialContext?: WorkflowContext;
+}
+type WorkflowPluginInput = WorkflowPluginConfig | WorkflowDefinition;
+declare class WorkflowError extends Error {
+    readonly result: WorkflowResult;
+    constructor(message: string, result: WorkflowResult);
+}
+declare class WorkflowPlugin extends BasePlugin {
+    readonly name = "workflow";
+    private readonly steps;
+    private readonly initialContext;
+    private readonly definition?;
+    private readonly engine?;
+    private lastResult;
+    constructor(config: WorkflowPluginInput, engine?: WorkflowPort);
+    protected buildHooks(): PluginHooks;
+    getLastResult(): WorkflowResult | undefined;
+    private beforeRun;
+    private executeWorkflow;
+    private executeWithRetry;
+    private rollback;
+}
+declare function createWorkflowPlugin(config: WorkflowPluginInput, engine?: WorkflowPort): WorkflowPlugin;
+
+interface ObservabilityConfig {
+    enableTracing?: boolean;
+    enableMetrics?: boolean;
+    enableCostEstimation?: boolean;
+    costPerInputToken?: number;
+    costPerOutputToken?: number;
+    maxSpans?: number;
+}
+interface Span {
+    id: string;
+    traceId: string;
+    name: string;
+    startTime: number;
+    endTime?: number;
+    attributes: Record<string, unknown>;
+    parentId?: string;
+    status: 'ok' | 'error';
+    children: Span[];
+}
+interface AgentMetrics {
+    totalTokens: {
+        input: number;
+        output: number;
+    };
+    totalLatencyMs: number;
+    toolCalls: {
+        name: string;
+        latencyMs: number;
+        success: boolean;
+    }[];
+    llmCalls: {
+        latencyMs: number;
+        inputTokens: number;
+        outputTokens: number;
+    }[];
+    estimatedCostUsd?: number;
+}
+declare class ObservabilityPlugin extends BasePlugin {
+    readonly name = "observability";
+    readonly version = "1.0.0";
+    private config;
+    private spans;
+    private rootSpans;
+    private activeSpans;
+    private sessionMetrics;
+    private sessionStartTimes;
+    private toolStartTimes;
+    private readonly toolSpanStack;
+    private readonly maxSpans;
+    constructor(config?: ObservabilityConfig);
+    protected buildHooks(): PluginHooks;
+    private generateId;
+    private createSpan;
+    private endSpan;
+    private getOrCreateMetrics;
+    private onRequest;
+    private onResponse;
+    private onToolStart;
+    private onToolEnd;
+    private onError;
+    getTraces(): Span[];
+    getMetrics(sessionId?: string): AgentMetrics;
+    private deepCopyMetrics;
+    exportOpenTelemetry(): object;
+    reset(): void;
+}
+/** @deprecated Use `ObservabilityConfig` instead */
+type ObservabilityPluginConfig = ObservabilityConfig;
+/** @deprecated Use `new ObservabilityPlugin(config)` instead */
+declare function createObservabilityPlugin(config?: ObservabilityConfig): ObservabilityPlugin;
+
+interface SemanticScrapingPluginOptions {
+    /** Custom adapter — if not provided, an in-memory adapter is created. */
+    adapter?: ISemanticScrapingPort;
+}
+declare class SemanticScrapingPlugin extends BasePlugin {
+    readonly name = "semantic-scraping";
+    private readonly adapter;
+    constructor(options?: SemanticScrapingPluginOptions);
+    protected buildHooks(): PluginHooks;
+    get tools(): Record<string, Tool<any, any>>;
+}
+declare function createSemanticScrapingPlugin(options?: SemanticScrapingPluginOptions): SemanticScrapingPlugin;
+
+type ReRankingStrategy = NonNullable<ReRankingOptions["strategy"]>;
+interface SemanticWebSearchQuality {
+    traceId: string;
+    cacheServed: boolean;
+    durationMs: number;
+    strategyRequested: ReRankingStrategy;
+    strategyUsed: ReRankingStrategy;
+    fallbackUsed: boolean;
+    candidates: number;
+    reranked: number;
+    averageScore: number;
+    searchAttempts: number;
+    scrapeAttempts: number;
+    scrapeFailures: number;
+}
+interface SemanticWebSearchResponse {
+    query: string;
+    results: Array<{
+        rank: number;
+        score: number;
+        title: string;
+        url: string;
+        snippet: string;
+        citation: string;
+    }>;
+    citations: string[];
+    quality: SemanticWebSearchQuality;
+    cost?: {
+        model: string;
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+        totalCost: number;
+        currency: "USD";
+    };
+    cacheHit: boolean;
+}
+interface SemanticWebSearchPluginOptions {
+    apiKey?: string;
+    crawler?: {
+        search: (query: string, options?: {
+            limit?: number;
+        }) => Promise<unknown>;
+        crawl?: (url: string) => Promise<unknown>;
+        close?: () => Promise<void>;
+    };
+    reranker?: ReRankingPort;
+    telemetry?: TelemetryPort;
+    costTracker?: CostTrackerPort;
+    costModel?: string;
+    emitTelemetry?: boolean;
+    cache?: ToolCache;
+    circuitBreaker?: CircuitBreaker;
+    defaultLimit?: number;
+    defaultScrapeTopK?: number;
+    defaultStrategy?: ReRankingStrategy;
+    fallbackStrategy?: ReRankingStrategy;
+    fallbackOnRerankError?: boolean;
+    requestTimeoutMs?: number;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    cacheTtlMs?: number;
+}
+declare class SemanticWebSearchPlugin extends BasePlugin {
+    private readonly options;
+    readonly name = "Semantic Web Search";
+    readonly description = "Native search\u2192rerank\u2192citation pipeline for high-quality web evidence.";
+    private crawlerPromise;
+    private readonly reranker;
+    private readonly telemetry?;
+    private readonly costTracker?;
+    private readonly costModel;
+    private readonly emitTelemetry;
+    private readonly cache;
+    private readonly circuitBreaker;
+    private readonly defaultLimit;
+    private readonly defaultScrapeTopK;
+    private readonly defaultStrategy;
+    private readonly fallbackStrategy;
+    private readonly fallbackOnRerankError;
+    private readonly requestTimeoutMs;
+    private readonly maxRetries;
+    private readonly retryDelayMs;
+    private readonly cacheTtlMs;
+    constructor(options?: SemanticWebSearchPluginOptions);
+    protected buildHooks(): {};
+    get tools(): {
+        semantic_web_search: Tool<{
+            query: string;
+            limit?: number | undefined;
+            strategy?: "tfidf" | "bm25" | "mmr" | undefined;
+            scrapeTopK?: number | undefined;
+        }, SemanticWebSearchResponse>;
+    };
+    dispose(): Promise<void>;
+    private getCrawler;
+    private initCrawler;
+    private normalizeResults;
+    private normalizeEntry;
+    private enrichTopResults;
+    private normalizeCrawlContent;
+    private executeWithRetry;
+    private withTimeout;
+    private sleep;
+    private calculateAverageScore;
+    private buildCostRecord;
+    private estimateTokens;
+    private emitEvent;
+    private emitMetric;
+    private toTelemetryAttribute;
+}
+declare function createSemanticWebSearchPlugin(options?: SemanticWebSearchPluginOptions): SemanticWebSearchPlugin;
+
+interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    method: string;
+    params?: Record<string, unknown>;
+}
+interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+type McpToolExecutor = (name: string, args: Record<string, unknown>) => Promise<{
+    content: Array<{
+        type: string;
+        text?: string;
+    }>;
+    isError?: boolean;
+}>;
+declare class DefaultMcpServerAdapter implements McpServerPort {
+    private tools;
+    private toolsByName;
+    private executor;
+    private options?;
+    private stdinHandler?;
+    private stdinBuffer;
+    private httpServer?;
+    private sseClients;
+    constructor(tools: McpToolServerDefinition[], executor: McpToolExecutor);
+    private rebuildToolIndex;
+    getRegisteredTools(): McpToolServerDefinition[];
+    setTools(tools: McpToolServerDefinition[]): void;
+    start(options: McpServerOptions): Promise<void>;
+    stop(): Promise<void>;
+    handleRequest(request: JsonRpcRequest): Promise<JsonRpcResponse>;
+    private startStdio;
+    private processStdioLine;
+    private startSse;
+    private handleHttpRequest;
+    private static readonly MAX_BODY_SIZE;
+    private readBody;
+}
+
+interface McpServerPluginOptions {
+    /** Default server name (default: "gaussflow-mcp-server") */
+    name?: string;
+    /** Default server version (default: "1.0.0") */
+    version?: string;
+    /** Additional static tool definitions to expose */
+    extraTools?: McpToolServerDefinition[];
+    /** Custom tool executor; defaults to looking up tools from setupContext */
+    executor?: (name: string, args: Record<string, unknown>) => Promise<{
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        isError?: boolean;
+    }>;
+}
+declare class McpServerPlugin implements Plugin {
+    readonly name = "mcp-server";
+    readonly version = "1.0.0";
+    readonly tools: Record<string, Tool<any, any>>;
+    private adapter?;
+    private readonly pluginOptions;
+    private collectedTools;
+    constructor(options?: McpServerPluginOptions);
+    setup(ctx: PluginSetupContext): Promise<void>;
+    dispose(): Promise<void>;
+    /** Expose the underlying adapter for testing */
+    getAdapter(): DefaultMcpServerAdapter | undefined;
+    /** Expose collected tools for testing */
+    getCollectedTools(): McpToolServerDefinition[];
+    private defaultExecutor;
+}
+declare function createMcpServerPlugin(options?: McpServerPluginOptions): McpServerPlugin;
+
+export { SemanticWebSearchPlugin as $, type A2AAgentRuntime as A, BasePlugin as B, type ChunkingPort as C, DefaultMcpServerAdapter as D, type EvalMetrics as E, type EvalsPluginOptions as F, GuardrailsError as G, GuardrailsPlugin as H, type GuardrailsPluginOptions as I, McpServerPlugin as J, type McpServerPluginOptions as K, type McpServerPort as L, type McpServerOptions as M, type McpToolExecutor as N, type McpToolServerDefinition as O, PluginManager as P, type ObservabilityConfig as Q, type ReRankingPort as R, type ScoredResult as S, ObservabilityPlugin as T, type ObservabilityPluginConfig as U, type ValidationPort as V, OneCrawlPlugin as W, type OneCrawlPluginOptions as X, type PushNotificationConfig as Y, SemanticScrapingPlugin as Z, type SemanticScrapingPluginOptions as _, type ChunkOptions as a, type SemanticWebSearchPluginOptions as a0, type SourceAttribution as a1, type TaskEventListener as a2, VectorlessPlugin as a3, type VectorlessPluginOptions as a4, WorkflowError as a5, WorkflowPlugin as a6, type WorkflowPluginConfig as a7, type WorkflowPluginInput as a8, createA2AHttpHandler as a9, createA2AJsonRpcHandler as aa, createA2APlugin as ab, createA2ASseHandler as ac, createAgentCardPlugin as ad, createEvalsPlugin as ae, createGuardrailsPlugin as af, createMcpServerPlugin as ag, createObservabilityPlugin as ah, createOneCrawlPlugin as ai, createPiiFilter as aj, createSemanticScrapingPlugin as ak, createSemanticWebSearchPlugin as al, createVectorlessPlugin as am, createWorkflowPlugin as an, type Span as ao, type Chunk as b, type ReRankingOptions as c, type ValidationResult as d, type A2AJsonRpcRequest as e, type A2AJsonRpcResponse as f, A2APlugin as g, type A2APluginOptions as h, A2APushNotifier as i, type A2ARequestHandlers as j, type A2ATask as k, type A2ATaskEvent as l, type A2ATaskStatus as m, type A2ATasksSendParams as n, AgentCardPlugin as o, type AgentCardPluginOptions as p, type AgentCardProvider as q, type AgentCardSnapshot as r, type AgentCardSource as s, type AgentMetrics as t, type ContentFilter as u, EvalMetricsSchema as v, type EvalResult as w, EvalResultSchema as x, type EvalScorer as y, EvalsPlugin as z };