@happyvertical/smrt-web 0.38.7 → 0.38.9

package/dist/index.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Serialize `list` query params into the query string the generated REST list
+ * route parses (`handleList` in `core/src/generators/rest.ts`): `limit`,
+ * `offset`, `orderBy` as scalars, and `where` entries as `field=value`
+ * (equality) or `field[op]=value` for a `{ op, value }` condition (`in` joins an
+ * array with commas). Called with no params (the collection runtime's argument-
+ * free `list()`) it returns `''`, so the bare-URL behavior is unchanged.
+ */
+export declare function buildListQuery(params?: Record<string, unknown>): string;
+
 /**
  * Build CRUD fetchers from a generated collection definition — the same URL
  * scheme and payload handling as the generated REST client
@@ -476,6 +486,29 @@ export declare interface PersistCollectionConfig<TData extends object = object>
  */
 export declare function registerDurableResource(namespace: string, resource: DurableResource): () => void;
 
+/**
+ * Register every collection's generated tool descriptors with WebMCP.
+ *
+ * @returns a disposer that deregisters all tools this call registered. On a
+ * browser without WebMCP the call is a no-op and the disposer is inert.
+ */
+export declare function registerWebMcpTools(definitions: SmrtWebCollectionDefinition[], options?: RegisterWebMcpToolsOptions): () => void;
+
+export declare interface RegisterWebMcpToolsOptions {
+    /** REST base path for the fetchers (default `/api/v1`). */
+    basePath?: string;
+    /** Injectable fetch (tests / SSR-safe wrappers). */
+    fetchFn?: typeof fetch;
+    /**
+     * Override how a definition's CRUD fetchers are built. Defaults to
+     * {@link createDefinitionFetchers}; the primary seam for testing `execute`
+     * without a live server.
+     */
+    resolveFetchers?: (definition: SmrtWebCollectionDefinition) => SmrtCrudFetchers;
+    /** Predicate to include/exclude individual tools (e.g. reads-only surfaces). */
+    filter?: (definition: SmrtWebCollectionDefinition, descriptor: NonNullable<SmrtWebCollectionDefinition['toolDescriptors']>[number]) => boolean;
+}
+
 /**
  * Run the `wrapMutation` hook across `capabilities` in array order for one
  * mutation, short-circuiting on the FIRST capability that returns `{ handled:
@@ -662,12 +695,6 @@ export declare interface SmrtWebCollection<TData extends object> {
     insert(row: SmrtWebRow<TData>): SmrtWebTransaction;
 }
 
-/**
- * One generated collection definition: everything needed to construct a client
- * collection over the generated REST surface. The `_row` property is a phantom
- * type carrier threaded through codegen — it never exists at runtime, it only
- * lets factories infer the row type from a definition.
- */
 export declare interface SmrtWebCollectionDefinition<TData extends object = object> {
     /** REST collection name (e.g. `products`). */
     name: string;
@@ -679,6 +706,12 @@ export declare interface SmrtWebCollectionDefinition<TData extends object = obje
     idField: string;
     /** CRUD + custom actions exposed by the api decorator config. */
     actions: string[];
+    /**
+     * WebMCP/MCP tool descriptors for the exposed actions (#1812). Optional so
+     * hand-built definitions (older codegen, tests) still satisfy the type; a
+     * missing value means "no WebMCP tools to register".
+     */
+    toolDescriptors?: WebToolDescriptor[];
     /** Persisted field metadata keyed by field name. */
     fields: Record<string, SmrtWebFieldDefinition>;
     /**
@@ -964,6 +997,31 @@ export declare interface UpdateStateConfig {
     namespace: DurableStoreKey;
 }
 
+/**
+ * One generated collection definition: everything needed to construct a client
+ * collection over the generated REST surface. The `_row` property is a phantom
+ * type carrier threaded through codegen — it never exists at runtime, it only
+ * lets factories infer the row type from a definition.
+ */
+/**
+ * One WebMCP / MCP tool descriptor for a collection action (#1812). Emitted by
+ * the core web-collections codegen as PLAIN DATA (this package has no smrt
+ * dependency), shaped to match Chrome's `document.modelContext.registerTool`
+ * input — see https://developer.chrome.com/docs/ai/webmcp. Consumed by
+ * {@link registerWebMcpTools} in `./webmcp`.
+ */
+export declare interface WebToolDescriptor {
+    /** The action this tool performs (`list` | `get` | … | a custom method name). */
+    action: string;
+    /** Tool id, `${className.toLowerCase()}_${action}` (e.g. `product_list`). */
+    name: string;
+    description: string;
+    /** JSON Schema for the tool's arguments. */
+    inputSchema: Record<string, unknown>;
+    /** True for non-mutating reads → WebMCP `annotations.readOnlyHint`. */
+    readOnly: boolean;
+}
+
 /**
  * Clear every durable artifact registered under `namespace`, then drop the
  * namespace. This is the single teardown point a logout / tenant-switch calls:

package/dist/index.js

@@ -1433,6 +1433,84 @@ function createUpdateState(config) {
 	};
 }
 //#endregion
+//#region src/webmcp.ts
+function getModelContext() {
+	const mc = globalThis.document?.modelContext;
+	if (mc && typeof mc.registerTool === "function") return mc;
+}
+function registerWebMcpTools(definitions, options = {}) {
+	const ctx = getModelContext();
+	if (!ctx) return () => {};
+	const basePath = options.basePath ?? "/api/v1";
+	const controller = new AbortController();
+	for (const definition of definitions) {
+		const descriptors = definition.toolDescriptors;
+		if (!descriptors || descriptors.length === 0) continue;
+		const fetchers = options.resolveFetchers ? options.resolveFetchers(definition) : createDefinitionFetchers(definition, basePath, options.fetchFn);
+		for (const descriptor of descriptors) {
+			if (options.filter && !options.filter(definition, descriptor)) continue;
+			ctx.registerTool({
+				name: descriptor.name,
+				description: descriptor.description,
+				inputSchema: descriptor.inputSchema,
+				annotations: { readOnlyHint: descriptor.readOnly },
+				execute: (args) => dispatch(fetchers, definition, descriptor.action, args ?? {})
+			}, { signal: controller.signal });
+		}
+	}
+	return () => controller.abort();
+}
+function requireId(args, action) {
+	const id = args.id;
+	if (typeof id !== "string" || id.length === 0) throw new Error(`WebMCP ${action} requires a string 'id' argument`);
+	return id;
+}
+function requireIdentifier(args) {
+	const value = args.id ?? args.slug;
+	if (typeof value !== "string" || value.length === 0) throw new Error("WebMCP get requires a string 'id' or 'slug' argument");
+	return value;
+}
+function listParams(args) {
+	const params = {};
+	if (args.limit !== void 0) params.limit = args.limit;
+	if (args.offset !== void 0) params.offset = args.offset;
+	if (args.orderBy !== void 0) params.orderBy = args.orderBy;
+	if (args.where !== void 0) params.where = args.where;
+	return params;
+}
+async function dispatch(fetchers, definition, action, args) {
+	switch (action) {
+		case "list": {
+			const rows = unwrapListResult(await fetchers.list(listParams(args)), definition.name);
+			return JSON.stringify(rows);
+		}
+		case "get": {
+			if (!fetchers.get) throw new Error(`${definition.name} has no get action`);
+			const row = unwrapItemResult(await fetchers.get(requireIdentifier(args)), `get(${definition.name})`);
+			return JSON.stringify(row);
+		}
+		case "create": {
+			const row = unwrapItemResult(await fetchers.create(args), `create(${definition.name})`);
+			return JSON.stringify(row);
+		}
+		case "update": {
+			if (!fetchers.update) throw new Error(`${definition.name} has no update action`);
+			const { id: _id, ...body } = args;
+			const row = unwrapItemResult(await fetchers.update(requireId(args, "update"), body), `update(${definition.name})`);
+			return JSON.stringify(row);
+		}
+		case "delete":
+			if (!fetchers.delete) throw new Error(`${definition.name} has no delete action`);
+			await fetchers.delete(requireId(args, "delete"));
+			return JSON.stringify({ success: true });
+		default: return JSON.stringify({
+			error: `WebMCP custom action '${action}' is not wired in the tracer`,
+			action,
+			collection: definition.name
+		});
+	}
+}
+//#endregion
 //#region src/index.ts
 var SmrtWebRequestError = class extends Error {
 	payload;
@@ -1460,6 +1538,33 @@ function unwrapItemResult(result, context) {
 	}
 	throw new SmrtWebRequestError(`[smrt-web] ${context} returned an unexpected payload shape`, result);
 }
+var SMRT_TO_REST_OPERATOR = {
+	">": "gt",
+	">=": "gte",
+	"<": "lt",
+	"<=": "lte",
+	"!=": "ne",
+	in: "in",
+	like: "like"
+};
+function buildListQuery(params) {
+	if (!params) return "";
+	const search = new URLSearchParams();
+	const { limit, offset, orderBy, where } = params;
+	if (limit !== void 0) search.set("limit", String(limit));
+	if (offset !== void 0) search.set("offset", String(offset));
+	if (orderBy !== void 0) search.set("orderBy", Array.isArray(orderBy) ? orderBy.join(", ") : String(orderBy));
+	if (where && typeof where === "object") {
+		for (const [field, condition] of Object.entries(where)) if (condition && typeof condition === "object" && !Array.isArray(condition) && "op" in condition && "value" in condition) {
+			const { op, value } = condition;
+			const restOp = SMRT_TO_REST_OPERATOR[op];
+			const token = Array.isArray(value) ? value.join(",") : String(value);
+			search.set(restOp ? `${field}[${restOp}]` : field, token);
+		} else if (condition !== void 0 && condition !== null) search.set(field, String(condition));
+	}
+	const qs = search.toString();
+	return qs ? `?${qs}` : "";
+}
 function createDefinitionFetchers(definition, basePath = "/api/v1", fetchFn = (...args) => globalThis.fetch(...args)) {
 	const collectionUrl = `${basePath}${definition.endpoint}`;
 	const headers = { "Content-Type": "application/json" };
@@ -1472,7 +1577,7 @@ function createDefinitionFetchers(definition, basePath = "/api/v1", fetchFn = (.
 		return payload;
 	};
 	return {
-		list: async () => parse(await fetchFn(collectionUrl, { headers })),
+		list: async (params) => parse(await fetchFn(`${collectionUrl}${buildListQuery(params)}`, { headers })),
 		get: async (id) => parse(await fetchFn(`${collectionUrl}/${id}`, { headers })),
 		create: async (data) => parse(await fetchFn(collectionUrl, {
 			method: "POST",
@@ -1779,6 +1884,6 @@ function createSmrtCollection(definition, options) {
 	return handle;
 }
 //#endregion
-export { DEFAULT_PERSIST_DEBOUNCE_MS, SmrtWebRequestError, createDefinitionFetchers, createSmrtCollection, createSmrtWebClient, createSmrtWebEventSubscriber, createUpdateState, durableStoreNamespace, getEngineCollection, getOutboxHandle, liveInvalidation, newLocalId, offlineOutbox, persistCollection, registerDurableResource, runWrapMutation, unwrapItemResult, unwrapListResult, wipeDurableStore };
+export { DEFAULT_PERSIST_DEBOUNCE_MS, SmrtWebRequestError, buildListQuery, createDefinitionFetchers, createSmrtCollection, createSmrtWebClient, createSmrtWebEventSubscriber, createUpdateState, durableStoreNamespace, getEngineCollection, getOutboxHandle, liveInvalidation, newLocalId, offlineOutbox, persistCollection, registerDurableResource, registerWebMcpTools, runWrapMutation, unwrapItemResult, unwrapListResult, wipeDurableStore };
 
 //# sourceMappingURL=index.js.map