agentex-creator-sdk 1.0.0

package/dist/packages/contracts/src/indexed-activity.js

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+/**
+ * Shared output shapes of the indexed activity tools (packages/tools `evm.contract-origin`, `evm.address-funding`, `evm.deployer-launches`,
+ * `evm.wallet-activity`) and of the reports that embed them (P02 Deployer Investigator, P03 Wallet Analyst). They live here so report
+ * contracts validate without tool implementations and the two can never drift.
+ */
+export const ACTIVITY_TOOL_REFS = Object.freeze({ origin: 'evm.contract-origin@0.1.0', funding: 'evm.address-funding@0.1.0', launches: 'evm.deployer-launches@0.1.0', wallet: 'evm.wallet-activity@0.1.0' });
+// R02: `debug_traceTransaction` (fixed prestate-diff tracer) verifies a contract's creation inside its transaction and names the contract that ran the CREATE.
+export const ACTIVITY_READ_METHODS = Object.freeze(['eth_chainId', 'eth_getBlockByNumber', 'eth_getCode', 'eth_getBalance', 'eth_getTransactionReceipt', 'alchemy_getAssetTransfers', 'alchemy_getTokenBalances', 'alchemy_getTokenMetadata', 'debug_traceTransaction']);
+const Exact = z.string().regex(/^(0|[1-9][0-9]{0,77})$/);
+const Hex32 = z.string().regex(/^0x[a-fA-F0-9]{64}$/);
+const Address = z.string().regex(/^0x[a-fA-F0-9]{40}$/);
+export const ActivityEvidenceIdSchema = z.string().regex(/^ev-[a-f0-9]{32}$/, 'Evidence ids are content-derived (ev- and 32 hex characters).');
+/** Same vocabulary as the tools' `FactSchema`: unknown, unavailable (no source), not-detected (probed and empty) and error are never collapsed. */
+export const ActivityFactSchema = z.discriminatedUnion('status', [
+    z.strictObject({ status: z.literal('observed'), value: z.union([z.string().max(4096), z.number(), z.boolean(), z.null()]), evidenceIds: z.array(ActivityEvidenceIdSchema).min(1), note: z.string().max(500).optional() }),
+    z.strictObject({ status: z.enum(['not-detected', 'unknown', 'unavailable', 'error', 'not-applicable']), reason: z.string().min(1).max(500), evidenceIds: z.array(ActivityEvidenceIdSchema) }),
+]);
+export const ActivityToolErrorSchema = z.strictObject({ category: z.string().regex(/^[a-z][a-z-]{1,63}$/), step: z.string().min(1).max(64), evidenceId: ActivityEvidenceIdSchema.nullable() });
+/** `direct-transaction-evidence`: a receipt, archive state or transaction field states it. `heuristic-association`: an inference such as an event naming an address. */
+export const ActivityFindingSchema = z.strictObject({ code: z.string().regex(/^[a-z][a-z0-9-]{1,63}$/), message: z.string().max(1000), basis: z.enum(['direct-transaction-evidence', 'heuristic-association', 'provider-index-assertion']), evidenceIds: z.array(ActivityEvidenceIdSchema) });
+const Errors = z.array(ActivityToolErrorSchema).max(24);
+const Findings = z.array(ActivityFindingSchema).max(32);
+export const ACTIVITY_CATEGORIES = ['external', 'internal', 'erc20', 'erc721', 'erc1155'];
+export const ActivityCategorySchema = z.enum(ACTIVITY_CATEGORIES);
+export const ActivityTransferSchema = z.strictObject({
+    direction: z.enum(['in', 'out']), category: ActivityCategorySchema, blockNumber: Exact, blockTimestamp: z.string().max(40).nullable(), transactionHash: Hex32, uniqueId: z.string().max(128),
+    from: Address, to: Address.nullable(), asset: z.string().max(64).nullable(), contract: Address.nullable(), tokenId: z.string().max(80).nullable(),
+    valueAtomic: Exact.nullable(), decimals: z.number().int().min(0).max(255).nullable(), valueFormatted: z.string().max(340).nullable(),
+    decimalsSource: z.enum(['native-18', 'provider-raw-contract', 'not-applicable', 'not-reported']), selfTransfer: z.boolean(), evidenceId: ActivityEvidenceIdSchema,
+});
+export const TransferPageStatusSchema = z.enum(['provider-exhausted', 'truncated-with-cursor', 'unavailable', 'not-read-call-bound']);
+export const TransferPageSchema = z.strictObject({ direction: z.enum(['in', 'out']), index: z.number().int().min(0).max(4), returned: z.number().int().nonnegative(), nextPageKey: z.string().max(256).nullable(), status: TransferPageStatusSchema, evidenceId: ActivityEvidenceIdSchema.nullable() });
+const OriginRoleSchema = z.strictObject({ address: Address, role: z.enum(['deployment-transaction-sender', 'creation-entry-target', 'factory-event-emitter', 'erc4337-entrypoint', 'trace-verified-creator', 'creation-candidate']), isPerson: z.literal(false), label: z.string().max(100).nullable(), basis: z.string().max(400), evidenceIds: z.array(ActivityEvidenceIdSchema) });
+export const ContractOriginBodySchema = z.strictObject({
+    contract: Address, chain: z.string(), codeAtSnapshot: ActivityFactSchema,
+    creation: z.strictObject({
+        status: z.enum(['confirmed-by-receipt', 'block-located', 'bounded-range', 'not-located', 'no-code-at-snapshot', 'unavailable']),
+        blockNumber: ActivityFactSchema, transactionHash: ActivityFactSchema, transactionBasis: z.enum(['receipt-contract-address', 'trace-verified-creation', 'first-indexed-activity-in-creation-block', 'not-established']),
+        createdBy: z.enum(['top-level-transaction', 'contract-call-in-transaction', 'not-established']),
+        anchor: z.strictObject({ source: z.enum(['supplied-transaction', 'first-indexed-token-transfer', 'first-indexed-inbound-call', 'none']), transactionHash: Hex32.nullable(), blockNumber: Exact.nullable(), evidenceIds: z.array(ActivityEvidenceIdSchema) }),
+        range: z.strictObject({ from: Exact, to: Exact }).nullable(), probes: z.number().int().min(0).max(8), codeBeforeCreation: ActivityFactSchema, codeAtCreationBlock: ActivityFactSchema,
+    }),
+    initiator: ActivityFactSchema, entryTarget: ActivityFactSchema, factoryEventEmitters: z.array(z.strictObject({ address: Address, label: z.string().max(100).nullable(), evidenceIds: z.array(ActivityEvidenceIdSchema).min(1) })).max(4),
+    roles: z.array(OriginRoleSchema).max(8), findings: Findings, errors: Errors,
+});
+const FunderSchema = z.strictObject({ funder: Address, label: z.string().max(100).nullable(), isPerson: z.literal(false), transfers: z.number().int().positive(), nativeAtomic: Exact, nativeFormatted: z.string().max(120), tokenTransfers: z.number().int().nonnegative(),
+    firstBlock: Exact, firstTransactionHash: Hex32, evidenceIds: z.array(ActivityEvidenceIdSchema).min(1) });
+export const AddressFundingBodySchema = z.strictObject({
+    address: Address, chain: z.string(), transfers: z.array(ActivityTransferSchema).max(100), funders: z.array(FunderSchema).max(100), pages: z.array(TransferPageSchema).max(4),
+    coverage: z.strictObject({ order: z.literal('oldest-first'), categories: z.array(ActivityCategorySchema), exhausted: z.boolean(), nextPageKey: z.string().max(256).nullable(), completeness: z.literal('provider-index-claim') }),
+    interpretation: z.literal('observed-transfer-not-ownership'), findings: Findings, errors: Errors,
+});
+const DeploymentSchema = z.strictObject({ transactionHash: Hex32, blockNumber: Exact, blockTimestamp: z.string().max(40).nullable(), contractAddress: ActivityFactSchema, succeeded: ActivityFactSchema, isSubject: z.boolean(), evidenceIds: z.array(ActivityEvidenceIdSchema).min(1) });
+export const DeployerLaunchesBodySchema = z.strictObject({
+    deployer: Address, chain: z.string(), window: z.strictObject({ fromBlock: Exact, toBlock: Exact }), deployments: z.array(DeploymentSchema).max(100), pages: z.array(TransferPageSchema).max(4),
+    coverage: z.strictObject({ transactionsExamined: z.number().int().nonnegative(), creationTransactions: z.number().int().nonnegative(), receiptsRead: z.number().int().nonnegative(), exhausted: z.boolean(), nextPageKey: z.string().max(256).nullable(), completeness: z.literal('provider-index-claim') }),
+    interpretation: z.literal('same-sender-deployments-not-common-control'), findings: Findings, errors: Errors,
+});
+const FlowSchema = z.strictObject({ asset: z.string().max(64), contract: Address.nullable(), category: ActivityCategorySchema, symbol: z.string().max(64).nullable(), decimals: z.number().int().min(0).max(255).nullable(),
+    inboundAtomic: Exact, outboundAtomic: Exact, inboundFormatted: z.string().max(340).nullable(), outboundFormatted: z.string().max(340).nullable(), transfersIn: z.number().int().nonnegative(), transfersOut: z.number().int().nonnegative(), selfTransfers: z.number().int().nonnegative(), unquantifiedTransfers: z.number().int().nonnegative() });
+const TransactionSchema = z.strictObject({ transactionHash: Hex32, blockNumber: Exact, blockTimestamp: z.string().max(40).nullable(), legsIn: z.number().int().nonnegative(), legsOut: z.number().int().nonnegative(),
+    classification: z.enum(['inbound-only', 'outbound-only', 'self-transfer', 'in-and-out-same-transaction']), note: z.string().max(300) });
+const TokenBalanceSchema = z.strictObject({ contract: Address, balanceAtomic: Exact.nullable(), symbol: ActivityFactSchema, decimals: ActivityFactSchema, balanceFormatted: z.string().max(340).nullable(), evidenceIds: z.array(ActivityEvidenceIdSchema).min(1) });
+export const WalletActivityBodySchema = z.strictObject({
+    wallet: Address, chain: z.string(), window: z.strictObject({ fromBlock: Exact, toBlock: Exact }), nativeBalance: z.strictObject({ balanceAtomic: ActivityFactSchema, balanceFormatted: z.string().max(120).nullable() }),
+    transfers: z.array(ActivityTransferSchema).max(200), pages: z.array(TransferPageSchema).max(4), flows: z.array(FlowSchema).max(200), transactions: z.array(TransactionSchema).max(200),
+    tokenBalances: z.strictObject({ status: z.enum(['observed', 'not-read', 'unavailable']), finality: z.literal('provider-latest-not-pinned'), balances: z.array(TokenBalanceSchema).max(100), nextPageKey: z.string().max(256).nullable(), evidenceIds: z.array(ActivityEvidenceIdSchema) }),
+    coverage: z.strictObject({ order: z.enum(['newest-first', 'oldest-first']), categories: z.array(ActivityCategorySchema), inbound: TransferPageStatusSchema, outbound: TransferPageStatusSchema, completeness: z.literal('provider-index-claim') }),
+    findings: Findings, labelChecks: z.array(z.strictObject({ code: z.string().max(64), message: z.string().max(1000), evidenceIds: z.array(ActivityEvidenceIdSchema) })).max(32), errors: Errors,
+});

package/dist/packages/contracts/src/indexed-agents.d.ts

@@ -0,0 +1,299 @@
+import { z } from 'zod';
+import { ResearchAnalysisSchema } from './index.js';
+import { type ToolEvidenceItem } from './workflow.js';
+/**
+ * Shared manifest and report rules for the indexed first-party agents (P02 Deployer Investigator, P03 Wallet Analyst). Their manifests use
+ * their own strict schema (like the Solana inspector), so `AgentManifestSchema` and every stored manifest hash stay unchanged. Every run is
+ * bounded by the paid RPC ceiling of 16 metered calls, pins one latest block (sequencer-confirmed) and rechecks it at completion.
+ */
+export declare const INDEXED_AGENT_CHAINS: readonly ["ethereum", "base"];
+export declare const IndexedAgentChainSchema: z.ZodEnum<{
+    ethereum: "ethereum";
+    base: "base";
+}>;
+export declare const INDEXED_AGENT_RPC_CEILING = 16;
+export declare const Hex32Schema: z.ZodString;
+export declare const BlockNumberInputSchema: z.ZodString;
+export declare function indexedManifestSchema<Id extends string>(outputSchemaId: Id): 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";
+    }>>;
+    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.ZodLiteral<Id>;
+    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";
+        }>>;
+        addressScope: z.ZodLiteral<"input-address">;
+        maximumCalls: z.ZodNumber;
+    }, z.core.$strict>>;
+    modelPolicy: z.ZodObject<{
+        mode: z.ZodLiteral<"deterministic">;
+        maximumModelTokens: z.ZodLiteral<0>;
+    }, 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>>;
+    limits: z.ZodObject<{
+        maximumRpcCalls: z.ZodNumber;
+        maximumDurationMs: z.ZodNumber;
+        maximumOutputBytes: z.ZodNumber;
+        maximumGraphDepth: 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;
+        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>;
+type IndexedManifestShape = z.infer<ReturnType<typeof indexedManifestSchema<string>>>;
+/** Executable subset: the fixed graph, the template's tool references and input declaration, and a run budget that fits the minimum plan. */
+export declare function indexedManifestIssues(manifest: IndexedManifestShape, template: IndexedManifestShape, minimumRpcCalls: number): {
+    path: (string | number)[];
+    message: string;
+}[];
+export declare const IndexedSnapshotSchema: z.ZodObject<{
+    blockNumber: z.ZodString;
+    blockHash: z.ZodString;
+    timestamp: z.ZodString;
+    finality: z.ZodLiteral<"sequencer-confirmed">;
+    canonicality: z.ZodEnum<{
+        "verified-at-completion": "verified-at-completion";
+        unchecked: "unchecked";
+        changed: "changed";
+    }>;
+}, z.core.$strict>;
+export declare const IndexedReportErrorSchema: z.ZodObject<{
+    category: z.ZodString;
+    message: z.ZodString;
+    step: z.ZodString;
+    evidenceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const IndexedUsageSchema: 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>;
+export declare const IndexedEvidenceSchema: 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>>;
+export { ResearchAnalysisSchema as IndexedAnalysisSchema };
+export declare const NotComputedSchema: z.ZodObject<{
+    status: z.ZodLiteral<"not-computed">;
+    reason: z.ZodString;
+    sourceGap: z.ZodEnum<{
+        "historical-prices": "historical-prices";
+        "trade-classification": "trade-classification";
+        "transaction-fees": "transaction-fees";
+    }>;
+}, z.core.$strict>;
+type ReportCore = {
+    status: string;
+    input: {
+        chain: string;
+    };
+    snapshot: {
+        canonicality: string;
+    } | null;
+    evidence: ToolEvidenceItem[];
+    analysis?: z.infer<typeof ResearchAnalysisSchema> | undefined;
+    usage: z.infer<typeof IndexedUsageSchema>;
+};
+/** Envelope, provenance, budget and AI-summary rules shared by both report schemas. */
+export declare function indexedReportIssues(report: ReportCore, allowedTools: readonly string[], ctx: z.RefinementCtx): void;
+/** Checkpoint receipt scope for indexed agents: a declared tool, the read-method allowlist, the accepted chain and an intact envelope. */
+export declare function validateIndexedReceipt(evidence: unknown, input: {
+    chain: string;
+}, allowedTools: readonly string[]): ToolEvidenceItem;
+export declare const reportHash: z.ZodString;

package/dist/packages/contracts/src/indexed-agents.js

@@ -0,0 +1,131 @@
+import { z } from 'zod';
+import { AnalysisPolicySchema, AtomicAmountSchema, contentHash, matchesTemplateInput, ModelUsageSchema, ObjectSchemaDefinition, ResearchAnalysisSchema, WorkflowNodeSchema } from './index.js';
+import { ACTIVITY_READ_METHODS, ActivityEvidenceIdSchema } from './indexed-activity.js';
+import { ToolEvidenceItemSchema } from './workflow.js';
+/**
+ * Shared manifest and report rules for the indexed first-party agents (P02 Deployer Investigator, P03 Wallet Analyst). Their manifests use
+ * their own strict schema (like the Solana inspector), so `AgentManifestSchema` and every stored manifest hash stay unchanged. Every run is
+ * bounded by the paid RPC ceiling of 16 metered calls, pins one latest block (sequencer-confirmed) and rechecks it at completion.
+ */
+export const INDEXED_AGENT_CHAINS = ['ethereum', 'base'];
+export const IndexedAgentChainSchema = z.enum(INDEXED_AGENT_CHAINS);
+export const INDEXED_AGENT_RPC_CEILING = 16;
+export const Hex32Schema = z.string().regex(/^0x[a-fA-F0-9]{64}$/, 'Expected a 32-byte hex hash');
+export const BlockNumberInputSchema = z.string().regex(/^(0|[1-9][0-9]{0,15})$/, 'Expected a decimal block number');
+const Identifier = z.string().regex(/^[a-z][a-z0-9._-]{0,63}$/);
+const Semver = z.string().regex(/^\d+\.\d+\.\d+$/);
+const Hash = z.string().regex(/^[a-f0-9]{64}$/);
+export function indexedManifestSchema(outputSchemaId) {
+    return z.strictObject({
+        schemaVersion: z.literal('1.0'), id: Identifier, version: Semver, name: z.string().min(1).max(100), description: z.string().min(1).max(2000),
+        author: z.strictObject({ id: Identifier, name: z.string().min(1).max(100), ownership: z.enum(['first-party', 'independent']) }),
+        license: z.string().min(1).max(100), visibility: z.enum(['private', 'source-visible', 'source-private']),
+        chains: z.array(IndexedAgentChainSchema).min(1).max(INDEXED_AGENT_CHAINS.length), inputSchema: ObjectSchemaDefinition, outputSchemaId: z.literal(outputSchemaId),
+        tools: z.array(z.strictObject({ id: Identifier, version: Semver, capability: z.literal('evm.read'), chains: z.array(IndexedAgentChainSchema).min(1).max(INDEXED_AGENT_CHAINS.length), addressScope: z.literal('input-address'), maximumCalls: z.number().int().min(1).max(INDEXED_AGENT_RPC_CEILING) })).min(1).max(4),
+        modelPolicy: z.strictObject({ mode: z.literal('deterministic'), maximumModelTokens: z.literal(0) }),
+        // Optional bounded AI-assisted summary, identical in shape and pricing to the Token Researcher's policy.analysis.
+        policy: z.strictObject({ analysis: AnalysisPolicySchema }).optional(),
+        limits: z.strictObject({ maximumRpcCalls: z.number().int().min(1).max(INDEXED_AGENT_RPC_CEILING), maximumDurationMs: z.number().int().min(1000).max(120000), maximumOutputBytes: z.number().int().min(1024).max(262144), maximumGraphDepth: z.number().int().min(1).max(16), maximumPages: z.number().int().min(0).max(2), maximumExecutionAtomic: AtomicAmountSchema }),
+        workflow: z.array(WorkflowNodeSchema).min(3).max(32), testCases: z.array(Identifier).min(1).max(100),
+    });
+}
+/** Executable subset: the fixed graph, the template's tool references and input declaration, and a run budget that fits the minimum plan. */
+export function indexedManifestIssues(manifest, template, minimumRpcCalls) {
+    const issues = [];
+    if (new Set(manifest.chains).size !== manifest.chains.length)
+        issues.push({ path: ['chains'], message: 'Duplicate chain' });
+    if (contentHash(manifest.workflow) !== contentHash(template.workflow))
+        issues.push({ path: ['workflow'], message: `The executor supports only the bounded ${template.name} graph.` });
+    if (!matchesTemplateInput(manifest, [template]))
+        issues.push({ path: ['inputSchema'], message: `The input declaration must match the supported ${template.name} inputs with the selected chains.` });
+    const refs = (value) => value.tools.map((tool) => `${tool.id}@${tool.version}`).join(',');
+    if (refs(manifest) !== refs(template))
+        issues.push({ path: ['tools'], message: `Only ${refs(template)} with the read-only input-address grant are executable.` });
+    for (const [index, tool] of manifest.tools.entries()) {
+        if (!manifest.chains.every((chain) => tool.chains.includes(chain)))
+            issues.push({ path: ['tools', index, 'chains'], message: `Tool ${tool.id} cannot execute on every declared chain` });
+        if (tool.maximumCalls > manifest.limits.maximumRpcCalls)
+            issues.push({ path: ['tools', index, 'maximumCalls'], message: `Tool ${tool.id} exceeds the run call budget` });
+    }
+    if (manifest.limits.maximumRpcCalls < minimumRpcCalls)
+        issues.push({ path: ['limits', 'maximumRpcCalls'], message: `${template.name} needs at least ${minimumRpcCalls} RPC calls.` });
+    return issues;
+}
+export const IndexedSnapshotSchema = z.strictObject({ blockNumber: AtomicAmountSchema, blockHash: Hex32Schema, timestamp: AtomicAmountSchema, finality: z.literal('sequencer-confirmed'), canonicality: z.enum(['verified-at-completion', 'unchecked', 'changed']) });
+export const IndexedReportErrorSchema = z.strictObject({ category: z.string().regex(/^[a-z][a-z-]{1,63}$/), message: z.string().max(1000), step: z.string().max(64), evidenceId: ActivityEvidenceIdSchema.optional() });
+export const IndexedUsageSchema = z.strictObject({ rpcCalls: z.number().int().nonnegative(), maximumRpcCalls: z.number().int().positive().max(INDEXED_AGENT_RPC_CEILING), elapsedMs: z.number().int().nonnegative(), modelTokens: z.literal(0), providerCostAtomic: z.null(), providerCostStatus: z.literal('unpriced'), model: ModelUsageSchema.optional() });
+export const IndexedEvidenceSchema = z.array(ToolEvidenceItemSchema).max(INDEXED_AGENT_RPC_CEILING * 2);
+export { ResearchAnalysisSchema as IndexedAnalysisSchema };
+export const NotComputedSchema = z.strictObject({ status: z.literal('not-computed'), reason: z.string().min(1).max(600), sourceGap: z.enum(['historical-prices', 'trade-classification', 'transaction-fees']) });
+/** Every `evidenceIds` array and `evidenceId` string outside the evidence list, bounded against hostile nesting. */
+function references(value) {
+    const found = [];
+    const stack = [{ node: value, depth: 0 }];
+    let visited = 0;
+    while (stack.length && visited++ < 50000) {
+        const { node, depth } = stack.pop();
+        if (Array.isArray(node)) {
+            for (const child of node)
+                stack.push({ node: child, depth: depth + 1 });
+            continue;
+        }
+        if (!node || typeof node !== 'object' || depth > 32)
+            continue;
+        for (const [key, child] of Object.entries(node)) {
+            if (key === 'evidence' && depth === 0)
+                continue;
+            if (key === 'evidenceIds' && Array.isArray(child))
+                found.push(...child.map(String));
+            else if (key === 'evidenceId' && typeof child === 'string')
+                found.push(child);
+            else
+                stack.push({ node: child, depth: depth + 1 });
+        }
+    }
+    return found;
+}
+/** Envelope, provenance, budget and AI-summary rules shared by both report schemas. */
+export function indexedReportIssues(report, allowedTools, ctx) {
+    const issue = (message, path = []) => ctx.addIssue({ code: 'custom', message, path });
+    const ids = new Set(report.evidence.map((item) => item.id));
+    if (ids.size !== report.evidence.length)
+        issue('Duplicate evidence id');
+    for (const item of report.evidence) {
+        if (!allowedTools.includes(item.tool) || item.capability !== 'evm.read')
+            issue(`Evidence ${item.id} was not produced by a declared tool.`);
+        if (!ACTIVITY_READ_METHODS.includes(item.source.method))
+            issue(`Unsupported read method ${item.source.method}`);
+        if (item.chain !== report.input.chain)
+            issue(`Evidence ${item.id} belongs to another chain.`);
+    }
+    for (const id of references(report))
+        if (!ids.has(id))
+            issue(`Unknown evidence reference ${id}`);
+    if (report.usage.rpcCalls > report.usage.maximumRpcCalls || report.evidence.length > report.usage.rpcCalls)
+        issue('RPC usage or evidence count exceeds the recorded budget.', ['usage']);
+    if (report.status !== 'failed' && report.snapshot?.canonicality !== 'verified-at-completion')
+        issue('Only a report whose pinned block was rechecked as canonical can be complete or partial.', ['status']);
+    if ((report.analysis === undefined) !== (report.usage.model === undefined))
+        issue('An AI-assisted summary section and usage.model must be reported together.', ['analysis']);
+    if (report.analysis) {
+        const completed = report.analysis.status === 'completed';
+        if (completed === (report.analysis.unavailableReason !== undefined))
+            issue('Only a summary that did not complete states an unavailable or skipped reason.', ['analysis', 'unavailableReason']);
+        if (!completed && report.analysis.findings.length)
+            issue('Only a completed AI-assisted summary can contain findings.', ['analysis', 'findings']);
+        if (report.analysis.status === 'skipped' && report.usage.model && (report.usage.model.inputTokens || report.usage.model.outputTokens || report.usage.model.costMicrousd))
+            issue('A skipped AI-assisted summary records no model usage.', ['usage', 'model']);
+        if (report.usage.model?.costStatus === 'unresolved' && (report.analysis.status !== 'unavailable' || report.analysis.findings.length || report.usage.model.inputTokens || report.usage.model.outputTokens || report.usage.model.costMicrousd < 1))
+            issue('An unresolved model cost belongs to an unavailable summary without findings and states its reserved maximum, never zero.', ['usage', 'model', 'costStatus']);
+    }
+}
+/** Checkpoint receipt scope for indexed agents: a declared tool, the read-method allowlist, the accepted chain and an intact envelope. */
+export function validateIndexedReceipt(evidence, input, allowedTools) {
+    const receipt = ToolEvidenceItemSchema.parse(evidence);
+    const chainId = input.chain === 'ethereum' ? 1 : input.chain === 'base' ? 8453 : null;
+    if (!allowedTools.includes(receipt.tool) || receipt.capability !== 'evm.read' || !ACTIVITY_READ_METHODS.includes(receipt.source.method) || receipt.chain !== input.chain
+        || (receipt.snapshot !== null && (receipt.snapshot.kind !== 'evm-block' || receipt.snapshot.chainId !== chainId)))
+        throw new Error('Receipt is outside the indexed agent read scope.');
+    return receipt;
+}
+export const reportHash = Hash;