@offerpilot/axiomruntime 0.0.1

package/dist/telegram/engine/codex-engine.js

@@ -0,0 +1,437 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { cleanupRuntime, createCommandPermissionRequest, formatEngineTimeout, prepareEngineRuntime, summarizeRuntime } from "./engine-utils.js";
+import { createJsonLineAccumulator, extractJsonLines, spawnCapture, stripAnsi, terminateProcessTree } from "./process-utils.js";
+import { startOpenAiUsageProxy } from "../../core/runner/openai-usage-proxy.js";
+import { requiresDangerousConfirmation } from "../interaction/approval.js";
+import { writeTelegramLog } from "../log.js";
+import { isRecord } from "../../core/utils/is-record.js";
+export class CodexEngine {
+    name = "codex";
+    processes = new Map();
+    controllers = new Map();
+    async execute(params) {
+        const runtime = await prepareEngineRuntime("codex", params.providerName, params.modelName);
+        const controller = new AbortController();
+        this.controllers.set(params.chatId, controller);
+        const signal = params.signal ?? controller.signal;
+        const startTime = Date.now();
+        const permissionMode = params.permissionMode ?? "default";
+        if (permissionMode === "bypassPermissions" && requiresDangerousConfirmation(params.prompt)) {
+            const approved = await params.onPermission(createCommandPermissionRequest("Codex prompt", params.prompt));
+            if (!approved) {
+                cleanupRuntime(runtime);
+                throw new Error("Dangerous command denied.");
+            }
+        }
+        let usageProxy = null;
+        await params.onProgress?.({ phase: "thinking", message: "Codex started" });
+        await writeTelegramLog({
+            action: "codex_start",
+            message: `Starting Codex for Telegram chat ${params.chatId}`,
+            metadata: { ...summarizeRuntime(runtime.provider, runtime.model, "codex"), cwd: params.cwd }
+        });
+        try {
+            usageProxy = await startOpenAiUsageProxy({
+                provider: runtime.provider,
+                model: runtime.model,
+                tool: "telegram"
+            });
+            const args = buildCodexArgs(params.prompt, runtime.model, params.cwd, permissionMode, {
+                baseUrl: usageProxy.baseUrl
+            }, params.resume, params.imagePaths);
+            const progressParser = createJsonLineAccumulator((event) => handleCodexProgressEvent(event, params.onProgress));
+            const result = await spawnCapture({
+                command: runtime.command,
+                args,
+                cwd: params.cwd,
+                env: {
+                    ...runtime.env,
+                    OPENAI_API_KEY: runtime.provider.apiKey,
+                    OPENAI_BASE_URL: usageProxy.baseUrl,
+                    AI_GATEWAY_BASE_URL: usageProxy.baseUrl
+                },
+                signal,
+                timeoutMs: params.timeoutMs,
+                onStdout: (chunk) => progressParser.push(chunk)
+            }, (child) => this.processes.set(params.chatId, child));
+            progressParser.end();
+            if (result.timedOut) {
+                throw new Error(formatEngineTimeout("Codex", params.timeoutMs, runtime.provider.name, runtime.model));
+            }
+            if (result.aborted) {
+                throw new Error("任务已停止。");
+            }
+            if (result.code !== 0) {
+                throw new Error(formatCodexFailure([result.stderr, result.stdout].filter((value) => value.trim()).join("\n") || `Codex exited with code ${result.code}`, runtime.provider.name, runtime.model));
+            }
+            await params.onProgress?.({ phase: "done" });
+            const parsed = parseCodexOutput(result.stdout, Date.now() - startTime);
+            const sessionId = parsed.sessionId ?? findLatestCodexSessionId({
+                cwd: params.cwd,
+                startedAtMs: startTime,
+                finishedAtMs: Date.now()
+            });
+            if (sessionId && !parsed.sessionId) {
+                await writeTelegramLog({
+                    action: "codex_session_detected",
+                    message: `Detected Codex session ${sessionId} from local history.`,
+                    metadata: { chatId: params.chatId, cwd: params.cwd }
+                });
+            }
+            return {
+                ...parsed,
+                sessionId,
+                cost: sumKnownProxyCosts(usageProxy.getRecords()),
+                usage: sumProxyUsage(usageProxy.getRecords()),
+                provider: runtime.provider.name,
+                model: runtime.model
+            };
+        }
+        finally {
+            this.processes.delete(params.chatId);
+            this.controllers.delete(params.chatId);
+            await usageProxy?.close().catch(() => undefined);
+            cleanupRuntime(runtime);
+        }
+    }
+    abort(chatId) {
+        if (!Number.isFinite(chatId)) {
+            for (const id of new Set([...this.controllers.keys(), ...this.processes.keys()])) {
+                this.abort(id);
+            }
+            return;
+        }
+        this.controllers.get(chatId)?.abort();
+        const child = this.processes.get(chatId);
+        if (child)
+            terminateProcessTree(child, "SIGTERM");
+        this.controllers.delete(chatId);
+        this.processes.delete(chatId);
+    }
+}
+export function buildCodexArgs(prompt, model, cwd, permissionMode, providerOverride, resume, imagePaths = []) {
+    const args = [
+        "exec",
+        ...(resume ? ["resume"] : []),
+        ...buildCodexProviderOverrideArgs(providerOverride),
+        "--json",
+        "--skip-git-repo-check",
+        "-m",
+        model,
+        ...(resume ? [] : ["-C", cwd])
+    ];
+    if (permissionMode === "readOnly") {
+        args.unshift("-a", "never", "-s", "read-only");
+    }
+    else if (permissionMode === "bypassPermissions") {
+        args.push("--dangerously-bypass-approvals-and-sandbox");
+    }
+    else if (permissionMode === "acceptEdits") {
+        args.unshift("-a", "never");
+        if (resume) {
+            args.unshift("-s", "workspace-write");
+        }
+        else {
+            args.push("-s", "workspace-write");
+        }
+    }
+    else {
+        args.unshift("-a", "on-request");
+        if (resume) {
+            args.unshift("-s", "workspace-write");
+        }
+        else {
+            args.push("-s", "workspace-write");
+        }
+    }
+    if (resume) {
+        args.push(resume);
+    }
+    for (const imagePath of imagePaths) {
+        args.push("--image", imagePath);
+    }
+    args.push(prompt);
+    return args;
+}
+function buildCodexProviderOverrideArgs(providerOverride) {
+    if (!providerOverride)
+        return [];
+    const providerId = providerOverride.providerId ?? "ai_gateway_proxy";
+    return [
+        "-c",
+        `model_provider=${tomlString(providerId)}`,
+        "-c",
+        `model_providers.${providerId}.name=${tomlString("AI Gateway Proxy")}`,
+        "-c",
+        `model_providers.${providerId}.base_url=${tomlString(providerOverride.baseUrl)}`,
+        "-c",
+        `model_providers.${providerId}.env_key=${tomlString("OPENAI_API_KEY")}`,
+        "-c",
+        `model_providers.${providerId}.requires_openai_auth=true`,
+        "-c",
+        `model_providers.${providerId}.wire_api=${tomlString("responses")}`
+    ];
+}
+function tomlString(value) {
+    return JSON.stringify(value);
+}
+export function parseCodexOutput(raw, duration) {
+    const events = extractJsonLines(raw);
+    let response = "";
+    let sessionId;
+    const toolCalls = [];
+    const filesChanged = new Set();
+    for (const event of events) {
+        if (!isRecord(event))
+            continue;
+        sessionId = readCodexSessionId(event) ?? sessionId;
+        const message = readCodexMessage(event);
+        if (message)
+            response = message;
+        const toolCall = readCodexToolCall(event);
+        if (toolCall)
+            toolCalls.push(toolCall);
+        for (const filePath of readChangedFiles(event)) {
+            filesChanged.add(filePath);
+        }
+    }
+    if (!response.trim()) {
+        response = stripAnsi(raw).trim();
+    }
+    return {
+        sessionId,
+        response,
+        toolCalls,
+        filesChanged: [...filesChanged],
+        duration
+    };
+}
+export function findLatestCodexSessionId(input) {
+    const codexHome = input.codexHome ?? process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex");
+    const sessionsRoot = path.join(codexHome, "sessions");
+    const finishedAtMs = input.finishedAtMs ?? Date.now();
+    const files = listCandidateCodexSessionFiles(sessionsRoot, input.startedAtMs, finishedAtMs);
+    const startedWindow = input.startedAtMs - 10_000;
+    const finishedWindow = finishedAtMs + 30_000;
+    for (const filePath of files) {
+        const stat = safeStat(filePath);
+        if (!stat || stat.mtimeMs < startedWindow || stat.mtimeMs > finishedWindow)
+            continue;
+        const session = readCodexSessionMeta(filePath);
+        if (!session)
+            continue;
+        if (path.resolve(session.cwd) !== path.resolve(input.cwd))
+            continue;
+        if (session.source && session.source !== "exec")
+            continue;
+        return session.sessionId;
+    }
+    return undefined;
+}
+export function formatCodexFailure(raw, providerName, model) {
+    const text = stripAnsi(raw).trim();
+    if (/stream disconnected/i.test(text)) {
+        return [
+            "Codex 请求失败：模型流式响应连续断开，已重试 5 次。",
+            providerName && model ? `Provider：${providerName} / ${model}` : "",
+            "这通常是 provider 上游或网络连接不稳定，不是 Telegram 输入格式问题。"
+        ].filter(Boolean).join("\n");
+    }
+    const meaningful = text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && !isBenignCodexDiagnostic(line))
+        .join("\n")
+        .trim();
+    return meaningful || text || "Codex exited without a diagnostic message.";
+}
+function isBenignCodexDiagnostic(line) {
+    return line === "Reading additional input from stdin..."
+        || /codex_core_plugins::remote::remote_installed_plugin_sync/.test(line)
+        || /codex_features: unknown feature key in config/.test(line)
+        || /codex_core_plugins::manifest: ignoring interface\.defaultPrompt/.test(line)
+        || /codex_core_plugins::manager: failed to warm featured plugin ids cache/.test(line);
+}
+function listCandidateCodexSessionFiles(sessionsRoot, startedAtMs, finishedAtMs) {
+    const dayDirs = new Set();
+    for (const ms of [startedAtMs, finishedAtMs, startedAtMs - 24 * 60 * 60 * 1000, finishedAtMs + 24 * 60 * 60 * 1000]) {
+        const date = new Date(ms);
+        dayDirs.add(path.join(sessionsRoot, String(date.getFullYear()), String(date.getMonth() + 1).padStart(2, "0"), String(date.getDate()).padStart(2, "0")));
+    }
+    const files = [];
+    for (const dir of dayDirs) {
+        for (const filePath of listJsonlFiles(dir)) {
+            const stat = safeStat(filePath);
+            if (stat)
+                files.push({ path: filePath, mtimeMs: stat.mtimeMs });
+        }
+    }
+    return files.sort((a, b) => b.mtimeMs - a.mtimeMs).map((file) => file.path);
+}
+function listJsonlFiles(dir) {
+    try {
+        return fs.readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl"))
+            .map((entry) => path.join(dir, entry.name));
+    }
+    catch {
+        return [];
+    }
+}
+function safeStat(filePath) {
+    try {
+        return fs.statSync(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+function readCodexSessionMeta(filePath) {
+    try {
+        const text = fs.readFileSync(filePath, "utf8");
+        for (const line of text.split(/\r?\n/).slice(0, 20)) {
+            if (!line.trim())
+                continue;
+            const event = JSON.parse(line);
+            if (!isRecord(event) || event.type !== "session_meta" || !isRecord(event.payload))
+                continue;
+            const sessionId = readCodexSessionId(event);
+            const cwd = typeof event.payload.cwd === "string" ? event.payload.cwd : "";
+            if (sessionId && cwd) {
+                return {
+                    sessionId,
+                    cwd,
+                    source: typeof event.payload.source === "string" ? event.payload.source : undefined
+                };
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function handleCodexProgressEvent(event, onProgress) {
+    if (!onProgress)
+        return;
+    if (!isRecord(event))
+        return;
+    const toolCall = readCodexToolCall(event);
+    if (toolCall) {
+        void onProgress(readCodexProgressUpdate(event, toolCall.tool));
+        return;
+    }
+    const responseText = readCodexMessage(event);
+    if (responseText || String(event.type ?? "").includes("message")) {
+        void onProgress({ phase: "writing", responseText: responseText ?? undefined });
+    }
+}
+function readCodexProgressUpdate(event, fallbackTool) {
+    const type = String(event.type ?? event.kind ?? "");
+    const input = isRecord(event.input) ? event.input : {};
+    const command = readFirstString(event.command, input.command, event.cmd, input.cmd);
+    if (command || /exec|command|shell/i.test(type)) {
+        return {
+            phase: "tool_calling",
+            tool: command ?? fallbackTool,
+            toolKind: "command"
+        };
+    }
+    const mcpServer = readFirstString(event.mcpServer, event.mcp_server, event.server, input.mcpServer, input.server);
+    const mcpTool = readFirstString(event.tool, event.name, input.tool, input.name);
+    if (mcpServer || /mcp/i.test(type)) {
+        return {
+            phase: "tool_calling",
+            tool: mcpTool ?? fallbackTool,
+            toolKind: "mcp",
+            mcpServer
+        };
+    }
+    return {
+        phase: "tool_calling",
+        tool: fallbackTool,
+        toolKind: "builtin"
+    };
+}
+function readFirstString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+function readCodexSessionId(event, depth = 0) {
+    if (depth > 4)
+        return null;
+    for (const key of ["session_id", "sessionId"]) {
+        const value = event[key];
+        if (typeof value === "string" && value.trim())
+            return value;
+    }
+    const id = event.id;
+    if (typeof id === "string" && isUuidLike(id))
+        return id;
+    for (const key of ["payload", "item", "message", "response"]) {
+        const value = event[key];
+        if (isRecord(value)) {
+            const nested = readCodexSessionId(value, depth + 1);
+            if (nested)
+                return nested;
+        }
+    }
+    return null;
+}
+function isUuidLike(value) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+function readCodexMessage(event) {
+    for (const key of ["last_message", "message", "summary", "output", "text", "content"]) {
+        const value = event[key];
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    if (isRecord(event.item)) {
+        return readCodexMessage(event.item);
+    }
+    return null;
+}
+function readCodexToolCall(event) {
+    const type = String(event.type ?? event.kind ?? "");
+    if (!/tool|command|exec|patch/i.test(type))
+        return null;
+    const tool = String(event.tool ?? event.name ?? event.command ?? type);
+    return {
+        tool,
+        input: isRecord(event.input) ? event.input : {},
+        output: typeof event.output === "string" ? event.output : "",
+        status: String(event.status ?? "success").includes("error") ? "error" : "success"
+    };
+}
+function readChangedFiles(event) {
+    const value = event.files_changed ?? event.filesChanged ?? event.changed_files;
+    if (Array.isArray(value))
+        return value.filter((item) => typeof item === "string");
+    if (typeof event.path === "string" && /patch|edit|write/i.test(String(event.type ?? "")))
+        return [event.path];
+    return [];
+}
+function sumKnownProxyCosts(records) {
+    const knownCosts = records
+        .map((record) => record.costUsd)
+        .filter((cost) => typeof cost === "number" && Number.isFinite(cost) && cost >= 0);
+    if (!knownCosts.length)
+        return undefined;
+    return Number(knownCosts.reduce((sum, cost) => sum + cost, 0).toFixed(8));
+}
+function sumProxyUsage(records) {
+    if (!records.length)
+        return undefined;
+    return records.reduce((sum, record) => ({
+        inputTokens: sum.inputTokens + record.usage.inputTokens,
+        outputTokens: sum.outputTokens + record.usage.outputTokens,
+        totalTokens: sum.totalTokens + record.usage.totalTokens,
+        cacheReadInputTokens: (sum.cacheReadInputTokens ?? 0) + (record.usage.cacheReadInputTokens ?? 0)
+    }), { inputTokens: 0, outputTokens: 0, totalTokens: 0, cacheReadInputTokens: 0 });
+}

package/dist/telegram/engine/engine-utils.js

@@ -0,0 +1,67 @@
+import { randomUUID } from "node:crypto";
+import { resolveExactProviderForTool, resolveProviderForTool } from "../../core/runner/fallback.js";
+import { buildRunnerEnv, cleanupTemporaryFiles, getToolBaseUrl, writeTemporaryClaudeSettings } from "../../core/runner/tool-runner.js";
+import { resolveToolCommand } from "../../core/runner/command-resolver.js";
+export async function prepareEngineRuntime(tool, providerName, modelName, permissionMode) {
+    // Telegram resolves and orders fallback candidates before invoking an
+    // engine. Once a candidate is selected, execute it exactly so the engine
+    // cannot perform a second, conflicting provider fallback.
+    const { provider, model } = providerName
+        ? await resolveExactProviderForTool(tool, providerName, modelName)
+        : await resolveProviderForTool(tool, providerName, modelName);
+    const command = resolveWorkingCommand(tool);
+    if (!command) {
+        throw new Error(`Failed to find ${tool} CLI. Run \`ai doctor\` to check local CLI installation.`);
+    }
+    const env = {
+        ...buildRunnerEnv(tool, provider, model),
+        AI_GATEWAY_SOURCE: "telegram"
+    };
+    const temporaryFiles = [];
+    const claudeSettingsPath = tool === "claude"
+        ? writeTemporaryClaudeSettings(provider, { permissionMode: permissionMode === "readOnly" ? "readOnly" : "provider" })
+        : null;
+    if (claudeSettingsPath)
+        temporaryFiles.push(claudeSettingsPath);
+    return { provider, model, env, command, temporaryFiles, claudeSettingsPath };
+}
+export function cleanupRuntime(runtime) {
+    cleanupTemporaryFiles(runtime.temporaryFiles);
+}
+export function resolveWorkingCommand(tool) {
+    return resolveToolCommand(tool);
+}
+export function createCommandPermissionRequest(tool, command) {
+    return {
+        id: randomUUID(),
+        tool,
+        description: `Confirm command before running in Telegram ${tool}.`,
+        command,
+        params: { command }
+    };
+}
+export function summarizeRuntime(provider, model, tool) {
+    return {
+        provider: provider.name,
+        model,
+        baseUrl: getToolBaseUrl(tool, provider)
+    };
+}
+export function formatEngineTimeout(engineLabel, timeoutMs, providerName, model) {
+    return [
+        `${engineLabel} 请求超时，已自动停止。`,
+        timeoutMs ? `超时时间：${formatDuration(timeoutMs)}` : "",
+        providerName && model ? `Provider：${providerName} / ${model}` : "",
+        "这通常是 CLI 子进程、provider 上游或网络连接卡住导致的。"
+    ].filter(Boolean).join("\n");
+}
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const seconds = Math.round(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remaining = seconds % 60;
+    return remaining ? `${minutes}m ${remaining}s` : `${minutes}m`;
+}

package/dist/telegram/engine/process-utils.js

@@ -0,0 +1,132 @@
+import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+export async function spawnCapture(options, onProcess) {
+    const child = spawn(options.command, options.args, {
+        cwd: options.cwd,
+        env: options.env,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: process.platform !== "win32"
+    });
+    onProcess?.(child);
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let aborted = false;
+    let killTimer;
+    const stdoutDecoder = new StringDecoder("utf8");
+    const stderrDecoder = new StringDecoder("utf8");
+    child.stdout?.on("data", (chunk) => {
+        const text = stdoutDecoder.write(chunk);
+        stdout += text;
+        void options.onStdout?.(text);
+    });
+    child.stderr?.on("data", (chunk) => {
+        const text = stderrDecoder.write(chunk);
+        stderr += text;
+        void options.onStderr?.(text);
+    });
+    const requestTermination = (reason) => {
+        if (reason === "timeout")
+            timedOut = true;
+        if (reason === "abort")
+            aborted = true;
+        terminateProcessTree(child, "SIGTERM");
+        killTimer ??= setTimeout(() => terminateProcessTree(child, "SIGKILL"), options.killGraceMs ?? 3000);
+        killTimer.unref?.();
+    };
+    const abortHandler = () => requestTermination("abort");
+    if (options.signal?.aborted) {
+        requestTermination("abort");
+    }
+    else {
+        options.signal?.addEventListener("abort", abortHandler, { once: true });
+    }
+    let timeout;
+    if (options.timeoutMs && options.timeoutMs > 0) {
+        timeout = setTimeout(() => requestTermination("timeout"), options.timeoutMs);
+        timeout.unref?.();
+    }
+    try {
+        const [code, signal] = await new Promise((resolve, reject) => {
+            child.once("error", reject);
+            child.once("close", (code, signal) => resolve([code, signal]));
+        });
+        stdout += stdoutDecoder.end();
+        stderr += stderrDecoder.end();
+        return { stdout, stderr, code, signal, timedOut, aborted };
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+        if (killTimer)
+            clearTimeout(killTimer);
+        options.signal?.removeEventListener("abort", abortHandler);
+    }
+}
+export function terminateProcessTree(child, signal) {
+    const pid = child.pid;
+    if (!pid)
+        return;
+    try {
+        if (process.platform !== "win32") {
+            process.kill(-pid, signal);
+            return;
+        }
+    }
+    catch {
+        // Fall back to killing the direct child below.
+    }
+    try {
+        child.kill(signal);
+    }
+    catch {
+        // The process may have already exited.
+    }
+}
+export function extractJsonLines(raw) {
+    const events = [];
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            events.push(JSON.parse(trimmed));
+        }
+        catch {
+            // Ignore non-JSON progress lines.
+        }
+    }
+    return events;
+}
+export function createJsonLineAccumulator(onEvent) {
+    let pending = "";
+    const emitLine = (line) => {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        try {
+            onEvent(JSON.parse(trimmed));
+        }
+        catch {
+            // Ignore non-JSON progress lines. The complete stdout remains available
+            // to the final result/error parser.
+        }
+    };
+    return {
+        push(chunk) {
+            pending += chunk;
+            const lines = pending.split("\n");
+            pending = lines.pop() ?? "";
+            for (const line of lines)
+                emitLine(line);
+        },
+        end() {
+            emitLine(pending);
+            pending = "";
+        }
+    };
+}
+export function stripAnsi(value) {
+    // eslint-disable-next-line no-control-regex
+    return value.replace(/\u001b(?:\[[0-9;?]*[A-Za-z]|\][^\u0007]*\u0007|[()][A-Z0-9]|[ -\/]*[0-~])/g, "");
+}

package/dist/telegram/engine/registry.js

@@ -0,0 +1,31 @@
+import { ClaudeEngine } from "./claude-engine.js";
+import { CodexEngine } from "./codex-engine.js";
+const factories = new Map();
+export function registerTelegramEngine(name, factory) {
+    factories.set(name, factory);
+}
+export function createTelegramEngines() {
+    return {
+        claude: createTelegramEngine("claude"),
+        codex: createTelegramEngine("codex")
+    };
+}
+export function createTelegramEngine(name) {
+    const factory = factories.get(name);
+    if (!factory) {
+        throw new Error(`Unknown Telegram engine: ${name}`);
+    }
+    return factory();
+}
+export function getTelegramEngine(engines, name) {
+    const engine = engines[name];
+    if (!engine) {
+        throw new Error(`Telegram engine is not registered: ${name}`);
+    }
+    return engine;
+}
+export function listTelegramEngineNames() {
+    return [...factories.keys()];
+}
+registerTelegramEngine("claude", () => new ClaudeEngine());
+registerTelegramEngine("codex", () => new CodexEngine());

package/dist/telegram/engine/types.js

@@ -0,0 +1 @@
+export {};