foldkit-agent-webmcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Glenn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,120 @@
+# `foldkit-agent-webmcp`
+
+The browser-native adapter for [`foldkit-agent`](../agent). It projects exposed
+Foldkit Messages into Chrome's experimental WebMCP Imperative API.
+
+WebMCP runs in the page itself, so a tool's `execute` dispatches directly into
+the same live Foldkit Runtime the human is already using — no DOM automation,
+and no external browser-session bridge.
+
+```text
+browser agent -> document.modelContext -> foldkit-agent-webmcp
+              -> Foldkit AgentRuntime  -> Message -> update -> Model + Commands
+```
+
+## Install
+
+```bash
+pnpm add foldkit-agent foldkit-agent-webmcp
+```
+
+## Usage
+
+```ts
+import { AgentWebMcp } from 'foldkit-agent-webmcp'
+
+const registration = AgentWebMcp.register({ agent: agentRuntime })
+```
+
+[examples/todo](../../examples/todo) registers a real contract and executes the
+resulting tools.
+
+`agent` is the `AgentRuntime` returned by `Agent.bind(...)`.
+
+Each currently available capability becomes one tool:
+
+```text
+capability name     -> tool name
+variant description -> description
+derived JSON Schema -> inputSchema
+Runtime dispatch    -> execute
+```
+
+No schema or handler is repeated in this package.
+
+### Options
+
+| Option | Default | Purpose |
+| --- | --- | --- |
+| `agent` | — | The bound `AgentRuntime`. |
+| `modelContext` | `document.modelContext` | The WebMCP producer surface. |
+| `signal` | — | Unregisters everything when aborted. |
+| `followModel` | `true` | Reconcile registrations as the Model changes. |
+| `invocationId` | `crypto.randomUUID()` | Supplies the invocation id. |
+| `onError` | — | Reports a failure from a reconcile no caller is awaiting. |
+
+### Returned registration
+
+```ts
+registration.refresh()     // reconcile against the current Model
+registration.registered()  // capability names currently registered
+registration.unregister()  // abort every registration and stop following
+```
+
+## Dynamic availability
+
+Tool availability is a projection of Model state, which falls out of TEA:
+
+```ts
+RequestedDeleteTodo: {
+  name: 'delete_todo',
+  description: 'Delete the selected todo',
+  available: model => Option.isSome(model.selectedTodoId),
+}
+```
+
+```text
+Todo list          tools: create_todo
+user selects todo  -> Model changes
+                   -> tools: create_todo, delete_todo
+```
+
+The adapter holds one `AbortController` per registered tool and passes its
+signal in the options bag, where `registerTool` takes it:
+
+```ts
+await document.modelContext.registerTool(tool, { signal: controller.signal })
+```
+
+Aborting that signal is what unregisters the tool, so it must not go on the
+descriptor. This is the registration signal, distinct from the execution signal
+passed to `execute`, which is forwarded as `Invocation.signal`.
+
+Reconciles are serialized, and a capability is recorded as registered only once
+`registerTool` resolves. A registration the browser refuses is not recorded and
+is retried on the next reconcile; `refresh()` rejects with the first failure
+after attempting the rest. Nothing is registered once `unregister()` has run,
+and a registration that was in flight when it ran is aborted.
+
+## Errors
+
+A dispatch failure is returned as a tool error rather than thrown, so the
+calling agent can act on it:
+
+```text
+No such capability: delete_todo
+Capability "delete_todo" is not available right now
+Not authorized to invoke "delete_todo"
+Invalid input for "create_todo"
+Capability "create_todo" failed unexpectedly
+```
+
+The last covers an unexpected defect, such as the host's `dispatch` throwing.
+`execute` never rejects and never echoes the underlying error back to the
+caller.
+
+## Why this stays an adapter
+
+WebMCP is experimental and evolving. The types it needs are declared locally in
+`src/webmcp.ts` rather than imported, so the browser API can change without the
+Foldkit agent contract changing with it.

package/dist/index.d.mts

@@ -0,0 +1,101 @@
+import { Agent } from "foldkit-agent";
+//#region src/webmcp.d.ts
+/**
+ * The slice of Chrome's experimental WebMCP Imperative API this adapter uses.
+ *
+ * These types are declared locally rather than imported: the API is still
+ * experimental, and Foldkit should not be coupled to a browser proposal that is
+ * still changing.
+ */
+/** Metadata passed to a tool's `execute` function. */
+interface ToolExecutionContext {
+  /** Cancellation for this invocation: is this call still wanted? */
+  readonly signal?: AbortSignal | undefined;
+}
+/** The value a WebMCP tool returns. */
+interface ToolResult {
+  readonly content: ReadonlyArray<{
+    readonly type: 'text';
+    readonly text: string;
+  }>;
+  readonly isError?: boolean;
+}
+/** A tool registration as accepted by `document.modelContext.registerTool`. */
+interface ToolDescriptor {
+  readonly name: string;
+  readonly description: string;
+  readonly inputSchema: Record<string, unknown>;
+  readonly execute: (input: any, context: ToolExecutionContext) => Promise<ToolResult>;
+}
+/**
+ * Options accepted alongside a tool registration.
+ *
+ * The registration signal belongs here, not on the descriptor: aborting it is
+ * how the documented API unregisters a tool.
+ */
+interface RegisterToolOptions {
+  readonly signal?: AbortSignal | undefined;
+}
+/** The producer surface exposed on `document.modelContext`. */
+interface ModelContext {
+  readonly registerTool: (tool: ToolDescriptor, options?: RegisterToolOptions) => void | Promise<unknown>;
+}
+/** Reads `document.modelContext`, when the page provides it. */
+declare const documentModelContext: () => ModelContext | undefined;
+//#endregion
+//#region src/register.d.ts
+/** A live WebMCP registration. */
+interface Registration {
+  /** Re-reads availability from the current Model and reconciles registrations. */
+  readonly refresh: () => Promise<void>;
+  /** Unregisters every tool and stops following the Model. */
+  readonly unregister: () => void;
+  /** The capability names currently registered with WebMCP. */
+  readonly registered: () => ReadonlyArray<string>;
+}
+interface RegisterOptions<Model, Context_, Principal, ByName, ByTag> {
+  /** The agent contract bound to a live Foldkit Runtime. */
+  readonly agent: Agent.AgentRuntime<Model, Context_, Principal, ByName, ByTag>;
+  /** Defaults to `document.modelContext`. */
+  readonly modelContext?: ModelContext | undefined;
+  /** Unregisters everything when aborted. */
+  readonly signal?: AbortSignal | undefined;
+  /**
+   * Follow the live Model and reconcile registrations as `available(model)`
+   * changes. Defaults to `true`, and is inert unless the host supports
+   * subscription.
+   */
+  readonly followModel?: boolean | undefined;
+  /** Supplies an invocation id. Defaults to `crypto.randomUUID()`. */
+  readonly invocationId?: (() => string) | undefined;
+  /**
+   * Reports a failure from a reconcile that no caller is awaiting -- the
+   * initial registration, or one triggered by a Model change.
+   */
+  readonly onError?: ((error: unknown) => void) | undefined;
+}
+/**
+ * Projects an agent contract into `document.modelContext.registerTool(...)`.
+ *
+ * Each currently available capability becomes one tool: the capability name
+ * becomes the tool name, the variant description becomes the description, the
+ * derived JSON Schema becomes `inputSchema`, and `execute` validates its input
+ * and dispatches into the same live Foldkit Runtime the human is using.
+ *
+ * Tool availability is itself a projection of Model state. When
+ * `available(model)` changes, registrations are reconciled: capabilities that
+ * are gone have their registration signal aborted, and capabilities that have
+ * appeared are registered.
+ *
+ * @example
+ * ```ts
+ * const registration = AgentWebMcp.register({ agent: agentRuntime })
+ * ```
+ */
+declare const register: <Model, Context_, Principal, ByName, ByTag>(options: RegisterOptions<Model, Context_, Principal, ByName, ByTag>) => Registration;
+declare namespace agentWebMcp_d_exports {
+  export { RegisterOptions, Registration, documentModelContext, register };
+}
+//#endregion
+export { agentWebMcp_d_exports as AgentWebMcp, type ModelContext, type RegisterToolOptions, type ToolDescriptor, type ToolExecutionContext, type ToolResult };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/webmcp.ts","../src/register.ts","../src/agentWebMcp.ts"],"mappings":";;;;;;;;;;UASiB;;WAEN,SAAS;;;UAIH;WACN,SAAS;aAAyB;aAAuB;;WACzD;;;UAIM;WACN;WACA;WACA,aAAa;WACb,UAAU,YAAY,SAAS,yBAAyB,QAAQ;;;;;;;;UAS1D;WACN,SAAS;;;UAIH;WACN,eACP,MAAM,gBACN,UAAU,+BACA;;;cAID,4BAA2B;;;;UCrCvB;;WAEN,eAAe;;WAEf;;WAEA,kBAAkB;;UAGZ,gBAAgB,OAAO,UAAU,WAAW,QAAQ;;WAE1D,OAAO,MAAM,aAAa,OAAO,UAAU,WAAW,QAAQ;;WAE9D,eAAe;;WAEf,SAAS;;;;;;WAMT;;WAEA;;;;;WAKA,YAAY;;;;;;;;;;;;;;;;;;;;cA0BV,WAAY,OAAO,UAAU,WAAW,QAAQ,OAC3D,SAAS,gBAAgB,OAAO,UAAU,WAAW,QAAQ,WAC5D"}

package/dist/index.mjs

@@ -0,0 +1,147 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Agent } from "foldkit-agent";
+import { Effect } from "effect";
+//#region src/webmcp.ts
+/** Reads `document.modelContext`, when the page provides it. */
+const documentModelContext = () => {
+	if (typeof document === "undefined") return void 0;
+	return document.modelContext;
+};
+//#endregion
+//#region src/register.ts
+const textResult = (text, isError = false) => ({
+	content: [{
+		type: "text",
+		text
+	}],
+	isError
+});
+/**
+* Projects an agent contract into `document.modelContext.registerTool(...)`.
+*
+* Each currently available capability becomes one tool: the capability name
+* becomes the tool name, the variant description becomes the description, the
+* derived JSON Schema becomes `inputSchema`, and `execute` validates its input
+* and dispatches into the same live Foldkit Runtime the human is using.
+*
+* Tool availability is itself a projection of Model state. When
+* `available(model)` changes, registrations are reconciled: capabilities that
+* are gone have their registration signal aborted, and capabilities that have
+* appeared are registered.
+*
+* @example
+* ```ts
+* const registration = AgentWebMcp.register({ agent: agentRuntime })
+* ```
+*/
+const register = (options) => {
+	const modelContext = options.modelContext ?? documentModelContext();
+	if (modelContext === void 0) throw new Error("WebMCP is unavailable: no document.modelContext. Pass an explicit modelContext to register().");
+	const { agent } = options;
+	const nextInvocationId = options.invocationId ?? Agent.newInvocationId;
+	/** One AbortController per registered tool: aborting it unregisters that tool. */
+	const controllers = /* @__PURE__ */ new Map();
+	let disposed = false;
+	const toolFor = (name, description, inputSchema) => {
+		const controller = new AbortController();
+		const execute = async (input, context) => {
+			try {
+				const result = await Effect.runPromise(Effect.result(agent.messages.dispatchUnknown(name, input, {
+					id: nextInvocationId(),
+					transport: "webmcp",
+					signal: context.signal
+				})));
+				if (result._tag === "Failure") return textResult(result.failure.message, true);
+				const { completion } = result.success;
+				if (completion === void 0) return textResult(`Dispatched ${result.success.tag}`);
+				return textResult(`${completion.status === "completed" ? "Completed" : "Failed"}: ${completion.message._tag}`, completion.status === "failed");
+			} catch {
+				return textResult(`Capability "${name}" failed unexpectedly`, true);
+			}
+		};
+		return {
+			controller,
+			tool: {
+				name,
+				description,
+				inputSchema,
+				execute
+			}
+		};
+	};
+	const runReconcile = async () => {
+		if (disposed) return;
+		const available = await Effect.runPromise(agent.messages.available);
+		const wanted = new Map(available.map((descriptor) => [descriptor.name, descriptor]));
+		for (const [name, controller] of [...controllers]) if (!wanted.has(name)) {
+			controller.abort();
+			controllers.delete(name);
+		}
+		let failure;
+		for (const [name, descriptor] of wanted) {
+			if (disposed) return;
+			if (controllers.has(name)) continue;
+			const { controller, tool } = toolFor(name, descriptor.description, descriptor.inputSchema);
+			try {
+				await modelContext.registerTool(tool, { signal: controller.signal });
+			} catch (error) {
+				failure ??= error;
+				continue;
+			}
+			if (disposed) {
+				controller.abort();
+				return;
+			}
+			controllers.set(name, controller);
+		}
+		if (failure !== void 0) throw failure;
+	};
+	/**
+	* Reconciles are serialized.
+	*
+	* A capability is recorded only once the browser has accepted it, so two
+	* overlapping reconciles would both see it as missing and register it twice.
+	*/
+	let queue = Promise.resolve();
+	const reconcile = () => {
+		const next = queue.then(runReconcile, runReconcile);
+		queue = next.then(() => {}, () => {});
+		return next;
+	};
+	let unsubscribe = () => {};
+	const unregister = () => {
+		disposed = true;
+		for (const controller of controllers.values()) controller.abort();
+		controllers.clear();
+		unsubscribe();
+	};
+	/**
+	* Reconciles without a caller to await the result. A rejection here would
+	* otherwise become an unhandled rejection, so it is reported through
+	* `onError` and the registration is left as it was.
+	*/
+	const reconcileInBackground = () => {
+		reconcile().catch((error) => {
+			options.onError?.(error);
+		});
+	};
+	reconcileInBackground();
+	if (options.followModel !== false) unsubscribe = agent.subscribe(reconcileInBackground);
+	if (options.signal?.aborted === true) unregister();
+	else options.signal?.addEventListener("abort", unregister, { once: true });
+	return {
+		refresh: reconcile,
+		unregister,
+		registered: () => [...controllers.keys()]
+	};
+};
+//#endregion
+//#region src/agentWebMcp.ts
+var agentWebMcp_exports = /* @__PURE__ */ __exportAll({
+	documentModelContext: () => documentModelContext,
+	register: () => register
+});
+//#endregion
+export { agentWebMcp_exports as AgentWebMcp };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/webmcp.ts","../src/register.ts","../src/agentWebMcp.ts"],"sourcesContent":["/**\n * The slice of Chrome's experimental WebMCP Imperative API this adapter uses.\n *\n * These types are declared locally rather than imported: the API is still\n * experimental, and Foldkit should not be coupled to a browser proposal that is\n * still changing.\n */\n\n/** Metadata passed to a tool's `execute` function. */\nexport interface ToolExecutionContext {\n  /** Cancellation for this invocation: is this call still wanted? */\n  readonly signal?: AbortSignal | undefined\n}\n\n/** The value a WebMCP tool returns. */\nexport interface ToolResult {\n  readonly content: ReadonlyArray<{ readonly type: 'text'; readonly text: string }>\n  readonly isError?: boolean\n}\n\n/** A tool registration as accepted by `document.modelContext.registerTool`. */\nexport interface ToolDescriptor {\n  readonly name: string\n  readonly description: string\n  readonly inputSchema: Record<string, unknown>\n  readonly execute: (input: any, context: ToolExecutionContext) => Promise<ToolResult>\n}\n\n/**\n * Options accepted alongside a tool registration.\n *\n * The registration signal belongs here, not on the descriptor: aborting it is\n * how the documented API unregisters a tool.\n */\nexport interface RegisterToolOptions {\n  readonly signal?: AbortSignal | undefined\n}\n\n/** The producer surface exposed on `document.modelContext`. */\nexport interface ModelContext {\n  readonly registerTool: (\n    tool: ToolDescriptor,\n    options?: RegisterToolOptions,\n  ) => void | Promise<unknown>\n}\n\n/** Reads `document.modelContext`, when the page provides it. */\nexport const documentModelContext = (): ModelContext | undefined => {\n  if (typeof document === 'undefined') return undefined\n  return (document as unknown as { modelContext?: ModelContext }).modelContext\n}\n","import { Agent } from 'foldkit-agent'\nimport { Effect } from 'effect'\nimport {\n  type ModelContext,\n  type ToolDescriptor,\n  type ToolResult,\n  documentModelContext,\n} from './webmcp.js'\n\n/** A live WebMCP registration. */\nexport interface Registration {\n  /** Re-reads availability from the current Model and reconciles registrations. */\n  readonly refresh: () => Promise<void>\n  /** Unregisters every tool and stops following the Model. */\n  readonly unregister: () => void\n  /** The capability names currently registered with WebMCP. */\n  readonly registered: () => ReadonlyArray<string>\n}\n\nexport interface RegisterOptions<Model, Context_, Principal, ByName, ByTag> {\n  /** The agent contract bound to a live Foldkit Runtime. */\n  readonly agent: Agent.AgentRuntime<Model, Context_, Principal, ByName, ByTag>\n  /** Defaults to `document.modelContext`. */\n  readonly modelContext?: ModelContext | undefined\n  /** Unregisters everything when aborted. */\n  readonly signal?: AbortSignal | undefined\n  /**\n   * Follow the live Model and reconcile registrations as `available(model)`\n   * changes. Defaults to `true`, and is inert unless the host supports\n   * subscription.\n   */\n  readonly followModel?: boolean | undefined\n  /** Supplies an invocation id. Defaults to `crypto.randomUUID()`. */\n  readonly invocationId?: (() => string) | undefined\n  /**\n   * Reports a failure from a reconcile that no caller is awaiting -- the\n   * initial registration, or one triggered by a Model change.\n   */\n  readonly onError?: ((error: unknown) => void) | undefined\n}\n\nconst textResult = (text: string, isError = false): ToolResult => ({\n  content: [{ type: 'text', text }],\n  isError,\n})\n\n/**\n * Projects an agent contract into `document.modelContext.registerTool(...)`.\n *\n * Each currently available capability becomes one tool: the capability name\n * becomes the tool name, the variant description becomes the description, the\n * derived JSON Schema becomes `inputSchema`, and `execute` validates its input\n * and dispatches into the same live Foldkit Runtime the human is using.\n *\n * Tool availability is itself a projection of Model state. When\n * `available(model)` changes, registrations are reconciled: capabilities that\n * are gone have their registration signal aborted, and capabilities that have\n * appeared are registered.\n *\n * @example\n * ```ts\n * const registration = AgentWebMcp.register({ agent: agentRuntime })\n * ```\n */\nexport const register = <Model, Context_, Principal, ByName, ByTag>(\n  options: RegisterOptions<Model, Context_, Principal, ByName, ByTag>,\n): Registration => {\n  const modelContext = options.modelContext ?? documentModelContext()\n  if (modelContext === undefined) {\n    throw new Error(\n      'WebMCP is unavailable: no document.modelContext. Pass an explicit modelContext to register().',\n    )\n  }\n\n  const { agent } = options\n  const nextInvocationId = options.invocationId ?? Agent.newInvocationId\n\n  /** One AbortController per registered tool: aborting it unregisters that tool. */\n  const controllers = new Map<string, AbortController>()\n  let disposed = false\n\n  const toolFor = (\n    name: string,\n    description: string,\n    inputSchema: Record<string, unknown>,\n  ): { readonly controller: AbortController; readonly tool: ToolDescriptor } => {\n    const controller = new AbortController()\n\n    const execute = async (\n      input: unknown,\n      context: { readonly signal?: AbortSignal | undefined },\n    ): Promise<ToolResult> => {\n      try {\n        // WebMCP hands the page a promise-returning callback, so this is the\n        // edge where Effect meets the browser, not a run inside a service.\n        const result = await Effect.runPromise(\n          Effect.result(\n            // The tool name and payload both come off the wire.\n            agent.messages.dispatchUnknown(name, input, {\n              id: nextInvocationId(),\n              transport: 'webmcp',\n              signal: context.signal,\n            }),\n          ),\n        )\n\n        // Every agent failure carries a message written for this audience.\n        if (result._tag === 'Failure') return textResult(result.failure.message, true)\n\n        // A declared completion contract has already resolved by the time\n        // dispatch returns, so a failed completion is a failed tool call --\n        // reported the same way the MCP adapter reports it.\n        const { completion } = result.success\n        if (completion === undefined) return textResult(`Dispatched ${result.success.tag}`)\n\n        return textResult(\n          `${completion.status === 'completed' ? 'Completed' : 'Failed'}: ${completion.message._tag}`,\n          completion.status === 'failed',\n        )\n      } catch {\n        // `Effect.result` captures expected failures but not defects, and a\n        // rejected tool promise is not something a calling agent can act on.\n        // Report it as a tool error without leaking the application's internals.\n        return textResult(`Capability \"${name}\" failed unexpectedly`, true)\n      }\n    }\n\n    return { controller, tool: { name, description, inputSchema, execute } }\n  }\n\n  const runReconcile = async (): Promise<void> => {\n    if (disposed) return\n\n    const available = await Effect.runPromise(agent.messages.available)\n    const wanted = new Map(available.map(descriptor => [descriptor.name, descriptor]))\n\n    // Unregister capabilities the Model no longer offers.\n    for (const [name, controller] of [...controllers]) {\n      if (!wanted.has(name)) {\n        controller.abort()\n        controllers.delete(name)\n      }\n    }\n\n    // Register capabilities that have appeared.\n    let failure: unknown\n    for (const [name, descriptor] of wanted) {\n      // unregister() can land while an await above is pending. Nothing more is\n      // registered after that.\n      if (disposed) return\n      if (controllers.has(name)) continue\n\n      const { controller, tool } = toolFor(name, descriptor.description, descriptor.inputSchema)\n\n      try {\n        // The signal goes in the options bag: aborting it is what unregisters\n        // the tool.\n        await modelContext.registerTool(tool, { signal: controller.signal })\n      } catch (error) {\n        // Nothing was registered, so nothing is recorded and nothing to abort.\n        failure ??= error\n        continue\n      }\n\n      // Disposal can also land while this registration is in flight, in which\n      // case the tool is already registered and has to be taken back.\n      if (disposed) {\n        controller.abort()\n        return\n      }\n\n      // Recorded only once the browser has accepted it.\n      controllers.set(name, controller)\n    }\n\n    if (failure !== undefined) throw failure\n  }\n\n  /**\n   * Reconciles are serialized.\n   *\n   * A capability is recorded only once the browser has accepted it, so two\n   * overlapping reconciles would both see it as missing and register it twice.\n   */\n  let queue: Promise<void> = Promise.resolve()\n\n  const reconcile = (): Promise<void> => {\n    const next = queue.then(runReconcile, runReconcile)\n    queue = next.then(\n      () => {},\n      () => {},\n    )\n    return next\n  }\n\n  let unsubscribe: () => void = () => {}\n\n  const unregister = (): void => {\n    disposed = true\n    for (const controller of controllers.values()) controller.abort()\n    controllers.clear()\n    unsubscribe()\n  }\n\n  /**\n   * Reconciles without a caller to await the result. A rejection here would\n   * otherwise become an unhandled rejection, so it is reported through\n   * `onError` and the registration is left as it was.\n   */\n  const reconcileInBackground = (): void => {\n    reconcile().catch(error => {\n      options.onError?.(error)\n    })\n  }\n\n  reconcileInBackground()\n\n  if (options.followModel !== false) {\n    unsubscribe = agent.subscribe(reconcileInBackground)\n  }\n\n  if (options.signal?.aborted === true) {\n    // An already-aborted signal never fires its listener.\n    unregister()\n  } else {\n    options.signal?.addEventListener('abort', unregister, { once: true })\n  }\n\n  return {\n    refresh: reconcile,\n    unregister,\n    registered: () => [...controllers.keys()],\n  }\n}\n","export { register, type RegisterOptions, type Registration } from './register.js'\nexport { documentModelContext } from './webmcp.js'\n"],"mappings":"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"}

package/dist/rolldown-runtime-D7D4PA-g.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "foldkit-agent-webmcp",
+  "version": "0.1.0",
+  "description": "WebMCP adapter for foldkit-agent. Projects exposed Foldkit Messages into document.modelContext tools.",
+  "keywords": [
+    "foldkit",
+    "effect",
+    "agents",
+    "webmcp",
+    "browser"
+  ],
+  "type": "module",
+  "license": "MIT",
+  "author": "Patrick Glenn <doeixd@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/doeixd/foldkit-plus.git",
+    "directory": "packages/agent-webmcp"
+  },
+  "homepage": "https://github.com/doeixd/foldkit-plus/tree/main/packages/agent-webmcp#readme",
+  "bugs": {
+    "url": "https://github.com/doeixd/foldkit-plus/issues"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "effect": "^4.0.0-rc.112",
+    "foldkit": "^0.158.2",
+    "foldkit-agent": "^0.1.0"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "effect": "4.0.0-rc.112",
+    "foldkit": "0.158.2",
+    "tsdown": "^0.23.0",
+    "typescript": "^5.7.2",
+    "foldkit-agent": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -b"
+  }
+}