agentex-creator-sdk 1.0.0

package/dist/packages/contracts/src/workflow.d.ts

@@ -0,0 +1,1568 @@
+import { z } from 'zod';
+/**
+ * General creator workflows (`agentex.workflow.v1`). Kept outside index.ts so the fixed first-party manifests, their schemas
+ * and hashes stay byte-for-byte unchanged. A workflow is typed data: declared tools from the platform registry, typed bindings,
+ * deterministic conditions/transforms and report sections. Descriptive text never grants a capability; permissions are derived
+ * only from `tools`, `permissions`, `secrets` and `limits` and are enforced by runtime policy outside nodes.
+ */
+export declare const WORKFLOW_SCHEMA_ID: "agentex.workflow.v1";
+export declare const MODEL_PROVIDER_UNCONFIGURED = "AI analysis is not available on this server, so AI analysis steps stay switched off and no model is called.";
+/** L04: models a creator may select for an AI analysis node. Mirrors the priced server tariff table (packages/model MODEL_TARIFFS); others are refused. */
+export declare const WORKFLOW_ALLOWED_MODELS: readonly ["claude-opus-5", "claude-opus-4-8"];
+export declare const WorkflowChainKeySchema: z.ZodEnum<{
+    ethereum: "ethereum";
+    base: "base";
+    robinhood: "robinhood";
+    solana: "solana";
+}>;
+export type WorkflowChainKey = z.infer<typeof WorkflowChainKeySchema>;
+export declare const ToolCapabilitySchema: z.ZodEnum<{
+    "evm.read": "evm.read";
+    "http.read": "http.read";
+    "solana.read": "solana.read";
+}>;
+export type ToolCapability = z.infer<typeof ToolCapabilitySchema>;
+/** Methods a read capability may ever request. Signing, sending and account-management methods are absent by construction. */
+export declare const CAPABILITY_METHODS: Readonly<Record<ToolCapability, readonly string[]>>;
+export declare const WorkflowFieldSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        string: "string";
+        boolean: "boolean";
+        integer: "integer";
+        "evm-address": "evm-address";
+        "solana-address": "solana-address";
+    }>;
+    description: z.ZodString;
+    enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const WorkflowInputSchemaDefinition: z.ZodObject<{
+    type: z.ZodLiteral<"object">;
+    properties: z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<{
+            string: "string";
+            boolean: "boolean";
+            integer: "integer";
+            "evm-address": "evm-address";
+            "solana-address": "solana-address";
+        }>;
+        description: z.ZodString;
+        enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    required: z.ZodArray<z.ZodString>;
+    additionalProperties: z.ZodLiteral<false>;
+}, z.core.$strict>;
+export declare const WorkflowBindingSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    source: z.ZodLiteral<"input">;
+    path: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    source: z.ZodLiteral<"node">;
+    nodeId: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    source: z.ZodLiteral<"literal">;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+}, z.core.$strict>], "source">;
+export type WorkflowBinding = z.infer<typeof WorkflowBindingSchema>;
+export declare const ConditionOperatorSchema: z.ZodEnum<{
+    equals: "equals";
+    exists: "exists";
+    gt: "gt";
+    lt: "lt";
+    gte: "gte";
+    lte: "lte";
+}>;
+export type ConditionOperator = z.infer<typeof ConditionOperatorSchema>;
+export declare const TransformSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"pick">;
+    from: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"input">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"node">;
+        nodeId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"literal">;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>], "source">;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"compare">;
+    left: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"input">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"node">;
+        nodeId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"literal">;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>], "source">;
+    operator: z.ZodEnum<{
+        equals: "equals";
+        gt: "gt";
+        lt: "lt";
+        gte: "gte";
+        lte: "lte";
+    }>;
+    right: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"input">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"node">;
+        nodeId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"literal">;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>], "source">;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"threshold">;
+    value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"input">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"node">;
+        nodeId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"literal">;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>], "source">;
+    threshold: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"format-amount">;
+    amount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"input">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"node">;
+        nodeId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"literal">;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>], "source">;
+    decimals: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"input">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"node">;
+        nodeId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"literal">;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>], "source">;
+}, z.core.$strict>], "op">;
+export type WorkflowTransform = z.infer<typeof TransformSchema>;
+export declare const FindingValueTypeSchema: z.ZodEnum<{
+    string: "string";
+    boolean: "boolean";
+    address: "address";
+    integer: "integer";
+    decimal: "decimal";
+}>;
+export type FindingValueType = z.infer<typeof FindingValueTypeSchema>;
+export declare const WorkflowNodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"input">;
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    dependsOn: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"tool">;
+    tool: z.ZodString;
+    arguments: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"input">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"node">;
+        nodeId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"literal">;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>], "source">>;
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    dependsOn: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"condition">;
+    field: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"input">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"node">;
+        nodeId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"literal">;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>], "source">;
+    operator: z.ZodEnum<{
+        equals: "equals";
+        exists: "exists";
+        gt: "gt";
+        lt: "lt";
+        gte: "gte";
+        lte: "lte";
+    }>;
+    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    whenTrue: z.ZodNullable<z.ZodString>;
+    whenFalse: z.ZodNullable<z.ZodString>;
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    dependsOn: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"transform">;
+    transform: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        op: z.ZodLiteral<"pick">;
+        from: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"input">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"node">;
+            nodeId: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"literal">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>], "source">;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"compare">;
+        left: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"input">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"node">;
+            nodeId: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"literal">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>], "source">;
+        operator: z.ZodEnum<{
+            equals: "equals";
+            gt: "gt";
+            lt: "lt";
+            gte: "gte";
+            lte: "lte";
+        }>;
+        right: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"input">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"node">;
+            nodeId: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"literal">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>], "source">;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"threshold">;
+        value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"input">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"node">;
+            nodeId: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"literal">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>], "source">;
+        threshold: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"format-amount">;
+        amount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"input">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"node">;
+            nodeId: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"literal">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>], "source">;
+        decimals: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"input">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"node">;
+            nodeId: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"literal">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>], "source">;
+    }, z.core.$strict>], "op">;
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    dependsOn: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"report-section">;
+    section: z.ZodString;
+    findings: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"input">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"node">;
+            nodeId: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"literal">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>], "source">;
+    }, z.core.$strict>>;
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    dependsOn: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"ai-analysis">;
+    instructions: z.ZodString;
+    inputs: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"input">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"node">;
+        nodeId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"literal">;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>], "source">>;
+    maximumTokens: z.ZodNumber;
+    model: z.ZodOptional<z.ZodEnum<{
+        "claude-opus-5": "claude-opus-5";
+        "claude-opus-4-8": "claude-opus-4-8";
+    }>>;
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    dependsOn: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"output">;
+    sections: z.ZodArray<z.ZodString>;
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    dependsOn: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"sandboxed-transform">;
+    inputs: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"input">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"node">;
+        nodeId: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"literal">;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    }, z.core.$strict>], "source">>;
+    source: z.ZodString;
+    timeoutMs: z.ZodNumber;
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    dependsOn: z.ZodArray<z.ZodString>;
+}, z.core.$strict>], "type">;
+export type WorkflowNode = z.infer<typeof WorkflowNodeSchema>;
+export type WorkflowNodeType = WorkflowNode['type'];
+export declare const WorkflowToolDeclarationSchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodString;
+    capability: z.ZodEnum<{
+        "evm.read": "evm.read";
+        "http.read": "http.read";
+        "solana.read": "solana.read";
+    }>;
+    chains: z.ZodArray<z.ZodEnum<{
+        ethereum: "ethereum";
+        base: "base";
+        robinhood: "robinhood";
+        solana: "solana";
+    }>>;
+    maximumCalls: z.ZodNumber;
+}, z.core.$strict>;
+export type WorkflowToolDeclaration = z.infer<typeof WorkflowToolDeclarationSchema>;
+/**
+ * N03/N04: a reviewed remote connector pinned by the version. `id` is the alias tool nodes name, `schemaHash` the approved connector version's
+ * declaration hash, `maximumCalls` the per-run call ceiling and `maximumCostMicrousd` the per-run metered cost ceiling. Absent keeps existing
+ * manifests byte-identical. Connector nodes run only on servers with AGENTEX_CONNECTORS_ENABLED=true, through the connector gateway.
+ */
+export declare const WorkflowConnectorDeclarationSchema: z.ZodObject<{
+    id: z.ZodString;
+    connectorId: z.ZodUUID;
+    schemaHash: z.ZodString;
+    maximumCalls: z.ZodNumber;
+    maximumCostMicrousd: z.ZodNumber;
+}, z.core.$strict>;
+export type WorkflowConnectorDeclaration = z.infer<typeof WorkflowConnectorDeclarationSchema>;
+export declare const WORKFLOW_CONNECTOR_TOOL_VERSION: "1.0.0";
+/** Evidence and step tool reference of a connector node. Aliases never collide with declared tool ids. */
+export declare const connectorToolRef: (alias: string) => string;
+export declare const CONNECTOR_CALL_METHOD: "POST";
+export declare const CONNECTORS_DISABLED = "Remote connectors are switched off on this server, so workflows that declare connectors cannot be saved, versioned or run.";
+export declare const WorkflowOutputSchemaDefinition: z.ZodObject<{
+    sections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        required: z.ZodBoolean;
+        findings: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            label: z.ZodString;
+            valueType: z.ZodEnum<{
+                string: "string";
+                boolean: "boolean";
+                address: "address";
+                integer: "integer";
+                decimal: "decimal";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Hosted use, source viewing and fork permission are separate rights. Per-run fees pay for platform execution only. */
+export declare const WorkflowRightsSchema: z.ZodObject<{
+    hostedUse: z.ZodEnum<{
+        "owner-only": "owner-only";
+        "listed-buyers": "listed-buyers";
+    }>;
+    sourceView: z.ZodEnum<{
+        public: "public";
+        "owner-only": "owner-only";
+    }>;
+    fork: z.ZodEnum<{
+        "not-permitted": "not-permitted";
+        permitted: "permitted";
+        "permitted-with-attribution": "permitted-with-attribution";
+    }>;
+    attributionNotice: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type WorkflowRights = z.infer<typeof WorkflowRightsSchema>;
+export declare const AttributionSchema: z.ZodObject<{
+    sourceId: z.ZodString;
+    sourceVersionHash: z.ZodString;
+    author: z.ZodString;
+    license: z.ZodString;
+    notice: z.ZodString;
+}, z.core.$strict>;
+export declare const WorkflowManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    id: z.ZodString;
+    version: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    author: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        ownership: z.ZodEnum<{
+            "first-party": "first-party";
+            independent: "independent";
+        }>;
+    }, z.core.$strict>;
+    license: z.ZodString;
+    visibility: z.ZodEnum<{
+        private: "private";
+        "source-visible": "source-visible";
+        "source-private": "source-private";
+    }>;
+    rights: z.ZodObject<{
+        hostedUse: z.ZodEnum<{
+            "owner-only": "owner-only";
+            "listed-buyers": "listed-buyers";
+        }>;
+        sourceView: z.ZodEnum<{
+            public: "public";
+            "owner-only": "owner-only";
+        }>;
+        fork: z.ZodEnum<{
+            "not-permitted": "not-permitted";
+            permitted: "permitted";
+            "permitted-with-attribution": "permitted-with-attribution";
+        }>;
+        attributionNotice: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    attribution: z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        sourceVersionHash: z.ZodString;
+        author: z.ZodString;
+        license: z.ZodString;
+        notice: z.ZodString;
+    }, z.core.$strict>>;
+    chains: z.ZodArray<z.ZodEnum<{
+        ethereum: "ethereum";
+        base: "base";
+        robinhood: "robinhood";
+        solana: "solana";
+    }>>;
+    inputSchema: z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+        properties: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                boolean: "boolean";
+                integer: "integer";
+                "evm-address": "evm-address";
+                "solana-address": "solana-address";
+            }>;
+            description: z.ZodString;
+            enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        required: z.ZodArray<z.ZodString>;
+        additionalProperties: z.ZodLiteral<false>;
+    }, z.core.$strict>;
+    outputSchemaId: z.ZodLiteral<"agentex.workflow.v1">;
+    outputSchema: z.ZodObject<{
+        sections: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            required: z.ZodBoolean;
+            findings: z.ZodArray<z.ZodObject<{
+                code: z.ZodString;
+                label: z.ZodString;
+                valueType: z.ZodEnum<{
+                    string: "string";
+                    boolean: "boolean";
+                    address: "address";
+                    integer: "integer";
+                    decimal: "decimal";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    tools: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        capability: z.ZodEnum<{
+            "evm.read": "evm.read";
+            "http.read": "http.read";
+            "solana.read": "solana.read";
+        }>;
+        chains: z.ZodArray<z.ZodEnum<{
+            ethereum: "ethereum";
+            base: "base";
+            robinhood: "robinhood";
+            solana: "solana";
+        }>>;
+        maximumCalls: z.ZodNumber;
+    }, z.core.$strict>>;
+    connectors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        connectorId: z.ZodUUID;
+        schemaHash: z.ZodString;
+        maximumCalls: z.ZodNumber;
+        maximumCostMicrousd: z.ZodNumber;
+    }, z.core.$strict>>>;
+    permissions: z.ZodObject<{
+        addressScope: z.ZodEnum<{
+            "input-bound": "input-bound";
+            "input-derived": "input-derived";
+        }>;
+        domains: z.ZodArray<z.ZodString>;
+        destinations: z.ZodTuple<[z.ZodLiteral<"run-report">], null>;
+    }, z.core.$strict>;
+    modelPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"deterministic">;
+        maximumModelTokens: z.ZodLiteral<0>;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"bounded-model">;
+        maximumModelTokens: z.ZodNumber;
+        maximumCostMicrousd: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>], "mode">;
+    secrets: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        reference: z.ZodString;
+        purpose: z.ZodString;
+    }, z.core.$strict>>;
+    limits: z.ZodObject<{
+        maximumSteps: z.ZodNumber;
+        maximumRpcCalls: z.ZodNumber;
+        maximumDurationMs: z.ZodNumber;
+        stepTimeoutMs: z.ZodNumber;
+        maximumOutputBytes: z.ZodNumber;
+        maximumGraphDepth: z.ZodNumber;
+        maximumBlockRange: z.ZodNumber;
+        maximumPages: z.ZodNumber;
+        maximumExecutionAtomic: z.ZodString;
+    }, z.core.$strict>;
+    workflow: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"input">;
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        dependsOn: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"tool">;
+        tool: z.ZodString;
+        arguments: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"input">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"node">;
+            nodeId: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"literal">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>], "source">>;
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        dependsOn: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"condition">;
+        field: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"input">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"node">;
+            nodeId: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"literal">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>], "source">;
+        operator: z.ZodEnum<{
+            equals: "equals";
+            exists: "exists";
+            gt: "gt";
+            lt: "lt";
+            gte: "gte";
+            lte: "lte";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        whenTrue: z.ZodNullable<z.ZodString>;
+        whenFalse: z.ZodNullable<z.ZodString>;
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        dependsOn: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"transform">;
+        transform: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            op: z.ZodLiteral<"pick">;
+            from: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<"input">;
+                path: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"node">;
+                nodeId: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"literal">;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            }, z.core.$strict>], "source">;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"compare">;
+            left: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<"input">;
+                path: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"node">;
+                nodeId: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"literal">;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            }, z.core.$strict>], "source">;
+            operator: z.ZodEnum<{
+                equals: "equals";
+                gt: "gt";
+                lt: "lt";
+                gte: "gte";
+                lte: "lte";
+            }>;
+            right: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<"input">;
+                path: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"node">;
+                nodeId: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"literal">;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            }, z.core.$strict>], "source">;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"threshold">;
+            value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<"input">;
+                path: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"node">;
+                nodeId: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"literal">;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            }, z.core.$strict>], "source">;
+            threshold: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"format-amount">;
+            amount: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<"input">;
+                path: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"node">;
+                nodeId: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"literal">;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            }, z.core.$strict>], "source">;
+            decimals: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<"input">;
+                path: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"node">;
+                nodeId: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"literal">;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            }, z.core.$strict>], "source">;
+        }, z.core.$strict>], "op">;
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        dependsOn: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"report-section">;
+        section: z.ZodString;
+        findings: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<"input">;
+                path: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"node">;
+                nodeId: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"literal">;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            }, z.core.$strict>], "source">;
+        }, z.core.$strict>>;
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        dependsOn: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"ai-analysis">;
+        instructions: z.ZodString;
+        inputs: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"input">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"node">;
+            nodeId: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"literal">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>], "source">>;
+        maximumTokens: z.ZodNumber;
+        model: z.ZodOptional<z.ZodEnum<{
+            "claude-opus-5": "claude-opus-5";
+            "claude-opus-4-8": "claude-opus-4-8";
+        }>>;
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        dependsOn: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"output">;
+        sections: z.ZodArray<z.ZodString>;
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        dependsOn: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"sandboxed-transform">;
+        inputs: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"input">;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"node">;
+            nodeId: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            source: z.ZodLiteral<"literal">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>], "source">>;
+        source: z.ZodString;
+        timeoutMs: z.ZodNumber;
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        dependsOn: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>], "type">>;
+    sampleOutput: z.ZodArray<z.ZodObject<{
+        section: z.ZodString;
+        findings: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strict>>;
+    testCases: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        chain: z.ZodEnum<{
+            ethereum: "ethereum";
+            base: "base";
+            robinhood: "robinhood";
+            solana: "solana";
+        }>;
+        values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strict>>;
+    presentation: z.ZodOptional<z.ZodObject<{
+        archetype: z.ZodEnum<{
+            "token-protocol": "token-protocol";
+            "wallet-flow": "wallet-flow";
+            "contract-security": "contract-security";
+            "market-liquidity": "market-liquidity";
+            "governance-treasury": "governance-treasury";
+            "monitoring-events": "monitoring-events";
+        }>;
+        headline: z.ZodOptional<z.ZodObject<{
+            section: z.ZodString;
+            finding: z.ZodString;
+        }, z.core.$strict>>;
+        datasets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            node: z.ZodString;
+            path: z.ZodString;
+            columns: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                label: z.ZodString;
+                type: z.ZodEnum<{
+                    boolean: "boolean";
+                    address: "address";
+                    integer: "integer";
+                    label: "label";
+                    text: "text";
+                    amount: "amount";
+                    percent: "percent";
+                    block: "block";
+                    transaction: "transaction";
+                    time: "time";
+                }>;
+                path: z.ZodString;
+            }, z.core.$strict>>;
+            maxRows: z.ZodNumber;
+        }, z.core.$strict>>>;
+        signals: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        coverage: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            node: z.ZodString;
+            path: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strict>>>;
+        blocks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"metrics">;
+            title: z.ZodString;
+            items: z.ZodArray<z.ZodObject<{
+                section: z.ZodString;
+                finding: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"section">;
+            section: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"table">;
+            dataset: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"bars">;
+            dataset: z.ZodString;
+            label: z.ZodString;
+            value: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"timeline">;
+            dataset: z.ZodString;
+            at: z.ZodString;
+            label: z.ZodString;
+            detail: z.ZodOptional<z.ZodString>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"flow">;
+            dataset: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            amount: z.ZodOptional<z.ZodString>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"graph">;
+            dataset: z.ZodString;
+            to: z.ZodString;
+            relation: z.ZodOptional<z.ZodString>;
+            from: z.ZodOptional<z.ZodString>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"signals">;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"coverage">;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"limitations">;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "type">>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type WorkflowManifest = z.infer<typeof WorkflowManifestSchema>;
+export declare function workflowBindings(node: WorkflowNode): WorkflowBinding[];
+export declare const isWorkflowManifest: (manifest: unknown) => boolean;
+/** Exact decimal helpers. Never floating point: numbers are only accepted when they are safe integers or already exact finite literals. */
+export declare function isDecimal(value: unknown): value is string | number;
+/** Compares two exact decimals; returns -1, 0 or 1. */
+export declare function compareDecimal(left: string | number, right: string | number): -1 | 0 | 1;
+/** Formats an unsigned atomic integer with `decimals` places exactly, trimming only trailing fractional zeros. */
+export declare function formatExactAmount(atomic: string | number, decimals: number): string;
+export declare function findingValueMatches(value: unknown, type: FindingValueType): boolean;
+/** Run input envelope. `values` are validated against the pinned manifest's input schema by `parseWorkflowRunInput`. */
+export declare const WorkflowRunInputSchema: z.ZodObject<{
+    workflow: z.ZodLiteral<"agentex.workflow.v1">;
+    chain: z.ZodEnum<{
+        ethereum: "ethereum";
+        base: "base";
+        robinhood: "robinhood";
+        solana: "solana";
+    }>;
+    values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+}, z.core.$strict>;
+export type WorkflowRunInput = z.infer<typeof WorkflowRunInputSchema>;
+export declare function parseWorkflowRunInput(raw: unknown, manifest: WorkflowManifest): WorkflowRunInput;
+/**
+ * F02 evidence envelope produced by every registry tool. It mirrors `agentex.tool-evidence.v1` in packages/tools/src/evidence.ts,
+ * which owns construction (`makeToolEvidence`); keep both definitions identical. Ids derive from the artifact hash, so neither a
+ * tool, a node nor a model can invent or reuse one. Contracts keep a copy so reports validate without tool implementations.
+ */
+export declare const TOOL_EVIDENCE_VERSION: "agentex.tool-evidence.v1";
+export declare const ToolSnapshotSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"evm-block">;
+    chainId: z.ZodNumber;
+    blockNumber: z.ZodString;
+    blockHash: z.ZodString;
+    timestamp: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"solana-slot">;
+    genesisHash: z.ZodString;
+    slot: z.ZodString;
+    commitment: z.ZodEnum<{
+        finalized: "finalized";
+        confirmed: "confirmed";
+    }>;
+    exactness: z.ZodEnum<{
+        "observed-context": "observed-context";
+        "lower-bound": "lower-bound";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"http-retrieval">;
+    retrievedAt: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"offline-input">;
+    inputHash: z.ZodString;
+}, z.core.$strict>], "kind">;
+export declare const ToolEvidenceCompletenessSchema: z.ZodEnum<{
+    error: "error";
+    "complete-for-request": "complete-for-request";
+    unavailable: "unavailable";
+    truncated: "truncated";
+    "empty-result": "empty-result";
+}>;
+/** Canonicality is excluded: it is the only field a completion recheck may legitimately change. */
+export declare function toolArtifactHash(item: Record<string, unknown>): string;
+export declare const ToolEvidenceItemSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"agentex.tool-evidence.v1">;
+    id: z.ZodString;
+    tool: z.ZodString;
+    capability: z.ZodEnum<{
+        "evm.read": "evm.read";
+        "http.read": "http.read";
+        "solana.read": "solana.read";
+    }>;
+    source: z.ZodObject<{
+        kind: z.ZodEnum<{
+            rpc: "rpc";
+            http: "http";
+            offline: "offline";
+        }>;
+        provider: z.ZodString;
+        method: z.ZodString;
+        documentationUrl: z.ZodNullable<z.ZodURL>;
+    }, z.core.$strict>;
+    chain: z.ZodString;
+    scope: z.ZodObject<{
+        subjects: z.ZodArray<z.ZodString>;
+        window: z.ZodNullable<z.ZodObject<{
+            unit: z.ZodEnum<{
+                block: "block";
+                slot: "slot";
+            }>;
+            from: z.ZodString;
+            to: z.ZodString;
+        }, z.core.$strict>>;
+        page: z.ZodNullable<z.ZodObject<{
+            index: z.ZodNumber;
+            size: z.ZodNumber;
+            cursor: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    request: z.ZodJSONSchema;
+    snapshot: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"evm-block">;
+        chainId: z.ZodNumber;
+        blockNumber: z.ZodString;
+        blockHash: z.ZodString;
+        timestamp: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"solana-slot">;
+        genesisHash: z.ZodString;
+        slot: z.ZodString;
+        commitment: z.ZodEnum<{
+            finalized: "finalized";
+            confirmed: "confirmed";
+        }>;
+        exactness: z.ZodEnum<{
+            "observed-context": "observed-context";
+            "lower-bound": "lower-bound";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"http-retrieval">;
+        retrievedAt: z.ZodISODateTime;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"offline-input">;
+        inputHash: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    observedAt: z.ZodISODateTime;
+    finality: z.ZodEnum<{
+        finalized: "finalized";
+        "sequencer-confirmed": "sequencer-confirmed";
+        unverified: "unverified";
+        "not-applicable": "not-applicable";
+        confirmed: "confirmed";
+        "finalized-lower-bound": "finalized-lower-bound";
+        "confirmed-lower-bound": "confirmed-lower-bound";
+    }>;
+    canonicality: z.ZodEnum<{
+        "verified-at-completion": "verified-at-completion";
+        unchecked: "unchecked";
+        changed: "changed";
+        "not-applicable": "not-applicable";
+    }>;
+    completeness: z.ZodEnum<{
+        error: "error";
+        "complete-for-request": "complete-for-request";
+        unavailable: "unavailable";
+        truncated: "truncated";
+        "empty-result": "empty-result";
+    }>;
+    errorCategory: z.ZodNullable<z.ZodString>;
+    result: z.ZodJSONSchema;
+    contentHash: z.ZodString;
+    artifactHash: z.ZodString;
+    privacy: z.ZodEnum<{
+        "public-chain-data": "public-chain-data";
+        "public-web-content": "public-web-content";
+        "private-input": "private-input";
+    }>;
+    trust: z.ZodEnum<{
+        "chain-state": "chain-state";
+        "provider-assertion": "provider-assertion";
+        "untrusted-third-party-content": "untrusted-third-party-content";
+        "offline-decoding": "offline-decoding";
+    }>;
+}, z.core.$strict>;
+export type ToolEvidenceItem = z.infer<typeof ToolEvidenceItemSchema>;
+export declare const WorkflowErrorCategorySchema: z.ZodEnum<{
+    "no-contract": "no-contract";
+    "provider-unavailable": "provider-unavailable";
+    "history-unavailable": "history-unavailable";
+    "rate-limited": "rate-limited";
+    timeout: "timeout";
+    cancelled: "cancelled";
+    unsupported: "unsupported";
+    "contract-reverted": "contract-reverted";
+    "invalid-response": "invalid-response";
+    "chain-mismatch": "chain-mismatch";
+    "snapshot-changed": "snapshot-changed";
+    "limit-exceeded": "limit-exceeded";
+    unconfigured: "unconfigured";
+    "permission-denied": "permission-denied";
+    "invalid-arguments": "invalid-arguments";
+    "invalid-tool-output": "invalid-tool-output";
+    "invented-evidence": "invented-evidence";
+    "unregistered-tool": "unregistered-tool";
+    "model-unconfigured": "model-unconfigured";
+    "step-timeout": "step-timeout";
+    "condition-unknown": "condition-unknown";
+    "model-failed": "model-failed";
+    "sandbox-unavailable": "sandbox-unavailable";
+    "sandbox-failed": "sandbox-failed";
+}>;
+export type WorkflowErrorCategory = z.infer<typeof WorkflowErrorCategorySchema>;
+export declare const WorkflowStepSchema: z.ZodObject<{
+    nodeId: z.ZodString;
+    type: z.ZodEnum<{
+        output: "output";
+        input: "input";
+        transform: "transform";
+        tool: "tool";
+        condition: "condition";
+        "report-section": "report-section";
+        "ai-analysis": "ai-analysis";
+        "sandboxed-transform": "sandboxed-transform";
+    }>;
+    tool: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        skipped: "skipped";
+        failed: "failed";
+        disabled: "disabled";
+        succeeded: "succeeded";
+    }>;
+    reason: z.ZodNullable<z.ZodString>;
+    branch: z.ZodNullable<z.ZodEnum<{
+        unknown: "unknown";
+        false: "false";
+        true: "true";
+    }>>;
+    rpcCalls: z.ZodNumber;
+    evidenceIds: z.ZodArray<z.ZodString>;
+    elapsedMs: z.ZodNumber;
+}, z.core.$strict>;
+export declare const WorkflowReportSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"agentex.workflow.v1">;
+    agentVersion: z.ZodString;
+    manifestHash: z.ZodString;
+    input: z.ZodObject<{
+        workflow: z.ZodLiteral<"agentex.workflow.v1">;
+        chain: z.ZodEnum<{
+            ethereum: "ethereum";
+            base: "base";
+            robinhood: "robinhood";
+            solana: "solana";
+        }>;
+        values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strict>;
+    status: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+        failed: "failed";
+    }>;
+    generatedAt: z.ZodISODateTime;
+    requiredSections: z.ZodArray<z.ZodString>;
+    sections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        status: z.ZodEnum<{
+            skipped: "skipped";
+            complete: "complete";
+            partial: "partial";
+            failed: "failed";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+        findings: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            code: z.ZodString;
+            label: z.ZodString;
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            code: z.ZodString;
+            label: z.ZodString;
+            status: z.ZodLiteral<"from-input">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            code: z.ZodString;
+            label: z.ZodString;
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                "not-run": "not-run";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">>;
+    }, z.core.$strict>>;
+    steps: z.ZodArray<z.ZodObject<{
+        nodeId: z.ZodString;
+        type: z.ZodEnum<{
+            output: "output";
+            input: "input";
+            transform: "transform";
+            tool: "tool";
+            condition: "condition";
+            "report-section": "report-section";
+            "ai-analysis": "ai-analysis";
+            "sandboxed-transform": "sandboxed-transform";
+        }>;
+        tool: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            skipped: "skipped";
+            failed: "failed";
+            disabled: "disabled";
+            succeeded: "succeeded";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+        branch: z.ZodNullable<z.ZodEnum<{
+            unknown: "unknown";
+            false: "false";
+            true: "true";
+        }>>;
+        rpcCalls: z.ZodNumber;
+        evidenceIds: z.ZodArray<z.ZodString>;
+        elapsedMs: z.ZodNumber;
+    }, z.core.$strict>>;
+    evidence: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"agentex.tool-evidence.v1">;
+        id: z.ZodString;
+        tool: z.ZodString;
+        capability: z.ZodEnum<{
+            "evm.read": "evm.read";
+            "http.read": "http.read";
+            "solana.read": "solana.read";
+        }>;
+        source: z.ZodObject<{
+            kind: z.ZodEnum<{
+                rpc: "rpc";
+                http: "http";
+                offline: "offline";
+            }>;
+            provider: z.ZodString;
+            method: z.ZodString;
+            documentationUrl: z.ZodNullable<z.ZodURL>;
+        }, z.core.$strict>;
+        chain: z.ZodString;
+        scope: z.ZodObject<{
+            subjects: z.ZodArray<z.ZodString>;
+            window: z.ZodNullable<z.ZodObject<{
+                unit: z.ZodEnum<{
+                    block: "block";
+                    slot: "slot";
+                }>;
+                from: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strict>>;
+            page: z.ZodNullable<z.ZodObject<{
+                index: z.ZodNumber;
+                size: z.ZodNumber;
+                cursor: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        request: z.ZodJSONSchema;
+        snapshot: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"evm-block">;
+            chainId: z.ZodNumber;
+            blockNumber: z.ZodString;
+            blockHash: z.ZodString;
+            timestamp: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"solana-slot">;
+            genesisHash: z.ZodString;
+            slot: z.ZodString;
+            commitment: z.ZodEnum<{
+                finalized: "finalized";
+                confirmed: "confirmed";
+            }>;
+            exactness: z.ZodEnum<{
+                "observed-context": "observed-context";
+                "lower-bound": "lower-bound";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"http-retrieval">;
+            retrievedAt: z.ZodISODateTime;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"offline-input">;
+            inputHash: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+        observedAt: z.ZodISODateTime;
+        finality: z.ZodEnum<{
+            finalized: "finalized";
+            "sequencer-confirmed": "sequencer-confirmed";
+            unverified: "unverified";
+            "not-applicable": "not-applicable";
+            confirmed: "confirmed";
+            "finalized-lower-bound": "finalized-lower-bound";
+            "confirmed-lower-bound": "confirmed-lower-bound";
+        }>;
+        canonicality: z.ZodEnum<{
+            "verified-at-completion": "verified-at-completion";
+            unchecked: "unchecked";
+            changed: "changed";
+            "not-applicable": "not-applicable";
+        }>;
+        completeness: z.ZodEnum<{
+            error: "error";
+            "complete-for-request": "complete-for-request";
+            unavailable: "unavailable";
+            truncated: "truncated";
+            "empty-result": "empty-result";
+        }>;
+        errorCategory: z.ZodNullable<z.ZodString>;
+        result: z.ZodJSONSchema;
+        contentHash: z.ZodString;
+        artifactHash: z.ZodString;
+        privacy: z.ZodEnum<{
+            "public-chain-data": "public-chain-data";
+            "public-web-content": "public-web-content";
+            "private-input": "private-input";
+        }>;
+        trust: z.ZodEnum<{
+            "chain-state": "chain-state";
+            "provider-assertion": "provider-assertion";
+            "untrusted-third-party-content": "untrusted-third-party-content";
+            "offline-decoding": "offline-decoding";
+        }>;
+    }, z.core.$strict>>;
+    errors: z.ZodArray<z.ZodObject<{
+        category: z.ZodEnum<{
+            "no-contract": "no-contract";
+            "provider-unavailable": "provider-unavailable";
+            "history-unavailable": "history-unavailable";
+            "rate-limited": "rate-limited";
+            timeout: "timeout";
+            cancelled: "cancelled";
+            unsupported: "unsupported";
+            "contract-reverted": "contract-reverted";
+            "invalid-response": "invalid-response";
+            "chain-mismatch": "chain-mismatch";
+            "snapshot-changed": "snapshot-changed";
+            "limit-exceeded": "limit-exceeded";
+            unconfigured: "unconfigured";
+            "permission-denied": "permission-denied";
+            "invalid-arguments": "invalid-arguments";
+            "invalid-tool-output": "invalid-tool-output";
+            "invented-evidence": "invented-evidence";
+            "unregistered-tool": "unregistered-tool";
+            "model-unconfigured": "model-unconfigured";
+            "step-timeout": "step-timeout";
+            "condition-unknown": "condition-unknown";
+            "model-failed": "model-failed";
+            "sandbox-unavailable": "sandbox-unavailable";
+            "sandbox-failed": "sandbox-failed";
+        }>;
+        message: z.ZodString;
+        step: z.ZodString;
+        evidenceId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    limitations: z.ZodArray<z.ZodString>;
+    usage: z.ZodObject<{
+        rpcCalls: z.ZodNumber;
+        maximumRpcCalls: z.ZodNumber;
+        toolExecutions: z.ZodNumber;
+        elapsedMs: z.ZodNumber;
+        modelTokens: z.ZodNumber;
+        providerCostAtomic: z.ZodNull;
+        providerCostStatus: z.ZodLiteral<"unpriced">;
+        modelCostMicrousd: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    presentation: z.ZodOptional<z.ZodObject<{
+        archetype: z.ZodEnum<{
+            "token-protocol": "token-protocol";
+            "wallet-flow": "wallet-flow";
+            "contract-security": "contract-security";
+            "market-liquidity": "market-liquidity";
+            "governance-treasury": "governance-treasury";
+            "monitoring-events": "monitoring-events";
+        }>;
+        agentName: z.ZodOptional<z.ZodString>;
+        headline: z.ZodNullable<z.ZodObject<{
+            section: z.ZodString;
+            finding: z.ZodString;
+        }, z.core.$strict>>;
+        blocks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"metrics">;
+            title: z.ZodString;
+            items: z.ZodArray<z.ZodObject<{
+                section: z.ZodString;
+                finding: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"section">;
+            section: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"table">;
+            dataset: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"bars">;
+            dataset: z.ZodString;
+            label: z.ZodString;
+            value: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"timeline">;
+            dataset: z.ZodString;
+            at: z.ZodString;
+            label: z.ZodString;
+            detail: z.ZodOptional<z.ZodString>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"flow">;
+            dataset: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            amount: z.ZodOptional<z.ZodString>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"graph">;
+            dataset: z.ZodString;
+            to: z.ZodString;
+            relation: z.ZodOptional<z.ZodString>;
+            from: z.ZodOptional<z.ZodString>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"signals">;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"coverage">;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"limitations">;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "type">>;
+    }, z.core.$strict>>;
+    datasets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        node: z.ZodString;
+        status: z.ZodEnum<{
+            observed: "observed";
+            unavailable: "unavailable";
+            absent: "absent";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+        columns: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            type: z.ZodEnum<{
+                boolean: "boolean";
+                address: "address";
+                integer: "integer";
+                label: "label";
+                text: "text";
+                amount: "amount";
+                percent: "percent";
+                block: "block";
+                transaction: "transaction";
+                time: "time";
+            }>;
+        }, z.core.$strict>>;
+        rows: z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+        totalRows: z.ZodNumber;
+        truncated: z.ZodBoolean;
+        evidenceIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>>;
+    signals: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        node: z.ZodString;
+        code: z.ZodString;
+        message: z.ZodString;
+        evidenceIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>>;
+    coverage: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        node: z.ZodString;
+        label: z.ZodString;
+        status: z.ZodEnum<{
+            observed: "observed";
+            unavailable: "unavailable";
+            absent: "absent";
+        }>;
+        fromBlock: z.ZodNullable<z.ZodString>;
+        toBlock: z.ZodNullable<z.ZodString>;
+        blocks: z.ZodNullable<z.ZodNumber>;
+        requestedBlocks: z.ZodNullable<z.ZodNumber>;
+        complete: z.ZodNullable<z.ZodBoolean>;
+        reason: z.ZodNullable<z.ZodString>;
+        approximateDuration: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type WorkflowReport = z.infer<typeof WorkflowReportSchema>;
+/**
+ * Server execution capabilities, decided by platform configuration (never by a package). Omitted capabilities are unavailable,
+ * so every caller that does not pass them fails closed.
+ */
+export interface WorkflowRuntimeCapabilities {
+    modelAnalysis?: boolean;
+    sandboxedTransforms?: boolean; /** N03: reviewed remote connectors (AGENTEX_CONNECTORS_ENABLED=true). */
+    connectors?: boolean;
+}
+export declare const SANDBOX_UNAVAILABLE = "Custom code steps are not available on this server, so sandboxed transform steps stay switched off. Creator code only ever runs inside the isolated sandbox.";
+export declare const MODEL_MINIMUM_OUTPUT_TOKENS = 256;
+/** Effective permissions, derived only from typed fields and server capabilities. Listing text, names and descriptions are never consulted. */
+export declare function workflowPermissions(manifest: WorkflowManifest, capabilities?: WorkflowRuntimeCapabilities): {
+    capabilities: ("evm.read" | "http.read" | "solana.read")[];
+    chains: ("ethereum" | "base" | "robinhood" | "solana")[];
+    tools: {
+        ref: string;
+        capability: "evm.read" | "http.read" | "solana.read";
+        maximumCalls: number;
+        executions: number;
+    }[];
+    addressScope: "input-bound" | "input-derived";
+    addressInputs: string[];
+    domains: string[];
+    destinations: "run-report"[];
+    secrets: {
+        name: string;
+        reference: string;
+    }[];
+    budget: {
+        maximumRpcCalls: number;
+        maximumSteps: number;
+        maximumDurationMs: number;
+        stepTimeoutMs: number;
+        maximumBlockRange: number;
+        maximumPages: number;
+        maximumExecutionAtomic: string;
+        maximumModelTokens: number;
+    };
+    aiAnalysis: {
+        declared: number;
+        enabled: boolean;
+        tools: string[];
+        reason: string | null;
+    };
+    sandboxedTransforms: {
+        declared: number;
+        enabled: boolean;
+        network: "none";
+        reason: string | null;
+    };
+    connectors: {
+        alias: string;
+        connectorId: string;
+        schemaHash: string;
+        maximumCalls: number;
+        maximumCostMicrousd: number;
+        executions: number;
+        enabled: boolean;
+        reason: string;
+    }[];
+    signing: boolean;
+    broadcasting: boolean;
+};
+/** Worst-case RPC attempts: every tool execution at its declared ceiling, bounded by the workflow budget. Provider cost stays unpriced. */
+export declare function estimateWorkflowRpcCost(manifest: WorkflowManifest): {
+    steps: {
+        nodeId: string;
+        tool: string;
+        maximumCalls: number;
+    }[];
+    declaredMaximum: number;
+    maximumRpcCalls: number;
+    budgetBinding: boolean;
+    providerCostAtomic: null;
+    providerCostStatus: "unpriced";
+};
+/** Blocking reasons for creating an immutable test version or executing. Drafts may still contain disabled declarations. */
+export declare function workflowExecutionBlockers(manifest: WorkflowManifest, capabilities?: WorkflowRuntimeCapabilities): string[];
+/** Structured validation for editors: returns every issue with its JSON path, never throws. */
+export declare function validateWorkflowManifest(raw: unknown): {
+    ok: true;
+    manifest: WorkflowManifest;
+    issues: [];
+} | {
+    ok: false;
+    issues: {
+        path: string;
+        message: string;
+    }[];
+};
+/**
+ * Buyer result contract for workflow runs: a non-failed report bound to its manifest in which every required section is complete,
+ * every finding is observed (citing complete captured tool evidence) or taken from input, at least one finding is tool-observed,
+ * and no policy/integrity failure or disabled model step occurred. Returns the unmet conditions; an empty list satisfies it.
+ */
+export declare function workflowResultContractIssues(raw: unknown, manifest?: WorkflowManifest): string[];