evolcore 0.0.4 → 0.0.6

package/dist/core/handoff/store.js

@@ -1,7 +1,7 @@
 import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
-import { resolveRoot } from '../../paths.js';
+import { resolvePaths } from '../../paths.js';
 import { atomicReadJson } from '../../utils/atomic-write.js';
 import { appendJsonl, readAllJsonlLines } from '../session/session-fs-store.js';
 import { classifyAunPayloadForLog } from '../message/message-log.js';
@@ -38,11 +38,21 @@ function boundedQueryLimit(limit) {
 }
 export class HandoffStore {
     rootDir;
-    constructor(rootDir = path.join(resolveRoot(), 'data', 'handoff')) {
-        this.rootDir = rootDir;
+    perAgentLayout;
+    /**
+     * The default store follows the runtime layout. An explicit root remains a
+     * self-contained test/embedding store with the historical `<root>/<aid>`
+     * shape, avoiding a hidden filesystem dependency in callers that inject it.
+     */
+    constructor(rootDir) {
+        this.rootDir = rootDir ?? resolvePaths().agentsDir;
+        this.perAgentLayout = rootDir === undefined;
     }
     agentDir(selfAid) {
-        return path.join(this.rootDir, safeSegment(selfAid, 'self_aid'));
+        const aid = safeSegment(selfAid, 'self_aid');
+        return this.perAgentLayout
+            ? path.join(this.rootDir, aid, 'data', 'handoff')
+            : path.join(this.rootDir, aid);
     }
     handoffsDir(selfAid) {
         return path.join(this.agentDir(selfAid), 'handoffs');

package/dist/core/inference/text-inference.js

@@ -1,4 +1,4 @@
-import { normalizeBaseagent, resolveAnthropicDirectConfig, resolveOpenaiDirectConfig, } from '../../agents/baseagent.js';
+import { normalizeBaseagent, resolveAnthropicDirectConfig, resolveEcagentConfig, resolveOpenaiDirectConfig, } from '../../agents/baseagent.js';
 function apiEndpoint(baseUrl, resource) {
     const configured = baseUrl?.trim();
     if (!configured)
@@ -101,6 +101,38 @@ export class OpenAITextInferenceProvider {
         return text;
     }
 }
+export class EcagentTextInferenceProvider {
+    config;
+    baseagent = 'ecagent';
+    constructor(config) {
+        this.config = config;
+    }
+    async completeText(request) {
+        const response = await fetch(apiEndpoint(this.config.baseUrl, 'chat/completions'), {
+            method: 'POST',
+            signal: request.signal,
+            headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${this.config.apiKey}` },
+            body: JSON.stringify({
+                model: request.model,
+                messages: [{ role: 'system', content: request.system }, { role: 'user', content: request.input }],
+                max_tokens: 256,
+                ...(request.effort ? { reasoning_effort: request.effort } : {}),
+            }),
+        });
+        if (!response.ok)
+            throw await parseError(response);
+        const body = await response.json();
+        const content = body.choices?.[0]?.message?.content;
+        const text = typeof content === 'string'
+            ? content
+            : Array.isArray(content)
+                ? content.filter((item) => item?.type === 'text').map((item) => item.text || '').join('')
+                : '';
+        if (!text)
+            throw new Error('ecagent text inference response contained no text');
+        return text;
+    }
+}
 export function createTextInferenceProvider(baseagent, config) {
     const canonical = normalizeBaseagent(baseagent).canonical;
     if (canonical === 'claude') {
@@ -111,5 +143,14 @@ export function createTextInferenceProvider(baseagent, config) {
         const resolved = resolveOpenaiDirectConfig(config.baseagents?.codex);
         return resolved ? new OpenAITextInferenceProvider(resolved) : undefined;
     }
+    if (canonical === 'ecagent') {
+        try {
+            const resolved = resolveEcagentConfig({ agents: { ecagent: config.baseagents?.ecagent } }, config.baseagents?.ecagent);
+            return new EcagentTextInferenceProvider(resolved);
+        }
+        catch {
+            return undefined;
+        }
+    }
     return undefined;
 }

package/dist/core/message/inbound-admission.js

@@ -44,6 +44,23 @@ export function evaluateInboundAdmissionPreflight(input) {
             }
         }
     }
+    else {
+        // Group admission is based on group membership in `contacts` mode, but
+        // owners mode still needs to identify an Owner sender. Resolve only the
+        // canonical identity needed for that distinction; group messages do not
+        // use contact status or private-channel blocking rules.
+        try {
+            const principal = resolvePrincipal(selfAid, channelType, actorId, input.channelKey);
+            if (principal.principalId) {
+                context.primaryId = principal.principalId;
+                context.isOwner = resolveContactView(selfAid, principal.principalId).isOwner;
+            }
+        }
+        catch {
+            // Open/contacts group admission remains membership-based even when a
+            // native identity cannot be resolved through the contact book.
+        }
+    }
     try {
         context.policy = readAccessPolicy(selfAid);
     }
@@ -62,26 +79,19 @@ export function evaluateOrdinaryInboundAdmission(context) {
     if (!policy)
         return { allow: false, reason: 'invalid_access_policy', context };
     if (context.chatType === 'group') {
-        if (policy.policyMode === 'owners-only') {
-            return { allow: false, reason: 'owners_only', context };
-        }
-        // `open` is genuinely open: group traffic is not gated by the optional
-        // channel allow-list. In `contacts`, AUN groups are currently open once
-        // the agent is receiving that group; non-AUN channels remain explicit.
-        if (policy.policyMode === 'open'
-            || (policy.policyMode === 'contacts' && context.channelType === 'aun')) {
+        if (context.isOwner)
+            return { allow: true, reason: 'owner', context };
+        if (policy.policyMode === 'open' || policy.policyMode === 'contacts') {
             return { allow: true, reason: 'group_channel_allowed', context };
         }
-        return policy.allowedGroupChannels.includes(context.channelKey)
-            ? { allow: true, reason: 'group_channel_allowed', context }
-            : { allow: false, reason: 'group_channel_denied', context };
+        return { allow: false, reason: 'owners', context };
     }
     if (context.isOwner)
         return { allow: true, reason: 'owner', context };
     if (policy.policyMode === 'open')
         return { allow: true, reason: 'open', context };
-    if (policy.policyMode === 'owners-only')
-        return { allow: false, reason: 'owners_only', context };
+    if (policy.policyMode === 'owners')
+        return { allow: false, reason: 'owners', context };
     if (context.primaryId && isAcceptedContact(context.selfAid, context.primaryId)) {
         return { allow: true, reason: 'contact', context };
     }

package/dist/core/message/pending-hints.js

@@ -4,7 +4,7 @@
 // 在下一条对端消息到达、渲染该轮 prompt 时一次性消费、注入渲染层。
 // 详见 docs/observer-insert-design.md 第一部分（§1.3 文件生命周期 / §1.4 thread 作用域）。
 //
-// 文件：sessions/<channelType>/<selfAID>/<对端>/pending-hints.jsonl（与 messages.jsonl 同级）
+// 文件：agents/<selfAID>/sessions/<channelSessionKey>/pending-hints.jsonl（与 messages.jsonl 同级）
 // 每行一个事件：
 //   { action:'add',    id, text, threadId, ownerAid, ts }
 //   { action:'remove', targetId?, threadId, ts }   // 无 targetId = 撤该 thread 全部