@happyvertical/smrt-svelte 0.43.2 → 0.43.4

package/dist/web/webmcp-ui.js

@@ -0,0 +1,455 @@
+import { DATA_SURFACE_IDENTIFIER_MAX_LENGTH, DATA_SURFACE_MAX_REQUEST_BYTES, } from '@happyvertical/smrt-ui/data';
+const CONTROL_ACTIONS = new Set([
+    'focus',
+    'reveal',
+    'highlight',
+    'explain',
+    'validate',
+    'stage',
+    'apply',
+    'clear',
+    'undo',
+]);
+const DEFAULT_PREFIX = 'smrt_ui_';
+const PREFIX_PATTERN = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
+const PUBLIC_FAILURE_REASONS = new Set([
+    'invalid_request',
+    'invalid_identifier',
+    'limit_exceeded',
+    'not_found',
+]);
+const PUBLIC_CONTROL_RESULT_REASONS = new Set([
+    'not_found',
+    'consent_required',
+    'sensitive_control',
+    'control_not_writable',
+    'control_not_editable',
+    'nothing_to_undo',
+    'denied',
+]);
+const documentLocks = new WeakMap();
+class PublicToolError extends Error {
+    reason;
+    details;
+    constructor(reason, details) {
+        super(reason);
+        this.reason = reason;
+        this.details = details;
+    }
+}
+function publicError(reason, details) {
+    return new PublicToolError(reason, details);
+}
+function success(result) {
+    return JSON.stringify({ ok: true, result });
+}
+function failure(reason, details) {
+    return JSON.stringify({
+        ok: false,
+        reason,
+        ...(details ? { details } : {}),
+    });
+}
+function requestBytes(value) {
+    return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+function assertRequestSize(value) {
+    if (requestBytes(value) > DATA_SURFACE_MAX_REQUEST_BYTES) {
+        throw publicError('limit_exceeded');
+    }
+}
+function requiredIdentifier(value, name, maxLength = DATA_SURFACE_IDENTIFIER_MAX_LENGTH) {
+    if (typeof value !== 'string' ||
+        value.length === 0 ||
+        value.length > maxLength ||
+        Array.from(value).some((character) => {
+            const code = character.charCodeAt(0);
+            return code < 32 || code === 127;
+        })) {
+        throw publicError('invalid_identifier', name);
+    }
+    return value;
+}
+function optionalIdentifier(value, name) {
+    return value === undefined ? undefined : requiredIdentifier(value, name);
+}
+function record(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw publicError('invalid_request');
+    }
+    return value;
+}
+function controlIdentity(value) {
+    const input = record(value);
+    const subjectInput = input.subject;
+    const subject = subjectInput === undefined
+        ? undefined
+        : (() => {
+            const next = record(subjectInput);
+            return {
+                type: requiredIdentifier(next.type, 'subject.type'),
+                id: requiredIdentifier(next.id, 'subject.id'),
+                ...(next.label === undefined
+                    ? {}
+                    : { label: requiredIdentifier(next.label, 'subject.label') }),
+            };
+        })();
+    return {
+        formId: requiredIdentifier(input.formId, 'formId'),
+        controlId: requiredIdentifier(input.controlId, 'controlId'),
+        ...(subject ? { subject } : {}),
+    };
+}
+function dataSurfaceIdentity(value) {
+    const input = record(value);
+    const kind = input.kind;
+    if (!['table', 'list', 'report', 'custom'].includes(String(kind))) {
+        throw publicError('invalid_request', 'identity.kind');
+    }
+    const subjectInput = input.subject;
+    const subject = subjectInput === undefined
+        ? undefined
+        : (() => {
+            const next = record(subjectInput);
+            return {
+                type: requiredIdentifier(next.type, 'subject.type'),
+                id: requiredIdentifier(next.id, 'subject.id'),
+                ...(next.label === undefined
+                    ? {}
+                    : { label: requiredIdentifier(next.label, 'subject.label') }),
+            };
+        })();
+    return {
+        surfaceId: requiredIdentifier(input.surfaceId, 'surfaceId'),
+        kind: kind,
+        ...(subject ? { subject } : {}),
+    };
+}
+function sanitizeControl(snapshot) {
+    const redactText = snapshot.metadata.sensitivity === 'secret' || snapshot.state.valueRedacted;
+    const runtimeState = { ...snapshot.state };
+    delete runtimeState.validationMessage;
+    return {
+        ...snapshot,
+        identity: { ...snapshot.identity },
+        metadata: {
+            ...snapshot.metadata,
+            constraints: snapshot.metadata.constraints
+                ? { ...snapshot.metadata.constraints }
+                : undefined,
+            options: snapshot.metadata.options?.map((option) => ({ ...option })),
+        },
+        state: {
+            ...(redactText ? runtimeState : snapshot.state),
+            ...(redactText || snapshot.state.valueRedacted
+                ? { value: undefined }
+                : {}),
+            ...(redactText || snapshot.state.stagedValueRedacted
+                ? { stagedValue: undefined }
+                : {}),
+        },
+    };
+}
+function sanitizeSurfaceValue(value, hiddenColumnIds, redactRowIds, parentKey) {
+    if (Array.isArray(value)) {
+        return value
+            .filter((entry) => parentKey !== 'columnOrder' ||
+            typeof entry !== 'string' ||
+            !hiddenColumnIds.has(entry))
+            .map((entry) => sanitizeSurfaceValue(entry, hiddenColumnIds, redactRowIds, parentKey))
+            .filter((entry) => entry !== undefined);
+    }
+    if (!value || typeof value !== 'object')
+        return value;
+    const object = value;
+    if (typeof object.columnId === 'string' &&
+        hiddenColumnIds.has(object.columnId)) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(object).flatMap(([key, entry]) => {
+        if (hiddenColumnIds.has(key))
+            return [];
+        if (redactRowIds &&
+            (key === 'selection' ||
+                key === 'selectedRowIds' ||
+                key === 'expandedRowIds')) {
+            return [];
+        }
+        const sanitized = sanitizeSurfaceValue(entry, hiddenColumnIds, redactRowIds, key);
+        return sanitized === undefined ? [] : [[key, sanitized]];
+    }));
+}
+function visibleDescriptor(descriptor) {
+    const columns = descriptor.columns.filter((column) => column.visibility !== 'hidden');
+    const visibleColumnIds = new Set(columns.map((column) => column.id));
+    const { rowKey, ...visible } = descriptor;
+    return {
+        ...visible,
+        identity: { ...descriptor.identity },
+        ...(visibleColumnIds.has(rowKey) ? { rowKey } : {}),
+        columns,
+        query: {
+            ...descriptor.query,
+            projectableColumnIds: descriptor.query.projectableColumnIds.filter((id) => visibleColumnIds.has(id)),
+            searchableColumnIds: descriptor.query.searchableColumnIds?.filter((id) => visibleColumnIds.has(id)),
+            filterableColumnIds: descriptor.query.filterableColumnIds?.filter((id) => visibleColumnIds.has(id)),
+            sortableColumnIds: descriptor.query.sortableColumnIds?.filter((id) => visibleColumnIds.has(id)),
+        },
+        actions: descriptor.actions.filter((action) => (action.columnIds ?? []).every((id) => visibleColumnIds.has(id))),
+    };
+}
+function visibleSnapshot(snapshot) {
+    const hiddenColumnIds = new Set(snapshot.descriptor.columns
+        .filter((column) => column.visibility === 'hidden')
+        .map((column) => column.id));
+    const rowKeyHidden = hiddenColumnIds.has(snapshot.descriptor.rowKey);
+    const state = sanitizeSurfaceValue(snapshot.state, hiddenColumnIds, rowKeyHidden);
+    return {
+        ...snapshot,
+        descriptor: visibleDescriptor(snapshot.descriptor),
+        state,
+        selection: rowKeyHidden ? null : snapshot.selection,
+    };
+}
+function executeSafely(execute) {
+    return Promise.resolve()
+        .then(execute)
+        .then(success)
+        .catch((error) => {
+        return error instanceof PublicToolError &&
+            PUBLIC_FAILURE_REASONS.has(error.reason)
+            ? failure(error.reason, error.details)
+            : failure('execution_failed');
+    });
+}
+function readTool(name, description, inputSchema, execute) {
+    return {
+        name,
+        description,
+        inputSchema,
+        annotations: { readOnlyHint: true, untrustedContentHint: true },
+        execute,
+    };
+}
+function tools(prefix, controlRegistry, dataSurfaceRegistry) {
+    const identitySchema = {
+        type: 'object',
+        required: ['formId', 'controlId'],
+        additionalProperties: false,
+        properties: {
+            formId: { type: 'string', minLength: 1, maxLength: 256 },
+            controlId: { type: 'string', minLength: 1, maxLength: 256 },
+            subject: { type: 'object' },
+        },
+    };
+    const surfaceIdentitySchema = {
+        type: 'object',
+        required: ['surfaceId', 'kind'],
+        additionalProperties: false,
+        properties: {
+            surfaceId: { type: 'string', minLength: 1, maxLength: 256 },
+            kind: { type: 'string', enum: ['table', 'list', 'report', 'custom'] },
+            subject: { type: 'object' },
+        },
+    };
+    return [
+        readTool(`${prefix}list_form_controls`, 'List the controls currently mounted in SMRT forms.', {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                formId: { type: 'string', minLength: 1, maxLength: 256 },
+            },
+        }, (args) => executeSafely(() => {
+            assertRequestSize(args);
+            const input = record(args);
+            const formId = optionalIdentifier(input.formId, 'formId');
+            return controlRegistry.list(formId).map(sanitizeControl);
+        })),
+        readTool(`${prefix}inspect_form_control`, 'Inspect one currently mounted SMRT form control.', {
+            type: 'object',
+            required: ['identity'],
+            additionalProperties: false,
+            properties: { identity: identitySchema },
+        }, (args) => executeSafely(() => {
+            assertRequestSize(args);
+            const input = record(args);
+            const snapshot = controlRegistry.get(controlIdentity(input.identity));
+            if (!snapshot)
+                throw publicError('not_found');
+            return sanitizeControl(snapshot);
+        })),
+        {
+            name: `${prefix}execute_form_control`,
+            description: 'Execute an allowed command on a mounted SMRT form control. Agent mutations are consent-gated.',
+            inputSchema: {
+                type: 'object',
+                required: ['action', 'identity'],
+                additionalProperties: false,
+                properties: {
+                    action: { type: 'string', enum: [...CONTROL_ACTIONS] },
+                    identity: identitySchema,
+                    value: {},
+                    durationMs: { type: 'number', minimum: 0, maximum: 60_000 },
+                },
+            },
+            annotations: { readOnlyHint: false, untrustedContentHint: true },
+            execute: (args) => executeSafely(async () => {
+                assertRequestSize(args);
+                const input = record(args);
+                if ('confirmed' in input)
+                    throw publicError('invalid_request', 'confirmed');
+                if (!CONTROL_ACTIONS.has(input.action)) {
+                    throw publicError('invalid_request', 'action');
+                }
+                const action = input.action;
+                const identity = controlIdentity(input.identity);
+                let command;
+                if (action === 'stage') {
+                    if (!('value' in input))
+                        throw publicError('invalid_request', 'value');
+                    command = { action, identity, value: input.value };
+                }
+                else if (action === 'apply') {
+                    command =
+                        'value' in input
+                            ? { action, identity, value: input.value }
+                            : { action, identity };
+                }
+                else if (action === 'highlight') {
+                    if (input.durationMs !== undefined &&
+                        (typeof input.durationMs !== 'number' ||
+                            input.durationMs < 0 ||
+                            input.durationMs > 60_000)) {
+                        throw publicError('invalid_request', 'durationMs');
+                    }
+                    command = { action, identity, durationMs: input.durationMs };
+                }
+                else {
+                    command = { action, identity };
+                }
+                const result = await controlRegistry.execute(command, {
+                    source: 'agent',
+                });
+                const reason = result.reason
+                    ? PUBLIC_CONTROL_RESULT_REASONS.has(result.reason)
+                        ? result.reason
+                        : 'execution_failed'
+                    : undefined;
+                return {
+                    ...result,
+                    ...(reason ? { reason } : { reason: undefined }),
+                    ...(result.snapshot
+                        ? { snapshot: sanitizeControl(result.snapshot) }
+                        : {}),
+                };
+            }),
+        },
+        readTool(`${prefix}list_data_surfaces`, 'List the data surfaces currently mounted in this SMRT Provider.', { type: 'object', additionalProperties: false, properties: {} }, (args) => executeSafely(() => {
+            assertRequestSize(args);
+            record(args);
+            return dataSurfaceRegistry.list().map(visibleDescriptor);
+        })),
+        readTool(`${prefix}inspect_data_surface`, 'Inspect one currently mounted SMRT data surface.', {
+            type: 'object',
+            required: ['identity'],
+            additionalProperties: false,
+            properties: { identity: surfaceIdentitySchema },
+        }, (args) => executeSafely(() => {
+            assertRequestSize(args);
+            const input = record(args);
+            const snapshot = dataSurfaceRegistry.inspect(dataSurfaceIdentity(input.identity));
+            if (!snapshot)
+                throw publicError('not_found');
+            return visibleSnapshot(snapshot);
+        })),
+        {
+            name: `${prefix}execute_data_surface_control`,
+            description: 'Execute a bounded visible-state command on a mounted SMRT data surface.',
+            inputSchema: {
+                type: 'object',
+                required: [
+                    'version',
+                    'commandId',
+                    'identity',
+                    'expectedRevision',
+                    'controlId',
+                ],
+                additionalProperties: false,
+                properties: {
+                    version: { type: 'number', const: 1 },
+                    commandId: { type: 'string', minLength: 1, maxLength: 256 },
+                    identity: surfaceIdentitySchema,
+                    expectedRevision: { type: 'number', minimum: 0 },
+                    controlId: { type: 'string', minLength: 1, maxLength: 256 },
+                    payload: {},
+                },
+            },
+            annotations: { readOnlyHint: false, untrustedContentHint: true },
+            execute: (args) => executeSafely(async () => {
+                assertRequestSize(args);
+                const input = record(args);
+                if (input.version !== 1)
+                    throw publicError('invalid_request', 'version');
+                if (typeof input.expectedRevision !== 'number' ||
+                    !Number.isSafeInteger(input.expectedRevision) ||
+                    input.expectedRevision < 0) {
+                    throw publicError('invalid_request', 'expectedRevision');
+                }
+                const command = {
+                    version: 1,
+                    commandId: requiredIdentifier(input.commandId, 'commandId'),
+                    identity: dataSurfaceIdentity(input.identity),
+                    expectedRevision: input.expectedRevision,
+                    controlId: requiredIdentifier(input.controlId, 'controlId'),
+                    ...('payload' in input ? { payload: input.payload } : {}),
+                };
+                const result = await dataSurfaceRegistry.execute(command);
+                return result.snapshot
+                    ? { ...result, snapshot: visibleSnapshot(result.snapshot) }
+                    : result;
+            }),
+        },
+    ];
+}
+/** Register the fixed browser-native adapter over mounted UI registries. */
+export function registerWebMcpUiTools(options) {
+    const prefix = options.prefix ?? DEFAULT_PREFIX;
+    if (!PREFIX_PATTERN.test(prefix)) {
+        throw new TypeError('Invalid WebMCP UI tool prefix');
+    }
+    const documentLike = options.document ??
+        globalThis
+            .document;
+    const modelContext = documentLike?.modelContext;
+    if (!modelContext || typeof modelContext.registerTool !== 'function') {
+        return () => { };
+    }
+    let locks = documentLocks.get(documentLike);
+    if (!locks) {
+        locks = new Set();
+        documentLocks.set(documentLike, locks);
+    }
+    if (locks.has(prefix)) {
+        throw new Error(`WebMCP UI prefix is already registered: ${prefix}`);
+    }
+    locks.add(prefix);
+    const controller = new AbortController();
+    let disposed = false;
+    try {
+        for (const tool of tools(prefix, options.controlRegistry, options.dataSurfaceRegistry)) {
+            modelContext.registerTool(tool, { signal: controller.signal });
+        }
+    }
+    catch (error) {
+        controller.abort();
+        locks.delete(prefix);
+        throw error;
+    }
+    return () => {
+        if (disposed)
+            return;
+        disposed = true;
+        controller.abort();
+        locks.delete(prefix);
+    };
+}

package/dist/web/webmcp.d.ts

@@ -14,7 +14,7 @@ declare global {
     registerTool(
       tool: WebMcpToolSpec,
       options?: { signal?: AbortSignal },
-    ): void;
+    ): Promise<void>;
   }
 }
 

package/dist/web/webmcp.svelte.d.ts

@@ -5,6 +5,9 @@ export interface WebMcpToolSpec {
     inputSchema: Record<string, unknown>;
     annotations?: {
         readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
         untrustedContentHint?: boolean;
     };
     execute: (args: Record<string, unknown>) => string | Promise<string>;
@@ -16,7 +19,7 @@ declare global {
     interface WebMcpModelContext {
         registerTool(tool: WebMcpToolSpec, options?: {
             signal?: AbortSignal;
-        }): void;
+        }): Promise<void>;
     }
 }
 /**

package/dist/web/webmcp.svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webmcp.svelte.d.ts","sourceRoot":"","sources":["../../src/web/webmcp.svelte.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,WAAW,CAAC,EAAE;QACZ,YAAY,CAAC,EAAE,OAAO,CAAC;QACvB,oBAAoB,CAAC,EAAE,OAAO,CAAC;KAChC,CAAC;IACF,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACtE;AAID,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,QAAQ;QAChB,YAAY,CAAC,EAAE,kBAAkB,CAAC;KACnC;IAED,UAAU,kBAAkB;QAC1B,YAAY,CACV,IAAI,EAAE,cAAc,EACpB,OAAO,CAAC,EAAE;YAAE,MAAM,CAAC,EAAE,WAAW,CAAA;SAAE,GACjC,IAAI,CAAC;KACT;CACF;AAYD;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,cAAc,GAAG,IAAI,GAAG,SAAS,GAC/C,IAAI,CAYN"}
+{"version":3,"file":"webmcp.svelte.d.ts","sourceRoot":"","sources":["../../src/web/webmcp.svelte.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,WAAW,CAAC,EAAE;QACZ,YAAY,CAAC,EAAE,OAAO,CAAC;QACvB,eAAe,CAAC,EAAE,OAAO,CAAC;QAC1B,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,oBAAoB,CAAC,EAAE,OAAO,CAAC;KAChC,CAAC;IACF,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACtE;AAID,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,QAAQ;QAChB,YAAY,CAAC,EAAE,kBAAkB,CAAC;KACnC;IAED,UAAU,kBAAkB;QAC1B,YAAY,CACV,IAAI,EAAE,cAAc,EACpB,OAAO,CAAC,EAAE;YAAE,MAAM,CAAC,EAAE,WAAW,CAAA;SAAE,GACjC,OAAO,CAAC,IAAI,CAAC,CAAC;KAClB;CACF;AAYD;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,cAAc,GAAG,IAAI,GAAG,SAAS,GAC/C,IAAI,CAYN"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happyvertical/smrt-svelte",
-  "version": "0.43.2",
+  "version": "0.43.4",
   "description": "Svelte 5 components for SMRT user management - auth, users, tenants, roles, permissions, groups",
   "type": "module",
   "smrtRawPrimitives": "strict",
@@ -123,10 +123,10 @@
     "@tanstack/db": "^0.6.14",
     "@tanstack/svelte-db": "^0.1.91",
     "esm-env": "^1.2.2",
-    "@happyvertical/smrt-types": "0.43.2",
-    "@happyvertical/smrt-ui": "0.43.2",
-    "@happyvertical/smrt-languages": "0.43.2",
-    "@happyvertical/smrt-web": "0.43.2"
+    "@happyvertical/smrt-web": "0.43.4",
+    "@happyvertical/smrt-ui": "0.43.4",
+    "@happyvertical/smrt-types": "0.43.4",
+    "@happyvertical/smrt-languages": "0.43.4"
   },
   "peerDependencies": {
     "@huggingface/transformers": ">=3.8.1",