evolcore 0.0.1 → 0.0.2

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

@@ -0,0 +1,173 @@
+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(/\/+$/, '');
+    return base.endsWith('/v1') ? `${base}/${resource}` : `${base}/v1/${resource}`;
+}
+async function parseError(response) {
+    let raw = '';
+    try {
+        raw = await response.text();
+    }
+    catch { }
+    let detail = raw;
+    try {
+        const body = JSON.parse(raw);
+        detail = body?.error?.message || body?.message || body?.detail || raw;
+    }
+    catch { }
+    const suffix = detail ? `: ${String(detail).slice(0, 500)}` : '';
+    return new Error(`Text inference request failed with HTTP ${response.status}${suffix}`);
+}
+export class AnthropicTextInferenceProvider {
+    config;
+    baseagent = 'claude';
+    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'), {
+            method: 'POST',
+            signal: request.signal,
+            headers: this.headers(),
+            body: JSON.stringify({
+                model: request.model,
+                max_tokens: 256,
+                system: request.system,
+                messages: [{ role: 'user', content: request.input }],
+            }),
+        });
+        if (!response.ok)
+            throw await parseError(response);
+        const body = await response.json();
+        const text = Array.isArray(body.content)
+            ? body.content
+                .filter((item) => item?.type === 'text' && typeof item.text === 'string')
+                .map((item) => item.text)
+                .join('')
+            : '';
+        if (!text)
+            throw new Error('Text inference response contained no text');
+        return text;
+    }
+    headers() {
+        return {
+            'Content-Type': 'application/json',
+            'anthropic-version': '2023-06-01',
+            'x-api-key': this.config.apiKey,
+            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;
+    baseagent = 'codex';
+    constructor(config) {
+        this.config = config;
+    }
+    async completeText(request) {
+        const response = await fetch(apiEndpoint(this.config.baseUrl, 'https://api.openai.com', 'responses'), {
+            method: 'POST',
+            signal: request.signal,
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.config.apiKey}`,
+            },
+            body: JSON.stringify({
+                model: request.model,
+                instructions: request.system,
+                input: request.input,
+                store: false,
+                tool_choice: 'none',
+                max_output_tokens: 256,
+                ...(request.effort ? { reasoning: { effort: request.effort } } : {}),
+            }),
+        });
+        if (!response.ok)
+            throw await parseError(response);
+        const body = await response.json();
+        const direct = typeof body.output_text === 'string' ? body.output_text : '';
+        const text = direct || (Array.isArray(body.output)
+            ? body.output.flatMap((item) => Array.isArray(item?.content) ? item.content : [])
+                .filter((item) => item?.type === 'output_text' && typeof item.text === 'string')
+                .map((item) => item.text)
+                .join('')
+            : '');
+        if (!text)
+            throw new Error('Text inference response contained no text');
+        return text;
+    }
+}
+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));
+    }
+    if (baseagent === 'codex') {
+        const override = config.baseagents?.codex;
+        if (!override)
+            return undefined;
+        const synthetic = { agents: { codex: override } };
+        return new OpenAITextInferenceProvider(resolveOpenaiConfig(synthetic, override));
+    }
+    return undefined;
+}

package/dist/core/interaction-registration.js

@@ -0,0 +1,10 @@
+/** Bind an adapter response to its runtime-owned channel identity domain. */
+export function registerAdapterInteractions(adapter, router) {
+    const channelKey = adapter.channelKey;
+    adapter.onInteraction?.(async (response) => {
+        return router.handleAsync({ ...response, channelKey });
+    });
+    adapter.onInteractionInvalidated?.((interactionId, reason) => {
+        return router.cancelFromChannel(interactionId, reason);
+    });
+}

package/dist/core/interaction-router.js

@@ -0,0 +1,278 @@
+import { logger } from '../utils/logger.js';
+export class InteractionRouter {
+    handlers = new Map();
+    /** sessionId → 该会话当前待应答的交互数量，用于触发 wait 生命周期钩子 */
+    pendingBySession = new Map();
+    waitHooks;
+    setWaitHooks(hooks) {
+        this.waitHooks = hooks;
+    }
+    /**
+     * 在 register() 之前提前标记 session 为等待状态（适用于发卡片有异步延迟的场景）。
+     * 必须与 unmarkWaiting() 配对使用，或后续 register() 会接管计数。
+     */
+    markWaiting(sessionId) {
+        this.incPending(sessionId);
+    }
+    /** 取消 markWaiting() 的占位（后续若有 register() 接管则不需调用此方法） */
+    unmarkWaiting(sessionId) {
+        this.decPending(sessionId);
+    }
+    /** 登记一个待应答交互；session 计数 0→1 时触发 onWaitStart */
+    incPending(sessionId) {
+        const next = (this.pendingBySession.get(sessionId) ?? 0) + 1;
+        this.pendingBySession.set(sessionId, next);
+        if (next === 1)
+            this.waitHooks?.onWaitStart(sessionId);
+    }
+    /** 注销一个待应答交互；session 计数 1→0 时触发 onWaitEnd */
+    decPending(sessionId) {
+        const cur = this.pendingBySession.get(sessionId) ?? 0;
+        if (cur <= 0)
+            return;
+        const next = cur - 1;
+        if (next === 0) {
+            this.pendingBySession.delete(sessionId);
+            this.waitHooks?.onWaitEnd(sessionId);
+        }
+        else {
+            this.pendingBySession.set(sessionId, next);
+        }
+    }
+    register(id, sessionId, callback, opts) {
+        // 同 id 替换：槽位本就占用，计数不变，不触发 wait 钩子
+        const existing = this.handlers.get(id);
+        if (existing?.timer)
+            clearTimeout(existing.timer);
+        const isReplacement = !!existing;
+        const pending = {
+            callback,
+            sessionId,
+            initiatorId: opts?.initiatorId,
+            initiatorChannelKey: opts?.initiatorChannelKey,
+            fallbackCommand: opts?.fallbackCommand,
+            onCancel: opts?.onCancel,
+            onChannelCancel: opts?.onChannelCancel,
+        };
+        if (opts?.timeoutMs && opts.timeoutMs > 0) {
+            pending.timer = setTimeout(() => {
+                // A replacement may have reused the same id while this timer was
+                // waiting. Only expire the exact registration that created it.
+                if (this.handlers.get(id) !== pending)
+                    return;
+                this.handlers.delete(id);
+                this.decPending(pending.sessionId);
+                const cancelReason = opts.timeoutCancelReason ?? 'timeout';
+                logger.debug(`[InteractionRouter] Timeout for interaction: ${id}`);
+                opts.onTimeout?.();
+                if (opts.onCancel) {
+                    Promise.resolve(opts.onCancel(cancelReason)).catch(err => {
+                        logger.error(`[InteractionRouter] Timeout cancellation error for ${id}:`, err);
+                    });
+                }
+            }, opts.timeoutMs);
+        }
+        this.handlers.set(id, pending);
+        if (!isReplacement)
+            this.incPending(sessionId);
+    }
+    dispatch(response) {
+        const handler = this.handlers.get(response.id);
+        if (!handler)
+            return false;
+        // Initiator 校验（集中式 backstop）：非发起者的操作直接丢弃，不消费 handler、不解除等待，
+        // 让真正的发起者仍可继续操作。身份只信渠道传入的已认证 operatorId（来自消息信封，非 payload 自报）。
+        // 渠道层若已自行校验（如飞书的 reject toast），此处不会重复命中（operatorId 已匹配）。
+        if (handler.initiatorId && response.operatorId !== handler.initiatorId) {
+            logger.info(`[InteractionRouter] rejected unauthenticated or non-initiator response: operator=${response.operatorId ?? '<missing>'} initiator=${handler.initiatorId} id=${response.id}`);
+            return false;
+        }
+        if (handler.initiatorChannelKey && response.channelKey !== handler.initiatorChannelKey) {
+            logger.info(`[InteractionRouter] rejected response from wrong channel: channel=${response.channelKey ?? '<missing>'} expected=${handler.initiatorChannelKey} operator=${response.operatorId ?? '<missing>'} id=${response.id}`);
+            return false;
+        }
+        // The handler must remain registered while the callback runs. Permission
+        // callbacks can discover that authorization was revoked and call
+        // router.cancel(reason), whose onCancel hook invalidates the rendered card.
+        // Removing the slot before callback execution loses that invalidator.
+        if (handler.inFlight) {
+            logger.info(`[InteractionRouter] ignored duplicate in-flight response: id=${response.id}`);
+            return false;
+        }
+        handler.inFlight = true;
+        const settle = (accepted, rejectionReason = 'backend_rejected') => {
+            // The callback may already have resolved/cancelled this exact handler.
+            if (this.handlers.get(response.id) !== handler)
+                return accepted;
+            if (handler.timer)
+                clearTimeout(handler.timer);
+            this.handlers.delete(response.id);
+            this.decPending(handler.sessionId);
+            if (!accepted && handler.onCancel) {
+                Promise.resolve(handler.onCancel(rejectionReason)).catch(err => {
+                    logger.error(`[InteractionRouter] Rejection cancellation error for ${response.id}:`, err);
+                });
+            }
+            return accepted;
+        };
+        const fail = (err) => {
+            logger.error(`[InteractionRouter] Callback error for ${response.id}:`, err);
+            return settle(false, 'callback_error');
+        };
+        try {
+            const result = response.channelKey === undefined
+                ? handler.callback(response.action, response.values, response.operatorId)
+                : handler.callback(response.action, response.values, response.operatorId, response.channelKey);
+            if (result && typeof result.catch === 'function') {
+                return Promise.resolve(result).then(accepted => settle(accepted !== false), fail);
+            }
+            return settle(result !== false);
+        }
+        catch (err) {
+            return fail(err);
+        }
+    }
+    /**
+     * Synchronous compatibility entrypoint used by text-command fallbacks.
+     * Async callbacks are started once and report true here; channel adapters
+     * must use handleAsync() so their UI waits for the backend result.
+     */
+    handle(response) {
+        const result = this.dispatch(response);
+        if (result && typeof result.then === 'function') {
+            void result;
+            return true;
+        }
+        return result;
+    }
+    /** Await the authoritative backend result before a channel resolves a card. */
+    async handleAsync(response) {
+        return await this.dispatch(response);
+    }
+    async cancelAll(sessionId, reason) {
+        const pending = [];
+        for (const [id, handler] of this.handlers.entries()) {
+            if (handler.sessionId === sessionId) {
+                if (handler.timer)
+                    clearTimeout(handler.timer);
+                this.handlers.delete(id);
+                this.decPending(handler.sessionId);
+                if (reason && handler.onCancel) {
+                    pending.push(Promise.resolve(handler.onCancel(reason)).then(() => undefined));
+                }
+            }
+        }
+        await Promise.allSettled(pending);
+    }
+    async cancel(id, reason) {
+        const handler = this.handlers.get(id);
+        if (handler) {
+            if (handler.timer)
+                clearTimeout(handler.timer);
+            this.handlers.delete(id);
+            this.decPending(handler.sessionId);
+            if (reason && handler.onCancel)
+                await handler.onCancel(reason);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Cancel an interaction because the channel superseded its rendered card.
+     * Permission flows use onChannelCancel to settle their business promise;
+     * ordinary interactions fall back to their existing onCancel hook.
+     */
+    async cancelFromChannel(id, reason) {
+        const handler = this.handlers.get(id);
+        if (!handler)
+            return false;
+        if (!handler.onChannelCancel)
+            return this.cancel(id, reason);
+        if (handler.inFlight)
+            return false;
+        handler.inFlight = true;
+        try {
+            const result = await handler.onChannelCancel(reason);
+            const accepted = result !== false;
+            if (this.handlers.get(id) === handler) {
+                handler.inFlight = false;
+                if (accepted)
+                    await this.cancel(id, reason);
+            }
+            return accepted;
+        }
+        catch (err) {
+            if (this.handlers.get(id) === handler)
+                handler.inFlight = false;
+            logger.error(`[InteractionRouter] Channel cancellation error for ${id}:`, err);
+            return false;
+        }
+    }
+    getPending(sessionId) {
+        const ids = [];
+        for (const [id, handler] of this.handlers.entries()) {
+            if (handler.sessionId === sessionId)
+                ids.push(id);
+        }
+        return ids;
+    }
+    getInitiator(id) {
+        return this.handlers.get(id)?.initiatorId;
+    }
+    findPendingByCommand(sessionId, command) {
+        for (const [id, handler] of this.handlers.entries()) {
+            if (handler.sessionId === sessionId && handler.fallbackCommand === command) {
+                return id;
+            }
+        }
+        return undefined;
+    }
+}
+/** 把 CommandCard 渲染为文本提示，channel 不支持卡片时使用 */
+export function renderCommandCardAsText(card) {
+    const lines = [card.title];
+    if (card.body)
+        lines.push(card.body);
+    lines.push('', '可用命令:');
+    for (const btn of card.buttons) {
+        const marker = btn.disabled ? '✓' : ' ';
+        lines.push(`  ${marker} ${btn.command}    ← ${btn.label}`);
+    }
+    return lines.join('\n');
+}
+/** 把 ActionInteraction 渲染为文本提示，channel 不支持卡片或卡片发送失败时使用 */
+export function renderActionAsText(req) {
+    if (req.kind.kind !== 'action') {
+        throw new Error('[renderActionAsText] expected ActionInteraction, got ' + req.kind.kind);
+    }
+    const action = req.kind;
+    const fb = req.fallback;
+    const lines = [action.title];
+    if (action.body)
+        lines.push(action.body);
+    // checkers 多选：渲染选项列表
+    if (action.checkers?.length) {
+        lines.push('');
+        action.checkers.forEach((chk, idx) => {
+            const desc = chk.description ? ` — ${chk.description}` : '';
+            lines.push(`  ${idx + 1}. ${chk.label}${desc}`);
+        });
+        lines.push('', '回复选项编号（多选用逗号分隔），或输入自定义内容');
+        return lines.join('\n');
+    }
+    if (!fb) {
+        return lines.join('\n');
+    }
+    lines.push('', '回复:');
+    for (const btn of action.buttons) {
+        const arg = fb.buttonArgMap?.[btn.key] ?? btn.key;
+        lines.push(`  /${fb.command} ${arg}    ← ${btn.label}`);
+    }
+    if (fb.acceptFreeText && fb.freeTextHint) {
+        lines.push(`  ${fb.freeTextHint}`);
+    }
+    if (action.allowCustomInput) {
+        lines.push(`  或直接输入自定义内容`);
+    }
+    return lines.join('\n');
+}

package/dist/core/message/create-status.js

@@ -0,0 +1,67 @@
+import fs from 'fs';
+import path from 'path';
+const FILE = 'create-status.json';
+export function readCreateStatus(agentDir) {
+    try {
+        const raw = fs.readFileSync(path.join(agentDir, FILE), 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/** 删除构建进度文件（agent 删除时清理）。非 purge 删除只移除 config.json，
+ *  故需显式清理本文件，避免目录残留陈旧进度。 */
+export function removeCreateStatus(agentDir) {
+    try {
+        fs.rmSync(path.join(agentDir, FILE), { force: true });
+    }
+    catch { /* ignore */ }
+}
+/** 构建进度写入器。每次状态变更原子落盘（写临时文件 + rename）。 */
+export class CreateStatusWriter {
+    agentDir;
+    status;
+    constructor(agentDir, aid) {
+        this.agentDir = agentDir;
+        const now = Date.now();
+        this.status = { aid, status: 'in_progress', currentPhase: null, steps: [], error: null, startedAt: now, updatedAt: now };
+        fs.mkdirSync(agentDir, { recursive: true });
+        this.flush();
+    }
+    begin(phase) {
+        this.status.currentPhase = phase;
+        this.status.steps.push({ phase, state: 'in_progress', ts: Date.now() });
+        this.flush();
+    }
+    done(phase, detail) { this.mark(phase, 'done', detail); }
+    warn(phase, detail) { this.mark(phase, 'warn', detail); }
+    finishReady() { this.status.status = 'ready'; this.status.currentPhase = null; this.flush(); }
+    finishFailed(phase, error) {
+        this.mark(phase, 'failed', error);
+        this.status.status = 'failed';
+        this.status.error = error;
+        this.status.currentPhase = null;
+        this.flush();
+    }
+    mark(phase, state, detail) {
+        const step = [...this.status.steps].reverse().find(s => s.phase === phase);
+        if (step) {
+            step.state = state;
+            if (detail)
+                step.detail = detail;
+            step.ts = Date.now();
+        }
+        else {
+            this.status.steps.push({ phase, state, detail, ts: Date.now() });
+        }
+        this.flush();
+    }
+    flush() {
+        this.status.updatedAt = Date.now();
+        const file = path.join(this.agentDir, FILE);
+        const tmp = `${file}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(this.status, null, 2));
+        fs.renameSync(tmp, file);
+    }
+}