@ganju/utils 0.0.1

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAlGhB,CAAC;;;;;;;;;;;;;;;;;;;;;;;kBAjHkB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA0DF,CAAC;oBAEd,CAAC;;;;aA0BkB,CAAC;mBAA8B,CAAC;WACvC,CAAC;gBACf,CAAC;gBAA4B,CAAA;;;mBAmBK,CAAC;oBACtC,CAAC;;;;;;;;;;;;;;;kBA1DmB,CAAC;;;;;;;sBAqCR,CAAC;;;;;;;;;CAuOf,CAAC;AAEF,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACX,qBAAqB,EACrB,YAAY,EACZ,OAAO,EACP,mBAAmB,EACnB,UAAU,EACV,eAAe,EACf,cAAc,EACd,gBAAgB,EAChB,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,EACnB,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EACjB,8BAA8B,EAC9B,mBAAmB,EACnB,oBAAoB,EACpB,iCAAiC,EACjC,kBAAkB,EAClB,mBAAmB,EACnB,gCAAgC,EAChC,mBAAmB,EACnB,oBAAoB,EACpB,iCAAiC,EACjC,SAAS,EACT,SAAS,EACT,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,yBAAyB,EACzB,uBAAuB,EACvB,qBAAqB,EACrB,cAAc,EACd,gBAAgB,EAChB,yBAAyB,EACzB,eAAe,EACf,eAAe,EACf,sBAAsB,EACtB,qBAAqB,EACrB,kBAAkB,EAClB,MAAM,EACN,kBAAkB,EAClB,YAAY,EACZ,sBAAsB,EACtB,mBAAmB,EACnB,sBAAsB,EACtB,kBAAkB,EAClB,sBAAsB,EACtB,0BAA0B,EAC1B,wBAAwB,EACxB,iBAAiB,EACjB,oBAAoB,EACpB,sBAAsB,EACtB,kBAAkB,EAClB,kBAAkB,EAClB,wBAAwB,EACxB,sBAAsB,EACtB,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAClB,uBAAuB,EACvB,iBAAiB,EACjB,gBAAgB,EAChB,UAAU,EACX,CAAC"}

package/dist/index.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utils = void 0;
+const schema_1 = require("./schema");
+const getEnv_1 = require("./getEnv");
+const fetcher_1 = require("./fetcher");
+const constants_1 = require("./constants");
+const slug_1 = require("./slug");
+const reservedToolName_1 = require("./reservedToolName");
+const crypto_1 = require("./crypto");
+const base64_1 = require("./base64");
+const mailHeaders_1 = require("./mailHeaders");
+const mimeMessage_1 = require("./mimeMessage");
+const parseHttpError_1 = require("./parseHttpError");
+const apiError_1 = require("./apiError");
+const coerce_1 = require("./coerce");
+const validateMessageVariables_1 = require("./validateMessageVariables");
+const jsonSchemaToZodShape_1 = require("./jsonSchemaToZodShape");
+const mcpProxy_1 = require("./mcpProxy");
+const customCodeToken_1 = require("./customCodeToken");
+const oauthProviders_1 = require("./oauthProviders");
+const attachment_1 = require("./attachment");
+const exposedResource_1 = require("./exposedResource");
+const vendorError_1 = require("./vendorError");
+const deadline_1 = require("./deadline");
+const customCodeProject_1 = require("./customCodeProject");
+const ssrf_1 = require("./ssrf");
+const formatRelative_1 = require("./formatRelative");
+const formatRelativeTime_1 = require("./formatRelativeTime");
+const languageCookieDomain_1 = require("./languageCookieDomain");
+const localizeZodIssue_1 = require("./localizeZodIssue");
+const slugifyTitle_1 = require("./slugifyTitle");
+const resourceUri_1 = require("./resourceUri");
+const toolCatalog_1 = require("./toolCatalog");
+const tallyUsageKinds_1 = require("./tallyUsageKinds");
+const formatFilename_1 = require("./formatFilename");
+const sanitize_1 = require("./sanitize");
+const chunking_1 = require("./chunking");
+const embeddable_1 = require("./embeddable");
+const l2Normalize_1 = require("./l2Normalize");
+const retry_1 = require("./retry");
+const processQueueBatch_1 = require("./processQueueBatch");
+const channelNotifier_1 = require("./channelNotifier");
+const channelDebounce_1 = require("./channelDebounce");
+const sources_1 = require("./sources");
+const oauth_1 = require("./oauth");
+const planLimitError_1 = require("./planLimitError");
+exports.utils = {
+    Schema: schema_1.Schema,
+    getEnv: getEnv_1.getEnv,
+    fetcher: fetcher_1.fetcher,
+    constants: constants_1.constants,
+    generateRandomSlug: slug_1.generateRandomSlug,
+    generateRandomToken: slug_1.generateRandomToken,
+    isReservedSlug: slug_1.isReservedSlug,
+    isValidSlugFormat: slug_1.isValidSlugFormat,
+    isReservedToolName: reservedToolName_1.isReservedToolName,
+    encryptString: crypto_1.encryptString,
+    decryptString: crypto_1.decryptString,
+    getCredentialEncryptionKey: crypto_1.getCredentialEncryptionKey,
+    sha256Hex: crypto_1.sha256Hex,
+    sha256Base64Url: crypto_1.sha256Base64Url,
+    hmacSha256Hex: crypto_1.hmacSha256Hex,
+    timingSafeEqual: crypto_1.timingSafeEqual,
+    bytesToBase64: base64_1.bytesToBase64,
+    base64ToBytes: base64_1.base64ToBytes,
+    hexToBytes: base64_1.hexToBytes,
+    utf8ToBase64: base64_1.utf8ToBase64,
+    base64ToUtf8: base64_1.base64ToUtf8,
+    toBase64Url: base64_1.toBase64Url,
+    fromBase64Url: base64_1.fromBase64Url,
+    utf8ToBase64Url: base64_1.utf8ToBase64Url,
+    base64UrlToUtf8: base64_1.base64UrlToUtf8,
+    sanitizeMailHeader: mailHeaders_1.sanitizeMailHeader,
+    encodeRfc2047: mailHeaders_1.encodeRfc2047,
+    formatMailHeader: mailHeaders_1.formatMailHeader,
+    buildMimeMessage: mimeMessage_1.buildMimeMessage,
+    sanitizeFilename: mimeMessage_1.sanitizeFilename,
+    formatFilenameHeader: mimeMessage_1.formatFilenameHeader,
+    chunkBase64: mimeMessage_1.chunkBase64,
+    parseHttpErrorMessage: parseHttpError_1.parseHttpErrorMessage,
+    isApiError: apiError_1.isApiError,
+    getApiErrorMessage: apiError_1.getApiErrorMessage,
+    toStringArray: coerce_1.toStringArray,
+    jsonSchemaToZodShape: jsonSchemaToZodShape_1.jsonSchemaToZodShape,
+    validateAgainstJsonSchema: jsonSchemaToZodShape_1.validateAgainstJsonSchema,
+    buildProxyToolName: mcpProxy_1.buildProxyToolName,
+    mintCustomCodeToken: customCodeToken_1.mintCustomCodeToken,
+    verifyCustomCodeToken: customCodeToken_1.verifyCustomCodeToken,
+    customCodeScriptName: customCodeToken_1.customCodeScriptName,
+    customCodePreviewScriptName: customCodeToken_1.customCodePreviewScriptName,
+    oauthProviders: oauthProviders_1.oauthProviders,
+    resolveAttachment: attachment_1.resolveAttachment,
+    isExposedResource: exposedResource_1.isExposedResource,
+    describeVendorError: vendorError_1.describeVendorError,
+    withDeadline: deadline_1.withDeadline,
+    isDeadlineError: deadline_1.isDeadlineError,
+    CUSTOM_CODE_PROJECT_MARKER: customCodeProject_1.CUSTOM_CODE_PROJECT_MARKER,
+    encodeProject: customCodeProject_1.encodeProject,
+    decodeProject: customCodeProject_1.decodeProject,
+    validateProjectFiles: customCodeProject_1.validateProjectFiles,
+    validateProjectPath: customCodeProject_1.validateProjectPath,
+    projectPathIssue: customCodeProject_1.projectPathIssue,
+    ipv4InPrivateRange: ssrf_1.ipv4InPrivateRange,
+    isBlockedHost: ssrf_1.isBlockedHost,
+    validateMessageVariables: validateMessageVariables_1.validateMessageVariables,
+    formatRelative: formatRelative_1.formatRelative,
+    formatRelativeTime: formatRelativeTime_1.formatRelativeTime,
+    languageCookieDomain: languageCookieDomain_1.languageCookieDomain,
+    localizeZodIssue: localizeZodIssue_1.localizeZodIssue,
+    languageFromHeader: localizeZodIssue_1.languageFromHeader,
+    slugifyTitle: slugifyTitle_1.slugifyTitle,
+    resourceUriFromTitle: resourceUri_1.resourceUriFromTitle,
+    TOOL_CATALOG: toolCatalog_1.TOOL_CATALOG,
+    TOOL_KEYS: toolCatalog_1.TOOL_KEYS,
+    describeCatalogTool: toolCatalog_1.describeCatalogTool,
+    findCatalogGroup: toolCatalog_1.findCatalogGroup,
+    findCatalogTool: toolCatalog_1.findCatalogTool,
+    isToolKey: toolCatalog_1.isToolKey,
+    tallyUsageKinds: tallyUsageKinds_1.tallyUsageKinds,
+    formatFilename: formatFilename_1.formatFilename,
+    decodeEntities: sanitize_1.decodeEntities,
+    escapeHtml: sanitize_1.escapeHtml,
+    parseOpenXmlProps: sanitize_1.parseOpenXmlProps,
+    stripBase64Images: sanitize_1.stripBase64Images,
+    sanitizeMetadataString: sanitize_1.sanitizeMetadataString,
+    serializeMetadataValue: sanitize_1.serializeMetadataValue,
+    chunkText: chunking_1.chunkText,
+    splitRecursive: chunking_1.splitRecursive,
+    buildHeader: chunking_1.buildHeader,
+    prepareChunks: chunking_1.prepareChunks,
+    isEmbeddableMimeType: embeddable_1.isEmbeddableMimeType,
+    l2Normalize: l2Normalize_1.l2Normalize,
+    sleep: retry_1.sleep,
+    isRateLimitError: retry_1.isRateLimitError,
+    withRateLimitRetry: retry_1.withRateLimitRetry,
+    processQueueBatch: processQueueBatch_1.processQueueBatch,
+    getToolStatusMessage: channelNotifier_1.getToolStatusMessage,
+    resolveDebounceMs: channelDebounce_1.resolveDebounceMs,
+    channelBufferKey: channelDebounce_1.channelBufferKey,
+    joinBufferedMessages: channelDebounce_1.joinBufferedMessages,
+    isResourceSourceEnabled: sources_1.isResourceSourceEnabled,
+    isDownloadableSource: sources_1.isDownloadableSource,
+    safeHostname: sources_1.safeHostname,
+    buildResourceDownloadUrl: sources_1.buildResourceDownloadUrl,
+    formatSourcesAsMarkdown: sources_1.formatSourcesAsMarkdown,
+    formatSourcesAsButtons: sources_1.formatSourcesAsButtons,
+    refreshOAuthToken: oauth_1.refreshOAuthToken,
+    OAuthReauthRequiredError: oauth_1.OAuthReauthRequiredError,
+    buildReauthMetadata: oauth_1.buildReauthMetadata,
+    clearReauthMetadata: oauth_1.clearReauthMetadata,
+    isCredentialNeedingReauth: oauth_1.isCredentialNeedingReauth,
+    PlanLimitError: planLimitError_1.PlanLimitError,
+    isPlanLimitError: planLimitError_1.isPlanLimitError
+};

package/dist/jsonSchemaToZodShape.d.ts

@@ -0,0 +1,38 @@
+import * as z from 'zod';
+export type JsonSchemaProperty = {
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    description?: string;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    enum?: string[];
+    items?: JsonSchemaProperty;
+};
+export type JsonSchema = {
+    type: 'object';
+    properties?: Record<string, JsonSchemaProperty>;
+    required?: string[];
+};
+export declare const jsonSchemaToZodShape: (schema: JsonSchema) => Record<string, z.ZodTypeAny>;
+export interface SchemaViolation {
+    path: string;
+    message: string;
+}
+/**
+ * Check a value against a declared JSON schema, returning the violations.
+ *
+ * The same compiler the MCP boot loop registers tools with, pointed at a value
+ * instead of at a tool definition — so what the dashboard's Test panel calls
+ * invalid is exactly what an MCP client would have refused to send. Written here
+ * rather than in apps/api because zod lives here, and a second copy of this
+ * would be a second opinion about what "valid" means.
+ *
+ * Unknown keys are allowed through: a JSON Schema without
+ * `additionalProperties: false` does not forbid them, and refusing an extra
+ * field on a test input that a real client would have passed along would make
+ * the panel lie.
+ */
+export declare const validateAgainstJsonSchema: (schema: JsonSchema, value: unknown) => SchemaViolation[];
+//# sourceMappingURL=jsonSchemaToZodShape.d.ts.map

package/dist/jsonSchemaToZodShape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonSchemaToZodShape.d.ts","sourceRoot":"","sources":["../src/jsonSchemaToZodShape.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAC;IAC3D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,kBAAkB,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,QAAQ,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAChD,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AA8CF,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,UAAU,KACjB,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,CAY7B,CAAC;AAEF,MAAM,WAAW,eAAe;IAE9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,yBAAyB,GACpC,QAAQ,UAAU,EAClB,OAAO,OAAO,KACb,eAAe,EAOjB,CAAC"}

package/dist/jsonSchemaToZodShape.js

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAgainstJsonSchema = exports.jsonSchemaToZodShape = void 0;
+const z = __importStar(require("zod"));
+const propertyToZod = (prop) => {
+    let field;
+    switch (prop.type) {
+        case 'string': {
+            if (prop.enum) {
+                field = z.enum(prop.enum);
+            }
+            else {
+                let str = z.string();
+                if (prop.minLength !== undefined)
+                    str = str.min(prop.minLength);
+                if (prop.maxLength !== undefined)
+                    str = str.max(prop.maxLength);
+                if (prop.pattern !== undefined)
+                    str = str.regex(new RegExp(prop.pattern));
+                field = str;
+            }
+            break;
+        }
+        case 'number': {
+            let num = z.number();
+            if (prop.minimum !== undefined)
+                num = num.min(prop.minimum);
+            if (prop.maximum !== undefined)
+                num = num.max(prop.maximum);
+            field = num;
+            break;
+        }
+        case 'boolean':
+            field = z.boolean();
+            break;
+        case 'array':
+            field = z.array(prop.items ? propertyToZod(prop.items) : z.any());
+            break;
+        case 'object':
+            field = z.record(z.string(), z.any());
+            break;
+        default:
+            field = z.any();
+    }
+    if (prop.description) {
+        field = field.describe(prop.description);
+    }
+    return field;
+};
+const jsonSchemaToZodShape = (schema) => {
+    const properties = schema.properties ?? {};
+    const required = schema.required ?? [];
+    const shape = {};
+    for (const [key, prop] of Object.entries(properties)) {
+        const field = propertyToZod(prop);
+        shape[key] = required.includes(key) ? field : field.optional();
+    }
+    return shape;
+};
+exports.jsonSchemaToZodShape = jsonSchemaToZodShape;
+/**
+ * Check a value against a declared JSON schema, returning the violations.
+ *
+ * The same compiler the MCP boot loop registers tools with, pointed at a value
+ * instead of at a tool definition — so what the dashboard's Test panel calls
+ * invalid is exactly what an MCP client would have refused to send. Written here
+ * rather than in apps/api because zod lives here, and a second copy of this
+ * would be a second opinion about what "valid" means.
+ *
+ * Unknown keys are allowed through: a JSON Schema without
+ * `additionalProperties: false` does not forbid them, and refusing an extra
+ * field on a test input that a real client would have passed along would make
+ * the panel lie.
+ */
+const validateAgainstJsonSchema = (schema, value) => {
+    const result = z.object((0, exports.jsonSchemaToZodShape)(schema)).safeParse(value ?? {});
+    if (result.success)
+        return [];
+    return result.error.issues.map(issue => ({
+        path: issue.path.join('.'),
+        message: issue.message
+    }));
+};
+exports.validateAgainstJsonSchema = validateAgainstJsonSchema;

package/dist/l2Normalize.d.ts

@@ -0,0 +1,2 @@
+export declare const l2Normalize: (values: number[]) => number[];
+//# sourceMappingURL=l2Normalize.d.ts.map

package/dist/l2Normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l2Normalize.d.ts","sourceRoot":"","sources":["../src/l2Normalize.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,WAAW,GAAI,QAAQ,MAAM,EAAE,KAAG,MAAM,EAMpD,CAAC"}

package/dist/l2Normalize.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.l2Normalize = void 0;
+// Scale a vector to unit length.
+//
+// Needed because `gemini-embedding-001` only returns a normalised vector at its
+// full 3072 dimensions. Ask for fewer via `outputDimensionality` — as we do, to
+// halve storage — and the values come back UNNORMALISED, because truncating a
+// unit vector leaves it shorter than 1. Cosine distance in pgvector assumes
+// nothing about magnitude, but our stored vectors and query vectors have to be
+// treated identically, and an unnormalised mix silently skews ranking rather
+// than failing. So both the ingest path and the query path normalise here.
+//
+// Returns the input unchanged when the magnitude is zero, which would otherwise
+// divide by zero and produce NaNs that poison the whole index.
+const l2Normalize = (values) => {
+    let sum = 0;
+    for (const v of values)
+        sum += v * v;
+    const magnitude = Math.sqrt(sum);
+    if (!magnitude || !Number.isFinite(magnitude))
+        return values;
+    return values.map(v => v / magnitude);
+};
+exports.l2Normalize = l2Normalize;

package/dist/languageCookieDomain.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Cookie `Domain` for the remembered language, derived from the host serving
+ * the request.
+ *
+ * `ganju.ai` and `app.ganju.ai` are two hosts, so a host-only cookie set by one
+ * is invisible to the other — someone who explicitly picks English on the
+ * marketing site would sign in and be handed Spanish again by the country
+ * lookup, which defeats the point of remembering the choice. Scoping the cookie
+ * to `.ganju.ai` makes one click cover both.
+ *
+ * Derived from the host rather than configured, because the two surfaces deploy
+ * separately and a value set in one place would silently rot in the other. The
+ * cost is the assumption below.
+ *
+ * **Assumes a single-label public suffix** — `ganju.ai`, `vocesqueabrazan.com`.
+ * A deploy under a multi-part suffix (`example.co.uk`) would compute `.co.uk`,
+ * which browsers reject, and the cookie would quietly go nowhere. Add that
+ * suffix here if it ever happens.
+ */
+export declare const languageCookieDomain: (hostname: string) => string | undefined;
+//# sourceMappingURL=languageCookieDomain.d.ts.map

package/dist/languageCookieDomain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"languageCookieDomain.d.ts","sourceRoot":"","sources":["../src/languageCookieDomain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,oBAAoB,GAAI,UAAU,MAAM,KAAG,MAAM,GAAG,SAiBhE,CAAC"}

package/dist/languageCookieDomain.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.languageCookieDomain = void 0;
+/**
+ * Cookie `Domain` for the remembered language, derived from the host serving
+ * the request.
+ *
+ * `ganju.ai` and `app.ganju.ai` are two hosts, so a host-only cookie set by one
+ * is invisible to the other — someone who explicitly picks English on the
+ * marketing site would sign in and be handed Spanish again by the country
+ * lookup, which defeats the point of remembering the choice. Scoping the cookie
+ * to `.ganju.ai` makes one click cover both.
+ *
+ * Derived from the host rather than configured, because the two surfaces deploy
+ * separately and a value set in one place would silently rot in the other. The
+ * cost is the assumption below.
+ *
+ * **Assumes a single-label public suffix** — `ganju.ai`, `vocesqueabrazan.com`.
+ * A deploy under a multi-part suffix (`example.co.uk`) would compute `.co.uk`,
+ * which browsers reject, and the cookie would quietly go nowhere. Add that
+ * suffix here if it ever happens.
+ */
+const languageCookieDomain = (hostname) => {
+    const labels = hostname.split('.');
+    // `localhost`, and anything else with nothing to share with.
+    if (labels.length < 2)
+        return undefined;
+    // A bare IP has no domain to scope to.
+    if (/^\d+$/.test(labels[labels.length - 1]))
+        return undefined;
+    const apex = labels.slice(-2).join('.');
+    // Cloudflare's preview hosts are a public suffix: every Pages project on the
+    // planet shares them, so browsers refuse a cookie scoped there. Falling back
+    // to host-only keeps previews working on their own.
+    if (apex === 'pages.dev' || apex === 'workers.dev')
+        return undefined;
+    return `.${apex}`;
+};
+exports.languageCookieDomain = languageCookieDomain;

package/dist/localizeZodIssue.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Re-render a Zod validation issue in the reader's language.
+ *
+ * Zod already ships a complete Spanish locale, so all ~305 built-in validators
+ * in `schema.ts` are covered without hand-translating anything. The trick is
+ * *where* to apply it. There are ~100 parse call sites across the three
+ * services; threading a per-parse error map through all of them is a hundred
+ * chances to miss one. Instead this runs once, in `handleError`'s ZodError
+ * branch, on the way out.
+ *
+ * That works because a Zod 4 issue keeps its structured fields — `code`,
+ * `origin`, `minimum`, `divisor`, `keys` — alongside the rendered `message`,
+ * and a locale error map is exactly a function from that structured issue to a
+ * string. So the English message Zod produced at parse time can be thrown away
+ * and rebuilt in Spanish at catch time.
+ *
+ * **Do not reach for `z.config({ localeError })` instead.** It mutates a
+ * module-level global (`zod/src/v4/core/config.ts`), and a Workers isolate
+ * serves concurrent requests in different languages — one request would set the
+ * locale for whatever else happened to be in flight. Nothing here holds state.
+ *
+ * What lands in `error_log` is untouched: `handleError` persists `err.message`,
+ * which is still Zod's own English dump from parse time. Nothing about
+ * persistence, and no migration, is involved.
+ */
+/** Minimal shape of the issue we need; Zod's own type lives in `zod`. */
+export interface ZodIssueLike {
+    code?: string;
+    message: string;
+    path?: PropertyKey[];
+}
+/**
+ * Narrow an `Accept-Language` header to a language we ship.
+ *
+ * `fetcher` sends the app's own locale rather than the browser's list, so this
+ * is normally a bare `en` or `es` — but the header is public, and a browser
+ * hitting the API directly will send the full `es-CO,es;q=0.9,en;q=0.8` form.
+ * Take the first tag and match on its primary subtag.
+ */
+export declare const languageFromHeader: (header?: string | null) => string;
+/** The issue's message in `language`, or its original English. */
+export declare const localizeZodIssue: (issue: ZodIssueLike, language: string) => string;
+//# sourceMappingURL=localizeZodIssue.d.ts.map

package/dist/localizeZodIssue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localizeZodIssue.d.ts","sourceRoot":"","sources":["../src/localizeZodIssue.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,yEAAyE;AACzE,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,WAAW,EAAE,CAAC;CACtB;AAkDD;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,MAAM,GAAG,IAAI,KAAG,MAK3D,CAAC;AAEF,kEAAkE;AAClE,eAAO,MAAM,gBAAgB,GAC3B,OAAO,YAAY,EACnB,UAAU,MAAM,KACf,MAmBF,CAAC"}

package/dist/localizeZodIssue.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localizeZodIssue = exports.languageFromHeader = void 0;
+const es_js_1 = __importDefault(require("zod/v4/locales/es.js"));
+const constants_1 = require("./constants");
+/**
+ * Messages we wrote ourselves. Zod renders a custom `message:` verbatim, so the
+ * locale map never sees them — they arrive here as the exact English string,
+ * which is what these keys are. Keying on our own text rather than on a code
+ * keeps `schema.ts` free of translation concerns, and keeps the English in
+ * `error_log` identical to what it has always been.
+ */
+const CUSTOM_MESSAGES = {
+    'This title is reserved as a bot command': {
+        es: 'Este título está reservado como comando del bot'
+    },
+    'Enter a valid email address': {
+        es: 'Escribe un correo electrónico válido'
+    },
+    'Unsupported mime type': {
+        es: 'Tipo de archivo no admitido'
+    },
+    'Slug is reserved': {
+        es: 'Ese slug está reservado'
+    },
+    [constants_1.constants.RESERVED_TOOL_NAME_MESSAGE]: {
+        es: 'Nombre de herramienta no válido — reservado por la plataforma'
+    },
+    [constants_1.constants.CUSTOM_CODE_UNKNOWN_CONNECTION_MESSAGE]: {
+        es: 'Conexión no válida — no existe un proveedor gestionado con ese nombre'
+    },
+    [constants_1.constants.OUTPUT_SCHEMA_NOT_OBJECT_MESSAGE]: {
+        es: 'Esquema de salida no válido — debe describir un objeto'
+    },
+    [constants_1.constants.CUSTOM_CODE_RESOURCE_PAYLOAD_MESSAGE]: {
+        es: 'Envía exactamente uno de content (texto) o bytes (base64)'
+    },
+    [constants_1.constants.CUSTOM_CODE_RESOURCE_TEXT_TOO_LARGE_MESSAGE]: {
+        es: `El contenido en línea supera el límite de ${constants_1.constants.CUSTOM_CODE_MAX_RESOURCE_TEXT_BYTES / (1024 * 1024)}MB`
+    },
+    [constants_1.constants.CUSTOM_CODE_RESOURCE_FILE_TOO_LARGE_MESSAGE]: {
+        es: `Los bytes del archivo superan el límite de ${constants_1.constants.CUSTOM_CODE_MAX_RESOURCE_FILE_BYTES / (1024 * 1024)}MB`
+    }
+};
+// Built once. `esLocale()` allocates its dictionaries on every call, and this
+// runs per issue, per failed request.
+const LOCALE_ERRORS = {
+    [constants_1.constants.LANGUAGE_ES]: (0, es_js_1.default)().localeError
+};
+/**
+ * Narrow an `Accept-Language` header to a language we ship.
+ *
+ * `fetcher` sends the app's own locale rather than the browser's list, so this
+ * is normally a bare `en` or `es` — but the header is public, and a browser
+ * hitting the API directly will send the full `es-CO,es;q=0.9,en;q=0.8` form.
+ * Take the first tag and match on its primary subtag.
+ */
+const languageFromHeader = (header) => {
+    const tag = header?.split(',')[0]?.trim().toLowerCase() ?? '';
+    return tag.startsWith(constants_1.constants.LANGUAGE_ES)
+        ? constants_1.constants.LANGUAGE_ES
+        : constants_1.constants.LANGUAGE_EN;
+};
+exports.languageFromHeader = languageFromHeader;
+/** The issue's message in `language`, or its original English. */
+const localizeZodIssue = (issue, language) => {
+    if (language === constants_1.constants.LANGUAGE_EN)
+        return issue.message;
+    const custom = CUSTOM_MESSAGES[issue.message]?.[language];
+    if (custom)
+        return custom;
+    const localeError = LOCALE_ERRORS[language];
+    if (!localeError)
+        return issue.message;
+    try {
+        const rendered = localeError(issue);
+        const message = typeof rendered === 'string' ? rendered : rendered?.message;
+        // A locale map may decline an issue it does not recognise; English is a
+        // better answer than an empty string.
+        return message || issue.message;
+    }
+    catch {
+        // Never let a formatting failure turn a 400 into a 500.
+        return issue.message;
+    }
+};
+exports.localizeZodIssue = localizeZodIssue;

package/dist/mailHeaders.d.ts

@@ -0,0 +1,4 @@
+export declare const sanitizeMailHeader: (value: string) => string;
+export declare const encodeRfc2047: (value: string) => string;
+export declare const formatMailHeader: (value: string) => string;
+//# sourceMappingURL=mailHeaders.d.ts.map

package/dist/mailHeaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mailHeaders.d.ts","sourceRoot":"","sources":["../src/mailHeaders.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,kBAAkB,GAAI,OAAO,MAAM,KAAG,MACZ,CAAC;AAExC,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,KAAG,MACyB,CAAC;AAExE,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,KAAG,MACP,CAAC"}

package/dist/mailHeaders.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatMailHeader = exports.encodeRfc2047 = exports.sanitizeMailHeader = void 0;
+const base64_1 = require("./base64");
+const ASCII_ONLY = /^[\x00-\x7F]*$/;
+const sanitizeMailHeader = (value) => value.replace(/[\r\n]+/g, ' ').trim();
+exports.sanitizeMailHeader = sanitizeMailHeader;
+const encodeRfc2047 = (value) => ASCII_ONLY.test(value) ? value : `=?UTF-8?B?${(0, base64_1.utf8ToBase64)(value)}?=`;
+exports.encodeRfc2047 = encodeRfc2047;
+const formatMailHeader = (value) => (0, exports.encodeRfc2047)((0, exports.sanitizeMailHeader)(value));
+exports.formatMailHeader = formatMailHeader;

package/dist/mcpProxy.d.ts

@@ -0,0 +1,2 @@
+export declare const buildProxyToolName: (prefix: string, remoteName: string) => string | null;
+//# sourceMappingURL=mcpProxy.d.ts.map

package/dist/mcpProxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcpProxy.d.ts","sourceRoot":"","sources":["../src/mcpProxy.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,MAAM,EACd,YAAY,MAAM,KACjB,MAAM,GAAG,IAKX,CAAC"}

package/dist/mcpProxy.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProxyToolName = void 0;
+const constants_1 = require("./constants");
+// Remote MCP tool keys are untrusted (the remote chooses them). Only allow the
+// charset MCP clients accept for tool names so the composed local name can't
+// break registration or downstream API calls.
+const REMOTE_TOOL_NAME_RE = /^[a-zA-Z0-9_-]+$/;
+// Compose the local MCP tool name for a proxied remote tool (`<prefix><sep><key>`),
+// or return null when the remote key can't be safely surfaced — bad charset, or
+// the composed name exceeds the tool-name length limit clients enforce. Callers
+// skip-and-log nulls rather than registering an unusable tool.
+const buildProxyToolName = (prefix, remoteName) => {
+    if (!remoteName || !REMOTE_TOOL_NAME_RE.test(remoteName))
+        return null;
+    const name = `${prefix}${constants_1.constants.MCP_PROXY_TOOL_NAME_SEP}${remoteName}`;
+    if (name.length > constants_1.constants.MCP_PROXY_TOOL_NAME_MAX)
+        return null;
+    return name;
+};
+exports.buildProxyToolName = buildProxyToolName;

package/dist/mimeMessage.d.ts

@@ -0,0 +1,21 @@
+export interface MimeAttachment {
+    filename: string;
+    mimeType: string;
+    base64: string;
+}
+export interface MimeMessageInput {
+    to: string;
+    subject: string;
+    body: string;
+    cc?: string;
+    bcc?: string;
+    inReplyTo?: string;
+    references?: string;
+    contentType?: 'text/html' | 'text/plain';
+    attachments?: MimeAttachment[];
+}
+export declare const sanitizeFilename: (name: string) => string;
+export declare const formatFilenameHeader: (name: string) => string;
+export declare const chunkBase64: (b64: string) => string;
+export declare const buildMimeMessage: (input: MimeMessageInput) => string;
+//# sourceMappingURL=mimeMessage.d.ts.map

package/dist/mimeMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mimeMessage.d.ts","sourceRoot":"","sources":["../src/mimeMessage.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,WAAW,GAAG,YAAY,CAAC;IACzC,WAAW,CAAC,EAAE,cAAc,EAAE,CAAC;CAChC;AAED,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,KAAG,MAG/C,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,KAAG,MAMnD,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,KAAG,MACP,CAAC;AAEpC,eAAO,MAAM,gBAAgB,GAAI,OAAO,gBAAgB,KAAG,MA6C1D,CAAC"}