aae-protocol 0.0.1 → 0.9.0

package/dist/models.d.ts

@@ -0,0 +1,687 @@
+/**
+ * Zod schemas + inferred TypeScript types for AAE protocol shapes.
+ *
+ * These mirror schemas/*.schema.json and the SPEC. When you change one,
+ * change the others and bump conformance test fixtures.
+ */
+import { z } from "zod";
+export declare const PROTOCOL_VERSION: "0.8";
+export declare const BlastRadius: {
+    readonly READ_ONLY: "read_only";
+    readonly SINGLE_SERVICE: "single_service";
+    readonly SINGLE_HOST: "single_host";
+    readonly MULTI_HOST: "multi_host";
+    readonly IRREVERSIBLE: "irreversible";
+};
+export declare const BlastRadiusSchema: z.ZodEnum<["read_only", "single_service", "single_host", "multi_host", "irreversible"]>;
+export type BlastRadius = z.infer<typeof BlastRadiusSchema>;
+export declare const Decision: {
+    readonly ALLOW: "allow";
+    readonly DENY: "deny";
+    readonly REQUIRE_APPROVAL: "require_approval";
+};
+/**
+ * v0.8: the decision enum is closed at exactly these three values. Unknown
+ * decision values — including the two refined v0.3 values retired in v0.8 —
+ * MUST fail parsing; consumers reject rather than coerce.
+ */
+export declare const DecisionSchema: z.ZodEnum<["allow", "deny", "require_approval"]>;
+export type Decision = z.infer<typeof DecisionSchema>;
+/** v0.3: whether a tool's effects can be undone. */
+export declare const ReversibilitySchema: z.ZodEnum<["reversible", "partially_reversible", "irreversible"]>;
+export type Reversibility = z.infer<typeof ReversibilitySchema>;
+/** v0.7: standard ext.confidence shape on policy decisions. A low-confidence
+ * allow is still an allow (G-2-safe); hosts may route it to spot checks. */
+export declare const ConfidenceSchema: z.ZodObject<{
+    score: z.ZodNumber;
+    basis: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    score: z.ZodNumber;
+    basis: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    score: z.ZodNumber;
+    basis: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+export type Confidence = z.infer<typeof ConfidenceSchema>;
+/** v0.3: standard ext.cost_estimate shape for cost-aware policy. */
+export declare const CostEstimateSchema: z.ZodObject<{
+    currency: z.ZodString;
+    amount: z.ZodNumber;
+    amount_max: z.ZodOptional<z.ZodNumber>;
+    basis: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    currency: z.ZodString;
+    amount: z.ZodNumber;
+    amount_max: z.ZodOptional<z.ZodNumber>;
+    basis: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    currency: z.ZodString;
+    amount: z.ZodNumber;
+    amount_max: z.ZodOptional<z.ZodNumber>;
+    basis: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">>;
+export type CostEstimate = z.infer<typeof CostEstimateSchema>;
+/** Core strictness modes (SPEC §5.3). */
+export declare const Strictness: {
+    readonly STRICT_LITERAL: "strict_literal";
+    readonly STRICT_TEMPLATE: "strict_template";
+};
+/**
+ * v0.8: strictness is an open string. Core normatively defines
+ * `strict_literal` (REQUIRED, default) and `strict_template` (OPTIONAL);
+ * any other value is a companion/extension mode, and a host that does not
+ * implement the requested mode MUST fail closed (C-16), never downgrade.
+ */
+export declare const StrictnessSchema: z.ZodString;
+export type Strictness = z.infer<typeof StrictnessSchema>;
+export declare const StepSchema: z.ZodObject<{
+    tool: z.ZodString;
+    args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    expected: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    blast_radius: z.ZodEnum<["read_only", "single_service", "single_host", "multi_host", "irreversible"]>;
+}, "strict", z.ZodTypeAny, {
+    tool: string;
+    args: Record<string, unknown>;
+    blast_radius: "read_only" | "single_service" | "single_host" | "multi_host" | "irreversible";
+    expected?: Record<string, unknown> | undefined;
+}, {
+    tool: string;
+    args: Record<string, unknown>;
+    blast_radius: "read_only" | "single_service" | "single_host" | "multi_host" | "irreversible";
+    expected?: Record<string, unknown> | undefined;
+}>;
+export type Step = z.infer<typeof StepSchema>;
+export declare const ContextSchema: z.ZodObject<{
+    rationale: z.ZodString;
+    triggered_by: z.ZodOptional<z.ZodString>;
+    derived_from: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    rationale: z.ZodString;
+    triggered_by: z.ZodOptional<z.ZodString>;
+    derived_from: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    rationale: z.ZodString;
+    triggered_by: z.ZodOptional<z.ZodString>;
+    derived_from: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+export type Context = z.infer<typeof ContextSchema>;
+export declare const ProposalSchema: z.ZodEffects<z.ZodObject<{
+    aae_version: z.ZodString;
+    proposal_id: z.ZodString;
+    agent_id: z.ZodString;
+    agent_chain: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    tenant_id: z.ZodString;
+    intent: z.ZodString;
+    context: z.ZodObject<{
+        rationale: z.ZodString;
+        triggered_by: z.ZodOptional<z.ZodString>;
+        derived_from: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        rationale: z.ZodString;
+        triggered_by: z.ZodOptional<z.ZodString>;
+        derived_from: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        rationale: z.ZodString;
+        triggered_by: z.ZodOptional<z.ZodString>;
+        derived_from: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>;
+    steps: z.ZodArray<z.ZodObject<{
+        tool: z.ZodString;
+        args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        expected: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        blast_radius: z.ZodEnum<["read_only", "single_service", "single_host", "multi_host", "irreversible"]>;
+    }, "strict", z.ZodTypeAny, {
+        tool: string;
+        args: Record<string, unknown>;
+        blast_radius: "read_only" | "single_service" | "single_host" | "multi_host" | "irreversible";
+        expected?: Record<string, unknown> | undefined;
+    }, {
+        tool: string;
+        args: Record<string, unknown>;
+        blast_radius: "read_only" | "single_service" | "single_host" | "multi_host" | "irreversible";
+        expected?: Record<string, unknown> | undefined;
+    }>, "many">;
+    submitted_at: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    aae_version: string;
+    proposal_id: string;
+    agent_id: string;
+    tenant_id: string;
+    intent: string;
+    context: {
+        rationale: string;
+        triggered_by?: string | undefined;
+        derived_from?: string | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    steps: {
+        tool: string;
+        args: Record<string, unknown>;
+        blast_radius: "read_only" | "single_service" | "single_host" | "multi_host" | "irreversible";
+        expected?: Record<string, unknown> | undefined;
+    }[];
+    submitted_at: string;
+    agent_chain?: string[] | undefined;
+}, {
+    aae_version: string;
+    proposal_id: string;
+    agent_id: string;
+    tenant_id: string;
+    intent: string;
+    context: {
+        rationale: string;
+        triggered_by?: string | undefined;
+        derived_from?: string | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    steps: {
+        tool: string;
+        args: Record<string, unknown>;
+        blast_radius: "read_only" | "single_service" | "single_host" | "multi_host" | "irreversible";
+        expected?: Record<string, unknown> | undefined;
+    }[];
+    submitted_at: string;
+    agent_chain?: string[] | undefined;
+}>, {
+    aae_version: string;
+    proposal_id: string;
+    agent_id: string;
+    tenant_id: string;
+    intent: string;
+    context: {
+        rationale: string;
+        triggered_by?: string | undefined;
+        derived_from?: string | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    steps: {
+        tool: string;
+        args: Record<string, unknown>;
+        blast_radius: "read_only" | "single_service" | "single_host" | "multi_host" | "irreversible";
+        expected?: Record<string, unknown> | undefined;
+    }[];
+    submitted_at: string;
+    agent_chain?: string[] | undefined;
+}, {
+    aae_version: string;
+    proposal_id: string;
+    agent_id: string;
+    tenant_id: string;
+    intent: string;
+    context: {
+        rationale: string;
+        triggered_by?: string | undefined;
+        derived_from?: string | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    steps: {
+        tool: string;
+        args: Record<string, unknown>;
+        blast_radius: "read_only" | "single_service" | "single_host" | "multi_host" | "irreversible";
+        expected?: Record<string, unknown> | undefined;
+    }[];
+    submitted_at: string;
+    agent_chain?: string[] | undefined;
+}>;
+export type Proposal = z.infer<typeof ProposalSchema>;
+export declare const EffectSchema: z.ZodObject<{
+    type: z.ZodString;
+    target: z.ZodString;
+    from: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    to: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    type: string;
+    target: string;
+    from?: string | null | undefined;
+    to?: string | null | undefined;
+    details?: Record<string, unknown> | undefined;
+}, {
+    type: string;
+    target: string;
+    from?: string | null | undefined;
+    to?: string | null | undefined;
+    details?: Record<string, unknown> | undefined;
+}>;
+export type Effect = z.infer<typeof EffectSchema>;
+export declare const StepPreviewSchema: z.ZodObject<{
+    step_index: z.ZodNumber;
+    predicted_effects: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        target: z.ZodString;
+        from: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        to: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strict", z.ZodTypeAny, {
+        type: string;
+        target: string;
+        from?: string | null | undefined;
+        to?: string | null | undefined;
+        details?: Record<string, unknown> | undefined;
+    }, {
+        type: string;
+        target: string;
+        from?: string | null | undefined;
+        to?: string | null | undefined;
+        details?: Record<string, unknown> | undefined;
+    }>, "many">;
+    estimated_duration_ms: z.ZodOptional<z.ZodNumber>;
+    diff: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    warnings: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    preview_unsupported_reason: z.ZodOptional<z.ZodString>;
+    ext: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, "strict", z.ZodTypeAny, {
+    step_index: number;
+    predicted_effects: {
+        type: string;
+        target: string;
+        from?: string | null | undefined;
+        to?: string | null | undefined;
+        details?: Record<string, unknown> | undefined;
+    }[];
+    warnings: string[];
+    estimated_duration_ms?: number | undefined;
+    diff?: string | null | undefined;
+    preview_unsupported_reason?: string | undefined;
+    ext?: Record<string, unknown> | null | undefined;
+}, {
+    step_index: number;
+    predicted_effects: {
+        type: string;
+        target: string;
+        from?: string | null | undefined;
+        to?: string | null | undefined;
+        details?: Record<string, unknown> | undefined;
+    }[];
+    estimated_duration_ms?: number | undefined;
+    diff?: string | null | undefined;
+    warnings?: string[] | undefined;
+    preview_unsupported_reason?: string | undefined;
+    ext?: Record<string, unknown> | null | undefined;
+}>;
+export type StepPreview = z.infer<typeof StepPreviewSchema>;
+/** Parse a decision's ext.confidence into the standard shape, if present. */
+export declare function confidenceOf(decision: PolicyDecision): Confidence | null;
+/** Parse a step preview's ext.cost_estimate into the standard shape, if present. */
+export declare function costEstimateOf(preview: StepPreview): CostEstimate | null;
+export declare const PreviewSchema: z.ZodObject<{
+    aae_version: z.ZodString;
+    preview_id: z.ZodString;
+    proposal_id: z.ZodString;
+    step_previews: z.ZodArray<z.ZodObject<{
+        step_index: z.ZodNumber;
+        predicted_effects: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            target: z.ZodString;
+            from: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            to: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strict", z.ZodTypeAny, {
+            type: string;
+            target: string;
+            from?: string | null | undefined;
+            to?: string | null | undefined;
+            details?: Record<string, unknown> | undefined;
+        }, {
+            type: string;
+            target: string;
+            from?: string | null | undefined;
+            to?: string | null | undefined;
+            details?: Record<string, unknown> | undefined;
+        }>, "many">;
+        estimated_duration_ms: z.ZodOptional<z.ZodNumber>;
+        diff: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        warnings: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        preview_unsupported_reason: z.ZodOptional<z.ZodString>;
+        ext: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, "strict", z.ZodTypeAny, {
+        step_index: number;
+        predicted_effects: {
+            type: string;
+            target: string;
+            from?: string | null | undefined;
+            to?: string | null | undefined;
+            details?: Record<string, unknown> | undefined;
+        }[];
+        warnings: string[];
+        estimated_duration_ms?: number | undefined;
+        diff?: string | null | undefined;
+        preview_unsupported_reason?: string | undefined;
+        ext?: Record<string, unknown> | null | undefined;
+    }, {
+        step_index: number;
+        predicted_effects: {
+            type: string;
+            target: string;
+            from?: string | null | undefined;
+            to?: string | null | undefined;
+            details?: Record<string, unknown> | undefined;
+        }[];
+        estimated_duration_ms?: number | undefined;
+        diff?: string | null | undefined;
+        warnings?: string[] | undefined;
+        preview_unsupported_reason?: string | undefined;
+        ext?: Record<string, unknown> | null | undefined;
+    }>, "many">;
+    aggregate_blast_radius: z.ZodEnum<["read_only", "single_service", "single_host", "multi_host", "irreversible"]>;
+    preview_unsupported: z.ZodBoolean;
+    generated_at: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    aae_version: string;
+    proposal_id: string;
+    preview_id: string;
+    step_previews: {
+        step_index: number;
+        predicted_effects: {
+            type: string;
+            target: string;
+            from?: string | null | undefined;
+            to?: string | null | undefined;
+            details?: Record<string, unknown> | undefined;
+        }[];
+        warnings: string[];
+        estimated_duration_ms?: number | undefined;
+        diff?: string | null | undefined;
+        preview_unsupported_reason?: string | undefined;
+        ext?: Record<string, unknown> | null | undefined;
+    }[];
+    aggregate_blast_radius: "read_only" | "single_service" | "single_host" | "multi_host" | "irreversible";
+    preview_unsupported: boolean;
+    generated_at: string;
+}, {
+    aae_version: string;
+    proposal_id: string;
+    preview_id: string;
+    step_previews: {
+        step_index: number;
+        predicted_effects: {
+            type: string;
+            target: string;
+            from?: string | null | undefined;
+            to?: string | null | undefined;
+            details?: Record<string, unknown> | undefined;
+        }[];
+        estimated_duration_ms?: number | undefined;
+        diff?: string | null | undefined;
+        warnings?: string[] | undefined;
+        preview_unsupported_reason?: string | undefined;
+        ext?: Record<string, unknown> | null | undefined;
+    }[];
+    aggregate_blast_radius: "read_only" | "single_service" | "single_host" | "multi_host" | "irreversible";
+    preview_unsupported: boolean;
+    generated_at: string;
+}>;
+export type Preview = z.infer<typeof PreviewSchema>;
+export declare const PolicyDecisionSchema: z.ZodEffects<z.ZodObject<{
+    aae_version: z.ZodString;
+    decision_id: z.ZodString;
+    proposal_id: z.ZodString;
+    decision: z.ZodEnum<["allow", "deny", "require_approval"]>;
+    policy_version: z.ZodString;
+    rules_evaluated: z.ZodArray<z.ZodString, "many">;
+    reason: z.ZodString;
+    required_approvers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    expires_at: z.ZodOptional<z.ZodString>;
+    strictness: z.ZodDefault<z.ZodString>;
+    decided_at: z.ZodString;
+    ext: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, "strict", z.ZodTypeAny, {
+    aae_version: string;
+    proposal_id: string;
+    decision_id: string;
+    decision: "allow" | "deny" | "require_approval";
+    policy_version: string;
+    rules_evaluated: string[];
+    reason: string;
+    strictness: string;
+    decided_at: string;
+    ext?: Record<string, unknown> | null | undefined;
+    required_approvers?: string[] | undefined;
+    expires_at?: string | undefined;
+}, {
+    aae_version: string;
+    proposal_id: string;
+    decision_id: string;
+    decision: "allow" | "deny" | "require_approval";
+    policy_version: string;
+    rules_evaluated: string[];
+    reason: string;
+    decided_at: string;
+    ext?: Record<string, unknown> | null | undefined;
+    required_approvers?: string[] | undefined;
+    expires_at?: string | undefined;
+    strictness?: string | undefined;
+}>, {
+    aae_version: string;
+    proposal_id: string;
+    decision_id: string;
+    decision: "allow" | "deny" | "require_approval";
+    policy_version: string;
+    rules_evaluated: string[];
+    reason: string;
+    strictness: string;
+    decided_at: string;
+    ext?: Record<string, unknown> | null | undefined;
+    required_approvers?: string[] | undefined;
+    expires_at?: string | undefined;
+}, {
+    aae_version: string;
+    proposal_id: string;
+    decision_id: string;
+    decision: "allow" | "deny" | "require_approval";
+    policy_version: string;
+    rules_evaluated: string[];
+    reason: string;
+    decided_at: string;
+    ext?: Record<string, unknown> | null | undefined;
+    required_approvers?: string[] | undefined;
+    expires_at?: string | undefined;
+    strictness?: string | undefined;
+}>;
+export type PolicyDecision = z.infer<typeof PolicyDecisionSchema>;
+export declare const CapabilityScopeSchema: z.ZodObject<{
+    tool: z.ZodString;
+    approved_steps_hash: z.ZodString;
+    target_constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    tool: z.ZodString;
+    approved_steps_hash: z.ZodString;
+    target_constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    tool: z.ZodString;
+    approved_steps_hash: z.ZodString;
+    target_constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type CapabilityScope = z.infer<typeof CapabilityScopeSchema>;
+export declare const CapabilityTokenSchema: z.ZodObject<{
+    aae_version: z.ZodString;
+    token_id: z.ZodString;
+    proposal_id: z.ZodString;
+    decision_id: z.ZodString;
+    scope: z.ZodObject<{
+        tool: z.ZodString;
+        approved_steps_hash: z.ZodString;
+        target_constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        tool: z.ZodString;
+        approved_steps_hash: z.ZodString;
+        target_constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        tool: z.ZodString;
+        approved_steps_hash: z.ZodString;
+        target_constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">>;
+    iat: z.ZodNumber;
+    exp: z.ZodNumber;
+    iss: z.ZodString;
+    sub: z.ZodOptional<z.ZodString>;
+    max_uses: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    aae_version: string;
+    proposal_id: string;
+    decision_id: string;
+    token_id: string;
+    scope: {
+        tool: string;
+        approved_steps_hash: string;
+        target_constraints?: Record<string, unknown> | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    iat: number;
+    exp: number;
+    iss: string;
+    max_uses: number;
+    sub?: string | undefined;
+}, {
+    aae_version: string;
+    proposal_id: string;
+    decision_id: string;
+    token_id: string;
+    scope: {
+        tool: string;
+        approved_steps_hash: string;
+        target_constraints?: Record<string, unknown> | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    iat: number;
+    exp: number;
+    iss: string;
+    max_uses: number;
+    sub?: string | undefined;
+}>;
+export type CapabilityToken = z.infer<typeof CapabilityTokenSchema>;
+export declare const EventSignatureSchema: z.ZodObject<{
+    alg: z.ZodEnum<["ed25519", "ecdsa-p256", "rsa-pss-sha256"]>;
+    key_id: z.ZodString;
+    value: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    value: string;
+    alg: "ed25519" | "ecdsa-p256" | "rsa-pss-sha256";
+    key_id: string;
+}, {
+    value: string;
+    alg: "ed25519" | "ecdsa-p256" | "rsa-pss-sha256";
+    key_id: string;
+}>;
+export type EventSignature = z.infer<typeof EventSignatureSchema>;
+/**
+ * v0.8 core event type binding an out-of-chain artifact to a chain event by
+ * content hash. Required payload fields: `artifact_hash` (algorithm-prefixed
+ * canonical hash), `bound_event_id`, `artifact_kind` (free-form string, e.g.
+ * `legible_record`, `session_recording`). Optional: `uri`, `media_type`,
+ * `producer_id`, `producer_version`. Artifacts are advisory; the chain event
+ * is authoritative.
+ */
+export declare const EVENT_TYPE_ARTIFACT_ATTESTED: "artifact_attested";
+export declare const AuditEventSchema: z.ZodObject<{
+    aae_version: z.ZodString;
+    event_id: z.ZodString;
+    event_type: z.ZodString;
+    proposal_id: z.ZodString;
+    tenant_id: z.ZodString;
+    agent_id: z.ZodString;
+    actor: z.ZodString;
+    ts: z.ZodString;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    prev_event_hash: z.ZodNullable<z.ZodString>;
+    this_event_hash: z.ZodString;
+    signature: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        alg: z.ZodEnum<["ed25519", "ecdsa-p256", "rsa-pss-sha256"]>;
+        key_id: z.ZodString;
+        value: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        value: string;
+        alg: "ed25519" | "ecdsa-p256" | "rsa-pss-sha256";
+        key_id: string;
+    }, {
+        value: string;
+        alg: "ed25519" | "ecdsa-p256" | "rsa-pss-sha256";
+        key_id: string;
+    }>>>;
+}, "strict", z.ZodTypeAny, {
+    aae_version: string;
+    proposal_id: string;
+    agent_id: string;
+    tenant_id: string;
+    event_id: string;
+    event_type: string;
+    actor: string;
+    ts: string;
+    payload: Record<string, unknown>;
+    prev_event_hash: string | null;
+    this_event_hash: string;
+    signature?: {
+        value: string;
+        alg: "ed25519" | "ecdsa-p256" | "rsa-pss-sha256";
+        key_id: string;
+    } | null | undefined;
+}, {
+    aae_version: string;
+    proposal_id: string;
+    agent_id: string;
+    tenant_id: string;
+    event_id: string;
+    event_type: string;
+    actor: string;
+    ts: string;
+    payload: Record<string, unknown>;
+    prev_event_hash: string | null;
+    this_event_hash: string;
+    signature?: {
+        value: string;
+        alg: "ed25519" | "ecdsa-p256" | "rsa-pss-sha256";
+        key_id: string;
+    } | null | undefined;
+}>;
+export type AuditEvent = z.infer<typeof AuditEventSchema>;
+export declare const ToolRegistrationSchema: z.ZodObject<{
+    aae_version: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    plan_schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    preview_schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    preview_supported: z.ZodBoolean;
+    default_blast_radius: z.ZodEnum<["read_only", "single_service", "single_host", "multi_host", "irreversible"]>;
+    aae_required: z.ZodBoolean;
+    data_classes_touched: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    compliance_relevant: z.ZodDefault<z.ZodBoolean>;
+    systems_of_record: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    reversibility: z.ZodOptional<z.ZodEnum<["reversible", "partially_reversible", "irreversible"]>>;
+}, "strict", z.ZodTypeAny, {
+    aae_version: string;
+    name: string;
+    plan_schema: Record<string, unknown>;
+    preview_supported: boolean;
+    default_blast_radius: "read_only" | "single_service" | "single_host" | "multi_host" | "irreversible";
+    aae_required: boolean;
+    data_classes_touched: string[];
+    compliance_relevant: boolean;
+    systems_of_record: string[];
+    description?: string | undefined;
+    preview_schema?: Record<string, unknown> | undefined;
+    reversibility?: "irreversible" | "reversible" | "partially_reversible" | undefined;
+}, {
+    aae_version: string;
+    name: string;
+    plan_schema: Record<string, unknown>;
+    preview_supported: boolean;
+    default_blast_radius: "read_only" | "single_service" | "single_host" | "multi_host" | "irreversible";
+    aae_required: boolean;
+    description?: string | undefined;
+    preview_schema?: Record<string, unknown> | undefined;
+    data_classes_touched?: string[] | undefined;
+    compliance_relevant?: boolean | undefined;
+    systems_of_record?: string[] | undefined;
+    reversibility?: "irreversible" | "reversible" | "partially_reversible" | undefined;
+}>;
+export type ToolRegistration = z.infer<typeof ToolRegistrationSchema>;
+//# sourceMappingURL=models.d.ts.map

package/dist/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../src/models.ts"],"names":[],"mappings":"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"}