@bevel-software/platform-mcp-core 0.8.0

package/dist/code-mode-names.d.ts

@@ -0,0 +1,40 @@
+import type { Tool } from '@utcp/sdk';
+import type { CodeModeUtcpClient } from '@utcp/code-mode';
+/**
+ * Pure helpers for mapping UTCP tool names to their code-mode (TypeScript)
+ * accessible form. Kept Mastra-free so the agent's Mastra tools
+ * (`code-mode.tool.ts`), the hosted MCP proxy and the local MCP server can all
+ * share them.
+ */
+export declare function sanitizeIdentifier(name: string): string;
+/** `MANUAL.tool` → the `manual.tool` form the code-mode runtime exposes. */
+export declare function utcpNameToTsInterfaceName(utcpName: string): string;
+/**
+ * The TYPED half of the ambiguity contract: callers that contain ambiguity
+ * per-name while letting real failures (an outage, a broken repository)
+ * fail the call need something sturdier to branch on than the message text
+ * of a bare Error thrown in another package.
+ */
+export declare class AmbiguousToolNameError extends Error {
+    constructor(message: string);
+}
+/**
+ * Resolve a tool by its raw UTCP name or its sanitized TS-accessible name.
+ * Throws when the sanitized name is claimed by more than one tool (an exact
+ * UTCP name always wins and can't be ambiguous).
+ */
+export declare function findToolByName(client: CodeModeUtcpClient, name: string): Promise<{
+    tool: Tool;
+    utcpName: string;
+} | null>;
+/**
+ * Resolve a batch of names against ONE catalog fetch (`tools_info` takes a
+ * list, and a per-name `getTools()` re-fetch scales with the list). Names that
+ * resolve are in the map; missing ones are simply absent; an ambiguous
+ * sanitized name throws, as in {@link findToolByName}.
+ */
+export declare function findToolsByNames(client: CodeModeUtcpClient, names: string[]): Promise<Map<string, {
+    tool: Tool;
+    utcpName: string;
+}>>;
+//# sourceMappingURL=code-mode-names.d.ts.map

package/dist/code-mode-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-mode-names.d.ts","sourceRoot":"","sources":["../src/code-mode-names.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAE1D;;;;;GAKG;AAEH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,4EAA4E;AAC5E,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMlE;AAkCD;;;;;GAKG;AACH,qBAAa,sBAAuB,SAAQ,KAAK;gBACnC,OAAO,EAAE,MAAM;CAI5B;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAIlD;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,MAAM,EAAE,GACd,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAexD"}

package/dist/code-mode-names.js

@@ -0,0 +1,93 @@
+/**
+ * Pure helpers for mapping UTCP tool names to their code-mode (TypeScript)
+ * accessible form. Kept Mastra-free so the agent's Mastra tools
+ * (`code-mode.tool.ts`), the hosted MCP proxy and the local MCP server can all
+ * share them.
+ */
+export function sanitizeIdentifier(name) {
+    return name.replace(/[^a-zA-Z0-9_]/g, '_').replace(/^[0-9]/, '_$&');
+}
+/** `MANUAL.tool` → the `manual.tool` form the code-mode runtime exposes. */
+export function utcpNameToTsInterfaceName(utcpName) {
+    if (utcpName.includes('.')) {
+        const [manualName, ...toolParts] = utcpName.split('.');
+        return `${sanitizeIdentifier(manualName)}.${toolParts.map(sanitizeIdentifier).join('_')}`;
+    }
+    return sanitizeIdentifier(utcpName);
+}
+/**
+ * Sanitized TS name → every UTCP tool that claims it, from ONE catalog fetch.
+ * Collisions are kept, not collapsed: sanitization is lossy (`a-b` and `a_b`
+ * both become `a_b`), and a lookup that silently picked one would describe —
+ * or dispatch — the wrong tool.
+ */
+async function tsNameIndex(client) {
+    const index = new Map();
+    for (const tool of await client.config.tool_repository.getTools()) {
+        const tsName = utcpNameToTsInterfaceName(tool.name);
+        const bucket = index.get(tsName);
+        if (bucket)
+            bucket.push(tool);
+        else
+            index.set(tsName, [tool]);
+    }
+    return index;
+}
+function resolveSanitized(index, name) {
+    const bucket = index.get(name);
+    if (!bucket || bucket.length === 0)
+        return null;
+    if (bucket.length > 1) {
+        throw new AmbiguousToolNameError(`Tool name "${name}" is ambiguous: ${bucket.map((t) => `"${t.name}"`).join(', ')} ` +
+            'all sanitize to it. Call the tool by its exact UTCP name instead.');
+    }
+    return { tool: bucket[0], utcpName: bucket[0].name };
+}
+/**
+ * The TYPED half of the ambiguity contract: callers that contain ambiguity
+ * per-name while letting real failures (an outage, a broken repository)
+ * fail the call need something sturdier to branch on than the message text
+ * of a bare Error thrown in another package.
+ */
+export class AmbiguousToolNameError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AmbiguousToolNameError';
+    }
+}
+/**
+ * Resolve a tool by its raw UTCP name or its sanitized TS-accessible name.
+ * Throws when the sanitized name is claimed by more than one tool (an exact
+ * UTCP name always wins and can't be ambiguous).
+ */
+export async function findToolByName(client, name) {
+    const direct = await client.config.tool_repository.getTool(name);
+    if (direct)
+        return { tool: direct, utcpName: name };
+    return resolveSanitized(await tsNameIndex(client), name);
+}
+/**
+ * Resolve a batch of names against ONE catalog fetch (`tools_info` takes a
+ * list, and a per-name `getTools()` re-fetch scales with the list). Names that
+ * resolve are in the map; missing ones are simply absent; an ambiguous
+ * sanitized name throws, as in {@link findToolByName}.
+ */
+export async function findToolsByNames(client, names) {
+    const out = new Map();
+    let index;
+    for (const name of names) {
+        if (out.has(name))
+            continue;
+        const direct = await client.config.tool_repository.getTool(name);
+        if (direct) {
+            out.set(name, { tool: direct, utcpName: name });
+            continue;
+        }
+        index ??= await tsNameIndex(client);
+        const resolved = resolveSanitized(index, name);
+        if (resolved)
+            out.set(name, resolved);
+    }
+    return out;
+}
+//# sourceMappingURL=code-mode-names.js.map

package/dist/code-mode-names.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-mode-names.js","sourceRoot":"","sources":["../src/code-mode-names.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AAEH,MAAM,UAAU,kBAAkB,CAAC,IAAY;IAC7C,OAAO,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;AACtE,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,yBAAyB,CAAC,QAAgB;IACxD,IAAI,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QAC3B,MAAM,CAAC,UAAU,EAAE,GAAG,SAAS,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACvD,OAAO,GAAG,kBAAkB,CAAC,UAAW,CAAC,IAAI,SAAS,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;IAC7F,CAAC;IACD,OAAO,kBAAkB,CAAC,QAAQ,CAAC,CAAC;AACtC,CAAC;AAED;;;;;GAKG;AACH,KAAK,UAAU,WAAW,CAAC,MAA0B;IACnD,MAAM,KAAK,GAAG,IAAI,GAAG,EAAkB,CAAC;IACxC,KAAK,MAAM,IAAI,IAAI,MAAM,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,QAAQ,EAAE,EAAE,CAAC;QAClE,MAAM,MAAM,GAAG,yBAAyB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpD,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACjC,IAAI,MAAM;YAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;;YACzB,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;IACjC,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,gBAAgB,CACvB,KAA0B,EAC1B,IAAY;IAEZ,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC/B,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAChD,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,sBAAsB,CAC9B,cAAc,IAAI,mBAAmB,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG;YACjF,mEAAmE,CACtE,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAE,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAE,CAAC,IAAI,EAAE,CAAC;AACzD,CAAC;AAED;;;;;GAKG;AACH,MAAM,OAAO,sBAAuB,SAAQ,KAAK;IAC/C,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,wBAAwB,CAAC;IACvC,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,MAA0B,EAC1B,IAAY;IAEZ,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACjE,IAAI,MAAM;QAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;IACpD,OAAO,gBAAgB,CAAC,MAAM,WAAW,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC;AAC3D,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,MAA0B,EAC1B,KAAe;IAEf,MAAM,GAAG,GAAG,IAAI,GAAG,EAA4C,CAAC;IAChE,IAAI,KAAsC,CAAC;IAC3C,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,SAAS;QAC5B,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACjE,IAAI,MAAM,EAAE,CAAC;YACX,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;YAChD,SAAS;QACX,CAAC;QACD,KAAK,KAAK,MAAM,WAAW,CAAC,MAAM,CAAC,CAAC;QACpC,MAAM,QAAQ,GAAG,gBAAgB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAC/C,IAAI,QAAQ;YAAE,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IACxC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/dispatch.d.ts

@@ -0,0 +1,44 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { CodeModeUtcpClient } from '@utcp/code-mode';
+import type { CallTemplate } from '@utcp/sdk';
+import type { ProxiedTool } from './proxied-tool.js';
+/**
+ * Register one manual on a client, reduced to a verdict.
+ *
+ * Deliberately NOT a loop over every manual: the two surfaces disagree about
+ * what a failure means. The hosted proxy memoizes per (user, manual) so a
+ * broken credential doesn't re-dial its provider on every session rebuild; the
+ * local server has one user and one process and just logs. Sharing the
+ * per-manual mechanics without sharing the retry policy keeps both honest.
+ *
+ * Never throws: a registration failure is a runtime problem (network, dead
+ * credential), not a schema one — the templates were validated before they got
+ * here — so it comes back as `{ ok: false }` for the caller to police.
+ */
+export declare function registerManual(client: CodeModeUtcpClient, manual: CallTemplate): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
+/**
+ * Run one tool call through `callToolStreaming` with a one-chunk lookahead:
+ * every chunk except the last becomes a progress notification, the last is the
+ * result.
+ *
+ * Dispatch always uses `callToolStreaming`, which is uniform across tool kinds:
+ * a plain `http` tool yields exactly one chunk (its final result, emitted as
+ * the tool result with no progress), while a `streamable_http` tool yields many.
+ * Because of that, adding — or later upgrading a tool to streaming — never
+ * touches this function.
+ *
+ * Continuity is the caller's: a tool that supports it (e.g. `ask`) returns its
+ * `sessionId` in the result verbatim, and the caller echoes it back per the
+ * tool's own schema — nothing here rewrites args. Args pass through to UTCP
+ * verbatim; each communication protocol does its own serialization (http reads
+ * the template's `body_field` out of the args, mcp forwards them untouched as
+ * MCP `arguments`), and the advertised schema is the tool's UTCP `inputs`
+ * verbatim too, so any reshaping here would be wrong for at least one protocol.
+ */
+export declare function dispatchToolCall(client: CodeModeUtcpClient, tool: ProxiedTool, args: Record<string, unknown>, onProgress?: (progress: number, message: string) => Promise<void>): Promise<CallToolResult>;
+//# sourceMappingURL=dispatch.d.ts.map

package/dist/dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../src/dispatch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD;;;;;;;;;;;;GAYG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,kBAAkB,EAC1B,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAWtD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAChE,OAAO,CAAC,cAAc,CAAC,CA4BzB"}

package/dist/dispatch.js

@@ -0,0 +1,72 @@
+import { toCallToolResult, toolError, describeToolFailure, renderProgress } from './results.js';
+/**
+ * Register one manual on a client, reduced to a verdict.
+ *
+ * Deliberately NOT a loop over every manual: the two surfaces disagree about
+ * what a failure means. The hosted proxy memoizes per (user, manual) so a
+ * broken credential doesn't re-dial its provider on every session rebuild; the
+ * local server has one user and one process and just logs. Sharing the
+ * per-manual mechanics without sharing the retry policy keeps both honest.
+ *
+ * Never throws: a registration failure is a runtime problem (network, dead
+ * credential), not a schema one — the templates were validated before they got
+ * here — so it comes back as `{ ok: false }` for the caller to police.
+ */
+export async function registerManual(client, manual) {
+    try {
+        const result = await client.registerManual(manual);
+        if (result && result.success === false) {
+            const errors = Array.isArray(result.errors) ? result.errors.join('; ') : 'unknown error';
+            return { ok: false, error: errors };
+        }
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * Run one tool call through `callToolStreaming` with a one-chunk lookahead:
+ * every chunk except the last becomes a progress notification, the last is the
+ * result.
+ *
+ * Dispatch always uses `callToolStreaming`, which is uniform across tool kinds:
+ * a plain `http` tool yields exactly one chunk (its final result, emitted as
+ * the tool result with no progress), while a `streamable_http` tool yields many.
+ * Because of that, adding — or later upgrading a tool to streaming — never
+ * touches this function.
+ *
+ * Continuity is the caller's: a tool that supports it (e.g. `ask`) returns its
+ * `sessionId` in the result verbatim, and the caller echoes it back per the
+ * tool's own schema — nothing here rewrites args. Args pass through to UTCP
+ * verbatim; each communication protocol does its own serialization (http reads
+ * the template's `body_field` out of the args, mcp forwards them untouched as
+ * MCP `arguments`), and the advertised schema is the tool's UTCP `inputs`
+ * verbatim too, so any reshaping here would be wrong for at least one protocol.
+ */
+export async function dispatchToolCall(client, tool, args, onProgress) {
+    let prev;
+    let hasPrev = false;
+    let progress = 0;
+    try {
+        for await (const chunk of client.callToolStreaming(tool.utcpName, args)) {
+            if (hasPrev && onProgress) {
+                progress += 1;
+                await onProgress(progress, renderProgress(prev)).catch((err) => console.warn('[mcp] progress notification failed:', err));
+            }
+            prev = chunk;
+            hasPrev = true;
+        }
+    }
+    catch (err) {
+        return toolError(`The "${tool.mcpName}" tool failed: ${describeToolFailure(err)}`);
+    }
+    // A stream that closes without ever yielding is a transport fault, not an
+    // empty result — every tool kind yields at least its final value (see above).
+    // Say so, instead of serializing the never-assigned `prev` into a "null".
+    if (!hasPrev) {
+        return toolError(`The "${tool.mcpName}" tool produced no output: its stream ended without a result.`);
+    }
+    return toCallToolResult(prev);
+}
+//# sourceMappingURL=dispatch.js.map

package/dist/dispatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.js","sourceRoot":"","sources":["../src/dispatch.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEhG;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,MAA0B,EAC1B,MAAoB;IAEpB,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;QACnD,IAAI,MAAM,IAAI,MAAM,CAAC,OAAO,KAAK,KAAK,EAAE,CAAC;YACvC,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC;YACzF,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QACtC,CAAC;QACD,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC;IACtB,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;IAChF,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,MAA0B,EAC1B,IAAiB,EACjB,IAA6B,EAC7B,UAAiE;IAEjE,IAAI,IAAa,CAAC;IAClB,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,IAAI,QAAQ,GAAG,CAAC,CAAC;IAEjB,IAAI,CAAC;QACH,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAM,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,EAAE,CAAC;YACxE,IAAI,OAAO,IAAI,UAAU,EAAE,CAAC;gBAC1B,QAAQ,IAAI,CAAC,CAAC;gBACd,MAAM,UAAU,CAAC,QAAQ,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAC7D,OAAO,CAAC,IAAI,CAAC,qCAAqC,EAAE,GAAG,CAAC,CACzD,CAAC;YACJ,CAAC;YACD,IAAI,GAAG,KAAK,CAAC;YACb,OAAO,GAAG,IAAI,CAAC;QACjB,CAAC;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,SAAS,CAAC,QAAQ,IAAI,CAAC,OAAO,kBAAkB,mBAAmB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACrF,CAAC;IAED,0EAA0E;IAC1E,8EAA8E;IAC9E,0EAA0E;IAC1E,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,SAAS,CAAC,QAAQ,IAAI,CAAC,OAAO,+DAA+D,CAAC,CAAC;IACxG,CAAC;IAED,OAAO,gBAAgB,CAAC,IAAI,CAAC,CAAC;AAChC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @bevel-software/platform-mcp-core — the transport-agnostic half of Bevel's
+ * MCP surface.
+ *
+ * Two surfaces re-expose the same UTCP tool catalog over MCP and differ only in
+ * where they run and how they reach it:
+ *
+ *   - the HOSTED proxy (`platform-core-backend`) registers the KB manual over
+ *     loopback plus each `.tool` the caller can read, resolves `${VAR}` from
+ *     the Secrets Vault, and speaks streamable HTTP;
+ *   - the LOCAL server (`@bevel-software/hexis-mcp`) registers the deployment's
+ *     own MCP endpoint as one `mcp` manual plus the `remote: false` manuals the
+ *     hosted endpoint cannot serve, resolves `${VAR}` from the process env, and
+ *     speaks stdio.
+ *
+ * Everything between "a UTCP client with manuals registered" and "an MCP result"
+ * is identical, and lives here: name flattening, the tool-name/schema guards
+ * that stop one bad tool blanking a client's whole toolset, streaming dispatch,
+ * and the code-mode meta-tools.
+ *
+ * What is NOT here, on purpose: manual DISCOVERY (who may see which manual is
+ * an access-control question the hosted REST surface answers), credential
+ * resolution (a vault loader server-side, `process.env` locally), and retry
+ * policy (see `registerManual`).
+ */
+export { type ProxiedTool, toListedTool, sanitizeInputSchema, flattenManualTool, flattenDiscoveredTool, } from './proxied-tool.js';
+export { describeToolFailure, toCallToolResult, renderProgress, toolError, needsAuthorizationResult, } from './results.js';
+export { CODE_MODE_META_TOOLS, META_TOOL_NAMES, CALL_TOOL_CHAIN_MAX_OUTPUT, type SpillPort, dispatchMetaTool, } from './meta-tools.js';
+export { registerManual, dispatchToolCall } from './dispatch.js';
+export { type SkillSummary, type LoadedSkill, skillPromptText, } from './skills.js';
+export { utcpNamespacePrefix, utcpNamespacedKey, seedBevelHostedManualVars, } from './utcp-namespace.js';
+export { sanitizeIdentifier, utcpNameToTsInterfaceName, findToolByName, findToolsByNames, AmbiguousToolNameError, } from './code-mode-names.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EACL,KAAK,WAAW,EAChB,YAAY,EACZ,mBAAmB,EACnB,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,cAAc,EACd,SAAS,EACT,wBAAwB,GACzB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,0BAA0B,EAC1B,KAAK,SAAS,EACd,gBAAgB,GACjB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjE,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,eAAe,GAChB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,yBAAyB,GAC1B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,kBAAkB,EAClB,yBAAyB,EACzB,cAAc,EACd,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,33 @@
+/**
+ * @bevel-software/platform-mcp-core — the transport-agnostic half of Bevel's
+ * MCP surface.
+ *
+ * Two surfaces re-expose the same UTCP tool catalog over MCP and differ only in
+ * where they run and how they reach it:
+ *
+ *   - the HOSTED proxy (`platform-core-backend`) registers the KB manual over
+ *     loopback plus each `.tool` the caller can read, resolves `${VAR}` from
+ *     the Secrets Vault, and speaks streamable HTTP;
+ *   - the LOCAL server (`@bevel-software/hexis-mcp`) registers the deployment's
+ *     own MCP endpoint as one `mcp` manual plus the `remote: false` manuals the
+ *     hosted endpoint cannot serve, resolves `${VAR}` from the process env, and
+ *     speaks stdio.
+ *
+ * Everything between "a UTCP client with manuals registered" and "an MCP result"
+ * is identical, and lives here: name flattening, the tool-name/schema guards
+ * that stop one bad tool blanking a client's whole toolset, streaming dispatch,
+ * and the code-mode meta-tools.
+ *
+ * What is NOT here, on purpose: manual DISCOVERY (who may see which manual is
+ * an access-control question the hosted REST surface answers), credential
+ * resolution (a vault loader server-side, `process.env` locally), and retry
+ * policy (see `registerManual`).
+ */
+export { toListedTool, sanitizeInputSchema, flattenManualTool, flattenDiscoveredTool, } from './proxied-tool.js';
+export { describeToolFailure, toCallToolResult, renderProgress, toolError, needsAuthorizationResult, } from './results.js';
+export { CODE_MODE_META_TOOLS, META_TOOL_NAMES, CALL_TOOL_CHAIN_MAX_OUTPUT, dispatchMetaTool, } from './meta-tools.js';
+export { registerManual, dispatchToolCall } from './dispatch.js';
+export { skillPromptText, } from './skills.js';
+export { utcpNamespacePrefix, utcpNamespacedKey, seedBevelHostedManualVars, } from './utcp-namespace.js';
+export { sanitizeIdentifier, utcpNameToTsInterfaceName, findToolByName, findToolsByNames, AmbiguousToolNameError, } from './code-mode-names.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAEL,YAAY,EACZ,mBAAmB,EACnB,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,cAAc,EACd,SAAS,EACT,wBAAwB,GACzB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,0BAA0B,EAE1B,gBAAgB,GACjB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjE,OAAO,EAGL,eAAe,GAChB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,yBAAyB,GAC1B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,kBAAkB,EAClB,yBAAyB,EACzB,cAAc,EACd,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,sBAAsB,CAAC"}

package/dist/meta-tools.d.ts

@@ -0,0 +1,27 @@
+import type { Tool as McpTool, CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { CodeModeUtcpClient } from '@utcp/code-mode';
+export declare const CODE_MODE_META_TOOLS: McpTool[];
+export declare const META_TOOL_NAMES: ReadonlySet<string>;
+/** Default cap on a `call_tool_chain` result's stringified size before it spills. */
+export declare const CALL_TOOL_CHAIN_MAX_OUTPUT = 200000;
+/**
+ * Where an oversized `call_tool_chain` payload goes. The hosted proxy hands in
+ * the shared workspace spill store, whose refs `read_file` can read back. A
+ * surface with nowhere to put it (the local server has no server-side store of
+ * its own) passes nothing and gets a truncation notice instead — the caller is
+ * told to narrow the chain rather than handed a ref that resolves nowhere.
+ */
+export interface SpillPort {
+    write(json: string): Promise<{
+        ref: string;
+        bytes: number;
+    }>;
+}
+/**
+ * Handle a code-mode meta-tool. `list_tools`/`tools_info` reflect on the
+ * client's discovered catalog; `call_tool_chain` runs the caller's JavaScript in
+ * the client's isolated-vm, where every registered tool is reachable as
+ * `<manual>.tool(...)`.
+ */
+export declare function dispatchMetaTool(client: CodeModeUtcpClient, name: string, args: Record<string, unknown>, spill?: SpillPort): Promise<CallToolResult>;
+//# sourceMappingURL=meta-tools.d.ts.map

package/dist/meta-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta-tools.d.ts","sourceRoot":"","sources":["../src/meta-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,IAAI,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAC1F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AA4B1D,eAAO,MAAM,oBAAoB,EAAE,OAAO,EAkCzC,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,MAAM,CAAoD,CAAC;AAErG,qFAAqF;AACrF,eAAO,MAAM,0BAA0B,SAAU,CAAC;AAgBlD;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC9D;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,KAAK,CAAC,EAAE,SAAS,GAChB,OAAO,CAAC,cAAc,CAAC,CA+EzB"}

package/dist/meta-tools.js

@@ -0,0 +1,161 @@
+import { utcpNameToTsInterfaceName, findToolsByNames } from './code-mode-names.js';
+import { toCallToolResult, toolError, describeToolFailure } from './results.js';
+/**
+ * Code-mode meta-tools exposed ALONGSIDE the direct tools. They let an external
+ * agent batch many Bevel calls into one isolated-vm run (`call_tool_chain`)
+ * instead of one MCP round-trip per call — the same efficiency our own agent
+ * gets. `call_tool_chain`'s description carries the code-mode protocol (there is
+ * no system prompt over MCP), so the client learns the convention from the tool
+ * itself; `list_tools`/`tools_info` are how it discovers what to call.
+ *
+ * Security is identical to the direct surface: the chain runs in an isolated-vm
+ * but calls tools with the CALLER's credentials against the external catalog —
+ * internal-only tools aren't in that catalog, so a chain can't reach them either.
+ *
+ * These three belong to whichever client holds the registry. A surface that
+ * registers ANOTHER Bevel MCP endpoint as one of its manuals therefore has to
+ * drop that endpoint's copies from the passthrough (see {@link META_TOOL_NAMES}):
+ * the remote trio describes the remote registry, and locally they must describe
+ * the merged one.
+ */
+const CALL_TOOL_CHAIN_DESCRIPTION = [
+    'Execute a short JavaScript program with direct access to every registered UTCP tool as a synchronous function. Call tools as `KNOWLEDGE_BASE.<tool>({ body: { ...args } })` with NO `await` (results are already resolved), and `return` the final value. The runtime is plain JavaScript (no type annotations / no TypeScript-only syntax).',
+    'Discover first: `list_tools` lists every tool in callable form (e.g. `KNOWLEDGE_BASE.read_file`); `tools_info` returns their exact argument + return shapes — do not guess. Batch multiple tool calls into one chain to avoid a round-trip per call. The chain runs with your own connection key, so it can only reach the tools you can already call directly.',
+    'Large results: if the combined result+logs exceed `max_output_size` (default 200000 chars) the full JSON is spilled to a shared store and you get back a `__tool_chain_spill__/…` ref instead. Read it with `read_file` (pass that ref as `path` — `branch` is ignored — plus `offset`/`limit` to slice it), or better, re-run a narrower chain that returns only what you need.',
+].join('\n\n');
+export const CODE_MODE_META_TOOLS = [
+    {
+        name: 'list_tools',
+        description: 'List every UTCP tool currently registered, in TypeScript-accessible form (e.g. `KNOWLEDGE_BASE.read_file`) for use inside `call_tool_chain`.',
+        inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    },
+    {
+        name: 'tools_info',
+        description: 'Get full TypeScript interface definitions for named tools (names from `list_tools`). The schemas are the source of truth — do not guess shapes.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                tool_names: { type: 'array', items: { type: 'string' }, minItems: 1, description: 'Tool names to describe.' },
+            },
+            required: ['tool_names'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'call_tool_chain',
+        description: CALL_TOOL_CHAIN_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                code: { type: 'string', minLength: 1, description: 'JavaScript to execute against the registered tools.' },
+                timeout: { type: 'integer', minimum: 1000, maximum: 120000, description: 'Timeout in ms (default 30000).' },
+                max_output_size: { type: 'integer', minimum: 1000, maximum: 1000000, description: 'Max result+logs size in chars before spilling (default 200000, max 1000000).' },
+            },
+            required: ['code'],
+            additionalProperties: false,
+        },
+    },
+];
+export const META_TOOL_NAMES = new Set(CODE_MODE_META_TOOLS.map((t) => t.name));
+/** Default cap on a `call_tool_chain` result's stringified size before it spills. */
+export const CALL_TOOL_CHAIN_MAX_OUTPUT = 200_000;
+/**
+ * UTF-8 byte length without Node's `Buffer` — this module stays free of
+ * runtime-specific globals. Matches `Buffer.byteLength`: a lone surrogate
+ * encodes as the 3-byte replacement character.
+ */
+function utf8ByteLength(s) {
+    let bytes = 0;
+    for (const ch of s) {
+        const cp = ch.codePointAt(0);
+        bytes += cp <= 0x7f ? 1 : cp <= 0x7ff ? 2 : cp <= 0xffff ? 3 : 4;
+    }
+    return bytes;
+}
+/**
+ * Handle a code-mode meta-tool. `list_tools`/`tools_info` reflect on the
+ * client's discovered catalog; `call_tool_chain` runs the caller's JavaScript in
+ * the client's isolated-vm, where every registered tool is reachable as
+ * `<manual>.tool(...)`.
+ */
+export async function dispatchMetaTool(client, name, args, spill) {
+    try {
+        if (name === 'list_tools') {
+            const tools = await client.config.tool_repository.getTools();
+            return toCallToolResult({ tools: tools.map((t) => utcpNameToTsInterfaceName(t.name)) });
+        }
+        if (name === 'tools_info') {
+            // The schema is advisory over a raw JSON-RPC call: a missing array or a
+            // non-string entry must be a named validation error here, not a generic
+            // failure out of a repository lookup it was never valid input for.
+            const rawNames = args.tool_names;
+            // Empty included — the schema says minItems 1, and an empty success
+            // payload for invalid input would read as "no tools exist".
+            if (!Array.isArray(rawNames) || rawNames.length === 0 || rawNames.some((n) => typeof n !== 'string')) {
+                return toolError('The "tools_info" tool requires "tool_names": a non-empty array of tool name strings.');
+            }
+            const names = rawNames;
+            const interfaces = [];
+            const notFound = [];
+            const resolved = await findToolsByNames(client, names);
+            for (const n of names) {
+                const found = resolved.get(n);
+                if (found)
+                    interfaces.push(client.toolToTypeScriptInterface(found.tool));
+                else
+                    notFound.push(n);
+            }
+            return toCallToolResult({ interfaces: interfaces.join('\n\n'), not_found: notFound });
+        }
+        // call_tool_chain
+        // Same advisory-schema rule as above: a missing or non-string `code` must
+        // not silently execute an empty program and report success.
+        const code = args.code;
+        if (typeof code !== 'string' || code.length === 0) {
+            return toolError('The "call_tool_chain" tool requires a non-empty "code" string.');
+        }
+        // Clamp both knobs to their schema bounds — the schema is advisory over a
+        // raw JSON-RPC call, and an unclamped `timeout` would let one chain hold
+        // the isolate far past the documented 120s cap.
+        const timeout = typeof args.timeout === 'number' && Number.isFinite(args.timeout)
+            ? Math.min(120_000, Math.max(1_000, Math.trunc(args.timeout)))
+            : 30_000;
+        // Clamp to [1000, 1_000_000] so a caller can't force oversized inline
+        // output past the spill.
+        const maxOutputSize = typeof args.max_output_size === 'number' && Number.isFinite(args.max_output_size)
+            ? Math.min(1_000_000, Math.max(1_000, Math.trunc(args.max_output_size)))
+            : CALL_TOOL_CHAIN_MAX_OUTPUT;
+        const { result, logs } = await client.callToolChain(code, timeout);
+        // Bound the payload: an external session has no ambient workspace, so an
+        // oversized result spills to the shared store and we return only a ref —
+        // parity with the in-process agent's `call_tool_chain`.
+        if (JSON.stringify({ success: true, result, logs }).length <= maxOutputSize) {
+            return toCallToolResult({ success: true, result, logs });
+        }
+        const fullJson = JSON.stringify({ result, logs }, null, 2);
+        if (!spill) {
+            return toCallToolResult({
+                success: true,
+                truncated: true,
+                // Bytes, not chars: the spill branch reports the store's byte count,
+                // and `result_bytes` must mean one thing across both paths.
+                result_bytes: utf8ByteLength(fullJson),
+                message: `Result+logs payload was ${fullJson.length} characters (exceeded max_output_size of ${maxOutputSize}), ` +
+                    'and this server has no spill store to park it in. Re-run a narrower chain that returns only what you ' +
+                    'need, or raise max_output_size.',
+            });
+        }
+        const { ref, bytes } = await spill.write(fullJson);
+        return toCallToolResult({
+            success: true,
+            truncated: true,
+            result_ref: ref,
+            result_bytes: bytes,
+            message: `Result+logs payload was ${fullJson.length} characters (exceeded max_output_size of ${maxOutputSize}). Full JSON saved to the shared spill store as \`${ref}\`. Read it back with \`read_file\` (pass that ref as \`path\`, \`branch\` ignored, plus \`offset\`/\`limit\` to slice), or re-run a narrower chain that returns only what you need.`,
+        });
+    }
+    catch (err) {
+        return toolError(`The "${name}" tool failed: ${describeToolFailure(err)}`);
+    }
+}
+//# sourceMappingURL=meta-tools.js.map

package/dist/meta-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta-tools.js","sourceRoot":"","sources":["../src/meta-tools.ts"],"names":[],"mappings":"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"}

package/dist/proxied-tool.d.ts

@@ -0,0 +1,49 @@
+import type { Tool as McpTool } from '@modelcontextprotocol/sdk/types.js';
+import type { JsonSchema, Tool as UtcpTool } from '@utcp/sdk';
+/** A tool discovered from a UTCP manual, flattened into what an MCP surface advertises. */
+export interface ProxiedTool {
+    utcpName: string;
+    mcpName: string;
+    description: string;
+    inputSchema: JsonSchema;
+    /** The UTCP manual this tool came from (the `<manual>` in `<manual>.<tool>`),
+     * used to look up the manual's declared per-user credentials before dispatch. */
+    manualName: string;
+}
+/** A discovered tool as an MCP listing entry, or null if its name can't be listed. */
+export declare function toListedTool(tool: ProxiedTool): McpTool | null;
+/**
+ * Make a remote server's JSON Schema safe for the Anthropic tool validator:
+ *  - inline local `$ref` pointers (`#/$defs/...`, `#/definitions/...`) and drop
+ *    the now-unreferenced `$defs`/`definitions` blocks (the API restricts `$ref`
+ *    and MCP clients converting our schemas reject it outright);
+ *  - drop non-standard `format` values (OpenAPI's `int32`/`byte`/… — only the
+ *    JSON-Schema-standard formats above are accepted; `format` is advisory, so
+ *    dropping it doesn't change tool behavior).
+ * Depth-bounded so a recursive schema degrades to a permissive `{}` node instead
+ * of hanging or emitting the unsupported recursion; non-local/external refs
+ * degrade the same way. Exported for direct testing.
+ */
+export declare function sanitizeInputSchema(schema: unknown): unknown;
+/**
+ * Flatten a discovered UTCP tool (`<manual>.<tool>`) into the advertised shape
+ * when MULTIPLE manuals are registered. Tools from `kbManualName` keep their
+ * bare name (so existing agents still call `read_file`); every other manual's
+ * tool is namespaced as `<manual>_<tool>` to guarantee a unique, dot-free MCP
+ * name.
+ *
+ * `kbManualName` is a parameter rather than a constant because the two surfaces
+ * that call this reach the KB through different manuals: the hosted proxy
+ * registers it over loopback, the local server registers the deployment's MCP
+ * endpoint. Whichever manual carries the core toolset is the one whose names
+ * must stay bare.
+ */
+export declare function flattenManualTool(tool: UtcpTool, kbManualName: string): ProxiedTool;
+/**
+ * Flatten one discovered UTCP tool into the advertised shape: strip the
+ * `<manual>.` namespace prefix for the MCP name and keep the UTCP input schema
+ * verbatim (Bevel-hosted HTTP tools show their `{body}` envelope, exactly as in
+ * `call_tool_chain`).
+ */
+export declare function flattenDiscoveredTool(prefix: string, tool: UtcpTool): ProxiedTool;
+//# sourceMappingURL=proxied-tool.d.ts.map

package/dist/proxied-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxied-tool.d.ts","sourceRoot":"","sources":["../src/proxied-tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,KAAK,EAAE,UAAU,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,WAAW,CAAC;AAE9D,2FAA2F;AAC3F,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,UAAU,CAAC;IACxB;qFACiF;IACjF,UAAU,EAAE,MAAM,CAAC;CACpB;AAoBD,sFAAsF;AACtF,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,GAAG,IAAI,CA4C9D;AAgBD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAkD5D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,GAAG,WAAW,CAYnF;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,WAAW,CASjF"}