iris-chatbot 5.3.1 → 5.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iris-chatbot",
-  "version": "5.3.1",
+  "version": "5.5.0",
   "private": false,
   "description": "One-command installer for the Iris project template.",
   "bin": {

package/template/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "iris",
-  "version": "5.3.1",
+  "version": "5.5.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "iris",
-      "version": "5.3.1",
+      "version": "5.5.0",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.72.1",
         "clsx": "^2.1.1",

package/template/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iris",
-  "version": "5.3.1",
+  "version": "5.5.0",
   "private": true,
   "description": "One-command installer for the Iris project template.",
   "engines": {

package/template/src/app/api/chat/route.ts

@@ -1,6 +1,8 @@
 import OpenAI from "openai";
 import Anthropic from "@anthropic-ai/sdk";
+import type { BetaContentBlockParam, BetaMessageParam } from "@anthropic-ai/sdk/resources/beta";
 import type {
+  ChatAttachment,
   ChatConnectionPayload,
   ChatMessageInput,
   MemoryContextPayload,
@@ -11,6 +13,10 @@ import type {
 } from "../../../lib/types";
 import { DEFAULT_LOCAL_TOOLS_SETTINGS } from "../../../lib/types";
 import { GEMINI_OPENAI_BASE_URL, supportsToolsByDefault } from "../../../lib/connections";
+import {
+  getAttachmentProviderForConnection,
+  normalizeChatAttachments,
+} from "../../../lib/attachments";
 import { createApprovalRequest } from "../../../lib/tooling/approvals";
 import {
   createToolRegistry,
@@ -514,17 +520,59 @@ function sanitizeChatMessages(messages: ChatMessageInput[]): ChatMessageInput[]
       continue;
     }
     const normalizedContent = message.content.replace(/\r\n/g, "\n");
-    if (!normalizedContent.trim()) {
+    const normalizedAttachments =
+      role === "user" ? normalizeChatAttachments(message.attachments) : [];
+    if (!normalizedContent.trim() && normalizedAttachments.length === 0) {
       continue;
     }
     sanitized.push({
       role,
       content: normalizedContent,
+      ...(normalizedAttachments.length > 0
+        ? { attachments: normalizedAttachments }
+        : {}),
     });
   }
   return sanitized;
 }
 
+function messageHasAttachments(message: ChatMessageInput): boolean {
+  return Array.isArray(message.attachments) && message.attachments.length > 0;
+}
+
+function messagesContainAttachments(messages: ChatMessageInput[]): boolean {
+  return messages.some((message) => messageHasAttachments(message));
+}
+
+function validateAttachmentProviderCompatibility(params: {
+  connection: RuntimeConnection;
+  messages: ChatMessageInput[];
+}): string | null {
+  const providerFromConnection = getAttachmentProviderForConnection(params.connection);
+  const providers = new Set<ChatAttachment["provider"]>();
+  for (const message of params.messages) {
+    for (const attachment of message.attachments ?? []) {
+      providers.add(attachment.provider);
+    }
+  }
+
+  if (providers.size === 0) {
+    return null;
+  }
+  if (providers.size > 1) {
+    return "Attachments from multiple providers cannot be mixed in one request.";
+  }
+  if (!providerFromConnection) {
+    return "This connection does not support attachments.";
+  }
+
+  const providerFromAttachment = [...providers][0];
+  if (providerFromAttachment !== providerFromConnection) {
+    return `Attachments were uploaded for ${providerFromAttachment}, but the active connection is ${providerFromConnection}.`;
+  }
+  return null;
+}
+
 function sanitizeMemoryContext(
   memory: ChatRequest["memory"],
 ): MemoryContextPayload | null {
@@ -2574,6 +2622,90 @@ async function tryDirectAutomationFastPath(params: {
   return true;
 }
 
+function toOpenAIMessageContent(
+  message: ChatMessageInput,
+): string | OpenAI.Responses.ResponseInputMessageContentList {
+  if (message.role !== "user" || !messageHasAttachments(message)) {
+    return message.content;
+  }
+
+  const content: OpenAI.Responses.ResponseInputMessageContentList = [];
+  if (message.content.trim()) {
+    content.push({
+      type: "input_text",
+      text: message.content,
+    });
+  }
+
+  for (const attachment of message.attachments ?? []) {
+    if (attachment.kind === "image") {
+      content.push({
+        type: "input_image",
+        detail: "auto",
+        file_id: attachment.providerFileId,
+      });
+      continue;
+    }
+    content.push({
+      type: "input_file",
+      file_id: attachment.providerFileId,
+      filename: attachment.name,
+    });
+  }
+
+  if (content.length === 0) {
+    content.push({
+      type: "input_text",
+      text: "",
+    });
+  }
+  return content;
+}
+
+function toAnthropicUserContent(message: ChatMessageInput): string | BetaContentBlockParam[] {
+  if (!messageHasAttachments(message)) {
+    return message.content;
+  }
+
+  const content: BetaContentBlockParam[] = [];
+  if (message.content.trim()) {
+    content.push({
+      type: "text",
+      text: message.content,
+    });
+  }
+
+  for (const attachment of message.attachments ?? []) {
+    if (attachment.kind === "image") {
+      content.push({
+        type: "image",
+        source: {
+          type: "file",
+          file_id: attachment.providerFileId,
+        },
+      });
+      continue;
+    }
+    content.push({
+      type: "document",
+      title: attachment.name,
+      citations: { enabled: true },
+      source: {
+        type: "file",
+        file_id: attachment.providerFileId,
+      },
+    });
+  }
+
+  if (content.length === 0) {
+    content.push({
+      type: "text",
+      text: "",
+    });
+  }
+  return content;
+}
+
 async function streamPlainChat(params: {
   connection: RuntimeConnection;
   model: string;
@@ -2600,19 +2732,65 @@ async function streamPlainChat(params: {
       throw new Error("Missing Anthropic API key for this connection.");
     }
     const client = new Anthropic({ apiKey: params.connection.apiKey });
-    const response = await client.messages.stream({
-      model: params.model,
-      max_tokens: 1024,
-      system: params.system,
-      messages: params.messages.map((message) => ({
-        role: message.role === "assistant" ? "assistant" : "user",
-        content: message.content,
-      })),
-    });
+    if (messagesContainAttachments(params.messages)) {
+      const systemBlocks = [
+        params.system?.trim() || "",
+        ...params.messages
+          .filter((message) => message.role === "system")
+          .map((message) => message.content.trim())
+          .filter(Boolean),
+      ].filter(Boolean);
+      const anthropicMessages: BetaMessageParam[] = params.messages
+        .filter((message) => message.role !== "system")
+        .map((message) => ({
+          role: message.role === "assistant" ? "assistant" : "user",
+          content:
+            message.role === "assistant"
+              ? message.content
+              : toAnthropicUserContent(message),
+        }));
+
+      const response = await client.beta.messages.create({
+        model: params.model,
+        max_tokens: 1024,
+        system: systemBlocks.length > 0 ? systemBlocks.join("\n\n") : undefined,
+        messages: anthropicMessages,
+        stream: true,
+        betas: ["files-api-2025-04-14", "pdfs-2024-09-25"],
+      });
 
-    for await (const event of response) {
-      if (event.type === "content_block_delta" && event.delta?.type === "text_delta") {
-        emitTokenText(params.send, event.delta.text);
+      for await (const event of response) {
+        const eventAny = event as {
+          type?: string;
+          delta?: { type?: string; text?: string };
+          error?: { message?: string };
+        };
+        if (eventAny.type === "content_block_delta" && eventAny.delta?.type === "text_delta") {
+          emitTokenText(params.send, eventAny.delta.text ?? "");
+          continue;
+        }
+        if (eventAny.type === "error") {
+          params.send({
+            type: "error",
+            error: eventAny.error?.message || "Anthropic response error",
+          });
+        }
+      }
+    } else {
+      const response = await client.messages.stream({
+        model: params.model,
+        max_tokens: 1024,
+        system: params.system,
+        messages: params.messages.map((message) => ({
+          role: message.role === "assistant" ? "assistant" : "user",
+          content: message.content,
+        })),
+      });
+
+      for await (const event of response) {
+        if (event.type === "content_block_delta" && event.delta?.type === "text_delta") {
+          emitTokenText(params.send, event.delta.text);
+        }
       }
     }
     return;
@@ -2644,7 +2822,7 @@ async function streamPlainChat(params: {
       input: params.messages.map((message) => ({
         type: "message",
         role: message.role,
-        content: message.content,
+        content: toOpenAIMessageContent(message),
       })),
       tools: webSearchMode !== "off" ? [{ type: "web_search" }] : undefined,
       tool_choice:
@@ -3105,6 +3283,17 @@ export async function POST(request: Request) {
       headers: { "Content-Type": "application/json" },
     });
   }
+  const hasAttachmentsInMessages = messagesContainAttachments(sanitizedMessages);
+  const attachmentCompatibilityError = validateAttachmentProviderCompatibility({
+    connection,
+    messages: sanitizedMessages,
+  });
+  if (attachmentCompatibilityError) {
+    return new Response(JSON.stringify({ error: attachmentCompatibilityError }), {
+      status: 400,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
 
   const webSourcesEnabled = normalizeWebSourcesEnabled(body.enableWebSources);
   const webSearchMode = decideWebSearchMode({
@@ -3154,7 +3343,7 @@ export async function POST(request: Request) {
           });
         }
 
-        if (localTools.enabled) {
+        if (localTools.enabled && !hasAttachmentsInMessages) {
           const lastUserText =
             [...sanitizedMessages].reverse().find((message) => message.role === "user")?.content ?? "";
           const communicationIntentType = classifyDraftCommunicationIntent(lastUserText);

package/template/src/app/api/chat/uploads/route.ts

@@ -0,0 +1,220 @@
+import OpenAI from "openai";
+import Anthropic from "@anthropic-ai/sdk";
+import type { ChatAttachment, ChatConnectionPayload } from "../../../../lib/types";
+import {
+  getAttachmentProviderForConnection,
+  MAX_ATTACHMENTS_PER_MESSAGE,
+  validateAttachmentCandidate,
+} from "../../../../lib/attachments";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+type RuntimeConnection = {
+  kind: "builtin" | "openai_compatible" | "ollama";
+  provider?: "openai" | "anthropic" | "google";
+  baseUrl?: string;
+  apiKey?: string;
+  headers: Array<{ key: string; value: string }>;
+};
+
+function headersArrayToRecord(
+  headers: RuntimeConnection["headers"],
+): Record<string, string> | undefined {
+  if (!headers.length) {
+    return undefined;
+  }
+  const out: Record<string, string> = {};
+  for (const header of headers) {
+    const key = header.key.trim();
+    if (!key) {
+      continue;
+    }
+    out[key] = header.value;
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
+function normalizeConnection(rawConnection: unknown): RuntimeConnection | null {
+  if (!rawConnection || typeof rawConnection !== "object") {
+    return null;
+  }
+  const connection = rawConnection as Partial<ChatConnectionPayload>;
+  const kind =
+    connection.kind === "builtin" ||
+    connection.kind === "openai_compatible" ||
+    connection.kind === "ollama"
+      ? connection.kind
+      : null;
+  if (!kind) {
+    return null;
+  }
+  const provider =
+    kind === "builtin" &&
+    (connection.provider === "openai" ||
+      connection.provider === "anthropic" ||
+      connection.provider === "google")
+      ? connection.provider
+      : undefined;
+  const baseUrl =
+    typeof connection.baseUrl === "string" && connection.baseUrl.trim().length > 0
+      ? connection.baseUrl.trim()
+      : undefined;
+  const apiKey =
+    typeof connection.apiKey === "string" && connection.apiKey.trim().length > 0
+      ? connection.apiKey.trim()
+      : undefined;
+  const headers = Array.isArray(connection.headers)
+    ? connection.headers
+        .filter(
+          (header): header is { key: string; value: string } =>
+            Boolean(header) &&
+            typeof header.key === "string" &&
+            typeof header.value === "string",
+        )
+        .map((header) => ({
+          key: header.key,
+          value: header.value,
+        }))
+    : [];
+
+  return {
+    kind,
+    provider,
+    baseUrl,
+    apiKey,
+    headers,
+  };
+}
+
+function badRequest(message: string) {
+  return new Response(JSON.stringify({ error: message }), {
+    status: 400,
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+}
+
+export async function POST(request: Request) {
+  let formData: FormData;
+  try {
+    formData = await request.formData();
+  } catch {
+    return badRequest("Invalid multipart form payload.");
+  }
+
+  const rawConnection = formData.get("connection");
+  if (typeof rawConnection !== "string" || !rawConnection.trim()) {
+    return badRequest("Missing connection payload.");
+  }
+
+  let parsedConnectionValue: unknown;
+  try {
+    parsedConnectionValue = JSON.parse(rawConnection);
+  } catch {
+    return badRequest("Invalid connection payload.");
+  }
+
+  const connection = normalizeConnection(parsedConnectionValue);
+  if (!connection) {
+    return badRequest("Invalid connection payload.");
+  }
+
+  const providerFamily = getAttachmentProviderForConnection(connection);
+  if (!providerFamily) {
+    return badRequest("This connection does not support chat attachments.");
+  }
+
+  const files = formData.getAll("files").filter((entry): entry is File => entry instanceof File);
+  if (files.length === 0) {
+    return badRequest("No files were uploaded.");
+  }
+  if (files.length > MAX_ATTACHMENTS_PER_MESSAGE) {
+    return badRequest(`You can upload up to ${MAX_ATTACHMENTS_PER_MESSAGE} files per message.`);
+  }
+
+  const attachments: ChatAttachment[] = [];
+
+  if (providerFamily === "anthropic") {
+    if (!connection.apiKey) {
+      return badRequest("Missing Anthropic API key.");
+    }
+    const client = new Anthropic({
+      apiKey: connection.apiKey,
+    });
+
+    for (const file of files) {
+      const validation = validateAttachmentCandidate({
+        name: file.name,
+        mimeType: file.type,
+        sizeBytes: file.size,
+      });
+      if (!validation.ok) {
+        return badRequest(validation.error);
+      }
+
+      const uploadable = new File([await file.arrayBuffer()], validation.name, {
+        type: validation.mimeType,
+      });
+      const uploaded = await client.beta.files.upload({
+        file: uploadable,
+        betas: ["files-api-2025-04-14"],
+      });
+
+      attachments.push({
+        provider: "anthropic",
+        providerFileId: uploaded.id,
+        kind: validation.kind,
+        name: validation.name,
+        mimeType: validation.mimeType,
+        sizeBytes: validation.sizeBytes,
+      });
+    }
+  } else {
+    if (connection.kind === "openai_compatible" && !connection.baseUrl) {
+      return badRequest("OpenAI-compatible connection is missing base URL.");
+    }
+    if (connection.kind === "builtin" && connection.provider === "openai" && !connection.apiKey) {
+      return badRequest("Missing OpenAI API key.");
+    }
+
+    const client = new OpenAI({
+      apiKey: connection.apiKey ?? "no-key-required",
+      baseURL: connection.kind === "openai_compatible" ? connection.baseUrl : undefined,
+      defaultHeaders: headersArrayToRecord(connection.headers),
+    });
+
+    for (const file of files) {
+      const validation = validateAttachmentCandidate({
+        name: file.name,
+        mimeType: file.type,
+        sizeBytes: file.size,
+      });
+      if (!validation.ok) {
+        return badRequest(validation.error);
+      }
+
+      const uploadable = await OpenAI.toFile(
+        await file.arrayBuffer(),
+        validation.name,
+        { type: validation.mimeType },
+      );
+      const uploaded = await client.files.create({
+        file: uploadable,
+        purpose: "user_data",
+      });
+
+      attachments.push({
+        provider: "openai",
+        providerFileId: uploaded.id,
+        kind: validation.kind,
+        name: validation.name,
+        mimeType: validation.mimeType,
+        sizeBytes: validation.sizeBytes,
+      });
+    }
+  }
+
+  return Response.json({ attachments });
+}