@setluca/mcp 0.1.1 → 0.2.1

package/dist/server.js

@@ -1,314 +1,272 @@
-import { McpServer, ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { Effect, Layer } from "effect";
+import { completable, McpServer, ResourceTemplate, } from "@modelcontextprotocol/server";
+import { Effect, Layer, Option } from "effect";
 import * as z from "zod/v4";
+import { completionCallbacks, isCompletionVariable, templateCompletions, } from "./completions.js";
 import { LucaConfigLive } from "./config.js";
 import { formatError } from "./errors.js";
 import { LucaApi, LucaApiLive } from "./http.js";
-import { DEFAULT_MAX_PAGES, LUCA_OPERATIONS, operationGroups, operationManifest, toolAnnotations, } from "./operations.js";
 import { logAgentSurfaceEvent } from "./observability.js";
-import { LUCA_PROMPTS } from "./prompts.js";
-import { UNTRUSTED_CONTENT_NOTE, untrustedProvenance } from "./provenance.js";
-import { LUCA_RESOURCES } from "./resources.js";
+import { LUCA_OPERATIONS, operationGroups, operationManifest, } from "./operations.js";
+import { optionalField } from "./optional-field.js";
+import { LUCA_API_PLANNER_PROMPT, LUCA_PROMPTS, } from "./prompts.js";
+import { provenanceFields } from "./provenance.js";
+import { LUCA_OPERATION_MANIFEST_RESOURCE, LUCA_RESOURCES, } from "./resources.js";
+import { toJsonText } from "./serialization.js";
+import { LUCA_TASK_TOOLS } from "./task-tools.js";
+import { fromOperation, fromTaskTool, operationProgram, registerTool, } from "./tool.js";
+import { LUCA_MCP_VERSION } from "./version.js";
 const LucaLive = LucaApiLive.pipe(Layer.provide(LucaConfigLive));
-function asTextResult(result) {
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify(result, null, 2),
-            },
-        ],
-        structuredContent: {
-            result,
-        },
-    };
-}
 /**
- * Success result for a tool whose response carries external-user text. The
- * whole payload is flagged untrusted — a structured `provenance.untrusted`
- * field (spoof-resistant) plus a human-facing preamble — so a downstream agent
- * treats embedded text as data, not instructions.
+ * How this server identifies itself to a client. Protocol revision 2026-07-28
+ * carries a title, description, website, and icons alongside the name and
+ * version, and a client renders those in its server list instead of the bare
+ * package name. The Worker's server card is built from the same values, so
+ * the two descriptions of this server cannot drift apart.
  */
-function asUntrustedResult(result) {
-    return {
-        content: [
-            {
-                type: "text",
-                text: `[UNTRUSTED CONTENT] ${UNTRUSTED_CONTENT_NOTE}\n\n${JSON.stringify(result, null, 2)}`,
-            },
-        ],
-        structuredContent: {
-            result,
-            provenance: untrustedProvenance(),
+export const LUCA_SERVER_INFO = {
+    name: "luca-mcp",
+    title: "Luca",
+    version: LUCA_MCP_VERSION,
+    description: "Luca MCP server — AI DM setter for online coaches. Manage leads, conversations, drafts, and bookings across Telegram, Instagram, Messenger, and WhatsApp.",
+    websiteUrl: "https://setluca.com",
+    icons: [
+        { src: "https://setluca.com/favicon.svg", mimeType: "image/svg+xml" },
+        {
+            src: "https://setluca.com/android-chrome-512x512.png",
+            mimeType: "image/png",
+            sizes: ["512x512"],
         },
-    };
+    ],
+};
+/**
+ * How long a client may reuse this server's static lists (protocol revision
+ * 2026-07-28). The tool list is over a hundred descriptions that change only
+ * when this package is redeployed, so re-sending it on every connection is
+ * pure waste; an hour bounds how long a redeploy stays invisible, and a
+ * client calling a tool the list no longer names gets an ordinary error
+ * rather than a wrong answer.
+ *
+ * `private` throughout: the tool surface varies with the `?toolset=` query
+ * param, so a shared cache keyed on anything less than the whole request
+ * could answer one shape with another. `resources/read` is left out on purpose.
+ * It returns live coach data and keeps the conservative default of no caching
+ * at all.
+ *
+ * These hints reach a client on the remote Streamable HTTP transport only.
+ * The SDK installs the modern-revision handlers from its HTTP entry
+ * (`createMcpHandler`, which `createRemoteHandler` is built on); a server
+ * constructed here and connected straight to a stdio or in-memory transport
+ * negotiates the legacy `initialize` handshake instead, and the legacy wire
+ * codec stamps no cache fields. Passing the table is still correct on both
+ * paths, inert on stdio rather than wrong, but only the remote handler can be
+ * asserted against, which is where the coverage lives.
+ */
+const STATIC_LIST_TTL_MS = 3_600_000;
+const LUCA_CACHE_HINTS = {
+    "tools/list": { ttlMs: STATIC_LIST_TTL_MS, cacheScope: "private" },
+    "prompts/list": { ttlMs: STATIC_LIST_TTL_MS, cacheScope: "private" },
+    "resources/list": { ttlMs: STATIC_LIST_TTL_MS, cacheScope: "private" },
+    "resources/templates/list": {
+        ttlMs: STATIC_LIST_TTL_MS,
+        cacheScope: "private",
+    },
+    "server/discover": { ttlMs: STATIC_LIST_TTL_MS, cacheScope: "private" },
+};
+// Only "tasks" selects the trimmed surface; every other value, including an
+// unset query param, takes the full-surface branch.
+export function parseToolset(value) {
+    return value === "tasks" ? "tasks" : "full";
 }
-function asSuccessResult(operation, result) {
-    return operation.untrustedContent
-        ? asUntrustedResult(result)
-        : asTextResult(result);
+const OPERATIONS_BY_ID = new Map(
+// This map is built once at module load, so a mutant inside it never takes
+// effect under a test runner that caches the module. It is unkillable by
+// construction rather than untested, and the lookups below are covered.
+// Stryker disable next-line ArrowFunction: module-level initializer, never re-evaluated per test
+LUCA_OPERATIONS.map((operation) => [operation.id, operation]));
+function operationByIdOrThrow(id) {
+    // Defensive invariant: every task tool's `composes` list references ids from
+    // the same CI-validated manifest, so this throw is unreachable with real data
+    // and the message text is never observed.
+    return Option.fromNullable(OPERATIONS_BY_ID.get(id)).pipe(Option.getOrThrowWith(
+    // Stryker disable next-line all: unreachable defensive throw, every composed id exists in the manifest
+    () => new Error(`task tool composes unknown operation: ${id}`)));
 }
-function asErrorResult(error) {
-    return {
-        isError: true,
-        content: [
-            {
-                type: "text",
-                text: formatError(error),
-            },
-        ],
-    };
+function registerLucaResources(server, lucaLayer, completions) {
+    for (const resource of LUCA_RESOURCES) {
+        const operation = resourceOperationOrThrow(resource.operationId);
+        const metadata = {
+            title: resource.title,
+            description: resource.description,
+            mimeType: "application/json",
+        };
+        // A resource is addressed either by a fixed uri or by a template; the two
+        // take different `registerResource` overloads, and a definition carrying
+        // neither is not addressable at all, so it registers nothing.
+        Option.fromNullable(resource.uri).pipe(Option.match({
+            onNone: () => registerTemplatedResource(server, resource, operation, lucaLayer, metadata, completions),
+            onSome: (uri) => server.registerResource(resource.name, uri, metadata, (readUri) => Effect.runPromise(readResource(resource, operation, lucaLayer, readUri, {}))),
+        }));
+    }
 }
-function operationDescription(operation) {
-    const idempotency = operation.idempotencyRequired
-        ? "Requires Idempotency-Key. Provide idempotencyKey for safe retries, or the server will generate one."
-        : "Does not require idempotency.";
-    const confirmation = operation.confirmRequired
-        ? "Destructive: has a real-world side effect. You must pass confirm: true; the call is rejected without it."
-        : undefined;
-    return [
-        operation.description,
-        "",
-        `Luca operation: ${operation.method} ${operation.path}`,
-        `Required scopes: ${operation.scopes.join(", ")}`,
-        `Required capability: ${operation.requiredScope.capability}; data sensitivity: ${operation.requiredScope.dataSensitivity}`,
-        idempotency,
-        confirmation,
-        "Use workspaceId or workspaceSlug to override the default workspace configured by environment.",
-    ]
-        .filter((line) => line !== undefined)
-        .join("\n");
+function resourceOperationOrThrow(operationId) {
+    return Option.fromNullable(OPERATIONS_BY_ID.get(operationId)).pipe(
+    // Defensive invariant: every `LUCA_RESOURCES` entry points at an id from the
+    // CI-validated manifest, so this throw is unreachable with real data and the
+    // message text is never observed.
+    Option.getOrThrowWith(
+    // Stryker disable next-line all: unreachable defensive throw, every resource operation id exists in the manifest
+    () => new Error(`Unknown resource operation: ${operationId}`)));
 }
-const CONFIRM_REQUIRED_MESSAGE = "This tool requires confirm: true because it has a real-world side effect (sends messages to leads or re-triggers downstream automations). Re-call the tool with confirm: true to proceed.";
-function confirmationError(operation) {
-    logAgentSurfaceEvent("mcp.write_gate.rejected", {
-        toolName: operation.toolName,
-    });
+function registerTemplatedResource(server, resource, operation, lucaLayer, metadata, completions) {
+    return Option.fromNullable(resource.uriTemplate).pipe(Option.match({
+        onNone: () => undefined,
+        onSome: (template) => server.registerResource(resource.name, 
+        // These templates are not enumerable. A lead or conversation uri is
+        // addressable but not listable, which an explicit `list: undefined`
+        // states at the call site. Omitting the key entirely reads the same
+        // to the SDK, so a mutant that drops it changes nothing observable.
+        // Stryker disable next-line ObjectLiteral: an absent `list` and an undefined one are the same to the SDK
+        new ResourceTemplate(template, {
+            list: undefined,
+            // A template whose variable has no live source registers without
+            // the key, rather than with an empty map a client would read as
+            // "completion offered, nothing to offer".
+            ...optionalField("complete", templateCompletions(template, completions)),
+        }), metadata, (uri, variables) => Effect.runPromise(readResource(resource, operation, lucaLayer, uri, variables))),
+    }));
+}
+/**
+ * One resource read. Mirrors the tool path: a failed read comes back as a typed
+ * error payload instead of a raw exception that would tear down the transport.
+ */
+function readResource(resource, operation, lucaLayer, uri, variables) {
+    return operationProgram(operation, resourceReadInput(resource, variables)).pipe(Effect.provide(lucaLayer), Effect.match({
+        onFailure: (error) => failedReadResult(uri, error),
+        onSuccess: (result) => readResult(operation, uri, result),
+    }));
+}
+/** A failed read, answered as a typed error payload the client can render. */
+function failedReadResult(uri, error) {
     return {
         isError: true,
-        content: [
-            {
-                type: "text",
-                text: `${operation.toolName}: ${CONFIRM_REQUIRED_MESSAGE}`,
-            },
-        ],
-        structuredContent: {
-            error: {
-                code: "confirmation_required",
-                toolName: operation.toolName,
-                requiredArgument: "confirm",
-            },
-        },
+        contents: [resourceContent(uri, { error: formatError(error) })],
     };
 }
-function isPaginatablePage(value) {
-    return typeof value === "object" && value !== null && "nextCursor" in value;
+/** A successful read's contents. */
+function readResult(operation, uri, result) {
+    return {
+        contents: [resourceContent(uri, resourcePayload(operation, result))],
+    };
 }
 /**
- * The single array-valued field on a list response is the items array
- * (`{ leads: [...], nextCursor }`). Returns undefined for ambiguous shapes so
- * the paginator falls back to returning the raw page untouched.
+ * The operation input a resource read runs, recorded as it is built.
+ *
+ * Only the resource's name is logged. Every variable a template carries is an
+ * id the client already typed, and a resource read takes no cursor: each one
+ * answers with a whole record or a single page.
  */
-function itemsKeyOf(page) {
-    const arrayKeys = Object.entries(page)
-        .filter(([key, value]) => key !== "nextCursor" && Array.isArray(value))
-        .map(([key]) => key);
-    return arrayKeys.length === 1 ? arrayKeys[0] : undefined;
-}
-function cursorOf(page) {
-    return typeof page.nextCursor === "string" && page.nextCursor.length > 0
-        ? page.nextCursor
-        : undefined;
+function resourceReadInput(resource, variables) {
+    logAgentSurfaceEvent("mcp.resources.read", { resourceType: resource.name });
+    return resource.buildInput(variables);
 }
 /**
- * Bounded server-side auto-pagination for list tools. Follows nextCursor up to
- * maxPages, merging the items array, then returns a single aggregated result.
- * If more pages remain past the guard, the result is explicitly marked
- * `truncated` with a `nextCursor` to continue — never a silent partial result.
+ * The payload of a successful read, provenance-tagged when it carries text an
+ * external user wrote. The rule itself lives in `provenance.ts`, shared with the
+ * tool results, so what "untrusted" attaches cannot drift between the two
+ * surfaces that answer with Luca data.
  */
-function paginatedProgram(operation, baseRequest, requestedMaxPages) {
-    const maxPages = requestedMaxPages ?? DEFAULT_MAX_PAGES;
-    return Effect.gen(function* () {
-        const api = yield* LucaApi;
-        const first = yield* api.request({ operation, ...baseRequest });
-        if (!isPaginatablePage(first)) {
-            return first;
-        }
-        const itemsKey = itemsKeyOf(first);
-        if (!itemsKey) {
-            return first;
-        }
-        const items = [...first[itemsKey]];
-        let cursor = cursorOf(first);
-        let pagesFetched = 1;
-        while (cursor !== undefined && pagesFetched < maxPages) {
-            const page = yield* api.request({
-                operation,
-                ...baseRequest,
-                query: { ...(baseRequest.query ?? {}), cursor },
-            });
-            if (!isPaginatablePage(page)) {
-                break;
-            }
-            const pageKey = itemsKeyOf(page) ?? itemsKey;
-            items.push(...(page[pageKey] ?? []));
-            cursor = cursorOf(page);
-            pagesFetched += 1;
-        }
-        const truncated = cursor !== undefined;
-        logPaginationTruncation(operation, pagesFetched, truncated);
-        return {
-            // Preserve every non-item, non-cursor top-level field from the first page
-            // (e.g. analytics totals on comment-event lists). The first page's own
-            // `nextCursor` is dropped in favor of the aggregated `pagination` below,
-            // and the item array is replaced with the merged one.
-            ...passthroughFields(first, itemsKey),
-            [itemsKey]: items,
-            pagination: {
-                pagesFetched,
-                truncated,
-                nextCursor: cursor ?? null,
-            },
-        };
-    });
-}
-/** Top-level first-page fields to carry through, minus items and nextCursor. */
-function passthroughFields(first, itemsKey) {
-    const rest = {};
-    for (const [key, value] of Object.entries(first)) {
-        if (key !== itemsKey && key !== "nextCursor") {
-            rest[key] = value;
-        }
-    }
-    return rest;
-}
-function logPaginationTruncation(operation, pagesFetched, truncated) {
-    if (truncated) {
-        logAgentSurfaceEvent("mcp.pagination.truncated", {
-            toolName: operation.toolName,
-            pages: pagesFetched,
-        });
-    }
-}
-function registerLucaOperation(server, operation, lucaLayer) {
-    server.registerTool(operation.toolName, {
-        title: operation.title,
-        description: operationDescription(operation),
-        inputSchema: operation.inputSchema,
-        outputSchema: operation.outputSchema,
-        annotations: toolAnnotations(operation),
-    }, async (input) => {
-        const toolInput = input;
-        if (operation.confirmRequired && toolInput.confirm !== true) {
-            return confirmationError(operation);
-        }
-        try {
-            return await Effect.runPromise(operationProgram(operation, toolInput).pipe(Effect.provide(lucaLayer), Effect.match({
-                onFailure: asErrorResult,
-                onSuccess: (result) => asSuccessResult(operation, result),
-            })));
-        }
-        catch (error) {
-            return asErrorResult(error);
-        }
-    });
-}
-/** The Effect program that runs an operation, auto-paginating list tools. */
-function operationProgram(operation, toolInput) {
-    const baseRequest = operation.buildRequest(toolInput);
-    return operation.paginates
-        ? paginatedProgram(operation, baseRequest, toolInput.maxPages)
-        : Effect.gen(function* () {
-            const api = yield* LucaApi;
-            return yield* api.request({ operation, ...baseRequest });
-        });
+function resourcePayload(operation, result) {
+    return { result, ...provenanceFields(operation.untrustedContent) };
 }
-const OPERATIONS_BY_ID = new Map(LUCA_OPERATIONS.map((operation) => [operation.id, operation]));
-function registerLucaResources(server, lucaLayer) {
-    for (const resource of LUCA_RESOURCES) {
-        const operation = OPERATIONS_BY_ID.get(resource.operationId);
-        if (!operation) {
-            throw new Error(`Unknown resource operation: ${resource.operationId}`);
-        }
-        const read = async (uri, variables) => {
-            const input = resource.buildInput(variables);
-            logAgentSurfaceEvent("mcp.resources.read", {
-                resourceType: resource.name,
-                hasCursor: Boolean(input.cursor),
-            });
-            // Mirror the tool path: a failed read returns a typed error result
-            // instead of a raw exception that would tear down the transport.
-            return await Effect.runPromise(operationProgram(operation, input).pipe(Effect.provide(lucaLayer), Effect.match({
-                onFailure: (error) => ({
-                    isError: true,
-                    contents: [
-                        {
-                            uri: uri.href,
-                            mimeType: "application/json",
-                            text: JSON.stringify({ error: formatError(error) }, null, 2),
-                        },
-                    ],
-                }),
-                onSuccess: (result) => ({
-                    contents: [
-                        {
-                            uri: uri.href,
-                            mimeType: "application/json",
-                            text: JSON.stringify(operation.untrustedContent
-                                ? { result, provenance: untrustedProvenance() }
-                                : { result }, null, 2),
-                        },
-                    ],
-                }),
-            })));
-        };
-        const metadata = {
-            title: resource.title,
-            description: resource.description,
-            mimeType: "application/json",
-        };
-        if (resource.uri) {
-            server.registerResource(resource.name, resource.uri, metadata, (uri) => read(uri, {}));
-        }
-        else if (resource.uriTemplate) {
-            server.registerResource(resource.name, new ResourceTemplate(resource.uriTemplate, { list: undefined }), metadata, (uri, variables) => read(uri, variables));
-        }
-    }
+/** A read's single JSON content block, in the shape MCP expects. */
+function resourceContent(uri, payload) {
+    return {
+        uri: uri.href,
+        mimeType: "application/json",
+        text: toJsonText(payload),
+    };
 }
-function registerResources(server) {
-    server.registerResource("luca-public-operations", "luca://operations", {
-        title: "Luca Public API Operations",
-        description: "MCP operation manifest derived from Luca's public API key policy.",
+function registerOperationManifestResource(server) {
+    server.registerResource(LUCA_OPERATION_MANIFEST_RESOURCE.name, LUCA_OPERATION_MANIFEST_RESOURCE.uri, {
+        title: LUCA_OPERATION_MANIFEST_RESOURCE.title,
+        description: LUCA_OPERATION_MANIFEST_RESOURCE.description,
         mimeType: "application/json",
     }, async (uri) => ({
         contents: [
             {
                 uri: uri.href,
                 mimeType: "application/json",
-                text: JSON.stringify({
+                text: toJsonText({
                     apiDocs: "https://api.setluca.com/docs",
                     openApi: "https://api.setluca.com/openapi.json",
                     groups: operationGroups(),
                     operations: operationManifest(),
-                }, null, 2),
+                }),
             },
         ],
     }));
 }
-function registerPrompts(server) {
-    server.registerPrompt("luca-api-planner", {
-        title: "Luca API Planner",
-        description: "Plan a Luca API workflow using the MCP tools, scopes, and idempotency rules.",
-        argsSchema: {
-            task: z
-                .string()
-                .optional()
-                .describe("The Luca API workflow the user wants to perform."),
-        },
-    }, ({ task }) => {
+/**
+ * A prompt's argument schemas with a completion source attached to every
+ * argument that has one.
+ *
+ * Two details of the SDK shape this. It looks for the completion metadata on
+ * the schema *inside* the optional wrapper, not on the wrapper. And
+ * `completable` stamps that metadata with a non-configurable property, so a
+ * schema can be stamped once and never again, while `LUCA_PROMPTS` is a
+ * module singleton the Worker re-registers on every request. Cloning the inner
+ * schema first gives each build its own object to stamp.
+ */
+function completableArgs(schema, completions) {
+    return Object.fromEntries(Object.entries(schema).map(([name, field]) => [
+        name,
+        isCompletionVariable(name)
+            ? field.clone({
+                ...field.def,
+                innerType: completable(field.def.innerType.clone(), completions[name]),
+            })
+            : field,
+    ]));
+}
+/**
+ * A prompt's arguments as a Zod object, or nothing when it takes none. An
+ * argument-less prompt registers with no `argsSchema` at all, so a client can
+ * invoke it without sending an otherwise-required empty args object.
+ */
+function promptArgsSchema(prompt, completions) {
+    if (Object.keys(prompt.argsSchema).length === 0) {
+        return;
+    }
+    return z.object(completableArgs(prompt.argsSchema, completions));
+}
+/**
+ * Registers the planner prompt plus every prompt in `prompts`.
+ *
+ * The list is a parameter so a test can drive this with its own prompt instead
+ * of mutating the exported `LUCA_PROMPTS` array out from under other tests.
+ */
+export function registerPrompts(server, prompts, completions) {
+    for (const prompt of [LUCA_API_PLANNER_PROMPT, ...prompts]) {
+        registerPrompt(server, prompt, completions);
+    }
+}
+function registerPrompt(server, prompt, completions) {
+    const config = {
+        title: prompt.title,
+        description: prompt.description,
+        ...optionalField("argsSchema", promptArgsSchema(prompt, completions)),
+    };
+    server.registerPrompt(prompt.name, config, (args) => {
+        // Parse with the prompt's own argsSchema, not a shared guess at one. A
+        // schema that does not match what the client was told to send silently
+        // drops any argument outside it before `prompt.build` ever sees it.
+        const parsedArgs = z.object(prompt.argsSchema).parse(args ?? {});
         logAgentSurfaceEvent("mcp.prompts.get", {
-            prompt: "luca-api-planner",
-            hasGuidance: false,
+            prompt: prompt.name,
+            // Booleans and the arg name only, never guidance text: `guidance` only
+            // exists on one prompt's schema, so this reads it without assuming
+            // every prompt shares that field.
+            hasGuidance: Boolean(parsedArgs.guidance),
         });
         return {
             messages: [
@@ -316,60 +274,44 @@ function registerPrompts(server) {
                     role: "user",
                     content: {
                         type: "text",
-                        text: [
-                            "Use Luca MCP tools only for public API operations.",
-                            "Do not ask for database access, internal endpoints, webhook ingress secrets, or browser cookies.",
-                            "For writes, pass a stable idempotencyKey when retrying the same user intent.",
-                            "Check luca://operations when you need exact tool names, scopes, and paths.",
-                            task ? `User task: ${task}` : undefined,
-                        ]
-                            .filter(Boolean)
-                            .join("\n"),
+                        text: prompt.build(parsedArgs),
                     },
                 },
             ],
         };
     });
-    for (const prompt of LUCA_PROMPTS) {
-        // Omit argsSchema for argument-less prompts so a client can invoke them
-        // without sending an (otherwise-required) empty args object.
-        const config = Object.keys(prompt.argsSchema).length > 0
-            ? {
-                title: prompt.title,
-                description: prompt.description,
-                argsSchema: prompt.argsSchema,
-            }
-            : { title: prompt.title, description: prompt.description };
-        server.registerPrompt(prompt.name, config, (args) => {
-            logAgentSurfaceEvent("mcp.prompts.get", {
-                prompt: prompt.name,
-                hasGuidance: Boolean(args?.guidance),
-            });
-            return {
-                messages: [
-                    {
-                        role: "user",
-                        content: {
-                            type: "text",
-                            text: prompt.build((args ?? {})),
-                        },
-                    },
-                ],
-            };
-        });
-    }
 }
+/**
+ * Build the Luca MCP server: registers the operation tools, the task tools, the
+ * `luca://…` resources, and the planner prompt against a shared `LucaApi` layer.
+ * `options.lucaLayer` swaps the HTTP client (tests inject an in-memory handler);
+ * `options.toolset` picks the tool set. `"tasks"` exposes only the task tools
+ * plus capability discovery, and `"full"`, the default, exposes everything.
+ */
 export function createLucaServer(options = {}) {
     const lucaLayer = options.lucaLayer ?? LucaLive;
-    const server = new McpServer({
-        name: "luca-mcp",
-        version: "0.1.0",
+    // The default value is only ever compared against `"tasks"` below; any other
+    // string (including `""`) takes the full-surface branch, so the literal here
+    // cannot change behavior.
+    // Stryker disable next-line StringLiteral: only `"tasks"` is compared downstream, so any non-tasks default behaves as full
+    const toolset = options.toolset ?? "full";
+    const server = new McpServer(LUCA_SERVER_INFO, {
+        cacheHints: LUCA_CACHE_HINTS,
     });
-    for (const operation of LUCA_OPERATIONS) {
-        registerLucaOperation(server, operation, lucaLayer);
+    // The tasks set carries one operation, capability discovery, so a client can
+    // still learn what the workspace supports without the full tool list.
+    const operations = toolset === "tasks"
+        ? [operationByIdOrThrow("capabilities.get")]
+        : LUCA_OPERATIONS;
+    for (const operation of operations) {
+        registerTool(server, fromOperation(operation), lucaLayer, toolset);
+    }
+    for (const tool of LUCA_TASK_TOOLS) {
+        registerTool(server, fromTaskTool(tool, operationByIdOrThrow), lucaLayer, toolset);
     }
-    registerResources(server);
-    registerLucaResources(server, lucaLayer);
-    registerPrompts(server);
+    registerOperationManifestResource(server);
+    const completions = completionCallbacks(operationByIdOrThrow, lucaLayer);
+    registerLucaResources(server, lucaLayer, completions);
+    registerPrompts(server, LUCA_PROMPTS, completions);
     return server;
 }