@nextclaw/ncp-react 0.3.2 → 0.3.4

package/dist/index.d.ts

@@ -32,4 +32,39 @@ declare function useHydratedNcpAgent({ sessionId, client, loadSeed, autoResumeRu
 
 declare function useNcpAgent(sessionId: string, client: NcpAgentClientEndpoint): UseNcpAgentResult;
 
-export { type NcpConversationSeed, type NcpConversationSeedLoader, type UseHydratedNcpAgentOptions, type UseHydratedNcpAgentResult, type UseNcpAgentResult, useHydratedNcpAgent, useNcpAgent };
+declare const DEFAULT_NCP_IMAGE_ATTACHMENT_ACCEPT = "image/png,image/jpeg,image/webp,image/gif";
+declare const DEFAULT_NCP_IMAGE_ATTACHMENT_MIME_TYPES: readonly ["image/png", "image/jpeg", "image/webp", "image/gif"];
+declare const DEFAULT_NCP_IMAGE_ATTACHMENT_MAX_BYTES: number;
+type NcpDraftAttachment = {
+    id: string;
+    name: string;
+    mimeType: string;
+    contentBase64: string;
+    sizeBytes: number;
+};
+type NcpRejectedAttachment = {
+    fileName: string;
+    mimeType: string;
+    sizeBytes: number;
+    reason: "unsupported-type" | "too-large" | "read-failed";
+};
+type ReadNcpDraftAttachmentsOptions = {
+    acceptedMimeTypes?: readonly string[];
+    maxBytes?: number;
+};
+type ReadNcpDraftAttachmentsResult = {
+    attachments: NcpDraftAttachment[];
+    rejected: NcpRejectedAttachment[];
+};
+declare function buildNcpImageAttachmentDataUrl(attachment: NcpDraftAttachment): string;
+declare function buildNcpRequestEnvelope(params: {
+    sessionId: string;
+    text?: string;
+    attachments?: readonly NcpDraftAttachment[];
+    metadata?: Record<string, unknown>;
+    messageId?: string;
+    timestamp?: string;
+}): NcpRequestEnvelope | null;
+declare function readFilesAsNcpDraftAttachments(files: Iterable<File>, options?: ReadNcpDraftAttachmentsOptions): Promise<ReadNcpDraftAttachmentsResult>;
+
+export { DEFAULT_NCP_IMAGE_ATTACHMENT_ACCEPT, DEFAULT_NCP_IMAGE_ATTACHMENT_MAX_BYTES, DEFAULT_NCP_IMAGE_ATTACHMENT_MIME_TYPES, type NcpConversationSeed, type NcpConversationSeedLoader, type NcpDraftAttachment, type NcpRejectedAttachment, type ReadNcpDraftAttachmentsOptions, type ReadNcpDraftAttachmentsResult, type UseHydratedNcpAgentOptions, type UseHydratedNcpAgentResult, type UseNcpAgentResult, buildNcpImageAttachmentDataUrl, buildNcpRequestEnvelope, readFilesAsNcpDraftAttachments, useHydratedNcpAgent, useNcpAgent };

package/dist/index.js

@@ -55,13 +55,6 @@ function normalizeSendEnvelope(input, sessionId) {
     }
   };
 }
-function toHydrationPayload(sessionId, snapshot) {
-  return {
-    sessionId,
-    messages: snapshot.messages,
-    activeRun: snapshot.activeRun
-  };
-}
 function useScopedAgentManager(sessionId) {
   const managerRef = useRef();
   if (!managerRef.current || managerRef.current.sessionId !== sessionId) {
@@ -110,7 +103,6 @@ function useNcpAgentRuntime({
       return;
     }
     setIsSending(true);
-    const previousSnapshot = manager.getSnapshot();
     await manager.dispatch({
       type: NcpEventType.MessageSent,
       payload: {
@@ -121,9 +113,6 @@ function useNcpAgentRuntime({
     });
     try {
       await client.send(envelope);
-    } catch (error) {
-      manager.hydrate(toHydrationPayload(sessionId, previousSnapshot));
-      throw error;
     } finally {
       setIsSending(false);
     }
@@ -235,7 +224,126 @@ function useNcpAgent(sessionId, client) {
   const manager = useScopedAgentManager(sessionId);
   return useNcpAgentRuntime({ sessionId, client, manager });
 }
+
+// src/attachments/ncp-attachments.ts
+var DEFAULT_NCP_IMAGE_ATTACHMENT_ACCEPT = "image/png,image/jpeg,image/webp,image/gif";
+var DEFAULT_NCP_IMAGE_ATTACHMENT_MIME_TYPES = [
+  "image/png",
+  "image/jpeg",
+  "image/webp",
+  "image/gif"
+];
+var DEFAULT_NCP_IMAGE_ATTACHMENT_MAX_BYTES = 10 * 1024 * 1024;
+function createAttachmentId() {
+  return `ncp-file-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function readFileAsDataUrl(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onerror = () => reject(reader.error ?? new Error(`Failed to read ${file.name}`));
+    reader.onload = () => {
+      if (typeof reader.result !== "string") {
+        reject(new Error(`Unexpected FileReader result for ${file.name}`));
+        return;
+      }
+      resolve(reader.result);
+    };
+    reader.readAsDataURL(file);
+  });
+}
+function toBase64Content(dataUrl) {
+  const commaIndex = dataUrl.indexOf(",");
+  return commaIndex >= 0 ? dataUrl.slice(commaIndex + 1) : dataUrl;
+}
+function buildNcpImageAttachmentDataUrl(attachment) {
+  return `data:${attachment.mimeType};base64,${attachment.contentBase64}`;
+}
+function buildNcpRequestEnvelope(params) {
+  const trimmedText = params.text?.trim() ?? "";
+  const attachments = params.attachments ?? [];
+  const parts = [
+    ...trimmedText ? [{ type: "text", text: trimmedText }] : [],
+    ...attachments.map((attachment) => ({
+      type: "file",
+      name: attachment.name,
+      mimeType: attachment.mimeType,
+      contentBase64: attachment.contentBase64,
+      sizeBytes: attachment.sizeBytes
+    }))
+  ];
+  if (parts.length === 0) {
+    return null;
+  }
+  const timestamp = params.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  const messageId = params.messageId ?? `user-${Date.now().toString(36)}`;
+  return {
+    sessionId: params.sessionId,
+    message: {
+      id: messageId,
+      sessionId: params.sessionId,
+      role: "user",
+      status: "final",
+      parts,
+      timestamp,
+      ...params.metadata ? { metadata: params.metadata } : {}
+    },
+    ...params.metadata ? { metadata: params.metadata } : {}
+  };
+}
+async function readFilesAsNcpDraftAttachments(files, options = {}) {
+  const acceptedMimeTypes = new Set(
+    options.acceptedMimeTypes ?? DEFAULT_NCP_IMAGE_ATTACHMENT_MIME_TYPES
+  );
+  const maxBytes = options.maxBytes ?? DEFAULT_NCP_IMAGE_ATTACHMENT_MAX_BYTES;
+  const attachments = [];
+  const rejected = [];
+  for (const file of files) {
+    const mimeType = file.type.trim().toLowerCase();
+    if (!acceptedMimeTypes.has(mimeType)) {
+      rejected.push({
+        fileName: file.name,
+        mimeType,
+        sizeBytes: file.size,
+        reason: "unsupported-type"
+      });
+      continue;
+    }
+    if (file.size > maxBytes) {
+      rejected.push({
+        fileName: file.name,
+        mimeType,
+        sizeBytes: file.size,
+        reason: "too-large"
+      });
+      continue;
+    }
+    try {
+      const dataUrl = await readFileAsDataUrl(file);
+      attachments.push({
+        id: createAttachmentId(),
+        name: file.name,
+        mimeType,
+        contentBase64: toBase64Content(dataUrl),
+        sizeBytes: file.size
+      });
+    } catch {
+      rejected.push({
+        fileName: file.name,
+        mimeType,
+        sizeBytes: file.size,
+        reason: "read-failed"
+      });
+    }
+  }
+  return { attachments, rejected };
+}
 export {
+  DEFAULT_NCP_IMAGE_ATTACHMENT_ACCEPT,
+  DEFAULT_NCP_IMAGE_ATTACHMENT_MAX_BYTES,
+  DEFAULT_NCP_IMAGE_ATTACHMENT_MIME_TYPES,
+  buildNcpImageAttachmentDataUrl,
+  buildNcpRequestEnvelope,
+  readFilesAsNcpDraftAttachments,
   useHydratedNcpAgent,
   useNcpAgent
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/ncp-react",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "private": false,
   "description": "React bindings for building NCP-based agent applications.",
   "type": "module",
@@ -15,8 +15,8 @@
     "dist"
   ],
   "dependencies": {
-    "@nextclaw/ncp": "0.3.1",
-    "@nextclaw/ncp-toolkit": "0.4.1"
+    "@nextclaw/ncp": "0.3.2",
+    "@nextclaw/ncp-toolkit": "0.4.2"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0"