@introspection-ai/recipes 0.13.0 → 0.14.0

package/dist/mcp-chunks/chunk-4SQKWYFF.js

@@ -0,0 +1,15 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/version.js
+import { createRequire } from "node:module";
+var MCPORTER_VERSION = (() => {
+  try {
+    return createRequire(import.meta.url)("../package.json").version;
+  } catch {
+    return process.env.MCPORTER_VERSION ?? "0.0.0-dev";
+  }
+})();
+
+export {
+  MCPORTER_VERSION
+};

package/dist/mcp-chunks/chunk-5QOSCSQB.js

@@ -0,0 +1,290 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  analyzeConnectionError
+} from "./chunk-UKYNQGNE.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/result-utils.js
+function extractEnvelope(raw) {
+  return collectEnvelopeFields(raw, { content: null, structuredContent: null }, 0);
+}
+function collectEnvelopeFields(raw, envelope, depth) {
+  if (!raw || typeof raw !== "object") {
+    return envelope;
+  }
+  const obj = raw;
+  let { content, structuredContent } = envelope;
+  if (!content && "content" in obj && Array.isArray(obj.content)) {
+    content = obj.content;
+  }
+  if (structuredContent === null && "structuredContent" in obj) {
+    structuredContent = obj.structuredContent;
+  }
+  const updated = { content, structuredContent };
+  if (depth >= 2) {
+    return updated;
+  }
+  let nested = updated;
+  if ("raw" in obj) {
+    nested = collectEnvelopeFields(obj.raw, nested, depth + 1);
+  }
+  if ("result" in obj) {
+    nested = collectEnvelopeFields(obj.result, nested, depth + 1);
+  }
+  return nested;
+}
+function asString(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value && typeof value === "object" && "text" in value) {
+    const text = value.text;
+    return typeof text === "string" ? text : null;
+  }
+  return null;
+}
+function collectCallContent(raw) {
+  const envelope = extractEnvelope(raw);
+  const textEntries = [];
+  const markdownEntries = [];
+  const jsonCandidates = [];
+  const images = [];
+  const rawContents = raw && typeof raw === "object" && Array.isArray(raw.contents) ? raw.contents ?? [] : void 0;
+  if (rawContents) {
+    for (const resource of rawContents) {
+      collectResourcePayload(resource, textEntries, markdownEntries, jsonCandidates);
+    }
+  }
+  if (!envelope.content) {
+    return {
+      content: envelope.content,
+      structuredContent: envelope.structuredContent,
+      textEntries,
+      markdownEntries,
+      jsonCandidates,
+      images
+    };
+  }
+  for (const entry of envelope.content) {
+    if (typeof entry === "string") {
+      const parsed2 = tryParseJson(entry);
+      if (parsed2 !== null) {
+        jsonCandidates.push(parsed2);
+      }
+      continue;
+    }
+    if (!entry || typeof entry !== "object" || !("type" in entry)) {
+      continue;
+    }
+    const typedEntry = entry;
+    if (typedEntry.type === "json") {
+      const parsed2 = tryParseJson(entry);
+      if (parsed2 !== null) {
+        jsonCandidates.push(parsed2);
+      }
+      continue;
+    }
+    if (typedEntry.type === "image") {
+      const data = typedEntry.data;
+      const mimeType = typedEntry.mimeType ?? "image/png";
+      if (typeof data === "string" && typeof mimeType === "string") {
+        images.push({ data, mimeType });
+      }
+      continue;
+    }
+    if (typedEntry.type === "resource") {
+      const resource = typedEntry.resource;
+      collectResourcePayload(resource, textEntries, markdownEntries, jsonCandidates);
+      continue;
+    }
+    if (typedEntry.type !== "text" && typedEntry.type !== "markdown") {
+      continue;
+    }
+    const text = asString(entry);
+    if (!text) {
+      continue;
+    }
+    textEntries.push(text);
+    if (typedEntry.type === "markdown") {
+      markdownEntries.push(text);
+    }
+    const parsed = tryParseJson(text);
+    if (parsed !== null) {
+      jsonCandidates.push(parsed);
+    }
+  }
+  return {
+    content: envelope.content,
+    structuredContent: envelope.structuredContent,
+    textEntries,
+    markdownEntries,
+    jsonCandidates,
+    images
+  };
+}
+function collectResourcePayload(resource, textEntries, markdownEntries, jsonCandidates) {
+  if (!resource || typeof resource !== "object") {
+    return;
+  }
+  const record = resource;
+  const uri = typeof record.uri === "string" ? record.uri : "";
+  const mimeType = typeof record.mimeType === "string" ? record.mimeType : "";
+  if (typeof record.text === "string") {
+    textEntries.push(record.text);
+    if (mimeType.toLowerCase().includes("markdown")) {
+      markdownEntries.push(record.text);
+    }
+    const parsed = tryParseJson(record.text);
+    if (parsed !== null) {
+      jsonCandidates.push(parsed);
+    }
+  } else if (typeof record.blob === "string") {
+    textEntries.push(`[Binary resource: ${uri}]`);
+  }
+}
+function collectText(entries, joiner) {
+  if (entries.length === 0) {
+    return null;
+  }
+  return entries.join(joiner);
+}
+function collectImages(images) {
+  if (images.length === 0) {
+    return null;
+  }
+  return images;
+}
+function unwrapJsonEnvelope(record, fallback) {
+  if ("json" in record) {
+    return record.json ?? null;
+  }
+  if ("data" in record) {
+    return Object.keys(record).length === 1 ? record.data ?? null : fallback;
+  }
+  return null;
+}
+function parseStructuredContent(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (typeof value === "string") {
+    return tryParseJson(value);
+  }
+  if (typeof value !== "object") {
+    return null;
+  }
+  const unwrapped = unwrapJsonEnvelope(value, value);
+  return unwrapped ?? value;
+}
+function tryParseJson(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (typeof value === "object") {
+    const unwrapped = unwrapJsonEnvelope(value, value);
+    if (unwrapped !== null) {
+      return unwrapped;
+    }
+  }
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function createCallResult(raw) {
+  let cachedContent;
+  const getCollectedContent = () => {
+    if (cachedContent) {
+      return cachedContent;
+    }
+    cachedContent = collectCallContent(raw);
+    return cachedContent;
+  };
+  return {
+    raw,
+    text(joiner = "\n") {
+      if (raw == null) {
+        return null;
+      }
+      if (typeof raw === "string") {
+        return raw;
+      }
+      const collected = getCollectedContent();
+      const combinedText = collectText(collected.textEntries, joiner);
+      if (combinedText) {
+        return combinedText;
+      }
+      return asString(collected.structuredContent);
+    },
+    markdown(joiner = "\n") {
+      const collected = getCollectedContent();
+      const structured = collected.structuredContent;
+      if (structured && typeof structured === "object") {
+        const markdown = structured.markdown;
+        if (typeof markdown === "string") {
+          return markdown;
+        }
+      }
+      return collectText(collected.markdownEntries, joiner);
+    },
+    json() {
+      const collected = getCollectedContent();
+      const parsedStructured = parseStructuredContent(collected.structuredContent);
+      if (parsedStructured !== null) {
+        return parsedStructured;
+      }
+      if (collected.jsonCandidates.length === 1) {
+        return collected.jsonCandidates[0];
+      }
+      if (collected.jsonCandidates.length > 1) {
+        return collected.jsonCandidates;
+      }
+      if (typeof raw === "string") {
+        const parsedRaw = tryParseJson(raw);
+        if (parsedRaw !== null) {
+          return parsedRaw;
+        }
+      }
+      const textContent = this.text?.();
+      if (typeof textContent === "string") {
+        const parsedText = tryParseJson(textContent);
+        if (parsedText !== null) {
+          return parsedText;
+        }
+      }
+      const markdownContent = this.markdown?.();
+      if (typeof markdownContent === "string") {
+        const parsedMarkdown = tryParseJson(markdownContent);
+        if (parsedMarkdown !== null) {
+          return parsedMarkdown;
+        }
+      }
+      return null;
+    },
+    images() {
+      const collected = getCollectedContent();
+      return collectImages(collected.images);
+    },
+    content() {
+      return getCollectedContent().content;
+    },
+    structuredContent() {
+      return getCollectedContent().structuredContent;
+    }
+  };
+}
+function describeConnectionIssue(error) {
+  return analyzeConnectionError(error);
+}
+function wrapCallResult(raw) {
+  return { raw, callResult: createCallResult(raw) };
+}
+
+export {
+  createCallResult,
+  describeConnectionIssue,
+  wrapCallResult
+};

package/dist/mcp-chunks/chunk-6W5QFASN.js

@@ -0,0 +1,77 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/logging.js
+var LOG_LEVEL_ORDER = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+var LOG_LEVEL_ALIASES = {
+  warning: "warn",
+  verbose: "debug"
+};
+function parseLogLevel(value, defaultLevel = "warn") {
+  if (!value) {
+    return defaultLevel;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) {
+    return defaultLevel;
+  }
+  const alias = LOG_LEVEL_ALIASES[normalized];
+  const candidate = alias ?? (normalized in LOG_LEVEL_ORDER ? normalized : void 0);
+  if (!candidate) {
+    const allowed = [...Object.keys(LOG_LEVEL_ORDER), ...Object.keys(LOG_LEVEL_ALIASES)].filter((key, index, array) => array.indexOf(key) === index).join(", ");
+    throw new Error(`Invalid log level '${value}'. Expected one of: ${allowed}.`);
+  }
+  return candidate;
+}
+function resolveLogLevelFromEnv(env = process.env, defaultLevel = "warn") {
+  try {
+    return parseLogLevel(env.MCPORTER_LOG_LEVEL, defaultLevel);
+  } catch (error) {
+    const raw = env.MCPORTER_LOG_LEVEL;
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[mcporter] Ignoring invalid MCPORTER_LOG_LEVEL value '${raw ?? ""}': ${message}`);
+    return defaultLevel;
+  }
+}
+function shouldLog(level, threshold) {
+  return LOG_LEVEL_ORDER[level] >= LOG_LEVEL_ORDER[threshold];
+}
+function createPrefixedConsoleLogger(prefix, level) {
+  const threshold = parseLogLevel(level);
+  const format = (message) => `[${prefix}] ${message}`;
+  return {
+    debug(message) {
+      if (shouldLog("debug", threshold)) {
+        console.debug(format(message));
+      }
+    },
+    info(message) {
+      if (shouldLog("info", threshold)) {
+        console.log(format(message));
+      }
+    },
+    warn(message) {
+      if (shouldLog("warn", threshold)) {
+        console.warn(format(message));
+      }
+    },
+    error(message, error) {
+      if (shouldLog("error", threshold)) {
+        console.error(format(message));
+        if (error) {
+          console.error(error);
+        }
+      }
+    }
+  };
+}
+
+export {
+  parseLogLevel,
+  resolveLogLevelFromEnv,
+  createPrefixedConsoleLogger
+};