agentex-creator-sdk 1.0.0

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

@@ -0,0 +1,1701 @@
+import { z } from 'zod';
+export declare const ChainKeySchema: z.ZodEnum<{
+    ethereum: "ethereum";
+    base: "base";
+    robinhood: "robinhood";
+}>;
+export type ChainKey = z.infer<typeof ChainKeySchema>;
+export declare const AddressSchema: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+export declare const AtomicAmountSchema: z.ZodString;
+export declare const AssetAmountSchema: z.ZodObject<{
+    chainId: z.ZodNumber;
+    asset: z.ZodUnion<readonly [z.ZodLiteral<"native">, z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>]>;
+    decimals: z.ZodNumber;
+    atomic: z.ZodString;
+}, z.core.$strict>;
+export declare const ResearchInputSchema: z.ZodObject<{
+    chain: z.ZodEnum<{
+        ethereum: "ethereum";
+        base: "base";
+        robinhood: "robinhood";
+    }>;
+    address: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+    scope: z.ZodDefault<z.ZodLiteral<"metadata-and-controls">>;
+    snapshotBlock: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ResearchInput = z.infer<typeof ResearchInputSchema>;
+export declare const ObjectSchemaDefinition: z.ZodObject<{
+    type: z.ZodLiteral<"object">;
+    properties: z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            array: "array";
+            integer: "integer";
+        }>;
+        description: z.ZodString;
+        enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    }, z.core.$strict>>;
+    required: z.ZodArray<z.ZodString>;
+    additionalProperties: z.ZodLiteral<false>;
+}, z.core.$strict>;
+export declare const WorkflowNodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"input">;
+    id: 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.ZodString;
+    }, z.core.$strict>], "source">>;
+    id: 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.ZodString;
+    }, z.core.$strict>], "source">;
+    operator: z.ZodEnum<{
+        equals: "equals";
+        exists: "exists";
+    }>;
+    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>;
+    whenTrue: z.ZodString;
+    whenFalse: z.ZodString;
+    id: z.ZodString;
+    dependsOn: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"output">;
+    from: z.ZodString;
+    id: z.ZodString;
+    dependsOn: z.ZodArray<z.ZodString>;
+}, z.core.$strict>], "type">;
+/** Output schema ids double as the explicit executable agent kind. Enum parsing keeps stored manifest hashes unchanged. */
+export declare const OutputSchemaIdSchema: z.ZodEnum<{
+    "agentex.token-research.v1": "agentex.token-research.v1";
+    "agentex.transaction-inspection.v1": "agentex.transaction-inspection.v1";
+    "agentex.watchtower-window.v1": "agentex.watchtower-window.v1";
+}>;
+export type OutputSchemaId = z.infer<typeof OutputSchemaIdSchema>;
+export declare const ResearchPolicySchema: z.ZodObject<{
+    readOwner: z.ZodBoolean;
+    readProxySlots: z.ZodBoolean;
+}, z.core.$strict>;
+export type ResearchPolicy = z.infer<typeof ResearchPolicySchema>;
+/**
+ * Token Researcher 0.3.0 market reads (P01): pools on listed venues by factory lookup, and balances of recent transfer recipients from an
+ * index. Absent: no market read, report section or hash change (0.1.0 and 0.2.0 manifests omit it). See token-market.ts.
+ */
+export declare const MarketPolicySchema: z.ZodObject<{
+    discoverPools: z.ZodBoolean;
+    recentHolderActivity: z.ZodBoolean;
+}, z.core.$strict>;
+export type MarketPolicy = z.infer<typeof MarketPolicySchema>;
+/**
+ * Optional bounded AI-assisted summary for Token Researcher manifests: one model request over evidence the deterministic reads already
+ * captured. Absent: the manifest hash, run behaviour and report shape are unchanged. The cost cap is the quoted model maximum in micro-USD.
+ */
+export declare const AnalysisPolicySchema: z.ZodObject<{
+    mode: z.ZodLiteral<"summary">;
+    maximumOutputTokens: z.ZodNumber;
+    maximumCostMicrousd: z.ZodNumber;
+}, z.core.$strict>;
+export type AnalysisPolicy = z.infer<typeof AnalysisPolicySchema>;
+export declare const ManifestPolicySchema: z.ZodObject<{
+    analysis: z.ZodObject<{
+        mode: z.ZodLiteral<"summary">;
+        maximumOutputTokens: z.ZodNumber;
+        maximumCostMicrousd: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const AgentManifestSchema: 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";
+    }>;
+    chains: z.ZodArray<z.ZodEnum<{
+        ethereum: "ethereum";
+        base: "base";
+        robinhood: "robinhood";
+    }>>;
+    inputSchema: z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+        properties: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                array: "array";
+                integer: "integer";
+            }>;
+            description: z.ZodString;
+            enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        }, z.core.$strict>>;
+        required: z.ZodArray<z.ZodString>;
+        additionalProperties: z.ZodLiteral<false>;
+    }, z.core.$strict>;
+    outputSchemaId: z.ZodEnum<{
+        "agentex.token-research.v1": "agentex.token-research.v1";
+        "agentex.transaction-inspection.v1": "agentex.transaction-inspection.v1";
+        "agentex.watchtower-window.v1": "agentex.watchtower-window.v1";
+    }>;
+    tools: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        capability: z.ZodLiteral<"evm.read">;
+        chains: z.ZodArray<z.ZodEnum<{
+            ethereum: "ethereum";
+            base: "base";
+            robinhood: "robinhood";
+        }>>;
+        addressScope: z.ZodEnum<{
+            "input-address": "input-address";
+            "input-transaction": "input-transaction";
+            "input-watch-scope": "input-watch-scope";
+        }>;
+        maximumCalls: z.ZodNumber;
+    }, z.core.$strict>>;
+    modelPolicy: z.ZodObject<{
+        mode: z.ZodLiteral<"deterministic">;
+        maximumModelTokens: z.ZodLiteral<0>;
+    }, z.core.$strict>;
+    researchPolicy: z.ZodOptional<z.ZodObject<{
+        readOwner: z.ZodBoolean;
+        readProxySlots: z.ZodBoolean;
+    }, z.core.$strict>>;
+    policy: z.ZodOptional<z.ZodObject<{
+        analysis: z.ZodObject<{
+            mode: z.ZodLiteral<"summary">;
+            maximumOutputTokens: z.ZodNumber;
+            maximumCostMicrousd: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    marketPolicy: z.ZodOptional<z.ZodObject<{
+        discoverPools: z.ZodBoolean;
+        recentHolderActivity: z.ZodBoolean;
+    }, z.core.$strict>>;
+    limits: z.ZodObject<{
+        maximumRpcCalls: z.ZodNumber;
+        maximumDurationMs: z.ZodNumber;
+        maximumOutputBytes: z.ZodNumber;
+        maximumGraphDepth: z.ZodNumber;
+        maximumPages: z.ZodLiteral<0>;
+        maximumExecutionAtomic: z.ZodString;
+    }, z.core.$strict>;
+    workflow: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"input">;
+        id: 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.ZodString;
+        }, z.core.$strict>], "source">>;
+        id: 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.ZodString;
+        }, z.core.$strict>], "source">;
+        operator: z.ZodEnum<{
+            equals: "equals";
+            exists: "exists";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>;
+        whenTrue: z.ZodString;
+        whenFalse: z.ZodString;
+        id: z.ZodString;
+        dependsOn: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"output">;
+        from: z.ZodString;
+        id: z.ZodString;
+        dependsOn: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>], "type">>;
+    testCases: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type AgentManifest = z.infer<typeof AgentManifestSchema>;
+export declare function canonicalJson(value: unknown): string;
+export declare const contentHash: (value: unknown) => string;
+export declare function publishManifest(input: unknown): {
+    manifest: {
+        schemaVersion: "1.0";
+        id: string;
+        version: string;
+        name: string;
+        description: string;
+        author: {
+            id: string;
+            name: string;
+            ownership: "first-party" | "independent";
+        };
+        license: string;
+        visibility: "private" | "source-visible" | "source-private";
+        chains: ("ethereum" | "base" | "robinhood")[];
+        inputSchema: {
+            type: "object";
+            properties: Record<string, {
+                type: "string" | "number" | "boolean" | "array" | "integer";
+                description: string;
+                enum?: (string | number | boolean)[] | undefined;
+            }>;
+            required: string[];
+            additionalProperties: false;
+        };
+        outputSchemaId: "agentex.token-research.v1" | "agentex.transaction-inspection.v1" | "agentex.watchtower-window.v1";
+        tools: {
+            id: string;
+            version: string;
+            capability: "evm.read";
+            chains: ("ethereum" | "base" | "robinhood")[];
+            addressScope: "input-address" | "input-transaction" | "input-watch-scope";
+            maximumCalls: number;
+        }[];
+        modelPolicy: {
+            mode: "deterministic";
+            maximumModelTokens: 0;
+        };
+        limits: {
+            maximumRpcCalls: number;
+            maximumDurationMs: number;
+            maximumOutputBytes: number;
+            maximumGraphDepth: number;
+            maximumPages: 0;
+            maximumExecutionAtomic: string;
+        };
+        workflow: ({
+            type: "input";
+            id: string;
+            dependsOn: string[];
+        } | {
+            type: "tool";
+            tool: string;
+            arguments: Record<string, {
+                source: "input";
+                path: string;
+            } | {
+                source: "node";
+                nodeId: string;
+                path: string;
+            }>;
+            id: string;
+            dependsOn: string[];
+        } | {
+            type: "condition";
+            field: {
+                source: "input";
+                path: string;
+            } | {
+                source: "node";
+                nodeId: string;
+                path: string;
+            };
+            operator: "equals" | "exists";
+            whenTrue: string;
+            whenFalse: string;
+            id: string;
+            dependsOn: string[];
+            value?: string | number | boolean | undefined;
+        } | {
+            type: "output";
+            from: string;
+            id: string;
+            dependsOn: string[];
+        })[];
+        testCases: string[];
+        researchPolicy?: {
+            readOwner: boolean;
+            readProxySlots: boolean;
+        } | undefined;
+        policy?: {
+            analysis: {
+                mode: "summary";
+                maximumOutputTokens: number;
+                maximumCostMicrousd: number;
+            };
+        } | undefined;
+        marketPolicy?: {
+            discoverPools: boolean;
+            recentHolderActivity: boolean;
+        } | undefined;
+    };
+    hash: string;
+};
+export declare const TOKEN_RESEARCHER_MANIFEST: {
+    schemaVersion: "1.0";
+    id: string;
+    version: string;
+    name: string;
+    description: string;
+    author: {
+        id: string;
+        name: string;
+        ownership: "first-party" | "independent";
+    };
+    license: string;
+    visibility: "private" | "source-visible" | "source-private";
+    chains: ("ethereum" | "base" | "robinhood")[];
+    inputSchema: {
+        type: "object";
+        properties: Record<string, {
+            type: "string" | "number" | "boolean" | "array" | "integer";
+            description: string;
+            enum?: (string | number | boolean)[] | undefined;
+        }>;
+        required: string[];
+        additionalProperties: false;
+    };
+    outputSchemaId: "agentex.token-research.v1" | "agentex.transaction-inspection.v1" | "agentex.watchtower-window.v1";
+    tools: {
+        id: string;
+        version: string;
+        capability: "evm.read";
+        chains: ("ethereum" | "base" | "robinhood")[];
+        addressScope: "input-address" | "input-transaction" | "input-watch-scope";
+        maximumCalls: number;
+    }[];
+    modelPolicy: {
+        mode: "deterministic";
+        maximumModelTokens: 0;
+    };
+    limits: {
+        maximumRpcCalls: number;
+        maximumDurationMs: number;
+        maximumOutputBytes: number;
+        maximumGraphDepth: number;
+        maximumPages: 0;
+        maximumExecutionAtomic: string;
+    };
+    workflow: ({
+        type: "input";
+        id: string;
+        dependsOn: string[];
+    } | {
+        type: "tool";
+        tool: string;
+        arguments: Record<string, {
+            source: "input";
+            path: string;
+        } | {
+            source: "node";
+            nodeId: string;
+            path: string;
+        }>;
+        id: string;
+        dependsOn: string[];
+    } | {
+        type: "condition";
+        field: {
+            source: "input";
+            path: string;
+        } | {
+            source: "node";
+            nodeId: string;
+            path: string;
+        };
+        operator: "equals" | "exists";
+        whenTrue: string;
+        whenFalse: string;
+        id: string;
+        dependsOn: string[];
+        value?: string | number | boolean | undefined;
+    } | {
+        type: "output";
+        from: string;
+        id: string;
+        dependsOn: string[];
+    })[];
+    testCases: string[];
+    researchPolicy?: {
+        readOwner: boolean;
+        readProxySlots: boolean;
+    } | undefined;
+    policy?: {
+        analysis: {
+            mode: "summary";
+            maximumOutputTokens: number;
+            maximumCostMicrousd: number;
+        };
+    } | undefined;
+    marketPolicy?: {
+        discoverPools: boolean;
+        recentHolderActivity: boolean;
+    } | undefined;
+};
+/**
+ * Token Researcher 0.2.0: the same workflow, tools, limits and output schema as 0.1.0, with buyer-visible text for the instant-read rule
+ * (latest block, sequencer-confirmed). 0.1.0 above stays byte-identical (hash 5784e6b0…) for stored versions, evidence and replay;
+ * new drafts, the SDK scaffold and `GET /v1/templates` start from 0.2.0.
+ */
+export declare const TOKEN_RESEARCHER_MANIFEST_V2: {
+    schemaVersion: "1.0";
+    id: string;
+    version: string;
+    name: string;
+    description: string;
+    author: {
+        id: string;
+        name: string;
+        ownership: "first-party" | "independent";
+    };
+    license: string;
+    visibility: "private" | "source-visible" | "source-private";
+    chains: ("ethereum" | "base" | "robinhood")[];
+    inputSchema: {
+        type: "object";
+        properties: Record<string, {
+            type: "string" | "number" | "boolean" | "array" | "integer";
+            description: string;
+            enum?: (string | number | boolean)[] | undefined;
+        }>;
+        required: string[];
+        additionalProperties: false;
+    };
+    outputSchemaId: "agentex.token-research.v1" | "agentex.transaction-inspection.v1" | "agentex.watchtower-window.v1";
+    tools: {
+        id: string;
+        version: string;
+        capability: "evm.read";
+        chains: ("ethereum" | "base" | "robinhood")[];
+        addressScope: "input-address" | "input-transaction" | "input-watch-scope";
+        maximumCalls: number;
+    }[];
+    modelPolicy: {
+        mode: "deterministic";
+        maximumModelTokens: 0;
+    };
+    limits: {
+        maximumRpcCalls: number;
+        maximumDurationMs: number;
+        maximumOutputBytes: number;
+        maximumGraphDepth: number;
+        maximumPages: 0;
+        maximumExecutionAtomic: string;
+    };
+    workflow: ({
+        type: "input";
+        id: string;
+        dependsOn: string[];
+    } | {
+        type: "tool";
+        tool: string;
+        arguments: Record<string, {
+            source: "input";
+            path: string;
+        } | {
+            source: "node";
+            nodeId: string;
+            path: string;
+        }>;
+        id: string;
+        dependsOn: string[];
+    } | {
+        type: "condition";
+        field: {
+            source: "input";
+            path: string;
+        } | {
+            source: "node";
+            nodeId: string;
+            path: string;
+        };
+        operator: "equals" | "exists";
+        whenTrue: string;
+        whenFalse: string;
+        id: string;
+        dependsOn: string[];
+        value?: string | number | boolean | undefined;
+    } | {
+        type: "output";
+        from: string;
+        id: string;
+        dependsOn: string[];
+    })[];
+    testCases: string[];
+    researchPolicy?: {
+        readOwner: boolean;
+        readProxySlots: boolean;
+    } | undefined;
+    policy?: {
+        analysis: {
+            mode: "summary";
+            maximumOutputTokens: number;
+            maximumCostMicrousd: number;
+        };
+    } | undefined;
+    marketPolicy?: {
+        discoverPools: boolean;
+        recentHolderActivity: boolean;
+    } | undefined;
+};
+/**
+ * Token Researcher 0.3.0 (P01): the 0.2.0 graph, tool and output schema across Ethereum, Base and Robinhood Chain, plus `marketPolicy`: pools on listed
+ * venues found by factory lookup with observed pool token balances, and current balances of recent transfer recipients from a provider index.
+ * 0.1.0 and 0.2.0 stay byte-identical. At most 15 reads at the latest block (16 with an explicit snapshot).
+ */
+export declare const TOKEN_RESEARCHER_MANIFEST_V3: {
+    schemaVersion: "1.0";
+    id: string;
+    version: string;
+    name: string;
+    description: string;
+    author: {
+        id: string;
+        name: string;
+        ownership: "first-party" | "independent";
+    };
+    license: string;
+    visibility: "private" | "source-visible" | "source-private";
+    chains: ("ethereum" | "base" | "robinhood")[];
+    inputSchema: {
+        type: "object";
+        properties: Record<string, {
+            type: "string" | "number" | "boolean" | "array" | "integer";
+            description: string;
+            enum?: (string | number | boolean)[] | undefined;
+        }>;
+        required: string[];
+        additionalProperties: false;
+    };
+    outputSchemaId: "agentex.token-research.v1" | "agentex.transaction-inspection.v1" | "agentex.watchtower-window.v1";
+    tools: {
+        id: string;
+        version: string;
+        capability: "evm.read";
+        chains: ("ethereum" | "base" | "robinhood")[];
+        addressScope: "input-address" | "input-transaction" | "input-watch-scope";
+        maximumCalls: number;
+    }[];
+    modelPolicy: {
+        mode: "deterministic";
+        maximumModelTokens: 0;
+    };
+    limits: {
+        maximumRpcCalls: number;
+        maximumDurationMs: number;
+        maximumOutputBytes: number;
+        maximumGraphDepth: number;
+        maximumPages: 0;
+        maximumExecutionAtomic: string;
+    };
+    workflow: ({
+        type: "input";
+        id: string;
+        dependsOn: string[];
+    } | {
+        type: "tool";
+        tool: string;
+        arguments: Record<string, {
+            source: "input";
+            path: string;
+        } | {
+            source: "node";
+            nodeId: string;
+            path: string;
+        }>;
+        id: string;
+        dependsOn: string[];
+    } | {
+        type: "condition";
+        field: {
+            source: "input";
+            path: string;
+        } | {
+            source: "node";
+            nodeId: string;
+            path: string;
+        };
+        operator: "equals" | "exists";
+        whenTrue: string;
+        whenFalse: string;
+        id: string;
+        dependsOn: string[];
+        value?: string | number | boolean | undefined;
+    } | {
+        type: "output";
+        from: string;
+        id: string;
+        dependsOn: string[];
+    })[];
+    testCases: string[];
+    researchPolicy?: {
+        readOwner: boolean;
+        readProxySlots: boolean;
+    } | undefined;
+    policy?: {
+        analysis: {
+            mode: "summary";
+            maximumOutputTokens: number;
+            maximumCostMicrousd: number;
+        };
+    } | undefined;
+    marketPolicy?: {
+        discoverPools: boolean;
+        recentHolderActivity: boolean;
+    } | undefined;
+};
+/** True when `inputSchema` equals one template version's input declaration with the manifest's own chains selected. */
+export declare function matchesTemplateInput(manifest: Pick<AgentManifest, 'inputSchema' | 'chains'>, templates: readonly Pick<AgentManifest, 'inputSchema'>[]): boolean;
+export declare function resolveResearchPolicy(manifest: Pick<AgentManifest, 'researchPolicy'>): Readonly<ResearchPolicy>;
+/** The validated AI-assisted summary policy, or null when the manifest declares none (or declares an invalid one). */
+export declare function resolveAnalysisPolicy(manifest: unknown): Readonly<AnalysisPolicy> | null;
+/** Pure quote helper: the maximum model spend a run of this manifest may incur, in micro-USD. 0 when no AI-assisted summary is declared. */
+export declare function analysisCostCap(manifest: unknown): number;
+/** Executable manifest subset shared by publication review and the actual researcher. */
+export declare const SupportedTokenResearcherManifestSchema: 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";
+    }>;
+    chains: z.ZodArray<z.ZodEnum<{
+        ethereum: "ethereum";
+        base: "base";
+        robinhood: "robinhood";
+    }>>;
+    inputSchema: z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+        properties: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                array: "array";
+                integer: "integer";
+            }>;
+            description: z.ZodString;
+            enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        }, z.core.$strict>>;
+        required: z.ZodArray<z.ZodString>;
+        additionalProperties: z.ZodLiteral<false>;
+    }, z.core.$strict>;
+    outputSchemaId: z.ZodEnum<{
+        "agentex.token-research.v1": "agentex.token-research.v1";
+        "agentex.transaction-inspection.v1": "agentex.transaction-inspection.v1";
+        "agentex.watchtower-window.v1": "agentex.watchtower-window.v1";
+    }>;
+    tools: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        capability: z.ZodLiteral<"evm.read">;
+        chains: z.ZodArray<z.ZodEnum<{
+            ethereum: "ethereum";
+            base: "base";
+            robinhood: "robinhood";
+        }>>;
+        addressScope: z.ZodEnum<{
+            "input-address": "input-address";
+            "input-transaction": "input-transaction";
+            "input-watch-scope": "input-watch-scope";
+        }>;
+        maximumCalls: z.ZodNumber;
+    }, z.core.$strict>>;
+    modelPolicy: z.ZodObject<{
+        mode: z.ZodLiteral<"deterministic">;
+        maximumModelTokens: z.ZodLiteral<0>;
+    }, z.core.$strict>;
+    researchPolicy: z.ZodOptional<z.ZodObject<{
+        readOwner: z.ZodBoolean;
+        readProxySlots: z.ZodBoolean;
+    }, z.core.$strict>>;
+    policy: z.ZodOptional<z.ZodObject<{
+        analysis: z.ZodObject<{
+            mode: z.ZodLiteral<"summary">;
+            maximumOutputTokens: z.ZodNumber;
+            maximumCostMicrousd: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    marketPolicy: z.ZodOptional<z.ZodObject<{
+        discoverPools: z.ZodBoolean;
+        recentHolderActivity: z.ZodBoolean;
+    }, z.core.$strict>>;
+    limits: z.ZodObject<{
+        maximumRpcCalls: z.ZodNumber;
+        maximumDurationMs: z.ZodNumber;
+        maximumOutputBytes: z.ZodNumber;
+        maximumGraphDepth: z.ZodNumber;
+        maximumPages: z.ZodLiteral<0>;
+        maximumExecutionAtomic: z.ZodString;
+    }, z.core.$strict>;
+    workflow: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"input">;
+        id: 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.ZodString;
+        }, z.core.$strict>], "source">>;
+        id: 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.ZodString;
+        }, z.core.$strict>], "source">;
+        operator: z.ZodEnum<{
+            equals: "equals";
+            exists: "exists";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>;
+        whenTrue: z.ZodString;
+        whenFalse: z.ZodString;
+        id: z.ZodString;
+        dependsOn: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"output">;
+        from: z.ZodString;
+        id: z.ZodString;
+        dependsOn: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>], "type">>;
+    testCases: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/** Nominal fresh-run RPC attempts. Provider failures may stop early; retry receipts stay charged. */
+export declare function getTokenResearcherRpcPlan(raw: unknown): Readonly<{
+    policy: Readonly<{
+        readOwner: boolean;
+        readProxySlots: boolean;
+    }>;
+    marketPolicy: {
+        discoverPools: boolean;
+        recentHolderActivity: boolean;
+    } | null;
+    latestSnapshotCalls: number;
+    explicitSnapshotCalls: number;
+    maximumRpcCalls: number;
+}>;
+export declare const FailureCategorySchema: 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";
+}>;
+export type FailureCategory = z.infer<typeof FailureCategorySchema>;
+export declare const ResearchErrorSchema: 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";
+    }>;
+    message: z.ZodString;
+    step: z.ZodString;
+    evidenceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** Shared EVM evidence envelope, bound to exactly one executor tool version. */
+export declare const evmEvidenceItemSchema: <Tool extends string>(tool: Tool) => z.ZodObject<{
+    id: z.ZodString;
+    tool: z.ZodLiteral<Tool>;
+    source: z.ZodObject<{
+        kind: z.ZodLiteral<"rpc">;
+        provider: z.ZodString;
+        method: z.ZodString;
+        documentationUrl: z.ZodURL;
+    }, z.core.$strict>;
+    chain: z.ZodEnum<{
+        ethereum: "ethereum";
+        base: "base";
+        robinhood: "robinhood";
+    }>;
+    chainId: z.ZodNumber;
+    request: z.ZodArray<z.ZodJSONSchema>;
+    snapshot: z.ZodNullable<z.ZodObject<{
+        blockNumber: z.ZodString;
+        blockHash: z.ZodString;
+    }, z.core.$strict>>;
+    observedAt: z.ZodISODateTime;
+    finality: z.ZodEnum<{
+        finalized: "finalized";
+        "sequencer-confirmed": "sequencer-confirmed";
+        unverified: "unverified";
+    }>;
+    canonicality: z.ZodEnum<{
+        "verified-at-completion": "verified-at-completion";
+        unchecked: "unchecked";
+        changed: "changed";
+    }>;
+    completeness: z.ZodEnum<{
+        error: "error";
+        "complete-for-request": "complete-for-request";
+    }>;
+    result: z.ZodJSONSchema;
+    contentHash: z.ZodString;
+    privacy: z.ZodLiteral<"public-chain-data">;
+}, z.core.$strict>;
+export declare const EvidenceItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    tool: z.ZodLiteral<"evm.inspect-token@0.1.0">;
+    source: z.ZodObject<{
+        kind: z.ZodLiteral<"rpc">;
+        provider: z.ZodString;
+        method: z.ZodString;
+        documentationUrl: z.ZodURL;
+    }, z.core.$strict>;
+    chain: z.ZodEnum<{
+        ethereum: "ethereum";
+        base: "base";
+        robinhood: "robinhood";
+    }>;
+    chainId: z.ZodNumber;
+    request: z.ZodArray<z.ZodJSONSchema>;
+    snapshot: z.ZodNullable<z.ZodObject<{
+        blockNumber: z.ZodString;
+        blockHash: z.ZodString;
+    }, z.core.$strict>>;
+    observedAt: z.ZodISODateTime;
+    finality: z.ZodEnum<{
+        finalized: "finalized";
+        "sequencer-confirmed": "sequencer-confirmed";
+        unverified: "unverified";
+    }>;
+    canonicality: z.ZodEnum<{
+        "verified-at-completion": "verified-at-completion";
+        unchecked: "unchecked";
+        changed: "changed";
+    }>;
+    completeness: z.ZodEnum<{
+        error: "error";
+        "complete-for-request": "complete-for-request";
+    }>;
+    result: z.ZodJSONSchema;
+    contentHash: z.ZodString;
+    privacy: z.ZodLiteral<"public-chain-data">;
+}, z.core.$strict>;
+export type EvidenceItem = z.infer<typeof EvidenceItemSchema>;
+export declare const ObservationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"observed">;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    evidenceIds: z.ZodArray<z.ZodString>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodEnum<{
+        error: "error";
+        unknown: "unknown";
+        unsupported: "unsupported";
+        "not-detected": "not-detected";
+        "not-applicable": "not-applicable";
+    }>;
+    reason: z.ZodString;
+    evidenceIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"skipped">;
+    reason: z.ZodString;
+    evidenceIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>], "status">;
+export type Observation = z.infer<typeof ObservationSchema>;
+export declare const ANALYSIS_LABEL = "AI-assisted summary";
+/** Model-written section, present only when the manifest declares policy.analysis. Deterministic observations are never part of it. */
+export declare const ResearchAnalysisSchema: z.ZodObject<{
+    label: z.ZodLiteral<"AI-assisted summary">;
+    status: z.ZodEnum<{
+        skipped: "skipped";
+        completed: "completed";
+        unavailable: "unavailable";
+    }>;
+    model: z.ZodString;
+    findings: z.ZodArray<z.ZodObject<{
+        claim: z.ZodString;
+        evidenceIds: z.ZodArray<z.ZodString>;
+        confidence: z.ZodEnum<{
+            supported: "supported";
+            uncertain: "uncertain";
+        }>;
+    }, z.core.$strict>>;
+    unavailableReason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ResearchAnalysis = z.infer<typeof ResearchAnalysisSchema>;
+/**
+ * Metered summary usage. `costStatus: 'unresolved'` means an earlier attempt sent the request but its usage was never recorded: `costMicrousd`
+ * is then the reserved worst case (an upper bound for settlement), not metered spend, and token counts are unknown (0). Absent: metered.
+ */
+export declare const ModelUsageSchema: z.ZodObject<{
+    model: z.ZodString;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    costMicrousd: z.ZodNumber;
+    costStatus: z.ZodOptional<z.ZodLiteral<"unresolved">>;
+}, z.core.$strict>;
+/**
+ * Token Researcher 0.3.0 market section. Every value is derived from captured receipts by `buildMarketSection` (token-market.ts). Pools are the
+ * listed venues' factory lookups only; recent recipients are an index page of recent transfers, never a holder list. No totals, prices or scores.
+ */
+export declare const TokenMarketSchema: z.ZodObject<{
+    pools: z.ZodObject<{
+        status: z.ZodEnum<{
+            error: "error";
+            unsupported: "unsupported";
+            observed: "observed";
+            skipped: "skipped";
+            "none-found": "none-found";
+            "not-read": "not-read";
+        }>;
+        reason: z.ZodString;
+        venuesChecked: z.ZodArray<z.ZodObject<{
+            lookup: z.ZodEnum<{
+                pool: "pool";
+                "no-pool": "no-pool";
+                "call-failed": "call-failed";
+            }>;
+            pool: z.ZodNullable<z.ZodString>;
+            venue: z.ZodString;
+            protocol: z.ZodEnum<{
+                "uniswap-v2": "uniswap-v2";
+                "uniswap-v3": "uniswap-v3";
+                aerodrome: "aerodrome";
+            }>;
+            factory: z.ZodString;
+            quoteToken: z.ZodString;
+            quoteSymbol: z.ZodString;
+            quoteDecimals: z.ZodNumber;
+            feeTier: z.ZodNullable<z.ZodNumber>;
+            stable: z.ZodNullable<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        pools: z.ZodArray<z.ZodObject<{
+            address: z.ZodString;
+            token0: z.ZodString;
+            tokenBalanceAtomic: z.ZodNullable<z.ZodString>;
+            quoteBalanceAtomic: z.ZodNullable<z.ZodString>;
+            reserve0Atomic: z.ZodNullable<z.ZodString>;
+            reserve1Atomic: z.ZodNullable<z.ZodString>;
+            sqrtPriceX96: z.ZodNullable<z.ZodString>;
+            tick: z.ZodNullable<z.ZodNumber>;
+            activeLiquidity: z.ZodNullable<z.ZodString>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            venue: z.ZodString;
+            protocol: z.ZodEnum<{
+                "uniswap-v2": "uniswap-v2";
+                "uniswap-v3": "uniswap-v3";
+                aerodrome: "aerodrome";
+            }>;
+            factory: z.ZodString;
+            quoteToken: z.ZodString;
+            quoteSymbol: z.ZodString;
+            quoteDecimals: z.ZodNumber;
+            feeTier: z.ZodNullable<z.ZodNumber>;
+            stable: z.ZodNullable<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        poolsFound: z.ZodNumber;
+        truncated: z.ZodBoolean;
+        evidenceIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    recentHolderActivity: z.ZodObject<{
+        status: z.ZodEnum<{
+            error: "error";
+            unsupported: "unsupported";
+            observed: "observed";
+            skipped: "skipped";
+            "none-found": "none-found";
+            "not-read": "not-read";
+        }>;
+        reason: z.ZodString;
+        basis: z.ZodLiteral<"recent-transfer-recipients-not-a-holder-list">;
+        transfersExamined: z.ZodNumber;
+        truncated: z.ZodBoolean;
+        accounts: z.ZodArray<z.ZodObject<{
+            address: z.ZodString;
+            latestReceiptBlock: z.ZodString;
+            balanceAtomic: z.ZodNullable<z.ZodString>;
+            isDiscoveredPool: z.ZodBoolean;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        evidenceIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    limitations: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type TokenMarket = z.infer<typeof TokenMarketSchema>;
+export declare const TokenResearchReportSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"agentex.token-research.v1">;
+    agentVersion: z.ZodString;
+    manifestHash: z.ZodString;
+    researchPolicy: z.ZodOptional<z.ZodObject<{
+        readOwner: z.ZodBoolean;
+        readProxySlots: z.ZodBoolean;
+    }, z.core.$strict>>;
+    marketPolicy: z.ZodOptional<z.ZodObject<{
+        discoverPools: z.ZodBoolean;
+        recentHolderActivity: z.ZodBoolean;
+    }, z.core.$strict>>;
+    market: z.ZodOptional<z.ZodObject<{
+        pools: z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unsupported: "unsupported";
+                observed: "observed";
+                skipped: "skipped";
+                "none-found": "none-found";
+                "not-read": "not-read";
+            }>;
+            reason: z.ZodString;
+            venuesChecked: z.ZodArray<z.ZodObject<{
+                lookup: z.ZodEnum<{
+                    pool: "pool";
+                    "no-pool": "no-pool";
+                    "call-failed": "call-failed";
+                }>;
+                pool: z.ZodNullable<z.ZodString>;
+                venue: z.ZodString;
+                protocol: z.ZodEnum<{
+                    "uniswap-v2": "uniswap-v2";
+                    "uniswap-v3": "uniswap-v3";
+                    aerodrome: "aerodrome";
+                }>;
+                factory: z.ZodString;
+                quoteToken: z.ZodString;
+                quoteSymbol: z.ZodString;
+                quoteDecimals: z.ZodNumber;
+                feeTier: z.ZodNullable<z.ZodNumber>;
+                stable: z.ZodNullable<z.ZodBoolean>;
+            }, z.core.$strict>>;
+            pools: z.ZodArray<z.ZodObject<{
+                address: z.ZodString;
+                token0: z.ZodString;
+                tokenBalanceAtomic: z.ZodNullable<z.ZodString>;
+                quoteBalanceAtomic: z.ZodNullable<z.ZodString>;
+                reserve0Atomic: z.ZodNullable<z.ZodString>;
+                reserve1Atomic: z.ZodNullable<z.ZodString>;
+                sqrtPriceX96: z.ZodNullable<z.ZodString>;
+                tick: z.ZodNullable<z.ZodNumber>;
+                activeLiquidity: z.ZodNullable<z.ZodString>;
+                evidenceIds: z.ZodArray<z.ZodString>;
+                venue: z.ZodString;
+                protocol: z.ZodEnum<{
+                    "uniswap-v2": "uniswap-v2";
+                    "uniswap-v3": "uniswap-v3";
+                    aerodrome: "aerodrome";
+                }>;
+                factory: z.ZodString;
+                quoteToken: z.ZodString;
+                quoteSymbol: z.ZodString;
+                quoteDecimals: z.ZodNumber;
+                feeTier: z.ZodNullable<z.ZodNumber>;
+                stable: z.ZodNullable<z.ZodBoolean>;
+            }, z.core.$strict>>;
+            poolsFound: z.ZodNumber;
+            truncated: z.ZodBoolean;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        recentHolderActivity: z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unsupported: "unsupported";
+                observed: "observed";
+                skipped: "skipped";
+                "none-found": "none-found";
+                "not-read": "not-read";
+            }>;
+            reason: z.ZodString;
+            basis: z.ZodLiteral<"recent-transfer-recipients-not-a-holder-list">;
+            transfersExamined: z.ZodNumber;
+            truncated: z.ZodBoolean;
+            accounts: z.ZodArray<z.ZodObject<{
+                address: z.ZodString;
+                latestReceiptBlock: z.ZodString;
+                balanceAtomic: z.ZodNullable<z.ZodString>;
+                isDiscoveredPool: z.ZodBoolean;
+                evidenceIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        limitations: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    input: z.ZodObject<{
+        chain: z.ZodEnum<{
+            ethereum: "ethereum";
+            base: "base";
+            robinhood: "robinhood";
+        }>;
+        address: z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>;
+        scope: z.ZodDefault<z.ZodLiteral<"metadata-and-controls">>;
+        snapshotBlock: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    status: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+        failed: "failed";
+    }>;
+    generatedAt: z.ZodISODateTime;
+    chainId: z.ZodNullable<z.ZodNumber>;
+    snapshot: z.ZodNullable<z.ZodObject<{
+        blockNumber: z.ZodString;
+        blockHash: z.ZodString;
+        timestamp: z.ZodString;
+        finality: z.ZodEnum<{
+            finalized: "finalized";
+            "sequencer-confirmed": "sequencer-confirmed";
+        }>;
+        canonicality: z.ZodEnum<{
+            "verified-at-completion": "verified-at-completion";
+            unchecked: "unchecked";
+            changed: "changed";
+        }>;
+    }, z.core.$strict>>;
+    metadata: z.ZodObject<{
+        name: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        symbol: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        decimals: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        totalSupplyAtomic: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        totalSupplyFormatted: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+    }, z.core.$strict>;
+    contract: z.ZodObject<{
+        codePresent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        codeHash: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        sourceVerification: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+    }, z.core.$strict>;
+    controls: z.ZodObject<{
+        implementation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        admin: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        beacon: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        owner: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        mintAuthority: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        freezeAuthority: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        upgradeability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+    }, z.core.$strict>;
+    coverage: z.ZodObject<{
+        holders: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        liquidity: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        deployment: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+        historicalActivity: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"observed">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                unknown: "unknown";
+                unsupported: "unsupported";
+                "not-detected": "not-detected";
+                "not-applicable": "not-applicable";
+            }>;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"skipped">;
+            reason: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "status">;
+    }, z.core.$strict>;
+    findings: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        evidenceIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    limitations: z.ZodArray<z.ZodString>;
+    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";
+        }>;
+        message: z.ZodString;
+        step: z.ZodString;
+        evidenceId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    evidence: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tool: z.ZodLiteral<"evm.inspect-token@0.1.0">;
+        source: z.ZodObject<{
+            kind: z.ZodLiteral<"rpc">;
+            provider: z.ZodString;
+            method: z.ZodString;
+            documentationUrl: z.ZodURL;
+        }, z.core.$strict>;
+        chain: z.ZodEnum<{
+            ethereum: "ethereum";
+            base: "base";
+            robinhood: "robinhood";
+        }>;
+        chainId: z.ZodNumber;
+        request: z.ZodArray<z.ZodJSONSchema>;
+        snapshot: z.ZodNullable<z.ZodObject<{
+            blockNumber: z.ZodString;
+            blockHash: z.ZodString;
+        }, z.core.$strict>>;
+        observedAt: z.ZodISODateTime;
+        finality: z.ZodEnum<{
+            finalized: "finalized";
+            "sequencer-confirmed": "sequencer-confirmed";
+            unverified: "unverified";
+        }>;
+        canonicality: z.ZodEnum<{
+            "verified-at-completion": "verified-at-completion";
+            unchecked: "unchecked";
+            changed: "changed";
+        }>;
+        completeness: z.ZodEnum<{
+            error: "error";
+            "complete-for-request": "complete-for-request";
+        }>;
+        result: z.ZodJSONSchema;
+        contentHash: z.ZodString;
+        privacy: z.ZodLiteral<"public-chain-data">;
+    }, z.core.$strict>>;
+    analysis: z.ZodOptional<z.ZodObject<{
+        label: z.ZodLiteral<"AI-assisted summary">;
+        status: z.ZodEnum<{
+            skipped: "skipped";
+            completed: "completed";
+            unavailable: "unavailable";
+        }>;
+        model: z.ZodString;
+        findings: z.ZodArray<z.ZodObject<{
+            claim: z.ZodString;
+            evidenceIds: z.ZodArray<z.ZodString>;
+            confidence: z.ZodEnum<{
+                supported: "supported";
+                uncertain: "uncertain";
+            }>;
+        }, z.core.$strict>>;
+        unavailableReason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    usage: z.ZodObject<{
+        rpcCalls: z.ZodNumber;
+        maximumRpcCalls: z.ZodNumber;
+        elapsedMs: z.ZodNumber;
+        modelTokens: z.ZodLiteral<0>;
+        providerCostAtomic: z.ZodNull;
+        providerCostStatus: z.ZodLiteral<"unpriced">;
+        model: z.ZodOptional<z.ZodObject<{
+            model: z.ZodString;
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            costMicrousd: z.ZodNumber;
+            costStatus: z.ZodOptional<z.ZodLiteral<"unresolved">>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type TokenResearchReport = z.infer<typeof TokenResearchReportSchema>;