@zackbart/connecta 0.12.2 → 0.14.0

package/src/providers/stripe.ts

@@ -0,0 +1,306 @@
+import {
+  remoteMcp,
+  type RemoteMcpAuth,
+} from "../connectors/remote-mcp.js";
+import type {
+  Connector,
+  ConnectorCallAdmissionPolicy,
+  ToolDef,
+} from "../types.js";
+
+/**
+ * Which Stripe environment this instance speaks to. Required, and deliberately
+ * undefaulted: there is no safe guess between an account that moves real money
+ * and one that does not.
+ */
+export type StripeMode = "production" | "sandbox";
+
+/** Stripe publishes one hosted MCP endpoint; the credential selects the mode. */
+export const STRIPE_MCP_ENDPOINT = "https://mcp.stripe.com/";
+
+export interface StripeOptions {
+  /**
+   * Which Stripe environment this connector reaches. Shapes the title,
+   * description, guide, and admission budget, and is checked against a
+   * recognizable key prefix in `auth` headers.
+   */
+  mode: StripeMode;
+  /** Human-readable display name; defaults to "Stripe (<mode>)". */
+  title?: string;
+  /** Which business this account bills for, and what it may be asked. */
+  purpose: string;
+  /** OAuth by default; static headers support restricted API keys. */
+  auth?: RemoteMcpAuth;
+  /**
+   * Connect platform only: act as this connected account (`acct_...`) by
+   * sending Stripe's `Stripe-Account` header. Stripe does not support OAuth on
+   * connected-account calls, so this requires `headers` auth.
+   */
+  connectedAccount?: string;
+  /** Account-specific conventions appended to the maintained provider guide. */
+  instructions?: string;
+  /** Connector-specific inline result limit; omit to inherit the deployment. */
+  maxResultBytes?: number;
+}
+
+/**
+ * Stripe documents no MCP-specific rate limit, so this transcribes the account
+ * limit the MCP server spends: 100 requests per second in live mode, 25 in a
+ * sandbox (https://docs.stripe.com/rate-limits). The concurrency bound is
+ * connecta's own conservative choice — Stripe documents that per-account and
+ * per-endpoint concurrency limits exist and surface as `429` with a
+ * `Stripe-Rate-Limited-Reason` of `global-concurrency` or
+ * `endpoint-concurrency`, but publishes no number. Declaring `maxConcurrency`
+ * is also what earns the right to the queue settings beside it.
+ */
+const STRIPE_ADMISSION: Readonly<
+  Record<StripeMode, ConnectorCallAdmissionPolicy>
+> = {
+  production: {
+    rules: [
+      {
+        maxConcurrency: 8,
+        queueTimeoutMs: 5_000,
+        retryAfterMs: 1_000,
+        budget: { kind: "rolling-window", maxCalls: 100, windowMs: 1_000 },
+      },
+    ],
+  },
+  sandbox: {
+    rules: [
+      {
+        maxConcurrency: 4,
+        queueTimeoutMs: 5_000,
+        retryAfterMs: 1_000,
+        budget: { kind: "rolling-window", maxCalls: 25, windowMs: 1_000 },
+      },
+    ],
+  },
+};
+
+/**
+ * Tools whose official contract is observational rather than mutating.
+ *
+ * `stripe_api_read` is on this list because Stripe documents it as the `GET`
+ * half of the generic pair — the tool itself is the read boundary, not the
+ * endpoint an agent names inside it.
+ */
+const READ_ONLY_TOOLS = new Set([
+  "stripe_api_search",
+  "stripe_api_details",
+  "stripe_api_read",
+  "get_stripe_account_info",
+  "get_balance_summary",
+  "search_stripe_documentation",
+  "stripe_implementation_planner",
+]);
+
+/**
+ * The maintained write catalog. `"destructive"` tools modify or remove state
+ * that already exists; `"additive"` ones only bring something new into being.
+ * Both leave the read-only path — the distinction only decides whether the
+ * connection asserts `destructiveHint`, which shapes the host's approval copy.
+ *
+ * `create_refund` is filed destructive despite its name: it reverses a
+ * settled charge and moves money back out, which is a mutation of something
+ * that already exists, not a fresh object appearing beside it.
+ */
+const WRITE_TOOLS: ReadonlyMap<string, "additive" | "destructive"> = new Map([
+  ["stripe_api_write", "destructive"],
+  ["create_refund", "destructive"],
+  ["stripe_report", "additive"],
+  ["send_stripe_mcp_feedback", "additive"],
+]);
+
+/**
+ * Fill in what the downstream leaves unsaid; never argue with what it says.
+ *
+ * Silence is what a vetted classification is for, and an explicit downstream
+ * annotation 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)).
+ */
+function vettedSafety(definition: ToolDef): ToolDef {
+  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 writes 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,
+    },
+  };
+}
+
+/** Stripe key prefixes carry their own mode; only a clear reading counts. */
+const LIVE_KEY = /\b(?:sk|rk|pk)_live_/;
+const TEST_KEY = /\b(?:sk|rk|pk)_test_/;
+
+/**
+ * Refuse a deployment whose declared mode and supplied key disagree.
+ *
+ * This is the one half of production/sandbox routing connecta can actually
+ * enforce. Nothing here reads or reports key material: an unrecognizable
+ * credential (OAuth, or a key shape this release does not know) is left alone
+ * rather than guessed at, and a mismatch names only the two modes.
+ */
+function assertModeMatchesKey(
+  id: string,
+  mode: StripeMode,
+  auth: RemoteMcpAuth,
+): void {
+  if (auth.type !== "headers") return;
+  for (const value of Object.values(auth.headers)) {
+    const keyMode = LIVE_KEY.test(value)
+      ? "production"
+      : TEST_KEY.test(value)
+        ? "sandbox"
+        : undefined;
+    if (keyMode !== undefined && keyMode !== mode) {
+      throw new Error(
+        `stripe("${id}") declares mode "${mode}" but its auth headers carry a ` +
+          `${keyMode === "production" ? "live" : "test"}-mode Stripe key.`,
+      );
+    }
+  }
+}
+
+function resolveAuth(id: string, options: StripeOptions): RemoteMcpAuth {
+  const auth = options.auth ?? { type: "oauth" };
+  const connectedAccount = options.connectedAccount?.trim();
+  if (connectedAccount === undefined || connectedAccount === "") return auth;
+  if (!connectedAccount.startsWith("acct_")) {
+    throw new Error(
+      `stripe("${id}") connectedAccount must be a Stripe account id ("acct_...").`,
+    );
+  }
+  if (auth.type !== "headers") {
+    throw new Error(
+      `stripe("${id}") cannot reach a connected account over OAuth; Stripe ` +
+        `requires a restricted API key for Stripe-Account calls.`,
+    );
+  }
+  return {
+    type: "headers",
+    headers: { ...auth.headers, "Stripe-Account": connectedAccount },
+  };
+}
+
+const MODE_COPY: Readonly<
+  Record<StripeMode, { title: string; blurb: string; warning: string }>
+> = {
+  production: {
+    title: "Stripe (production)",
+    blurb: "production — live money and real customers",
+    warning:
+      "This is a PRODUCTION account. Every write moves real money against real customers, and a refund cannot be undone. If a request could plausibly be a rehearsal, route it to a sandbox connector instead.",
+  },
+  sandbox: {
+    title: "Stripe (sandbox)",
+    blurb: "sandbox — test data, no real money",
+    warning:
+      "This is a SANDBOX account. Nothing here is real money and none of these objects exist in production, so never answer a question about live revenue, payouts, or a named customer from this connector.",
+  },
+};
+
+function usageGuide(
+  mode: StripeMode,
+  purpose: string,
+  instructions: string | undefined,
+): string {
+  const copy = MODE_COPY[mode];
+  const accountInstructions = instructions?.trim();
+  const rate = mode === "production" ? "100" : "25";
+  return `# Stripe usage
+
+Mode: ${mode}. Account purpose: ${purpose}
+
+${copy.warning}
+
+- Four generic tools reach any Stripe API method. Find the method with \`stripe_api_search\`, read its parameters with \`stripe_api_details\`, then call \`stripe_api_read\` (GET) or \`stripe_api_write\` (POST/PATCH/PUT/DELETE). Never guess a path or a parameter name — \`stripe_api_details\` is cheaper than a rejected write.
+- Prefer a dedicated tool when one covers the task: \`get_stripe_account_info\` for which account this is, \`get_balance_summary\` for balances, \`create_refund\` for refunds, \`stripe_report\` for reports. One call instead of three, and a refund named \`create_refund\` reads far more clearly in the approval a human sees than the same refund buried in \`stripe_api_write\` arguments.
+- \`stripe_api_write\` carries the blast radius of the entire write API — every POST, PATCH, PUT, and DELETE, from a customer edit to a subscription cancellation. State the method and path explicitly; expect approval on every call.
+- Lists are cursor-paginated: \`limit\` defaults to 10 and caps at 100, \`starting_after\` and \`ending_before\` take an object id and are mutually exclusive, and \`has_more\` says whether to continue. Page inside \`execute_code\` and reduce before returning.
+- Amounts are integers in the currency's minor unit: \`1099\` is 10.99 USD, and zero-decimal currencies like JPY take \`10\` for 10 JPY. Never send a decimal.
+- Send an \`Idempotency-Key\` on every write you might retry, if the tool accepts it, and reuse the same key for the retry. A retry with a fresh key is a second charge, not a second attempt.
+- Stripe answers a rate limit with \`429\` and a \`Stripe-Rate-Limited-Reason\` header; back off on that rather than retrying immediately. This account's documented ceiling is ${rate} requests per second, and any single endpoint is capped at 25 per second regardless of mode, so paging one list is the real constraint.
+- Use \`search_stripe_documentation\` when the shape of an object or a flow is unclear; it is a read and costs nothing but a call.
+- Treat every create, update, delete, refund, and report run 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`
+      : ""
+  }`;
+}
+
+/** A maintained Stripe hosted-MCP connection. */
+export function stripe(id: string, options: StripeOptions): Connector {
+  const purpose = options.purpose.trim();
+  if (!purpose) {
+    throw new Error("stripe() requires a non-empty account purpose.");
+  }
+  const mode = options.mode;
+  if (mode !== "production" && mode !== "sandbox") {
+    throw new Error(
+      `stripe("${id}") requires mode "production" or "sandbox".`,
+    );
+  }
+  const auth = resolveAuth(id, options);
+  assertModeMatchesKey(id, mode, auth);
+  const copy = MODE_COPY[mode];
+  const connector = remoteMcp(id, {
+    url: STRIPE_MCP_ENDPOINT,
+    title: options.title ?? copy.title,
+    description: `Stripe payments (${copy.blurb}) — ${purpose}`,
+    auth,
+    requireHttps: true,
+    callAdmission: STRIPE_ADMISSION[mode],
+    usageGuide: usageGuide(mode, purpose, options.instructions),
+    ...(options.maxResultBytes !== undefined
+      ? { maxResultBytes: options.maxResultBytes }
+      : {}),
+  });
+  return {
+    ...connector,
+    async listTools(ctx) {
+      return (await connector.listTools(ctx)).map(vettedSafety);
+    },
+  };
+}

package/src/skills.ts

@@ -1,9 +1,9 @@
 import type { Connector } from "./types.js";
 
 export const CONNECTA_INSTRUCTIONS =
-  'Connecta exposes seven meta-tools. execute_code is primary: use connecta.search, describe, call, and batch for discovery, multiple or dependent calls, loops, joins, and result reduction. connecta.ui(html) is a guest function inside execute_code, never a connector address or search_tools result; pass one HTML string for display-only, or bind named read-only refresh/drill-down calls in its optional reads argument, and return the same initial summary data the HTML renders. For one read at an unknown address, search_tools with 2–4 distinctive action/object terms and includeSchemas="compact", then one call_tool — a lone cold call is cheaper direct than a program. Use call_destructive_tool individually for unannotated, write-capable, or destructive tools; authorize_connector follows auth_required; get_result follows truncation. If this routing is unfamiliar, fetch skills({ name: "usage" }).';
+  'Connecta exposes seven meta-tools. For one read at an unknown address, search_tools with 2–4 distinctive action/object terms and includeSchemas="compact", then one call_tool — a lone cold call is cheaper direct than a program. For read-only reduction, multiple or dependent calls, loops, joins, or branches, do not call top-level search_tools: make one execute_code call whose program searches, selects, calls, and reduces; never return discovery for another call. connecta.ui(html) is a guest function inside execute_code, never a connector address or search_tools result; pass one HTML string for display-only, or bind named read-only refresh/drill-down calls in its optional reads argument, and return the same initial summary data the HTML renders. Unannotated, write-capable, or destructive tools stay top level: search_tools, then call_destructive_tool; authorize_connector follows auth_required; get_result follows truncation. If this routing is unfamiliar, fetch skills({ name: "usage" }).';
 
-export const USAGE_SKILL = `# Connecta usage
+const USAGE_SKILL_BASE = `# Connecta usage
 
 ## The surface
 
@@ -23,7 +23,7 @@ Use exact addresses from discovery; never invent one. Search 2–4 distinctive a
 
 One async arrow function. The only capabilities are one global per connector (\`<connectorId>.<toolName>(args)\`), the \`connecta\` functions, and \`console.log\`.
 
-- \`connecta.search({})\` browses every catalog; \`safety: "readOnly"\` narrows to calls a program can execute, \`connector: "<id>"\` to one. This filters results, not authority; matches carry \`address\` and annotations.
+- \`connecta.search({})\` loads all catalogs; pass \`connector: "<id>"\` when obvious to load one. \`safety: "readOnly"\` keeps executable calls. Neither grants authority. Matches carry \`address\` and annotations.
 - Exact schemas: \`connecta.describe({ address: "connector.tool" })\` for one, \`{ addresses: [...] }\` for many; \`format: "json"\` only for exact constraints.
 - Two to ten independent calls: \`connecta.batch([...])\`. Each outcome is \`{ address, ok: true, data }\` or \`{ address, ok: false, error, errorDetails: { code, retryable } }\` — how a program tells a policy refusal from a transient failure.
 - Search inside the run, not before it; return only the reduction the answer needs, never raw payloads.
@@ -35,18 +35,16 @@ One async arrow function. The only capabilities are one global per connector (\`
 
 `;
 
-/**
- * Appended to USAGE_SKILL only when the deployment actually has at least one
- * connector guide. A deployment with none — every deployment that has not
- * adopted the feature — keeps the base guide byte-for-byte, rather than paying
- * context for an instruction to fetch guides that do not exist.
- */
-export const CONNECTOR_GUIDES_SECTION = `
+/** Deployment-scoped guide routing appended to the shared usage guide. */
+const CONNECTOR_GUIDES_SECTION = `
 ## Per-connector guides
 
-Some connectors here ship their own usage guide — preferred tools, address quirks, pagination conventions, rate-limit etiquette, query patterns. \`skills({})\` lists each one as \`connector:<connectorId>\`; fetch it with \`skills({ name: "connector:<connectorId>" })\`. \`search_tools\`, \`connecta.search\`, and \`connecta.describe\` set \`guide\` on matches whose connector has one. Read a connector's guide before working with it for the first time in a task.
+When a connector here ships a deployment-scoped usage guide, \`skills({})\` and discovery return the exact \`guide\` name plus a bounded \`guideSummary\` saying what it covers. Fetch only a listed or carried name with \`skills({ name: <guide> })\`; never infer one from a connector id. \`guideRequired: true\` is a hard stop: fetch before calling. \`guideRequiredReasons\` says why — \`connector_required\` and \`approval_required\` stand however you expand the schema; \`schema_truncated\` clears once describe returns the exact one. Otherwise fetch when the summary names a connector-specific sequence, unit, pagination rule, alias, or generic API convention relevant to the task. A read-only call whose compact schema is complete and unambiguous may proceed without fetching an otherwise irrelevant guide. Connector guides do not replace the shared Connecta usage guide and never apply to another deployment implicitly.
 `;
 
+/** Shared Connecta routing guidance, byte-identical across deployments. */
+export const USAGE_SKILL = USAGE_SKILL_BASE + CONNECTOR_GUIDES_SECTION;
+
 /** The always-loaded MCP `instructions` string. */
 export function instructionsFor(): string {
   return CONNECTA_INSTRUCTIONS;
@@ -59,10 +57,14 @@ export function hasConnectorGuides(connectors: readonly Connector[]): boolean {
   );
 }
 
-/** The built-in usage guide, plus the guides section when there is one to point at. */
-function usageSkill(connectors: readonly Connector[]): string {
-  if (!hasConnectorGuides(connectors)) return USAGE_SKILL;
-  return USAGE_SKILL + CONNECTOR_GUIDES_SECTION;
+/**
+ * The built-in usage guide is byte-identical across deployments, so an agent
+ * that has read it once in a task never needs an equivalent deployment-local
+ * copy. Guide-free deployments still pay no fixed tool-description cost: the
+ * conditional notes in meta-tools.ts remain absent.
+ */
+function usageSkill(_connectors: readonly Connector[]): string {
+  return USAGE_SKILL;
 }
 
 const AVAILABLE_SKILLS = [
@@ -91,7 +93,8 @@ export function connectorSkillName(connectorId: string): string {
 /** The connector's guide, or undefined when it declares none (or a blank one). */
 export function connectorGuide(connector: Connector): string | undefined {
   const guide = connector.usageGuide;
-  return guide && guide.trim() !== "" ? guide : undefined;
+  const content = typeof guide === "string" ? guide : guide?.content;
+  return content && content.trim() !== "" ? content : undefined;
 }
 
 const SUMMARY_LENGTH = 120;
@@ -125,8 +128,17 @@ function withoutFrontmatter(lines: string[]): string[] {
  * the connector's own description when the guide opens with nothing but
  * markup.
  */
+function boundedSummary(summary: string): string | undefined {
+  const line = summary.replace(/\s+/g, " ").trim();
+  if (line === "") return undefined;
+  return line.length <= SUMMARY_LENGTH
+    ? line
+    : `${line.slice(0, SUMMARY_LENGTH - 1).trimEnd()}…`;
+}
+
 function summarizeGuide(connector: Connector, guide: string): string {
   let inFence = false;
+  let headingFallback: string | undefined;
   for (const raw of withoutFrontmatter(guide.split("\n"))) {
     if (FENCE_RE.test(raw)) {
       inFence = !inFence;
@@ -134,6 +146,7 @@ function summarizeGuide(connector: Connector, guide: string): string {
     }
     if (inFence) continue;
     if (raw.trim() === "" || NOT_SUMMARY_RE.test(raw)) continue;
+    const heading = /^\s*#{1,6}/.test(raw);
     const line = raw
       // `\s*` (not `\s+`) so a bare `#` strips to nothing and is skipped, and
       // an unspaced `#Heading` is still read as a heading.
@@ -142,11 +155,37 @@ function summarizeGuide(connector: Connector, guide: string): string {
       .replace(/\s+/g, " ")
       .trim();
     if (line === "") continue;
-    return line.length <= SUMMARY_LENGTH
-      ? line
-      : `${line.slice(0, SUMMARY_LENGTH - 1).trimEnd()}…`;
+    if (heading) {
+      headingFallback ??= boundedSummary(line);
+      continue;
+    }
+    return boundedSummary(line) ?? line;
   }
-  return connector.description ?? `Usage guide for "${connector.id}".`;
+  if (headingFallback) return headingFallback;
+  const fallback = connector.description ?? `Usage guide for "${connector.id}".`;
+  return boundedSummary(fallback) ?? `Usage guide for "${connector.id}".`;
+}
+
+/** Bounded, decision-useful discovery summary for a connector guide. */
+export function connectorGuideSummary(
+  connector: Connector,
+): string | undefined {
+  const guide = connectorGuide(connector);
+  if (!guide) return undefined;
+  const configured =
+    typeof connector.usageGuide === "object"
+      ? boundedSummary(connector.usageGuide.summary ?? "")
+      : undefined;
+  return configured ?? summarizeGuide(connector, guide);
+}
+
+/** Whether correct use always depends on conventions outside the tool schema. */
+export function connectorGuideRequired(connector: Connector): boolean {
+  return (
+    connectorGuide(connector) !== undefined &&
+    typeof connector.usageGuide === "object" &&
+    connector.usageGuide.required === true
+  );
 }
 
 export interface SkillListing {
@@ -165,11 +204,13 @@ export function listSkills(connectors: readonly Connector[]): SkillListing[] {
     description: skill.description,
   }));
   for (const connector of connectors) {
-    const guide = connectorGuide(connector);
-    if (!guide) continue;
+    // Undefined here means "no guide" and nothing else: a connector that has
+    // one always summarizes to a non-empty line, configured or derived.
+    const summary = connectorGuideSummary(connector);
+    if (!summary) continue;
     listing.push({
       name: connectorSkillName(connector.id),
-      description: summarizeGuide(connector, guide),
+      description: summary,
     });
   }
   return listing;

package/src/types.ts

@@ -212,13 +212,17 @@ export interface Connector {
    */
   callAdmission?: ConnectorCallAdmissionPolicy;
   /**
-   * Optional agent-facing usage guide (markdown) for this connector — preferred
-   * tools, address quirks, pagination conventions, rate-limit etiquette, good
-   * query patterns. Listed by the `skills` meta-tool as `connector:<id>` and
-   * returned verbatim by `skills({ name: "connector:<id>" })`. Keep it concise
-   * and imperative; it is read by agents, not operators.
+   * Optional agent-facing usage guide for this connector. A string preserves
+   * the original markdown-only contract. The structured form can add a short
+   * discovery summary and require review when even a complete compact schema
+   * cannot describe correct use (for example a generic API wrapper or a
+   * cross-operation sequencing rule).
+   *
+   * Listed by `skills` as `connector:<id>` and returned verbatim by
+   * `skills({ name: "connector:<id>" })`. The guide remains deployment-owned
+   * configuration; no runtime registration or shared mutable copy exists.
    */
-  usageGuide?: string;
+  usageGuide?: string | ConnectorUsageGuide;
   /** Optional operator-managed credential slot rendered on /credentials. */
   credential?: ConnectorCredentialConfig;
   /** Optional server-side check used by /credentials' Test action. */
@@ -309,6 +313,23 @@ export interface Connector {
   ): Promise<Response | null>;
 }
 
+export interface ConnectorUsageGuide {
+  /** Markdown returned verbatim by `skills({ name: "connector:<id>" })`. */
+  content: string;
+  /**
+   * Bounded discovery hint describing the conventions the guide covers. When
+   * omitted, Connecta derives a summary from the guide's first meaningful line.
+   */
+  summary?: string;
+  /**
+   * Require review before every operation on this connector. Reserve this for
+   * cases whose correct arguments or sequence cannot be expressed by the
+   * downstream tool schema; mutations and truncated schemas are required
+   * automatically and do not need this flag.
+   */
+  required?: boolean;
+}
+
 /** Result of one sandboxed code execution. */
 export interface ExecuteResult {
   result: unknown;

package/src/version.ts

@@ -4,4 +4,4 @@
  * a bump that forgets this file fails the build rather than shipping a stale
  * version to `/health` and to downstream MCP handshakes.
  */
-export const CONNECTA_VERSION = "0.12.2";
+export const CONNECTA_VERSION = "0.14.0";

package/templates/node/package.json

@@ -12,7 +12,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@zackbart/connecta": "0.12.2",
+    "@zackbart/connecta": "0.14.0",
     "quickjs-emscripten": "0.32.0"
   },
   "devDependencies": {