evolcore 0.0.26 → 0.0.27

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 });