@easynet/agent-tool-hub 1.0.6

package/dist/toolhub-runtime-CQkP4QVW.d.ts

@@ -0,0 +1,1564 @@
+import { N8nLocal } from '@easynet/n8n-local';
+import { ErrorObject } from 'ajv';
+import { BulkheadPolicy, CircuitBreakerPolicy } from 'cockatiel';
+
+/**
+ * Budget constraints for a tool invocation.
+ */
+interface BudgetConfig {
+    timeoutMs?: number;
+    maxRetries?: number;
+    maxToolCalls?: number;
+}
+/**
+ * Execution context passed from agent-orchestra.
+ * Contains permissions, budget, and observability context.
+ */
+interface ExecContext {
+    requestId: string;
+    taskId: string;
+    /** Allowed capabilities for this invocation */
+    permissions: Capability[];
+    budget?: BudgetConfig;
+    /** OpenTelemetry-compatible trace ID */
+    traceId?: string;
+    userId?: string;
+    /** Optional: enable dry-run mode for two-phase commit */
+    dryRun?: boolean;
+}
+/**
+ * Tool invocation intent from agent-orchestra.
+ * Represents what the agent wants to do (untrusted input).
+ */
+interface ToolIntent {
+    /** ToolSpec.name reference */
+    tool: string;
+    /** Untrusted input arguments */
+    args: unknown;
+    /** Human-readable purpose for audit trail */
+    purpose: string;
+    /** Idempotency key: recommended format requestId:taskId:tool */
+    idempotencyKey?: string;
+}
+
+/**
+ * Unified tool kinds supported by the tools package.
+ */
+type ToolKind = "mcp" | "langchain" | "n8n" | "comfyui" | "skill" | "core";
+/**
+ * Capability declarations for tools.
+ * Used by PolicyEngine for permission gating.
+ */
+type Capability = "read:web" | "read:fs" | "write:fs" | "read:db" | "write:db" | "network" | "gpu" | "workflow" | "danger:destructive";
+/**
+ * Cost hints for tools, used by Budget and routing.
+ */
+interface CostHints {
+    latencyMsP50?: number;
+    latencyMsP95?: number;
+    isAsync?: boolean;
+}
+/**
+ * Unified tool specification.
+ * All tool types (MCP, LangChain, n8n, ComfyUI, SKILL) are described by this interface.
+ */
+interface ToolSpec {
+    /** Globally unique name, recommended format: namespace/name */
+    name: string;
+    /** Semver version */
+    version: string;
+    /** Tool kind determines which adapter handles execution */
+    kind: ToolKind;
+    description?: string;
+    tags?: string[];
+    /** JSON Schema for input validation */
+    inputSchema: object;
+    /** JSON Schema for output validation */
+    outputSchema: object;
+    /** Required capabilities for this tool */
+    capabilities: Capability[];
+    costHints?: CostHints;
+    /** Adapter-specific: endpoint URL (MCP/n8n/ComfyUI) */
+    endpoint?: string;
+    /** Adapter-specific: resource identifier (workflowId, promptId, etc.) */
+    resourceId?: string;
+    /** Adapter-specific: implementation reference (LangChain Tool instance, skill handler) */
+    impl?: unknown;
+}
+/**
+ * Unified adapter interface.
+ * Each protocol adapter (MCP, LangChain, n8n, ComfyUI, SKILL) implements this.
+ */
+interface ToolAdapter {
+    kind: ToolKind;
+    /** Optional: supports dynamic tool discovery */
+    listTools?(): Promise<ToolSpec[]>;
+    /** Execute the tool with validated args */
+    invoke(spec: ToolSpec, args: unknown, ctx: ExecContext): Promise<{
+        result: unknown;
+        raw?: unknown;
+    }>;
+}
+
+/**
+ * Evidence attached to a tool result for audit trail.
+ */
+interface Evidence {
+    type: "tool" | "file" | "url" | "text" | "metric";
+    ref: string;
+    summary: string;
+    createdAt: string;
+}
+/**
+ * Error information in a tool result.
+ */
+interface ToolError {
+    kind?: "TOOL_NOT_FOUND" | "INPUT_SCHEMA_INVALID" | "POLICY_DENIED" | "BUDGET_EXCEEDED" | "TIMEOUT" | "UPSTREAM_ERROR" | "OUTPUT_SCHEMA_INVALID" | "PATH_OUTSIDE_SANDBOX" | "FILE_TOO_LARGE" | "HTTP_DISALLOWED_HOST" | "HTTP_TIMEOUT" | "HTTP_TOO_LARGE";
+    message: string;
+    details?: unknown;
+}
+/**
+ * Unified tool result returned to agent-orchestra.
+ * Always structured, never throws raw exceptions.
+ */
+interface ToolResult {
+    ok: boolean;
+    result?: unknown;
+    evidence: Evidence[];
+    error?: ToolError;
+    /** Raw response for debugging (can be disabled in production) */
+    raw?: unknown;
+}
+
+/**
+ * Event types emitted by PTCRuntime and observability layer.
+ */
+type ToolEventType = "TOOL_CALLED" | "TOOL_RESULT" | "POLICY_DENIED" | "RETRY" | "TIMEOUT" | "BUDGET_EXCEEDED" | "JOB_SUBMITTED" | "JOB_COMPLETED" | "JOB_FAILED";
+/**
+ * Base event structure for all tool events.
+ */
+interface ToolEvent {
+    type: ToolEventType;
+    timestamp: string;
+    requestId: string;
+    taskId: string;
+    toolName: string;
+    traceId?: string;
+    userId?: string;
+}
+/**
+ * Emitted when a tool is called.
+ */
+interface ToolCalledEvent extends ToolEvent {
+    type: "TOOL_CALLED";
+    argsSummary: string;
+    purpose: string;
+    idempotencyKey?: string;
+}
+/**
+ * Emitted when a tool returns a result.
+ */
+interface ToolResultEvent extends ToolEvent {
+    type: "TOOL_RESULT";
+    ok: boolean;
+    durationMs: number;
+    resultSummary: string;
+    evidence: Evidence[];
+    error?: ToolError;
+}
+/**
+ * Emitted when policy denies a tool invocation.
+ */
+interface PolicyDeniedEvent extends ToolEvent {
+    type: "POLICY_DENIED";
+    reason: string;
+    missingCapabilities?: string[];
+}
+/**
+ * Emitted on retry.
+ */
+interface RetryEvent extends ToolEvent {
+    type: "RETRY";
+    attempt: number;
+    maxRetries: number;
+    reason: string;
+}
+/**
+ * Async job events.
+ */
+interface JobSubmittedEvent extends ToolEvent {
+    type: "JOB_SUBMITTED";
+    jobId: string;
+}
+interface JobCompletedEvent extends ToolEvent {
+    type: "JOB_COMPLETED";
+    jobId: string;
+    durationMs: number;
+}
+interface JobFailedEvent extends ToolEvent {
+    type: "JOB_FAILED";
+    jobId: string;
+    error: string;
+}
+/**
+ * Union type of all tool events.
+ */
+type AnyToolEvent = ToolCalledEvent | ToolResultEvent | PolicyDeniedEvent | RetryEvent | JobSubmittedEvent | JobCompletedEvent | JobFailedEvent;
+
+/**
+ * Search query for tools.
+ */
+interface ToolSearchQuery {
+    /** Text search in name/description/tags */
+    text?: string;
+    /** Filter by tool kind */
+    kind?: ToolKind;
+    /** Filter by required capabilities */
+    capabilities?: Capability[];
+    /** Filter by tags */
+    tags?: string[];
+}
+/**
+ * Tool Registry: manages tool registration, lookup, and search.
+ * Supports both static registration and dynamic discovery via adapters.
+ */
+declare class ToolRegistry {
+    private readonly tools;
+    private readonly tagIndex;
+    private readonly kindIndex;
+    /**
+     * Register a single tool spec.
+     * Overwrites if same name already exists.
+     */
+    register(spec: ToolSpec): void;
+    /**
+     * Register multiple tool specs at once.
+     */
+    bulkRegister(specs: ToolSpec[]): void;
+    /**
+     * Unregister a tool by name.
+     */
+    unregister(name: string): boolean;
+    /**
+     * Get a tool spec by name.
+     */
+    get(name: string): ToolSpec | undefined;
+    /**
+     * Check if a tool exists.
+     */
+    has(name: string): boolean;
+    /**
+     * Search tools by query.
+     */
+    search(query: ToolSearchQuery): ToolSpec[];
+    /**
+     * List all registered tool names.
+     */
+    list(): string[];
+    /**
+     * Get count of registered tools.
+     */
+    get size(): number;
+    /**
+     * Export a snapshot of all registered tools (for debugging/routing).
+     */
+    snapshot(): ToolSpec[];
+    /**
+     * Clear all registered tools.
+     */
+    clear(): void;
+    private validateSpec;
+    private indexTool;
+    private deindexTool;
+}
+
+/**
+ * Schema validation result.
+ */
+interface ValidationResult {
+    valid: boolean;
+    errors?: ErrorObject[];
+    data?: unknown;
+}
+/**
+ * AJV-based JSON Schema validator with coercion and default enrichment.
+ */
+declare class SchemaValidator {
+    private readonly ajv;
+    private readonly cache;
+    constructor();
+    /**
+     * Validate data against a JSON Schema.
+     * Coerces types and applies defaults in-place.
+     */
+    validate(schema: object, data: unknown): ValidationResult;
+    /**
+     * Validate and return coerced data, or throw a descriptive error.
+     */
+    validateOrThrow(schema: object, data: unknown, context: string): unknown;
+    /**
+     * Apply default values from schema to data without full validation.
+     */
+    enrichDefaults(schema: object, data: unknown): unknown;
+    private getOrCompile;
+}
+/**
+ * Error thrown on schema validation failure.
+ */
+declare class SchemaValidationError extends Error {
+    readonly errors: ErrorObject[];
+    constructor(message: string, errors: ErrorObject[]);
+}
+
+/**
+ * Policy configuration for the engine.
+ */
+interface PolicyConfig {
+    /** File system sandbox paths (allowed write directories) */
+    sandboxPaths?: string[];
+    /** Allowed URL patterns (regex strings) */
+    urlAllowlist?: string[];
+    /** Denied URL patterns (regex strings) */
+    urlDenylist?: string[];
+    /** SQL patterns that are denied (e.g., DROP, TRUNCATE) */
+    deniedSqlPatterns?: string[];
+    /** Network allowed domains */
+    allowedDomains?: string[];
+    /** Whether to require explicit permission for danger:destructive */
+    requireExplicitDangerPermission?: boolean;
+}
+/**
+ * Result of a policy check.
+ */
+interface PolicyCheckResult {
+    allowed: boolean;
+    reason?: string;
+    missingCapabilities?: Capability[];
+}
+/**
+ * Policy engine for capability gating, parameter security, and access control.
+ */
+declare class PolicyEngine {
+    private readonly config;
+    constructor(config?: PolicyConfig);
+    /**
+     * Enforce all policy checks. Throws PolicyDeniedError if denied.
+     */
+    enforce(spec: ToolSpec, args: unknown, ctx: ExecContext): void;
+    /**
+     * Check all policies without throwing.
+     */
+    check(spec: ToolSpec, args: unknown, ctx: ExecContext): PolicyCheckResult;
+    /**
+     * Check that context permissions cover tool capabilities.
+     */
+    private checkCapabilities;
+    /**
+     * Check parameter-level security constraints.
+     */
+    private checkParameters;
+    private checkFilePaths;
+    private checkUrls;
+    private checkSql;
+    private checkDomains;
+    /**
+     * Extract string values from args matching given key patterns.
+     */
+    private extractStringValues;
+}
+/**
+ * Error thrown when policy denies execution.
+ */
+declare class PolicyDeniedError extends Error {
+    readonly missingCapabilities?: Capability[] | undefined;
+    readonly kind = "POLICY_DENIED";
+    constructor(message: string, missingCapabilities?: Capability[] | undefined);
+}
+
+/**
+ * Budget configuration for a tool or global scope.
+ */
+interface BudgetOptions {
+    /** Default timeout in ms for tool invocations */
+    defaultTimeoutMs?: number;
+    /** Max concurrent invocations per tool */
+    maxConcurrency?: number;
+    /** Rate limit: max calls per window */
+    rateLimit?: {
+        maxCalls: number;
+        windowMs: number;
+    };
+    /** Circuit breaker config */
+    circuitBreaker?: {
+        /** Number of consecutive failures before opening */
+        threshold: number;
+        /** Half-open reset time in ms */
+        halfOpenAfterMs: number;
+    };
+}
+/**
+ * Budget manager that provides timeout, rate limiting, concurrency control,
+ * and circuit breaker per tool.
+ */
+declare class BudgetManager {
+    private readonly defaultTimeoutMs;
+    private readonly bulkheads;
+    private readonly circuitBreakers;
+    private readonly rateLimiters;
+    private readonly options;
+    constructor(options?: BudgetOptions);
+    /**
+     * Get effective timeout for a tool invocation.
+     */
+    getTimeout(_toolName: string, contextTimeoutMs?: number): number;
+    /**
+     * Check rate limit for a tool. Returns true if allowed.
+     */
+    checkRateLimit(toolName: string): boolean;
+    /**
+     * Get or create a bulkhead (concurrency limiter) for a tool.
+     */
+    getBulkhead(toolName: string): BulkheadPolicy | undefined;
+    /**
+     * Get or create a circuit breaker for a tool.
+     */
+    getCircuitBreaker(toolName: string): CircuitBreakerPolicy | undefined;
+    /**
+     * Execute a function within budget constraints (bulkhead + circuit breaker).
+     */
+    execute<T>(toolName: string, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Reset all policies for a tool (useful for testing).
+     */
+    reset(toolName: string): void;
+    /**
+     * Reset all policies globally.
+     */
+    resetAll(): void;
+}
+
+/**
+ * Event log entry with sequence number.
+ */
+interface LogEntry {
+    seq: number;
+    event: AnyToolEvent;
+}
+/**
+ * Event log listener type.
+ */
+type EventListener = (entry: LogEntry) => void;
+/**
+ * Append-only event log for tool invocations.
+ * Supports in-memory storage with configurable max size and event subscriptions.
+ */
+declare class EventLog {
+    private readonly entries;
+    private seq;
+    private readonly maxEntries;
+    private readonly emitter;
+    constructor(options?: {
+        maxEntries?: number;
+    });
+    /**
+     * Append an event to the log.
+     */
+    append(event: AnyToolEvent): LogEntry;
+    /**
+     * Subscribe to all events.
+     */
+    on(listener: EventListener): () => void;
+    /**
+     * Subscribe to events of a specific type.
+     */
+    onType(type: ToolEventType, listener: EventListener): () => void;
+    /**
+     * Query events by filter.
+     */
+    query(filter: {
+        type?: ToolEventType;
+        toolName?: string;
+        requestId?: string;
+        since?: number;
+        limit?: number;
+    }): LogEntry[];
+    /**
+     * Get all entries.
+     */
+    getAll(): readonly LogEntry[];
+    /**
+     * Get entry count.
+     */
+    get size(): number;
+    /**
+     * Clear all entries (for testing).
+     */
+    clear(): void;
+}
+
+type LogLevel = "silent" | "error" | "warn" | "info" | "debug" | "trace";
+interface DebugOptions {
+    enabled?: boolean;
+    level?: LogLevel;
+    includeArgs?: boolean;
+    includeResults?: boolean;
+    includeRaw?: boolean;
+    logEvents?: boolean;
+    prefix?: string;
+}
+interface ResolvedDebugOptions {
+    enabled: boolean;
+    level: LogLevel;
+    includeArgs: boolean;
+    includeResults: boolean;
+    includeRaw: boolean;
+    logEvents: boolean;
+    prefix: string;
+}
+interface Logger {
+    options: ResolvedDebugOptions;
+    isEnabled(level: LogLevel): boolean;
+    error(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+    info(message: string, meta?: Record<string, unknown>): void;
+    debug(message: string, meta?: Record<string, unknown>): void;
+    trace(message: string, meta?: Record<string, unknown>): void;
+}
+declare function createLogger(options?: DebugOptions): Logger;
+declare function sanitizeForLog(value: unknown, maxLen?: number): string;
+declare function summarizeForLog(value: unknown, maxLen?: number): string;
+
+/**
+ * Simple counter metric.
+ */
+interface CounterValue {
+    name: string;
+    labels: Record<string, string>;
+    value: number;
+}
+/**
+ * Histogram bucket.
+ */
+interface HistogramValue {
+    name: string;
+    labels: Record<string, string>;
+    count: number;
+    sum: number;
+    buckets: Map<number, number>;
+}
+/**
+ * Lightweight metrics collector for tool invocations.
+ * Provides counters and histograms with label support.
+ */
+declare class Metrics {
+    private readonly counters;
+    private readonly histograms;
+    private readonly defaultBuckets;
+    /**
+     * Increment a counter.
+     */
+    increment(name: string, labels?: Record<string, string>, value?: number): void;
+    /**
+     * Record a value in a histogram.
+     */
+    observe(name: string, labels: Record<string, string>, value: number): void;
+    /**
+     * Get a counter value.
+     */
+    getCounter(name: string, labels?: Record<string, string>): number;
+    /**
+     * Get histogram stats.
+     */
+    getHistogram(name: string, labels: Record<string, string>): HistogramValue | undefined;
+    /**
+     * Get all counter values.
+     */
+    getAllCounters(): CounterValue[];
+    /**
+     * Get all histogram values.
+     */
+    getAllHistograms(): HistogramValue[];
+    /**
+     * Record standard tool invocation metrics.
+     */
+    recordInvocation(toolName: string, ok: boolean, durationMs: number): void;
+    /**
+     * Record a retry event.
+     */
+    recordRetry(toolName: string): void;
+    /**
+     * Record a policy denial.
+     */
+    recordPolicyDenied(toolName: string, reason: string): void;
+    /**
+     * Reset all metrics (for testing).
+     */
+    reset(): void;
+    private makeKey;
+    private parseKey;
+}
+
+/**
+ * A trace span representing a unit of work.
+ */
+interface Span {
+    spanId: string;
+    traceId: string;
+    parentSpanId?: string;
+    name: string;
+    startTime: number;
+    endTime?: number;
+    durationMs?: number;
+    status: "ok" | "error" | "in_progress";
+    attributes: Record<string, string | number | boolean>;
+    events: SpanEvent[];
+}
+/**
+ * An event within a span.
+ */
+interface SpanEvent {
+    name: string;
+    timestamp: number;
+    attributes?: Record<string, string | number | boolean>;
+}
+/**
+ * Lightweight tracing system for tool invocation spans.
+ * Compatible with OpenTelemetry trace/span ID format.
+ */
+declare class Tracing {
+    private readonly spans;
+    private readonly traceSpans;
+    /**
+     * Start a new span.
+     */
+    startSpan(options: {
+        name: string;
+        traceId?: string;
+        parentSpanId?: string;
+        attributes?: Record<string, string | number | boolean>;
+    }): Span;
+    /**
+     * End a span and calculate duration.
+     */
+    endSpan(spanId: string, status?: "ok" | "error"): Span | undefined;
+    /**
+     * Add an event to a span.
+     */
+    addEvent(spanId: string, name: string, attributes?: Record<string, string | number | boolean>): void;
+    /**
+     * Set attributes on a span.
+     */
+    setAttributes(spanId: string, attributes: Record<string, string | number | boolean>): void;
+    /**
+     * Get a span by ID.
+     */
+    getSpan(spanId: string): Span | undefined;
+    /**
+     * Get all spans for a trace.
+     */
+    getTrace(traceId: string): Span[];
+    /**
+     * Create a child span from a parent.
+     */
+    createChildSpan(parentSpanId: string, name: string, attributes?: Record<string, string | number | boolean>): Span | undefined;
+    /**
+     * Clear all traces (for testing).
+     */
+    clear(): void;
+}
+
+/**
+ * PTC Runtime configuration.
+ */
+interface PTCRuntimeConfig {
+    policy?: PolicyConfig;
+    budget?: BudgetOptions;
+    /** Include raw response in ToolResult (default: true, disable in production) */
+    includeRaw?: boolean;
+    /** Maximum retries if not specified in context (default: 2) */
+    defaultMaxRetries?: number;
+    /** Debug/logging configuration */
+    debug?: DebugOptions;
+}
+/**
+ * PTC Runtime: the unified execution kernel for all tool invocations.
+ *
+ * Enforces the mandatory 9-step pipeline:
+ * 1. Resolve (Registry lookup)
+ * 2. Input Validate (AJV)
+ * 3. Defaults Enrich
+ * 4. Policy Gate
+ * 5. Budget check
+ * 6. Execute (adapter.invoke())
+ * 7. Output Validate (AJV)
+ * 8. Evidence Build
+ * 9. Audit & Metrics
+ *
+ * Never throws to callers - always returns ToolResult.
+ */
+declare class PTCRuntime {
+    private readonly registry;
+    private readonly adapters;
+    private readonly validator;
+    private readonly policy;
+    private readonly budget;
+    private readonly eventLog;
+    private readonly metrics;
+    private readonly tracing;
+    private readonly config;
+    private readonly logger;
+    constructor(options?: {
+        registry?: ToolRegistry;
+        validator?: SchemaValidator;
+        policy?: PolicyEngine;
+        budget?: BudgetManager;
+        eventLog?: EventLog;
+        metrics?: Metrics;
+        tracing?: Tracing;
+        config?: PTCRuntimeConfig;
+    });
+    /**
+     * Register an adapter for a tool kind.
+     */
+    registerAdapter(adapter: ToolAdapter): void;
+    /**
+     * Get the tool registry.
+     */
+    getRegistry(): ToolRegistry;
+    /**
+     * Get the event log.
+     */
+    getEventLog(): EventLog;
+    /**
+     * Get the metrics collector.
+     */
+    getMetrics(): Metrics;
+    /**
+     * Get the tracing system.
+     */
+    getTracing(): Tracing;
+    /**
+     * Invoke a tool through the PTC pipeline.
+     * Never throws - always returns a structured ToolResult.
+     */
+    invoke(intent: ToolIntent, ctx: ExecContext): Promise<ToolResult>;
+    /**
+     * Search for tools in the registry.
+     */
+    searchTools(query: string, filters?: {
+        kind?: string;
+        capabilities?: string[];
+        tags?: string[];
+    }): ToolSpec[];
+    /**
+     * Get the schema for a tool.
+     */
+    getToolSchema(toolName: string): {
+        input: object;
+        output: object;
+    } | undefined;
+    private getPipelineDeps;
+    private getObservabilityDeps;
+    private buildDryRunResult;
+}
+
+/**
+ * Interface for LangChain-compatible tool instances.
+ * Matches @langchain/core BaseTool.invoke() signature.
+ */
+interface LangChainToolLike {
+    invoke(input: unknown, config?: unknown): Promise<unknown>;
+    name?: string;
+    description?: string;
+    schema?: object;
+}
+/**
+ * Options for creating a LangChainAdapter.
+ */
+interface LangChainAdapterOptions {
+    /** Map of tool names to their implementations */
+    tools?: Map<string, LangChainToolLike>;
+    /** Debug/logging configuration */
+    debug?: DebugOptions;
+}
+/**
+ * Adapter for LangChain-compatible tools.
+ * Wraps local tool instances with the unified ToolAdapter interface.
+ */
+declare class LangChainAdapter implements ToolAdapter {
+    readonly kind: "langchain";
+    private readonly tools;
+    private readonly logger;
+    constructor(options?: LangChainAdapterOptions);
+    /**
+     * Register a LangChain tool instance.
+     */
+    registerTool(name: string, tool: LangChainToolLike): void;
+    /**
+     * Unregister a tool.
+     */
+    unregisterTool(name: string): boolean;
+    /**
+     * List available tools (from registered instances).
+     */
+    listTools(): Promise<ToolSpec[]>;
+    /**
+     * Invoke a LangChain tool.
+     */
+    invoke(spec: ToolSpec, args: unknown, ctx: ExecContext): Promise<{
+        result: unknown;
+        raw?: unknown;
+    }>;
+    private resolveTool;
+    private normalizeResult;
+}
+
+/**
+ * MCP tool definition as returned by MCP server.
+ */
+interface MCPToolDefinition {
+    name: string;
+    description?: string;
+    inputSchema?: object;
+}
+/**
+ * MCP call result from MCP server.
+ */
+interface MCPCallResult {
+    content: Array<{
+        type: string;
+        text?: string;
+        data?: unknown;
+    }>;
+    isError?: boolean;
+}
+/**
+ * Injectable MCP client interface.
+ * Matches the core methods of @modelcontextprotocol/sdk Client.
+ */
+interface MCPClientLike {
+    listTools(): Promise<{
+        tools: MCPToolDefinition[];
+    }>;
+    callTool(params: {
+        name: string;
+        arguments?: Record<string, unknown>;
+    }): Promise<MCPCallResult>;
+}
+/**
+ * Options for creating an MCPAdapter.
+ */
+interface MCPAdapterOptions {
+    /** Injectable MCP client instance */
+    client?: MCPClientLike;
+    /** Endpoint URL for the MCP server (used in ToolSpec) */
+    endpoint?: string;
+    /** Tool name prefix for namespacing */
+    prefix?: string;
+    /** Auth token for MCP server */
+    authToken?: string;
+    /** Debug/logging configuration */
+    debug?: DebugOptions;
+}
+/**
+ * Adapter for MCP (Model Context Protocol) servers.
+ * Supports tool discovery and invocation via injectable MCP client.
+ */
+declare class MCPAdapter implements ToolAdapter {
+    readonly kind: "mcp";
+    private client;
+    private readonly endpoint;
+    private readonly prefix;
+    private readonly _authToken?;
+    private cachedTools;
+    private cacheExpiry;
+    private readonly cacheTtlMs;
+    private readonly logger;
+    constructor(options?: MCPAdapterOptions);
+    /**
+     * Set or replace the MCP client.
+     */
+    setClient(client: MCPClientLike): void;
+    /**
+     * Discover tools from the MCP server.
+     */
+    listTools(): Promise<ToolSpec[]>;
+    /**
+     * Invoke an MCP tool.
+     */
+    invoke(spec: ToolSpec, args: unknown, _ctx: ExecContext): Promise<{
+        result: unknown;
+        raw?: unknown;
+    }>;
+    /**
+     * Invalidate the tool cache.
+     */
+    invalidateCache(): void;
+    private mapToToolSpec;
+    private extractMCPName;
+    private parseResult;
+}
+
+/**
+ * HTTP client interface for n8n API/webhook calls.
+ */
+interface HttpClient {
+    fetch(url: string, options: {
+        method: string;
+        headers?: Record<string, string>;
+        body?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        status: number;
+        json(): Promise<unknown>;
+        text(): Promise<string>;
+    }>;
+}
+/**
+ * n8n invocation mode.
+ */
+type N8nInvokeMode = "webhook" | "api";
+/**
+ * n8n adapter configuration.
+ */
+interface N8nAdapterOptions {
+    /** Injectable HTTP client */
+    httpClient?: HttpClient;
+    /** n8n API base URL (for API mode) */
+    apiBaseUrl?: string;
+    /** n8n API key */
+    apiKey?: string;
+    /** Default invocation mode */
+    defaultMode?: N8nInvokeMode;
+    /** Threshold in ms: if workflow takes longer, treat as async */
+    asyncThresholdMs?: number;
+    /** Debug/logging configuration */
+    debug?: DebugOptions;
+}
+/**
+ * Adapter for n8n workflows.
+ * Supports webhook trigger and API invocation modes.
+ * Handles idempotency keys and sync/async detection.
+ */
+declare class N8nAdapter implements ToolAdapter {
+    readonly kind: "n8n";
+    private readonly httpClient;
+    private readonly apiBaseUrl;
+    private readonly apiKey?;
+    private readonly defaultMode;
+    private readonly _asyncThresholdMs;
+    private readonly idempotencyStore;
+    private readonly logger;
+    constructor(options?: N8nAdapterOptions);
+    /**
+     * Invoke an n8n workflow.
+     */
+    invoke(spec: ToolSpec, args: unknown, ctx: ExecContext): Promise<{
+        result: unknown;
+        raw?: unknown;
+    }>;
+    private invokeWebhook;
+    private invokeApi;
+    private getInvokeMode;
+    private buildIdempotencyKey;
+    private normalizeResult;
+}
+
+interface N8nLocalAdapterOptions {
+    /** Reuse an existing N8nLocal instance */
+    instance?: N8nLocal;
+    /** Auto-start n8n-local on first invoke (default: true) */
+    autoStart?: boolean;
+    /** Whether to start the internal HTTP server (default: false) */
+    startHttpServer?: boolean;
+    /** SQLite database file path (default: "database.sqlite") */
+    sqliteDatabase?: string;
+    /** Optional data folder for workflow sync */
+    dataFolder?: string;
+    /** Debug/logging configuration */
+    debug?: DebugOptions;
+}
+/**
+ * Adapter for n8n-local (embedded) workflow execution.
+ * Uses in-process instance, no HTTP API calls.
+ */
+declare class N8nLocalAdapter implements ToolAdapter {
+    readonly kind: "n8n";
+    private readonly instance;
+    private readonly autoStart;
+    private startPromise?;
+    private readonly workflowMap;
+    private readonly logger;
+    constructor(options?: N8nLocalAdapterOptions);
+    listTools(): Promise<ToolSpec[]>;
+    invoke(spec: ToolSpec, args: unknown, _ctx: ExecContext): Promise<{
+        result: unknown;
+        raw?: unknown;
+    }>;
+    stop(): Promise<void>;
+    start(): Promise<void>;
+    syncWorkflows(specs: ToolSpec[]): Promise<void>;
+    private ensureStarted;
+    private ensureWorkflowImported;
+    private getWorkflowDefinition;
+    private normalizeWorkflow;
+}
+
+/**
+ * ComfyUI queue prompt response.
+ */
+interface ComfyUIQueueResponse {
+    prompt_id: string;
+    number: number;
+    node_errors?: Record<string, unknown>;
+}
+/**
+ * ComfyUI history entry.
+ */
+interface ComfyUIHistoryEntry {
+    status: {
+        status_str: string;
+        completed: boolean;
+    };
+    outputs: Record<string, {
+        images?: Array<{
+            filename: string;
+            subfolder: string;
+            type: string;
+        }>;
+    }>;
+}
+/**
+ * Injectable HTTP client for ComfyUI API.
+ */
+interface ComfyUIHttpClient {
+    fetch(url: string, options: {
+        method: string;
+        headers?: Record<string, string>;
+        body?: string;
+    }): Promise<{
+        status: number;
+        json(): Promise<unknown>;
+        text(): Promise<string>;
+    }>;
+}
+/**
+ * ComfyUI adapter options.
+ */
+interface ComfyUIAdapterOptions {
+    /** Injectable HTTP client */
+    httpClient?: ComfyUIHttpClient;
+    /** ComfyUI server base URL */
+    baseUrl?: string;
+    /** Polling interval in ms for async jobs */
+    pollIntervalMs?: number;
+    /** Max poll attempts before timeout */
+    maxPollAttempts?: number;
+    /** Client ID for ComfyUI WebSocket */
+    clientId?: string;
+    /** Debug/logging configuration */
+    debug?: DebugOptions;
+}
+/**
+ * Adapter for ComfyUI image generation workflows.
+ * Submits prompts to the queue, polls for completion, and retrieves artifacts.
+ */
+declare class ComfyUIAdapter implements ToolAdapter {
+    readonly kind: "comfyui";
+    private readonly httpClient;
+    private readonly baseUrl;
+    private readonly pollIntervalMs;
+    private readonly maxPollAttempts;
+    private readonly clientId;
+    private readonly logger;
+    constructor(options?: ComfyUIAdapterOptions);
+    /**
+     * Invoke a ComfyUI workflow.
+     * Queues the prompt and polls for completion.
+     */
+    invoke(spec: ToolSpec, args: unknown, _ctx: ExecContext): Promise<{
+        result: unknown;
+        raw?: unknown;
+    }>;
+    /**
+     * Get the status of a queued prompt.
+     */
+    getStatus(promptId: string): Promise<{
+        completed: boolean;
+        status: string;
+    }>;
+    /**
+     * Get the result of a completed prompt.
+     */
+    getResult(promptId: string): Promise<unknown>;
+    private buildPrompt;
+    private mergeWorkflowArgs;
+    private deepMerge;
+    private queuePrompt;
+    private getHistory;
+    private pollForCompletion;
+    private extractResult;
+    private sleep;
+}
+
+/**
+ * Parsed SKILL.md manifest following Anthropic's Agent Skills specification.
+ *
+ * A SKILL.md file has:
+ * - YAML frontmatter with `name` and `description` (Level 1: metadata, always loaded)
+ * - Markdown body with instructions (Level 2: loaded when triggered)
+ * - Bundled resource files referenced from the body (Level 3: loaded as needed)
+ *
+ * @see https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview
+ */
+/**
+ * YAML frontmatter from SKILL.md.
+ * This is Level 1 (metadata) — always loaded at startup for discovery.
+ */
+interface SkillFrontmatter {
+    /**
+     * Skill name identifier.
+     * - Max 64 characters
+     * - Lowercase letters, numbers, and hyphens only
+     */
+    name: string;
+    /**
+     * What the skill does and when to use it.
+     * - Max 1024 characters
+     * - Should include triggers/contexts for activation
+     * - Written in third person
+     */
+    description: string;
+}
+/**
+ * A resource file bundled with the skill.
+ * Resources are Level 3 — loaded only as needed during execution.
+ */
+interface SkillResource {
+    /** Relative path from the skill directory */
+    relativePath: string;
+    /** Absolute path on disk */
+    absolutePath: string;
+    /** File extension (e.g., ".md", ".py", ".json") */
+    extension: string;
+    /** Resource type inferred from extension */
+    type: "instructions" | "code" | "data";
+}
+/**
+ * Full parsed SKILL.md with progressive disclosure levels.
+ */
+interface SkillDefinition {
+    /** Level 1: Metadata from YAML frontmatter (always loaded, ~100 tokens) */
+    frontmatter: SkillFrontmatter;
+    /** Level 2: Markdown body instructions (loaded when skill triggered, <5k tokens recommended) */
+    instructions: string;
+    /** Level 3: Bundled resource files (loaded as needed, effectively unlimited) */
+    resources: SkillResource[];
+    /** Absolute path to the skill directory */
+    dirPath: string;
+    /** Absolute path to the SKILL.md file */
+    skillMdPath: string;
+}
+/**
+ * Validation error for SKILL.md parsing.
+ */
+declare class SkillManifestError extends Error {
+    readonly path: string;
+    readonly field: string;
+    constructor(path: string, field: string, message: string);
+}
+/**
+ * Validate a SkillFrontmatter object.
+ * Throws SkillManifestError if invalid.
+ */
+declare function validateFrontmatter(fm: Partial<SkillFrontmatter>, filePath: string): asserts fm is SkillFrontmatter;
+
+/**
+ * Skill handler function signature.
+ * A skill handler provides programmatic execution when bundled scripts need
+ * to run as part of skill invocation.
+ */
+type SkillHandler = (args: unknown, ctx: SkillContext) => Promise<SkillOutput>;
+/**
+ * Context passed to skill handlers.
+ * Provides access to the skill's progressive disclosure levels and sub-tool invocation.
+ */
+interface SkillContext {
+    requestId: string;
+    taskId: string;
+    traceId?: string;
+    userId?: string;
+    /** The skill definition with all three disclosure levels */
+    skill: SkillInvocationContext;
+    /** Invoke a sub-tool (if needed by the skill) */
+    invokeTool?: (toolName: string, args: unknown) => Promise<unknown>;
+}
+/**
+ * Skill invocation context providing progressive disclosure access.
+ * Mirrors the three-level loading model from the Anthropic spec.
+ */
+interface SkillInvocationContext {
+    /** Level 1: Metadata (name + description) — always available */
+    name: string;
+    description: string;
+    /** Level 2: Instructions from SKILL.md body — loaded when triggered */
+    instructions: string;
+    /** Level 3: Resource access — loaded as needed */
+    resources: SkillResource[];
+    /** Read a resource file by relative path */
+    readResource: (relativePath: string) => Promise<string>;
+    /** Get resources filtered by type */
+    getResourcesByType: (type: "instructions" | "code" | "data") => SkillResource[];
+    /** Absolute path to the skill directory (for script execution) */
+    dirPath: string;
+}
+/**
+ * Structured output from a skill handler.
+ */
+interface SkillOutput {
+    result: unknown;
+    evidence?: Evidence[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Result returned when a skill is invoked in instruction-only mode
+ * (no handler function, just SKILL.md content for an agent to consume).
+ */
+interface SkillInstructionResult {
+    /** The skill name */
+    name: string;
+    /** The skill description */
+    description: string;
+    /** The full instructions from SKILL.md body */
+    instructions: string;
+    /** List of available resources with paths and types */
+    resources: Array<{
+        path: string;
+        type: "instructions" | "code" | "data";
+    }>;
+    /** The skill directory path for resource access */
+    dirPath: string;
+}
+/**
+ * Options for creating a SkillAdapter.
+ */
+interface SkillAdapterOptions {
+    /** Map of skill names to their SkillDefinitions (from SKILL.md) */
+    definitions?: Map<string, SkillDefinition>;
+    /** Map of skill names to their handler functions (optional per skill) */
+    handlers?: Map<string, SkillHandler>;
+    /** Optional sub-tool invoker for skills that need to call other tools */
+    toolInvoker?: (toolName: string, args: unknown, ctx: ExecContext) => Promise<unknown>;
+    /** Debug/logging configuration */
+    debug?: DebugOptions;
+}
+/**
+ * Adapter for SKILL type tools following Anthropic's Agent Skills specification.
+ *
+ * Implements the three-level progressive disclosure model:
+ * - Level 1 (metadata): name + description, used for discovery (~100 tokens)
+ * - Level 2 (instructions): SKILL.md body, loaded when skill is triggered (<5k tokens)
+ * - Level 3 (resources): bundled files, loaded as needed (unlimited)
+ *
+ * Skills can operate in two modes:
+ * 1. **Instruction-only**: Returns SKILL.md content for an agent/model to consume
+ * 2. **Handler mode**: Executes a bundled handler function with full context
+ *
+ * This implementation is model-agnostic — any model can consume the skill instructions.
+ *
+ * @see https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview
+ */
+declare class SkillAdapter implements ToolAdapter {
+    readonly kind: "skill";
+    private readonly definitions;
+    private readonly handlers;
+    private readonly toolInvoker?;
+    private readonly logger;
+    constructor(options?: SkillAdapterOptions);
+    /**
+     * Register a skill definition (from SKILL.md parsing).
+     */
+    registerSkill(name: string, definition: SkillDefinition, handler?: SkillHandler): void;
+    /**
+     * Unregister a skill.
+     */
+    unregisterSkill(name: string): boolean;
+    /**
+     * List registered skills with Level 1 metadata.
+     * Returns ToolSpecs with name and description from YAML frontmatter.
+     */
+    listTools(): Promise<ToolSpec[]>;
+    /**
+     * Get Level 1 metadata for all registered skills.
+     * This is what gets loaded at startup (~100 tokens per skill).
+     */
+    getMetadata(): Array<{
+        name: string;
+        description: string;
+    }>;
+    /**
+     * Get Level 2 instructions for a specific skill.
+     * This is loaded when the skill is triggered.
+     */
+    getInstructions(name: string): string | undefined;
+    /**
+     * Get Level 3 resources for a specific skill.
+     */
+    getResources(name: string): SkillResource[];
+    /**
+     * Read a specific resource file from a skill.
+     */
+    readResource(skillName: string, relativePath: string): Promise<string>;
+    /**
+     * Invoke a skill.
+     *
+     * If the skill has a handler function, executes it with full context.
+     * Otherwise, returns the skill's instruction content (Level 2 + Level 3 manifest)
+     * for an agent/model to consume and act upon.
+     */
+    invoke(spec: ToolSpec, args: unknown, ctx: ExecContext): Promise<{
+        result: unknown;
+        raw?: unknown;
+    }>;
+    private invokeWithHandler;
+    private invokeInstructionOnly;
+    private buildInvocationContext;
+    private resolveDefinition;
+    private resolveHandler;
+}
+
+/**
+ * Configuration for core tools runtime.
+ */
+interface CoreToolsConfig {
+    /** Absolute path. All FS operations are confined within this root. */
+    sandboxRoot: string;
+    /** Only these hosts may be fetched. Supports wildcard prefix (e.g. "*.github.com"). */
+    allowedHosts: string[];
+    /** Maximum bytes for fs.readText (default: 5MB) */
+    maxReadBytes: number;
+    /** Maximum bytes for HTTP response body (default: 5MB) */
+    maxHttpBytes: number;
+    /** Maximum bytes for http.downloadFile (default: 100MB) */
+    maxDownloadBytes: number;
+    /** CIDR ranges to block. Defaults include RFC1918 + loopback + link-local. */
+    blockedCidrs: string[];
+    /** Default HTTP timeout in ms (default: 15000) */
+    defaultTimeoutMs: number;
+    /** User-Agent header for HTTP requests */
+    httpUserAgent: string;
+    /** If true, large HTTP responses are auto-written to sandbox and a file ref is returned */
+    enableAutoWriteLargeResponses: boolean;
+}
+/**
+ * Default configuration values for core tools.
+ */
+declare const DEFAULT_CORE_TOOLS_CONFIG: Omit<CoreToolsConfig, "sandboxRoot" | "allowedHosts">;
+/**
+ * Context passed to each core tool handler.
+ */
+interface CoreToolContext {
+    execCtx: ExecContext;
+    config: CoreToolsConfig;
+}
+/**
+ * Structured result from a core tool handler.
+ */
+interface CoreToolResult {
+    result: unknown;
+    evidence: Evidence[];
+}
+/**
+ * A core tool handler function.
+ */
+type CoreToolHandler = (args: Record<string, unknown>, ctx: CoreToolContext) => Promise<CoreToolResult>;
+
+/**
+ * Adapter for core tools (kind="core").
+ * Dispatches to registered handler functions by tool name.
+ *
+ * Core tools are local, atomic operations (filesystem, HTTP, utilities)
+ * that enforce their own security constraints (sandbox, SSRF) in addition
+ * to the PolicyEngine capability gating.
+ */
+declare class CoreAdapter implements ToolAdapter {
+    readonly kind: "core";
+    private readonly handlers;
+    private readonly config;
+    constructor(config: CoreToolsConfig);
+    /**
+     * Register a handler for a specific core tool name.
+     */
+    registerHandler(toolName: string, handler: CoreToolHandler): void;
+    /**
+     * Unregister a handler.
+     */
+    unregisterHandler(toolName: string): boolean;
+    /**
+     * List registered core tool names.
+     */
+    getRegisteredTools(): string[];
+    /**
+     * Invoke dispatches to the appropriate handler by spec.name.
+     */
+    invoke(spec: ToolSpec, args: unknown, ctx: ExecContext): Promise<{
+        result: unknown;
+        raw?: unknown;
+    }>;
+}
+
+/**
+ * User-provided config for registerCoreTools.
+ * `sandboxRoot` and `allowedHosts` are required; the rest have defaults.
+ */
+type CoreToolsUserConfig = Pick<CoreToolsConfig, "sandboxRoot" | "allowedHosts"> & Partial<Omit<CoreToolsConfig, "sandboxRoot" | "allowedHosts">>;
+/**
+ * Register all core tools with a ToolRegistry and return the configured CoreAdapter.
+ *
+ * Usage:
+ * ```ts
+ * const registry = new ToolRegistry();
+ * const coreAdapter = registerCoreTools(registry, {
+ *   sandboxRoot: "/var/tool-hub/sandbox",
+ *   allowedHosts: ["api.github.com", "*.example.com"],
+ * });
+ * runtime.registerAdapter(coreAdapter);
+ * ```
+ */
+declare function registerCoreTools(registry: ToolRegistry, userConfig: CoreToolsUserConfig): CoreAdapter;
+
+interface ToolMetadata {
+    name: string;
+    description: string;
+}
+type ToolDescription = SkillInstructionResult | {
+    name: string;
+    description?: string;
+    kind: ToolSpec["kind"];
+    version: string;
+    tags?: string[];
+    capabilities: Capability[];
+    inputSchema: object;
+    outputSchema: object;
+    costHints?: ToolSpec["costHints"];
+    endpoint?: string;
+    resourceId?: string;
+};
+interface ToolHubInitOptions {
+    roots: Array<string | {
+        path: string;
+        namespace?: string;
+    } | {
+        path: "coreTools";
+        namespace?: string;
+        config?: CoreToolsUserConfig;
+    }>;
+    namespace?: string;
+    extensions?: string[];
+    onDiscoverError?: (dir: string, err: Error) => void;
+    includeCoreTools?: boolean;
+    coreTools?: CoreToolsUserConfig;
+    runtimeConfig?: PTCRuntimeConfig;
+    debug?: DebugOptions;
+    watch?: {
+        enabled?: boolean;
+        debounceMs?: number;
+        persistent?: boolean;
+    };
+    langchain?: LangChainAdapterOptions;
+    mcp?: MCPAdapterOptions;
+    n8n?: N8nAdapterOptions;
+    n8nLocal?: N8nLocalAdapterOptions;
+    n8nMode?: "local" | "api";
+    comfyui?: ComfyUIAdapterOptions;
+    skill?: SkillAdapterOptions;
+}
+interface InvokeOptions {
+    purpose?: string;
+    requestId?: string;
+    taskId?: string;
+    traceId?: string;
+    userId?: string;
+    permissions?: Capability[];
+    budget?: BudgetConfig;
+    dryRun?: boolean;
+    idempotencyKey?: string;
+}
+declare class ToolHub {
+    private readonly registry;
+    private readonly runtime;
+    private readonly logger;
+    private scanner;
+    private readonly scannerOptions;
+    private readonly skillAdapter;
+    private n8nLocalAdapter?;
+    private readonly n8nLocalOptions?;
+    private readonly n8nMode;
+    private readonly includeCoreTools;
+    private readonly coreToolsConfig?;
+    private readonly watchConfig?;
+    private readonly watchers;
+    private readonly watchTimers;
+    constructor(options: ToolHubInitOptions);
+    /**
+     * Initialize all tools by scanning the configured roots.
+     */
+    initAllTools(): Promise<ToolSpec[]>;
+    /**
+     * Refresh tools by re-scanning current roots.
+     */
+    refreshTools(): Promise<ToolSpec[]>;
+    /**
+     * Add additional roots and optionally refresh.
+     */
+    addRoots(roots: Array<string | {
+        path: string;
+        namespace?: string;
+    }>, refresh?: boolean): Promise<ToolSpec[] | void>;
+    /**
+     * Replace roots and optionally refresh.
+     */
+    setRoots(roots: Array<string | {
+        path: string;
+        namespace?: string;
+    }>, refresh?: boolean): Promise<ToolSpec[] | void>;
+    /**
+     * Watch all current roots and auto-refresh on changes.
+     */
+    watchRoots(options?: {
+        debounceMs?: number;
+        persistent?: boolean;
+    }): void;
+    /**
+     * Stop watching all roots.
+     */
+    unwatchRoots(): void;
+    /**
+     * Return tool metadata in SKILL-like format (name + description).
+     */
+    listToolMetadata(): ToolMetadata[];
+    /**
+     * Get a tool's full description. For skills, returns full SKILL content.
+     */
+    getToolDescription(toolName: string): ToolDescription;
+    /**
+     * Invoke a tool through PTC Runtime.
+     */
+    invokeTool(toolName: string, args: unknown, options?: InvokeOptions): Promise<ToolResult>;
+    /**
+     * Invoke a tool using a pre-built ToolIntent and ExecContext.
+     */
+    invokeIntent(intent: ToolIntent, ctx: ExecContext): Promise<ToolResult>;
+    getRegistry(): ToolRegistry;
+    getRuntime(): PTCRuntime;
+    shutdown(): Promise<void>;
+    private ensureN8nLocalAdapter;
+    private extractSkillDefinition;
+}
+declare function createToolHub(options: ToolHubInitOptions): ToolHub;
+
+declare function createToolHubAndInit(options: ToolHubInitOptions): Promise<ToolHub>;
+declare function createToolHubAndInitFromConfig(configPath: string): Promise<ToolHub>;
+declare function createAgentToolHub(configPath: string): Promise<ToolHub>;
+
+export { N8nLocalAdapter as $, type AnyToolEvent as A, type BudgetConfig as B, type Capability as C, DEFAULT_CORE_TOOLS_CONFIG as D, type ExecContext as E, type JobFailedEvent as F, type JobSubmittedEvent as G, type HistogramValue as H, type InvokeOptions as I, type JobCompletedEvent as J, type LangChainAdapterOptions as K, LangChainAdapter as L, type LangChainToolLike as M, type LogEntry as N, type LogLevel as O, type Logger as P, MCPAdapter as Q, type MCPAdapterOptions as R, type SkillDefinition as S, type ToolSpec as T, type MCPCallResult as U, type MCPClientLike as V, type MCPToolDefinition as W, Metrics as X, N8nAdapter as Y, type N8nAdapterOptions as Z, type N8nInvokeMode as _, type Evidence as a, type N8nLocalAdapterOptions as a0, PTCRuntime as a1, type PTCRuntimeConfig as a2, type PolicyCheckResult as a3, type PolicyConfig as a4, PolicyDeniedError as a5, type PolicyDeniedEvent as a6, PolicyEngine as a7, type ResolvedDebugOptions as a8, type RetryEvent as a9, createLogger as aA, createToolHub as aB, createToolHubAndInitFromConfig as aC, registerCoreTools as aD, sanitizeForLog as aE, summarizeForLog as aF, validateFrontmatter as aG, createToolHubAndInit as aH, SchemaValidationError as aa, SchemaValidator as ab, SkillAdapter as ac, type SkillAdapterOptions as ad, type SkillContext as ae, type SkillHandler as af, type SkillInstructionResult as ag, type SkillInvocationContext as ah, SkillManifestError as ai, type SkillOutput as aj, type Span as ak, type SpanEvent as al, type ToolCalledEvent as am, type ToolDescription as an, type ToolError as ao, type ToolEvent as ap, type ToolEventType as aq, ToolHub as ar, type ToolIntent as as, type ToolMetadata as at, type ToolResult as au, type ToolResultEvent as av, type ToolSearchQuery as aw, Tracing as ax, type ValidationResult as ay, createAgentToolHub as az, ToolRegistry as b, type ToolAdapter as c, type SkillFrontmatter as d, type SkillResource as e, type ToolKind as f, type CostHints as g, type ToolHubInitOptions as h, BudgetManager as i, type BudgetOptions as j, ComfyUIAdapter as k, type ComfyUIAdapterOptions as l, type ComfyUIHistoryEntry as m, type ComfyUIHttpClient as n, type ComfyUIQueueResponse as o, CoreAdapter as p, type CoreToolContext as q, type CoreToolHandler as r, type CoreToolResult as s, type CoreToolsConfig as t, type CoreToolsUserConfig as u, type CounterValue as v, type DebugOptions as w, type EventListener as x, EventLog as y, type HttpClient as z };