@seamward/setup-mcp 0.1.0-alpha.9

package/dist/contracts.js

@@ -0,0 +1,931 @@
+import * as z from "zod/v4";
+export const setupMcpSchemaVersion = "seamward.setup-mcp/4";
+export const fingerprintSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+export const setupMcpErrorCodes = [
+    "plan_not_found",
+    "legacy_plan_requires_replan",
+    "confirmation_required",
+    "no_matching_actions",
+    "invalid_input",
+    "scan_limit_exceeded",
+    "generated_file_conflict",
+    "apply_in_progress",
+    "setup_preview_stale",
+    "idempotency_conflict",
+    "verification_failed",
+    "setup_state_conflict",
+    "stale_setup_lock",
+    "configuration_required",
+    "contract_preview_expired",
+    "contract_activation_conflict",
+    "authentication_required",
+    "insufficient_scope",
+    "integration_scope_mismatch",
+    "integration_mapping_required",
+    "contract_version_conflict",
+    "source_verification_required",
+    "not_found",
+    "remote_conflict",
+    "rate_limited",
+    "service_unavailable",
+    "remote_request_failed",
+    "remote_response_invalid",
+    "plan_conflict",
+    "internal_error",
+];
+export const setupMcpErrorCodeSchema = z.enum(setupMcpErrorCodes);
+export const setupMcpErrorRecovery = {
+    plan_not_found: {
+        retryable: false,
+        recovery: "Run prepare_setup to create a current setup plan.",
+    },
+    legacy_plan_requires_replan: {
+        retryable: false,
+        recovery: "Run prepare_setup and review the replacement plan.",
+    },
+    confirmation_required: {
+        retryable: false,
+        recovery: "Approve the requested trust boundary before applying it.",
+    },
+    no_matching_actions: {
+        retryable: false,
+        recovery: "Run prepare_setup and choose one of the proposed operations.",
+    },
+    invalid_input: {
+        retryable: false,
+        recovery: "Correct the request to match the published tool schema.",
+    },
+    scan_limit_exceeded: {
+        retryable: false,
+        recovery: "Narrow the configured service root, then run prepare_setup again.",
+    },
+    generated_file_conflict: {
+        retryable: false,
+        recovery: "Review the changed generated file and explicitly replace or preserve it before preparing again.",
+    },
+    apply_in_progress: {
+        retryable: true,
+        recovery: "Wait for the active local apply to finish, then retry.",
+    },
+    setup_preview_stale: {
+        retryable: false,
+        recovery: "Run review_remote_setup again and approve the current Integration preview.",
+    },
+    idempotency_conflict: {
+        retryable: false,
+        recovery: "Keep the original request for that idempotency key, or review the setup again before applying a different request.",
+    },
+    verification_failed: {
+        retryable: false,
+        recovery: "Review the verification failure, correct the source or project checks, then prepare and apply again.",
+    },
+    setup_state_conflict: {
+        retryable: false,
+        recovery: "Run check_setup_status, then prepare and review the current state again.",
+    },
+    stale_setup_lock: {
+        retryable: false,
+        recovery: "Confirm no setup apply is running, remove only the reported stale lock, then prepare again.",
+    },
+    configuration_required: {
+        retryable: false,
+        recovery: "Run npx @seamward/setup@alpha to authorize the application environment, then restart the coding agent and review the remote setup again.",
+    },
+    contract_preview_expired: {
+        retryable: false,
+        recovery: "Run review_remote_setup again before approving a remote change.",
+    },
+    contract_activation_conflict: {
+        retryable: false,
+        recovery: "Read the current contract state and run review_remote_setup again.",
+    },
+    authentication_required: {
+        retryable: false,
+        recovery: "Run npx @seamward/setup@alpha and approve the application environment again, then restart the coding agent.",
+    },
+    insufficient_scope: {
+        retryable: false,
+        recovery: "Run npx @seamward/setup@alpha and approve the application environment again with the requested access, then restart the coding agent.",
+    },
+    integration_scope_mismatch: {
+        retryable: false,
+        recovery: "Choose the correct integration boundary and run prepare_setup again.",
+    },
+    integration_mapping_required: {
+        retryable: false,
+        recovery: "Select the matching existing Integration or adjust the proposed name and provider, then run the setup review again.",
+    },
+    contract_version_conflict: {
+        retryable: false,
+        recovery: "Choose a new immutable contract version or review the existing version.",
+    },
+    source_verification_required: {
+        retryable: false,
+        recovery: "Run apply_local_setup and resolve every source verification failure.",
+    },
+    not_found: {
+        retryable: false,
+        recovery: "Verify the workspace and integration connection, then review the setup again.",
+    },
+    remote_conflict: {
+        retryable: false,
+        recovery: "Read the current remote state and run review_remote_setup again.",
+    },
+    rate_limited: {
+        retryable: true,
+        recovery: "Wait for the reported retry interval, then repeat the same request.",
+    },
+    service_unavailable: {
+        retryable: true,
+        recovery: "Wait for Seamward service health to recover, then repeat the same request.",
+    },
+    remote_request_failed: {
+        retryable: false,
+        recovery: "Verify the request and access configuration, then review again.",
+    },
+    remote_response_invalid: {
+        retryable: false,
+        recovery: "Report the invalid service response before trying again.",
+    },
+    plan_conflict: {
+        retryable: false,
+        recovery: "Run prepare_setup and review the current plan again.",
+    },
+    internal_error: {
+        retryable: false,
+        recovery: "Inspect the local setup logs and report the failure before trying again.",
+    },
+};
+export const setupMcpErrorOutputSchema = z
+    .object({
+    schemaVersion: z.literal(setupMcpSchemaVersion),
+    error: z
+        .object({
+        code: setupMcpErrorCodeSchema,
+        retryable: z.boolean(),
+        message: z.string().min(1),
+        recovery: z.string().min(1),
+    })
+        .strict(),
+})
+    .strict();
+const envelope = (data) => z.object({ schemaVersion: z.literal(setupMcpSchemaVersion), data }).strict();
+const fingerprint = fingerprintSchema;
+const integrationScope = z
+    .object({
+    direction: z.enum(["inbound", "outbound"]),
+    protocol: z.enum(["http-api", "http-webhook", "queue", "scheduled-feed"]),
+})
+    .strict();
+const integrationGroupSummary = z
+    .object({
+    setupId: z.string().min(1),
+    name: z.string().min(1),
+    scope: integrationScope,
+    operationCount: z.number().int().positive(),
+    contractFiles: z.array(z.string()),
+    confidence: z.enum(["high", "review_required"]),
+    requiredEnvironment: z.array(z.string()).length(2).optional(),
+})
+    .strict();
+const contractArtifact = z
+    .object({
+    file: z.string(),
+    format: z.enum(["openapi", "json_schema"]),
+    operationCount: z.number().int().nonnegative().nullable(),
+    fingerprint,
+})
+    .strict();
+const discoveryFinding = z
+    .object({
+    id: z.string(),
+    file: z.string(),
+    line: z.number().int().positive(),
+    language: z.enum(["typescript", "javascript", "python", "php", "go"]),
+    protocol: z.enum(["http", "webhook", "queue", "scheduled_feed"]),
+    direction: z.enum(["inbound", "outbound"]),
+    kind: z.enum([
+        "http_client",
+        "http_server",
+        "webhook_handler",
+        "queue_publish",
+        "queue_consume",
+        "scheduled_feed",
+    ]),
+    confidence: z.enum(["high", "medium"]),
+    detector: z.string(),
+    fileFingerprint: fingerprint,
+    targetHint: z.string().optional(),
+})
+    .strict();
+const discoveryResult = z
+    .object({
+    schemaVersion: z.literal("0.2"),
+    repositoryFingerprint: fingerprint,
+    scanPolicyVersion: z.literal("seamward-scan/1"),
+    scannedFiles: z.number().int().nonnegative(),
+    skippedFiles: z.number().int().nonnegative(),
+    languages: z.array(z.enum(["typescript", "javascript", "python", "php", "go"])),
+    findings: z.array(discoveryFinding),
+    contracts: z.array(contractArtifact),
+})
+    .strict();
+const setupAction = z
+    .object({
+    id: z.string(),
+    type: z.enum([
+        "create_bootstrap",
+        "instrument_operation",
+        "register_contract",
+    ]),
+    mode: z.enum(["automatic", "review_required", "manual"]),
+    adapter: z.string(),
+    language: z
+        .enum(["typescript", "javascript", "python", "php", "go"])
+        .optional(),
+    findingId: z.string().optional(),
+    file: z.string().optional(),
+    line: z.number().int().positive().optional(),
+    direction: z.enum(["inbound", "outbound"]).optional(),
+    protocol: z.enum(["http", "webhook", "queue", "scheduled_feed"]).optional(),
+    operationKind: z
+        .enum([
+        "http_client",
+        "http_server",
+        "webhook_handler",
+        "queue_publish",
+        "queue_consume",
+        "scheduled_feed",
+    ])
+        .optional(),
+    targetHint: z.string().optional(),
+    confidence: z.enum(["high", "medium"]).optional(),
+    contract: contractArtifact.optional(),
+    integrationScope: integrationScope.optional(),
+})
+    .strict();
+const setupPlan = z
+    .object({
+    schemaVersion: z.literal("0.2"),
+    setupId: z.string().min(1).optional(),
+    analysisFingerprint: fingerprint,
+    projectName: z.string(),
+    integrationScope: integrationScope.nullable(),
+    excludedIntegrationScopes: z.array(integrationScope),
+    unassignedContracts: z.array(contractArtifact),
+    connectionKeyEnvironment: z.string(),
+    runtimeTarget: z.enum(["node-esm", "node-commonjs", "unknown"]),
+    packageManager: z.enum(["npm", "pnpm", "yarn", "bun"]).nullable(),
+    requiredEnvironment: z.tuple([z.string(), z.string()]),
+    install: z
+        .object({
+        package: z.literal("@seamward/collector"),
+        command: z.string(),
+    })
+        .strict()
+        .nullable(),
+    discovery: discoveryResult,
+    actions: z.array(setupAction),
+    generatedFiles: z.array(z
+        .object({
+        path: z.string(),
+        template: z.enum(["node_collector", "node_collector_v2"]),
+    })
+        .strict()),
+    fingerprint,
+})
+    .strict();
+const applyResult = z
+    .object({
+    applied: z.boolean(),
+    fingerprint,
+    files: z.array(z.string()),
+})
+    .strict();
+const contractStatus = z
+    .object({
+    integrationId: z.string(),
+    activeContractVersionId: z.string().nullable(),
+    contracts: z.array(z
+        .object({
+        id: z.string(),
+        declaredVersion: z.string(),
+        lifecycleStatus: z.enum(["draft", "active", "superseded"]),
+    })
+        .strict()),
+})
+    .strict();
+const actionEvidence = z
+    .object({
+    actionId: z.string(),
+    actionType: z.enum([
+        "create_bootstrap",
+        "instrument_operation",
+        "register_contract",
+    ]),
+    status: z.enum([
+        "pending",
+        "source_verified",
+        "attested_only",
+        "stale",
+        "missing",
+        "registered",
+    ]),
+    evidenceFingerprint: fingerprint.optional(),
+    recordedAt: z.string().optional(),
+})
+    .strict();
+const remoteLifecycle = z
+    .object({
+    activation: z
+        .object({ contractVersionId: z.string(), recordedAt: z.string() })
+        .strict()
+        .optional(),
+    firstObservation: z
+        .object({
+        integrationId: z.string(),
+        observationId: z.string(),
+        receivedAt: z.string(),
+        recordedAt: z.string(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+export const contractBindingSchema = z
+    .object({
+    method: z.string().min(1).max(16).optional(),
+    routeTemplate: z.string().min(1).max(512),
+    eventType: z.string().min(1).max(200).optional(),
+    payloadLocation: z.enum(["request", "response", "message"]),
+    statusSelector: z.string().min(1).max(64).optional(),
+})
+    .strict();
+export const setupMcpInputSchemas = {
+    prepare_setup: z
+        .object({
+        direction: z.enum(["inbound", "outbound"]).optional(),
+        protocol: z
+            .enum(["http-api", "http-webhook", "queue", "scheduled-feed"])
+            .optional(),
+        contractFiles: z.array(z.string().min(1).max(512)).max(20).default([]),
+        includeSetupIds: z.array(z.string().min(1).max(63)).max(50).default([]),
+        excludeSetupIds: z.array(z.string().min(1).max(63)).max(50).default([]),
+    })
+        .strict()
+        .refine((value) => (value.direction === undefined) === (value.protocol === undefined), { message: "Direction and protocol must be selected together" })
+        .refine((value) => value.includeSetupIds.every((setupId) => !value.excludeSetupIds.includes(setupId)), { message: "A setup cannot be both included and excluded" }),
+    apply_local_setup: z.object({}).strict(),
+    review_remote_setup: z
+        .object({
+        declaredVersion: z.string().min(1).max(128).optional(),
+        contractFile: z.string().min(1).max(512).optional(),
+        integrationProposals: z
+            .array(z
+            .object({
+            setupId: z.string().min(1).max(128),
+            name: z.string().trim().min(1).max(120),
+            provider: z.string().trim().min(1).max(120),
+            preferredIntegrationId: z
+                .string()
+                .regex(/^int_[A-Za-z0-9_-]+$/)
+                .optional(),
+        })
+            .strict())
+            .max(20)
+            .default([]),
+        integrationMappings: z
+            .array(z
+            .object({
+            setupId: z.string().min(1).max(63),
+            integrationId: z.string().min(1).max(200),
+        })
+            .strict())
+            .max(50)
+            .default([]),
+    })
+        .strict(),
+    connect_remote_setup: z.object({}).strict(),
+    check_setup_status: z.object({}).strict(),
+    analyze_repository: z.object({}).strict(),
+    plan_setup: z
+        .object({
+        direction: z.enum(["inbound", "outbound"]),
+        protocol: z.enum(["http-api", "http-webhook", "queue", "scheduled-feed"]),
+        contractFiles: z.array(z.string().min(1).max(512)).max(20).default([]),
+    })
+        .strict(),
+    apply_generated_setup: z
+        .object({
+        planFingerprint: fingerprintSchema,
+        confirmation: z.literal("write_generated_setup"),
+    })
+        .strict(),
+    replace_generated_setup: z
+        .object({
+        previousPlanFingerprint: fingerprintSchema,
+        planFingerprint: fingerprintSchema,
+        confirmation: z.literal("replace_generated_setup"),
+    })
+        .strict(),
+    record_setup_evidence: z
+        .object({
+        planFingerprint: fingerprintSchema,
+        expectedStateFingerprint: fingerprintSchema,
+        implementationFiles: z.array(z.string().min(1).max(512)).min(1).max(100),
+        note: z.string().min(1).max(256).optional(),
+        confirmation: z.literal("record_source_evidence"),
+    })
+        .strict(),
+    verify_setup: z.object({ planFingerprint: fingerprintSchema }).strict(),
+    preview_contract_registration: z
+        .object({
+        planFingerprint: fingerprintSchema,
+        file: z.string().min(1).max(512).optional(),
+        declaredVersion: z.string().min(1).max(128),
+        includeExamples: z.boolean().default(false),
+        jsonSchemaBinding: contractBindingSchema.optional(),
+    })
+        .strict(),
+    register_contract: z
+        .object({
+        approvalFingerprint: fingerprintSchema,
+        confirmation: z.literal("register_contract"),
+    })
+        .strict(),
+    read_contract_status: z
+        .object({ planFingerprint: fingerprintSchema })
+        .strict(),
+    preview_contract_activation: z
+        .object({
+        planFingerprint: fingerprintSchema,
+        contractVersionId: z.string().min(1).max(128),
+        reason: z.enum(["promote", "rollback"]),
+    })
+        .strict(),
+    activate_contract: z
+        .object({
+        approvalFingerprint: fingerprintSchema,
+        confirmation: z.literal("activate_contract"),
+    })
+        .strict(),
+    check_first_observation: z
+        .object({ planFingerprint: fingerprintSchema })
+        .strict(),
+};
+export const setupMcpOutputSchemas = {
+    prepare_setup: envelope(z.discriminatedUnion("status", [
+        z
+            .object({
+            status: z.literal("ready"),
+            summary: z.string(),
+            scope: integrationScope.optional(),
+            groups: z.array(integrationGroupSummary).min(1).optional(),
+            removedGroups: z
+                .array(z
+                .object({
+                setupId: z.string(),
+                files: z.array(z.string()),
+                remoteAction: z.literal("left_active"),
+            })
+                .strict())
+                .optional(),
+            proposedChanges: z.array(z.union([
+                z
+                    .object({
+                    file: z.string(),
+                    description: z.string(),
+                    kind: z.literal("source"),
+                    operationLabel: z.string().min(1),
+                    line: z.number().int().positive(),
+                    direction: z.enum(["inbound", "outbound"]),
+                    operationKind: z.enum([
+                        "http_client",
+                        "http_server",
+                        "webhook_handler",
+                        "queue_publish",
+                        "queue_consume",
+                        "scheduled_feed",
+                    ]),
+                    adapter: z.string().min(1),
+                })
+                    .strict(),
+                z
+                    .object({
+                    file: z.string(),
+                    description: z.string(),
+                    kind: z.enum([
+                        "generated",
+                        "dependency",
+                        "contract",
+                        "removal",
+                    ]),
+                })
+                    .strict(),
+            ])),
+        })
+            .strict(),
+        z
+            .object({
+            status: z.literal("needs_input"),
+            summary: z.string(),
+            choices: z.array(integrationScope),
+            contractChoices: z.array(z.string()),
+        })
+            .strict(),
+        z
+            .object({
+            status: z.literal("manual_required"),
+            summary: z.string(),
+            reasons: z.array(z.string()),
+        })
+            .strict(),
+    ])),
+    apply_local_setup: envelope(z.discriminatedUnion("status", [
+        z
+            .object({
+            status: z.literal("verified"),
+            summary: z.string(),
+            files: z.array(z.string()),
+            groups: z
+                .array(z
+                .object({
+                setupId: z.string(),
+                status: z.literal("verified"),
+                files: z.array(z.string()),
+            })
+                .strict())
+                .optional(),
+            retiredGroups: z
+                .array(z
+                .object({
+                setupId: z.string(),
+                files: z.array(z.string()),
+                remoteAction: z.literal("left_active"),
+            })
+                .strict())
+                .optional(),
+            localSetupComplete: z.literal(true),
+        })
+            .strict(),
+        z
+            .object({
+            status: z.literal("manual_required"),
+            summary: z.string(),
+            reasons: z.array(z.string()),
+            localSetupComplete: z.literal(false),
+        })
+            .strict(),
+    ])),
+    review_remote_setup: envelope(z.discriminatedUnion("status", [
+        z
+            .object({
+            status: z.literal("ready"),
+            summary: z.string(),
+            contractFile: z.string().optional(),
+            declaredVersion: z.string().optional(),
+            effects: z.array(z.string()),
+            groups: z
+                .array(z
+                .object({
+                setupId: z.string(),
+                integrationId: z.string(),
+                name: z.string(),
+                action: z.enum(["create", "reuse"]).optional(),
+                provider: z.string().optional(),
+                direction: z.enum(["inbound", "outbound"]).optional(),
+                protocol: z
+                    .enum([
+                    "http-api",
+                    "http-webhook",
+                    "queue",
+                    "scheduled-feed",
+                ])
+                    .optional(),
+                contractFile: z.string().optional(),
+                declaredVersion: z.string().optional(),
+                effects: z.array(z.string()),
+            })
+                .strict())
+                .optional(),
+        })
+            .strict(),
+        z
+            .object({
+            status: z.literal("not_applicable"),
+            summary: z.string(),
+        })
+            .strict(),
+        z
+            .object({
+            status: z.literal("blocked"),
+            summary: z.string(),
+            blockers: z.array(z.string()),
+        })
+            .strict(),
+        z
+            .object({
+            status: z.literal("needs_input"),
+            summary: z.string(),
+            contractChoices: z.array(z.string()).optional(),
+            integrationChoices: z
+                .array(z
+                .object({
+                setupId: z.string(),
+                name: z.string(),
+                candidates: z.array(z
+                    .object({
+                    integrationId: z.string(),
+                    name: z.string(),
+                    provider: z.string(),
+                    direction: z.enum(["inbound", "outbound"]),
+                    protocol: z.enum([
+                        "http-api",
+                        "http-webhook",
+                        "queue",
+                        "scheduled-feed",
+                    ]),
+                })
+                    .strict()),
+            })
+                .strict())
+                .optional(),
+        })
+            .strict(),
+    ])),
+    connect_remote_setup: envelope(z
+        .object({
+        status: z.enum([
+            "connected",
+            "partially_connected",
+            "already_connected",
+        ]),
+        summary: z.string(),
+        contractStatus: z.enum([
+            "not_applicable",
+            "draft",
+            "active",
+            "unknown",
+        ]),
+        groups: z
+            .array(z
+            .object({
+            setupId: z.string(),
+            integrationId: z.string(),
+            status: z.enum([
+                "connected",
+                "partially_connected",
+                "already_connected",
+                "failed",
+                "not_attempted",
+            ]),
+            contractStatus: z.enum([
+                "not_applicable",
+                "draft",
+                "active",
+                "unknown",
+            ]),
+            errorCode: setupMcpErrorCodeSchema.optional(),
+        })
+            .strict())
+            .optional(),
+    })
+        .strict()),
+    check_setup_status: envelope(z
+        .object({
+        status: z.enum([
+            "not_prepared",
+            "local_changes_required",
+            "ready_to_connect",
+            "waiting_for_traffic",
+            "partially_connected",
+            "connected",
+            "stale",
+            "conflict",
+        ]),
+        summary: z.string(),
+        localSetupComplete: z.boolean(),
+        contractStatus: z.enum([
+            "not_applicable",
+            "missing",
+            "draft",
+            "active",
+        ]),
+        firstObservation: z.enum(["not_checked", "waiting", "observed"]),
+        groups: z
+            .array(z
+            .object({
+            setupId: z.string(),
+            status: z.enum([
+                "local_changes_required",
+                "ready_to_connect",
+                "waiting_for_traffic",
+                "connected",
+                "stale",
+                "conflict",
+            ]),
+            contractStatus: z.enum([
+                "not_applicable",
+                "missing",
+                "draft",
+                "active",
+            ]),
+            firstObservation: z.enum([
+                "not_checked",
+                "waiting",
+                "observed",
+            ]),
+        })
+            .strict())
+            .optional(),
+    })
+        .strict()),
+    analyze_repository: envelope(z
+        .object({
+        project: z
+            .object({
+            projectName: z.string(),
+            packageManager: z.enum(["npm", "pnpm", "yarn", "bun"]),
+            runtimeTarget: z.enum(["node-esm", "node-commonjs", "unknown"]),
+        })
+            .strict(),
+        discovery: discoveryResult,
+        integrationScopes: z.array(integrationScope),
+        privacy: z
+            .object({
+            sourceContentReturned: z.literal(false),
+            environmentFilesRead: z.literal(false),
+            absolutePathsReturned: z.literal(false),
+            credentialsReturned: z.literal(false),
+        })
+            .strict(),
+    })
+        .strict()),
+    plan_setup: envelope(z
+        .object({
+        plan: setupPlan,
+        applyPreview: applyResult,
+    })
+        .strict()),
+    apply_generated_setup: envelope(applyResult),
+    replace_generated_setup: envelope(applyResult),
+    record_setup_evidence: envelope(z
+        .object({
+        applied: z.literal(true),
+        planFingerprint: fingerprint,
+        recordedActions: z.array(z
+            .object({
+            file: z.string().nullable(),
+            status: z.literal("recorded"),
+        })
+            .strict()),
+    })
+        .strict()),
+    verify_setup: envelope(z
+        .object({
+        planFingerprint: fingerprint,
+        stateFingerprint: fingerprint,
+        sourceBackedComplete: z.boolean(),
+        localSetupComplete: z.boolean(),
+        setupComplete: z.boolean(),
+        blockers: z.array(z.object({ code: z.string(), file: z.string().optional() }).strict()),
+        artifactsValid: z.boolean(),
+        collectorDependency: z
+            .object({
+            present: z.boolean(),
+            compatible: z.boolean(),
+            version: z.string().nullable(),
+            minimumVersion: z.string(),
+        })
+            .strict(),
+        generatedFiles: z.array(z
+            .object({
+            file: z.string(),
+            present: z.boolean(),
+            matches: z.boolean(),
+        })
+            .strict()),
+        instrumentationActions: z.array(actionEvidence),
+        contractActions: z.array(actionEvidence),
+        remoteLifecycle,
+    })
+        .strict()),
+    preview_contract_registration: envelope(z
+        .object({
+        approvalFingerprint: fingerprint,
+        integrationId: z.string(),
+        file: z.string(),
+        format: z.enum(["openapi", "json_schema"]),
+        fingerprint,
+        byteSize: z.number().int().nonnegative(),
+        removedExampleFields: z.number().int().nonnegative(),
+        operationBinding: contractBindingSchema.optional(),
+    })
+        .strict()),
+    register_contract: envelope(z
+        .object({
+        integrationId: z.string(),
+        registered: z.array(z
+            .object({
+            file: z.string(),
+            contractVersionId: z.string(),
+            status: z.literal("draft"),
+            removedExampleFields: z.number().int().nonnegative(),
+        })
+            .strict()),
+        skipped: z.array(z.never()),
+    })
+        .strict()),
+    read_contract_status: envelope(contractStatus),
+    preview_contract_activation: envelope(z
+        .object({
+        planFingerprint: fingerprint,
+        stateFingerprint: fingerprint,
+        contractVersionId: z.string(),
+        expectedActiveContractVersionId: z.string().nullable(),
+        reason: z.enum(["promote", "rollback"]),
+        reconcile: z.boolean(),
+        integrationId: z.string(),
+        approvalFingerprint: fingerprint,
+    })
+        .strict()),
+    activate_contract: envelope(z.union([
+        z
+            .object({
+            integrationId: z.string(),
+            activationId: z.string(),
+            activeContractVersionId: z.string(),
+            previousActiveContractVersionId: z.string().nullable(),
+            revision: z.number().int().positive(),
+        })
+            .strict(),
+        z
+            .object({
+            integrationId: z.string(),
+            activeContractVersionId: z.string(),
+            reconciled: z.literal(true),
+        })
+            .strict(),
+    ])),
+    check_first_observation: envelope(z.discriminatedUnion("status", [
+        z.object({ status: z.literal("source_verification_required") }).strict(),
+        z.object({ status: z.literal("contract_activation_required") }).strict(),
+        z
+            .object({
+            status: z.literal("waiting"),
+            integrationId: z.string(),
+            checkedFrom: z.string(),
+        })
+            .strict(),
+        z
+            .object({
+            status: z.literal("observed"),
+            integrationId: z.string(),
+            observation: z
+                .object({ id: z.string(), receivedAt: z.string() })
+                .strict(),
+            scope: z.literal("integration_connection"),
+        })
+            .strict(),
+    ])),
+};
+function tool(name, title, description, options) {
+    return {
+        name,
+        title,
+        description,
+        inputSchema: setupMcpInputSchemas[name],
+        outputSchema: setupMcpOutputSchemas[name],
+        ...options,
+    };
+}
+export const setupMcpToolDefinitions = [
+    tool("prepare_setup", "Prepare Seamward setup", "Analyze this service and present one plain-language setup proposal. If the repository is ambiguous, return readable choices without guessing.", { readOnly: true, destructive: false, idempotent: true, openWorld: false }),
+    tool("apply_local_setup", "Apply local Seamward setup", "Apply the reviewed local setup as one operation: install the collector, write plan-owned files, instrument supported source boundaries, run project verification, record evidence, and roll back on failure.", { readOnly: false, destructive: true, idempotent: true, openWorld: true }),
+    tool("review_remote_setup", "Review remote Seamward connection", "Read current contract state and present the exact remote effects for one approval. This tool does not change remote state.", { readOnly: true, destructive: false, idempotent: true, openWorld: true }),
+    tool("connect_remote_setup", "Connect Seamward remotely", "Connect the reviewed contract as one retry-safe operation. Register and activate a new version when required, or link an exact already-active version to the reviewed local setup without a remote write.", { readOnly: false, destructive: true, idempotent: true, openWorld: true }),
+    tool("check_setup_status", "Check Seamward setup status", "Read local verification, active contract state, and the first accepted observation without changing local or remote state.", { readOnly: true, destructive: false, idempotent: true, openWorld: true }),
+];
+export const legacySetupMcpToolDefinitions = [
+    tool("analyze_repository", "Analyze repository", "Scan the configured service root locally and return redacted integration boundaries. Source contents and environment files are never returned.", { readOnly: true, destructive: false, idempotent: true, openWorld: false }),
+    tool("plan_setup", "Plan Seamward setup", "Build one deterministic, scope-specific setup plan without writing files.", { readOnly: true, destructive: false, idempotent: true, openWorld: false }),
+    tool("apply_generated_setup", "Apply generated setup", "Write only a first reviewed setup plan and generated collector bootstrap after exact confirmation.", { readOnly: false, destructive: false, idempotent: true, openWorld: false }),
+    tool("replace_generated_setup", "Replace generated setup", "Replace an unchanged generated plan with a reviewed replan, then reset prior evidence. Reviewer-modified generated files are never overwritten.", { readOnly: false, destructive: true, idempotent: false, openWorld: false }),
+    tool("record_setup_evidence", "Record source-backed setup evidence", "Verify planned adapters in local implementation files and replace their evidence record after an optimistic state check.", { readOnly: false, destructive: true, idempotent: false, openWorld: false }),
+    tool("verify_setup", "Verify Seamward setup", "Verify local artifacts, current source evidence, contract lifecycle, and first-observation state without writing.", { readOnly: true, destructive: false, idempotent: true, openWorld: false }),
+    tool("preview_contract_registration", "Preview contract registration", "Validate one planned contract locally and return an approval fingerprint without a network request.", { readOnly: true, destructive: false, idempotent: true, openWorld: false }),
+    tool("register_contract", "Register contract", "Register the exact locally previewed contract as an immutable draft after confirmation.", { readOnly: false, destructive: false, idempotent: false, openWorld: true }),
+    tool("read_contract_status", "Read contract status", "List contract versions and the active version for this Integration.", { readOnly: true, destructive: false, idempotent: true, openWorld: true }),
+    tool("preview_contract_activation", "Preview contract activation", "Require source-backed evidence, read the active contract, and bind a plan-owned promotion or rollback to an approval fingerprint.", { readOnly: true, destructive: false, idempotent: true, openWorld: true }),
+    tool("activate_contract", "Activate contract", "Activate the exact previewed contract version after confirmation and optimistic-concurrency validation.", { readOnly: false, destructive: true, idempotent: false, openWorld: true }),
+    tool("check_first_observation", "Check first observation", "Read the redacted Observation API after source verification and persist the first accepted observation.", { readOnly: false, destructive: false, idempotent: true, openWorld: true }),
+];
+export function toolAnnotations(readOnly, destructive, idempotent, openWorld) {
+    return {
+        readOnlyHint: readOnly,
+        destructiveHint: destructive,
+        idempotentHint: idempotent,
+        openWorldHint: openWorld,
+    };
+}
+//# sourceMappingURL=contracts.js.map