@dexto/core 1.1.10 → 1.2.0

package/dist/resources/reference-parser.cjs

@@ -0,0 +1,217 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var reference_parser_exports = {};
+__export(reference_parser_exports, {
+  expandMessageReferences: () => expandMessageReferences,
+  formatResourceContent: () => formatResourceContent,
+  parseResourceReferences: () => parseResourceReferences,
+  resolveResourceReferences: () => resolveResourceReferences
+});
+module.exports = __toCommonJS(reference_parser_exports);
+function escapeRegExp(literal) {
+  return literal.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+}
+function parseResourceReferences(message) {
+  const references = [];
+  const regex = /(?:^|(?<=\s))@(?:(<[^>]+>)|([a-zA-Z0-9_-]+):([a-zA-Z0-9._/-]+)|([a-zA-Z0-9._/-]+))(?![a-zA-Z0-9@.])/g;
+  let match;
+  while ((match = regex.exec(message)) !== null) {
+    const [originalRef, uriWithBrackets, serverName, serverResource, simpleName] = match;
+    if (uriWithBrackets) {
+      references.push({ originalRef, type: "uri", identifier: uriWithBrackets.slice(1, -1) });
+    } else if (serverName && serverResource) {
+      references.push({
+        originalRef,
+        type: "server-scoped",
+        serverName,
+        identifier: serverResource
+      });
+    } else if (simpleName) {
+      references.push({ originalRef, type: "name", identifier: simpleName });
+    }
+  }
+  return references;
+}
+function resolveResourceReferences(references, availableResources) {
+  const resolvedRefs = references.map((ref) => ({ ...ref }));
+  for (const ref of resolvedRefs) {
+    switch (ref.type) {
+      case "uri": {
+        if (availableResources[ref.identifier]) {
+          ref.resourceUri = ref.identifier;
+        } else {
+          const uriMatchUri = findResourceByOriginalUri(
+            availableResources,
+            ref.identifier
+          );
+          if (uriMatchUri) ref.resourceUri = uriMatchUri;
+        }
+        break;
+      }
+      case "server-scoped": {
+        const serverScopedUri = findResourceByServerAndName(
+          availableResources,
+          ref.serverName,
+          ref.identifier
+        );
+        if (serverScopedUri) ref.resourceUri = serverScopedUri;
+        break;
+      }
+      case "name": {
+        const nameMatchUri = findResourceByName(availableResources, ref.identifier);
+        if (nameMatchUri) ref.resourceUri = nameMatchUri;
+        break;
+      }
+    }
+  }
+  return resolvedRefs;
+}
+function findResourceByOriginalUri(resources, uri) {
+  const normalizedUri = uri.trim().toLowerCase();
+  for (const [resourceUri, resource] of Object.entries(resources)) {
+    const originalUri = typeof resource.metadata?.originalUri === "string" ? resource.metadata.originalUri : void 0;
+    if (originalUri && originalUri.toLowerCase() === normalizedUri) {
+      return resourceUri;
+    }
+  }
+  for (const [resourceUri, resource] of Object.entries(resources)) {
+    const originalUri = typeof resource.metadata?.originalUri === "string" ? resource.metadata.originalUri : void 0;
+    if (originalUri && originalUri.toLowerCase().includes(normalizedUri)) {
+      return resourceUri;
+    }
+  }
+  return void 0;
+}
+function findResourceByServerAndName(resources, serverName, identifier) {
+  const normalizedIdentifier = identifier.trim().toLowerCase();
+  const matchingResources = Object.entries(resources).filter(
+    ([, resource]) => resource.serverName === serverName
+  );
+  for (const [uri, resource] of matchingResources) {
+    if (!resource.name) continue;
+    const normalizedName = resource.name.trim().toLowerCase();
+    if (normalizedName === normalizedIdentifier || normalizedName.includes(normalizedIdentifier)) {
+      return uri;
+    }
+  }
+  for (const [uri, resource] of matchingResources) {
+    const metadataUri = typeof resource.metadata?.originalUri === "string" ? resource.metadata.originalUri : void 0;
+    if (metadataUri?.toLowerCase().includes(normalizedIdentifier) || uri.toLowerCase().includes(normalizedIdentifier)) {
+      return uri;
+    }
+  }
+  return void 0;
+}
+function findResourceByName(resources, identifier) {
+  const normalizedIdentifier = identifier.trim().toLowerCase();
+  for (const [uri, resource] of Object.entries(resources)) {
+    if (!resource.name) continue;
+    const normalizedName = resource.name.trim().toLowerCase();
+    if (normalizedName === normalizedIdentifier || normalizedName.includes(normalizedIdentifier)) {
+      return uri;
+    }
+  }
+  for (const [uri, resource] of Object.entries(resources)) {
+    const originalUri = typeof resource.metadata?.originalUri === "string" ? resource.metadata.originalUri : void 0;
+    if (originalUri?.toLowerCase().includes(normalizedIdentifier) || uri.toLowerCase().includes(normalizedIdentifier)) {
+      return uri;
+    }
+  }
+  return void 0;
+}
+function formatResourceContent(resourceUri, resourceName, content) {
+  const contentParts = [];
+  contentParts.push(`
+--- Content from resource: ${resourceName} (${resourceUri}) ---`);
+  for (const item of content.contents) {
+    if (item.text && typeof item.text === "string") {
+      contentParts.push(item.text);
+    } else if (item.blob) {
+      const blobSize = typeof item.blob === "string" ? item.blob.length : "unknown";
+      contentParts.push(`[Binary content: ${item.mimeType || "unknown"}, ${blobSize} bytes]`);
+    }
+  }
+  contentParts.push("--- End of resource content ---\n");
+  return contentParts.join("\n");
+}
+async function expandMessageReferences(message, availableResources, resourceReader) {
+  const parsedRefs = parseResourceReferences(message);
+  if (parsedRefs.length === 0) {
+    return {
+      expandedMessage: message,
+      expandedReferences: [],
+      unresolvedReferences: [],
+      extractedImages: []
+    };
+  }
+  const resolvedRefs = resolveResourceReferences(parsedRefs, availableResources);
+  const expandedReferences = resolvedRefs.filter((ref) => ref.resourceUri);
+  const unresolvedReferences = resolvedRefs.filter((ref) => !ref.resourceUri);
+  let expandedMessage = message;
+  const failedRefs = [];
+  const extractedImages = [];
+  for (const ref of expandedReferences) {
+    try {
+      const content = await resourceReader(ref.resourceUri);
+      const resource = availableResources[ref.resourceUri];
+      let isImageResource = false;
+      for (const item of content.contents) {
+        if (item.blob && item.mimeType && item.mimeType.startsWith("image/") && typeof item.blob === "string") {
+          extractedImages.push({
+            image: item.blob,
+            mimeType: item.mimeType,
+            name: resource?.name || ref.identifier
+          });
+          isImageResource = true;
+          break;
+        }
+      }
+      if (isImageResource) {
+        const pattern = new RegExp(escapeRegExp(ref.originalRef), "g");
+        expandedMessage = expandedMessage.replace(pattern, " ").replace(/\s{2,}/g, " ").trim();
+      } else {
+        const formattedContent = formatResourceContent(
+          ref.resourceUri,
+          resource?.name || ref.identifier,
+          content
+        );
+        const pattern = new RegExp(escapeRegExp(ref.originalRef), "g");
+        expandedMessage = expandedMessage.replace(pattern, formattedContent);
+      }
+    } catch (_error) {
+      failedRefs.push(ref);
+    }
+  }
+  const failedRefSet = new Set(failedRefs);
+  const finalExpandedReferences = expandedReferences.filter((ref) => !failedRefSet.has(ref));
+  unresolvedReferences.push(...failedRefs);
+  return {
+    expandedMessage,
+    expandedReferences: finalExpandedReferences,
+    unresolvedReferences,
+    extractedImages
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  expandMessageReferences,
+  formatResourceContent,
+  parseResourceReferences,
+  resolveResourceReferences
+});

package/dist/resources/reference-parser.d.ts

@@ -0,0 +1,33 @@
+import type { ResourceSet } from './types.js';
+import type { ReadResourceResult } from '@modelcontextprotocol/sdk/types.js';
+export interface ResourceReference {
+    originalRef: string;
+    resourceUri?: string;
+    type: 'name' | 'uri' | 'server-scoped';
+    serverName?: string;
+    identifier: string;
+}
+export interface ResourceExpansionResult {
+    expandedMessage: string;
+    expandedReferences: ResourceReference[];
+    unresolvedReferences: ResourceReference[];
+    extractedImages: Array<{
+        image: string;
+        mimeType: string;
+        name: string;
+    }>;
+}
+/**
+ * Parse resource references from a message.
+ *
+ * @ symbols are only treated as resource references if they:
+ * 1. Are at the start of the message, OR
+ * 2. Are preceded by whitespace
+ *
+ * This means email addresses like "user@example.com" are NOT treated as references.
+ */
+export declare function parseResourceReferences(message: string): ResourceReference[];
+export declare function resolveResourceReferences(references: ResourceReference[], availableResources: ResourceSet): ResourceReference[];
+export declare function formatResourceContent(resourceUri: string, resourceName: string, content: ReadResourceResult): string;
+export declare function expandMessageReferences(message: string, availableResources: ResourceSet, resourceReader: (uri: string) => Promise<ReadResourceResult>): Promise<ResourceExpansionResult>;
+//# sourceMappingURL=reference-parser.d.ts.map

package/dist/resources/reference-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference-parser.d.ts","sourceRoot":"","sources":["../../src/resources/reference-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAK7E,MAAM,WAAW,iBAAiB;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,GAAG,KAAK,GAAG,eAAe,CAAC;IACvC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,uBAAuB;IACpC,eAAe,EAAE,MAAM,CAAC;IACxB,kBAAkB,EAAE,iBAAiB,EAAE,CAAC;IACxC,oBAAoB,EAAE,iBAAiB,EAAE,CAAC;IAC1C,eAAe,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC7E;AAMD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAuB5E;AAED,wBAAgB,yBAAyB,CACrC,UAAU,EAAE,iBAAiB,EAAE,EAC/B,kBAAkB,EAAE,WAAW,GAChC,iBAAiB,EAAE,CAmCrB;AAiGD,wBAAgB,qBAAqB,CACjC,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,kBAAkB,GAC5B,MAAM,CAaR;AAED,wBAAsB,uBAAuB,CACzC,OAAO,EAAE,MAAM,EACf,kBAAkB,EAAE,WAAW,EAC/B,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,kBAAkB,CAAC,GAC7D,OAAO,CAAC,uBAAuB,CAAC,CA8ElC"}

package/dist/resources/reference-parser.js

@@ -0,0 +1,191 @@
+import "../chunk-C6A6W6XS.js";
+function escapeRegExp(literal) {
+  return literal.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+}
+function parseResourceReferences(message) {
+  const references = [];
+  const regex = /(?:^|(?<=\s))@(?:(<[^>]+>)|([a-zA-Z0-9_-]+):([a-zA-Z0-9._/-]+)|([a-zA-Z0-9._/-]+))(?![a-zA-Z0-9@.])/g;
+  let match;
+  while ((match = regex.exec(message)) !== null) {
+    const [originalRef, uriWithBrackets, serverName, serverResource, simpleName] = match;
+    if (uriWithBrackets) {
+      references.push({ originalRef, type: "uri", identifier: uriWithBrackets.slice(1, -1) });
+    } else if (serverName && serverResource) {
+      references.push({
+        originalRef,
+        type: "server-scoped",
+        serverName,
+        identifier: serverResource
+      });
+    } else if (simpleName) {
+      references.push({ originalRef, type: "name", identifier: simpleName });
+    }
+  }
+  return references;
+}
+function resolveResourceReferences(references, availableResources) {
+  const resolvedRefs = references.map((ref) => ({ ...ref }));
+  for (const ref of resolvedRefs) {
+    switch (ref.type) {
+      case "uri": {
+        if (availableResources[ref.identifier]) {
+          ref.resourceUri = ref.identifier;
+        } else {
+          const uriMatchUri = findResourceByOriginalUri(
+            availableResources,
+            ref.identifier
+          );
+          if (uriMatchUri) ref.resourceUri = uriMatchUri;
+        }
+        break;
+      }
+      case "server-scoped": {
+        const serverScopedUri = findResourceByServerAndName(
+          availableResources,
+          ref.serverName,
+          ref.identifier
+        );
+        if (serverScopedUri) ref.resourceUri = serverScopedUri;
+        break;
+      }
+      case "name": {
+        const nameMatchUri = findResourceByName(availableResources, ref.identifier);
+        if (nameMatchUri) ref.resourceUri = nameMatchUri;
+        break;
+      }
+    }
+  }
+  return resolvedRefs;
+}
+function findResourceByOriginalUri(resources, uri) {
+  const normalizedUri = uri.trim().toLowerCase();
+  for (const [resourceUri, resource] of Object.entries(resources)) {
+    const originalUri = typeof resource.metadata?.originalUri === "string" ? resource.metadata.originalUri : void 0;
+    if (originalUri && originalUri.toLowerCase() === normalizedUri) {
+      return resourceUri;
+    }
+  }
+  for (const [resourceUri, resource] of Object.entries(resources)) {
+    const originalUri = typeof resource.metadata?.originalUri === "string" ? resource.metadata.originalUri : void 0;
+    if (originalUri && originalUri.toLowerCase().includes(normalizedUri)) {
+      return resourceUri;
+    }
+  }
+  return void 0;
+}
+function findResourceByServerAndName(resources, serverName, identifier) {
+  const normalizedIdentifier = identifier.trim().toLowerCase();
+  const matchingResources = Object.entries(resources).filter(
+    ([, resource]) => resource.serverName === serverName
+  );
+  for (const [uri, resource] of matchingResources) {
+    if (!resource.name) continue;
+    const normalizedName = resource.name.trim().toLowerCase();
+    if (normalizedName === normalizedIdentifier || normalizedName.includes(normalizedIdentifier)) {
+      return uri;
+    }
+  }
+  for (const [uri, resource] of matchingResources) {
+    const metadataUri = typeof resource.metadata?.originalUri === "string" ? resource.metadata.originalUri : void 0;
+    if (metadataUri?.toLowerCase().includes(normalizedIdentifier) || uri.toLowerCase().includes(normalizedIdentifier)) {
+      return uri;
+    }
+  }
+  return void 0;
+}
+function findResourceByName(resources, identifier) {
+  const normalizedIdentifier = identifier.trim().toLowerCase();
+  for (const [uri, resource] of Object.entries(resources)) {
+    if (!resource.name) continue;
+    const normalizedName = resource.name.trim().toLowerCase();
+    if (normalizedName === normalizedIdentifier || normalizedName.includes(normalizedIdentifier)) {
+      return uri;
+    }
+  }
+  for (const [uri, resource] of Object.entries(resources)) {
+    const originalUri = typeof resource.metadata?.originalUri === "string" ? resource.metadata.originalUri : void 0;
+    if (originalUri?.toLowerCase().includes(normalizedIdentifier) || uri.toLowerCase().includes(normalizedIdentifier)) {
+      return uri;
+    }
+  }
+  return void 0;
+}
+function formatResourceContent(resourceUri, resourceName, content) {
+  const contentParts = [];
+  contentParts.push(`
+--- Content from resource: ${resourceName} (${resourceUri}) ---`);
+  for (const item of content.contents) {
+    if (item.text && typeof item.text === "string") {
+      contentParts.push(item.text);
+    } else if (item.blob) {
+      const blobSize = typeof item.blob === "string" ? item.blob.length : "unknown";
+      contentParts.push(`[Binary content: ${item.mimeType || "unknown"}, ${blobSize} bytes]`);
+    }
+  }
+  contentParts.push("--- End of resource content ---\n");
+  return contentParts.join("\n");
+}
+async function expandMessageReferences(message, availableResources, resourceReader) {
+  const parsedRefs = parseResourceReferences(message);
+  if (parsedRefs.length === 0) {
+    return {
+      expandedMessage: message,
+      expandedReferences: [],
+      unresolvedReferences: [],
+      extractedImages: []
+    };
+  }
+  const resolvedRefs = resolveResourceReferences(parsedRefs, availableResources);
+  const expandedReferences = resolvedRefs.filter((ref) => ref.resourceUri);
+  const unresolvedReferences = resolvedRefs.filter((ref) => !ref.resourceUri);
+  let expandedMessage = message;
+  const failedRefs = [];
+  const extractedImages = [];
+  for (const ref of expandedReferences) {
+    try {
+      const content = await resourceReader(ref.resourceUri);
+      const resource = availableResources[ref.resourceUri];
+      let isImageResource = false;
+      for (const item of content.contents) {
+        if (item.blob && item.mimeType && item.mimeType.startsWith("image/") && typeof item.blob === "string") {
+          extractedImages.push({
+            image: item.blob,
+            mimeType: item.mimeType,
+            name: resource?.name || ref.identifier
+          });
+          isImageResource = true;
+          break;
+        }
+      }
+      if (isImageResource) {
+        const pattern = new RegExp(escapeRegExp(ref.originalRef), "g");
+        expandedMessage = expandedMessage.replace(pattern, " ").replace(/\s{2,}/g, " ").trim();
+      } else {
+        const formattedContent = formatResourceContent(
+          ref.resourceUri,
+          resource?.name || ref.identifier,
+          content
+        );
+        const pattern = new RegExp(escapeRegExp(ref.originalRef), "g");
+        expandedMessage = expandedMessage.replace(pattern, formattedContent);
+      }
+    } catch (_error) {
+      failedRefs.push(ref);
+    }
+  }
+  const failedRefSet = new Set(failedRefs);
+  const finalExpandedReferences = expandedReferences.filter((ref) => !failedRefSet.has(ref));
+  unresolvedReferences.push(...failedRefs);
+  return {
+    expandedMessage,
+    expandedReferences: finalExpandedReferences,
+    unresolvedReferences,
+    extractedImages
+  };
+}
+export {
+  expandMessageReferences,
+  formatResourceContent,
+  parseResourceReferences,
+  resolveResourceReferences
+};

package/dist/resources/schemas.cjs

@@ -0,0 +1,98 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schemas_exports = {};
+__export(schemas_exports, {
+  InternalResourceConfigSchema: () => InternalResourceConfigSchema,
+  InternalResourcesSchema: () => InternalResourcesSchema,
+  isInternalResourcesEnabled: () => isInternalResourcesEnabled
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_zod = require("zod");
+const FileExtensionSchema = import_zod.z.string().regex(
+  /^\.[A-Za-z0-9][A-Za-z0-9._-]*$/,
+  "Extensions must start with a dot and may include alphanumerics, dot, underscore, or hyphen (e.g., .d.ts, .tar.gz)"
+).describe("File extension pattern starting with a dot; supports multi-part extensions");
+const FileSystemResourceSchema = import_zod.z.object({
+  type: import_zod.z.literal("filesystem"),
+  paths: import_zod.z.array(import_zod.z.string()).min(1).describe("File paths or directories to expose as resources (at least one required)"),
+  maxDepth: import_zod.z.number().min(1).max(10).default(3).describe("Maximum directory depth to traverse (default: 3)"),
+  maxFiles: import_zod.z.number().min(1).max(1e4).default(1e3).describe("Maximum number of files to include (default: 1000)"),
+  includeHidden: import_zod.z.boolean().default(false).describe("Include hidden files and directories (default: false)"),
+  includeExtensions: import_zod.z.array(FileExtensionSchema).default([
+    ".txt",
+    ".md",
+    ".js",
+    ".ts",
+    ".json",
+    ".html",
+    ".css",
+    ".py",
+    ".yaml",
+    ".yml",
+    ".xml",
+    ".jsx",
+    ".tsx",
+    ".vue",
+    ".php",
+    ".rb",
+    ".go",
+    ".rs",
+    ".java",
+    ".kt",
+    ".swift",
+    ".sql",
+    ".sh",
+    ".bash",
+    ".zsh"
+  ]).describe("File extensions to include (default: common text files)")
+}).strict();
+const BlobResourceSchema = import_zod.z.object({
+  type: import_zod.z.literal("blob").describe("Enable blob storage resource provider")
+}).strict().describe(
+  "Blob resource provider configuration - actual storage settings are in storage.blob section"
+);
+const InternalResourceConfigSchema = import_zod.z.discriminatedUnion("type", [
+  FileSystemResourceSchema,
+  BlobResourceSchema
+]);
+const InternalResourcesSchema = import_zod.z.union([
+  import_zod.z.array(InternalResourceConfigSchema),
+  // array-only form
+  import_zod.z.object({
+    enabled: import_zod.z.boolean().optional().describe("Explicit toggle; auto-enabled when resources are non-empty"),
+    resources: import_zod.z.array(InternalResourceConfigSchema).default([]).describe("List of internal resource configurations")
+  }).strict()
+]).default([]).describe(
+  "Internal resource configuration. Can be an array of resources (auto-enabled) or object with enabled field"
+).transform((input) => {
+  if (Array.isArray(input)) {
+    return { enabled: input.length > 0, resources: input };
+  }
+  const enabled = input.enabled !== void 0 ? input.enabled : input.resources.length > 0;
+  return { enabled, resources: input.resources };
+});
+function isInternalResourcesEnabled(config) {
+  return config.enabled && config.resources.length > 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InternalResourceConfigSchema,
+  InternalResourcesSchema,
+  isInternalResourcesEnabled
+});