evolcore 0.0.26 → 0.0.28

package/dist/aun/msg/upload.js

@@ -1,7 +1,7 @@
 import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
-import { guessMime, formatSize } from '../../utils/media-cache.js';
+import { formatSize } from '../../utils/media-cache.js';
 const EXT_TYPE_MAP = {
     '.png': 'image', '.jpg': 'image', '.jpeg': 'image',
     '.gif': 'image', '.webp': 'image', '.svg': 'image',
@@ -11,6 +11,15 @@ const EXT_TYPE_MAP = {
     '.opus': 'voice', '.mp3': 'voice', '.aac': 'voice',
     '.m4a': 'voice', '.wav': 'voice', '.flac': 'voice', '.ogg': 'voice',
 };
+const EXT_CONTENT_TYPE_MAP = {
+    '.txt': 'text/plain', '.md': 'text/markdown', '.csv': 'text/csv',
+    '.json': 'application/json', '.xml': 'application/xml', '.html': 'text/html',
+    '.pdf': 'application/pdf', '.zip': 'application/zip',
+    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml',
+    '.mp4': 'video/mp4', '.mov': 'video/quicktime', '.webm': 'video/webm',
+    '.mp3': 'audio/mpeg', '.wav': 'audio/wav', '.ogg': 'audio/ogg',
+};
 export function inferPayloadType(filename) {
     const ext = path.extname(filename).toLowerCase();
     return EXT_TYPE_MAP[ext] ?? 'file';
@@ -20,109 +29,57 @@ export function isValidPayloadType(value) {
 }
 /** 单次上传最大大小（与 daemon sendFile 一致）。 */
 export const MAX_AUN_ATTACHMENT_SIZE = 10 * 1024 * 1024;
-/**
- * Inline JSON-RPC 上传阈值。超过该大小直接使用上传会话，避免把文件
- * Base64 编码后放进 storage.put_object 的 RPC 参数。
- */
-export const INLINE_AUN_ATTACHMENT_SIZE = 64 * 1024;
-/** server 端 inline 上限错误的识别特征。优先匹配错误消息里的“inline 上限”字样。 */
-function isInlineLimitError(err) {
-    const msg = err?.message ?? '';
-    return /inline\s*上限|inline limit|create_upload_session/i.test(msg);
-}
 /**
  * 上传内存中的二进制内容并构造发送用的标准附件 payload。
  */
 export async function uploadBufferAndBuildPayload(conn, ownerAid, data, filename, opts) {
-    const safeFilename = path.basename(filename.trim());
-    if (!safeFilename || safeFilename === '.' || safeFilename === '..') {
+    const displayFilename = path.basename(filename);
+    if (!displayFilename.trim() || displayFilename === '.' || displayFilename === '..') {
         throw new Error('文件名不能为空');
     }
     if (data.length === 0) {
-        throw new Error(`文件为空: ${safeFilename}`);
+        throw new Error(`文件为空: ${displayFilename}`);
     }
     if (data.length > MAX_AUN_ATTACHMENT_SIZE) {
-        throw new Error(`文件过大 (${formatSize(data.length)}, 上限 ${formatSize(MAX_AUN_ATTACHMENT_SIZE)}): ${safeFilename}`);
+        throw new Error(`文件过大 (${formatSize(data.length)}, 上限 ${formatSize(MAX_AUN_ATTACHMENT_SIZE)}): ${displayFilename}`);
     }
     const sha256 = crypto.createHash('sha256').update(data).digest('hex');
-    const contentType = opts?.contentType ?? guessMime(safeFilename);
-    const objectKey = `shared/${crypto.randomUUID()}/${safeFilename}`;
+    const explicitContentType = opts?.contentType?.trim() || undefined;
+    // Storage keys have a narrower character set than local filenames. Keep the
+    // original basename in the attachment; only the opaque storage key is sanitized.
+    const storageFilename = displayFilename.replace(/[^A-Za-z0-9._-]/g, '_');
+    const objectKey = `shared/${crypto.randomUUID()}/${storageFilename}`;
     const total = data.length;
     const report = (phase, bytes) => opts?.onProgress?.({ phase, bytes, total });
-    // 小文件优先走 inline，兼容不支持上传会话的服务端；大文件直接走
-    // session，避免先构造一份可能超过 JSON-RPC 限制的 Base64 请求。
-    let useUploadSession = total > INLINE_AUN_ATTACHMENT_SIZE;
-    if (!useUploadSession) {
-        try {
-            report('inline', 0);
-            await conn.call('storage.put_object', {
-                object_key: objectKey,
-                content: data.toString('base64'),
-                content_type: contentType,
-                is_private: false,
-                overwrite: true,
-            });
-            report('inline', total);
-        }
-        catch (e) {
-            if (!isInlineLimitError(e))
-                throw e;
-            useUploadSession = true;
-        }
-    }
-    // inline 被拒或文件超过 inline 阈值：session + HTTP PUT
-    if (useUploadSession) {
-        report('session-create', 0);
-        const session = await conn.call('storage.create_upload_session', {
-            object_key: objectKey,
-            size_bytes: total,
-            content_type: contentType,
-        });
-        const uploadUrl = session?.upload_url;
-        if (!uploadUrl)
-            throw new Error('storage.create_upload_session 未返回 upload_url');
-        // 简单 Buffer 上传 + 周期性进度（不用流，避免某些 storage 网关对 chunked / duplex 不友好）
-        report('http-put', 0);
-        const PROGRESS_TICK_MS = 250;
-        let lastBytes = 0;
-        const tickerStart = Date.now();
-        // 实际上一次性发送；等待响应期间按 2MB/s 估算进度，且不超过 99%。
-        const ticker = setInterval(() => {
-            const elapsed = Date.now() - tickerStart;
-            const estimated = Math.min(total - 1, Math.floor((elapsed / 1000) * 2 * 1024 * 1024));
-            if (estimated > lastBytes) {
-                lastBytes = estimated;
-                report('http-put', estimated);
-            }
-        }, PROGRESS_TICK_MS);
-        let uploadResp;
+    // Use the client-owned facade so storage RPCs stay inside the SDK. Do not
+    // rebuild StorageVFS over conn.call: SDK-internal RPCs are not application APIs.
+    report('upload', 0);
+    const uploaded = await conn.storage.writeBytes(`/${objectKey}`, data, {
+        contentType: explicitContentType,
+        public: true,
+        overwrite: true,
+    });
+    // Use the stored MIME instead of inferring a second, potentially different
+    // type for the attachment. Older storage responses may omit this metadata.
+    let contentType = uploaded.contentType?.trim() || explicitContentType;
+    if (!contentType && typeof conn.storage.stat === 'function') {
         try {
-            uploadResp = await fetch(uploadUrl, {
-                method: 'PUT',
-                body: new Blob([new Uint8Array(data)], { type: contentType }),
-                headers: { 'Content-Type': contentType },
-            });
+            contentType = (await conn.storage.stat(`/${objectKey}`)).contentType?.trim();
         }
-        finally {
-            clearInterval(ticker);
+        catch {
+            // A successful upload should remain usable when a legacy facade cannot
+            // perform a follow-up stat call.
         }
-        if (!uploadResp.ok)
-            throw new Error(`HTTP 上传失败: ${uploadResp.status}`);
-        report('http-put', total);
-        report('session-complete', total);
-        await conn.call('storage.complete_upload', {
-            object_key: objectKey,
-            sha256,
-            content_type: contentType,
-            is_private: false,
-            size_bytes: total,
-        });
     }
+    if (!contentType)
+        contentType = EXT_CONTENT_TYPE_MAP[path.extname(displayFilename).toLowerCase()] ?? 'application/octet-stream';
+    if (!contentType)
+        throw new Error('Storage 上传结果缺少 Content-Type');
     report('done', total);
     const attachment = {
         owner_aid: ownerAid,
         object_key: objectKey,
-        filename: safeFilename,
+        filename: displayFilename,
         size_bytes: total,
         sha256,
         content_type: contentType,
@@ -135,7 +92,7 @@ export async function uploadBufferAndBuildPayload(conn, ownerAid, data, filename
         type = opts.as;
     }
     else {
-        type = inferPayloadType(safeFilename);
+        type = inferPayloadType(displayFilename);
     }
     const payload = {
         type,
@@ -144,7 +101,7 @@ export async function uploadBufferAndBuildPayload(conn, ownerAid, data, filename
     if (opts?.text)
         payload.text = opts.text;
     else if (type === 'file')
-        payload.text = `📎 ${safeFilename} (${formatSize(total)})`;
+        payload.text = `📎 ${displayFilename} (${formatSize(total)})`;
     if (type === 'voice' && opts?.transcript)
         payload.transcript = opts.transcript;
     return { payload, type, attachment };
@@ -152,9 +109,7 @@ export async function uploadBufferAndBuildPayload(conn, ownerAid, data, filename
 /**
  * 上传本地文件并构造发送用的 payload。
  *
- * 策略：小文件使用 storage.put_object（内联 base64）；大文件直接使用
- * storage.create_upload_session + HTTP PUT + storage.complete_upload，避免
- * 将大文件编码后放入 JSON-RPC。此时通过 onProgress 上报字节级进度。
+ * 通过 SDK StorageVFS 协商并执行上传，onProgress 上报上传阶段。
  */
 export async function uploadFileAndBuildPayload(conn, ownerAid, filePath, opts) {
     const absPath = path.resolve(filePath);

package/dist/aun/outbox.js

@@ -115,14 +115,14 @@ function writeEntries(aid, entries, queue = 'default') {
     atomicWrite(file, content);
 }
 function trimFinalEntries(entries) {
-    const finalEntries = entries.filter(entry => !!entry.terminal || !!entry.deliveryResult);
+    const finalEntries = entries.filter(entry => !entry.critical && (!!entry.terminal || !!entry.deliveryResult));
     if (finalEntries.length <= MAX_TERMINAL_ENTRIES_PER_AID)
         return entries;
     const retainedFinalIds = new Set(finalEntries
         .sort((left, right) => (left.terminal?.at ?? left.deliveryResult?.at ?? left.ts) - (right.terminal?.at ?? right.deliveryResult?.at ?? right.ts))
         .slice(-MAX_TERMINAL_ENTRIES_PER_AID)
         .map(entry => entry.id));
-    return entries.filter(entry => (!entry.terminal && !entry.deliveryResult) || retainedFinalIds.has(entry.id));
+    return entries.filter(entry => entry.critical || (!entry.terminal && !entry.deliveryResult) || retainedFinalIds.has(entry.id));
 }
 export function enqueue(aid, opts) {
     const queue = opts.queue ?? 'default';
@@ -138,12 +138,11 @@ export function enqueue(aid, opts) {
             markExpired(existing);
     }
     if (opts.dedupeKey) {
-        // Terminal results are decisions for this logical operation. Reusing the
-        // same route must not silently turn a permanent rejection into a retry;
-        // an explicit route correction is the only case that replaces it.
+        // A terminal result or a delivery receipt is also a decision for this
+        // logical operation. Reusing the same route must return that decision
+        // instead of silently creating a second send attempt. Route correction
+        // remains the one intentional replacement path.
         const existing = existingEntries.find(entry => entry.dedupeKey === opts.dedupeKey
-            && !entry.terminal
-            && !entry.deliveryResult
             && !isExpired(entry));
         if (existing
             && existing.channelId === opts.channelId
@@ -323,6 +322,17 @@ export function markTerminal(aid, id, failure, submitted, queue = submitted ? en
     writeEntries(aid, entries, queue);
     return true;
 }
+/** Keep the latest transient failure visible without changing the operation or its route. */
+export function recordRetry(aid, submitted, failure) {
+    const queue = entryQueue(submitted);
+    const entries = readEntries(aid, queue);
+    const entry = entries.find(candidate => candidate.id === submitted.id);
+    if (!entry || !hasSamePersistedRoute(entry, submitted) || entry.terminal || entry.deliveryResult)
+        return;
+    entry.lastError = failure.error ?? 'delivery is pending';
+    entry.lastErrorCode = failure.code;
+    writeEntries(aid, entries, queue);
+}
 /** Retain a bounded success receipt for queued Trigger history reconciliation. */
 export function markDelivered(aid, id, messageId, submitted, queue = submitted ? entryQueue(submitted) : 'default') {
     const entries = readEntries(aid, queue);
@@ -364,6 +374,18 @@ async function drainOnce(aid, sender, queue) {
     let permanent = 0;
     const remaining = [];
     for (const entry of entries) {
+        // Cancellation or another sender may have changed an
+        // entry while this drain was awaiting a previous network call.
+        if (entry.critical) {
+            const currentEntry = readEntries(aid, queue).find(candidate => candidate.id === entry.id);
+            if (!currentEntry || !hasSamePersistedRoute(currentEntry, entry))
+                continue;
+            if (currentEntry.terminal || currentEntry.deliveryResult) {
+                remaining.push(currentEntry);
+                continue;
+            }
+            Object.assign(entry, currentEntry);
+        }
         if (isExpired(entry)) {
             expired++;
             markExpired(entry);

package/dist/aun/rpc/client.js

@@ -5,6 +5,7 @@ export async function createShortConnection(aid, opts) {
         const client = await loadClient(store, aid);
         await client.connect({ connection_kind: 'short', short_ttl_ms: opts?.shortTtlMs ?? 30000, auto_reconnect: false });
         return {
+            get storage() { return client.storage; },
             async call(method, params) {
                 return client.call(method, params);
             },

package/dist/aun/storage/client.js

@@ -1,9 +1,10 @@
 import fs from 'fs';
-import crypto from 'crypto';
-import { rpcCall } from '../rpc/index.js';
+import { createShortConnection, rpcCall } from '../rpc/index.js';
 function rpcErrorToString(error) {
     if (!error)
         return 'unknown error';
+    if (error instanceof Error)
+        return error.message;
     if (typeof error === 'string')
         return error;
     try {
@@ -13,67 +14,55 @@ function rpcErrorToString(error) {
         return String(error);
     }
 }
-function pickUrl(value) {
-    return typeof value === 'string' && value.trim() ? value : undefined;
-}
 export async function storageUpload(aid, localFile, remotePath, opts) {
     const fileBuffer = Buffer.isBuffer(localFile) ? localFile : fs.readFileSync(localFile);
     return storageUploadBuffer(aid, fileBuffer, remotePath, opts);
 }
 export async function storageUploadBuffer(aid, fileBuffer, remotePath, opts) {
-    const contentType = opts?.contentType ?? 'application/octet-stream';
-    const sha256 = crypto.createHash('sha256').update(fileBuffer).digest('hex');
-    const createResult = await rpcCall(aid, 'storage.create_upload_session', {
-        object_key: remotePath,
-        content_type: contentType,
-        size_bytes: fileBuffer.length,
-    }, { aunPath: opts?.aunPath });
-    if (!createResult.ok) {
-        return { ok: false, objectKey: remotePath, error: rpcErrorToString(createResult.error) };
-    }
-    const uploadUrl = createResult.result.upload_url;
-    if (!uploadUrl) {
-        return { ok: false, objectKey: remotePath, error: 'storage.create_upload_session did not return upload_url' };
-    }
-    const putResp = await fetch(uploadUrl, {
-        method: 'PUT',
-        headers: { 'Content-Type': contentType },
-        body: new Blob([new Uint8Array(fileBuffer)], { type: contentType }),
-        redirect: 'follow',
-    });
-    if (!putResp.ok) {
-        return { ok: false, objectKey: remotePath, error: `HTTP PUT failed: ${putResp.status}` };
+    let conn;
+    try {
+        conn = await createShortConnection(aid, { aunPath: opts?.aunPath });
+        const uploaded = await conn.storage.writeBytes(remotePath, fileBuffer, {
+            contentType: opts?.contentType,
+            public: opts?.isPublic ?? false,
+            overwrite: true,
+        });
+        const objectKey = uploaded.path.replace(/^\/+/, '');
+        if (!objectKey)
+            throw new Error('Storage 上传结果缺少文件路径');
+        // agent.md avatars require a stable public URL, never an expiring ticket.
+        const publicUrl = opts?.isPublic
+            ? `https://${aid}/${objectKey.split('/').map(encodeURIComponent).join('/')}`
+            : undefined;
+        return { ok: true, objectKey, publicUrl };
     }
-    const completeResult = await rpcCall(aid, 'storage.complete_upload', {
-        object_key: remotePath,
-        sha256,
-        content_type: contentType,
-        size_bytes: fileBuffer.length,
-        is_private: !opts?.isPublic,
-    }, { aunPath: opts?.aunPath });
-    if (!completeResult.ok) {
-        return { ok: false, objectKey: remotePath, error: rpcErrorToString(completeResult.error) };
+    catch (error) {
+        return { ok: false, objectKey: remotePath, error: rpcErrorToString(error) };
     }
-    let publicUrl = pickUrl(completeResult.result?.url);
-    if (opts?.isPublic) {
-        if (!publicUrl) {
-            const ticketResult = await rpcCall(aid, 'storage.create_download_ticket', {
-                object_key: remotePath,
-                expire_in_seconds: 86400 * 30,
-            }, { aunPath: opts?.aunPath });
-            if (ticketResult.ok) {
-                publicUrl = pickUrl(ticketResult.result?.url) ?? pickUrl(ticketResult.result?.download_url);
-            }
-        }
-        publicUrl ??= `https://${aid}/${remotePath}`;
+    finally {
+        if (conn)
+            await conn.close();
     }
-    return { ok: true, objectKey: remotePath, publicUrl };
 }
 export async function storageLs(aid, prefix, opts) {
     return rpcCall(aid, 'storage.list_objects', { prefix: prefix || '' }, { aunPath: opts?.aunPath });
 }
 export async function storageRm(aid, remotePath, opts) {
-    return rpcCall(aid, 'storage.delete_object', { object_key: remotePath }, { aunPath: opts?.aunPath });
+    let conn;
+    try {
+        conn = await createShortConnection(aid, { aunPath: opts?.aunPath });
+        const result = await conn.storage.remove(remotePath);
+        return { ok: true, result };
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error && typeof error.code === 'number'
+            ? error.code : -1;
+        return { ok: false, error: { code, message: rpcErrorToString(error) } };
+    }
+    finally {
+        if (conn)
+            await conn.close();
+    }
 }
 export async function storageQuota(aid, opts) {
     return rpcCall(aid, 'storage.get_quota', {}, { aunPath: opts?.aunPath });