evolcore 0.0.2 → 0.0.4

package/dist/core/evolagent-registry.js

@@ -2,7 +2,8 @@ import fs from 'fs';
 import path from 'path';
 import { EvolAgent } from './evolagent.js';
 import { logger } from '../utils/logger.js';
-import { agentMdPath, agentPersonalDir } from '../paths.js';
+import { agentPersonalDir } from '../paths.js';
+import { invalidateAgentDisplayName, resolveAgentDisplayName } from '../aun/aid/agentmd.js';
 import { loadAllAgents, ensureAgentDirSkeleton, loadAgent, validateAgentConfig, } from '../config-store.js';
 import { resolveEffective } from '../config/config-manager.js';
 // ── Channel Fingerprint ───────────────────────────────────────────────────
@@ -129,7 +130,6 @@ export class EvolAgentRegistry {
                 aid: raw.aid,
                 enabled: raw.enabled,
                 owners: raw.owners,
-                admins: raw.admins,
                 channels: Array.isArray(raw.channels) ? raw.channels : [],
                 active_baseagent: raw.active_baseagent,
                 baseagents: raw.baseagents,
@@ -211,9 +211,8 @@ export class EvolAgentRegistry {
         return [...this.agents.values()].map(a => this.toInfo(a));
     }
     invalidateAgentDisplayCache(aid) {
-        this.displayNameCache.delete(aid);
+        invalidateAgentDisplayName(aid);
         this.personalNameCache.delete(aid);
-        this.displayNamePending.delete(aid);
     }
     runnableAgents() {
         return [...this.agents.values()].filter(a => a.status === 'stopped');
@@ -443,43 +442,8 @@ export class EvolAgentRegistry {
         }
         return null;
     }
-    displayNameCache = new Map();
-    displayNamePending = new Set();
     resolveDisplayName(aid) {
-        const cached = this.displayNameCache.get(aid);
-        if (cached)
-            return cached;
-        try {
-            const mdPath = agentMdPath(aid);
-            if (fs.existsSync(mdPath)) {
-                const content = fs.readFileSync(mdPath, 'utf-8');
-                const fm = content.match(/^---\n([\s\S]*?)\n---/);
-                if (fm) {
-                    const nm = fm[1].match(/^name:\s*["']?(.+?)["']?\s*$/m);
-                    if (nm?.[1]) {
-                        this.displayNameCache.set(aid, nm[1]);
-                        return nm[1];
-                    }
-                }
-            }
-        }
-        catch { }
-        if (!this.displayNamePending.has(aid)) {
-            this.displayNamePending.add(aid);
-            import('../aun/aid/index.js').then(({ agentmdGet }) => {
-                agentmdGet(aid).then(content => {
-                    if (typeof content === 'string') {
-                        const fm = content.match(/^---\n([\s\S]*?)\n---/);
-                        if (fm) {
-                            const nm = fm[1].match(/^name:\s*["']?(.+?)["']?\s*$/m);
-                            if (nm?.[1])
-                                this.displayNameCache.set(aid, nm[1]);
-                        }
-                    }
-                }).catch(() => { }).finally(() => this.displayNamePending.delete(aid));
-            }).catch(() => { this.displayNamePending.delete(aid); });
-        }
-        return undefined;
+        return resolveAgentDisplayName(aid);
     }
     personalNameCache = new Map();
     resolvePersonalName(aid) {

package/dist/core/evolagent.js

@@ -1,9 +1,11 @@
 import path from 'path';
-import { formatChannelKey } from './channel-loader.js';
+import { formatChannelKey, tryParseChannelKey } from './channel-loader.js';
 import { agentPersonalDir } from '../paths.js';
 import { fileCache } from './daemon-file-cache.js';
 import { ConfigTarget, read as cfgRead, write as cfgWrite, ensureFile as cfgEnsure, resolveEffective } from '../config/config-manager.js';
 import { withLifecycleForWrite } from '../config/lifecycle.js';
+import { isStaticAgentAdmin, isStaticAgentOwner } from '../config/peer-role-resolver.js';
+import { resolvePrincipal } from '../config/contact-book.js';
 /**
  * EvolAgent —— 一个 self-agent 的运行时表示。
  *
@@ -123,19 +125,28 @@ export class EvolAgent {
     /**
      * Check if a user has owner role for this agent (private scope).
      */
-    isOwner(_channelKey, userId) {
-        if (this.merged.owners?.includes(userId))
-            return true;
-        return false;
+    isOwner(channelKey, userId) {
+        const principalId = this.managementPrincipal(channelKey, userId);
+        return !!principalId && isStaticAgentOwner(this.aid, principalId);
     }
     /**
      * Check if a user has admin role for this agent (private scope).
-     * Uses static owners/admins from agent config.
+     * Owner remains in Agent config; admin is resolved from the direct AUN relation.
      */
-    isAdmin(_channelKey, userId) {
-        if (this.isOwner(_channelKey, userId))
+    isAdmin(channelKey, userId) {
+        const principalId = this.managementPrincipal(channelKey, userId);
+        if (!principalId)
+            return false;
+        if (isStaticAgentOwner(this.aid, principalId))
             return true;
-        return this.merged.admins?.includes(userId) ?? false;
+        return isStaticAgentAdmin(this.aid, principalId);
+    }
+    managementPrincipal(channelKey, userId) {
+        const channelType = tryParseChannelKey(channelKey)?.type ?? String(channelKey || '').split('#')[0];
+        const resolution = resolvePrincipal(this.aid, channelType, userId, channelKey);
+        return resolution.principalStatus === 'native_aid' || resolution.principalStatus === 'mapped'
+            ? resolution.principalId ?? null
+            : null;
     }
     /**
      * Get the first owner of this agent (private scope).

package/dist/core/handoff/runtime.js

@@ -5,6 +5,10 @@ import { KeyedFairMutex } from './mutex.js';
 import { HandoffStore } from './store.js';
 import { createRootCausation, deriveCausation, normalizeCausation } from '../causation/context.js';
 import { recordCausationSpan } from '../causation/audit.js';
+import { logger } from '../../utils/logger.js';
+const HANDOFF_STALE_WARN_MS = 72 * 60 * 60 * 1000;
+const HANDOFF_LARGE_AGGREGATE_COUNT = 10;
+const HANDOFF_LARGE_AGGREGATE_CHARS = 50_000;
 export class HandoffTargetBlockedError extends Error {
     blockingHandoffId;
     attentionReason;
@@ -25,6 +29,20 @@ export class HandoffDeliveryFailedError extends Error {
         this.name = 'HandoffDeliveryFailedError';
     }
 }
+export class HandoffReturnPolicyRequiredError extends Error {
+    code = 'HANDOFF_RETURN_POLICY_REQUIRED';
+    constructor() {
+        super('跨会话 ec msg/group send 必须显式指定 --return none|required');
+        this.name = 'HandoffReturnPolicyRequiredError';
+    }
+}
+export class TriggerHandoffRequiredForbiddenError extends Error {
+    code = 'TRIGGER_HANDOFF_REQUIRED_FORBIDDEN';
+    constructor() {
+        super('Trigger 的跨会话 ec msg/group send 只允许 --return none，不能使用 required');
+        this.name = 'TriggerHandoffRequiredForbiddenError';
+    }
+}
 export class HandoffRuntime {
     sessionManager;
     messageQueue;
@@ -32,6 +50,8 @@ export class HandoffRuntime {
     mutexes = new KeyedFairMutex();
     dispatcher;
     now;
+    staleWarned = new Set();
+    largeAggregateWarned = new Set();
     constructor(sessionManager, messageQueue, sender, store = new HandoffStore(), options = {}) {
         this.sessionManager = sessionManager;
         this.messageQueue = messageQueue;
@@ -56,6 +76,11 @@ export class HandoffRuntime {
         if (target.id === origin.id) {
             return { crossSession: false, targetSession: target };
         }
+        if (!input.explicitReturnPolicy)
+            throw new HandoffReturnPolicyRequiredError();
+        if (input.explicitReturnPolicy === 'required' && input.causation?.trigger?.path.length) {
+            throw new TriggerHandoffRequiredForbiddenError();
+        }
         await this.dispatcher.expireTargetQueued(input.selfAid, target.id);
         throwIfAborted(input.signal);
         const head = this.store.listByTarget(input.selfAid, target.id, 'queued')[0];
@@ -91,7 +116,8 @@ export class HandoffRuntime {
     }
     hasOpenTarget(selfAid, targetSessionId) {
         return this.store.listByTarget(selfAid, targetSessionId)
-            .some(instance => instance.state === 'target_sent' || instance.state === 'return_pending');
+            .some(instance => instance.state === 'target_sent'
+            || (instance.state === 'return_pending' && instance.return_policy === 'required'));
     }
     async bindReply(input) {
         const key = `${input.selfAid}\u0000${input.targetSessionId}`;
@@ -105,6 +131,8 @@ export class HandoffRuntime {
                 responseMessageId: input.responseMessageId,
                 refMessageId: input.refMessageId,
             });
+            for (const instance of attached)
+                this.warnIfStale(instance);
             const handoffIds = attached.map(instance => instance.handoff_id);
             return {
                 candidate: handoffIds.length > 0,
@@ -157,6 +185,7 @@ export class HandoffRuntime {
             messageId,
             timestamp: Date.now(),
             source: 'handoff',
+            boundSessionId: origin.id,
             causation: instance.return_causation
                 ? deriveCausation(instance.return_causation)
                 : instance.causation
@@ -186,55 +215,120 @@ export class HandoffRuntime {
         }
     }
     buildPromptItem(message) {
-        const delivery = message.handoffDelivery;
-        const selfAid = message.selfAID;
-        if (!delivery || !selfAid)
-            return null;
-        const instance = this.store.get(selfAid, delivery.handoffId);
-        if (!instance)
-            return null;
-        if (delivery.direction === 'target' && instance.state !== 'return_pending')
-            return null;
-        if (delivery.direction === 'origin' && instance.state !== 'origin_delivered')
-            return null;
-        return {
-            kind: 'handoff',
-            peerId: message.peerId,
-            peerName: message.peerName,
-            peerType: message.peerType,
-            content: message.content,
-            timestamp: message.timestamp,
-            causation: message.causation,
-            handoff: {
-                kind: delivery.direction === 'target' ? 'request_to_target' : 'response_to_origin',
-                handoffId: instance.handoff_id,
-                previousContent: this.requestSummary(instance),
-                previousMessageId: instance.target_message_id,
-                returnPolicy: instance.return_policy,
-            },
-        };
+        return this.buildPromptItems(message)[0] ?? null;
     }
     buildPromptItems(message) {
         const delivery = message.handoffDelivery;
-        if (!delivery)
+        const selfAid = message.selfAID;
+        if (!delivery || !selfAid)
             return [];
         const ids = delivery.handoffIds?.length ? delivery.handoffIds : [delivery.handoffId];
-        const items = [];
+        const instances = [];
         for (const handoffId of ids) {
-            const item = this.buildPromptItem({
-                ...message,
-                handoffDelivery: { direction: delivery.direction, handoffId },
-            });
-            if (item)
-                items.push(item);
+            const instance = this.store.get(selfAid, handoffId);
+            if (!instance || instance.attention_required)
+                continue;
+            if (delivery.direction === 'target') {
+                const expectedState = instance.return_policy === 'none'
+                    ? 'target_context_pending'
+                    : 'return_pending';
+                if (instance.state !== expectedState)
+                    continue;
+            }
+            else if (instance.state !== 'origin_delivered') {
+                continue;
+            }
+            instances.push(instance);
+        }
+        if (instances.length === 0)
+            return [];
+        if (delivery.direction === 'origin') {
+            this.warnIfLargeAggregate(message, instances, 'origin');
+            const first = instances[0];
+            return [{
+                    kind: 'handoff',
+                    peerId: message.peerId,
+                    peerName: message.peerName,
+                    peerType: message.peerType,
+                    content: message.content,
+                    timestamp: message.timestamp,
+                    causation: message.causation,
+                    handoff: {
+                        kind: 'response_to_origin',
+                        handoffId: first.handoff_id,
+                        handoffIds: instances.map(instance => instance.handoff_id),
+                        originEntries: instances.map(instance => ({
+                            previousContent: this.requestSummary(instance),
+                            responseContent: instance.return_content ?? '',
+                            previousMessageId: instance.target_message_id,
+                        })),
+                        previousContent: this.requestSummary(first),
+                        previousMessageId: first.target_message_id,
+                        returnPolicy: first.return_policy,
+                    },
+                }];
         }
-        return items;
+        const requiredEntries = instances
+            .filter(instance => instance.return_policy === 'required')
+            .map(instance => ({
+            handoffId: instance.handoff_id,
+            previousContent: this.requestSummary(instance),
+            previousMessageId: instance.target_message_id,
+        }));
+        const contextEntries = instances
+            .filter(instance => instance.return_policy === 'none')
+            .map(instance => ({
+            previousContent: this.requestSummary(instance),
+            previousMessageId: instance.target_message_id,
+        }));
+        this.warnIfLargeAggregate(message, instances, 'target');
+        const first = instances[0];
+        return [{
+                kind: 'handoff',
+                peerId: message.peerId,
+                peerName: message.peerName,
+                peerType: message.peerType,
+                content: message.content,
+                timestamp: message.timestamp,
+                causation: message.causation,
+                handoff: {
+                    kind: 'request_to_target',
+                    handoffId: first.handoff_id,
+                    handoffIds: instances.map(instance => instance.handoff_id),
+                    requiredEntries,
+                    contextEntries,
+                    previousContent: this.requestSummary(first),
+                    previousMessageId: first.target_message_id,
+                    returnPolicy: requiredEntries.length > 0 ? 'required' : 'none',
+                },
+            }];
     }
     completeOriginContext(selfAid, handoffId) {
         const instance = this.store.get(selfAid, handoffId);
         if (instance?.state === 'origin_delivered')
             this.store.completeOriginContext(selfAid, handoffId);
     }
+    completeTargetContext(selfAid, handoffId) {
+        const instance = this.store.get(selfAid, handoffId);
+        if (instance?.state === 'target_context_pending' && instance.return_policy === 'none') {
+            this.store.completeTargetContext(selfAid, handoffId);
+        }
+    }
+    validateTargetSessionBinding(selfAid, handoffIds, executionSessionId) {
+        const invalidHandoffIds = [];
+        for (const handoffId of handoffIds) {
+            const instance = this.store.get(selfAid, handoffId);
+            if (!instance
+                || instance.target_session_id !== executionSessionId
+                || instance.consumed_target_session_id !== executionSessionId) {
+                invalidHandoffIds.push(handoffId);
+                if (instance && !instance.attention_required) {
+                    this.store.markAttention(selfAid, handoffId, 'HANDOFF_SESSION_BINDING_MISMATCH');
+                }
+            }
+        }
+        return { ok: invalidHandoffIds.length === 0, invalidHandoffIds };
+    }
     status(selfAid, handoffId) {
         return this.store.status(selfAid, handoffId);
     }
@@ -276,6 +370,10 @@ export class HandoffRuntime {
     async recover(selfAids) {
         const originEnqueues = [];
         for (const selfAid of selfAids) {
+            // v1 initially represented return=none as return_pending and required an
+            // empty manual return. It has already been shown to a target turn, so
+            // finish it before version reconciliation instead of prompting again.
+            this.store.migrateLegacyNonePending(selfAid, this.now?.());
             this.expireQueued([selfAid]);
             const events = this.store.events(selfAid);
             const lastSendEvent = new Map();
@@ -285,6 +383,7 @@ export class HandoffRuntime {
                 }
             }
             for (const instance of this.store.list(selfAid)) {
+                this.warnIfStale(instance);
                 const versionedEvents = events.filter(event => event.handoff_id === instance.handoff_id && event.to_version !== undefined);
                 const latestEventVersion = versionedEvents.reduce((latest, event) => Math.max(latest, event.to_version ?? 0), 0);
                 if (latestEventVersion !== instance.version) {
@@ -313,6 +412,32 @@ export class HandoffRuntime {
         }
         await Promise.all(originEnqueues);
     }
+    warnIfStale(instance) {
+        if (instance.state !== 'target_sent' && instance.state !== 'return_pending')
+            return;
+        const ageMs = (this.now?.() ?? Date.now()) - instance.created_at;
+        const key = instance.handoff_id;
+        if (ageMs < HANDOFF_STALE_WARN_MS || this.staleWarned.has(key))
+            return;
+        this.staleWarned.add(key);
+        logger.warn(`[Handoff] stale open handoff id=${instance.handoff_id}`
+            + ` state=${instance.state} returnPolicy=${instance.return_policy}`
+            + ` ageHours=${Math.floor(ageMs / 3_600_000)}`
+            + ` originSession=${instance.origin_session_id} targetSession=${instance.target_session_id}`);
+    }
+    warnIfLargeAggregate(message, instances, direction) {
+        const chars = message.content.length
+            + instances.reduce((total, instance) => total + this.requestSummary(instance).length, 0);
+        if (instances.length < HANDOFF_LARGE_AGGREGATE_COUNT && chars < HANDOFF_LARGE_AGGREGATE_CHARS)
+            return;
+        const key = `${message.messageId ?? '<none>'}:${instances.map(instance => instance.handoff_id).join(',')}`;
+        if (this.largeAggregateWarned.has(key))
+            return;
+        this.largeAggregateWarned.add(key);
+        logger.warn(`[Handoff] large prompt aggregate direction=${direction}`
+            + ` session=${direction === 'target' ? instances[0].target_session_id : instances[0].origin_session_id}`
+            + ` count=${instances.length} chars=${chars} responseMessage=${message.messageId ?? '<none>'}`);
+    }
     requestSummary(instance) {
         return classifyAunPayloadForLog(instance.request.payload).content || '[payload]';
     }

package/dist/core/handoff/store.js

@@ -272,7 +272,8 @@ export class HandoffStore {
     }
     attachSessionContext(input) {
         const open = this.listByTarget(input.selfAid, input.targetSessionId)
-            .filter(item => (item.state === 'target_sent' || item.state === 'return_pending') && !item.attention_required)
+            .filter(item => (item.state === 'target_sent'
+            || (item.state === 'return_pending' && item.return_policy === 'required')) && !item.attention_required)
             .sort((left, right) => {
             const leftRef = input.refMessageId && left.target_message_id === input.refMessageId ? 0 : 1;
             const rightRef = input.refMessageId && right.target_message_id === input.refMessageId ? 0 : 1;
@@ -283,7 +284,9 @@ export class HandoffStore {
             const previousVersion = instance.version;
             const firstAttachment = instance.state === 'target_sent';
             if (firstAttachment) {
-                instance.state = 'return_pending';
+                instance.state = instance.return_policy === 'none'
+                    ? 'target_context_pending'
+                    : 'return_pending';
                 instance.response_message_id = input.responseMessageId;
                 instance.consumed_at = now;
                 instance.consumed_target_session_id = input.targetSessionId;
@@ -308,6 +311,47 @@ export class HandoffStore {
     bindExactReply(input) {
         return this.attachSessionContext(input)[0] ?? null;
     }
+    completeTargetContext(selfAid, handoffId, now = Date.now()) {
+        const instance = this.requireState(selfAid, handoffId, 'target_context_pending');
+        if (instance.return_policy !== 'none') {
+            throw new Error('target context auto-completion requires return=none');
+        }
+        const previous = instance.version;
+        instance.state = 'completed';
+        instance.version++;
+        instance.updated_at = now;
+        instance.completed_at = now;
+        this.appendEvent(selfAid, 'target_context_consumed', handoffId, {
+            operationKey: instance.response_message_id ?? undefined,
+            fromVersion: previous,
+            toVersion: instance.version,
+            now,
+        });
+        this.write(selfAid, instance);
+        return instance;
+    }
+    migrateLegacyNonePending(selfAid, now = Date.now()) {
+        const migrated = [];
+        for (const instance of this.list(selfAid)) {
+            if (instance.return_policy !== 'none' || instance.state !== 'return_pending')
+                continue;
+            const previous = instance.version;
+            instance.state = 'completed';
+            instance.version++;
+            instance.updated_at = now;
+            instance.completed_at = now;
+            this.appendEvent(selfAid, 'target_context_consumed', instance.handoff_id, {
+                operationKey: instance.response_message_id ?? undefined,
+                fromVersion: previous,
+                toVersion: instance.version,
+                details: { migration: true, previous_state: 'return_pending' },
+                now,
+            });
+            this.write(selfAid, instance);
+            migrated.push(instance);
+        }
+        return migrated;
+    }
     returnHandoff(input) {
         const selected = this.selectReturnCandidate(input);
         if ('ok' in selected)

package/dist/core/handoff/types.js

@@ -3,6 +3,7 @@ export const HANDOFF_STATES = [
     'queued',
     'failed',
     'target_sent',
+    'target_context_pending',
     'return_pending',
     'origin_queued',
     'origin_delivered',

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

@@ -1,10 +1,9 @@
-import { createHash } from 'crypto';
-import { resolveAnthropicConfig, resolveOpenaiConfig, } from '../../agents/baseagent.js';
-const MODEL_LIST_TTL_MS = 5 * 60 * 1000;
-const MODEL_LIST_MAX_PAGES = 20;
-const anthropicModelListCache = new Map();
-function apiEndpoint(baseUrl, defaultBaseUrl, resource) {
-    const base = (baseUrl || defaultBaseUrl).replace(/\/+$/, '');
+import { normalizeBaseagent, resolveAnthropicDirectConfig, resolveOpenaiDirectConfig, } from '../../agents/baseagent.js';
+function apiEndpoint(baseUrl, resource) {
+    const configured = baseUrl?.trim();
+    if (!configured)
+        throw new Error('Direct text inference baseUrl is not configured');
+    const base = configured.replace(/\/+$/, '');
     return base.endsWith('/v1') ? `${base}/${resource}` : `${base}/v1/${resource}`;
 }
 async function parseError(response) {
@@ -28,53 +27,8 @@ export class AnthropicTextInferenceProvider {
     constructor(config) {
         this.config = config;
     }
-    async listModels(signal) {
-        const cacheKey = this.modelListCacheKey();
-        const cached = anthropicModelListCache.get(cacheKey);
-        if (cached && Date.now() - cached.fetchedAt < MODEL_LIST_TTL_MS)
-            return [...cached.models];
-        const models = [];
-        const seen = new Set();
-        let afterId;
-        for (let page = 0; page < MODEL_LIST_MAX_PAGES; page++) {
-            const endpoint = new URL(apiEndpoint(this.config.baseUrl, 'https://api.anthropic.com', 'models'));
-            endpoint.searchParams.set('limit', '100');
-            if (afterId)
-                endpoint.searchParams.set('after_id', afterId);
-            const response = await fetch(endpoint, {
-                method: 'GET',
-                signal,
-                headers: this.headers(),
-            });
-            if (!response.ok)
-                throw await parseError(response);
-            const body = await response.json();
-            const entries = Array.isArray(body.data)
-                ? body.data
-                : (Array.isArray(body.models) ? body.models : []);
-            for (const entry of entries) {
-                const id = typeof entry === 'string'
-                    ? entry
-                    : entry?.id || entry?.name || entry?.model;
-                if (typeof id !== 'string' || !id.trim() || seen.has(id))
-                    continue;
-                seen.add(id);
-                models.push(id);
-            }
-            if (body.has_more !== true)
-                break;
-            const next = typeof body.last_id === 'string' && body.last_id ? body.last_id : undefined;
-            if (!next || next === afterId)
-                throw new Error('Claude model list pagination returned no next cursor');
-            afterId = next;
-        }
-        if (models.length === 0)
-            throw new Error('Claude model list API returned no models');
-        anthropicModelListCache.set(cacheKey, { models, fetchedAt: Date.now() });
-        return [...models];
-    }
     async completeText(request) {
-        const response = await fetch(apiEndpoint(this.config.baseUrl, 'https://api.anthropic.com', 'messages'), {
+        const response = await fetch(apiEndpoint(this.config.baseUrl, 'messages'), {
             method: 'POST',
             signal: request.signal,
             headers: this.headers(),
@@ -83,6 +37,7 @@ export class AnthropicTextInferenceProvider {
                 max_tokens: 256,
                 system: request.system,
                 messages: [{ role: 'user', content: request.input }],
+                ...(request.effort ? { output_config: { effort: request.effort } } : {}),
             }),
         });
         if (!response.ok)
@@ -106,14 +61,6 @@ export class AnthropicTextInferenceProvider {
             Authorization: `Bearer ${this.config.apiKey}`,
         };
     }
-    modelListCacheKey() {
-        const endpoint = apiEndpoint(this.config.baseUrl, 'https://api.anthropic.com', 'models');
-        const credential = createHash('sha256').update(this.config.apiKey).digest('hex');
-        return `${endpoint}\0${credential}`;
-    }
-}
-export function _resetTextInferenceModelCacheForTests() {
-    anthropicModelListCache.clear();
 }
 export class OpenAITextInferenceProvider {
     config;
@@ -122,7 +69,7 @@ export class OpenAITextInferenceProvider {
         this.config = config;
     }
     async completeText(request) {
-        const response = await fetch(apiEndpoint(this.config.baseUrl, 'https://api.openai.com', 'responses'), {
+        const response = await fetch(apiEndpoint(this.config.baseUrl, 'responses'), {
             method: 'POST',
             signal: request.signal,
             headers: {
@@ -155,19 +102,14 @@ export class OpenAITextInferenceProvider {
     }
 }
 export function createTextInferenceProvider(baseagent, config) {
-    if (baseagent === 'claude') {
-        const override = config.baseagents?.claude;
-        if (!override)
-            return undefined;
-        const synthetic = { agents: { claude: override } };
-        return new AnthropicTextInferenceProvider(resolveAnthropicConfig(synthetic, override));
+    const canonical = normalizeBaseagent(baseagent).canonical;
+    if (canonical === 'claude') {
+        const resolved = resolveAnthropicDirectConfig(config.baseagents?.claude);
+        return resolved ? new AnthropicTextInferenceProvider(resolved) : undefined;
     }
-    if (baseagent === 'codex') {
-        const override = config.baseagents?.codex;
-        if (!override)
-            return undefined;
-        const synthetic = { agents: { codex: override } };
-        return new OpenAITextInferenceProvider(resolveOpenaiConfig(synthetic, override));
+    if (canonical === 'codex') {
+        const resolved = resolveOpenaiDirectConfig(config.baseagents?.codex);
+        return resolved ? new OpenAITextInferenceProvider(resolved) : undefined;
     }
     return undefined;
 }

package/dist/core/message/file-markers.js

@@ -0,0 +1,7 @@
+/**
+ * A file marker may contain surrounding whitespace inside its brackets so
+ * formatted responses such as `[ SEND_FILE:./report.md ]` remain actionable.
+ */
+export function createSendFileMarkerPattern() {
+    return /\[\s*SEND_FILE:(?:(\w+):)?([^\]]*?\S[^\]]*?)\s*\]/g;
+}