@ganju/utils 0.0.13 → 0.0.15

package/dist/toolConfirmation.js

@@ -4,7 +4,7 @@
 // participant's next message is a plain yes. These are the pieces of that rule
 // that aren't the runner's own bookkeeping.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stableJson = exports.isSensitiveTool = exports.formatConfirmationSummary = exports.isConfirmationReply = exports.parseConfirmationButton = exports.confirmationButtonId = exports.confirmationButtonLabels = exports.languageFromPhoneNumber = exports.annotationsForEffect = exports.TOOL_EFFECTS = void 0;
+exports.toolApprovalUrl = exports.toolApprovalStatus = exports.stableJson = exports.isSensitiveProxiedTool = exports.keepProxiedToolMarks = exports.proxiedToolAnnotations = exports.proxiedToolTrust = exports.isSensitiveTool = exports.formatConfirmationSummary = exports.isConfirmationReply = exports.parseConfirmationButton = exports.confirmationButtonId = exports.confirmationButtonLabels = exports.languageFromPhoneNumber = exports.annotationsForEffect = exports.TOOL_EFFECTS = void 0;
 // What an owner says a tool they wrote does, in the words the dashboard asks
 // it in, and the MCP annotations each answer stands for: `read` only looks
 // things up, `write` changes things that can be undone, `sensitive` sends,
@@ -223,6 +223,62 @@ exports.formatConfirmationSummary = formatConfirmationSummary;
  */
 const isSensitiveTool = (annotations) => annotations?.readOnlyHint !== true && annotations?.destructiveHint !== false;
 exports.isSensitiveTool = isSensitiveTool;
+const proxiedToolTrust = (config, remoteToolName) => ({
+    trustHints: config?.trustAnnotations === true,
+    readOnly: Array.isArray(config?.readOnlyTools) &&
+        config.readOnlyTools.includes(remoteToolName)
+});
+exports.proxiedToolTrust = proxiedToolTrust;
+/**
+ * The annotations a proxied tool is registered with. A remote server's hints
+ * are its own claim about itself, and one that marks a delete read-only would
+ * skip every confirmation — so unless the organization chose to trust that
+ * server, the read-only and destructive hints are dropped and the tool reads
+ * as sensitive by the defaults above. A tool the owner marked as only reading
+ * is read-only whatever the remote says, trusted or not. Clients see the
+ * same, so they ask about the same tools. The harmless parts (title,
+ * openWorldHint, idempotentHint) pass through.
+ */
+const proxiedToolAnnotations = (annotations, trust) => {
+    const result = { ...annotations };
+    if (trust.readOnly) {
+        delete result.destructiveHint;
+        return { ...result, readOnlyHint: true };
+    }
+    if (!trust.trustHints) {
+        delete result.readOnlyHint;
+        delete result.destructiveHint;
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+};
+exports.proxiedToolAnnotations = proxiedToolAnnotations;
+// The install-config keys that hold the owner's trust marks above.
+const PROXIED_TOOL_MARK_KEYS = ['trustAnnotations', 'readOnlyTools'];
+/**
+ * An install's new config with the owner's trust marks carried over from the
+ * stored one wherever the new one doesn't say. A save that only knew about
+ * the allow-lists (an older dashboard, a script) must not quietly turn the
+ * marks off; one that sends them, even as false or empty, decides.
+ */
+const keepProxiedToolMarks = (stored, incoming) => {
+    if (!stored ||
+        typeof stored !== 'object' ||
+        !incoming ||
+        typeof incoming !== 'object') {
+        return incoming;
+    }
+    const merged = { ...incoming };
+    for (const key of PROXIED_TOOL_MARK_KEYS) {
+        if (merged[key] === undefined && key in stored) {
+            merged[key] = stored[key];
+        }
+    }
+    return merged;
+};
+exports.keepProxiedToolMarks = keepProxiedToolMarks;
+/** Whether a proxied tool is confirmed, decided as its registration is. */
+const isSensitiveProxiedTool = (annotations, trust) => (0, exports.isSensitiveTool)((0, exports.proxiedToolAnnotations)(annotations, trust));
+exports.isSensitiveProxiedTool = isSensitiveProxiedTool;
 // JSON with keys sorted at every depth, so two argument objects that say the
 // same thing serialize the same whatever order the model emitted them in.
 const stableJson = (value) => {
@@ -237,3 +293,21 @@ const stableJson = (value) => {
     return JSON.stringify(value) ?? 'null';
 };
 exports.stableJson = stableJson;
+/**
+ * Where an approval stands. Spent and refused come first, since an answer
+ * stays the answer after the window closes; past its time, one never answered
+ * or never used can no longer be.
+ */
+const toolApprovalStatus = (approval, now = Date.now()) => {
+    if (approval.usedAt)
+        return 'used';
+    if (approval.deniedAt)
+        return 'denied';
+    if (approval.expiresAt.getTime() <= now)
+        return 'expired';
+    return approval.approvedAt ? 'approved' : 'pending';
+};
+exports.toolApprovalStatus = toolApprovalStatus;
+/** The dashboard page where the user answers one approval. */
+const toolApprovalUrl = (webUrl, path, approvalId) => `${webUrl.replace(/\/+$/, '')}${path}/${encodeURIComponent(approvalId)}`;
+exports.toolApprovalUrl = toolApprovalUrl;

package/dist/toolCount.d.ts

@@ -0,0 +1,13 @@
+/**
+ * An mcp-proxy row exposes each discovered remote tool its allow-list keeps,
+ * so a single GitHub install can be dozens of tools. A custom-code row exposes
+ * the functions of its published version the allow-list keeps — pass their
+ * names as `customCodeFunctions`; without them the row counts as one. Every
+ * other row is one tool.
+ */
+export declare const countInstallTools: (install: {
+    toolKey: string;
+    config: unknown;
+    metadata: unknown;
+}, customCodeFunctions?: string[]) => number;
+//# sourceMappingURL=toolCount.d.ts.map

package/dist/toolCount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolCount.d.ts","sourceRoot":"","sources":["../src/toolCount.ts"],"names":[],"mappings":"AAqBA;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAC5B,SAAS;IACP,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;CACnB,EACD,sBAAsB,MAAM,EAAE,KAC7B,MAiBF,CAAC"}

package/dist/toolCount.js

@@ -0,0 +1,45 @@
+"use strict";
+// How many tools an install puts in front of a model, which is what the tool
+// limit counts. Imports nothing, so node --test runs it directly.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countInstallTools = void 0;
+// The same values as constants.TOOL_DEFINITION_KEY_MCP_PROXY and
+// TOOL_DEFINITION_KEY_CUSTOM_CODE, written out rather than imported, since
+// this file imports nothing.
+const MCP_PROXY_TOOL_KEY = 'mcp-proxy';
+const CUSTOM_CODE_TOOL_KEY = 'custom-code';
+// The tools an allow-list keeps out of `names`. An empty or absent list keeps
+// all of them, as the MCP boot loop reads it.
+const allowedCount = (names, config) => {
+    const allowedTools = config
+        ?.allowedTools;
+    if (!Array.isArray(allowedTools) || allowedTools.length === 0) {
+        return names.length;
+    }
+    const allowed = new Set(allowedTools);
+    return names.filter(name => allowed.has(name)).length;
+};
+/**
+ * An mcp-proxy row exposes each discovered remote tool its allow-list keeps,
+ * so a single GitHub install can be dozens of tools. A custom-code row exposes
+ * the functions of its published version the allow-list keeps — pass their
+ * names as `customCodeFunctions`; without them the row counts as one. Every
+ * other row is one tool.
+ */
+const countInstallTools = (install, customCodeFunctions) => {
+    if (install.toolKey === CUSTOM_CODE_TOOL_KEY) {
+        return customCodeFunctions
+            ? allowedCount(customCodeFunctions, install.config)
+            : 1;
+    }
+    if (install.toolKey !== MCP_PROXY_TOOL_KEY)
+        return 1;
+    const discovered = install.metadata?.discovery?.tools;
+    if (!Array.isArray(discovered))
+        return 0;
+    const names = discovered
+        .map(tool => tool?.name)
+        .filter((name) => typeof name === 'string');
+    return allowedCount(names, install.config);
+};
+exports.countInstallTools = countInstallTools;

package/dist/toolLint.d.ts

@@ -10,7 +10,7 @@ export interface LintableTool {
         openWorldHint?: boolean;
     };
 }
-export declare const TOOL_LINT_RULES: readonly ["missing-description", "short-description", "no-usage-guidance", "missing-annotations", "undescribed-input", "overlapping-tools", "too-many-tools"];
+export declare const TOOL_LINT_RULES: readonly ["missing-description", "short-description", "no-usage-guidance", "missing-annotations", "undescribed-input", "reserved-input", "overlapping-tools", "too-many-tools"];
 export type ToolLintRule = (typeof TOOL_LINT_RULES)[number];
 export interface ToolLintFinding {
     rule: ToolLintRule;

package/dist/toolLint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolLint.d.ts","sourceRoot":"","sources":["../src/toolLint.ts"],"names":[],"mappings":"AAeA,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,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;KACzB,CAAC;CACH;AAED,eAAO,MAAM,eAAe,+JAQlB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5D,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,YAAY,CAAC;IAGnB,IAAI,CAAC,EAAE,MAAM,CAAC;IAGd,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IAEjB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IAEjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IAGf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAI9B,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;IAGxB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAID,eAAO,MAAM,gCAAgC,KAAK,CAAC;AAKnD,eAAO,MAAM,mBAAmB,KAAK,CAAC;AA2ItC;;;GAGG;AACH,eAAO,MAAM,SAAS,GACpB,OAAO,YAAY,EAAE,EACrB,UAAS,eAAoB,KAC5B,eAAe,EA8FjB,CAAC"}
+{"version":3,"file":"toolLint.d.ts","sourceRoot":"","sources":["../src/toolLint.ts"],"names":[],"mappings":"AAeA,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,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;KACzB,CAAC;CACH;AAED,eAAO,MAAM,eAAe,iLASlB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5D,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,YAAY,CAAC;IAGnB,IAAI,CAAC,EAAE,MAAM,CAAC;IAGd,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IAGjB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IAEjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IAGf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAI9B,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;IAGxB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAID,eAAO,MAAM,gCAAgC,KAAK,CAAC;AAKnD,eAAO,MAAM,mBAAmB,KAAK,CAAC;AA0KtC;;;GAGG;AACH,eAAO,MAAM,SAAS,GACpB,OAAO,YAAY,EAAE,EACrB,UAAS,eAAoB,KAC5B,eAAe,EAwGjB,CAAC"}

package/dist/toolLint.js

@@ -19,6 +19,7 @@ exports.TOOL_LINT_RULES = [
     'no-usage-guidance',
     'missing-annotations',
     'undescribed-input',
+    'reserved-input',
     'overlapping-tools',
     'too-many-tools'
 ];
@@ -44,8 +45,11 @@ const fold = (text) => text
 // Wording that tells a model WHEN to call a tool rather than only what it does
 // — English, Spanish and Portuguese, the languages descriptions here are
 // written in. Loose on purpose: a false "says when" costs nothing, a false
-// "doesn't" nags someone whose description is fine.
-const USAGE_GUIDANCE = /\b(use|uses|using|call|calls|when|whenever|before|after|instead|only if|if the user|if you|for questions|usa|usala|usalo|usar|llama|llamala|llamar|cuando|antes de|despues de|en lugar de|si el usuario|quando|use-a|utilize|chame)\b/;
+// "doesn't" nags someone whose description is fine. But not so loose that
+// words about how a tool works count: "uses the Stripe API" and "makes an API
+// call" say nothing about when to reach for it, so "call" counts only as an
+// instruction ("call this…", "call it…").
+const USAGE_GUIDANCE = /\b(use|call (?:this|it)|when|whenever|before|after|instead|only if|if the user|if you|for questions|usa|usala|usalo|usar|llama|llamala|llamar|cuando|antes de|despues de|en lugar de|si el usuario|quando|use-a|utilize|chame)\b/;
 const STOPWORDS = new Set([
     'the',
     'and',
@@ -87,8 +91,19 @@ const STOPWORDS = new Set([
 const contentWords = (text) => new Set(fold(text)
     .split(/[^a-z0-9]+/)
     .filter(word => word.length >= 3 && !STOPWORDS.has(word)));
+// A proxied tool is named `<server prefix>__<remote name>`. The prefix says
+// which connection it came from, not what it does, so `search_repositories`
+// and `github__search_repositories` are the same tool to a model. Kept here
+// rather than imported from constants (MCP_PROXY_TOOL_NAME_SEP), since this
+// file imports nothing.
+const PROXY_NAME_SEP = '__';
+const withoutProxyPrefix = (name) => {
+    const at = name.lastIndexOf(PROXY_NAME_SEP);
+    const bare = at === -1 ? name : name.slice(at + PROXY_NAME_SEP.length);
+    return bare || name;
+};
 // `lookupOrder`, `lookup-order` and `order_lookup` name the same thing.
-const nameTokens = (name) => name
+const nameTokens = (name) => withoutProxyPrefix(name)
     .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
     .toLowerCase()
     .split(/[^a-z0-9]+/)
@@ -146,6 +161,16 @@ const undescribedPaths = (schema, prefix = '') => {
     }
     return paths;
 };
+// Top-level input names the server takes for itself. `confirmation` carries
+// the token a sensitive tool's second call brings back: the server replaces a
+// property of that name and strips it before the tool runs, so it never
+// reaches the tool.
+// Kept here rather than imported from constants (MCP_TOOL_CONFIRMATION_ARG),
+// since this file imports nothing.
+const RESERVED_INPUT_NAMES = ['confirmation'];
+const reservedPaths = (schema) => isObject(schema) && isObject(schema.properties)
+    ? RESERVED_INPUT_NAMES.filter(name => Object.prototype.hasOwnProperty.call(schema.properties, name))
+    : [];
 const quoted = (name) => `"${name}"`;
 /**
  * Check a set of tools for what makes them hard for a model to use. Findings
@@ -211,6 +236,15 @@ const lintTools = (tools, options = {}) => {
                 message: `${quoted(tool.name)} has input properties with no description: ${paths.join(', ')}. A model has to guess what to pass.`
             });
         }
+        const reserved = reservedPaths(tool.inputSchema);
+        if (reserved.length > 0) {
+            findings.push({
+                rule: 'reserved-input',
+                tool: tool.name,
+                paths: reserved,
+                message: `${quoted(tool.name)} has an input named ${reserved.map(quoted).join(', ')}, which the server keeps for confirming sensitive actions: on a tool it confirms, that property is replaced and its value never reaches the tool. Rename it.`
+            });
+        }
         // Each pair once — against the tools after this one, then the rest of the
         // server — and one finding per tool, so twenty look-alikes are nineteen
         // lines rather than a hundred and ninety.

package/dist/untrustedContent.d.ts

@@ -0,0 +1,135 @@
+export declare const UNTRUSTED_CONTENT_TAG = "untrusted_content";
+export declare const UNTRUSTED_CONTENT_META_KEY = "ganju.ai/untrusted";
+export declare const UNTRUSTED_CONTENT_NOTE: string;
+/**
+ * Wrap text that came from outside in the marks the model is told about.
+ * `source` says where it came from (a tool name, a URI) and is reduced to
+ * characters that can't close the attribute.
+ */
+export declare const wrapUntrustedContent: (source: string, text: string) => string;
+/**
+ * The text inside a wrapped block, for code that reads a tool's result itself
+ * (citations parse search results as JSON). Text that isn't one block is
+ * returned as it is.
+ */
+export declare const unwrapUntrustedContent: (text: string) => string;
+/** Whether a tool result carries the flag set by the server that ran it. */
+export declare const isUntrustedToolResult: (result: unknown) => boolean;
+export declare const INSTRUCTION_WARNING_METADATA_KEY = "instructionWarning";
+export interface InstructionWarning {
+    passages: string[];
+    checkedAt: string;
+}
+/**
+ * The passages of `text` that read like instructions to an AI model, as the
+ * document wrote them, at most five and each cut to a readable length. Empty
+ * when nothing matched.
+ */
+export declare const findInstructionLikeText: (text: string) => string[];
+type ContentBlock = {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+};
+export interface LabelledToolResult {
+    content: ContentBlock[];
+    structuredContent?: unknown;
+    isError?: boolean;
+    _meta?: Record<string, unknown>;
+}
+/**
+ * Outside text as a tool result: wrapped, and flagged so that a sensitive call
+ * made after it asks first. `flag: false` labels without flagging — for the
+ * organization's own knowledge base, where reading a clean document shouldn't
+ * make every later action ask.
+ */
+export declare const untrustedToolResult: (source: string, text: string, options?: {
+    flag?: boolean;
+}) => {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    _meta?: Record<string, unknown>;
+};
+/**
+ * Mostly the user's own writing, but able to quote someone else's — a draft
+ * carrying the email it replies to. Labelled always, flagged only when it
+ * reads like instructions, so "show my drafts, then send that one" doesn't
+ * ask every time.
+ */
+export declare const ownWritingToolResult: (source: string, text: string) => {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    _meta?: Record<string, unknown>;
+};
+/**
+ * What one of the organization's own integrations (an HTTP endpoint, a custom
+ * tool) brought back. The integration is the owner's, but the data may not be
+ * — a support ticket, a product review — so its text is wrapped. Flagged only
+ * when it reads like instructions: a menu lookup before an order is the
+ * ordinary case. A declared output schema makes the structured copy required,
+ * so it stays and can't carry the label, but it is read for instructions all
+ * the same. Errors pass through as they are: a tool whose error carries
+ * outside text labels that part itself (see untrustedErrorResult).
+ */
+export declare const labelOwnToolResult: <T extends LabelledToolResult>(result: T, source: string) => T;
+/**
+ * A failure whose message carries text from outside — an endpoint's error
+ * body, a remote server's or a script's error. `message` is ours and stays
+ * first, so the result still reads as an `Error:`; `detail` is wrapped.
+ * Flagged always unless `flag: false`, which the organization's own
+ * integrations pass with whether the detail reads like instructions.
+ */
+export declare const untrustedErrorResult: (message: string, source: string, detail: string, options?: {
+    flag?: boolean;
+}) => {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError: true;
+    _meta?: Record<string, unknown>;
+};
+/** Whether text reads like instructions to the model. */
+export declare const readsLikeInstructions: (text: string) => boolean;
+type ResourceContent = {
+    uri: string;
+    text?: string;
+    [key: string]: unknown;
+};
+/**
+ * A resource read, as it goes back to the model: each text part wrapped under
+ * its own uri, binary parts as they are. `instructionLike` says whether any
+ * text part reads like instructions, for the caller deciding whether to flag
+ * the session.
+ */
+export declare const labelResourceContents: <T extends ResourceContent>(contents: T[]) => {
+    contents: T[];
+    instructionLike: boolean;
+};
+/**
+ * A remote MCP server's tool result, as it goes back through the proxy.
+ *
+ * Within `maxBytes` the blocks are kept as they are; past it they are
+ * flattened to one text block, structured copy included, since the SDK can't
+ * return several large blocks in one result. Whatever the remote answers was written by someone
+ * else, so every text block is labelled and the result is always flagged.
+ * Images and other blocks pass through.
+ *
+ * A structured copy can't carry the label, and some clients hand the model
+ * that copy instead of the text. Proxied tools register no output schema, so
+ * the copy is optional: it is folded into the labelled text (as JSON, unless a
+ * text block already says exactly that) and dropped. A copy alone counts as
+ * content — "(the tool returned no content)" is only for a result that has
+ * neither.
+ */
+export declare const labelProxiedToolResult: (raw: {
+    content?: unknown;
+    structuredContent?: unknown;
+    isError?: boolean;
+}, source: string, maxBytes: number) => LabelledToolResult;
+export {};
+//# sourceMappingURL=untrustedContent.d.ts.map

package/dist/untrustedContent.d.ts.map

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