@setluca/mcp 0.2.1 → 0.3.1

package/dist/openapi-zod.js

@@ -1,335 +0,0 @@
-import * as z from "zod/v4";
-function isNullable(schema) {
-    return (schema.nullable === true ||
-        (Array.isArray(schema.type) && schema.type.includes("null")));
-}
-function nonNullTypes(schema) {
-    if (Array.isArray(schema.type)) {
-        return schema.type.filter((type) => type !== "null");
-    }
-    // Forcing this guard true yields `[undefined]`, which `baseSchema` reads
-    // exactly as it reads the empty list: the first element is undefined either
-    // way, so the same Zod schema comes out.
-    // Stryker disable next-line ConditionalExpression: `[undefined]` and `[]` are indistinguishable in `baseSchema`
-    if (schema.type) {
-        return [schema.type];
-    }
-    return [];
-}
-function withDescription(schema, description) {
-    return description ? schema.describe(description) : schema;
-}
-const JsonLiteralSchema = z.union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.null(),
-]);
-function enumSchema(values) {
-    const strings = z.array(z.string()).safeParse(values);
-    if (strings.success) {
-        // An empty enum lands here too, since the empty list is a list of strings.
-        // It admits nothing, which is also the only thing `z.enum` cannot express.
-        const [first, ...rest] = strings.data;
-        return first === undefined ? z.never() : z.enum([first, ...rest]);
-    }
-    const literals = z.array(JsonLiteralSchema).safeParse(values);
-    if (!literals.success) {
-        return z.never();
-    }
-    const [firstValue, secondValue, ...restValues] = literals.data;
-    // The empty list already went down the string branch, so this one is not
-    // empty. The guard exists to satisfy the compiler's view of destructuring.
-    // Stryker disable next-line ConditionalExpression,BlockStatement: unreachable, an empty enum is a list of strings
-    if (firstValue === undefined) {
-        return z.never();
-    }
-    const first = z.literal(firstValue);
-    if (secondValue === undefined) {
-        return first;
-    }
-    const second = z.literal(secondValue);
-    const rest = restValues.map((value) => z.literal(value));
-    return z.union([first, second, ...rest]);
-}
-/**
- * Zod 4 moved the string formats to top-level constructors: the `.uuid()` /
- * `.url()` / `.datetime()` methods on a ZodString are deprecated. They all
- * still subclass ZodString, so the length and pattern refinements below chain
- * onto whichever base a format picks.
- */
-function formatBase(format) {
-    if (format === "uuid") {
-        return z.uuid();
-    }
-    if (format === "uri") {
-        return z.url();
-    }
-    if (format === "date-time") {
-        return z.iso.datetime({ offset: true });
-    }
-    return z.string();
-}
-function stringSchema(schema) {
-    let result = formatBase(schema.format);
-    if (schema.minLength !== undefined) {
-        result = result.min(schema.minLength);
-    }
-    if (schema.maxLength !== undefined) {
-        result = result.max(schema.maxLength);
-    }
-    // Forcing this guard true is an equivalent mutation rather than an untested
-    // branch: with no pattern the body builds `new RegExp(undefined)`, which is
-    // the empty pattern `/(?:)/` and matches every string, so the constraint it
-    // adds rejects nothing. Forcing it false is a real change and is covered.
-    // Stryker disable next-line ConditionalExpression: an absent pattern compiles to /(?:)/, which constrains nothing
-    if (schema.pattern) {
-        // fallow-ignore-next-line security-sink -- patterns come from Luca's checked-in generated OpenAPI document at startup, never from MCP tool arguments or request data
-        result = result.regex(new RegExp(schema.pattern));
-    }
-    return result;
-}
-function numberSchema(schema, integer) {
-    let result = integer ? z.number().int() : z.number();
-    if (schema.minimum !== undefined) {
-        result =
-            schema.exclusiveMinimum === true
-                ? result.gt(schema.minimum)
-                : result.min(schema.minimum);
-    }
-    if (schema.maximum !== undefined) {
-        result =
-            schema.exclusiveMaximum === true
-                ? result.lt(schema.maximum)
-                : result.max(schema.maximum);
-    }
-    return result;
-}
-function arraySchema(schema) {
-    let result = z.array(schema.items ? schemaToZod(schema.items) : z.unknown());
-    if (schema.minItems !== undefined) {
-        result = result.min(schema.minItems);
-    }
-    if (schema.maxItems !== undefined) {
-        result = result.max(schema.maxItems);
-    }
-    return result;
-}
-function scalarSchema(schema, type) {
-    if (type === "string") {
-        return stringSchema(schema);
-    }
-    if (type === "integer" || type === "number") {
-        return numberSchema(schema, type === "integer");
-    }
-    return scalarSchemaWithoutConstraints(schema, type);
-}
-function scalarSchemaWithoutConstraints(schema, type) {
-    switch (type) {
-        case "boolean":
-            return z.boolean();
-        case "array":
-            return arraySchema(schema);
-        case "object":
-            return objectSchema(schema);
-        default:
-            return z.unknown();
-    }
-}
-function objectSchema(schema) {
-    const properties = schema.properties ?? {};
-    const required = new Set(schema.required ?? []);
-    const fields = {};
-    for (const [key, property] of Object.entries(properties)) {
-        const propertySchema = schemaToZod(property);
-        fields[key] = required.has(key)
-            ? propertySchema
-            : propertySchema.optional();
-    }
-    const result = z.object(fields);
-    if (schema.additionalProperties === true) {
-        return result.catchall(z.unknown());
-    }
-    // Absent, `false`, and the malformed scalars a generated document can carry
-    // all close the object. Only a nested schema opens it, and every extra key
-    // then has to match that schema.
-    const extra = schema.additionalProperties;
-    if (typeof extra !== "object") {
-        return result;
-    }
-    return result.catchall(schemaToZod(extra));
-}
-function schemaToZod(schema) {
-    const literal = literalOrEnumSchema(schema);
-    if (literal) {
-        return literal;
-    }
-    const composite = compositeSchema(schema);
-    if (composite) {
-        return composite;
-    }
-    return describedBaseSchema(schema);
-}
-function literalOrEnumSchema(schema) {
-    if (schema.const !== undefined) {
-        const literal = JsonLiteralSchema.safeParse(schema.const);
-        return literal.success ? z.literal(literal.data) : z.never();
-    }
-    if (schema.enum) {
-        return withDescription(enumSchema(schema.enum), schema.description);
-    }
-    return;
-}
-function compositeSchema(schema) {
-    const variants = schema.anyOf ?? schema.oneOf;
-    if (variants?.length) {
-        return variantSchema(schema, variants);
-    }
-    const allOf = schema.allOf;
-    if (allOf?.length) {
-        return withDescription(schemaToZod(mergeAllOf(allOf)), schema.description);
-    }
-    return;
-}
-function variantSchema(schema, variants) {
-    const [first, second, ...rest] = variants.map(schemaToZod);
-    // `compositeSchema` only calls here for a non-empty variant list, so there is
-    // always a first. The guard exists to satisfy the compiler's view of
-    // destructuring.
-    // Stryker disable next-line ConditionalExpression,BlockStatement: unreachable, the variant list is non-empty by construction
-    if (first === undefined) {
-        return z.never();
-    }
-    // A single variant is the variant itself. Wrapping one schema in a union
-    // would change nothing except what a client reads in the JSON Schema.
-    const union = second === undefined ? first : z.union([first, second, ...rest]);
-    return withDescription(isNullable(schema) ? union.nullable() : union, schema.description);
-}
-function describedBaseSchema(schema) {
-    const base = baseSchema(schema);
-    return withDescription(isNullable(schema) ? base.nullable() : base, schema.description);
-}
-function mergeAllOf(allOf) {
-    const merged = {};
-    const properties = {};
-    const required = [];
-    for (const item of allOf) {
-        Object.assign(merged, item);
-        Object.assign(properties, item.properties);
-        required.push(...(item.required ?? []));
-    }
-    return {
-        ...merged,
-        ...(Object.keys(properties).length > 0 ? { properties } : undefined),
-        // Equivalent under this module's public contract: an empty `required: []`
-        // and an absent `required` produce the identical Zod object schema, because
-        // `objectSchema` derives its required-set from `schema.required ?? []`, so
-        // both yield an all-optional object. The guard only avoids emitting a noise key.
-        // Stryker disable next-line ConditionalExpression,EqualityOperator: empty and absent `required` are indistinguishable downstream
-        ...(required.length > 0 ? { required } : undefined),
-    };
-}
-function baseSchema(schema) {
-    const types = nonNullTypes(schema);
-    const [first, second, ...rest] = types;
-    if (first === undefined) {
-        return schema.properties ? objectSchema(schema) : z.unknown();
-    }
-    if (second === undefined) {
-        return scalarSchema(schema, first);
-    }
-    return z.union([
-        scalarSchema(schema, first),
-        scalarSchema(schema, second),
-        ...rest.map((type) => scalarSchema(schema, type)),
-    ]);
-}
-function relaxJsonSchema(schema) {
-    const relaxed = {};
-    // Forcing this guard true assigns `relaxed.type = undefined` when there is no
-    // type, which is indistinguishable downstream from omitting the key: both
-    // `nonNullTypes` and the object-routing in `baseSchema` treat an undefined
-    // `type` and an absent `type` identically, producing the same Zod schema.
-    // Stryker disable next-line ConditionalExpression: an undefined `type` and an absent one yield the identical relaxed schema
-    if (schema.type !== undefined) {
-        relaxed.type = schema.type;
-    }
-    if (isNullable(schema)) {
-        relaxed.nullable = true;
-    }
-    if (schema.properties) {
-        const properties = {};
-        for (const [key, value] of Object.entries(schema.properties)) {
-            properties[key] = relaxJsonSchema(value);
-        }
-        relaxed.properties = properties;
-        relaxed.required = [];
-        relaxed.additionalProperties = true;
-        // Defensive belt-and-suspenders: with `properties` present, `baseSchema`
-        // routes an absent type and an explicit `"object"` type to the same
-        // `objectSchema` call, so setting the type here never changes the produced
-        // Zod schema. Verified equivalent through both public entry points.
-        // Stryker disable next-line ConditionalExpression,BlockStatement: object routing is identical with or without an explicit type when properties exist
-        if (relaxed.type === undefined) {
-            // Stryker disable next-line StringLiteral: type value is inert here, properties already force objectSchema downstream
-            relaxed.type = "object";
-        }
-    }
-    if (schema.anyOf) {
-        relaxed.anyOf = schema.anyOf.map(relaxJsonSchema);
-    }
-    if (schema.oneOf) {
-        relaxed.oneOf = schema.oneOf.map(relaxJsonSchema);
-    }
-    if (schema.allOf) {
-        relaxed.allOf = schema.allOf.map(relaxJsonSchema);
-    }
-    // Array items and scalar formats/patterns/ranges/enums are intentionally
-    // dropped. See the doc comment.
-    return relaxed;
-}
-const untrustedProvenanceSchema = z
-    .object({ untrusted: z.literal(true), note: z.string() })
-    .loose();
-/**
- * The `structuredContent` fields for a tool: `{ result }`, plus an optional
- * `provenance` marker for operations that carry lead-authored text. `result` is
- * the operation's success-response body, deep-relaxed (see
- * {@link relaxJsonSchema}) so real results validate while malformed ones fail
- * loud.
- */
-export function openApiToolOutputFields(input) {
-    const resultSchema = input.body
-        ? schemaToZod(relaxJsonSchema(input.body))
-        : z.unknown();
-    return input.untrustedContent
-        ? {
-            result: resultSchema,
-            provenance: untrustedProvenanceSchema.optional(),
-        }
-        : { result: resultSchema };
-}
-export function openApiToolInputFields(input) {
-    const fields = new Map(Object.entries(input.workspaceInput));
-    if (input.idempotencyRequired) {
-        for (const [key, schema] of Object.entries(input.idempotencyInput)) {
-            fields.set(key, schema);
-        }
-    }
-    const pathSchema = input.spec?.path
-        ? schemaToZod(input.spec.path)
-        : undefined;
-    if (pathSchema instanceof z.ZodObject) {
-        // oxlint-disable-next-line typescript/dot-notation -- Zod owns this public property name; bracket access avoids classifying the library member as a local shape symbol.
-        for (const [key, schema] of Object.entries(pathSchema["shape"])) {
-            fields.set(key, schema);
-        }
-    }
-    if (input.spec?.query) {
-        fields.set("query", schemaToZod(input.spec.query).optional());
-    }
-    if (input.spec?.body) {
-        fields.set("body", schemaToZod(input.spec.body));
-    }
-    return Object.fromEntries(fields);
-}

package/dist/page-shape.js

@@ -1,62 +0,0 @@
-import { OPENAPI_INPUTS } from "./generated/openapi-inputs.js";
-import { OPENAPI_OUTPUTS } from "./generated/openapi-outputs.js";
-const INPUTS_BY_ROUTE = new Map(Object.entries(OPENAPI_INPUTS));
-const OUTPUTS_BY_ROUTE = new Map(Object.entries(OPENAPI_OUTPUTS));
-/**
- * Every name a page cursor goes by in the manifest: `cursor` almost everywhere,
- * and `before` on the conversation-messages route. This is an allowlist of two
- * names, not inference. A schema cannot say which of a route's string query
- * fields is a cursor without a naming convention, and there are two.
- */
-const CURSOR_QUERY_PARAMS = ["cursor", "before"];
-/**
- * The query field a route takes its page cursor in, absent when it takes none.
- *
- * Takes the query schema rather than the route so the shape rules can be tested
- * against a schema directly. The generated manifest carries only the schemas
- * the API actually serves, and a rule this small should be provable against the
- * ones it does not.
- */
-export function cursorQueryParamOf(query) {
-    return CURSOR_QUERY_PARAMS.find((name) => query?.properties?.[name] !== undefined);
-}
-/**
- * The array field a page carries its records in, absent when the body hands
- * back no cursor or declares no array. The items array is the first
- * array-valued property the body declares, which is deterministic rather than a
- * guess among equals: key order here is OpenAPI declaration order.
- */
-export function itemsKeyOf(body) {
-    if (body?.type !== "object" || body.properties?.nextCursor === undefined) {
-        return;
-    }
-    return Object.entries(body.properties).find(([key, schema]) => key !== "nextCursor" && schema?.type === "array")?.[0];
-}
-/**
- * The page shape of a route, absent when the route does not paginate.
- *
- * Walking a list needs both halves: a body that hands back a cursor and an
- * array to merge, and a query field to send the cursor in. Guessing from the
- * operation id used to answer this, and was wrong fourteen times: twelve routes
- * that answer with a plain array and no cursor, and two that paginate under an
- * id that does not end in `.list`.
- */
-export function pageShapeFor(method, path) {
-    const route = `${method} ${path}`;
-    return pageShapeOf(INPUTS_BY_ROUTE.get(route)?.query, OUTPUTS_BY_ROUTE.get(route));
-}
-/**
- * The page shape a request and response schema pair describes, absent when
- * either half is missing. Split from {@link pageShapeFor} so both halves can be
- * withheld independently: the manifest happens to carry no route that takes a
- * cursor and answers without one, and that asymmetry is a fact about today's
- * API rather than a rule this function may assume.
- */
-export function pageShapeOf(query, body) {
-    const cursorQueryParam = cursorQueryParamOf(query);
-    const itemsKey = itemsKeyOf(body);
-    if (cursorQueryParam === undefined || itemsKey === undefined) {
-        return;
-    }
-    return { cursorQueryParam, itemsKey };
-}