npm - @zackbart/connecta - Versions diffs - 0.11.0 → 0.12.0 - Mend

@zackbart/connecta 0.11.0 → 0.12.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (33) hide show

package/CHANGELOG.md +40 -0
package/dist/apps-shell.d.ts +38 -0
package/dist/apps-shell.d.ts.map +1 -0
package/dist/apps-shell.js +175 -0
package/dist/apps-shell.js.map +1 -0
package/dist/execute.d.ts +36 -5
package/dist/execute.d.ts.map +1 -1
package/dist/execute.js +130 -14
package/dist/execute.js.map +1 -1
package/dist/executor-admission.d.ts +8 -0
package/dist/executor-admission.d.ts.map +1 -1
package/dist/executor-admission.js +11 -0
package/dist/executor-admission.js.map +1 -1
package/dist/executors/quickjs.d.ts.map +1 -1
package/dist/executors/quickjs.js +2 -2
package/dist/executors/quickjs.js.map +1 -1
package/dist/routes/mcp.d.ts.map +1 -1
package/dist/routes/mcp.js +48 -0
package/dist/routes/mcp.js.map +1 -1
package/dist/version.d.ts +1 -1
package/dist/version.js +1 -1
package/documentation/code-mode.md +109 -6
package/documentation/mcp-2026-07-28.md +1 -1
package/documentation/mcp-ui-design.md +382 -0
package/ethos.md +7 -2
package/package.json +1 -1
package/src/apps-shell.ts +179 -0
package/src/execute.ts +143 -13
package/src/executor-admission.ts +12 -0
package/src/executors/quickjs.ts +2 -1
package/src/routes/mcp.ts +60 -0
package/src/version.ts +1 -1
package/templates/node/package.json +1 -1

package/src/apps-shell.ts ADDED Viewed

@@ -0,0 +1,179 @@
+/**
+ * The one MCP Apps template connecta serves (`U5`, `U6`).
+ *
+ * A build-time string constant, not a file read at startup: the core is
+ * Web-API-only so it runs unchanged on Workers, and the same bytes have to
+ * serve everywhere. The shell is display-only — it renders whatever HTML a
+ * program handed `connecta.ui` inside a nested `srcdoc` frame and forwards no
+ * channel back from that frame to the host, so program-authored markup is
+ * inert beyond its own pixels.
+ *
+ * The address carries a version segment because hosts are permitted to
+ * prefetch and cache templates by URI: change these bytes, bump `v1`.
+ */
+/** The only `ui://` URI in the system. No program input reaches it. */
+export const PROGRAM_UI_RESOURCE_URI = "ui://connecta/program-ui/v1";
+/** The mimeType the Apps spec requires of an HTML template. */
+export const PROGRAM_UI_MIME_TYPE = "text/html;profile=mcp-app";
+/**
+ * The result `_meta` key carrying the payload (`U3`). A plain single-label
+ * prefix rather than the reverse-DNS form MCP's SHOULD prefers: connecta has
+ * no domain to reverse, and fabricating one to satisfy a SHOULD is a worse
+ * answer than the shape the key format's MUST already permits.
+ */
+export const PROGRAM_UI_META_KEY = "connecta/ui";
+/** The one extension identifier connecta advertises (`U11`). */
+export const MCP_APPS_EXTENSION = "io.modelcontextprotocol/ui";
+/**
+ * The shell document. Dependency-free and deliberately small: it speaks the
+ * Apps postMessage dialect (`ui/initialize`, `ui/notifications/initialized`,
+ * `ui/notifications/tool-result`, `ui/notifications/size-changed`,
+ * `ui/resource-teardown`), lifts `_meta["connecta/ui"].html` out of the
+ * delivered tool result, and puts it in a frame. It declares no CSP domains,
+ * so the host applies its restrictive default and the `srcdoc` frame inherits
+ * `default-src 'none'` — the payload gets scripts and local interactivity,
+ * and no network.
+ */
+export const PROGRAM_UI_SHELL_HTML = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>connecta program view</title>
+    <style>
+      html,
+      body {
+        margin: 0;
+        padding: 0;
+        background: transparent;
+      }
+      #program-view {
+        display: block;
+        width: 100%;
+        min-height: 480px;
+        border: 0;
+      }
+    </style>
+  </head>
+  <body>
+    <iframe
+      id="program-view"
+      title="Program-rendered view"
+      sandbox="allow-scripts"
+      srcdoc=""
+    ></iframe>
+    <script>
+      (function () {
+        "use strict";
+        // The host frame is the only peer this shell speaks to, in either
+        // direction. The payload frame below is sandboxed to scripts alone,
+        // with no same-origin escape, and is never handed a reply path:
+        // anything it posts fails the source check and is dropped. There is
+        // no bridge from program HTML to the host, by construction rather
+        // than by validation.
+        var host = window.parent;
+        var view = document.getElementById("program-view");
+        var initializeId = "connecta-ui-initialize";
+        var lastWidth = 0;
+        var lastHeight = 0;
+        function send(message) {
+          if (!host || host === window) return;
+          host.postMessage(message, "*");
+        }
+        function notify(method, params) {
+          send({ jsonrpc: "2.0", method: method, params: params });
+        }
+        // Program views are fixed-height by construction. The shell has no
+        // bridge to the payload frame — that is the security posture, not an
+        // omission — so it can never learn the payload's content height, and
+        // what it reports here is its own box: the min-height above, unless
+        // the host has given it more. Taller content scrolls inside the inner
+        // frame rather than growing the view. Raising the min-height is the
+        // only lever; a content-height signal would cost the isolation.
+        function reportSize() {
+          var width = Math.ceil(document.documentElement.clientWidth);
+          var height = Math.ceil(document.documentElement.scrollHeight);
+          if (width === lastWidth && height === lastHeight) return;
+          lastWidth = width;
+          lastHeight = height;
+          notify("ui/notifications/size-changed", {
+            width: width,
+            height: height
+          });
+        }
+        function payloadHtml(result) {
+          if (!result || typeof result !== "object") return null;
+          var meta = result._meta;
+          if (!meta || typeof meta !== "object") return null;
+          var payload = meta["connecta/ui"];
+          if (!payload || typeof payload !== "object") return null;
+          var html = payload.html;
+          return typeof html === "string" && html.length > 0 ? html : null;
+        }
+        function render(params) {
+          var html =
+            payloadHtml(params) ||
+            payloadHtml(params && params.result) ||
+            payloadHtml(params && params.toolResult);
+          if (html === null) return;
+          view.srcdoc = html;
+          reportSize();
+        }
+        window.addEventListener("message", function (event) {
+          if (event.source !== host) return;
+          var message = event.data;
+          if (!message || message.jsonrpc !== "2.0") return;
+          if (message.method === "ui/notifications/tool-result") {
+            render(message.params);
+            return;
+          }
+          if (message.method === "ui/resource-teardown") {
+            // A host->view request, not a notification: the host waits for
+            // this reply before it tears the view down. There is nothing to
+            // release, so answer immediately rather than make it time out.
+            if (message.id !== undefined && message.id !== null) {
+              send({ jsonrpc: "2.0", id: message.id, result: {} });
+            }
+            return;
+          }
+          // Only a completed handshake earns "initialized". A JSON-RPC error
+          // response carries the same id, and announcing initialization on one
+          // would assert a handshake that never happened.
+          if (message.id === initializeId && message.result !== undefined) {
+            notify("ui/notifications/initialized", {});
+          }
+        });
+        window.addEventListener("resize", reportSize);
+        view.addEventListener("load", reportSize);
+        // Every field here is required by the Apps initialize schema, and a
+        // conforming host rejects the request outright when one is missing —
+        // which would strand the shell before any tool result arrives.
+        send({
+          jsonrpc: "2.0",
+          id: initializeId,
+          method: "ui/initialize",
+          params: {
+            appInfo: { name: "connecta program view", version: "1" },
+            appCapabilities: {},
+            protocolVersion: "2026-01-26"
+          }
+        });
+        reportSize();
+      })();
+    </script>
+  </body>
+</html>
+`;

package/src/execute.ts CHANGED Viewed

@@ -1,6 +1,10 @@
 import type { McpServer } from "@modelcontextprotocol/server";
 import { z } from "zod";
 import type { ActivityRequestContext } from "./activity.js";
+import {
+  PROGRAM_UI_META_KEY,
+  PROGRAM_UI_RESOURCE_URI,
+} from "./apps-shell.js";
 import {
   boundedDiscoveryText,
   CatalogService,
@@ -15,6 +19,7 @@ import {
 } from "./executor-result.js";
 import {
   ExecutorAdmissionError,
+  ExecutorExecutionError,
   isAdmittingExecutor,
 } from "./executor-admission.js";
 import { classifyCallError } from "./errors.js";
@@ -69,6 +74,7 @@ class ExecuteDiagnostics {
   setupMs = 0;
   executorWallMs = 0;
   private emitted?: { count: number; bytes: number };
+  private ui?: number;
   /** Numbers only, per R8 — and only once something was emitted, so a
    * non-emitting run's diagnostics stay byte-for-byte what they were. */
@@ -76,6 +82,15 @@ class ExecuteDiagnostics {
     if (count > 0) this.emitted = { count, bytes };
   }
+  /**
+   * U9: the UI payload gets its own aggregate — one number, the payload's
+   * serialized size. Folding it into `emitted` would desync that aggregate's
+   * pair, which reports the bytes a specific block count cost.
+   */
+  recordUi(bytes: number): void {
+    this.ui = bytes;
+  }
   private stats(operation: ExecuteDiagnosticOperation) {
     let stats = this.operations.get(operation);
     if (!stats) {
@@ -158,6 +173,7 @@ class ExecuteDiagnostics {
     };
     operations: ExecuteOperationDiagnostics[];
     emitted?: { count: number; bytes: number };
+    ui?: number;
   } {
     const operations = [...this.operations.values()];
     return {
@@ -174,6 +190,7 @@ class ExecuteDiagnostics {
       },
       operations,
       ...(this.emitted ? { emitted: this.emitted } : {}),
+      ...(this.ui !== undefined ? { ui: this.ui } : {}),
     };
   }
 }
@@ -231,16 +248,49 @@ function requireEmittedBlock(raw: unknown): EmittedBlock {
   return raw as EmittedBlock;
 }
+const UI_SHAPE_HINT =
+  "connecta.ui accepts exactly one argument: a non-empty string of HTML";
+/** What the argument was, named the way the emit validator names a bad field. */
+function describeUiArgument(raw: unknown): string {
+  if (raw === null) return "null";
+  if (raw === undefined) return "undefined";
+  if (Array.isArray(raw)) return "an array";
+  if (typeof raw === "string") return "an empty string";
+  const kind = typeof raw;
+  return `${/^[aeiou]/.test(kind) ? "an" : "a"} ${kind}`;
+}
 /**
- * Request-local collection for `connecta.emit`. Budgets fail loudly at the
- * crossing call — the block is not partially accepted and prior blocks are
- * unaffected — so a program learns it is over budget while it can still
- * choose differently (M5). Accepted blocks never ride `ExecuteResult`; the
- * handler that owns this collector appends them to the final tool result.
+ * Strict U1 validation. There is no options parameter and no sugar form, for
+ * M1's reason: sugar is how a one-shape contract grows hair. An options bag or
+ * an MCP block object is just a non-string, and fails as one.
+ */
+function requireUiHtml(raw: unknown): string {
+  if (typeof raw !== "string" || raw.length === 0) {
+    throw new Error(`${UI_SHAPE_HINT}; got ${describeUiArgument(raw)}`);
+  }
+  return raw;
+}
+/**
+ * Request-local collection for `connecta.emit` and `connecta.ui`. Budgets fail
+ * loudly at the crossing call — nothing is partially accepted and prior blocks
+ * are unaffected — so a program learns it is over budget while it can still
+ * choose differently (M5, U4). Accepted output never rides `ExecuteResult`; the
+ * handler that owns this collector delivers it on the final tool result.
+ *
+ * The two channels share the byte aggregate and nothing else: a UI payload is
+ * not a block, so it spends no block count, and at most one is ever accepted.
  */
 export class EmitCollector {
   readonly blocks: EmittedBlock[] = [];
+  /** The shared transport aggregate: emitted blocks plus the UI payload. */
   bytes = 0;
+  /** The one accepted UI payload (U2), delivered in result `_meta` on success. */
+  ui?: { html: string };
+  /** What the blocks alone cost, so the `emitted` aggregate stays a true pair. */
+  private blockBytes = 0;
   constructor(
     private readonly maxBytes: number,
     private readonly maxBlocks: number,
@@ -262,7 +312,38 @@ export class EmitCollector {
     }
     this.blocks.push(block);
     this.bytes += size;
-    this.diagnostics?.recordEmitted(this.blocks.length, this.bytes);
+    this.blockBytes += size;
+    this.diagnostics?.recordEmitted(this.blocks.length, this.blockBytes);
+  }
+  /**
+   * U2 and U4: one payload per run, measured as the serialized bytes of
+   * `{ html }` against the same aggregate emit spends. A second call throws
+   * naming the constraint rather than replacing the first — one tool result
+   * renders one view, and last-wins would silently discard a payload the
+   * program deliberately supplied.
+   *
+   * Multiplicity is checked before shape, so the second call is told what it
+   * actually broke. A program whose second payload is also malformed has one
+   * problem worth naming — that there is a second payload at all — and a
+   * complaint about its type would send the author to fix the wrong thing.
+   */
+  acceptUi(raw: unknown): void {
+    if (this.ui) {
+      throw new Error(
+        "connecta.ui accepts at most one payload per run: a view was already accepted and stands",
+      );
+    }
+    const payload = { html: requireUiHtml(raw) };
+    const size = diagnosticsEncoder.encode(JSON.stringify(payload)).byteLength;
+    if (this.bytes + size > this.maxBytes) {
+      throw new Error(
+        `connecta.ui byte budget exceeded: payload is ${size} serialized bytes with ${this.maxBytes - this.bytes} of ${this.maxBytes} remaining`,
+      );
+    }
+    this.ui = payload;
+    this.bytes += size;
+    this.diagnostics?.recordUi(size);
   }
 }
@@ -558,6 +639,18 @@ export async function buildSandboxProviders(
           }
           limits.emitCollector.accept(block);
         },
+        // The rendered-output channel rides the same bridge for the same
+        // reason (U7): one more provider fn, no change to ExecuteResult or
+        // the Executor contract. Delivery is the handler's job, not the
+        // guest's — nothing here becomes addressable.
+        ui: async (html: unknown) => {
+          if (!limits.emitCollector) {
+            throw new Error(
+              "connecta.ui is unavailable: no emission collector was configured for this execution",
+            );
+          }
+          limits.emitCollector.acceptUi(html);
+        },
         batch: async (calls: unknown) => {
           const started = Date.now();
           const callCount = Array.isArray(calls) ? calls.length : 0;
@@ -812,6 +905,9 @@ export function createExecuteTool(
               ? { retryAfterMs: err.retryAfterMs }
               : {}),
           },
+          ...(err instanceof ExecutorExecutionError
+            ? discardedEmits(emitted)
+            : {}),
           ...(diagnostics ? { diagnostics: diagnostics.finish() } : {}),
         });
         result.isError = true;
@@ -936,9 +1032,19 @@ export function createExecuteTool(
     const response = jsonResult({
       result,
       ...(emitted.blocks.length > 0 ? { emitted: emitted.blocks.length } : {}),
+      // U3: the model learns a view rendered without seeing its bytes. Spread
+      // conditionally so a program that never called connecta.ui produces
+      // today's byte-for-byte response.
+      ...(emitted.ui ? { ui: true } : {}),
       ...(logs ? { logs } : {}),
       ...(diagnostics ? { diagnostics: diagnostics.finish() } : {}),
     });
+    if (emitted.ui) {
+      // _meta is where the Apps spec's best practices put data "not intended
+      // for model context", and how shipped hosts behave. The shell reads
+      // exactly this key out of the tool result the host delivers to it.
+      response._meta = { [PROGRAM_UI_META_KEY]: { html: emitted.ui.html } };
+    }
     if (emitted.blocks.length > 0) {
       // Emitted image/audio blocks are valid MCP content that ToolResult's
       // text-only typing does not model — the same acknowledged gap
@@ -951,20 +1057,31 @@ export function createExecuteTool(
   };
 }
-/** M4: a failed program delivers no blocks, but the discard is visible. */
+/**
+ * M4 and U3: a failed program delivers no blocks and no view, but each
+ * discard is visible — and one failure can discard both.
+ */
 function discardedEmits(emitted: EmitCollector): {
   emittedDiscarded?: number;
+  uiDiscarded?: true;
 } {
-  return emitted.blocks.length > 0
-    ? { emittedDiscarded: emitted.blocks.length }
-    : {};
+  return {
+    ...(emitted.blocks.length > 0
+      ? { emittedDiscarded: emitted.blocks.length }
+      : {}),
+    ...(emitted.ui ? { uiDiscarded: true as const } : {}),
+  };
 }
 /** The same visibility for the plain-text error paths. */
 function discardedEmitsText(emitted: EmitCollector): string {
-  return emitted.blocks.length > 0
-    ? `\n\nemittedDiscarded: ${emitted.blocks.length}`
-    : "";
+  const lines = [
+    ...(emitted.blocks.length > 0
+      ? [`emittedDiscarded: ${emitted.blocks.length}`]
+      : []),
+    ...(emitted.ui ? ["uiDiscarded: true"] : []),
+  ];
+  return lines.length > 0 ? `\n\n${lines.join("\n")}` : "";
 }
 const executeDescription = (
@@ -976,6 +1093,7 @@ Write an async arrow function. It runs with NO network, filesystem, timers, or i
 - connecta.call(address, args) and connecta.batch(calls) — call raw addresses.
 - connecta.search(args), connecta.describe({ address: "<connectorId>.<toolName>" }), and connecta.describe({ addresses: [...] }) — load and inspect request-local catalogs on demand. Use safety: "readOnly" to avoid advertising calls this sandbox cannot execute; the filter changes results, not authority. Matches carrying schemas also list inputKeys, requiredInputKeys, and outputKeys — the same names the schema shows, ready to check against before building args. They are absent when a schema is not a plain object shape, so read the schema itself rather than assuming a missing list means no fields.
 - connecta.emit(block) — deliver rich MCP content alongside the JSON return: exactly { type: "text", text } or { type: "image" | "audio", data (base64), mimeType }, no other fields. Blocks are appended to the result on success only, spend no host calls, and are budgeted per run (${emitBudgets.maxBlocks} blocks, ${emitBudgets.maxBytes} serialized bytes); an over-budget or invalid emit throws catchably and accepts nothing.
+- connecta.ui(html) — hand the client one rendered view of this run: exactly one argument, a non-empty HTML string, no options and no block object. At most one per run, delivered on success only, out of model context (the envelope just reports ui: true), and spending no host calls. It draws on the same ${emitBudgets.maxBytes}-byte budget as connecta.emit; a second, over-budget, or invalid call throws catchably and accepts nothing. The view is display-only — no network, no tool calls, no links.
 - console.log(...) — captured and returned alongside the result.
 Tool calls return plain values (MCP text content is JSON-parsed when possible) and throw on downstream errors — use try/catch to handle them. A thrown error carries only a message; connecta.batch reports each call as { address, ok: true, data } or { address, ok: false, error, errorDetails: { code, retryable } }, so use it when the program must tell a policy refusal from a transient failure. Never retry a failure whose retryable is false, and never retry a rate_limited one immediately — the sandbox has no timers. Return a JSON-serializable value; large results are truncated, so reduce data in code instead of returning raw payloads.
@@ -1055,6 +1173,18 @@ export function registerExecuteTool(
         destructiveHint: false,
         openWorldHint: true,
       },
+      // U5 and U10: declared unconditionally. A host without the Apps
+      // extension ignores unknown _meta and sees the ordinary envelope, which
+      // is the text fallback the spec mandates — and a stateless aggregator
+      // has nowhere dependable to hold a negotiation check anyway. The
+      // explicit visibility keeps hosts from being told the view may call
+      // execute_code; the default ["model","app"] would say exactly that.
+      _meta: {
+        ui: {
+          resourceUri: PROGRAM_UI_RESOURCE_URI,
+          visibility: ["model"],
+        },
+      },
     },
     async (args, extra) => {
       const controller = new AbortController();

package/src/executor-admission.ts CHANGED Viewed

@@ -36,6 +36,18 @@ export class ExecutorAdmissionError extends Error {
   }
 }
+/**
+ * A lifecycle failure after the sandbox started running. It keeps the stable
+ * admission-error envelope while letting response assembly distinguish work
+ * torn down in flight from work that never entered the executor.
+ */
+export class ExecutorExecutionError extends ExecutorAdmissionError {
+  constructor(code: ExecutorAdmissionErrorCode, message: string) {
+    super(code, message);
+    this.name = "ExecutorExecutionError";
+  }
+}
 export interface AdmissionLease {
   /** Time spent waiting behind active work. Zero for immediate admission. */
   readonly waitMs: number;

package/src/executors/quickjs.ts CHANGED Viewed

@@ -9,6 +9,7 @@ import { fileURLToPath } from "node:url";
 import {
   AdmissionController,
   ExecutorAdmissionError,
+  ExecutorExecutionError,
 } from "../executor-admission.js";
 import type {
   AdmittingExecutor,
@@ -737,7 +738,7 @@ class QuickJsChildPool implements AdmittingExecutor {
     if (!child) return Promise.resolve();
     this.rejectActive(
       slot,
-      new ExecutorAdmissionError(
+      new ExecutorExecutionError(
         "executor_closed",
         "Executor is shutting down.",
       ),

package/src/routes/mcp.ts CHANGED Viewed

@@ -5,6 +5,12 @@ import {
   WebStandardStreamableHTTPServerTransport,
 } from "@modelcontextprotocol/server";
 import type { ActivityActor, ActivityRequestContext } from "../activity.js";
+import {
+  MCP_APPS_EXTENSION,
+  PROGRAM_UI_MIME_TYPE,
+  PROGRAM_UI_RESOURCE_URI,
+  PROGRAM_UI_SHELL_HTML,
+} from "../apps-shell.js";
 import { registerExecuteTool } from "../execute.js";
 import {
   ExecutorAdmissionError,
@@ -184,6 +190,42 @@ function toolkitRetired(logger: Logger): Response {
   );
 }
+/**
+ * U5: one static template, served by a handler that answers exactly one URI
+ * and fails on every other. Registering it is also what declares the
+ * `resources` capability — which is why `resources/list` has to answer, and
+ * why it answers with nothing. That is the Apps spec's permitted omission of
+ * UI-only resources from listing, taken exactly: the capability stays honest
+ * because the method answers, and nothing downstream is ever listed or
+ * aggregated. Widening this handler to proxy downstream templates is a
+ * decision (see the design record), not a diff.
+ */
+function registerProgramUiResource(server: McpServer): void {
+  server.registerResource(
+    "connecta-program-ui",
+    PROGRAM_UI_RESOURCE_URI,
+    {
+      title: "connecta program view",
+      description:
+        "The MCP Apps shell that renders HTML an execute_code program handed connecta.ui.",
+      mimeType: PROGRAM_UI_MIME_TYPE,
+    },
+    (uri) => ({
+      contents: [
+        {
+          uri: uri.href,
+          mimeType: PROGRAM_UI_MIME_TYPE,
+          text: PROGRAM_UI_SHELL_HTML,
+        },
+      ],
+    }),
+  );
+  // The SDK's generated listing would advertise the template it just
+  // registered. Replace it rather than accept that: the URI reaches the host
+  // through tool metadata, so the listing has nothing to carry.
+  server.server.setRequestHandler("resources/list", () => ({ resources: [] }));
+}
 async function serveMcp(
   request: Request,
   opts: ServerOptions,
@@ -195,6 +237,23 @@ async function serveMcp(
   const createServer = (): McpServer => {
     const server = new McpServer(opts.serverInfo, {
       instructions: instructionsFor(),
+      // U11: the Apps extension must be explicitly negotiated, and a
+      // conforming client acts on an extension only when both sides declare
+      // it — without this line no host reads execute_code's _meta.ui, no host
+      // fetches the shell, and the whole design is inert. This is the one
+      // extension connecta advertises; the versioned extensions framework
+      // stays declined as a general surface (documentation/mcp-2026-07-28.md).
+      capabilities: {
+        extensions: {
+          [MCP_APPS_EXTENSION]: { mimeTypes: [PROGRAM_UI_MIME_TYPE] },
+        },
+        // Registering the shell below declares `resources` on its own, but it
+        // would default `listChanged` to true. Connecta serves one build-time
+        // template and never sends a list_changed notification, so say so:
+        // a client that subscribes on the strength of that flag would wait
+        // forever for an event this server has no way to produce.
+        resources: { listChanged: false },
+      },
       cacheHints: {
         "tools/list": {
           ttlMs: 3_600_000,
@@ -202,6 +261,7 @@ async function serveMcp(
         },
       },
     });
+    registerProgramUiResource(server);
     const activity: ActivityRequestContext | undefined = opts.activity
       ? {
           sink: opts.activity,

package/src/version.ts CHANGED Viewed

@@ -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.11.0";
+export const CONNECTA_VERSION = "0.12.0";

package/templates/node/package.json CHANGED Viewed

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