@setluca/mcp 0.1.1 → 0.2.1

package/dist/operations.js

@@ -1,780 +1,11 @@
-import * as z from "zod/v4";
-import { OPENAPI_INPUTS } from "./generated/openapi-inputs.js";
-import { OPENAPI_OUTPUTS } from "./generated/openapi-outputs.js";
-import { openApiToolInputShape, openApiToolOutputShape, } from "./openapi-zod.js";
-const LUCA_OPERATION_GROUPS = {
-    capabilities: {
-        title: "Capabilities",
-        description: "Public API capabilities and boundary discovery.",
-    },
-    leads: {
-        title: "Leads",
-        description: "Lead identity, consent, notes, custom fields, and imports.",
-    },
-    conversations: {
-        title: "Conversations",
-        description: "Conversation search and message context.",
-    },
-    reviewQueue: {
-        title: "Review Queue",
-        description: "Human review queue visibility.",
-    },
-    bookings: {
-        title: "Bookings",
-        description: "Booking creation, scheduling, and cancellation.",
-    },
-    campaigns: {
-        title: "Campaigns",
-        description: "Campaign drafts, enrollment, analytics, comments, and simulations.",
-    },
-    broadcasts: {
-        title: "Broadcasts",
-        description: "Broadcast draft, approval, launch, pause, retry, and cancel flows.",
-    },
-    webhooks: {
-        title: "Webhooks",
-        description: "Webhook subscriptions, deliveries, signatures, and replays.",
-    },
-    integrations: {
-        title: "Integrations",
-        description: "CRM connections, OAuth, mappings, sync runs, and event logs.",
-    },
-    voice: {
-        title: "Voice",
-        description: "Read-only voice-fingerprint summary.",
-    },
-};
-function requiredScopeFor(input) {
-    let capability = "draft";
-    if (input.method === "GET") {
-        capability = "read";
-    }
-    else if (input.confirmRequired) {
-        // Real-world side effect (sends, enrollments, replays) = operating the
-        // live queue.
-        capability = "queue_ops";
-    }
-    return {
-        capability,
-        dataSensitivity: input.untrustedContent ? "full_content" : "redacted",
-    };
-}
-/**
- * Operation groups whose responses carry text authored by leads or other
- * external users (conversation messages, lead-provided profile fields, the
- * review queue's inbound context). Output from these tools is wrapped with an
- * untrusted-content boundary so a downstream agent treats it as data, never as
- * instructions (prompt-injection defense).
- */
-const UNTRUSTED_CONTENT_GROUPS = new Set([
-    "conversations",
-    "leads",
-    "reviewQueue",
-]);
-/** Server-side bounded auto-pagination guard for list tools. */
-export const DEFAULT_MAX_PAGES = 10;
-const MAX_PAGES_LIMIT = 50;
-const workspaceInput = {
-    workspaceId: z
-        .string()
-        .uuid()
-        .optional()
-        .describe("Optional Luca workspace id override."),
-    workspaceSlug: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("Optional Luca workspace slug override."),
-};
-const idempotencyInput = {
-    idempotencyKey: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("Stable key for safe retries. If omitted, the MCP server generates a unique key for this call."),
-};
-const confirmInput = {
-    confirm: z
-        .boolean()
-        .optional()
-        .describe("This tool has a real-world side effect (sends messages or re-triggers downstream automations). Pass confirm: true to proceed; the call is rejected without it."),
-};
-const paginationInput = {
-    maxPages: z
-        .number()
-        .int()
-        .min(1)
-        .max(MAX_PAGES_LIMIT)
-        .optional()
-        .describe(`Max pages the server auto-fetches and merges (default ${DEFAULT_MAX_PAGES}, hard cap ${MAX_PAGES_LIMIT}). If more remain, the result is marked truncated with a nextCursor to continue.`),
-};
-function commonInput(input) {
-    return {
-        ...(input.query ? { query: input.query } : {}),
-        ...(input.body ? { body: input.body } : {}),
-        ...(input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {}),
-        workspace: {
-            ...(input.workspaceId ? { workspaceId: input.workspaceId } : {}),
-            ...(input.workspaceSlug ? { workspaceSlug: input.workspaceSlug } : {}),
-        },
-    };
-}
-function pathParams(input, path) {
-    const params = {};
-    for (const [, key] of path.matchAll(/\{([^}]+)\}/g)) {
-        if (!key) {
-            continue;
-        }
-        const value = input[key];
-        if (typeof value === "string") {
-            params[key] = value;
-        }
-    }
-    return params;
-}
-function inputSchemaFor(input) {
-    const shape = openApiToolInputShape({
-        spec: OPENAPI_INPUTS[`${input.method} ${input.path}`],
-        workspaceInput,
-        idempotencyInput,
-        idempotencyRequired: input.idempotencyRequired,
-    });
-    if (input.confirmRequired) {
-        Object.assign(shape, confirmInput);
-    }
-    if (input.paginates) {
-        Object.assign(shape, paginationInput);
-    }
-    return shape;
-}
-function operationGroupForId(id) {
-    const [prefix] = id.split(".");
-    if (prefix && prefix in LUCA_OPERATION_GROUPS) {
-        return prefix;
-    }
-    throw new Error(`Unknown Luca operation group for operation id: ${id}`);
-}
-function op(input) {
-    const idempotencyRequired = input.idempotencyRequired ?? false;
-    const confirmRequired = input.confirmRequired ?? false;
-    const paginates = input.method === "GET" && input.id.endsWith(".list");
-    const group = operationGroupForId(input.id);
-    const untrustedContent = input.untrustedContent ??
-        (input.method === "GET" && UNTRUSTED_CONTENT_GROUPS.has(group));
-    const operation = {
-        id: input.id,
-        group,
-        toolName: `luca_${input.id.replaceAll(".", "_")}`,
-        title: `Luca ${input.id}`,
-        method: input.method,
-        path: input.path,
-        scopes: input.scopes,
-        idempotencyRequired,
-        confirmRequired,
-        paginates,
-        untrustedContent,
-        requiredScope: requiredScopeFor({
-            method: input.method,
-            confirmRequired,
-            untrustedContent,
-        }),
-        description: input.description,
-        inputSchema: inputSchemaFor({
-            method: input.method,
-            path: input.path,
-            idempotencyRequired,
-            confirmRequired,
-            paginates,
-        }),
-        outputSchema: openApiToolOutputShape({
-            body: OPENAPI_OUTPUTS[`${input.method} ${input.path}`],
-            untrustedContent,
-        }),
-        buildRequest: (toolInput) => ({
-            pathParams: pathParams(toolInput, input.path),
-            ...commonInput(toolInput),
-        }),
-    };
-    return operation;
-}
-export const LUCA_OPERATIONS = [
-    op({
-        id: "capabilities.get",
-        method: "GET",
-        path: "/api/capabilities",
-        scopes: [
-            "leads:read",
-            "conversations:read",
-            "bookings:read",
-            "campaigns:read",
-            "broadcasts:read",
-            "webhooks:read",
-            "integrations:read",
-        ],
-        description: "Describe Luca's public API capabilities, scopes, and boundaries.",
-    }),
-    op({
-        id: "leads.list",
-        method: "GET",
-        path: "/api/leads",
-        scopes: ["leads:read"],
-        description: "List leads. Query supports limit, cursor, channel, and q according to Luca OpenAPI.",
-    }),
-    op({
-        id: "leads.get",
-        method: "GET",
-        path: "/api/leads/{id}",
-        scopes: ["leads:read"],
-        description: "Get a lead's full timeline and notes.",
-    }),
-    op({
-        id: "leads.explain",
-        method: "GET",
-        path: "/api/leads/{id}/explain",
-        scopes: ["leads:read"],
-        description: "Explain why a lead qualified: the qualifier's reasoning, signals, and confidence from its most recent drafted turn.",
-    }),
-    op({
-        id: "leads.create",
-        method: "POST",
-        path: "/api/leads",
-        scopes: ["leads:write"],
-        idempotencyRequired: true,
-        description: "Create or upsert a lead identity. Body requires channel and externalUserId.",
-    }),
-    op({
-        id: "leads.update",
-        method: "PATCH",
-        path: "/api/leads/{id}",
-        scopes: ["leads:write"],
-        idempotencyRequired: true,
-        description: "Update a lead's display name, stage, score, tags, or custom fields.",
-    }),
-    op({
-        id: "leads.fieldDefinitions.list",
-        method: "GET",
-        path: "/api/leads/field-definitions",
-        scopes: ["leads:read"],
-        description: "List custom lead field definitions.",
-    }),
-    op({
-        id: "leads.fieldDefinitions.upsert",
-        method: "POST",
-        path: "/api/leads/field-definitions",
-        scopes: ["leads:write"],
-        idempotencyRequired: true,
-        description: "Create or update a custom lead field definition.",
-    }),
-    op({
-        id: "leads.importPreview",
-        method: "POST",
-        path: "/api/leads/imports/preview",
-        scopes: ["leads:read"],
-        description: "Preview a mapped CSV lead import before applying it.",
-    }),
-    op({
-        id: "leads.importApply",
-        method: "POST",
-        path: "/api/leads/imports/apply",
-        scopes: ["leads:write"],
-        idempotencyRequired: true,
-        description: "Apply a mapped lead import with consent evidence.",
-    }),
-    op({
-        id: "leads.identities.attach",
-        method: "POST",
-        path: "/api/leads/{id}/identities",
-        scopes: ["leads:write"],
-        idempotencyRequired: true,
-        description: "Attach a verified or claimed identity to a lead.",
-    }),
-    op({
-        id: "leads.consents.grant",
-        method: "POST",
-        path: "/api/leads/{id}/consents",
-        scopes: ["leads:write"],
-        idempotencyRequired: true,
-        description: "Grant explicit lead consent for a channel purpose.",
-    }),
-    op({
-        id: "leads.consents.revoke",
-        method: "POST",
-        path: "/api/leads/{id}/consents/revoke",
-        scopes: ["leads:write"],
-        idempotencyRequired: true,
-        description: "Revoke explicit lead consent for a channel purpose.",
-    }),
-    op({
-        id: "leads.notes.add",
-        method: "POST",
-        path: "/api/leads/{id}/notes",
-        scopes: ["leads:write"],
-        idempotencyRequired: true,
-        description: "Append a coach note to a lead. Body requires body.",
-    }),
-    op({
-        id: "conversations.list",
-        method: "GET",
-        path: "/api/conversations",
-        scopes: ["conversations:read"],
-        description: "List recent conversations. Query supports limit, cursor, channel, and q.",
-    }),
-    op({
-        id: "conversations.get",
-        method: "GET",
-        path: "/api/conversations/{id}",
-        scopes: ["conversations:read"],
-        description: "Get a conversation with messages and lead context.",
-    }),
-    op({
-        id: "reviewQueue.list",
-        method: "GET",
-        path: "/api/review-queue",
-        scopes: ["review_queue:read"],
-        description: "List review-queue items when the API key has review queue access.",
-    }),
-    op({
-        id: "reviewQueue.explain",
-        method: "GET",
-        path: "/api/review-queue/{id}/explain",
-        scopes: ["review_queue:read"],
-        description: "Explain the signals behind a drafted reply: its voice-match score, any critic findings, and the qualification that motivated it.",
-    }),
-    op({
-        id: "bookings.list",
-        method: "GET",
-        path: "/api/bookings",
-        scopes: ["bookings:read"],
-        description: "List bookings. Query supports limit, cursor, status, and upcoming.",
-    }),
-    op({
-        id: "bookings.create",
-        method: "POST",
-        path: "/api/bookings",
-        scopes: ["bookings:write"],
-        idempotencyRequired: true,
-        description: "Create a provider-neutral booking record. Body requires leadId and slotAt.",
-    }),
-    op({
-        id: "bookings.update",
-        method: "PATCH",
-        path: "/api/bookings/{id}",
-        scopes: ["bookings:write"],
-        idempotencyRequired: true,
-        description: "Reschedule or update booking status.",
-    }),
-    op({
-        id: "bookings.cancel",
-        method: "DELETE",
-        path: "/api/bookings/{id}",
-        scopes: ["bookings:write"],
-        idempotencyRequired: true,
-        description: "Cancel a booking.",
-    }),
-    op({
-        id: "campaigns.list",
-        method: "GET",
-        path: "/api/campaigns",
-        scopes: ["campaigns:read"],
-        description: "List campaigns. Query supports limit, cursor, and status.",
-    }),
-    op({
-        id: "campaigns.get",
-        method: "GET",
-        path: "/api/campaigns/{id}",
-        scopes: ["campaigns:read"],
-        description: "Get campaign draft and latest published version.",
-    }),
-    op({
-        id: "campaigns.create",
-        method: "POST",
-        path: "/api/campaigns",
-        scopes: ["campaigns:write"],
-        idempotencyRequired: true,
-        description: "Create a campaign draft. Body requires name and may include graph.",
-    }),
-    op({
-        id: "campaigns.generate",
-        method: "POST",
-        path: "/api/campaigns/generate",
-        scopes: ["campaigns:write"],
-        idempotencyRequired: true,
-        description: "Generate a safe AI campaign plan without creating or publishing it.",
-    }),
-    op({
-        id: "campaigns.draft.update",
-        method: "PATCH",
-        path: "/api/campaigns/{id}/draft",
-        scopes: ["campaigns:write"],
-        description: "Autosave a campaign draft.",
-        // The route requires an idempotency key; without this the tool never sends
-        // one and every call is rejected (the dead-tool the drift guard now flags).
-        idempotencyRequired: true,
-    }),
-    op({
-        id: "campaigns.enrollments.list",
-        method: "GET",
-        path: "/api/campaigns/{id}/enrollments",
-        scopes: ["campaigns:read"],
-        description: "List campaign enrollments.",
-    }),
-    op({
-        id: "campaigns.enroll",
-        method: "POST",
-        path: "/api/campaigns/{id}/enrollments",
-        scopes: ["campaigns:write"],
-        idempotencyRequired: true,
-        confirmRequired: true,
-        description: "Enroll a lead in the latest published campaign version. Triggers the live campaign's automation for that lead.",
-    }),
-    op({
-        id: "campaigns.analytics",
-        method: "GET",
-        path: "/api/campaigns/{id}/analytics",
-        scopes: ["analytics:read"],
-        description: "Read campaign attribution and performance analytics.",
-    }),
-    op({
-        id: "campaigns.providerCapabilities",
-        method: "GET",
-        path: "/api/campaigns/{id}/provider-capabilities",
-        scopes: ["campaigns:read"],
-        description: "Evaluate provider capability blockers for a campaign draft.",
-    }),
-    op({
-        id: "campaigns.commentEvents.list",
-        method: "GET",
-        path: "/api/campaigns/comment-events",
-        scopes: ["campaigns:read"],
-        description: "List matched, suppressed, blocked, and replayed comment automation events.",
-        // Each event carries verbatim external-commenter text (`body`,
-        // `commenterDisplayName`), so this read must be framed untrusted even
-        // though the campaigns group is not blanket-untrusted (AS5).
-        untrustedContent: true,
-    }),
-    op({
-        id: "campaigns.simulations.list",
-        method: "GET",
-        path: "/api/campaigns/{id}/simulations",
-        scopes: ["campaigns:read"],
-        description: "List persisted campaign simulation runs.",
-    }),
-    op({
-        id: "campaigns.simulations.create",
-        method: "POST",
-        path: "/api/campaigns/{id}/simulations",
-        scopes: ["campaigns:write"],
-        idempotencyRequired: true,
-        description: "Run a persisted dry-run simulation without sending messages.",
-    }),
-    op({
-        id: "campaigns.simulations.get",
-        method: "GET",
-        path: "/api/campaigns/{id}/simulations/{simulationId}",
-        scopes: ["campaigns:read"],
-        description: "Get a campaign simulation run with trace.",
-    }),
-    op({
-        id: "broadcasts.list",
-        method: "GET",
-        path: "/api/broadcasts",
-        scopes: ["broadcasts:read"],
-        description: "List broadcasts. Query supports limit, cursor, and status.",
-    }),
-    op({
-        id: "broadcasts.get",
-        method: "GET",
-        path: "/api/broadcasts/{id}",
-        scopes: ["broadcasts:read"],
-        description: "Get broadcast detail.",
-    }),
-    op({
-        id: "broadcasts.create",
-        method: "POST",
-        path: "/api/broadcasts",
-        scopes: ["broadcasts:write"],
-        idempotencyRequired: true,
-        description: "Create a broadcast draft. Body requires campaignId and name.",
-    }),
-    op({
-        id: "broadcasts.preview",
-        method: "POST",
-        path: "/api/broadcasts/{id}/preview",
-        scopes: ["broadcasts:write"],
-        idempotencyRequired: true,
-        description: "Refresh broadcast recipient and sample-message preview.",
-    }),
-    op({
-        id: "broadcasts.approve",
-        method: "POST",
-        path: "/api/broadcasts/{id}/approve",
-        scopes: ["broadcasts:write"],
-        idempotencyRequired: true,
-        description: "Approve a safe broadcast draft and snapshot recipients.",
-    }),
-    op({
-        id: "broadcasts.launch",
-        method: "POST",
-        path: "/api/broadcasts/{id}/launch",
-        scopes: ["broadcasts:write"],
-        idempotencyRequired: true,
-        confirmRequired: true,
-        description: "Launch an approved broadcast. Sends messages to live leads.",
-    }),
-    op({
-        id: "broadcasts.pause",
-        method: "POST",
-        path: "/api/broadcasts/{id}/pause",
-        scopes: ["broadcasts:write"],
-        idempotencyRequired: true,
-        description: "Pause a running broadcast with an optional operator reason.",
-    }),
-    op({
-        id: "broadcasts.retry",
-        method: "POST",
-        path: "/api/broadcasts/{id}/retry",
-        scopes: ["broadcasts:write"],
-        idempotencyRequired: true,
-        confirmRequired: true,
-        description: "Retry failed broadcast recipients after operator review. Re-sends messages to leads.",
-    }),
-    op({
-        id: "broadcasts.cancel",
-        method: "POST",
-        path: "/api/broadcasts/{id}/cancel",
-        scopes: ["broadcasts:write"],
-        idempotencyRequired: true,
-        description: "Cancel a draft, approved, running, paused, or failed broadcast.",
-    }),
-    op({
-        id: "webhooks.subscriptions.list",
-        method: "GET",
-        path: "/api/webhook-subscriptions",
-        scopes: ["webhooks:read"],
-        description: "List outbound webhook subscriptions.",
-    }),
-    op({
-        id: "webhooks.subscriptions.create",
-        method: "POST",
-        path: "/api/webhook-subscriptions",
-        scopes: ["webhooks:write"],
-        idempotencyRequired: true,
-        description: "Create an outbound webhook subscription.",
-    }),
-    op({
-        id: "webhooks.subscriptions.update",
-        method: "PATCH",
-        path: "/api/webhook-subscriptions/{id}",
-        scopes: ["webhooks:write"],
-        idempotencyRequired: true,
-        description: "Update an outbound webhook subscription.",
-    }),
-    op({
-        id: "webhooks.testDelivery",
-        method: "POST",
-        path: "/api/webhook-subscriptions/test-delivery",
-        scopes: ["webhooks:write"],
-        idempotencyRequired: true,
-        description: "Queue a canonical test webhook event.",
-    }),
-    op({
-        id: "webhooks.deliveries.list",
-        method: "GET",
-        path: "/api/webhook-subscriptions/deliveries",
-        scopes: ["webhooks:read"],
-        description: "List webhook deliveries.",
-    }),
-    op({
-        id: "webhooks.signatureGuide",
-        method: "GET",
-        path: "/api/webhook-subscriptions/signature-guide",
-        scopes: ["webhooks:read"],
-        description: "Describe Luca webhook HMAC verification.",
-    }),
-    op({
-        id: "webhooks.deliveries.replay",
-        method: "POST",
-        path: "/api/webhook-subscriptions/deliveries/{deliveryId}/replay",
-        scopes: ["webhooks:write"],
-        idempotencyRequired: true,
-        confirmRequired: true,
-        description: "Replay one webhook delivery without changing the event id. Re-triggers the subscriber's downstream automation.",
-    }),
-    op({
-        id: "webhooks.events.replay",
-        method: "POST",
-        path: "/api/webhook-subscriptions/events/{eventId}/replay",
-        scopes: ["webhooks:write"],
-        idempotencyRequired: true,
-        confirmRequired: true,
-        description: "Replay one canonical webhook event. Re-triggers subscribers' downstream automations.",
-    }),
-    op({
-        id: "webhooks.events.bulkReplay",
-        method: "POST",
-        path: "/api/webhook-subscriptions/events/replay",
-        scopes: ["webhooks:write"],
-        idempotencyRequired: true,
-        confirmRequired: true,
-        description: "Bulk replay webhook events by type and time range. Re-triggers downstream automations at scale.",
-    }),
-    op({
-        id: "integrations.connectors.list",
-        method: "GET",
-        path: "/api/integrations/connectors",
-        scopes: ["integrations:read"],
-        description: "List Zapier, Make, and CRM provider capabilities.",
-    }),
-    op({
-        id: "integrations.crm.oauthUrl",
-        method: "GET",
-        path: "/api/integrations/crm/providers/{provider}/oauth-url",
-        scopes: ["integrations:write"],
-        description: "Create a CRM provider OAuth URL.",
-    }),
-    op({
-        id: "integrations.crm.oauthCallback",
-        method: "POST",
-        path: "/api/integrations/crm/oauth/callback",
-        scopes: ["integrations:write"],
-        idempotencyRequired: true,
-        description: "Exchange a CRM OAuth code and store encrypted credentials.",
-    }),
-    op({
-        id: "integrations.crm.connections.list",
-        method: "GET",
-        path: "/api/integrations/crm/connections",
-        scopes: ["integrations:read"],
-        description: "List CRM connections.",
-    }),
-    op({
-        id: "integrations.crm.connections.create",
-        method: "POST",
-        path: "/api/integrations/crm/connections",
-        scopes: ["integrations:write"],
-        idempotencyRequired: true,
-        description: "Create or update a workspace-scoped CRM connection.",
-    }),
-    op({
-        id: "integrations.crm.connections.schema",
-        method: "GET",
-        path: "/api/integrations/crm/connections/{id}/schema",
-        scopes: ["integrations:read"],
-        description: "Discover CRM provider schema.",
-    }),
-    op({
-        id: "integrations.crm.connections.health",
-        method: "POST",
-        path: "/api/integrations/crm/connections/{id}/health",
-        scopes: ["integrations:write"],
-        idempotencyRequired: true,
-        description: "Probe CRM provider health.",
-    }),
-    op({
-        id: "integrations.crm.connections.webhooksSetup",
-        method: "POST",
-        path: "/api/integrations/crm/connections/{id}/webhooks/setup",
-        scopes: ["integrations:write"],
-        idempotencyRequired: true,
-        description: "Configure CRM provider webhook status.",
-    }),
-    op({
-        id: "integrations.crm.mappings.suggest",
-        method: "POST",
-        path: "/api/integrations/crm/connections/{id}/mappings/suggest",
-        scopes: ["integrations:write"],
-        idempotencyRequired: true,
-        description: "Suggest CRM field mappings.",
-    }),
-    op({
-        id: "integrations.crm.mappings.confirm",
-        method: "PUT",
-        path: "/api/integrations/crm/connections/{id}/mappings",
-        scopes: ["integrations:write"],
-        idempotencyRequired: true,
-        description: "Confirm CRM field mappings.",
-    }),
-    op({
-        id: "integrations.crm.syncRuns.list",
-        method: "GET",
-        path: "/api/integrations/crm/connections/{id}/sync-runs",
-        scopes: ["integrations:read"],
-        description: "List CRM sync history.",
-    }),
-    op({
-        id: "integrations.crm.syncRuns.create",
-        method: "POST",
-        path: "/api/integrations/crm/connections/{id}/sync-runs",
-        scopes: ["integrations:write"],
-        idempotencyRequired: true,
-        description: "Create a CRM dry-run or live sync run.",
-    }),
-    op({
-        id: "integrations.events.list",
-        method: "GET",
-        path: "/api/integrations/events",
-        scopes: ["integrations:read"],
-        description: "List integration event log.",
-    }),
-    op({
-        id: "voice.profile",
-        method: "GET",
-        path: "/api/voice/profile",
-        scopes: ["voice:read"],
-        description: "Read a non-verbatim voice-fingerprint summary: version, example count, and last refresh. No corpus text.",
-    }),
-];
-/**
- * MCP tool annotations derived from the operation model, so a client can
- * reason about a tool before calling it (auto-approve reads, flag destructive
- * writes). Hints only — never a security boundary; the Luca API still enforces
- * scopes and safety server-side.
- */
-export function toolAnnotations(operation) {
-    const readOnly = operation.method === "GET";
-    return {
-        title: operation.title,
-        readOnlyHint: readOnly,
-        // Destructive = a real-world side effect or an irreversible delete. Only
-        // meaningful for writes; ordinary create/update is a write but not
-        // destructive, so a client can treat it with less friction than a launch.
-        destructiveHint: !readOnly && (operation.confirmRequired || operation.method === "DELETE"),
-        // Reads are naturally idempotent; flagged writes carry an idempotency-key
-        // contract that makes a repeat with the same key a no-op.
-        idempotentHint: readOnly || operation.idempotencyRequired,
-        // Every tool reaches the external Luca API, outside this server's control.
-        openWorldHint: true,
-    };
-}
-export function operationManifest() {
-    return LUCA_OPERATIONS.map((operation) => ({
-        id: operation.id,
-        group: operation.group,
-        toolName: operation.toolName,
-        method: operation.method,
-        path: operation.path,
-        scopes: operation.scopes,
-        idempotencyRequired: operation.idempotencyRequired,
-        confirmRequired: operation.confirmRequired,
-        paginates: operation.paginates,
-        untrustedContent: operation.untrustedContent,
-        requiredScope: operation.requiredScope,
-        annotations: toolAnnotations(operation),
-        description: operation.description,
-    }));
-}
-export function operationGroups() {
-    return Object.entries(LUCA_OPERATION_GROUPS).map(([id, metadata]) => {
-        const operations = LUCA_OPERATIONS.filter((operation) => operation.group === id);
-        return {
-            id: id,
-            title: metadata.title,
-            description: metadata.description,
-            toolCount: operations.length,
-            scopes: [
-                ...new Set(operations.flatMap((operation) => operation.scopes)),
-            ].sort(),
-            tools: operations.map((operation) => operation.toolName),
-        };
-    });
-}
+// Public entry point for the operation model. The implementation is split by
+// job under `./operations/`: `registry.ts` holds the types and the `op()`
+// machinery, `catalog.ts` holds the operation table, and `manifest.ts` holds
+// the views derived from it. What a client is told about a tool lives in
+// `../annotations.ts`, one level up, because both kinds of tool ask for it.
+// This file names each export rather than re-exporting with `export *`,
+// because a star barrel pulls the whole dependency graph into every importer.
+// The lint rule that forbids it is measuring real load cost, not style.
+export { LUCA_OPERATIONS } from "./operations/catalog.js";
+export { operationGroups, operationManifest } from "./operations/manifest.js";
+export { confirmInput, DEFAULT_MAX_PAGES, outputSchemaFor, WORKSPACE_INPUT_FIELDS, } from "./operations/registry.js";