@zackbart/connecta 0.15.1 → 0.16.1

package/dist/providers/linear.d.ts

@@ -18,11 +18,20 @@ export interface LinearOptions {
     /** Which workspace this is and what decisions it answers. */
     purpose: string;
     /**
-     * Endpoint selection. Defaults to `"read-write"`. `"read-only"` binds the
-     * connection to Linear's read-only endpoint, whose token is scope-limited
-     * downstream — a stronger guarantee than any annotation Connecta applies.
+     * Endpoint selection. Required, and deliberately undefaulted.
+     *
+     * `"read-only"` binds the connection to Linear's read-only endpoint, whose
+     * token is scope-limited downstream — a stronger guarantee than any
+     * annotation Connecta applies. `"read-write"` reaches the full API.
+     *
+     * Neither is a safe default. Defaulting to `"read-write"` hands a deployment
+     * write access it never asked for, and defaulting to `"read-only"` turns a
+     * deployment that does write into one whose every write fails at Linear —
+     * at runtime, where no agent can repair it. So the operator declares it, and
+     * a deployment that forgot fails here instead
+     * ([#342](https://github.com/zackbart/connecta/issues/342)).
      */
-    access?: LinearAccess;
+    access: LinearAccess;
     /** OAuth by default; static headers support a Linear personal API key. */
     auth?: RemoteMcpAuth;
     /** Workspace-specific conventions appended to the maintained provider guide. */
@@ -39,6 +48,18 @@ export interface LinearOptions {
      */
     callAdmission?: ConnectorCallAdmissionPolicy;
 }
+/**
+ * The manifest this release reviewed: both lists in one place, which is what
+ * makes the classification the connector applies and the drift check that runs
+ * beside it the same fact (P13). No schema digests yet — no release has read
+ * Linear's live schemas and written them down, and an invented digest would
+ * report a change that never happened. `npm run drift:check -- --record` reads
+ * them from a live workspace and prints the block to paste in
+ * ([#351](https://github.com/zackbart/connecta/issues/351)).
+ *
+ * Exported because the maintainer-run check compares against this manifest and
+ * *names* what moved, which the runtime check deliberately cannot.
+ */
+export declare const LINEAR_VETTED_CATALOG: import("../catalog-drift.js").VettedCatalog;
 /** A maintained Linear hosted-MCP connection. */
 export declare function linear(id: string, options: LinearOptions): Connector;
-//# sourceMappingURL=linear.d.ts.map

package/dist/providers/linear.js

@@ -1,4 +1,5 @@
 import { remoteMcp, } from "../connectors/remote-mcp.js";
+import { vettedCatalog, withVettedCatalog } from "../catalog-drift.js";
 /**
  * Linear publishes two hosted endpoints. `read-only` is not a client-side
  * filter: it advertises the `read` scope alone, so the token minted for it
@@ -127,60 +128,21 @@ const WRITE_TOOLS = new Map([
     ["delete_customer_need", "destructive"],
 ]);
 /**
- * Fill in downstream silence; keep reviewed destructive tools fail-closed.
+ * The manifest this release reviewed: both lists in one place, which is what
+ * makes the classification the connector applies and the drift check that runs
+ * beside it the same fact (P13). No schema digests yet — no release has read
+ * Linear's live schemas and written them down, and an invented digest would
+ * report a change that never happened. `npm run drift:check -- --record` reads
+ * them from a live workspace and prints the block to paste in
+ * ([#351](https://github.com/zackbart/connecta/issues/351)).
  *
- * Silence is what a vetted classification is for, and an explicit downstream
- * annotation otherwise wins in both directions. `destructiveHint: true` or
- * `readOnlyHint: false` on an allowlisted read name is the downstream telling
- * us this release's allowlist is stale; `readOnlyHint: true` on a name no
- * release has classified says the same thing from the other side. The single
- * place a vetted verdict still overrides the downstream is a name this release
- * reviewed and filed destructive: there connecta knows what the tool does, and
- * a claim to the contrary is a downstream bug rather than news
- * ([#310](https://github.com/zackbart/connecta/issues/310),
- * [#315](https://github.com/zackbart/connecta/issues/315)).
+ * Exported because the maintainer-run check compares against this manifest and
+ * *names* what moved, which the runtime check deliberately cannot.
  */
-function vettedSafety(definition) {
-    const downstream = definition.annotations ?? {};
-    if (READ_ONLY_TOOLS.has(definition.name)) {
-        if (downstream.destructiveHint === true ||
-            downstream.readOnlyHint === false) {
-            return definition;
-        }
-        return {
-            ...definition,
-            annotations: {
-                ...downstream,
-                readOnlyHint: true,
-                destructiveHint: downstream.destructiveHint ?? false,
-            },
-        };
-    }
-    if (WRITE_TOOLS.get(definition.name) === "destructive") {
-        return {
-            ...definition,
-            annotations: {
-                ...downstream,
-                readOnlyHint: false,
-                destructiveHint: true,
-            },
-        };
-    }
-    // Maintained additive creates and tools this release has never seen land
-    // here alike. Fill-in only: a silent tool is not read-only, so drift still
-    // fails closed onto `call_destructive_tool`, and neither population gets a
-    // `destructiveHint` it has not earned. A tool that arrives explicitly
-    // read-only keeps that annotation — on a name no release has reviewed, the
-    // downstream's own word is the only evidence there is, and rewriting it
-    // would be an overrule rather than a fill-in.
-    return {
-        ...definition,
-        annotations: {
-            ...downstream,
-            readOnlyHint: downstream.readOnlyHint ?? false,
-        },
-    };
-}
+export const LINEAR_VETTED_CATALOG = vettedCatalog({
+    reads: READ_ONLY_TOOLS,
+    writes: WRITE_TOOLS,
+});
 function usageGuide(purpose, access, instructions) {
     const accountInstructions = instructions?.trim();
     // Leads the guide because discovery summarizes a connector by its first
@@ -215,7 +177,10 @@ export function linear(id, options) {
     if (!purpose) {
         throw new Error("linear() requires a non-empty workspace purpose.");
     }
-    const access = options.access ?? "read-write";
+    const access = options.access;
+    if (access !== "read-write" && access !== "read-only") {
+        throw new Error(`linear("${id}") requires access "read-write" or "read-only".`);
+    }
     const connector = remoteMcp(id, {
         url: LINEAR_MCP_ENDPOINTS[access],
         // The title is what browse-time discovery renders; a read-only connection
@@ -226,7 +191,19 @@ export function linear(id, options) {
             : `Linear issue tracking and project planning — ${purpose}`,
         auth: options.auth ?? { type: "oauth" },
         requireHttps: true,
-        usageGuide: usageGuide(purpose, access, options.instructions),
+        usageGuide: {
+            content: usageGuide(purpose, access, options.instructions),
+            // Explicit rather than derived. The derived summary would truncate the
+            // access note mid-sentence at 120 characters, and the one thing a
+            // browsing agent must not get wrong is whether this connection can write
+            // at all ([#342](https://github.com/zackbart/connecta/issues/342)).
+            summary: access === "read-only"
+                ? "Read-only: every write fails at Linear. Id resolution, upsert semantics, and cursor paging."
+                : "Read-write. Id resolution, `save_*` upsert semantics, plan-gated areas, and cursor paging.",
+            // Not `required`. Linear's own schemas describe each call correctly; the
+            // guide adds cross-tool sequence advice that is worth reading before a
+            // write, not worth loading before every read.
+        },
         ...(options.callAdmission !== undefined
             ? { callAdmission: options.callAdmission }
             : {}),
@@ -234,11 +211,5 @@ export function linear(id, options) {
             ? { maxResultBytes: options.maxResultBytes }
             : {}),
     });
-    return {
-        ...connector,
-        async listTools(ctx) {
-            return (await connector.listTools(ctx)).map(vettedSafety);
-        },
-    };
+    return withVettedCatalog(connector, LINEAR_VETTED_CATALOG);
 }
-//# sourceMappingURL=linear.js.map

package/dist/providers/mixpanel.d.ts

@@ -1,13 +1,22 @@
 import { type RemoteMcpAuth } from "../connectors/remote-mcp.js";
-import type { Connector } from "../types.js";
+import type { Connector, ConnectorCallAdmissionPolicy } from "../types.js";
 export type MixpanelRegion = "us" | "eu" | "in";
 export declare const MIXPANEL_MCP_ENDPOINTS: Readonly<Record<MixpanelRegion, string>>;
 export interface MixpanelOptions {
-    /** Human-readable display name; defaults to "Mixpanel". */
+    /**
+     * Human-readable display name; defaults to "Mixpanel (<region>)". The region
+     * rides the title because a project lives in exactly one residency and
+     * discovery shows the title before anything else.
+     */
     title?: string;
     /** Who should use this account and for what decisions. */
     purpose: string;
-    /** Mixpanel data residency region. Defaults to "us". */
+    /**
+     * Mixpanel data residency region. Defaults to `"us"`, which is where a
+     * project lives unless it was explicitly created in the EU or India
+     * residency — the other two are opt-in, so `"us"` is the honest default
+     * rather than a convenient one.
+     */
     region?: MixpanelRegion;
     /** OAuth by default; static headers support Mixpanel service accounts. */
     auth?: RemoteMcpAuth;
@@ -15,7 +24,29 @@ export interface MixpanelOptions {
     instructions?: string;
     /** Connector-specific inline result limit; omit to inherit the deployment. */
     maxResultBytes?: number;
+    /**
+     * Optional per-runtime call-admission policy. Deliberately not defaulted:
+     * Mixpanel meters its MCP server per user per hour, and a per-runtime
+     * counter cannot approximate a per-user quota — one runtime serving several
+     * users under-counts, and several runtimes sharing one user over-counts.
+     * A hardcoded ceiling would therefore either throttle a healthy deployment
+     * or fail to protect a busy one, so the number stays with the operator who
+     * knows the account.
+     */
+    callAdmission?: ConnectorCallAdmissionPolicy;
 }
+/**
+ * The manifest this release reviewed: both lists in one place, which is what
+ * makes the classification the connector applies and the drift check that runs
+ * beside it the same fact (P13). No schema digests yet — no release has read
+ * Mixpanel's live schemas and written them down, and an invented digest would
+ * report a change that never happened. `npm run drift:check -- --record` reads
+ * them from a live project and prints the block to paste in
+ * ([#351](https://github.com/zackbart/connecta/issues/351)).
+ *
+ * Exported because the maintainer-run check compares against this manifest and
+ * *names* what moved, which the runtime check deliberately cannot.
+ */
+export declare const MIXPANEL_VETTED_CATALOG: import("../catalog-drift.js").VettedCatalog;
 /** A maintained Mixpanel hosted-MCP connection. */
 export declare function mixpanel(id: string, options: MixpanelOptions): Connector;
-//# sourceMappingURL=mixpanel.d.ts.map

package/dist/providers/mixpanel.js

@@ -1,23 +1,10 @@
 import { remoteMcp, } from "../connectors/remote-mcp.js";
+import { vettedCatalog, withVettedCatalog } from "../catalog-drift.js";
 export const MIXPANEL_MCP_ENDPOINTS = {
     us: "https://mcp.mixpanel.com/mcp",
     eu: "https://mcp-eu.mixpanel.com/mcp",
     in: "https://mcp-in.mixpanel.com/mcp",
 };
-// Budget-only: a rejection computes its own retry-after from the window, and
-// declaring `retryAfterMs` here would be a queue setting without a queue —
-// which the admission controller refuses at construction.
-const MIXPANEL_ADMISSION = {
-    rules: [
-        {
-            budget: {
-                kind: "rolling-window",
-                maxCalls: 600,
-                windowMs: 3_600_000,
-            },
-        },
-    ],
-};
 /** Tools whose official contract is observational rather than mutating. */
 const READ_ONLY_TOOLS = new Set([
     "Run-Query",
@@ -93,71 +80,47 @@ const WRITE_TOOLS = new Map([
     ["Update-Feature-Flag", "destructive"],
 ]);
 /**
- * Fill in downstream silence; keep reviewed destructive tools fail-closed.
+ * The manifest this release reviewed: both lists in one place, which is what
+ * makes the classification the connector applies and the drift check that runs
+ * beside it the same fact (P13). No schema digests yet — no release has read
+ * Mixpanel's live schemas and written them down, and an invented digest would
+ * report a change that never happened. `npm run drift:check -- --record` reads
+ * them from a live project and prints the block to paste in
+ * ([#351](https://github.com/zackbart/connecta/issues/351)).
  *
- * Silence is what a vetted classification is for, and an explicit downstream
- * annotation otherwise wins in both directions. `destructiveHint: true` or
- * `readOnlyHint: false` on an allowlisted read name is the downstream telling
- * us this release's allowlist is stale; `readOnlyHint: true` on a name no
- * release has classified says the same thing from the other side. The single
- * place a vetted verdict still overrides the downstream is a name this release
- * reviewed and filed destructive: there connecta knows what the tool does, and
- * a claim to the contrary is a downstream bug rather than news
- * ([#310](https://github.com/zackbart/connecta/issues/310),
- * [#315](https://github.com/zackbart/connecta/issues/315)).
+ * Exported because the maintainer-run check compares against this manifest and
+ * *names* what moved, which the runtime check deliberately cannot.
  */
-function vettedSafety(definition) {
-    const downstream = definition.annotations ?? {};
-    if (READ_ONLY_TOOLS.has(definition.name)) {
-        if (downstream.destructiveHint === true ||
-            downstream.readOnlyHint === false) {
-            return definition;
-        }
-        return {
-            ...definition,
-            annotations: {
-                ...downstream,
-                readOnlyHint: true,
-                destructiveHint: downstream.destructiveHint ?? false,
-            },
-        };
-    }
-    if (WRITE_TOOLS.get(definition.name) === "destructive") {
-        return {
-            ...definition,
-            annotations: {
-                ...downstream,
-                readOnlyHint: false,
-                destructiveHint: true,
-            },
-        };
-    }
-    // Maintained additive creates and tools this release has never seen land
-    // here alike. Fill-in only: a silent tool is not read-only, so drift still
-    // fails closed onto `call_destructive_tool`, and neither population gets a
-    // `destructiveHint` it has not earned. A tool that arrives explicitly
-    // read-only keeps that annotation — on a name no release has reviewed, the
-    // downstream's own word is the only evidence there is, and rewriting it
-    // would be an overrule rather than a fill-in.
-    return {
-        ...definition,
-        annotations: {
-            ...downstream,
-            readOnlyHint: downstream.readOnlyHint ?? false,
-        },
-    };
-}
-function usageGuide(purpose, instructions) {
+export const MIXPANEL_VETTED_CATALOG = vettedCatalog({
+    reads: READ_ONLY_TOOLS,
+    writes: WRITE_TOOLS,
+});
+const REGION_COPY = {
+    us: "US",
+    eu: "EU",
+    in: "India",
+};
+function usageGuide(purpose, region, instructions) {
     const accountInstructions = instructions?.trim();
+    // Leads the guide because discovery summarizes a connector by its first
+    // content line. A project lives in exactly one residency, so a question
+    // pointed at the wrong region does not return fewer rows — it returns
+    // nothing, and reads as the project having no data.
+    const regionNote = `${REGION_COPY[region]}-residency connection: bound to Mixpanel's ${region} endpoint. A project created in another residency is not reachable from here at all, so an empty result may mean wrong connector rather than no data.`;
     return `# Mixpanel usage
 
+${regionNote}
+
 Account purpose: ${purpose}
 
 - Start with \`Get-Projects\`, then use \`Get-Business-Context\` for the selected project before interpreting its events or metrics.
+- Resolve ids before acting; never guess one. \`Get-Projects\` yields the project id every other call is scoped by, and \`List-Dashboards\`, \`List-Cohorts\`, \`List-Metrics\`, \`List-Experiments\`, and \`List-Feature-Flags\` yield the ids their \`Get-\`, \`Update-\`, and \`Delete-\` counterparts expect.
 - Discover names with \`Get-Events\`, \`List-Properties\`, and \`Get-Property-Values\`; do not guess event or property spelling.
 - For a new analysis, fetch \`Get-Query-Schema\` before \`Run-Query\`. Reduce query results inside \`execute_code\` before returning them.
 - Use \`Get-Report\` when the request names an existing saved report. Use \`Run-Query\` for a new question.
-- Mixpanel limits MCP traffic to 600 requests per user per hour. Reuse discovery results within a run and avoid speculative fan-out.
+- This account's tool list is not a fixed set. Mixpanel gates parts of its MCP catalog by plan and beta enrollment — experiments, feature flags, session replay, and issue triage are the usual absentees — so search this connector for what it actually exposes rather than assuming a documented tool is here.
+- Mixpanel meters MCP traffic per user per hour, shared with everything else that credential does. Reuse discovery results within a run and avoid speculative fan-out.
+- An \`auth_required\` failure means this connector's Mixpanel authorization is missing or expired: run \`authorize_connector\` for this connector id, then retry the same call unchanged. A rejected argument or a plan restriction comes back in Mixpanel's own words instead — read it rather than re-authorizing.
 - Treat every create, update, edit, merge, dismiss, duplicate, or delete operation as a write. Connecta routes the maintained write catalog through \`call_destructive_tool\`; newly added tools also fail closed until classified.
 ${accountInstructions
         ? `\n## Account instructions\n\n${accountInstructions}\n`
@@ -170,23 +133,34 @@ export function mixpanel(id, options) {
         throw new Error("mixpanel() requires a non-empty account purpose.");
     }
     const region = options.region ?? "us";
+    if (!(region in MIXPANEL_MCP_ENDPOINTS)) {
+        throw new Error(`mixpanel("${id}") region must be "us", "eu", or "in".`);
+    }
     const connector = remoteMcp(id, {
         url: MIXPANEL_MCP_ENDPOINTS[region],
-        title: options.title ?? "Mixpanel",
-        description: `Mixpanel product analytics — ${purpose}`,
+        // The region rides the title because browse-time discovery renders the
+        // title and the guide summary and nothing else, and residency is the fact
+        // an agent must not get wrong between two Mixpanel connections.
+        title: options.title ?? `Mixpanel (${region})`,
+        description: `Mixpanel product analytics (${REGION_COPY[region]} residency) — ${purpose}`,
         auth: options.auth ?? { type: "oauth" },
         requireHttps: true,
-        callAdmission: MIXPANEL_ADMISSION,
-        usageGuide: usageGuide(purpose, options.instructions),
+        usageGuide: {
+            content: usageGuide(purpose, region, options.instructions),
+            // Explicit rather than derived: the derived summary would truncate the
+            // residency note mid-sentence at 120 characters
+            // ([#342](https://github.com/zackbart/connecta/issues/342)).
+            summary: `${REGION_COPY[region]} residency. Project scoping, id resolution, query-schema-first analysis, plan-gated catalog.`,
+            // Not `required`. Mixpanel's own schemas describe each call; the guide
+            // carries the project-then-context sequence, which is worth reading
+            // before an analysis rather than before every call.
+        },
+        ...(options.callAdmission !== undefined
+            ? { callAdmission: options.callAdmission }
+            : {}),
         ...(options.maxResultBytes !== undefined
             ? { maxResultBytes: options.maxResultBytes }
             : {}),
     });
-    return {
-        ...connector,
-        async listTools(ctx) {
-            return (await connector.listTools(ctx)).map(vettedSafety);
-        },
-    };
+    return withVettedCatalog(connector, MIXPANEL_VETTED_CATALOG);
 }
-//# sourceMappingURL=mixpanel.js.map

package/dist/providers/notion.d.ts

@@ -36,4 +36,3 @@ export interface NotionOptions {
 }
 /** A maintained Notion connection over the public REST API. */
 export declare function notion(id: string, options: NotionOptions): Connector;
-//# sourceMappingURL=notion.d.ts.map

package/dist/providers/notion.js

@@ -1,4 +1,5 @@
 import { api } from "../connectors/api.js";
+import { guardedFetch } from "../connectors/guarded-fetch.js";
 import { ConnectorCallError } from "../errors.js";
 /** Notion's REST origin. Every tool below speaks to exactly this host. */
 export const NOTION_API_BASE_URL = "https://api.notion.com";
@@ -34,6 +35,15 @@ const MAX_CHILDREN_PER_REQUEST = 100;
  * hits this ceiling it stops and says so in `truncated`.
  */
 const MAX_CONTENT_REQUESTS = 20;
+/**
+ * The largest response this connection will read.
+ *
+ * Notion's own limits put a legitimate answer nowhere near this: `page_size`
+ * tops out at 100, and every payload here is JSON. Four mebibytes is a ceiling
+ * on absurdity — a proxy that decided to answer with something enormous — not
+ * a budget any real read has to think about.
+ */
+const NOTION_MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
 /**
  * Approximates Notion's documented limit: "an average of three requests per
  * second, with some bursts beyond the average allowed" — expressed as a
@@ -132,42 +142,50 @@ function notionFailure(status, body, retryAfterHeader) {
         retryable: false,
     });
 }
+/**
+ * The one transport every Notion tool goes through.
+ *
+ * URL confinement, `ctx.signal`, redirect refusal, bounded reads, and the
+ * "could not reach the provider" normalization live in the shared helper. The
+ * two things that cannot be shared stay here: the integration token becomes
+ * the headers Notion accepts, and `notionFailure` decides what a status means
+ * — which is the whole reason a generic HTTP client is the wrong shape, given
+ * that Notion's 403 and 404 both mean something no status table would guess.
+ */
+const send = guardedFetch({
+    provider: "Notion",
+    baseUrl: NOTION_API_BASE_URL,
+    headers: { "Notion-Version": NOTION_API_VERSION },
+    maxResponseBytes: NOTION_MAX_RESPONSE_BYTES,
+    authenticate: async (ctx) => {
+        const token = (await ctx.credential?.get())?.trim();
+        if (!token) {
+            throw new ConnectorCallError("auth_required", "No Notion integration token is configured for this connector — an operator must add one on /credentials before any Notion call can run.");
+        }
+        return { Authorization: `Bearer ${token}` };
+    },
+});
 async function notionRequest(ctx, request) {
-    const token = (await ctx.credential?.get())?.trim();
-    if (!token) {
-        throw new ConnectorCallError("auth_required", "No Notion integration token is configured for this connector — an operator must add one on /credentials before any Notion call can run.");
-    }
-    const url = new URL(request.path, NOTION_API_BASE_URL);
-    for (const [key, value] of Object.entries(request.query ?? {})) {
-        if (value !== undefined)
-            url.searchParams.set(key, String(value));
-    }
-    const headers = {
-        Authorization: `Bearer ${token}`,
-        "Notion-Version": NOTION_API_VERSION,
-    };
-    if (request.body !== undefined)
-        headers["Content-Type"] = "application/json";
-    const response = await fetch(url, {
-        method: request.method,
-        headers,
-        ...(request.body !== undefined
-            ? { body: JSON.stringify(request.body) }
-            : {}),
-        ...(ctx.signal ? { signal: ctx.signal } : {}),
+    return await send(request, ctx, async (response) => {
+        let payload;
+        try {
+            // Notion answers a delete with an empty body and a gateway answers with
+            // HTML; neither is a payload, and neither is worth a different failure.
+            payload = (await response.json());
+        }
+        catch (cause) {
+            // A transport failure is not a parse failure. The connector's byte
+            // ceiling fires from inside this read, and swallowing it would report an
+            // oversized response as an empty success on a 2xx.
+            if (cause instanceof ConnectorCallError)
+                throw cause;
+            payload = undefined;
+        }
+        if (!response.ok) {
+            throw notionFailure(response.status, payload, response.headers.get("Retry-After"));
+        }
+        return payload ?? {};
     });
-    const text = await response.text();
-    let payload;
-    try {
-        payload = text ? JSON.parse(text) : undefined;
-    }
-    catch {
-        payload = undefined;
-    }
-    if (!response.ok) {
-        throw notionFailure(response.status, payload, response.headers.get("Retry-After"));
-    }
-    return payload ?? {};
 }
 // ---------------------------------------------------------------------------
 // Projections
@@ -513,9 +531,15 @@ function projectSchemaProperty(property) {
 // ---------------------------------------------------------------------------
 // Shared schema fragments
 // ---------------------------------------------------------------------------
+// The compact renderer inlines every property description, so these three
+// shared strings are paid for once per tool that uses them. `query_data_source`
+// carries all three plus a filter grammar and rendered past the 1,024-byte
+// compact budget until they were cut to the fact each one actually adds
+// ([#342](https://github.com/zackbart/connecta/issues/342)); the long versions
+// live in the usage guide, which is fetched once rather than per tool.
 const RAW_PROPERTY = {
     type: "boolean",
-    description: "Return Notion's unprojected response instead of the lean projection. Payloads are large — use only when a field the projection drops is genuinely needed.",
+    description: "Return Notion's much larger unprojected response instead of the lean projection.",
 };
 const PAGE_SIZE_PROPERTY = {
     type: "integer",
@@ -525,12 +549,12 @@ const PAGE_SIZE_PROPERTY = {
 };
 const START_CURSOR_PROPERTY = {
     type: "string",
-    description: "Opaque cursor from a previous response's next_cursor. Pass it back verbatim; never parse or construct one.",
+    description: "Opaque next_cursor from the previous response. Pass it back verbatim.",
 };
 const PROPERTY_SELECT = {
     type: "array",
     items: { type: "string" },
-    description: "Return only these property names. Omit for all properties. Narrowing here is the cheapest way to keep results small.",
+    description: "Return only these property names. Omit for all. The cheapest way to shrink a result.",
 };
 function listOutputSchema(itemSchema) {
     return {
@@ -674,10 +698,11 @@ function buildTools(defaultPageSize) {
         // ---------------------------------------------------------------- reads
         {
             name: "search",
-            description: "Find pages and data sources by title across everything shared with this integration. Matches titles only, never page content — use query_data_source to filter rows inside a database. Returns identity fields only; call get_page for a match's properties.",
+            description: "Find pages and data sources by title across everything shared with this integration. Never searches page content — use query_data_source for rows inside a database. Returns identity fields only.",
             annotations: { readOnlyHint: true },
             inputSchema: {
                 type: "object",
+                required: [],
                 properties: {
                     query: {
                         type: "string",
@@ -1064,6 +1089,7 @@ function buildTools(defaultPageSize) {
                                 direction: {
                                     type: "string",
                                     enum: ["ascending", "descending"],
+                                    description: "Direction for this sort.",
                                 },
                             },
                             additionalProperties: false,
@@ -1104,6 +1130,7 @@ function buildTools(defaultPageSize) {
             annotations: { readOnlyHint: true },
             inputSchema: {
                 type: "object",
+                required: [],
                 properties: {
                     page_size: PAGE_SIZE_PROPERTY,
                     start_cursor: START_CURSOR_PROPERTY,
@@ -1127,7 +1154,12 @@ function buildTools(defaultPageSize) {
             name: "get_self",
             description: "Identify the integration this connector authenticates as, and the workspace it is installed in. The cheapest way to confirm the token works before a longer sequence.",
             annotations: { readOnlyHint: true },
-            inputSchema: { type: "object", additionalProperties: false },
+            inputSchema: {
+                type: "object",
+                required: [],
+                properties: {},
+                additionalProperties: false,
+            },
             outputSchema: {
                 type: "object",
                 properties: {
@@ -1189,15 +1221,22 @@ function buildTools(defaultPageSize) {
             description: "Create a page, either as a child of another page or as a row in a data source. Notion has no idempotency key: a retried create makes a second page, so confirm with search before repeating one.",
             annotations: { readOnlyHint: false },
             inputSchema: {
+                // Empty rather than absent: a parent is required, but *which* parent is
+                // an exclusive choice a plain-object `required` list cannot express,
+                // and the top-level `anyOf` that could would cost the tool its
+                // `inputKeys` in discovery. The choice is stated in both parent
+                // descriptions and enforced locally as `invalid_args` before any round
+                // trip ([#342](https://github.com/zackbart/connecta/issues/342)).
+                required: [],
                 type: "object",
                 properties: {
                     parent_page_id: {
                         type: "string",
-                        description: "Create as a child page of this page.",
+                        description: "Create as a child page of this page. Exactly one parent id, this or parent_data_source_id.",
                     },
                     parent_data_source_id: {
                         type: "string",
-                        description: "Create as a row in this data source. Not a database id.",
+                        description: "Create as a row in this data source, not a database id. Exactly one parent id, this or parent_page_id.",
                     },
                     title: { type: "string", description: "Plain-text title." },
                     title_property: {
@@ -1561,6 +1600,13 @@ it. A block type this projection does not model keeps its payload under
 - **429** carries a retry window. Notion allows roughly three requests per
   second per integration, so wait it out rather than retrying immediately.
 
+## No escape hatch
+
+This connection has no guarded raw-REST tool, deliberately. Notion's public
+API is small and slow-moving enough for the named surface to cover it, so
+there is no \`notion_api_*\` to reach for — an operation absent from the tool
+list is absent from this connection, not hidden behind a generic call.
+
 ## Writes and pagination
 
 - Notion has **no idempotency key**. A retried \`create_page\` or
@@ -1622,4 +1668,3 @@ export function notion(id, options) {
             : {}),
     });
 }
-//# sourceMappingURL=notion.js.map

package/dist/providers/stripe.d.ts

@@ -32,6 +32,18 @@ export interface StripeOptions {
     /** Connector-specific inline result limit; omit to inherit the deployment. */
     maxResultBytes?: number;
 }
+/**
+ * The manifest this release reviewed: both lists in one place, which is what
+ * makes the classification the connector applies and the drift check that runs
+ * beside it the same fact (P13). No schema digests yet — no release has read
+ * Stripe's live schemas and written them down, and an invented digest would
+ * report a change that never happened. `npm run drift:check -- --record` reads
+ * them from a live account and prints the block to paste in
+ * ([#351](https://github.com/zackbart/connecta/issues/351)).
+ *
+ * Exported because the maintainer-run check compares against this manifest and
+ * *names* what moved, which the runtime check deliberately cannot.
+ */
+export declare const STRIPE_VETTED_CATALOG: import("../catalog-drift.js").VettedCatalog;
 /** A maintained Stripe hosted-MCP connection. */
 export declare function stripe(id: string, options: StripeOptions): Connector;
-//# sourceMappingURL=stripe.d.ts.map