otto-intel-mcp 0.1.2 → 0.1.4

package/dist/execution-delegation-operations-definition.d.ts

@@ -0,0 +1,282 @@
+/** Token-bound, read-only view of the durable delegated-operation journal. */
+import { z } from 'zod';
+import { type DelegatedSendResult } from './execution-delegated-definition.js';
+import { type DelegationOperationRecord } from './execution-delegation-operation-store.js';
+export declare const DELEGATION_OPERATIONS_TOOL_NAME: "otto_delegation_operations";
+export declare const DELEGATION_RECONCILE_TOOL_NAME: "otto_delegation_reconcile";
+export declare const DELEGATION_OPERATIONS_INPUT_SCHEMA: z.ZodObject<{
+    accessToken: z.ZodString;
+    artifactId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const DELEGATION_RECONCILE_INPUT_SCHEMA: z.ZodObject<{
+    accessToken: z.ZodString;
+    artifactId: z.ZodString;
+}, z.core.$strict>;
+export declare const DELEGATION_OPERATIONS_RESULT_SCHEMA: z.ZodObject<{
+    user_id: z.ZodString;
+    store_available: z.ZodBoolean;
+    journal: z.ZodObject<{
+        schema_version: z.ZodLiteral<2>;
+        ready: z.ZodBoolean;
+        coverage_started_at: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    unresolved: z.ZodBoolean;
+    operations: z.ZodArray<z.ZodObject<{
+        artifact_id: z.ZodString;
+        account: z.ZodString;
+        chain_id: z.ZodLiteral<8453>;
+        state: z.ZodEnum<{
+            unknown: "unknown";
+            confirmed: "confirmed";
+            prepared: "prepared";
+            submitted: "submitted";
+            failed: "failed";
+        }>;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+        steps: z.ZodArray<z.ZodObject<{
+            index: z.ZodNumber;
+            transaction_hash: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                unknown: "unknown";
+                confirmed: "confirmed";
+                prepared: "prepared";
+                submitted: "submitted";
+                failed: "failed";
+            }>;
+        }, z.core.$strict>>;
+        result: z.ZodOptional<z.ZodObject<{
+            status: z.ZodLiteral<"sent">;
+            user_id: z.ZodString;
+            address: z.ZodString;
+            chain_id: z.ZodLiteral<8453>;
+            artifact_id: z.ZodString;
+            steps: z.ZodArray<z.ZodObject<{
+                index: z.ZodNumber;
+                kind: z.ZodEnum<{
+                    approve: "approve";
+                    approve_reset: "approve_reset";
+                    call: "call";
+                }>;
+                to: z.ZodString;
+                transaction_hash: z.ZodString;
+                status: z.ZodLiteral<"success">;
+                block_number: z.ZodString;
+                gas_used: z.ZodString;
+            }, z.core.$strict>>;
+            fence: z.ZodObject<{
+                policy_id: z.ZodString;
+                policy_name: z.ZodString;
+                rules_digest: z.ZodString;
+                per_swap_cap_usd: z.ZodLiteral<5000>;
+                user_cap_usd: z.ZodNumber;
+            }, z.core.$strict>;
+            delegation: z.ZodObject<{
+                expires_at: z.ZodString;
+            }, z.core.$strict>;
+            replayed: z.ZodOptional<z.ZodBoolean>;
+            verification: z.ZodObject<{
+                checks: z.ZodArray<z.ZodString>;
+                gross: z.ZodString;
+                min_amount_out: z.ZodString;
+                otto_fee_atomic: z.ZodString;
+                otto_fee_recipient: z.ZodString;
+                fee_config_version: z.ZodString;
+                receiver: z.ZodString;
+                call_data_digest: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type DelegationOperationsResult = z.infer<typeof DELEGATION_OPERATIONS_RESULT_SCHEMA>;
+/**
+ * Parse a stored success only when it is the exact receipt for this durable operation.
+ * Both replay and the protected lookup use this one validator so neither can trust a
+ * schema-valid result whose user, artifact, account, chain, step order, kind or hash
+ * disagrees with the journal.
+ */
+export declare function confirmedDelegationOperationResult(operation: DelegationOperationRecord): DelegatedSendResult | undefined;
+export declare const DELEGATION_OPERATIONS_TOOL_DEFINITION: Readonly<{
+    name: "otto_delegation_operations";
+    title: "Read one end user's delegated operation history and recovery state";
+    description: "Read the durable Base delegated-operation journal for the end user resolved from { accessToken }. Optional artifactId selects one exact own-user operation; without it, the result includes a bounded recent terminal history and every unresolved operation regardless of age. The global unresolved flag is fail-closed: it is true when the store is unavailable, journal coverage is not rollout-ready, or any operation has a prepared/submitted/unknown outcome. Stored serialized transactions and CDP idempotency keys are never returned, and this tool never submits or retries anything. Server-to-server only: the caller also presents Otto's delegation secret in the x-otto-delegation-auth request header; no userId argument is accepted.";
+    inputSchema: z.ZodObject<{}, z.core.$loose>;
+    strictInputSchema: z.ZodObject<{
+        accessToken: z.ZodString;
+        artifactId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    outputSchema: z.ZodObject<{
+        user_id: z.ZodString;
+        store_available: z.ZodBoolean;
+        journal: z.ZodObject<{
+            schema_version: z.ZodLiteral<2>;
+            ready: z.ZodBoolean;
+            coverage_started_at: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        unresolved: z.ZodBoolean;
+        operations: z.ZodArray<z.ZodObject<{
+            artifact_id: z.ZodString;
+            account: z.ZodString;
+            chain_id: z.ZodLiteral<8453>;
+            state: z.ZodEnum<{
+                unknown: "unknown";
+                confirmed: "confirmed";
+                prepared: "prepared";
+                submitted: "submitted";
+                failed: "failed";
+            }>;
+            created_at: z.ZodString;
+            updated_at: z.ZodString;
+            steps: z.ZodArray<z.ZodObject<{
+                index: z.ZodNumber;
+                transaction_hash: z.ZodOptional<z.ZodString>;
+                state: z.ZodEnum<{
+                    unknown: "unknown";
+                    confirmed: "confirmed";
+                    prepared: "prepared";
+                    submitted: "submitted";
+                    failed: "failed";
+                }>;
+            }, z.core.$strict>>;
+            result: z.ZodOptional<z.ZodObject<{
+                status: z.ZodLiteral<"sent">;
+                user_id: z.ZodString;
+                address: z.ZodString;
+                chain_id: z.ZodLiteral<8453>;
+                artifact_id: z.ZodString;
+                steps: z.ZodArray<z.ZodObject<{
+                    index: z.ZodNumber;
+                    kind: z.ZodEnum<{
+                        approve: "approve";
+                        approve_reset: "approve_reset";
+                        call: "call";
+                    }>;
+                    to: z.ZodString;
+                    transaction_hash: z.ZodString;
+                    status: z.ZodLiteral<"success">;
+                    block_number: z.ZodString;
+                    gas_used: z.ZodString;
+                }, z.core.$strict>>;
+                fence: z.ZodObject<{
+                    policy_id: z.ZodString;
+                    policy_name: z.ZodString;
+                    rules_digest: z.ZodString;
+                    per_swap_cap_usd: z.ZodLiteral<5000>;
+                    user_cap_usd: z.ZodNumber;
+                }, z.core.$strict>;
+                delegation: z.ZodObject<{
+                    expires_at: z.ZodString;
+                }, z.core.$strict>;
+                replayed: z.ZodOptional<z.ZodBoolean>;
+                verification: z.ZodObject<{
+                    checks: z.ZodArray<z.ZodString>;
+                    gross: z.ZodString;
+                    min_amount_out: z.ZodString;
+                    otto_fee_atomic: z.ZodString;
+                    otto_fee_recipient: z.ZodString;
+                    fee_config_version: z.ZodString;
+                    receiver: z.ZodString;
+                    call_data_digest: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    annotations: Readonly<{
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+        openWorldHint: true;
+    }>;
+}>;
+export declare const DELEGATION_RECONCILE_TOOL_DEFINITION: Readonly<{
+    name: "otto_delegation_reconcile";
+    title: "Reconcile one end user's known-hash delegated operation";
+    description: "Acquire the artifact's permanent process-liveness guard, then check Base for finalized canonical receipts of already-stored transaction hashes. Every chain transaction must match the stored chain, hash, sender, target, calldata, value, nonce, gas and EIP-1559 fee fields before its receipt is recorded. This tool never calls CDP, never retries a request, never builds or submits a later step, and leaves prepared/unknown no-hash steps unresolved. It returns the same token-bound operation snapshot as otto_delegation_operations. Server-to-server only: the caller also presents Otto's delegation secret in x-otto-delegation-auth.";
+    inputSchema: z.ZodObject<{}, z.core.$loose>;
+    strictInputSchema: z.ZodObject<{
+        accessToken: z.ZodString;
+        artifactId: z.ZodString;
+    }, z.core.$strict>;
+    outputSchema: z.ZodObject<{
+        user_id: z.ZodString;
+        store_available: z.ZodBoolean;
+        journal: z.ZodObject<{
+            schema_version: z.ZodLiteral<2>;
+            ready: z.ZodBoolean;
+            coverage_started_at: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        unresolved: z.ZodBoolean;
+        operations: z.ZodArray<z.ZodObject<{
+            artifact_id: z.ZodString;
+            account: z.ZodString;
+            chain_id: z.ZodLiteral<8453>;
+            state: z.ZodEnum<{
+                unknown: "unknown";
+                confirmed: "confirmed";
+                prepared: "prepared";
+                submitted: "submitted";
+                failed: "failed";
+            }>;
+            created_at: z.ZodString;
+            updated_at: z.ZodString;
+            steps: z.ZodArray<z.ZodObject<{
+                index: z.ZodNumber;
+                transaction_hash: z.ZodOptional<z.ZodString>;
+                state: z.ZodEnum<{
+                    unknown: "unknown";
+                    confirmed: "confirmed";
+                    prepared: "prepared";
+                    submitted: "submitted";
+                    failed: "failed";
+                }>;
+            }, z.core.$strict>>;
+            result: z.ZodOptional<z.ZodObject<{
+                status: z.ZodLiteral<"sent">;
+                user_id: z.ZodString;
+                address: z.ZodString;
+                chain_id: z.ZodLiteral<8453>;
+                artifact_id: z.ZodString;
+                steps: z.ZodArray<z.ZodObject<{
+                    index: z.ZodNumber;
+                    kind: z.ZodEnum<{
+                        approve: "approve";
+                        approve_reset: "approve_reset";
+                        call: "call";
+                    }>;
+                    to: z.ZodString;
+                    transaction_hash: z.ZodString;
+                    status: z.ZodLiteral<"success">;
+                    block_number: z.ZodString;
+                    gas_used: z.ZodString;
+                }, z.core.$strict>>;
+                fence: z.ZodObject<{
+                    policy_id: z.ZodString;
+                    policy_name: z.ZodString;
+                    rules_digest: z.ZodString;
+                    per_swap_cap_usd: z.ZodLiteral<5000>;
+                    user_cap_usd: z.ZodNumber;
+                }, z.core.$strict>;
+                delegation: z.ZodObject<{
+                    expires_at: z.ZodString;
+                }, z.core.$strict>;
+                replayed: z.ZodOptional<z.ZodBoolean>;
+                verification: z.ZodObject<{
+                    checks: z.ZodArray<z.ZodString>;
+                    gross: z.ZodString;
+                    min_amount_out: z.ZodString;
+                    otto_fee_atomic: z.ZodString;
+                    otto_fee_recipient: z.ZodString;
+                    fee_config_version: z.ZodString;
+                    receiver: z.ZodString;
+                    call_data_digest: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    annotations: Readonly<{
+        readOnlyHint: false;
+        destructiveHint: false;
+        idempotentHint: true;
+        openWorldHint: true;
+    }>;
+}>;

package/dist/execution-delegation-operations-definition.js

@@ -0,0 +1,117 @@
+/** Token-bound, read-only view of the durable delegated-operation journal. */
+import { z } from 'zod';
+import { DELEGATED_SEND_RESULT_SCHEMA, DELEGATED_TOOL_TRANSPORT_SCHEMA, DELEGATION_AUTH_HEADER, } from './execution-delegated-definition.js';
+import { DELEGATION_OPERATION_JOURNAL_SCHEMA_VERSION, DELEGATION_OPERATION_STATES, DELEGATION_OPERATION_STEP_STATES, } from './execution-delegation-operation-store.js';
+export const DELEGATION_OPERATIONS_TOOL_NAME = 'otto_delegation_operations';
+export const DELEGATION_RECONCILE_TOOL_NAME = 'otto_delegation_reconcile';
+const ACCESS_TOKEN_SCHEMA = z.string().min(16).max(8192);
+const ARTIFACT_ID_SCHEMA = z.string().regex(/^[0-9A-HJKMNP-TV-Z]{26}$/);
+const ADDRESS_SCHEMA = z.string().regex(/^0x[0-9a-fA-F]{40}$/);
+const HASH_SCHEMA = z.string().regex(/^0x[0-9a-fA-F]{64}$/);
+export const DELEGATION_OPERATIONS_INPUT_SCHEMA = z
+    .object({
+    accessToken: ACCESS_TOKEN_SCHEMA,
+    /** Exact own-user lookup when present; otherwise bounded terminal history plus every unresolved row. */
+    artifactId: ARTIFACT_ID_SCHEMA.optional(),
+})
+    .strict();
+export const DELEGATION_RECONCILE_INPUT_SCHEMA = z.object({
+    accessToken: ACCESS_TOKEN_SCHEMA,
+    artifactId: ARTIFACT_ID_SCHEMA,
+}).strict();
+export const DELEGATION_OPERATIONS_RESULT_SCHEMA = z
+    .object({
+    user_id: z.string().regex(/^[a-zA-Z0-9-]{1,100}$/),
+    store_available: z.boolean(),
+    journal: z
+        .object({
+        schema_version: z.literal(DELEGATION_OPERATION_JOURNAL_SCHEMA_VERSION),
+        ready: z.boolean(),
+        coverage_started_at: z.string().datetime().nullable(),
+    })
+        .strict(),
+    /** Global own-user guard state, never narrowed by artifactId. */
+    unresolved: z.boolean(),
+    operations: z.array(z
+        .object({
+        artifact_id: ARTIFACT_ID_SCHEMA,
+        account: ADDRESS_SCHEMA,
+        chain_id: z.literal(8453),
+        state: z.enum(DELEGATION_OPERATION_STATES),
+        created_at: z.string().datetime(),
+        updated_at: z.string().datetime(),
+        steps: z.array(z
+            .object({
+            index: z.number().int().min(0).max(3),
+            transaction_hash: HASH_SCHEMA.optional(),
+            state: z.enum(DELEGATION_OPERATION_STEP_STATES),
+        })
+            .strict()),
+        result: DELEGATED_SEND_RESULT_SCHEMA.optional(),
+    })
+        .strict()),
+})
+    .strict();
+const CONFIRMED_STEP_KINDS = ['approve_reset', 'approve', 'call'];
+/**
+ * Parse a stored success only when it is the exact receipt for this durable operation.
+ * Both replay and the protected lookup use this one validator so neither can trust a
+ * schema-valid result whose user, artifact, account, chain, step order, kind or hash
+ * disagrees with the journal.
+ */
+export function confirmedDelegationOperationResult(operation) {
+    if (operation.state !== 'confirmed')
+        return undefined;
+    const parsed = DELEGATED_SEND_RESULT_SCHEMA.safeParse(operation.result);
+    if (!parsed.success)
+        return undefined;
+    const result = parsed.data;
+    if (result.user_id !== operation.userId ||
+        result.artifact_id !== operation.artifactId ||
+        result.address.toLowerCase() !== operation.account.toLowerCase() ||
+        result.chain_id !== operation.chainId ||
+        operation.steps.length !== CONFIRMED_STEP_KINDS.length ||
+        result.steps.length !== CONFIRMED_STEP_KINDS.length)
+        return undefined;
+    for (const [index, kind] of CONFIRMED_STEP_KINDS.entries()) {
+        const saved = operation.steps[index];
+        const sent = result.steps[index];
+        if (saved?.index !== index ||
+            saved.kind !== kind ||
+            saved.state !== 'confirmed' ||
+            sent?.index !== index ||
+            sent.kind !== kind ||
+            saved.transactionHash?.toLowerCase() !== sent.transaction_hash.toLowerCase())
+            return undefined;
+    }
+    return result;
+}
+export const DELEGATION_OPERATIONS_TOOL_DEFINITION = Object.freeze({
+    name: DELEGATION_OPERATIONS_TOOL_NAME,
+    title: "Read one end user's delegated operation history and recovery state",
+    description: `Read the durable Base delegated-operation journal for the end user resolved from { accessToken }. Optional artifactId selects one exact own-user operation; without it, the result includes a bounded recent terminal history and every unresolved operation regardless of age. The global unresolved flag is fail-closed: it is true when the store is unavailable, journal coverage is not rollout-ready, or any operation has a prepared/submitted/unknown outcome. Stored serialized transactions and CDP idempotency keys are never returned, and this tool never submits or retries anything. Server-to-server only: the caller also presents Otto's delegation secret in the ${DELEGATION_AUTH_HEADER} request header; no userId argument is accepted.`,
+    inputSchema: DELEGATED_TOOL_TRANSPORT_SCHEMA,
+    strictInputSchema: DELEGATION_OPERATIONS_INPUT_SCHEMA,
+    outputSchema: DELEGATION_OPERATIONS_RESULT_SCHEMA,
+    annotations: Object.freeze({
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    }),
+});
+export const DELEGATION_RECONCILE_TOOL_DEFINITION = Object.freeze({
+    name: DELEGATION_RECONCILE_TOOL_NAME,
+    title: "Reconcile one end user's known-hash delegated operation",
+    description: `Acquire the artifact's permanent process-liveness guard, then check Base for finalized canonical receipts of already-stored transaction hashes. Every chain transaction must match the stored chain, hash, sender, target, calldata, value, nonce, gas and EIP-1559 fee fields before its receipt is recorded. This tool never calls CDP, never retries a request, never builds or submits a later step, and leaves prepared/unknown no-hash steps unresolved. It returns the same token-bound operation snapshot as ${DELEGATION_OPERATIONS_TOOL_NAME}. Server-to-server only: the caller also presents Otto's delegation secret in ${DELEGATION_AUTH_HEADER}.`,
+    inputSchema: DELEGATED_TOOL_TRANSPORT_SCHEMA,
+    strictInputSchema: DELEGATION_RECONCILE_INPUT_SCHEMA,
+    outputSchema: DELEGATION_OPERATIONS_RESULT_SCHEMA,
+    annotations: Object.freeze({
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    }),
+});
+//# sourceMappingURL=execution-delegation-operations-definition.js.map

package/dist/execution-delegation-operations.d.ts

@@ -0,0 +1,6 @@
+import { type DelegationCaller } from './execution-delegation.js';
+import { type DelegationOperationsResult } from './execution-delegation-operations-definition.js';
+import type { ExecutionToolRuntime } from './execution-tools.js';
+export declare function readDelegationOperations(runtime: ExecutionToolRuntime, rawInput: unknown, caller: DelegationCaller): Promise<DelegationOperationsResult>;
+/** Known-hash-only recovery. The original worker's fixed guard must be acquirable before any mutation. */
+export declare function reconcileDelegationOperation(runtime: ExecutionToolRuntime, rawInput: unknown, caller: DelegationCaller): Promise<DelegationOperationsResult>;