agentbnb 2.2.0 → 3.0.0

package/dist/index.d.ts

@@ -204,6 +204,393 @@ declare const CapabilityCardSchema: z.ZodObject<{
     updated_at?: string | undefined;
 }>;
 type CapabilityCard = z.infer<typeof CapabilityCardSchema>;
+/**
+ * Capability Card v2.0 — one card per agent, multiple independently-priced skills.
+ *
+ * Introduced in Phase 4 (Plan 02). Existing v1.0 cards are migrated to this
+ * shape by `runMigrations()` in `src/registry/store.ts`.
+ */
+declare const CapabilityCardV2Schema: z.ZodObject<{
+    spec_version: z.ZodLiteral<"2.0">;
+    id: z.ZodString;
+    owner: z.ZodString;
+    /** Agent display name — was 'name' in v1.0. */
+    agent_name: z.ZodString;
+    /** At least one skill is required. */
+    skills: z.ZodArray<z.ZodObject<{
+        /** Stable skill identifier, e.g. 'tts-elevenlabs'. Used for gateway routing and idle tracking. */
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        level: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+        /** Optional grouping category, e.g. 'tts' | 'video_gen' | 'code_review'. */
+        category: z.ZodOptional<z.ZodString>;
+        inputs: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<["text", "json", "file", "audio", "image", "video", "stream"]>;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodDefault<z.ZodBoolean>;
+            schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            type: "text" | "json" | "file" | "audio" | "image" | "video" | "stream";
+            required: boolean;
+            description?: string | undefined;
+            schema?: Record<string, unknown> | undefined;
+        }, {
+            name: string;
+            type: "text" | "json" | "file" | "audio" | "image" | "video" | "stream";
+            description?: string | undefined;
+            required?: boolean | undefined;
+            schema?: Record<string, unknown> | undefined;
+        }>, "many">;
+        outputs: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<["text", "json", "file", "audio", "image", "video", "stream"]>;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodDefault<z.ZodBoolean>;
+            schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            type: "text" | "json" | "file" | "audio" | "image" | "video" | "stream";
+            required: boolean;
+            description?: string | undefined;
+            schema?: Record<string, unknown> | undefined;
+        }, {
+            name: string;
+            type: "text" | "json" | "file" | "audio" | "image" | "video" | "stream";
+            description?: string | undefined;
+            required?: boolean | undefined;
+            schema?: Record<string, unknown> | undefined;
+        }>, "many">;
+        pricing: z.ZodObject<{
+            credits_per_call: z.ZodNumber;
+            credits_per_minute: z.ZodOptional<z.ZodNumber>;
+            free_tier: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        }, {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        }>;
+        /** Per-skill online flag — overrides card-level availability for this skill. */
+        availability: z.ZodOptional<z.ZodObject<{
+            online: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            online: boolean;
+        }, {
+            online: boolean;
+        }>>;
+        powered_by: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodOptional<z.ZodString>;
+            tier: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            provider: string;
+            model?: string | undefined;
+            tier?: string | undefined;
+        }, {
+            provider: string;
+            model?: string | undefined;
+            tier?: string | undefined;
+        }>, "many">>;
+        metadata: z.ZodOptional<z.ZodObject<{
+            apis_used: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            avg_latency_ms: z.ZodOptional<z.ZodNumber>;
+            success_rate: z.ZodOptional<z.ZodNumber>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            capacity: z.ZodOptional<z.ZodObject<{
+                calls_per_hour: z.ZodDefault<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                calls_per_hour: number;
+            }, {
+                calls_per_hour?: number | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            apis_used?: string[] | undefined;
+            avg_latency_ms?: number | undefined;
+            success_rate?: number | undefined;
+            tags?: string[] | undefined;
+            capacity?: {
+                calls_per_hour: number;
+            } | undefined;
+        }, {
+            apis_used?: string[] | undefined;
+            avg_latency_ms?: number | undefined;
+            success_rate?: number | undefined;
+            tags?: string[] | undefined;
+            capacity?: {
+                calls_per_hour?: number | undefined;
+            } | undefined;
+        }>>;
+        /**
+         * Private per-skill metadata. Stripped from all API and CLI responses —
+         * never transmitted beyond the local store.
+         */
+        _internal: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        id: string;
+        level: 1 | 2 | 3;
+        inputs: {
+            name: string;
+            type: "text" | "json" | "file" | "audio" | "image" | "video" | "stream";
+            required: boolean;
+            description?: string | undefined;
+            schema?: Record<string, unknown> | undefined;
+        }[];
+        outputs: {
+            name: string;
+            type: "text" | "json" | "file" | "audio" | "image" | "video" | "stream";
+            required: boolean;
+            description?: string | undefined;
+            schema?: Record<string, unknown> | undefined;
+        }[];
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        availability?: {
+            online: boolean;
+        } | undefined;
+        powered_by?: {
+            provider: string;
+            model?: string | undefined;
+            tier?: string | undefined;
+        }[] | undefined;
+        _internal?: Record<string, unknown> | undefined;
+        metadata?: {
+            apis_used?: string[] | undefined;
+            avg_latency_ms?: number | undefined;
+            success_rate?: number | undefined;
+            tags?: string[] | undefined;
+            capacity?: {
+                calls_per_hour: number;
+            } | undefined;
+        } | undefined;
+        category?: string | undefined;
+    }, {
+        name: string;
+        description: string;
+        id: string;
+        level: 1 | 2 | 3;
+        inputs: {
+            name: string;
+            type: "text" | "json" | "file" | "audio" | "image" | "video" | "stream";
+            description?: string | undefined;
+            required?: boolean | undefined;
+            schema?: Record<string, unknown> | undefined;
+        }[];
+        outputs: {
+            name: string;
+            type: "text" | "json" | "file" | "audio" | "image" | "video" | "stream";
+            description?: string | undefined;
+            required?: boolean | undefined;
+            schema?: Record<string, unknown> | undefined;
+        }[];
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        availability?: {
+            online: boolean;
+        } | undefined;
+        powered_by?: {
+            provider: string;
+            model?: string | undefined;
+            tier?: string | undefined;
+        }[] | undefined;
+        _internal?: Record<string, unknown> | undefined;
+        metadata?: {
+            apis_used?: string[] | undefined;
+            avg_latency_ms?: number | undefined;
+            success_rate?: number | undefined;
+            tags?: string[] | undefined;
+            capacity?: {
+                calls_per_hour?: number | undefined;
+            } | undefined;
+        } | undefined;
+        category?: string | undefined;
+    }>, "many">;
+    availability: z.ZodObject<{
+        online: z.ZodBoolean;
+        schedule: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        online: boolean;
+        schedule?: string | undefined;
+    }, {
+        online: boolean;
+        schedule?: string | undefined;
+    }>;
+    /** Optional deployment environment metadata. */
+    environment: z.ZodOptional<z.ZodObject<{
+        runtime: z.ZodString;
+        region: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        runtime: string;
+        region?: string | undefined;
+    }, {
+        runtime: string;
+        region?: string | undefined;
+    }>>;
+    /**
+     * Private per-card metadata. Stripped from all API and CLI responses —
+     * never transmitted beyond the local store.
+     */
+    _internal: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    created_at: z.ZodOptional<z.ZodString>;
+    updated_at: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    spec_version: "2.0";
+    id: string;
+    owner: string;
+    availability: {
+        online: boolean;
+        schedule?: string | undefined;
+    };
+    agent_name: string;
+    skills: {
+        name: string;
+        description: string;
+        id: string;
+        level: 1 | 2 | 3;
+        inputs: {
+            name: string;
+            type: "text" | "json" | "file" | "audio" | "image" | "video" | "stream";
+            required: boolean;
+            description?: string | undefined;
+            schema?: Record<string, unknown> | undefined;
+        }[];
+        outputs: {
+            name: string;
+            type: "text" | "json" | "file" | "audio" | "image" | "video" | "stream";
+            required: boolean;
+            description?: string | undefined;
+            schema?: Record<string, unknown> | undefined;
+        }[];
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        availability?: {
+            online: boolean;
+        } | undefined;
+        powered_by?: {
+            provider: string;
+            model?: string | undefined;
+            tier?: string | undefined;
+        }[] | undefined;
+        _internal?: Record<string, unknown> | undefined;
+        metadata?: {
+            apis_used?: string[] | undefined;
+            avg_latency_ms?: number | undefined;
+            success_rate?: number | undefined;
+            tags?: string[] | undefined;
+            capacity?: {
+                calls_per_hour: number;
+            } | undefined;
+        } | undefined;
+        category?: string | undefined;
+    }[];
+    _internal?: Record<string, unknown> | undefined;
+    created_at?: string | undefined;
+    updated_at?: string | undefined;
+    environment?: {
+        runtime: string;
+        region?: string | undefined;
+    } | undefined;
+}, {
+    spec_version: "2.0";
+    id: string;
+    owner: string;
+    availability: {
+        online: boolean;
+        schedule?: string | undefined;
+    };
+    agent_name: string;
+    skills: {
+        name: string;
+        description: string;
+        id: string;
+        level: 1 | 2 | 3;
+        inputs: {
+            name: string;
+            type: "text" | "json" | "file" | "audio" | "image" | "video" | "stream";
+            description?: string | undefined;
+            required?: boolean | undefined;
+            schema?: Record<string, unknown> | undefined;
+        }[];
+        outputs: {
+            name: string;
+            type: "text" | "json" | "file" | "audio" | "image" | "video" | "stream";
+            description?: string | undefined;
+            required?: boolean | undefined;
+            schema?: Record<string, unknown> | undefined;
+        }[];
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        availability?: {
+            online: boolean;
+        } | undefined;
+        powered_by?: {
+            provider: string;
+            model?: string | undefined;
+            tier?: string | undefined;
+        }[] | undefined;
+        _internal?: Record<string, unknown> | undefined;
+        metadata?: {
+            apis_used?: string[] | undefined;
+            avg_latency_ms?: number | undefined;
+            success_rate?: number | undefined;
+            tags?: string[] | undefined;
+            capacity?: {
+                calls_per_hour?: number | undefined;
+            } | undefined;
+        } | undefined;
+        category?: string | undefined;
+    }[];
+    _internal?: Record<string, unknown> | undefined;
+    created_at?: string | undefined;
+    updated_at?: string | undefined;
+    environment?: {
+        runtime: string;
+        region?: string | undefined;
+    } | undefined;
+}>;
+type CapabilityCardV2 = z.infer<typeof CapabilityCardV2Schema>;
+/**
+ * Signed escrow receipt — cryptographic proof that a requester has committed credits.
+ * Sent to the provider so they can verify the requester's credit commitment
+ * without needing access to the requester's local database.
+ */
+interface EscrowReceipt {
+    /** Agent owner identifier of the requester. */
+    requester_owner: string;
+    /** Hex-encoded Ed25519 public key of the requester. */
+    requester_public_key: string;
+    /** Number of credits committed. */
+    amount: number;
+    /** Capability Card ID being requested. */
+    card_id: string;
+    /** Optional skill ID within the card. */
+    skill_id?: string;
+    /** ISO 8601 timestamp of receipt creation. */
+    timestamp: string;
+    /** UUID nonce — prevents replay attacks. */
+    nonce: string;
+    /** Base64url Ed25519 signature over all other fields. */
+    signature: string;
+}
 
 /**
  * Opens a SQLite database at the given path (or in-memory if ':memory:').
@@ -275,10 +662,10 @@ declare function openCreditDb(path?: string): Database.Database;
 declare function getBalance(db: Database.Database, owner: string): number;
 
 /**
- * Discriminated union over all four skill configuration types.
- * Used by SkillExecutor to dispatch to the correct executor mode.
+ * Schema for API wrapper skills (Mode A).
+ * Wraps a REST API call with input/output mapping.
  */
-declare const SkillConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+declare const ApiSkillConfigSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodLiteral<"api">;
     name: z.ZodString;
@@ -299,8 +686,8 @@ declare const SkillConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         key: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         type: "apikey";
-        header: string;
         key: string;
+        header: string;
     }, {
         type: "apikey";
         key: string;
@@ -357,8 +744,8 @@ declare const SkillConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         token: string;
     } | {
         type: "apikey";
-        header: string;
         key: string;
+        header: string;
     } | {
         type: "basic";
         username: string;
@@ -392,7 +779,12 @@ declare const SkillConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     output_mapping?: Record<string, string> | undefined;
     timeout_ms?: number | undefined;
     retries?: number | undefined;
-}>, z.ZodObject<{
+}>;
+/**
+ * Schema for pipeline skills (Mode B).
+ * Chains multiple skills or commands sequentially.
+ */
+declare const PipelineSkillConfigSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodLiteral<"pipeline">;
     name: z.ZodString;
@@ -463,7 +855,12 @@ declare const SkillConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         input_mapping?: Record<string, string> | undefined;
     })[];
     timeout_ms?: number | undefined;
-}>, z.ZodObject<{
+}>;
+/**
+ * Schema for OpenClaw bridge skills (Mode C).
+ * Forwards execution to a local OpenClaw agent.
+ */
+declare const OpenClawSkillConfigSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodLiteral<"openclaw">;
     name: z.ZodString;
@@ -507,7 +904,12 @@ declare const SkillConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     agent_name: string;
     channel: "telegram" | "webhook" | "process";
     timeout_ms?: number | undefined;
-}>, z.ZodObject<{
+}>;
+/**
+ * Schema for command execution skills (Mode D).
+ * Runs local shell commands with parameter substitution.
+ */
+declare const CommandSkillConfigSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodLiteral<"command">;
     name: z.ZodString;
@@ -557,120 +959,1772 @@ declare const SkillConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     timeout_ms?: number | undefined;
     allowed_commands?: string[] | undefined;
     working_dir?: string | undefined;
-}>]>;
-/** TypeScript type for any skill config entry */
-type SkillConfig = z.infer<typeof SkillConfigSchema>;
-
-/**
- * Result returned by SkillExecutor.execute() for every invocation.
- * Always includes timing data regardless of success or failure.
- */
-interface ExecutionResult {
-    /** Whether the skill executed successfully. */
-    success: boolean;
-    /** The output produced by the skill on success. */
-    result?: unknown;
-    /** Error message if success is false. */
-    error?: string;
-    /** Wall-clock execution time in milliseconds. */
-    latency_ms: number;
-}
-/**
- * Interface that all executor mode implementations must satisfy.
- * Each mode handles one skill type: 'api' | 'pipeline' | 'openclaw' | 'command'.
- */
-interface ExecutorMode {
-    /**
-     * Execute a skill with the given config and input parameters.
-     *
-     * @param config - The validated SkillConfig for this skill.
-     * @param params - The input parameters passed by the caller.
-     * @returns A partial ExecutionResult without latency_ms (added by SkillExecutor).
-     */
-    execute(config: SkillConfig, params: Record<string, unknown>): Promise<Omit<ExecutionResult, 'latency_ms'>>;
-}
-/**
- * Central dispatcher that routes skill execution requests to the appropriate
- * executor mode based on the skill's `type` field.
- *
- * Usage:
- * ```ts
- * const executor = createSkillExecutor(configs, modes);
- * const result = await executor.execute('tts-skill', { text: 'hello' });
- * ```
- */
-declare class SkillExecutor {
-    private readonly skillMap;
-    private readonly modeMap;
-    /**
-     * @param configs - Parsed SkillConfig array (from parseSkillsFile).
-     * @param modes - Map from skill type string to its executor implementation.
-     */
-    constructor(configs: SkillConfig[], modes: Map<string, ExecutorMode>);
-    /**
-     * Execute a skill by ID with the given input parameters.
-     *
-     * Dispatch order:
-     * 1. Look up skill config by skillId.
-     * 2. Find executor mode by config.type.
-     * 3. Invoke mode.execute(), wrap with latency timing.
-     * 4. Catch any thrown errors and return as ExecutionResult with success:false.
-     *
-     * @param skillId - The ID of the skill to execute.
-     * @param params - Input parameters for the skill.
-     * @returns ExecutionResult including success, result/error, and latency_ms.
-     */
-    execute(skillId: string, params: Record<string, unknown>): Promise<ExecutionResult>;
-    /**
-     * Returns the IDs of all registered skills.
-     *
-     * @returns Array of skill ID strings.
-     */
-    listSkills(): string[];
-    /**
-     * Returns the SkillConfig for a given skill ID, or undefined if not found.
-     *
-     * @param skillId - The skill ID to look up.
-     * @returns The SkillConfig or undefined.
-     */
-    getSkillConfig(skillId: string): SkillConfig | undefined;
-}
-
+}>;
 /**
- * Options for creating a gateway server.
+ * Schema for conductor orchestration skills (Mode E).
+ * Routes execution to the ConductorMode for task decomposition and multi-agent orchestration.
  */
-interface GatewayOptions {
-    /** Port to listen on. Default 7700. */
-    port?: number;
-    /** Open registry database instance. */
-    registryDb: Database.Database;
-    /** Open credit database instance. */
-    creditDb: Database.Database;
-    /** Valid bearer tokens for auth. */
-    tokens: string[];
-    /** URL of the local capability handler. */
-    handlerUrl: string;
-    /** Request timeout in ms. Default 30000. */
-    timeoutMs?: number;
-    /** Disable logging (useful for tests). */
-    silent?: boolean;
-    /**
-     * Optional SkillExecutor instance.
-     * When provided, skill execution is dispatched through SkillExecutor.execute()
-     * instead of forwarding via fetch(handlerUrl).
-     * When absent, the original handlerUrl fetch path is used (backward compat).
-     */
-    skillExecutor?: SkillExecutor;
-}
+declare const ConductorSkillConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"conductor">;
+    name: z.ZodString;
+    conductor_skill: z.ZodEnum<["orchestrate", "plan"]>;
+    pricing: z.ZodObject<{
+        credits_per_call: z.ZodNumber;
+        credits_per_minute: z.ZodOptional<z.ZodNumber>;
+        free_tier: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    }, {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    }>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "conductor";
+    id: string;
+    pricing: {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    };
+    conductor_skill: "orchestrate" | "plan";
+    timeout_ms?: number | undefined;
+}, {
+    name: string;
+    type: "conductor";
+    id: string;
+    pricing: {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    };
+    conductor_skill: "orchestrate" | "plan";
+    timeout_ms?: number | undefined;
+}>;
 /**
- * Creates a Fastify gateway server for agent-to-agent communication.
- * Registers /health (unauthenticated) and /rpc (token-authenticated) endpoints.
- * Returns a configured Fastify instance (call .ready() before using inject,
- * or .listen() to start accepting connections).
- *
- * @param opts - Gateway configuration options.
- * @returns Configured Fastify instance (not yet listening).
+ * Discriminated union over all five skill configuration types.
+ * Used by SkillExecutor to dispatch to the correct executor mode.
  */
-declare function createGatewayServer(opts: GatewayOptions): FastifyInstance;
+declare const SkillConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"api">;
+    name: z.ZodString;
+    endpoint: z.ZodString;
+    method: z.ZodEnum<["GET", "POST", "PUT", "DELETE"]>;
+    auth: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"bearer">;
+        token: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "bearer";
+        token: string;
+    }, {
+        type: "bearer";
+        token: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"apikey">;
+        header: z.ZodDefault<z.ZodString>;
+        key: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "apikey";
+        key: string;
+        header: string;
+    }, {
+        type: "apikey";
+        key: string;
+        header?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"basic">;
+        username: z.ZodString;
+        password: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "basic";
+        username: string;
+        password: string;
+    }, {
+        type: "basic";
+        username: string;
+        password: string;
+    }>]>>;
+    input_mapping: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    output_mapping: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    pricing: z.ZodObject<{
+        credits_per_call: z.ZodNumber;
+        credits_per_minute: z.ZodOptional<z.ZodNumber>;
+        free_tier: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    }, {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    }>;
+    timeout_ms: z.ZodDefault<z.ZodNumber>;
+    retries: z.ZodDefault<z.ZodNumber>;
+    provider: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "api";
+    id: string;
+    pricing: {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    };
+    endpoint: string;
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    input_mapping: Record<string, string>;
+    output_mapping: Record<string, string>;
+    timeout_ms: number;
+    retries: number;
+    provider?: string | undefined;
+    auth?: {
+        type: "bearer";
+        token: string;
+    } | {
+        type: "apikey";
+        key: string;
+        header: string;
+    } | {
+        type: "basic";
+        username: string;
+        password: string;
+    } | undefined;
+}, {
+    name: string;
+    type: "api";
+    id: string;
+    pricing: {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    };
+    endpoint: string;
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    provider?: string | undefined;
+    auth?: {
+        type: "bearer";
+        token: string;
+    } | {
+        type: "apikey";
+        key: string;
+        header?: string | undefined;
+    } | {
+        type: "basic";
+        username: string;
+        password: string;
+    } | undefined;
+    input_mapping?: Record<string, string> | undefined;
+    output_mapping?: Record<string, string> | undefined;
+    timeout_ms?: number | undefined;
+    retries?: number | undefined;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"pipeline">;
+    name: z.ZodString;
+    steps: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        skill_id: z.ZodString;
+        input_mapping: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        input_mapping: Record<string, string>;
+        skill_id: string;
+    }, {
+        skill_id: string;
+        input_mapping?: Record<string, string> | undefined;
+    }>, z.ZodObject<{
+        command: z.ZodString;
+        input_mapping: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        input_mapping: Record<string, string>;
+        command: string;
+    }, {
+        command: string;
+        input_mapping?: Record<string, string> | undefined;
+    }>]>, "many">;
+    pricing: z.ZodObject<{
+        credits_per_call: z.ZodNumber;
+        credits_per_minute: z.ZodOptional<z.ZodNumber>;
+        free_tier: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    }, {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    }>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "pipeline";
+    id: string;
+    pricing: {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    };
+    steps: ({
+        input_mapping: Record<string, string>;
+        skill_id: string;
+    } | {
+        input_mapping: Record<string, string>;
+        command: string;
+    })[];
+    timeout_ms?: number | undefined;
+}, {
+    name: string;
+    type: "pipeline";
+    id: string;
+    pricing: {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    };
+    steps: ({
+        skill_id: string;
+        input_mapping?: Record<string, string> | undefined;
+    } | {
+        command: string;
+        input_mapping?: Record<string, string> | undefined;
+    })[];
+    timeout_ms?: number | undefined;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"openclaw">;
+    name: z.ZodString;
+    agent_name: z.ZodString;
+    channel: z.ZodEnum<["telegram", "webhook", "process"]>;
+    pricing: z.ZodObject<{
+        credits_per_call: z.ZodNumber;
+        credits_per_minute: z.ZodOptional<z.ZodNumber>;
+        free_tier: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    }, {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    }>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "openclaw";
+    id: string;
+    pricing: {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    };
+    agent_name: string;
+    channel: "telegram" | "webhook" | "process";
+    timeout_ms?: number | undefined;
+}, {
+    name: string;
+    type: "openclaw";
+    id: string;
+    pricing: {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    };
+    agent_name: string;
+    channel: "telegram" | "webhook" | "process";
+    timeout_ms?: number | undefined;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"command">;
+    name: z.ZodString;
+    command: z.ZodString;
+    output_type: z.ZodEnum<["json", "text", "file"]>;
+    allowed_commands: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    working_dir: z.ZodOptional<z.ZodString>;
+    timeout_ms: z.ZodDefault<z.ZodNumber>;
+    pricing: z.ZodObject<{
+        credits_per_call: z.ZodNumber;
+        credits_per_minute: z.ZodOptional<z.ZodNumber>;
+        free_tier: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    }, {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "command";
+    id: string;
+    pricing: {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    };
+    timeout_ms: number;
+    command: string;
+    output_type: "text" | "json" | "file";
+    allowed_commands?: string[] | undefined;
+    working_dir?: string | undefined;
+}, {
+    name: string;
+    type: "command";
+    id: string;
+    pricing: {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    };
+    command: string;
+    output_type: "text" | "json" | "file";
+    timeout_ms?: number | undefined;
+    allowed_commands?: string[] | undefined;
+    working_dir?: string | undefined;
+}>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"conductor">;
+    name: z.ZodString;
+    conductor_skill: z.ZodEnum<["orchestrate", "plan"]>;
+    pricing: z.ZodObject<{
+        credits_per_call: z.ZodNumber;
+        credits_per_minute: z.ZodOptional<z.ZodNumber>;
+        free_tier: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    }, {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    }>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "conductor";
+    id: string;
+    pricing: {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    };
+    conductor_skill: "orchestrate" | "plan";
+    timeout_ms?: number | undefined;
+}, {
+    name: string;
+    type: "conductor";
+    id: string;
+    pricing: {
+        credits_per_call: number;
+        credits_per_minute?: number | undefined;
+        free_tier?: number | undefined;
+    };
+    conductor_skill: "orchestrate" | "plan";
+    timeout_ms?: number | undefined;
+}>]>;
+/**
+ * Root schema for a skills.yaml file.
+ * Contains a list of skill configurations.
+ */
+declare const SkillsFileSchema: z.ZodObject<{
+    skills: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"api">;
+        name: z.ZodString;
+        endpoint: z.ZodString;
+        method: z.ZodEnum<["GET", "POST", "PUT", "DELETE"]>;
+        auth: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"bearer">;
+            token: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "bearer";
+            token: string;
+        }, {
+            type: "bearer";
+            token: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"apikey">;
+            header: z.ZodDefault<z.ZodString>;
+            key: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "apikey";
+            key: string;
+            header: string;
+        }, {
+            type: "apikey";
+            key: string;
+            header?: string | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"basic">;
+            username: z.ZodString;
+            password: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "basic";
+            username: string;
+            password: string;
+        }, {
+            type: "basic";
+            username: string;
+            password: string;
+        }>]>>;
+        input_mapping: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        output_mapping: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        pricing: z.ZodObject<{
+            credits_per_call: z.ZodNumber;
+            credits_per_minute: z.ZodOptional<z.ZodNumber>;
+            free_tier: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        }, {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        }>;
+        timeout_ms: z.ZodDefault<z.ZodNumber>;
+        retries: z.ZodDefault<z.ZodNumber>;
+        provider: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        type: "api";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        endpoint: string;
+        method: "GET" | "POST" | "PUT" | "DELETE";
+        input_mapping: Record<string, string>;
+        output_mapping: Record<string, string>;
+        timeout_ms: number;
+        retries: number;
+        provider?: string | undefined;
+        auth?: {
+            type: "bearer";
+            token: string;
+        } | {
+            type: "apikey";
+            key: string;
+            header: string;
+        } | {
+            type: "basic";
+            username: string;
+            password: string;
+        } | undefined;
+    }, {
+        name: string;
+        type: "api";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        endpoint: string;
+        method: "GET" | "POST" | "PUT" | "DELETE";
+        provider?: string | undefined;
+        auth?: {
+            type: "bearer";
+            token: string;
+        } | {
+            type: "apikey";
+            key: string;
+            header?: string | undefined;
+        } | {
+            type: "basic";
+            username: string;
+            password: string;
+        } | undefined;
+        input_mapping?: Record<string, string> | undefined;
+        output_mapping?: Record<string, string> | undefined;
+        timeout_ms?: number | undefined;
+        retries?: number | undefined;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"pipeline">;
+        name: z.ZodString;
+        steps: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            skill_id: z.ZodString;
+            input_mapping: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            input_mapping: Record<string, string>;
+            skill_id: string;
+        }, {
+            skill_id: string;
+            input_mapping?: Record<string, string> | undefined;
+        }>, z.ZodObject<{
+            command: z.ZodString;
+            input_mapping: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            input_mapping: Record<string, string>;
+            command: string;
+        }, {
+            command: string;
+            input_mapping?: Record<string, string> | undefined;
+        }>]>, "many">;
+        pricing: z.ZodObject<{
+            credits_per_call: z.ZodNumber;
+            credits_per_minute: z.ZodOptional<z.ZodNumber>;
+            free_tier: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        }, {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        }>;
+        timeout_ms: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        type: "pipeline";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        steps: ({
+            input_mapping: Record<string, string>;
+            skill_id: string;
+        } | {
+            input_mapping: Record<string, string>;
+            command: string;
+        })[];
+        timeout_ms?: number | undefined;
+    }, {
+        name: string;
+        type: "pipeline";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        steps: ({
+            skill_id: string;
+            input_mapping?: Record<string, string> | undefined;
+        } | {
+            command: string;
+            input_mapping?: Record<string, string> | undefined;
+        })[];
+        timeout_ms?: number | undefined;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"openclaw">;
+        name: z.ZodString;
+        agent_name: z.ZodString;
+        channel: z.ZodEnum<["telegram", "webhook", "process"]>;
+        pricing: z.ZodObject<{
+            credits_per_call: z.ZodNumber;
+            credits_per_minute: z.ZodOptional<z.ZodNumber>;
+            free_tier: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        }, {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        }>;
+        timeout_ms: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        type: "openclaw";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        agent_name: string;
+        channel: "telegram" | "webhook" | "process";
+        timeout_ms?: number | undefined;
+    }, {
+        name: string;
+        type: "openclaw";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        agent_name: string;
+        channel: "telegram" | "webhook" | "process";
+        timeout_ms?: number | undefined;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"command">;
+        name: z.ZodString;
+        command: z.ZodString;
+        output_type: z.ZodEnum<["json", "text", "file"]>;
+        allowed_commands: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        working_dir: z.ZodOptional<z.ZodString>;
+        timeout_ms: z.ZodDefault<z.ZodNumber>;
+        pricing: z.ZodObject<{
+            credits_per_call: z.ZodNumber;
+            credits_per_minute: z.ZodOptional<z.ZodNumber>;
+            free_tier: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        }, {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        type: "command";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        timeout_ms: number;
+        command: string;
+        output_type: "text" | "json" | "file";
+        allowed_commands?: string[] | undefined;
+        working_dir?: string | undefined;
+    }, {
+        name: string;
+        type: "command";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        command: string;
+        output_type: "text" | "json" | "file";
+        timeout_ms?: number | undefined;
+        allowed_commands?: string[] | undefined;
+        working_dir?: string | undefined;
+    }>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"conductor">;
+        name: z.ZodString;
+        conductor_skill: z.ZodEnum<["orchestrate", "plan"]>;
+        pricing: z.ZodObject<{
+            credits_per_call: z.ZodNumber;
+            credits_per_minute: z.ZodOptional<z.ZodNumber>;
+            free_tier: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        }, {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        }>;
+        timeout_ms: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        type: "conductor";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        conductor_skill: "orchestrate" | "plan";
+        timeout_ms?: number | undefined;
+    }, {
+        name: string;
+        type: "conductor";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        conductor_skill: "orchestrate" | "plan";
+        timeout_ms?: number | undefined;
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    skills: ({
+        name: string;
+        type: "api";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        endpoint: string;
+        method: "GET" | "POST" | "PUT" | "DELETE";
+        input_mapping: Record<string, string>;
+        output_mapping: Record<string, string>;
+        timeout_ms: number;
+        retries: number;
+        provider?: string | undefined;
+        auth?: {
+            type: "bearer";
+            token: string;
+        } | {
+            type: "apikey";
+            key: string;
+            header: string;
+        } | {
+            type: "basic";
+            username: string;
+            password: string;
+        } | undefined;
+    } | {
+        name: string;
+        type: "pipeline";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        steps: ({
+            input_mapping: Record<string, string>;
+            skill_id: string;
+        } | {
+            input_mapping: Record<string, string>;
+            command: string;
+        })[];
+        timeout_ms?: number | undefined;
+    } | {
+        name: string;
+        type: "openclaw";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        agent_name: string;
+        channel: "telegram" | "webhook" | "process";
+        timeout_ms?: number | undefined;
+    } | {
+        name: string;
+        type: "command";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        timeout_ms: number;
+        command: string;
+        output_type: "text" | "json" | "file";
+        allowed_commands?: string[] | undefined;
+        working_dir?: string | undefined;
+    } | {
+        name: string;
+        type: "conductor";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        conductor_skill: "orchestrate" | "plan";
+        timeout_ms?: number | undefined;
+    })[];
+}, {
+    skills: ({
+        name: string;
+        type: "api";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        endpoint: string;
+        method: "GET" | "POST" | "PUT" | "DELETE";
+        provider?: string | undefined;
+        auth?: {
+            type: "bearer";
+            token: string;
+        } | {
+            type: "apikey";
+            key: string;
+            header?: string | undefined;
+        } | {
+            type: "basic";
+            username: string;
+            password: string;
+        } | undefined;
+        input_mapping?: Record<string, string> | undefined;
+        output_mapping?: Record<string, string> | undefined;
+        timeout_ms?: number | undefined;
+        retries?: number | undefined;
+    } | {
+        name: string;
+        type: "pipeline";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        steps: ({
+            skill_id: string;
+            input_mapping?: Record<string, string> | undefined;
+        } | {
+            command: string;
+            input_mapping?: Record<string, string> | undefined;
+        })[];
+        timeout_ms?: number | undefined;
+    } | {
+        name: string;
+        type: "openclaw";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        agent_name: string;
+        channel: "telegram" | "webhook" | "process";
+        timeout_ms?: number | undefined;
+    } | {
+        name: string;
+        type: "command";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        command: string;
+        output_type: "text" | "json" | "file";
+        timeout_ms?: number | undefined;
+        allowed_commands?: string[] | undefined;
+        working_dir?: string | undefined;
+    } | {
+        name: string;
+        type: "conductor";
+        id: string;
+        pricing: {
+            credits_per_call: number;
+            credits_per_minute?: number | undefined;
+            free_tier?: number | undefined;
+        };
+        conductor_skill: "orchestrate" | "plan";
+        timeout_ms?: number | undefined;
+    })[];
+}>;
+/** TypeScript type for any skill config entry */
+type SkillConfig = z.infer<typeof SkillConfigSchema>;
+/** TypeScript type for an API-mode skill config */
+type ApiSkillConfig = z.infer<typeof ApiSkillConfigSchema>;
+/** TypeScript type for a pipeline-mode skill config */
+type PipelineSkillConfig = z.infer<typeof PipelineSkillConfigSchema>;
+/** TypeScript type for an OpenClaw-mode skill config */
+type OpenClawSkillConfig = z.infer<typeof OpenClawSkillConfigSchema>;
+/** TypeScript type for a command-mode skill config */
+type CommandSkillConfig = z.infer<typeof CommandSkillConfigSchema>;
+/** TypeScript type for a conductor-mode skill config */
+type ConductorSkillConfig = z.infer<typeof ConductorSkillConfigSchema>;
+/**
+ * Expands `${VAR_NAME}` patterns in a string using process.env.
+ *
+ * Only matches env-var-style names: uppercase letters, digits, and underscores
+ * (e.g. `${API_KEY}`, `${MY_TOKEN_123}`). Patterns containing dots or lowercase
+ * letters (e.g. `${params.text}`, `${prev.result}`) are left untouched — those
+ * are runtime interpolation placeholders handled by the interpolation engine.
+ *
+ * @param value - The string potentially containing `${ENV_VAR}` references.
+ * @returns The string with env var references replaced; runtime placeholders preserved.
+ * @throws Error if a referenced env var is not defined.
+ */
+declare function expandEnvVars(value: string): string;
+/**
+ * Parses a skills.yaml file content string into a typed SkillConfig array.
+ *
+ * 1. Parses YAML string into a raw object (throws on invalid YAML).
+ * 2. Expands all `${ENV_VAR}` references in string values using process.env.
+ * 3. Validates the result with the SkillsFileSchema Zod schema (throws ZodError on invalid shape).
+ *
+ * @param yamlContent - Raw YAML string (contents of skills.yaml).
+ * @returns Parsed and validated array of SkillConfig objects.
+ * @throws YAMLException if YAML syntax is invalid.
+ * @throws ZodError if schema validation fails.
+ * @throws Error if any referenced environment variable is not defined.
+ */
+declare function parseSkillsFile(yamlContent: string): SkillConfig[];
+
+/**
+ * Result returned by SkillExecutor.execute() for every invocation.
+ * Always includes timing data regardless of success or failure.
+ */
+interface ExecutionResult {
+    /** Whether the skill executed successfully. */
+    success: boolean;
+    /** The output produced by the skill on success. */
+    result?: unknown;
+    /** Error message if success is false. */
+    error?: string;
+    /** Wall-clock execution time in milliseconds. */
+    latency_ms: number;
+}
+/**
+ * Interface that all executor mode implementations must satisfy.
+ * Each mode handles one skill type: 'api' | 'pipeline' | 'openclaw' | 'command'.
+ */
+interface ExecutorMode {
+    /**
+     * Execute a skill with the given config and input parameters.
+     *
+     * @param config - The validated SkillConfig for this skill.
+     * @param params - The input parameters passed by the caller.
+     * @returns A partial ExecutionResult without latency_ms (added by SkillExecutor).
+     */
+    execute(config: SkillConfig, params: Record<string, unknown>): Promise<Omit<ExecutionResult, 'latency_ms'>>;
+}
+/**
+ * Central dispatcher that routes skill execution requests to the appropriate
+ * executor mode based on the skill's `type` field.
+ *
+ * Usage:
+ * ```ts
+ * const executor = createSkillExecutor(configs, modes);
+ * const result = await executor.execute('tts-skill', { text: 'hello' });
+ * ```
+ */
+declare class SkillExecutor {
+    private readonly skillMap;
+    private readonly modeMap;
+    /**
+     * @param configs - Parsed SkillConfig array (from parseSkillsFile).
+     * @param modes - Map from skill type string to its executor implementation.
+     */
+    constructor(configs: SkillConfig[], modes: Map<string, ExecutorMode>);
+    /**
+     * Execute a skill by ID with the given input parameters.
+     *
+     * Dispatch order:
+     * 1. Look up skill config by skillId.
+     * 2. Find executor mode by config.type.
+     * 3. Invoke mode.execute(), wrap with latency timing.
+     * 4. Catch any thrown errors and return as ExecutionResult with success:false.
+     *
+     * @param skillId - The ID of the skill to execute.
+     * @param params - Input parameters for the skill.
+     * @returns ExecutionResult including success, result/error, and latency_ms.
+     */
+    execute(skillId: string, params: Record<string, unknown>): Promise<ExecutionResult>;
+    /**
+     * Returns the IDs of all registered skills.
+     *
+     * @returns Array of skill ID strings.
+     */
+    listSkills(): string[];
+    /**
+     * Returns the SkillConfig for a given skill ID, or undefined if not found.
+     *
+     * @param skillId - The skill ID to look up.
+     * @returns The SkillConfig or undefined.
+     */
+    getSkillConfig(skillId: string): SkillConfig | undefined;
+}
+/**
+ * Factory function to create a SkillExecutor with the given configs and mode implementations.
+ *
+ * @param configs - Array of parsed SkillConfig objects.
+ * @param modes - Map from type key to ExecutorMode implementation.
+ * @returns A configured SkillExecutor instance.
+ */
+declare function createSkillExecutor(configs: SkillConfig[], modes: Map<string, ExecutorMode>): SkillExecutor;
+
+/**
+ * Options for creating a gateway server.
+ */
+interface GatewayOptions {
+    /** Port to listen on. Default 7700. */
+    port?: number;
+    /** Open registry database instance. */
+    registryDb: Database.Database;
+    /** Open credit database instance. */
+    creditDb: Database.Database;
+    /** Valid bearer tokens for auth. */
+    tokens: string[];
+    /** URL of the local capability handler. */
+    handlerUrl: string;
+    /** Request timeout in ms. Default 30000. */
+    timeoutMs?: number;
+    /** Disable logging (useful for tests). */
+    silent?: boolean;
+    /**
+     * Optional SkillExecutor instance.
+     * When provided, skill execution is dispatched through SkillExecutor.execute()
+     * instead of forwarding via fetch(handlerUrl).
+     * When absent, the original handlerUrl fetch path is used (backward compat).
+     */
+    skillExecutor?: SkillExecutor;
+}
+/**
+ * Creates a Fastify gateway server for agent-to-agent communication.
+ * Registers /health (unauthenticated) and /rpc (token-authenticated) endpoints.
+ * Returns a configured Fastify instance (call .ready() before using inject,
+ * or .listen() to start accepting connections).
+ *
+ * @param opts - Gateway configuration options.
+ * @returns Configured Fastify instance (not yet listening).
+ */
+declare function createGatewayServer(opts: GatewayOptions): FastifyInstance;
+
+/**
+ * Extracts a nested value from an object using dot-notation path.
+ * e.g. `extractByPath({ data: { audio: 'abc' } }, 'data.audio')` returns `'abc'`
+ *
+ * When path starts with "response.", the "response" prefix is stripped
+ * (the mapping convention uses "response.xxx" but the actual response body
+ * is the root object passed in).
+ *
+ * @param obj - The object to traverse.
+ * @param dotPath - Dot-separated property path.
+ * @returns The value at the path, or `undefined` if any step is missing.
+ */
+declare function extractByPath(obj: unknown, dotPath: string): unknown;
+/**
+ * Builds the Authorization / API-key headers for the configured auth type.
+ *
+ * @param auth - The auth config from ApiSkillConfig.
+ * @returns A plain object of header name → value entries.
+ */
+declare function buildAuthHeaders(auth: ApiSkillConfig['auth']): Record<string, string>;
+/**
+ * Routes a set of input parameters to their respective destination buckets
+ * (body, query, path, header) based on the `input_mapping` config.
+ *
+ * @param params - The input parameters passed to execute().
+ * @param mapping - The `input_mapping` record from ApiSkillConfig.
+ * @returns Four buckets: body, query, pathParams, headers.
+ */
+declare function applyInputMapping(params: Record<string, unknown>, mapping: Record<string, string>): {
+    body: Record<string, unknown>;
+    query: Record<string, string>;
+    pathParams: Record<string, string>;
+    headers: Record<string, string>;
+};
+/**
+ * API Executor (Mode A) — config-driven REST API calls.
+ *
+ * Supports:
+ * - All 4 HTTP methods: GET, POST, PUT, DELETE
+ * - Input mapping to body, query string, path params, or request headers
+ * - Auth: bearer token, API key header, HTTP Basic
+ * - Output mapping via dot-notation extraction from JSON response
+ * - Retry with exponential backoff on 429/500/503
+ * - Timeout via AbortController
+ *
+ * Implements {@link ExecutorMode} — registered under the `"api"` type key.
+ */
+declare class ApiExecutor implements ExecutorMode {
+    /**
+     * Execute an API call described by the given skill config.
+     *
+     * @param config - The validated SkillConfig (must be ApiSkillConfig).
+     * @param params - Input parameters to map to the HTTP request.
+     * @returns Partial ExecutionResult (without latency_ms — added by SkillExecutor).
+     */
+    execute(config: SkillConfig, params: Record<string, unknown>): Promise<Omit<ExecutionResult, 'latency_ms'>>;
+}
+
+/**
+ * Executor mode for pipeline-type skills (Mode B).
+ *
+ * Chains multiple skill invocations or shell commands sequentially.
+ * Each step can reference previous step outputs via `${prev.result.*}` or
+ * `${steps[N].result.*}` in its `input_mapping` values.
+ *
+ * Usage:
+ * ```ts
+ * const pipelineExecutor = new PipelineExecutor(skillExecutor);
+ * modes.set('pipeline', pipelineExecutor);
+ * ```
+ */
+declare class PipelineExecutor implements ExecutorMode {
+    private readonly skillExecutor;
+    /**
+     * @param skillExecutor - The parent SkillExecutor used to dispatch sub-skill calls.
+     */
+    constructor(skillExecutor: SkillExecutor);
+    /**
+     * Execute a pipeline skill config sequentially.
+     *
+     * Algorithm:
+     * 1. Initialise context: { params, steps: [], prev: { result: null } }
+     * 2. For each step:
+     *    a. Resolve input_mapping keys against current context via interpolateObject.
+     *    b. If step has `skill_id`: dispatch via skillExecutor.execute(). On failure → stop.
+     *    c. If step has `command`: interpolate command string, run via exec(). On non-zero exit → stop.
+     *    d. Store step result in context.steps[i] and context.prev.
+     * 3. Return success with final step result (or null for empty pipeline).
+     *
+     * @param config - The PipelineSkillConfig for this skill.
+     * @param params - Input parameters from the caller.
+     * @returns Partial ExecutionResult (without latency_ms — added by SkillExecutor wrapper).
+     */
+    execute(config: SkillConfig, params: Record<string, unknown>): Promise<Omit<ExecutionResult, 'latency_ms'>>;
+}
+
+/**
+ * OpenClaw Bridge — ExecutorMode C.
+ *
+ * Forwards AgentBnB skill execution requests to an OpenClaw agent via one of
+ * three configurable channels:
+ * - `webhook` — HTTP POST to OpenClaw agent's local webhook endpoint
+ * - `process` — spawn `openclaw run <agent_name>` subprocess
+ * - `telegram` — fire-and-forget POST to Telegram Bot API
+ *
+ * Implements the {@link ExecutorMode} interface so it can be registered into
+ * a {@link SkillExecutor} mode map under the key `'openclaw'`.
+ *
+ * @example
+ * ```ts
+ * const modes = new Map([['openclaw', new OpenClawBridge()]]);
+ * const executor = createSkillExecutor(configs, modes);
+ * ```
+ */
+declare class OpenClawBridge implements ExecutorMode {
+    /**
+     * Execute a skill with the given config and input parameters.
+     *
+     * @param config - The SkillConfig for this skill (must be type 'openclaw').
+     * @param params - Input parameters passed by the caller.
+     * @returns Partial ExecutionResult without latency_ms.
+     */
+    execute(config: SkillConfig, params: Record<string, unknown>): Promise<Omit<ExecutionResult, 'latency_ms'>>;
+}
+
+/**
+ * Implements the Command Executor mode (Mode D) for the SkillExecutor.
+ *
+ * Wraps local shell commands as skills with:
+ * - Parameter substitution via `${params.x}` interpolation
+ * - Three output types: text (raw stdout), json (parsed), file (path from stdout)
+ * - Security allowlist via `allowed_commands` (base command checked against list)
+ * - Configurable timeout and working directory
+ */
+declare class CommandExecutor implements ExecutorMode {
+    /**
+     * Execute a command skill with the provided parameters.
+     *
+     * Steps:
+     * 1. Security check: base command must be in `allowed_commands` if set.
+     * 2. Interpolate `config.command` using `{ params }` context.
+     * 3. Run via `child_process.exec` with timeout and cwd.
+     * 4. Parse stdout based on `output_type`: text | json | file.
+     *
+     * @param config - Validated CommandSkillConfig.
+     * @param params - Input parameters passed by the caller.
+     * @returns Partial ExecutionResult (without latency_ms).
+     */
+    execute(config: SkillConfig, params: Record<string, unknown>): Promise<Omit<ExecutionResult, 'latency_ms'>>;
+}
+
+/**
+ * Resolves a dot-path expression (optionally with array index notation) against an object.
+ *
+ * Examples:
+ * - "name"           → obj.name
+ * - "a.b.c"          → obj.a.b.c
+ * - "steps[0].result" → obj.steps[0].result
+ *
+ * @param obj  - The root object to traverse.
+ * @param path - A dot-separated path string, supporting `[N]` array index notation.
+ * @returns The resolved value, or `undefined` if any segment is missing.
+ */
+declare function resolvePath(obj: unknown, path: string): unknown;
+/**
+ * Interpolates `${expression}` placeholders in a template string against a context object.
+ *
+ * - Resolves dot-path and array-index expressions against `context`.
+ * - Object values are JSON.stringify'd.
+ * - Missing paths resolve to empty string.
+ * - Non-string (number, boolean, etc.) values are converted via String().
+ *
+ * @param template - A string containing zero or more `${...}` expressions.
+ * @param context  - The object to resolve expressions against.
+ * @returns The interpolated string.
+ */
+declare function interpolate(template: string, context: Record<string, unknown>): string;
+/**
+ * Deep-walks an object and interpolates all string leaf values using the given context.
+ *
+ * Handles nested objects and arrays recursively. Non-string leaf values are preserved
+ * unchanged.
+ *
+ * @param obj     - The object whose string values should be interpolated.
+ * @param context - The interpolation context (same as `interpolate`).
+ * @returns A new object with all string leaves interpolated.
+ */
+declare function interpolateObject(obj: Record<string, unknown>, context: Record<string, unknown>): Record<string, unknown>;
+
+/**
+ * Shared types for the Conductor module — task decomposition, matching, budgeting, and orchestration.
+ */
+/**
+ * A single sub-task produced by the TaskDecomposer.
+ * Represents one step in a multi-step orchestration plan.
+ */
+interface SubTask {
+    /** Unique identifier for this sub-task (UUID). */
+    id: string;
+    /** Human-readable description of what this step does. */
+    description: string;
+    /** The capability category required to execute this step (e.g. 'tts', 'text_gen'). */
+    required_capability: string;
+    /** Parameters to pass to the executing agent's skill. */
+    params: Record<string, unknown>;
+    /** IDs of sub-tasks that must complete before this one can start. */
+    depends_on: string[];
+    /** Estimated credit cost for this step. */
+    estimated_credits: number;
+}
+/**
+ * Result of matching a SubTask to an available agent/skill.
+ */
+interface MatchResult {
+    /** ID of the sub-task this match is for. */
+    subtask_id: string;
+    /** Owner/agent ID of the selected peer. */
+    selected_agent: string;
+    /** Skill ID on the selected agent's card. */
+    selected_skill: string;
+    /** Match quality score (0-1). */
+    score: number;
+    /** Negotiated credit cost. */
+    credits: number;
+    /** Alternative matches considered. */
+    alternatives: Array<{
+        agent: string;
+        skill: string;
+        score: number;
+        credits: number;
+    }>;
+}
+/**
+ * Budget constraints for an orchestration run.
+ */
+interface ExecutionBudget {
+    /** Sum of all sub-task estimated_credits. */
+    estimated_total: number;
+    /** Hard ceiling — abort if exceeded. */
+    max_budget: number;
+    /** Credits retained by the Conductor for coordination. */
+    orchestration_fee: number;
+    /** Per-task actual spending tracker. */
+    per_task_spending: Map<string, number>;
+    /** Whether human/agent approval is needed before execution. */
+    requires_approval: boolean;
+}
+/**
+ * Final result of a completed orchestration.
+ */
+interface OrchestrationResult {
+    /** Whether all sub-tasks completed successfully. */
+    success: boolean;
+    /** Per-subtask output data, keyed by sub-task ID. */
+    results: Map<string, unknown>;
+    /** Total credits spent across all sub-tasks + orchestration fee. */
+    total_credits: number;
+    /** Wall-clock time from start to finish. */
+    latency_ms: number;
+    /** Error messages for failed sub-tasks. */
+    errors?: string[];
+}
+
+/**
+ * Template step definition used internally to generate SubTask instances.
+ */
+interface TemplateStep {
+    description: string;
+    required_capability: string;
+    estimated_credits: number;
+    /**
+     * Dependency indices — references to other steps in the same template (0-based).
+     * Converted to UUIDs at decomposition time.
+     */
+    depends_on_indices: number[];
+}
+/**
+ * A decomposition template: keyword triggers + ordered steps.
+ */
+interface Template {
+    keywords: readonly string[];
+    steps: readonly TemplateStep[];
+}
+/**
+ * Hardcoded decomposition templates for MVP.
+ *
+ * Each template maps keywords to a DAG of steps.
+ * Future versions will replace this with LLM-driven decomposition.
+ */
+declare const TEMPLATES: Readonly<Record<string, Template>>;
+/**
+ * Decomposes a natural-language task description into an ordered array of SubTasks
+ * using hardcoded keyword-matching templates.
+ *
+ * Returns the first matching template's steps as SubTask[], or an empty array
+ * if no template matches.
+ *
+ * @param task - Natural language task description.
+ * @param _availableCapabilities - Reserved for future filtering (unused in MVP).
+ * @returns Array of SubTask objects forming a dependency DAG.
+ */
+declare function decompose(task: string, _availableCapabilities?: string[]): SubTask[];
+
+/**
+ * CapabilityMatcher — finds the best agent for each sub-task using registry search + peer scoring.
+ *
+ * Wraps the existing searchCards() for card discovery and scorePeers() for ranked selection
+ * with self-exclusion. Returns alternatives for failover when the primary agent fails.
+ */
+
+/**
+ * Options for matchSubTasks.
+ */
+interface MatchOptions {
+    /** Open SQLite database with registry tables. */
+    db: Database.Database;
+    /** Sub-tasks to find agents for. */
+    subtasks: SubTask[];
+    /** Owner ID of the conductor agent — excluded from matches (self-exclusion). */
+    conductorOwner: string;
+}
+/**
+ * Finds the best agent for each sub-task using registry FTS search and peer scoring.
+ *
+ * For each sub-task:
+ * 1. Searches cards via FTS5 with `{ online: true }` filter
+ * 2. Builds Candidate[] from both v1.0 (card-level pricing) and v2.0 (skill-level pricing) cards
+ * 3. Scores and ranks candidates via scorePeers() with self-exclusion
+ * 4. Selects the top scorer as the primary agent and up to 2 alternatives
+ *
+ * Sub-tasks with no matching cards return a MatchResult with empty selected_agent and score 0.
+ *
+ * @param opts - Match configuration including database, subtasks, and conductor owner ID.
+ * @returns MatchResult[] in the same order as the input subtasks.
+ */
+declare function matchSubTasks(opts: MatchOptions): MatchResult[];
+
+/**
+ * Configuration for credit budget enforcement.
+ * Controls how many credits are kept in reserve and unavailable for auto-spending.
+ */
+interface BudgetConfig {
+    /** Minimum credits to keep in reserve. Auto-requests cannot reduce balance below this floor. Default: 20. */
+    reserve_credits: number;
+}
+/**
+ * Enforces credit reserve floors to prevent auto-request from draining balances to zero.
+ *
+ * Phase 7 auto-request MUST call canSpend() before every escrow hold.
+ * Without reserve enforcement, auto-request can drain credits to zero,
+ * isolating the agent from the network.
+ *
+ * @example
+ * ```typescript
+ * const budget = new BudgetManager(creditDb, config.owner, config.budget);
+ * if (!budget.canSpend(card.pricing.credits_per_call)) {
+ *   throw new AgentBnBError('Insufficient credits — reserve floor would be breached');
+ * }
+ * ```
+ */
+declare class BudgetManager {
+    private readonly creditDb;
+    private readonly owner;
+    private readonly config;
+    /**
+     * Creates a new BudgetManager.
+     *
+     * @param creditDb - The credit SQLite database instance.
+     * @param owner - Agent owner identifier.
+     * @param config - Budget configuration. Defaults to DEFAULT_BUDGET_CONFIG (20 credit reserve).
+     */
+    constructor(creditDb: Database.Database, owner: string, config?: BudgetConfig);
+    /**
+     * Returns the number of credits available for spending.
+     * Computed as: max(0, balance - reserve_credits).
+     * Always returns a non-negative number — never goes below zero.
+     *
+     * @returns Available credits (balance minus reserve, floored at 0).
+     */
+    availableCredits(): number;
+    /**
+     * Returns true if spending `amount` credits is permitted by budget rules.
+     *
+     * Rules:
+     * - Zero-cost calls (amount <= 0) always return true.
+     * - Any positive amount requires availableCredits() >= amount.
+     * - If balance is at or below the reserve floor, all positive-cost calls return false.
+     *
+     * @param amount - Number of credits to spend.
+     * @returns true if the spend is allowed, false if it would breach the reserve floor.
+     */
+    canSpend(amount: number): boolean;
+}
+
+/**
+ * BudgetController — pre-calculates orchestration cost and enforces spending limits.
+ *
+ * Extends BudgetManager to add orchestration-specific logic: fee calculation,
+ * approval gating when estimated cost exceeds max budget, and per-task spending tracking.
+ */
+
+/** Credits retained by the Conductor for coordination overhead. */
+declare const ORCHESTRATION_FEE = 5;
+/**
+ * Controls budget enforcement for orchestration runs.
+ *
+ * Wraps BudgetManager and adds:
+ * - Pre-calculation of total cost (sub-task credits + orchestration fee)
+ * - Approval gating when estimated total exceeds max budget
+ * - Reserve floor enforcement via BudgetManager.canSpend()
+ *
+ * @example
+ * ```typescript
+ * const controller = new BudgetController(budgetManager, 100);
+ * const budget = controller.calculateBudget(matchResults);
+ * if (controller.canExecute(budget)) {
+ *   // proceed with orchestration
+ * }
+ * ```
+ */
+declare class BudgetController {
+    private readonly budgetManager;
+    private readonly maxBudget;
+    /**
+     * Creates a new BudgetController.
+     *
+     * @param budgetManager - Underlying BudgetManager for reserve floor enforcement.
+     * @param maxBudget - Hard ceiling for the orchestration run.
+     */
+    constructor(budgetManager: BudgetManager, maxBudget: number);
+    /**
+     * Pre-calculates the total budget for an orchestration run.
+     *
+     * Sums all matched sub-task credits, adds the orchestration fee,
+     * and determines whether approval is required (estimated > max).
+     *
+     * @param matches - MatchResult[] from the CapabilityMatcher.
+     * @returns An ExecutionBudget with cost breakdown and approval status.
+     */
+    calculateBudget(matches: MatchResult[]): ExecutionBudget;
+    /**
+     * Checks whether orchestration can proceed without explicit approval.
+     *
+     * Returns true only when:
+     * 1. The budget does NOT require approval (estimated_total <= max_budget)
+     * 2. The BudgetManager confirms sufficient credits (respecting reserve floor)
+     *
+     * @param budget - ExecutionBudget from calculateBudget().
+     * @returns true if execution can proceed autonomously.
+     */
+    canExecute(budget: ExecutionBudget): boolean;
+    /**
+     * Checks budget after explicit user/agent approval.
+     *
+     * Ignores the requires_approval flag — used when the caller has already
+     * obtained explicit approval for the over-budget orchestration.
+     * Still enforces the reserve floor via BudgetManager.canSpend().
+     *
+     * @param budget - ExecutionBudget from calculateBudget().
+     * @returns true if the agent has sufficient credits (reserve floor check only).
+     */
+    approveAndCheck(budget: ExecutionBudget): boolean;
+}
+
+/** Fixed owner identifier for the Conductor agent. */
+declare const CONDUCTOR_OWNER = "agentbnb-conductor";
+/**
+ * Builds the Conductor's CapabilityCardV2.
+ *
+ * The Conductor exposes two skills:
+ * - `orchestrate` (5 cr): Decomposes and executes multi-agent tasks
+ * - `plan` (1 cr): Returns an execution plan with cost estimate only
+ *
+ * The returned card is validated against CapabilityCardV2Schema before return.
+ *
+ * @returns A valid CapabilityCardV2 for the Conductor.
+ */
+declare function buildConductorCard(): CapabilityCardV2;
+/**
+ * Registers the Conductor card in the given SQLite database.
+ *
+ * Idempotent: uses INSERT OR REPLACE to handle repeated calls gracefully.
+ * Stores the v2.0 card as JSON in the same `capability_cards` table used
+ * by the registry, following the same (id, owner, data, created_at, updated_at) schema.
+ *
+ * @param db - Open better-sqlite3 database instance (with migrations applied).
+ * @returns The registered CapabilityCardV2.
+ */
+declare function registerConductorCard(db: Database.Database): CapabilityCardV2;
+
+/**
+ * PipelineOrchestrator — DAG-based remote execution engine for the Conductor.
+ *
+ * Executes sub-tasks across remote agents via the Gateway client,
+ * respecting dependency ordering (parallel waves for independent tasks),
+ * output piping between steps, and retry with alternative agents on failure.
+ *
+ * Budget checking is NOT done here — the caller (ConductorMode) handles that.
+ * This module is pure execution.
+ */
+
+/**
+ * Options for the orchestrate() function.
+ */
+interface OrchestrateOptions {
+    /** Ordered list of sub-tasks forming a dependency DAG. */
+    subtasks: SubTask[];
+    /** Match results keyed by subtask ID. */
+    matches: Map<string, MatchResult>;
+    /** Bearer token for authenticating with remote agents. */
+    gatewayToken: string;
+    /** Resolves an agent owner to their gateway URL and card ID. */
+    resolveAgentUrl: (agentOwner: string) => {
+        url: string;
+        cardId: string;
+    };
+    /** Per-task timeout in milliseconds. Default 30000. */
+    timeoutMs?: number;
+    /** Maximum budget in credits. If set, aborts remaining tasks when exceeded. */
+    maxBudget?: number;
+}
+/**
+ * Executes a DAG of sub-tasks across remote agents via Gateway.
+ *
+ * Execution flow:
+ * 1. Computes execution waves from dependency graph
+ * 2. For each wave, executes all tasks in parallel via Promise.allSettled
+ * 3. Before each task, interpolates params against completed step outputs
+ * 4. On failure, retries with the first alternative agent from MatchResult
+ * 5. Tracks per-task spending and total credits
+ * 6. Optionally enforces a maxBudget ceiling
+ *
+ * @param opts - Orchestration options.
+ * @returns Aggregated orchestration result.
+ */
+declare function orchestrate(opts: OrchestrateOptions): Promise<OrchestrationResult>;
+
+/**
+ * ConductorMode — ExecutorMode implementation for Conductor skills.
+ *
+ * Chains TaskDecomposer -> CapabilityMatcher -> BudgetController -> PipelineOrchestrator
+ * to execute multi-agent orchestration pipelines via the SkillExecutor dispatch system.
+ *
+ * Supports two conductor skills:
+ * - `orchestrate`: Full pipeline — decompose, match, budget check, execute, return results.
+ * - `plan`: Planning only — decompose, match, budget check, return plan without executing.
+ */
+
+/**
+ * Configuration options for ConductorMode.
+ */
+interface ConductorModeOptions {
+    /** Registry database for card search (FTS5). */
+    db: Database.Database;
+    /** Credit database for budget checks. */
+    creditDb: Database.Database;
+    /** Owner ID of the conductor agent — used for self-exclusion in matching. */
+    conductorOwner: string;
+    /** Bearer token for authenticating with remote agents. */
+    gatewayToken: string;
+    /** Resolves an agent owner to their gateway URL and card ID. */
+    resolveAgentUrl: (owner: string) => {
+        url: string;
+        cardId: string;
+    };
+    /** Maximum budget in credits for orchestration runs. Default 100. */
+    maxBudget?: number;
+}
+/**
+ * ExecutorMode implementation for Conductor skills ('orchestrate' and 'plan').
+ *
+ * Dispatches through the full Conductor pipeline:
+ * 1. TaskDecomposer breaks the task into SubTasks
+ * 2. CapabilityMatcher finds agents for each sub-task
+ * 3. BudgetController validates cost against limits
+ * 4. PipelineOrchestrator executes the DAG (orchestrate only)
+ */
+declare class ConductorMode implements ExecutorMode {
+    private readonly db;
+    private readonly creditDb;
+    private readonly conductorOwner;
+    private readonly gatewayToken;
+    private readonly resolveAgentUrl;
+    private readonly maxBudget;
+    constructor(opts: ConductorModeOptions);
+    /**
+     * Execute a conductor skill with the given config and params.
+     *
+     * @param config - SkillConfig with type 'conductor' and conductor_skill field.
+     * @param params - Must include `task` string.
+     * @returns Execution result without latency_ms (added by SkillExecutor).
+     */
+    execute(config: SkillConfig, params: Record<string, unknown>): Promise<Omit<ExecutionResult, 'latency_ms'>>;
+}
+
+/**
+ * Ed25519 keypair as raw DER-encoded Buffers.
+ */
+interface KeyPair {
+    publicKey: Buffer;
+    privateKey: Buffer;
+}
+/**
+ * Generates a new Ed25519 keypair.
+ * Uses Node.js built-in crypto — no external dependencies.
+ *
+ * @returns Object with publicKey and privateKey as DER-encoded Buffers.
+ */
+declare function generateKeyPair(): KeyPair;
+/**
+ * Saves an Ed25519 keypair to disk.
+ * Private key is written with mode 0o600 (owner read/write only).
+ *
+ * @param configDir - Directory to write key files into.
+ * @param keys - The keypair to persist.
+ */
+declare function saveKeyPair(configDir: string, keys: KeyPair): void;
+/**
+ * Loads an Ed25519 keypair from disk.
+ *
+ * @param configDir - Directory containing private.key and public.key files.
+ * @returns The loaded keypair.
+ * @throws {AgentBnBError} with code 'KEYPAIR_NOT_FOUND' if either key file is missing.
+ */
+declare function loadKeyPair(configDir: string): KeyPair;
+/**
+ * Signs escrow receipt data with an Ed25519 private key.
+ * Data is serialized to canonical JSON (sorted keys) before signing.
+ *
+ * @param data - The receipt data to sign (all fields except 'signature').
+ * @param privateKey - DER-encoded Ed25519 private key.
+ * @returns Base64url-encoded signature string.
+ */
+declare function signEscrowReceipt(data: Record<string, unknown>, privateKey: Buffer): string;
+/**
+ * Verifies an Ed25519 signature over escrow receipt data.
+ * Returns false (does not throw) for invalid signatures or wrong keys.
+ *
+ * @param data - The receipt data that was signed (all fields except 'signature').
+ * @param signature - Base64url-encoded signature string.
+ * @param publicKey - DER-encoded Ed25519 public key.
+ * @returns true if signature is valid, false otherwise.
+ */
+declare function verifyEscrowReceipt(data: Record<string, unknown>, signature: string, publicKey: Buffer): boolean;
+
+/**
+ * Zod schema for validating EscrowReceipt objects.
+ * Used by providers to validate incoming receipts before verification.
+ */
+declare const EscrowReceiptSchema: z.ZodObject<{
+    requester_owner: z.ZodString;
+    requester_public_key: z.ZodString;
+    amount: z.ZodNumber;
+    card_id: z.ZodString;
+    skill_id: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodString;
+    nonce: z.ZodString;
+    signature: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    card_id: string;
+    signature: string;
+    requester_owner: string;
+    requester_public_key: string;
+    amount: number;
+    timestamp: string;
+    nonce: string;
+    skill_id?: string | undefined;
+}, {
+    card_id: string;
+    signature: string;
+    requester_owner: string;
+    requester_public_key: string;
+    amount: number;
+    timestamp: string;
+    nonce: string;
+    skill_id?: string | undefined;
+}>;
+/**
+ * Options for creating a signed escrow receipt.
+ */
+interface CreateReceiptOpts {
+    /** Agent owner identifier (requester). */
+    owner: string;
+    /** Number of credits to commit. */
+    amount: number;
+    /** Capability Card ID being requested. */
+    cardId: string;
+    /** Optional skill ID within the card. */
+    skillId?: string;
+}
+/**
+ * Creates a signed escrow receipt by atomically holding credits in the local DB
+ * and producing a cryptographically signed receipt that can be sent to a provider.
+ *
+ * This combines local escrow hold + receipt generation from the requester's perspective.
+ *
+ * @param db - The credit database instance.
+ * @param privateKey - DER-encoded Ed25519 private key for signing.
+ * @param publicKey - DER-encoded Ed25519 public key (included in receipt for verification).
+ * @param opts - Receipt creation options (owner, amount, cardId, skillId).
+ * @returns Object with escrowId (local reference) and signed receipt (for transmission).
+ * @throws {AgentBnBError} with code 'INSUFFICIENT_CREDITS' if balance is too low.
+ */
+declare function createSignedEscrowReceipt(db: Database.Database, privateKey: Buffer, publicKey: Buffer, opts: CreateReceiptOpts): {
+    escrowId: string;
+    receipt: EscrowReceipt;
+};
+
+/**
+ * Provider-side settlement: records earnings from a signed escrow receipt.
+ * The provider calls this after successfully executing a capability.
+ * Credits are recorded in the provider's own local DB.
+ *
+ * @param providerDb - The provider's local credit database.
+ * @param providerOwner - Provider agent identifier.
+ * @param receipt - The signed escrow receipt from the requester.
+ * @returns Object indicating settlement success.
+ */
+declare function settleProviderEarning(providerDb: Database.Database, providerOwner: string, receipt: EscrowReceipt): {
+    settled: true;
+};
+/**
+ * Requester-side settlement: confirms that the escrow debit is permanent.
+ * Called after the requester receives confirmation that the provider
+ * successfully executed the capability. Marks escrow as 'settled' without
+ * crediting anyone (credits stay deducted from requester).
+ *
+ * @param requesterDb - The requester's local credit database.
+ * @param escrowId - The escrow ID to confirm as settled.
+ */
+declare function settleRequesterEscrow(requesterDb: Database.Database, escrowId: string): void;
+/**
+ * Requester-side failure handling: releases escrowed credits (refund).
+ * Called when the capability execution fails and the requester needs
+ * their credits back.
+ *
+ * @param requesterDb - The requester's local credit database.
+ * @param escrowId - The escrow ID to release.
+ */
+declare function releaseRequesterEscrow(requesterDb: Database.Database, escrowId: string): void;
 
-export { type CapabilityCard, CapabilityCardSchema, createGatewayServer, getBalance, getCard, insertCard, openCreditDb, openDatabase, searchCards };
+export { ApiExecutor, type ApiSkillConfig, ApiSkillConfigSchema, BudgetController, CONDUCTOR_OWNER, type CapabilityCard, CapabilityCardSchema, CommandExecutor, type CommandSkillConfig, CommandSkillConfigSchema, ConductorMode, type ConductorModeOptions, type ConductorSkillConfig, ConductorSkillConfigSchema, type CreateReceiptOpts, type EscrowReceipt, EscrowReceiptSchema, type ExecutionBudget, type ExecutionResult, type ExecutorMode, type KeyPair, type MatchOptions, type MatchResult, ORCHESTRATION_FEE, OpenClawBridge, type OpenClawSkillConfig, OpenClawSkillConfigSchema, type OrchestrateOptions, type OrchestrationResult, PipelineExecutor, type PipelineSkillConfig, PipelineSkillConfigSchema, type SkillConfig, SkillConfigSchema, SkillExecutor, SkillsFileSchema, type SubTask, TEMPLATES, applyInputMapping, buildAuthHeaders, buildConductorCard, createGatewayServer, createSignedEscrowReceipt, createSkillExecutor, decompose, expandEnvVars, extractByPath, generateKeyPair, getBalance, getCard, insertCard, interpolate, interpolateObject, loadKeyPair, matchSubTasks, openCreditDb, openDatabase, orchestrate, parseSkillsFile, registerConductorCard, releaseRequesterEscrow, resolvePath, saveKeyPair, searchCards, settleProviderEarning, settleRequesterEscrow, signEscrowReceipt, verifyEscrowReceipt };