evolcore 0.0.11 → 0.0.13

package/dist/aun/msg/mention-schema.js

@@ -0,0 +1,20 @@
+import { MentionSchemaError, normalizeMentionEntries, } from '../../core/message/mention-schema.js';
+const AUN_MENTION_KEYS = new Set(['aid', 'scope', 'display', 'offset', 'length']);
+/**
+ * Validate the AUN wire schema. `userId` is deliberately excluded here:
+ * it identifies users in platform-native adapters such as Feishu/DingTalk,
+ * while AUN addresses agents with `aid` and uses `scope: 'all'` for broadcast.
+ */
+export function normalizeAunMentionEntries(raw) {
+    const entries = normalizeMentionEntries(raw);
+    for (const [index, entry] of entries.entries()) {
+        if ('userId' in entry) {
+            throw new MentionSchemaError('userId is not valid in AUN mentions; use {aid: "..."}', index);
+        }
+        const unsupported = Object.keys(entry).find(key => !AUN_MENTION_KEYS.has(key));
+        if (unsupported) {
+            throw new MentionSchemaError(`${unsupported} is not valid AUN mention metadata`, index);
+        }
+    }
+    return entries;
+}

package/dist/aun/msg/p2p.js

@@ -10,6 +10,7 @@ import { resolvePaths } from '../../paths.js';
 import { ipcQuery } from '../../ipc.js';
 import { AGENT_DELEGATION_TOKEN_ENV } from '../../core/auth/agent-delegation.js';
 import { loadDaemonConfig } from '../../config-store.js';
+import { normalizeAunMentionEntries } from './mention-schema.js';
 const DEFAULT_TASK_EXECUTION_MS = 60 * 60 * 1000;
 const DAEMON_SEND_TIMEOUT_GRACE_MS = 10_000;
 const MAX_TIMER_MS = 2_147_483_647;
@@ -206,6 +207,9 @@ export async function msgSend(args) {
         let payload;
         if (args.body.mode !== 'file') {
             payload = buildSimplePayload(args.body);
+            if (Object.prototype.hasOwnProperty.call(payload, 'mentions')) {
+                payload.mentions = normalizeAunMentionEntries(payload.mentions);
+            }
             applyRoutingPayloadFields(payload, args, runtimeContext, false);
             const daemonResult = await tryDaemonMsgSend(args, payload, runtimeContext);
             if (daemonResult)
@@ -265,6 +269,9 @@ export async function msgSend(args) {
         // 5. 写入 payload.thread_id/ref_message_id（如果指定）
         applyRoutingPayloadFields(payload, args, runtimeContext, false);
         applyRoutingPayloadFields(payload, args, runtimeContext);
+        if (Object.prototype.hasOwnProperty.call(payload, 'mentions')) {
+            payload.mentions = normalizeAunMentionEntries(payload.mentions);
+        }
         const encrypt = resolveAunMessageEncrypt(args.encrypt);
         const sendParams = { to: args.to, payload, encrypt };
         const result = await conn.call('message.send', sendParams);

package/dist/aun/msg/upload.js

@@ -2,7 +2,22 @@ import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
 import { guessMime, formatSize } from '../../utils/media-cache.js';
-import { inferPayloadType, isValidPayloadType } from './payload-type.js';
+const EXT_TYPE_MAP = {
+    '.png': 'image', '.jpg': 'image', '.jpeg': 'image',
+    '.gif': 'image', '.webp': 'image', '.svg': 'image',
+    '.bmp': 'image', '.heic': 'image', '.heif': 'image',
+    '.mp4': 'video', '.mov': 'video', '.webm': 'video',
+    '.avi': 'video', '.mkv': 'video', '.m4v': 'video',
+    '.opus': 'voice', '.mp3': 'voice', '.aac': 'voice',
+    '.m4a': 'voice', '.wav': 'voice', '.flac': 'voice', '.ogg': 'voice',
+};
+export function inferPayloadType(filename) {
+    const ext = path.extname(filename).toLowerCase();
+    return EXT_TYPE_MAP[ext] ?? 'file';
+}
+export function isValidPayloadType(value) {
+    return value === 'image' || value === 'video' || value === 'voice' || value === 'file';
+}
 /** 单次上传最大大小（与 daemon sendFile 一致）。 */
 export const MAX_AUN_ATTACHMENT_SIZE = 10 * 1024 * 1024;
 /** server 端 inline 上限错误的识别特征。优先匹配错误消息里的“inline 上限”字样。 */

package/dist/aun/outbox.js

@@ -1,6 +1,7 @@
 import crypto from 'crypto';
 import { agentOutboxPath } from '../paths.js';
 import { atomicRead, atomicWrite } from '../utils/atomic-write.js';
+import { isDeliveryTarget, isDeliveryTargetForChannel, sameDeliveryTarget } from '../core/message/message-utils.js';
 const MAX_ENTRIES_PER_AID = 20;
 const DEFAULT_TTL = 300_000; // 5 minutes
 function outboxFile(aid) {
@@ -16,6 +17,9 @@ function isExpired(entry) {
         return false;
     return Date.now() - entry.ts > entry.ttl;
 }
+export function isDeliveryForChannel(value, channelId) {
+    return isDeliveryTargetForChannel(value, channelId);
+}
 function readEntries(aid) {
     const file = outboxFile(aid);
     try {
@@ -43,17 +47,32 @@ function writeEntries(aid, entries) {
     atomicWrite(file, content);
 }
 export function enqueue(aid, opts) {
-    const existingEntries = readEntries(aid);
+    const delivery = opts.delivery;
+    if (!isDeliveryForChannel(delivery, opts.channelId)) {
+        const code = isDeliveryTarget(delivery) ? 'AUN_OUTBOUND_ROUTE_MISMATCH' : 'AUN_OUTBOUND_ROUTE_REQUIRED';
+        throw Object.assign(new Error(`invalid AUN outbox delivery route for channelId=${opts.channelId}`), { code });
+    }
+    let existingEntries = readEntries(aid);
     if (opts.dedupeKey) {
         const existing = existingEntries.find(entry => entry.dedupeKey === opts.dedupeKey && !isExpired(entry));
-        if (existing)
+        if (existing
+            && existing.channelId === opts.channelId
+            && isDeliveryForChannel(existing.delivery, existing.channelId)
+            && sameDeliveryTarget(existing.delivery, delivery)) {
             return existing;
+        }
+        if (existing) {
+            // A pre-route entry must not block corrected code from persisting the
+            // same logical operation with an explicit delivery target.
+            existingEntries = existingEntries.filter(entry => entry.id !== existing.id);
+        }
     }
     const entry = {
         id: generateId(),
         ts: Date.now(),
         aid,
         channelId: opts.channelId,
+        delivery,
         dedupeKey: opts.dedupeKey,
         critical: opts.critical,
         type: opts.type,
@@ -123,6 +142,9 @@ export function cleanup(aid) {
 // duplicate sends while allowing a later drain trigger to pick up entries
 // enqueued during an active pass.
 const activeDrainTails = new Map();
+function hasRouteForChannel(entry) {
+    return isDeliveryForChannel(entry.delivery, entry.channelId);
+}
 async function drainOnce(aid, sender) {
     const entries = readEntries(aid);
     if (entries.length === 0)
@@ -137,6 +159,13 @@ async function drainOnce(aid, sender) {
             expired++;
             continue;
         }
+        if (!hasRouteForChannel(entry)) {
+            // A route is security-sensitive metadata. An entry whose groupId does
+            // not match its address cannot be repaired from channelId, so remove it
+            // instead of retrying the same malformed send forever.
+            expired++;
+            continue;
+        }
         try {
             entry.attempts = (entry.attempts ?? 0) + 1;
             const ok = await sender(entry);

package/dist/aun/rpc/client.js

@@ -0,0 +1,66 @@
+import { getAidStore, loadClient, SLOT } from '../aid/store.js';
+export async function createShortConnection(aid, opts) {
+    const store = await getAidStore({ slotId: opts?.slotId ?? SLOT.cli, aunPath: opts?.aunPath });
+    try {
+        const client = await loadClient(store, aid);
+        await client.connect({ connection_kind: 'short', short_ttl_ms: 30000, auto_reconnect: false });
+        return {
+            async call(method, params) {
+                return client.call(method, params);
+            },
+            async close() {
+                try {
+                    await client.close();
+                }
+                finally {
+                    store.close();
+                }
+            },
+        };
+    }
+    catch (error) {
+        store.close();
+        throw error;
+    }
+}
+export async function rpcCall(aid, method, params, opts) {
+    const conn = await createShortConnection(aid, opts);
+    try {
+        const result = await conn.call(method, params);
+        return { ok: true, result };
+    }
+    catch (error) {
+        if (error.code !== undefined && error.message !== undefined) {
+            return { ok: false, error: { code: error.code, message: error.message, data: error.data } };
+        }
+        return { ok: false, error: { code: -1, message: String(error.message || error) } };
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function rpcBatch(aid, calls, opts) {
+    const conn = await createShortConnection(aid, opts);
+    const results = [];
+    try {
+        for (const { method, params } of calls) {
+            try {
+                const result = await conn.call(method, params);
+                results.push({ ok: true, result });
+            }
+            catch (error) {
+                if (error.code !== undefined && error.message !== undefined) {
+                    results.push({ ok: false, error: { code: error.code, message: error.message, data: error.data } });
+                }
+                else {
+                    results.push({ ok: false, error: { code: -1, message: String(error.message || error) } });
+                }
+                break;
+            }
+        }
+    }
+    finally {
+        await conn.close();
+    }
+    return results;
+}

package/dist/aun/rpc/index.js

@@ -1,2 +1 @@
-export { rpcCall, rpcBatch } from './caller.js';
-export { createShortConnection } from './connection.js';
+export { rpcCall, rpcBatch, createShortConnection } from './client.js';

package/dist/aun/storage/{upload.js → client.js}

@@ -46,7 +46,7 @@ export async function storageUpload(aid, localFile, remotePath, opts) {
         sha256,
         content_type: contentType,
         size_bytes: fileBuffer.length,
-        is_private: !(opts?.isPublic),
+        is_private: !opts?.isPublic,
     }, { aunPath: opts?.aunPath });
     if (!completeResult.ok) {
         return { ok: false, objectKey: remotePath, error: rpcErrorToString(completeResult.error) };
@@ -56,7 +56,7 @@ export async function storageUpload(aid, localFile, remotePath, opts) {
         if (!publicUrl) {
             const ticketResult = await rpcCall(aid, 'storage.create_download_ticket', {
                 object_key: remotePath,
-                expire_in_seconds: 86400 * 30, // 30天
+                expire_in_seconds: 86400 * 30,
             }, { aunPath: opts?.aunPath });
             if (ticketResult.ok) {
                 publicUrl = pickUrl(ticketResult.result?.url) ?? pickUrl(ticketResult.result?.download_url);
@@ -66,3 +66,12 @@ export async function storageUpload(aid, localFile, remotePath, opts) {
     }
     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 });
+}
+export async function storageQuota(aid, opts) {
+    return rpcCall(aid, 'storage.get_quota', {}, { aunPath: opts?.aunPath });
+}

package/dist/aun/storage/index.js

@@ -1,3 +1,2 @@
-export { storageUpload } from './upload.js';
+export { storageUpload, storageLs, storageRm, storageQuota } from './client.js';
 export { storageDownload } from './download.js';
-export { storageLs, storageRm, storageQuota } from './manage.js';