iris-chatbot 5.3.0 → 5.4.0

package/template/src/lib/attachments.ts

@@ -0,0 +1,222 @@
+import type { ChatAttachment } from "./types";
+
+export const MAX_ATTACHMENTS_PER_MESSAGE = 8;
+export const MAX_ATTACHMENT_SIZE_BYTES = 25 * 1024 * 1024;
+
+const IMAGE_EXTENSIONS = new Set(["png", "jpg", "jpeg", "webp", "gif"]);
+const DOCUMENT_EXTENSIONS = new Set(["txt", "md", "doc", "docx"]);
+
+const DOCUMENT_MIME_TYPES = new Set([
+  "text/plain",
+  "text/markdown",
+  "text/x-markdown",
+  "application/msword",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+]);
+
+const EXTENSION_TO_MIME: Record<string, string> = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  gif: "image/gif",
+  pdf: "application/pdf",
+  txt: "text/plain",
+  md: "text/markdown",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+};
+
+export const COMPOSER_FILE_ACCEPT =
+  ".png,.jpg,.jpeg,.webp,.gif,.pdf,.txt,.md,.doc,.docx";
+
+type AttachmentConnection = {
+  kind?: unknown;
+  provider?: unknown;
+} | null | undefined;
+
+type AttachmentCandidate = {
+  name: string;
+  mimeType?: string | null;
+  sizeBytes: number;
+};
+
+function normalizeFileName(name: string): string {
+  const trimmed = name.trim();
+  if (!trimmed) {
+    return "attachment";
+  }
+  const basename = trimmed.split(/[\\/]/).pop()?.trim() || "attachment";
+  return basename || "attachment";
+}
+
+function normalizeMimeType(mimeType: string | null | undefined): string {
+  return typeof mimeType === "string" ? mimeType.trim().toLowerCase() : "";
+}
+
+function extensionFromName(name: string): string {
+  const index = name.lastIndexOf(".");
+  if (index < 0 || index === name.length - 1) {
+    return "";
+  }
+  return name.slice(index + 1).toLowerCase();
+}
+
+function inferMimeType(name: string, fallback: ChatAttachment["kind"]): string {
+  const ext = extensionFromName(name);
+  const mapped = EXTENSION_TO_MIME[ext];
+  if (mapped) {
+    return mapped;
+  }
+  if (fallback === "image") {
+    return "image/png";
+  }
+  if (fallback === "pdf") {
+    return "application/pdf";
+  }
+  return "text/plain";
+}
+
+export function getAttachmentProviderForConnection(
+  connection: AttachmentConnection,
+): ChatAttachment["provider"] | null {
+  if (!connection || typeof connection.kind !== "string") {
+    return null;
+  }
+  if (connection.kind === "openai_compatible") {
+    return "openai";
+  }
+  if (connection.kind !== "builtin" || typeof connection.provider !== "string") {
+    return null;
+  }
+  if (connection.provider === "openai") {
+    return "openai";
+  }
+  if (connection.provider === "anthropic") {
+    return "anthropic";
+  }
+  return null;
+}
+
+export function detectAttachmentKind(
+  candidate: Pick<AttachmentCandidate, "name" | "mimeType">,
+): ChatAttachment["kind"] | null {
+  const name = normalizeFileName(candidate.name);
+  const extension = extensionFromName(name);
+  const mimeType = normalizeMimeType(candidate.mimeType);
+
+  if (mimeType.startsWith("image/") || IMAGE_EXTENSIONS.has(extension)) {
+    return "image";
+  }
+  if (mimeType === "application/pdf" || extension === "pdf") {
+    return "pdf";
+  }
+  if (DOCUMENT_MIME_TYPES.has(mimeType) || DOCUMENT_EXTENSIONS.has(extension)) {
+    return "document";
+  }
+  return null;
+}
+
+export function validateAttachmentCandidate(candidate: AttachmentCandidate): {
+  ok: true;
+  kind: ChatAttachment["kind"];
+  name: string;
+  mimeType: string;
+  sizeBytes: number;
+} | {
+  ok: false;
+  error: string;
+} {
+  const name = normalizeFileName(candidate.name);
+  if (!Number.isFinite(candidate.sizeBytes) || candidate.sizeBytes <= 0) {
+    return {
+      ok: false,
+      error: `${name} is empty.`,
+    };
+  }
+  if (candidate.sizeBytes > MAX_ATTACHMENT_SIZE_BYTES) {
+    return {
+      ok: false,
+      error: `${name} is larger than 25 MB.`,
+    };
+  }
+
+  const kind = detectAttachmentKind(candidate);
+  if (!kind) {
+    return {
+      ok: false,
+      error: `${name} is not a supported file type.`,
+    };
+  }
+
+  const normalizedMimeType = normalizeMimeType(candidate.mimeType) || inferMimeType(name, kind);
+  return {
+    ok: true,
+    kind,
+    name,
+    mimeType: normalizedMimeType,
+    sizeBytes: candidate.sizeBytes,
+  };
+}
+
+export function normalizeChatAttachments(input: unknown): ChatAttachment[] {
+  if (!Array.isArray(input)) {
+    return [];
+  }
+
+  const normalized: ChatAttachment[] = [];
+  const seen = new Set<string>();
+
+  for (const item of input) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const record = item as {
+      provider?: unknown;
+      providerFileId?: unknown;
+      kind?: unknown;
+      name?: unknown;
+      mimeType?: unknown;
+      sizeBytes?: unknown;
+    };
+
+    const provider =
+      record.provider === "openai" || record.provider === "anthropic"
+        ? record.provider
+        : null;
+    const providerFileId =
+      typeof record.providerFileId === "string" ? record.providerFileId.trim() : "";
+    const kind =
+      record.kind === "image" || record.kind === "pdf" || record.kind === "document"
+        ? record.kind
+        : null;
+    const name = typeof record.name === "string" ? normalizeFileName(record.name) : "";
+    const mimeType = normalizeMimeType(
+      typeof record.mimeType === "string" ? record.mimeType : "",
+    );
+    const sizeBytes =
+      typeof record.sizeBytes === "number" && Number.isFinite(record.sizeBytes) && record.sizeBytes > 0
+        ? record.sizeBytes
+        : 0;
+
+    if (!provider || !providerFileId || !kind || !name || !mimeType || sizeBytes <= 0) {
+      continue;
+    }
+
+    const uniqueKey = `${provider}:${providerFileId}`;
+    if (seen.has(uniqueKey)) {
+      continue;
+    }
+    seen.add(uniqueKey);
+    normalized.push({
+      provider,
+      providerFileId,
+      kind,
+      name,
+      mimeType,
+      sizeBytes,
+    });
+  }
+
+  return normalized;
+}

package/template/src/lib/data.ts

@@ -1,6 +1,7 @@
 import { nanoid } from "nanoid";
 import { db } from "./db";
 import type {
+  ChatAttachment,
   LocalToolsSettings,
   MemorySettings,
   MessageNode,
@@ -292,10 +293,11 @@ export async function deleteConversation(conversationId: string) {
 export async function appendUserAndAssistant(params: {
   thread: Thread;
   content: string;
+  attachments?: ChatAttachment[];
   provider: string;
   model: string;
 }) {
-  const { thread, content, provider, model } = params;
+  const { thread, content, attachments, provider, model } = params;
   const now = Date.now();
   const userId = nanoid();
   const assistantId = nanoid();
@@ -306,6 +308,7 @@ export async function appendUserAndAssistant(params: {
     parentId: thread.headMessageId,
     role: "user",
     content,
+    ...(attachments?.length ? { attachments } : {}),
     createdAt: now,
   };
 

package/template/src/lib/types.ts

@@ -29,6 +29,7 @@ export type MessageNode = {
   parentId: string | null;
   role: "system" | "user" | "assistant";
   content: string;
+  attachments?: ChatAttachment[];
   createdAt: number;
   provider?: string;
   model?: string;
@@ -217,6 +218,16 @@ export type ToolApproval = {
 export type ChatMessageInput = {
   role: "user" | "assistant" | "system";
   content: string;
+  attachments?: ChatAttachment[];
+};
+
+export type ChatAttachment = {
+  provider: "openai" | "anthropic";
+  providerFileId: string;
+  kind: "image" | "pdf" | "document";
+  name: string;
+  mimeType: string;
+  sizeBytes: number;
 };
 
 export type ChatCitationSource = {