artifacty 0.1.2 → 0.2.0

package/src/lib/converters.js

@@ -2,7 +2,8 @@ import path from "node:path";
 import { createHash } from "node:crypto";
 import { ARTIFACT_TYPES, contentTypeForFormat, normalizeFormat } from "./storage.js";
 
-const KNOWN_AGENTS = new Set(["auto", "artifacty", "claude", "codex", "gemini", "generic"]);
+const CONTINUATION_AGENTS = new Set(["codex", "copilot", "cursor"]);
+const KNOWN_AGENTS = new Set(["auto", "artifacty", "claude", "codex", "copilot", "cursor", "gemini", "generic"]);
 
 export function convertAgentArtifact(input = {}) {
   const originalAgent = normalizeAgent(input.agent || input.sourceAgent || input.source_agent || "auto");
@@ -12,12 +13,21 @@ export function convertAgentArtifact(input = {}) {
   const sourcePath = optionalString(input.sourcePath || input.path || input.file);
   const fileName = optionalString(input.fileName || input.filename || (sourcePath ? path.basename(sourcePath) : ""));
   const explicitContentType = optionalString(input.contentType || input.mimeType || input.mime_type);
-  const content = String(decoded.content ?? input.content ?? payload ?? "");
+  let content = String(decoded.content ?? input.content ?? payload ?? "");
   const format = normalizeFormat(
     input.format ||
       decoded.format ||
       detectFormat({ content, contentType: explicitContentType || decoded.contentType, fileName })
   );
+  const media = normalizeMediaContent({
+    content,
+    format,
+    contentType: explicitContentType || decoded.contentType,
+    fileName
+  });
+  if (media) {
+    content = media.content;
+  }
   const sourceAgent = optionalString(input.sourceAgent || input.source_agent || decoded.sourceAgent) ||
     (originalAgent === "auto" ? detectAgent(parsed, fileName) : originalAgent);
 
@@ -26,7 +36,7 @@ export function convertAgentArtifact(input = {}) {
     optionalString(decoded.title) ||
     inferTitle({ content, format, fileName, sourceAgent });
 
-  const contentType = explicitContentType || decoded.contentType || contentTypeForFormat(format);
+  const contentType = explicitContentType || decoded.contentType || media?.mimeType || contentTypeForFormat(format);
   const artifactType = normalizeArtifactType(
     input.artifactType ||
       input.artifact_type ||
@@ -52,6 +62,7 @@ export function convertAgentArtifact(input = {}) {
     metadata: {
       ...normalizeMetadata(decoded.metadata),
       ...normalizeMetadata(input.metadata),
+      ...mediaMetadata(media),
       artifactyImport: {
         converter: "agent-artifact-v1",
         originalAgent,
@@ -71,9 +82,21 @@ export function detectFormat({ content = "", contentType = "", fileName = "" } =
   if (type.includes("vnd.ant.code") || type.includes("source-code")) {
     return "code";
   }
+  if (type.includes("sarif")) {
+    return "sarif";
+  }
+  if (type.includes("csv")) {
+    return "csv";
+  }
   if (type.includes("svg")) {
     return "svg";
   }
+  if (isSupportedImageMime(type)) {
+    return "image";
+  }
+  if (isSupportedVideoMime(type)) {
+    return "video";
+  }
   if (type.includes("vnd.ant.mermaid") || type.includes("mermaid")) {
     return "mermaid";
   }
@@ -93,7 +116,21 @@ export function detectFormat({ content = "", contentType = "", fileName = "" } =
     return "text";
   }
 
-  const extension = path.extname(fileName).toLowerCase();
+  const lowerName = optionalString(fileName).toLowerCase();
+  if (lowerName.endsWith(".sarif") || lowerName.endsWith(".sarif.json")) {
+    return "sarif";
+  }
+  if (lowerName.endsWith(".csv")) {
+    return "csv";
+  }
+  if (isImageFileName(lowerName)) {
+    return "image";
+  }
+  if (isVideoFileName(lowerName)) {
+    return "video";
+  }
+
+  const extension = path.extname(lowerName);
   if (extension === ".html" || extension === ".htm") {
     return "html";
   }
@@ -129,12 +166,24 @@ export function detectFormat({ content = "", contentType = "", fileName = "" } =
   if (looksLikeReact(trimmed)) {
     return "react";
   }
+  if (looksLikeMediaDataUrl(trimmed, "image")) {
+    return "image";
+  }
+  if (looksLikeMediaDataUrl(trimmed, "video")) {
+    return "video";
+  }
   if (/^<!doctype html/i.test(trimmed) || /^<html[\s>]/i.test(trimmed)) {
     return "html";
   }
+  if (looksLikeSarif(trimmed)) {
+    return "sarif";
+  }
   if (looksLikeJson(trimmed)) {
     return "json";
   }
+  if (looksLikeCsv(trimmed)) {
+    return "csv";
+  }
   if (/^#{1,3}\s+\S/m.test(trimmed) || /^[-*]\s+\S/m.test(trimmed)) {
     return "markdown";
   }
@@ -160,13 +209,28 @@ function decodePayload(parsed, agent) {
 function decodeObjectPayload(value, agent) {
   const artifactObject = value.artifact && typeof value.artifact === "object" ? value.artifact : value;
 
-  if (Array.isArray(artifactObject.files) || artifactObject.bundle) {
+  if (Array.isArray(artifactObject.files) || Array.isArray(artifactObject.assets) || Array.isArray(artifactObject.media) || Array.isArray(artifactObject.attachments) || artifactObject.bundle) {
     return decodeBundlePayload(artifactObject, agent);
   }
 
-  const codexContinuation = decodeCodexContinuationPayload(artifactObject, agent);
-  if (codexContinuation) {
-    return codexContinuation;
+  const continuation = decodeContinuationPayload(artifactObject, agent);
+  if (continuation) {
+    return continuation;
+  }
+
+  if (isSarifObject(artifactObject)) {
+    return {
+      content: JSON.stringify(artifactObject, null, 2),
+      format: "sarif",
+      contentType: "application/sarif+json; charset=utf-8",
+      title: artifactObject.title || artifactObject.name || "SARIF report",
+      sourceAgent: artifactObject.sourceAgent || artifactObject.source_agent || artifactObject.agent || (agent === "auto" ? undefined : agent),
+      artifactType: artifactObject.artifactType || artifactObject.artifact_type || "analysis-report",
+      tags: artifactObject.tags,
+      metadata: {
+        originalPayloadShape: "sarif"
+      }
+    };
   }
 
   if (typeof artifactObject.content === "string" && !Array.isArray(artifactObject.content)) {
@@ -208,6 +272,22 @@ function decodeObjectPayload(value, agent) {
     return objectContent(artifactObject, "react", artifactObject.react || artifactObject.jsx, "react");
   }
 
+  if (artifactObject.image !== undefined || artifactObject.screenshot !== undefined) {
+    return mediaObjectContent(artifactObject, "image", artifactObject.image ?? artifactObject.screenshot);
+  }
+
+  if (artifactObject.video !== undefined || artifactObject.recording !== undefined || artifactObject.demo !== undefined) {
+    return mediaObjectContent(artifactObject, "video", artifactObject.video ?? artifactObject.recording ?? artifactObject.demo);
+  }
+
+  if (typeof artifactObject.sarif === "string") {
+    return objectContent(artifactObject, "sarif", artifactObject.sarif, "sarif");
+  }
+
+  if (typeof artifactObject.csv === "string") {
+    return objectContent(artifactObject, "csv", artifactObject.csv, "csv");
+  }
+
   if (typeof artifactObject.html === "string") {
     return objectContent(artifactObject, "html", artifactObject.html, "html");
   }
@@ -312,10 +392,38 @@ function objectContent(object, shape, content, format) {
   };
 }
 
+function mediaObjectContent(object, format, mediaValue) {
+  const sourceContentType = object.contentType || object.content_type || object.mimeType || object.mime_type || object.type;
+  const content = typeof mediaValue === "string"
+    ? mediaValue
+    : optionalString(mediaValue?.data || mediaValue?.base64 || mediaValue?.content || mediaValue?.url);
+  const contentType = optionalString(mediaValue?.mimeType || mediaValue?.mime_type || sourceContentType);
+  return {
+    content,
+    format,
+    contentType,
+    title: object.title || object.name,
+    sourceAgent: object.sourceAgent || object.source_agent || object.agent,
+    artifactType: object.artifactType || object.artifact_type || "asset",
+    tags: object.tags,
+    metadata: {
+      originalPayloadShape: format,
+      originalId: object.id,
+      originalContentType: sourceContentType || contentType
+    }
+  };
+}
+
 function decodeBundlePayload(object, agent) {
   const bundle = object.bundle && typeof object.bundle === "object" ? object.bundle : object;
   const files = Array.isArray(bundle.files) ? bundle.files : [];
-  const codexMetadata = collectCodexContinuationMetadata({ agent }, bundle, object);
+  const assets = normalizeBundleAssets(firstPresent(bundle.assets, bundle.media, bundle.attachments));
+  const parts = normalizeBundleParts(bundle.parts, assets, optionalString(bundle.summary || object.summary || bundle.text));
+  const sourceAgent = object.sourceAgent || object.source_agent || object.agent || agent;
+  const continuationAgent = detectContinuationAgent({ agent: sourceAgent }, "auto");
+  const continuationMetadata = continuationAgent
+    ? collectContinuationMetadata(continuationAgent, { agent: sourceAgent }, bundle, object)
+    : {};
   const normalizedFiles = files.map((file, index) => {
     const content = typeof file.content === "string" ? file.content : "";
     return {
@@ -335,8 +443,11 @@ function decodeBundlePayload(object, agent) {
       schemaVersion: 1,
       artifactType: "bundle",
       title: object.title || bundle.title || "Artifact bundle",
+      text: optionalString(bundle.text || bundle.summary || object.summary),
+      parts,
+      assets,
       files: normalizedFiles,
-      ...bundleDocumentMetadata(codexMetadata)
+      ...bundleDocumentMetadata(continuationMetadata)
     }, null, 2),
     format: "json",
     contentType: "application/vnd.artifacty.bundle+json; charset=utf-8",
@@ -347,37 +458,83 @@ function decodeBundlePayload(object, agent) {
     metadata: {
       originalPayloadShape: "artifact-bundle",
       fileCount: normalizedFiles.length,
+      assetCount: assets.length,
       bundlePolicy: "text-files-stored-inline-in-bundle-json",
-      ...codexMetadata
+      assetPolicy: assets.length > 0 ? "base64-assets-stored-inline-in-bundle-json" : undefined,
+      ...continuationMetadata
     }
   };
 }
 
-function decodeCodexContinuationPayload(object, agent) {
-  if (!isCodexPayload(object, agent) || hasDirectContentField(object)) {
+function normalizeBundleAssets(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((asset, index) => {
+    if (!asset || typeof asset !== "object") {
+      return null;
+    }
+    const rawData = optionalString(asset.data || asset.base64 || asset.content || asset.url);
+    const dataUrl = parseDataUrl(rawData);
+    const mimeType = dataUrl?.mimeType ||
+      mediaMimeTypeFromContentType(asset.mimeType || asset.mime_type || asset.contentType || asset.content_type || asset.type, "image") ||
+      mediaMimeTypeFromContentType(asset.mimeType || asset.mime_type || asset.contentType || asset.content_type || asset.type, "video") ||
+      mediaMimeTypeFromFileName(asset.fileName || asset.filename || asset.name || asset.path) ||
+      "application/octet-stream";
+    const data = dataUrl?.base64 || normalizeBase64(rawData);
+    if (!data) {
+      return null;
+    }
+    return pruneEmpty({
+      id: optionalString(asset.id) || `asset-${index + 1}`,
+      name: optionalString(asset.name || asset.fileName || asset.filename || asset.path),
+      role: optionalString(asset.role || asset.kind || asset.type),
+      mimeType,
+      encoding: "base64",
+      data,
+      sizeBytes: Buffer.byteLength(data, "base64"),
+      sha256: createHash("sha256").update(Buffer.from(data, "base64")).digest("hex"),
+      caption: optionalString(asset.caption || asset.alt || asset.description)
+    });
+  }).filter(Boolean);
+}
+
+function normalizeBundleParts(value, assets, text) {
+  if (Array.isArray(value) && value.length > 0) {
+    return value;
+  }
+  return [
+    text ? { type: "text", text } : null,
+    ...assets.map((asset) => ({ type: "asset-ref", assetId: asset.id, mimeType: asset.mimeType }))
+  ].filter(Boolean);
+}
+
+function decodeContinuationPayload(object, agent) {
+  const sourceAgent = detectContinuationAgent(object, agent);
+  if (!sourceAgent || hasDirectContentField(object)) {
     return null;
   }
 
-  const artifactType = inferCodexContinuationType(object);
+  const artifactType = inferContinuationType(object);
   if (!artifactType) {
     return null;
   }
 
-  const metadata = collectCodexContinuationMetadata({ agent }, object);
+  const metadata = collectContinuationMetadata(sourceAgent, { agent }, object);
   return {
-    content: renderCodexContinuationMarkdown(object, artifactType, metadata),
+    content: renderContinuationMarkdown(sourceAgent, object, artifactType, metadata),
     format: "markdown",
     contentType: "text/markdown; charset=utf-8",
-    title: object.title || object.name || titleForCodexType(artifactType),
-    sourceAgent: "codex",
+    title: object.title || object.name || titleForContinuationType(sourceAgent, artifactType),
+    sourceAgent,
     artifactType,
     tags: uniqueStrings([
       artifactType,
-      "codex",
+      sourceAgent,
       ...normalizeTags(object.tags)
     ]),
     metadata: {
-      originalPayloadShape: "codex-continuation",
+      originalPayloadShape: `${sourceAgent}-continuation`,
       continuationKind: artifactType,
       ...metadata
     }
@@ -394,10 +551,17 @@ function hasDirectContentField(object) {
     typeof object.svg === "string" ||
     typeof object.mermaid === "string" ||
     typeof object.react === "string" ||
-    typeof object.jsx === "string";
+    typeof object.jsx === "string" ||
+    typeof object.sarif === "string" ||
+    typeof object.csv === "string" ||
+    object.image !== undefined ||
+    object.screenshot !== undefined ||
+    object.video !== undefined ||
+    object.recording !== undefined ||
+    object.demo !== undefined;
 }
 
-function isCodexPayload(object, agent) {
+function detectContinuationAgent(object, agent) {
   const explicit = normalizeAgent(
     object.sourceAgent ||
       object.source_agent ||
@@ -407,10 +571,10 @@ function isCodexPayload(object, agent) {
       object.created_by ||
       agent
   );
-  return explicit === "codex";
+  return CONTINUATION_AGENTS.has(explicit) ? explicit : "";
 }
 
-function inferCodexContinuationType(object) {
+function inferContinuationType(object) {
   const explicit = optionalString(object.artifactType || object.artifact_type || object.kind || object.category || object.purpose || object.type).toLowerCase();
   if (explicit.includes("review")) {
     return "code-review";
@@ -449,11 +613,8 @@ function inferCodexContinuationType(object) {
   return null;
 }
 
-function collectCodexContinuationMetadata(...sources) {
+function collectContinuationMetadata(sourceAgent, ...sources) {
   const objects = sources.filter((item) => item && typeof item === "object");
-  if (!objects.some((item) => isCodexPayload(item, "auto"))) {
-    return {};
-  }
   const source = Object.assign({}, ...objects);
   const continuation = pruneEmpty({
     summary: optionalString(source.summary),
@@ -471,21 +632,36 @@ function collectCodexContinuationMetadata(...sources) {
     residualRisk: optionalString(source.residualRisk || source.residual_risk)
   });
 
-  return Object.keys(continuation).length > 0
-    ? { codexContinuation: continuation }
-    : {};
+  if (Object.keys(continuation).length === 0) {
+    return {};
+  }
+
+  const metadata = { continuation };
+  metadata[`${sourceAgent}Continuation`] = continuation;
+  return metadata;
 }
 
 function bundleDocumentMetadata(metadata) {
-  return metadata.codexContinuation
-    ? { codexContinuation: metadata.codexContinuation }
-    : {};
+  const result = {};
+  if (metadata.continuation) {
+    result.continuation = metadata.continuation;
+  }
+  if (metadata.codexContinuation) {
+    result.codexContinuation = metadata.codexContinuation;
+  }
+  if (metadata.copilotContinuation) {
+    result.copilotContinuation = metadata.copilotContinuation;
+  }
+  if (metadata.cursorContinuation) {
+    result.cursorContinuation = metadata.cursorContinuation;
+  }
+  return result;
 }
 
-function renderCodexContinuationMarkdown(object, artifactType, metadata) {
-  const continuation = metadata.codexContinuation || {};
-  const title = object.title || object.name || titleForCodexType(artifactType);
-  const lines = [`# ${title}`, "", `Source: Codex`, `Artifact type: ${artifactType}`, ""];
+function renderContinuationMarkdown(sourceAgent, object, artifactType, metadata) {
+  const continuation = metadata.continuation || metadata[`${sourceAgent}Continuation`] || {};
+  const title = object.title || object.name || titleForContinuationType(sourceAgent, artifactType);
+  const lines = [`# ${title}`, "", `Source: ${displayAgentName(sourceAgent)}`, `Artifact type: ${artifactType}`, ""];
 
   addTextSection(lines, "Summary", continuation.summary);
   addTextSection(lines, "Goal", continuation.goal);
@@ -507,17 +683,31 @@ function renderCodexContinuationMarkdown(object, artifactType, metadata) {
   return lines.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
 }
 
-function titleForCodexType(artifactType) {
+function titleForContinuationType(sourceAgent, artifactType) {
+  const displayName = displayAgentName(sourceAgent);
   if (artifactType === "code-review") {
-    return "Codex Code Review";
+    return `${displayName} Code Review`;
   }
   if (artifactType === "test-report") {
-    return "Codex Verification Report";
+    return `${displayName} Verification Report`;
   }
   if (artifactType === "diff-walkthrough") {
-    return "Codex Diff Walkthrough";
+    return `${displayName} Diff Walkthrough`;
+  }
+  return `${displayName} Handoff`;
+}
+
+function displayAgentName(sourceAgent) {
+  if (sourceAgent === "copilot") {
+    return "GitHub Copilot";
   }
-  return "Codex Handoff";
+  if (sourceAgent === "cursor") {
+    return "Cursor";
+  }
+  if (sourceAgent === "codex") {
+    return "Codex";
+  }
+  return sourceAgent || "Agent";
 }
 
 function addTextSection(lines, title, value) {
@@ -683,6 +873,12 @@ function detectAgent(parsed, fileName) {
   if (lowerName.includes("codex")) {
     return "codex";
   }
+  if (lowerName.includes("copilot")) {
+    return "copilot";
+  }
+  if (lowerName.includes("cursor")) {
+    return "cursor";
+  }
   return "generic";
 }
 
@@ -706,6 +902,18 @@ function safeFormat(value) {
   if (normalized === "code" || normalized.includes("vnd.ant.code") || normalized.includes("source-code")) {
     return "code";
   }
+  if (normalized === "sarif" || normalized.includes("sarif")) {
+    return "sarif";
+  }
+  if (normalized === "csv" || normalized.includes("csv")) {
+    return "csv";
+  }
+  if (isSupportedImageMime(normalized) || normalized === "image") {
+    return "image";
+  }
+  if (isSupportedVideoMime(normalized) || normalized === "video") {
+    return "video";
+  }
   if (normalized === "html" || normalized.includes("html")) {
     return "html";
   }
@@ -859,7 +1067,7 @@ function createBundleDocument({ title, text, assets, parts }) {
   };
 }
 
-function inferArtifactType({ format, fileName, metadata }) {
+function inferArtifactType({ format, content, fileName, metadata }) {
   if (metadata?.originalPayloadShape === "artifact-bundle") {
     return "bundle";
   }
@@ -875,6 +1083,18 @@ function inferArtifactType({ format, fileName, metadata }) {
   if (format === "code") {
     return "snippet";
   }
+  if (format === "sarif") {
+    return "analysis-report";
+  }
+  if (format === "csv") {
+    return looksLikeAnalysisCsv(content) ||
+      /findings?|security|review|scan/i.test(optionalString(fileName))
+      ? "analysis-report"
+      : "table";
+  }
+  if (format === "image" || format === "video") {
+    return "asset";
+  }
   const lowerName = optionalString(fileName).toLowerCase();
   if (lowerName.includes("handoff")) {
     return "handoff";
@@ -888,6 +1108,14 @@ function inferArtifactType({ format, fileName, metadata }) {
   return "document";
 }
 
+function looksLikeAnalysisCsv(content) {
+  const [header = ""] = optionalString(content).split(/\r?\n/, 1);
+  const normalized = header.toLowerCase();
+  return normalized.includes("severity") &&
+    (normalized.includes("message") || normalized.includes("description")) &&
+    (normalized.includes("file") || normalized.includes("path") || normalized.includes("rule"));
+}
+
 function normalizeArtifactType(value) {
   const normalized = optionalString(value).toLowerCase();
   if (!normalized) {
@@ -928,6 +1156,157 @@ function looksLikeJson(value) {
     (trimmed.startsWith("[") && trimmed.endsWith("]"));
 }
 
+function looksLikeSarif(value) {
+  if (!looksLikeJson(value)) {
+    return false;
+  }
+  try {
+    return isSarifObject(JSON.parse(optionalString(value)));
+  } catch {
+    return false;
+  }
+}
+
+function isSarifObject(value) {
+  return value &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    Array.isArray(value.runs) &&
+    (typeof value.version === "string" || optionalString(value.$schema).toLowerCase().includes("sarif"));
+}
+
+function looksLikeCsv(value) {
+  const lines = optionalString(value)
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd())
+    .filter(Boolean)
+    .slice(0, 5);
+  if (lines.length < 2 || lines[0].trimStart().startsWith("|")) {
+    return false;
+  }
+  const counts = lines.map(csvFieldCount);
+  return counts[0] > 1 && counts.every((count) => count === counts[0]);
+}
+
+function csvFieldCount(line) {
+  let count = 1;
+  let inQuotes = false;
+  for (let index = 0; index < line.length; index += 1) {
+    const char = line[index];
+    if (char === "\"") {
+      if (inQuotes && line[index + 1] === "\"") {
+        index += 1;
+      } else {
+        inQuotes = !inQuotes;
+      }
+    } else if (char === "," && !inQuotes) {
+      count += 1;
+    }
+  }
+  return count;
+}
+
+function looksLikeMediaDataUrl(value, kind) {
+  const match = /^data:([^;,]+);base64,/i.exec(optionalString(value));
+  if (!match) {
+    return false;
+  }
+  const mimeType = match[1].toLowerCase();
+  return kind === "image" ? isSupportedImageMime(mimeType) : isSupportedVideoMime(mimeType);
+}
+
+function normalizeMediaContent({ content, format, contentType, fileName }) {
+  if (format !== "image" && format !== "video") {
+    return null;
+  }
+  const dataUrl = parseDataUrl(content);
+  const mimeType = dataUrl?.mimeType ||
+    mediaMimeTypeFromContentType(contentType, format) ||
+    mediaMimeTypeFromFileName(fileName) ||
+    "";
+  const normalized = dataUrl?.base64 || normalizeBase64(content);
+  if (!normalized) {
+    return null;
+  }
+  return {
+    content: normalized,
+    mimeType,
+    encoding: "base64",
+    originalEncoding: dataUrl ? "data-url" : "base64"
+  };
+}
+
+function mediaMetadata(media) {
+  if (!media) {
+    return {};
+  }
+  return {
+    mimeType: media.mimeType || undefined,
+    encoding: media.encoding,
+    mediaPolicy: "base64-media-stored-inline; /raw decodes bytes for preview and download",
+    originalEncoding: media.originalEncoding
+  };
+}
+
+function parseDataUrl(value) {
+  const match = /^data:([^;,]+);base64,([A-Za-z0-9+/=_-]+)$/i.exec(optionalString(value).replace(/\s+/g, ""));
+  if (!match) {
+    return null;
+  }
+  return {
+    mimeType: match[1].toLowerCase(),
+    base64: normalizeBase64(match[2])
+  };
+}
+
+function normalizeBase64(value) {
+  const normalized = optionalString(value).replace(/\s+/g, "").replaceAll("-", "+").replaceAll("_", "/");
+  if (!normalized || !/^[A-Za-z0-9+/]+={0,2}$/.test(normalized)) {
+    return "";
+  }
+  return normalized;
+}
+
+function mediaMimeTypeFromContentType(contentType, format) {
+  const normalized = optionalString(contentType).toLowerCase().split(";")[0];
+  if (format === "image" && isSupportedImageMime(normalized)) {
+    return normalized;
+  }
+  if (format === "video" && isSupportedVideoMime(normalized)) {
+    return normalized;
+  }
+  return "";
+}
+
+function mediaMimeTypeFromFileName(fileName) {
+  const extension = path.extname(optionalString(fileName).toLowerCase());
+  return {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm"
+  }[extension] || "";
+}
+
+function isImageFileName(fileName) {
+  return isSupportedImageMime(mediaMimeTypeFromFileName(fileName));
+}
+
+function isVideoFileName(fileName) {
+  return isSupportedVideoMime(mediaMimeTypeFromFileName(fileName));
+}
+
+function isSupportedImageMime(value) {
+  return new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]).has(optionalString(value).toLowerCase().split(";")[0]);
+}
+
+function isSupportedVideoMime(value) {
+  return new Set(["video/mp4", "video/webm"]).has(optionalString(value).toLowerCase().split(";")[0]);
+}
+
 function looksLikeMermaid(value) {
   const firstMeaningfulLine = optionalString(value)
     .split(/\r?\n/)
@@ -989,6 +1368,12 @@ function normalizeAgent(value) {
   if (normalized === "gemini-cli" || normalized === "google") {
     return "gemini";
   }
+  if (normalized === "github-copilot" || normalized === "copilot-chat" || normalized === "vscode-copilot" || normalized === "vs-code-copilot") {
+    return "copilot";
+  }
+  if (normalized === "cursor-ai") {
+    return "cursor";
+  }
   if (normalized === "openai" || normalized === "chatgpt") {
     return "codex";
   }