@bevel-software/platform-mcp-core 0.8.0

package/dist/proxied-tool.js

@@ -0,0 +1,183 @@
+/**
+ * MCP tool-name grammar (also the Anthropic API's), and a length bound. A
+ * remote MCP server can expose a tool whose flattened name breaks this — too
+ * long, or an illegal char the `<manual>_<name>` flattening didn't remove — and
+ * an MCP client (or the model API behind it) rejects the ENTIRE `tools/list`
+ * response when a single entry is non-conforming. That makes EVERY tool vanish
+ * the moment one bad tool from a newly-added server enters the catalog, with no
+ * server-side error (the rejection is the client's). `toListedTool` isolates it
+ * per tool: drop the offender (logged), normalize an odd schema, keep the rest.
+ */
+const MCP_TOOL_NAME_RE = /^[a-zA-Z0-9_-]+$/;
+// The Anthropic API caps a tool name at 128 chars — but the MCP CLIENT (Claude
+// Code, claude.ai) prepends `mcp__<server>__` (≈20+ chars) before sending it,
+// and that FULL name is what the 128 applies to. So budget for the prefix here,
+// or a long `googlecalendar_…` name we pass gets the whole request 400'd. This
+// is deliberately conservative; a dropped tool is logged so it's diagnosable.
+const MCP_TOOL_NAME_MAX = 100;
+/** A discovered tool as an MCP listing entry, or null if its name can't be listed. */
+export function toListedTool(tool) {
+    if (!MCP_TOOL_NAME_RE.test(tool.mcpName) || tool.mcpName.length > MCP_TOOL_NAME_MAX) {
+        console.warn(`[mcp] dropping tool "${tool.mcpName}" from the listing — not a valid MCP tool name ` +
+            `(must match ${MCP_TOOL_NAME_RE} and be ≤${MCP_TOOL_NAME_MAX} chars). ` +
+            'One non-conforming tool would otherwise make the whole toolset disappear on the client.');
+        return null;
+    }
+    // MCP requires an object inputSchema. A remote server's schema that isn't a
+    // plain object (or omits `type: 'object'`) can invalidate the whole response,
+    // so normalize it — keeping any declared properties — rather than pass it
+    // through verbatim.
+    const raw = tool.inputSchema;
+    let inputSchema = raw && typeof raw === 'object' && !Array.isArray(raw)
+        ? { type: 'object', ...raw }
+        : { type: 'object', properties: {} };
+    // Sanitize the schema into what the Anthropic tool validator accepts. A
+    // remote server that emits a construct the validator rejects — Google's
+    // gmail/calendar use `$ref`/`$defs` AND OpenAPI `format` values like
+    // `int32`/`byte` — makes the CLIENT reject the ENTIRE tools/list response,
+    // so all tools vanish and nothing registers. Sanitizing per-tool means one
+    // odd server can't blank the whole toolset.
+    inputSchema = sanitizeInputSchema(inputSchema);
+    // The MCP/Anthropic validator requires the top-level `type` to be exactly
+    // "object" and (for the Anthropic API) `properties` to be present. Force both
+    // so a remote schema that declared something else — or a union like
+    // `["object","null"]` — can't reject the whole tools/list.
+    inputSchema.type = 'object';
+    // An array passes `typeof === 'object'` but is not a property map, so it
+    // must coerce like any other non-object or it poisons the whole listing.
+    if (typeof inputSchema.properties !== 'object' ||
+        inputSchema.properties === null ||
+        Array.isArray(inputSchema.properties)) {
+        inputSchema.properties = {};
+    }
+    return {
+        name: tool.mcpName,
+        description: tool.description,
+        inputSchema: inputSchema,
+    };
+}
+/** JSON-Schema string `format` values the Anthropic tool validator accepts. */
+const SUPPORTED_SCHEMA_FORMATS = new Set([
+    'date-time',
+    'time',
+    'date',
+    'duration',
+    'email',
+    'hostname',
+    'uri',
+    'ipv4',
+    'ipv6',
+    'uuid',
+]);
+/**
+ * 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 function sanitizeInputSchema(schema) {
+    const root = schema;
+    const resolvePointer = (pointer) => {
+        if (!pointer.startsWith('#/'))
+            return undefined;
+        let node = root;
+        for (const partRaw of pointer.slice(2).split('/')) {
+            const part = partRaw.replace(/~1/g, '/').replace(/~0/g, '~');
+            if (!node || typeof node !== 'object')
+                return undefined;
+            node = node[part];
+        }
+        return node;
+    };
+    // `isPropertyMap` marks the value of `properties`/`patternProperties`: its
+    // keys are the tool's OWN field names, not schema keywords, so a field
+    // literally named `format`, `$ref` or `definitions` must survive untouched
+    // (its VALUE is still a schema and is walked as one).
+    const walk = (node, depth, isPropertyMap = false) => {
+        if (depth > 20)
+            return {}; // recursion/cycle guard — permissive fallback
+        if (Array.isArray(node))
+            return node.map((item) => walk(item, depth + 1));
+        if (!node || typeof node !== 'object')
+            return node;
+        const obj = node;
+        if (!isPropertyMap && typeof obj.$ref === 'string') {
+            const target = resolvePointer(obj.$ref);
+            // JSON Schema allows siblings next to $ref; keep them, target wins ties.
+            const siblings = { ...obj };
+            delete siblings.$ref;
+            const resolved = walk(target ?? {}, depth + 1);
+            return resolved && typeof resolved === 'object' && !Array.isArray(resolved)
+                ? { ...siblings, ...resolved }
+                : Object.keys(siblings).length
+                    ? siblings
+                    : resolved ?? {};
+        }
+        const out = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (isPropertyMap) {
+                out[key] = walk(value, depth + 1);
+                continue;
+            }
+            if (key === '$defs' || key === 'definitions')
+                continue; // inlined above
+            // Drop a non-standard `format` (OpenAPI `int32`/`byte`/…) — the validator
+            // only allows the JSON-Schema-standard set; the annotation is non-load-bearing.
+            if (key === 'format' && (typeof value !== 'string' || !SUPPORTED_SCHEMA_FORMATS.has(value))) {
+                continue;
+            }
+            out[key] = walk(value, depth + 1, key === 'properties' || key === 'patternProperties');
+        }
+        return out;
+    };
+    return walk(schema, 0);
+}
+/**
+ * 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 function flattenManualTool(tool, kbManualName) {
+    const dot = tool.name.indexOf('.');
+    const manual = dot >= 0 ? tool.name.slice(0, dot) : '';
+    const bare = dot >= 0 ? tool.name.slice(dot + 1) : tool.name;
+    const mcpName = manual === kbManualName ? bare : tool.name.replace(/\./g, '_');
+    return {
+        utcpName: tool.name,
+        mcpName,
+        description: tool.description,
+        inputSchema: tool.inputs,
+        manualName: manual,
+    };
+}
+/**
+ * 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 function flattenDiscoveredTool(prefix, tool) {
+    return {
+        utcpName: tool.name,
+        mcpName: tool.name.startsWith(prefix) ? tool.name.slice(prefix.length) : tool.name,
+        description: tool.description,
+        inputSchema: tool.inputs,
+        // `prefix` is `<manual>.`; the manual is that without the trailing dot.
+        manualName: prefix.endsWith('.') ? prefix.slice(0, -1) : prefix,
+    };
+}
+//# sourceMappingURL=proxied-tool.js.map

package/dist/proxied-tool.js.map

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

package/dist/results.d.ts

@@ -0,0 +1,19 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Extract a human-meaningful failure message from a tool-call error. UTCP's
+ * HTTP protocol surfaces a non-2xx as an axios-style error whose `.response.data`
+ * is the REST endpoint's JSON body (`{ error: "..." }`). Pull that out so the
+ * MCP caller sees the tool's real message instead of a bare "status code 500".
+ */
+export declare function describeToolFailure(err: unknown): string;
+export declare function toCallToolResult(value: unknown): CallToolResult;
+export declare function renderProgress(chunk: unknown): string;
+export declare function toolError(message: string): CallToolResult;
+/**
+ * The result returned when the caller is missing personal credentials a tool
+ * needs. Marked `isError` so the external agent surfaces it to the person rather
+ * than treating it as tool output. Names the tool, lists the missing items, and
+ * gives the absolute setup-page URL so the person can provide them and retry.
+ */
+export declare function needsAuthorizationResult(toolName: string, missing: string[], connectUrl: string): CallToolResult;
+//# sourceMappingURL=results.d.ts.map

package/dist/results.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"results.d.ts","sourceRoot":"","sources":["../src/results.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEzE;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAgBxD;AAsED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,CAS/D;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAGrD;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,CAEzD;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EAAE,EACjB,UAAU,EAAE,MAAM,GACjB,cAAc,CAMhB"}

package/dist/results.js

@@ -0,0 +1,130 @@
+/**
+ * Extract a human-meaningful failure message from a tool-call error. UTCP's
+ * HTTP protocol surfaces a non-2xx as an axios-style error whose `.response.data`
+ * is the REST endpoint's JSON body (`{ error: "..." }`). Pull that out so the
+ * MCP caller sees the tool's real message instead of a bare "status code 500".
+ */
+export function describeToolFailure(err) {
+    const data = err?.response?.data;
+    if (data && typeof data === 'object') {
+        const inner = data.error;
+        if (typeof inner === 'string' && inner.length > 0)
+            return inner;
+    }
+    if (typeof data === 'string' && data.length > 0)
+        return data;
+    // Total, like `safeJsonText`: a thrown value whose own `toString` throws
+    // (e.g. a null-prototype object) must still come back as a description —
+    // this function runs inside catch paths, where a second throw would turn
+    // a tool failure into a handler failure.
+    try {
+        return err instanceof Error ? err.message : String(err);
+    }
+    catch {
+        return '(indescribable tool failure)';
+    }
+}
+/**
+ * Turn a tool's final value into an MCP result:
+ *  - a tool that already returns the MCP agentic shape (`{ content: [...] }`,
+ *    each entry a real content block) is passed through unchanged;
+ *  - a bare string becomes the text content;
+ *  - anything else is JSON-stringified into one text block.
+ *
+ * Note we do NOT collapse a structured object down to its `text` field: doing
+ * so silently dropped the other fields (e.g. `ask`'s `status` / `sessionId`,
+ * the id a caller must echo back to poll or continue a conversation).
+ * Stringifying the whole object keeps every field, so the caller always sees
+ * the id it is responsible for echoing.
+ *
+ * The passthrough guard checks the entries, not just that `content` is an array:
+ * a domain value that merely happens to carry a `content` array of non-blocks
+ * (e.g. `{ content: ['a', 'b'] }`) is data, not an MCP result, so it falls
+ * through to JSON-stringify and survives intact instead of being emitted as a
+ * malformed result the client can't parse.
+ */
+function isMcpContentBlock(entry) {
+    return typeof entry === 'object' && entry !== null && typeof entry.type === 'string';
+}
+/**
+ * `JSON.stringify`, made total. A tool can legally hand back a value JSON
+ * refuses verbatim — a BigInt or circular object (throws), a bare
+ * function/symbol (stringifies to `undefined`) — and a COMPLETED call must not
+ * turn into a crash at the serialization step. The plain stringify runs first
+ * so well-formed values (shared non-circular references included) come out
+ * exactly as before; only a value it rejects degrades to the replacer pass
+ * (BigInt → decimal string, its own ancestor → '[Circular]'), and a value even
+ * that can't take (e.g. a throwing `toJSON`) falls back to `String(value)`.
+ */
+function safeJsonText(value) {
+    try {
+        const text = JSON.stringify(value);
+        if (text !== undefined)
+            return text;
+    }
+    catch {
+        // BigInt / circular / throwing toJSON — degrade below.
+    }
+    try {
+        // Circularity is being one's own ANCESTOR, not being visited twice: a
+        // shared (diamond) reference is legal JSON and stringify visits it once
+        // per parent, so a grown-only "seen" set would mislabel every sibling
+        // share as circular. The stack tracks only the active descent — the
+        // holder (`this`) of the current key is necessarily the innermost live
+        // ancestor, so popping down to it discards branches already unwound.
+        const ancestors = [];
+        const text = JSON.stringify(value, function (_key, v) {
+            if (typeof v === 'bigint')
+                return v.toString();
+            if (v && typeof v === 'object') {
+                while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this)
+                    ancestors.pop();
+                if (ancestors.includes(v))
+                    return '[Circular]';
+                ancestors.push(v);
+            }
+            return v;
+        });
+        if (text !== undefined)
+            return text;
+    }
+    catch {
+        // fall through to the value's own toString
+    }
+    try {
+        return String(value);
+    }
+    catch {
+        return '(unserializable tool output)';
+    }
+}
+export function toCallToolResult(value) {
+    // Already in MCP agentic format — pass through untouched, but only when every
+    // `content` entry is a real content block (has a string `type`).
+    const content = value?.content;
+    if (value && typeof value === 'object' && Array.isArray(content) && content.every(isMcpContentBlock)) {
+        return value;
+    }
+    const text = typeof value === 'string' ? value : safeJsonText(value ?? null);
+    return { content: [{ type: 'text', text: text || '(tool produced no output)' }] };
+}
+export function renderProgress(chunk) {
+    const s = typeof chunk === 'string' ? chunk : safeJsonText(chunk);
+    return s.length > 500 ? s.slice(0, 497) + '...' : s;
+}
+export function toolError(message) {
+    return { isError: true, content: [{ type: 'text', text: message }] };
+}
+/**
+ * The result returned when the caller is missing personal credentials a tool
+ * needs. Marked `isError` so the external agent surfaces it to the person rather
+ * than treating it as tool output. Names the tool, lists the missing items, and
+ * gives the absolute setup-page URL so the person can provide them and retry.
+ */
+export function needsAuthorizationResult(toolName, missing, connectUrl) {
+    const items = missing.join(', ');
+    const text = `The "${toolName}" tool needs credentials you haven't set up yet: ${items}. ` +
+        `Open ${connectUrl} to connect your accounts and enter your keys, then run the tool again.`;
+    return { isError: true, content: [{ type: 'text', text }] };
+}
+//# sourceMappingURL=results.js.map

package/dist/results.js.map

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

package/dist/skills.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Skills exposed as MCP prompts (slash commands in an MCP client).
+ *
+ * Both surfaces do this the same way and must keep doing it the same way: a
+ * skill's instructions are the prompt body, and the bundled files are named at
+ * the end with the exact call that fetches them. A person running the same
+ * skill through the hosted endpoint and through the local server should get
+ * identical text, so the formatting lives here rather than in either server.
+ */
+/** Minimal skill shapes the prompt bridge needs (no dependency on `modules/skills`). */
+export interface SkillSummary {
+    name: string;
+    description: string;
+}
+export interface LoadedSkill extends SkillSummary {
+    body: string;
+    path: string;
+    files: string[];
+}
+/** The prompt message text for a loaded skill: its instructions body + a pointer to bundled files. */
+export declare function skillPromptText(skill: LoadedSkill): string;
+//# sourceMappingURL=skills.d.ts.map

package/dist/skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../src/skills.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,wFAAwF;AACxF,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,WAAY,SAAQ,YAAY;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,sGAAsG;AACtG,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAU1D"}

package/dist/skills.js

@@ -0,0 +1,20 @@
+/**
+ * Skills exposed as MCP prompts (slash commands in an MCP client).
+ *
+ * Both surfaces do this the same way and must keep doing it the same way: a
+ * skill's instructions are the prompt body, and the bundled files are named at
+ * the end with the exact call that fetches them. A person running the same
+ * skill through the hosted endpoint and through the local server should get
+ * identical text, so the formatting lives here rather than in either server.
+ */
+/** The prompt message text for a loaded skill: its instructions body + a pointer to bundled files. */
+export function skillPromptText(skill) {
+    const rel = skill.files.map((f) => f.startsWith(`${skill.path}/`) ? f.slice(skill.path.length + 1) : f);
+    // Each name is quoted: a comma inside a file name must not read as a list
+    // separator, and the quoted form is exactly the `file` value get_skill takes.
+    const footer = rel.length
+        ? `\n\n---\nSkill folder: ${skill.path}\nBundled files (fetch each with the get_skill tool: { name: ${JSON.stringify(skill.name)}, file }): ${rel.map((f) => JSON.stringify(f)).join(', ')}`
+        : '';
+    return `${skill.body}${footer}`;
+}
+//# sourceMappingURL=skills.js.map

package/dist/skills.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.js","sourceRoot":"","sources":["../src/skills.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAcH,sGAAsG;AACtG,MAAM,UAAU,eAAe,CAAC,KAAkB;IAChD,MAAM,GAAG,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAChC,CAAC,CAAC,UAAU,CAAC,GAAG,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CACpE,CAAC;IACF,0EAA0E;IAC1E,8EAA8E;IAC9E,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM;QACvB,CAAC,CAAC,0BAA0B,KAAK,CAAC,IAAI,gEAAgE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,cAAc,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;QAC5L,CAAC,CAAC,EAAE,CAAC;IACP,OAAO,GAAG,KAAK,CAAC,IAAI,GAAG,MAAM,EAAE,CAAC;AAClC,CAAC"}

package/dist/utcp-namespace.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The key UTCP uses to look up a manual's `${VAR}`. `@utcp/sdk` first SANITIZES
+ * the manual name — every non-word char (`-`, `.`, spaces, …) becomes `_`
+ * (`manualCallTemplate.name.replace(/[^\w]/g, "_")` at registration) — and then
+ * namespaces variables under `<namespace>_<VAR>` where every `_` in the
+ * sanitized namespace is DOUBLED (the variable substitutor), so `my_tool` + `KEY`
+ * → `my__tool_KEY` and `my-tool` + `KEY` → the very same `my__tool_KEY`. Our
+ * secret storage AND scope resolution must derive the exact same key. For an
+ * alphanumeric name (no `_`, no punctuation) this reduces to `<name>_<VAR>`,
+ * so plain tool names are unaffected.
+ */
+export declare function utcpNamespacePrefix(manualName: string): string;
+export declare function utcpNamespacedKey(manualName: string, varName: string): string;
+/**
+ * Seed the loopback discovery vars (`<ns>_API_URL` + `<ns>_CONNECTION_KEY`) for
+ * every Bevel-HOSTED manual in `manuals` — one whose discovery `url` targets our
+ * own backend with `${API_URL}` as its ORIGIN (the KB manual and inline `.tool`
+ * sub-manuals). A third-party http/mcp `.tool` points at an arbitrary URL, so it
+ * is deliberately NOT seeded: handing it `connectionKey` would leak the bearer to
+ * that endpoint. Keying off the origin (not a bare `includes('${API_URL}')`) is
+ * deliberate — an `http` `.tool`'s URL is author-controlled, so a substring match
+ * would let `http://attacker/?x=${API_URL}` be seeded the bearer and exfiltrate
+ * it. This is the exfiltration-safe seeding rule shared by the external MCP proxy
+ * and the in-process agent factory, so the bearer-leak decision is written ONCE.
+ */
+export declare function seedBevelHostedManualVars(manuals: readonly {
+    name?: unknown;
+    url?: unknown;
+}[], loopbackBaseUrl: string, connectionKey: string): Record<string, string>;
+//# sourceMappingURL=utcp-namespace.d.ts.map

package/dist/utcp-namespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utcp-namespace.d.ts","sourceRoot":"","sources":["../src/utcp-namespace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE7E;AAyBD;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,SAAS;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CAAE,EAAE,EACrD,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,MAAM,GACpB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAWxB"}

package/dist/utcp-namespace.js

@@ -0,0 +1,66 @@
+/**
+ * The key UTCP uses to look up a manual's `${VAR}`. `@utcp/sdk` first SANITIZES
+ * the manual name — every non-word char (`-`, `.`, spaces, …) becomes `_`
+ * (`manualCallTemplate.name.replace(/[^\w]/g, "_")` at registration) — and then
+ * namespaces variables under `<namespace>_<VAR>` where every `_` in the
+ * sanitized namespace is DOUBLED (the variable substitutor), so `my_tool` + `KEY`
+ * → `my__tool_KEY` and `my-tool` + `KEY` → the very same `my__tool_KEY`. Our
+ * secret storage AND scope resolution must derive the exact same key. For an
+ * alphanumeric name (no `_`, no punctuation) this reduces to `<name>_<VAR>`,
+ * so plain tool names are unaffected.
+ */
+export function utcpNamespacePrefix(manualName) {
+    return `${manualName.replace(/[^\w]/g, '_').replace(/_/g, '__')}_`;
+}
+export function utcpNamespacedKey(manualName, varName) {
+    return `${utcpNamespacePrefix(manualName)}${varName}`;
+}
+/**
+ * The origin template WE mint for every Bevel-hosted manual's discovery URL
+ * (`${API_URL}/api/…`). `${API_URL}` expands to the loopback origin, so a
+ * Bevel-hosted URL always has this exact string as its scheme+authority.
+ */
+const LOOPBACK_ORIGIN_TEMPLATE = '${API_URL}';
+/**
+ * True only when `${API_URL}` is the URL's ORIGIN (scheme+authority) — the shape
+ * we ourselves produce for a Bevel-hosted manual. A third-party `.tool` author
+ * can embed the literal `${API_URL}` anywhere in a path or query
+ * (`http://evil.example/?x=${API_URL}`) but can NOT make it the authority without
+ * pointing the request back at our own loopback, so anchoring the trust decision
+ * to the origin is what a user `.tool`'s URL text cannot forge.
+ */
+function isBevelHostedUrl(url) {
+    if (!url.startsWith(LOOPBACK_ORIGIN_TEMPLATE))
+        return false;
+    // The char right after the origin must delimit the authority; anything else
+    // (`${API_URL}.evil.com`, `${API_URL}evil`) is a different, untrusted host.
+    const next = url.charAt(LOOPBACK_ORIGIN_TEMPLATE.length);
+    return next === '' || next === '/' || next === '?' || next === '#';
+}
+/**
+ * Seed the loopback discovery vars (`<ns>_API_URL` + `<ns>_CONNECTION_KEY`) for
+ * every Bevel-HOSTED manual in `manuals` — one whose discovery `url` targets our
+ * own backend with `${API_URL}` as its ORIGIN (the KB manual and inline `.tool`
+ * sub-manuals). A third-party http/mcp `.tool` points at an arbitrary URL, so it
+ * is deliberately NOT seeded: handing it `connectionKey` would leak the bearer to
+ * that endpoint. Keying off the origin (not a bare `includes('${API_URL}')`) is
+ * deliberate — an `http` `.tool`'s URL is author-controlled, so a substring match
+ * would let `http://attacker/?x=${API_URL}` be seeded the bearer and exfiltrate
+ * it. This is the exfiltration-safe seeding rule shared by the external MCP proxy
+ * and the in-process agent factory, so the bearer-leak decision is written ONCE.
+ */
+export function seedBevelHostedManualVars(manuals, loopbackBaseUrl, connectionKey) {
+    const variables = {};
+    for (const m of manuals) {
+        const name = typeof m.name === 'string' ? m.name : '';
+        if (!name)
+            continue;
+        const url = m.url;
+        if (typeof url !== 'string' || !isBevelHostedUrl(url))
+            continue;
+        variables[utcpNamespacedKey(name, 'API_URL')] = loopbackBaseUrl;
+        variables[utcpNamespacedKey(name, 'CONNECTION_KEY')] = connectionKey;
+    }
+    return variables;
+}
+//# sourceMappingURL=utcp-namespace.js.map

package/dist/utcp-namespace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utcp-namespace.js","sourceRoot":"","sources":["../src/utcp-namespace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,mBAAmB,CAAC,UAAkB;IACpD,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC;AACrE,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,UAAkB,EAAE,OAAe;IACnE,OAAO,GAAG,mBAAmB,CAAC,UAAU,CAAC,GAAG,OAAO,EAAE,CAAC;AACxD,CAAC;AAED;;;;GAIG;AACH,MAAM,wBAAwB,GAAG,YAAY,CAAC;AAE9C;;;;;;;GAOG;AACH,SAAS,gBAAgB,CAAC,GAAW;IACnC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,wBAAwB,CAAC;QAAE,OAAO,KAAK,CAAC;IAC5D,4EAA4E;IAC5E,4EAA4E;IAC5E,MAAM,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC;IACzD,OAAO,IAAI,KAAK,EAAE,IAAI,IAAI,KAAK,GAAG,IAAI,IAAI,KAAK,GAAG,IAAI,IAAI,KAAK,GAAG,CAAC;AACrE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,yBAAyB,CACvC,OAAqD,EACrD,eAAuB,EACvB,aAAqB;IAErB,MAAM,SAAS,GAA2B,EAAE,CAAC;IAC7C,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;QACxB,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;QACtD,IAAI,CAAC,IAAI;YAAE,SAAS;QACpB,MAAM,GAAG,GAAI,CAAuB,CAAC,GAAG,CAAC;QACzC,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC;YAAE,SAAS;QAChE,SAAS,CAAC,iBAAiB,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC;QAChE,SAAS,CAAC,iBAAiB,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC,GAAG,aAAa,CAAC;IACvE,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@bevel-software/platform-mcp-core",
+  "version": "0.8.0",
+  "description": "The transport-agnostic half of Bevel's MCP surface: UTCP manual registration, tool discovery, MCP listing/dispatch and the code-mode meta-tools. Shared by the hosted proxy and the local stdio server.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/__tests__",
+    "!dist/__tests__",
+    "THIRD-PARTY-NOTICES.md"
+  ],
+  "engines": {
+    "node": ">=22 <23"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@utcp/code-mode": "^1.2.12",
+    "@utcp/http": "^1.1.11",
+    "@utcp/mcp": "^1.1.3",
+    "@utcp/sdk": "^1.1.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.0",
+    "vitest": "^3.2.6"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Bevel-Software/Hexis.git",
+    "directory": "packages/mcp-core"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
+}