@offerpilot/axiomruntime 0.0.1

package/dist/server/runtime-server.js

@@ -0,0 +1,430 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import http from "node:http";
+import path from "node:path";
+import { Agent, fetch } from "undici";
+import { readCache, recordProviderRuntimeFailure, recordProviderRuntimeSuccess } from "../core/config/cache-store.js";
+import { readProviders } from "../core/config/providers-store.js";
+import { writeLog } from "../core/logs/log-service.js";
+import { resolveProviderCandidatesForTool } from "../core/runner/fallback.js";
+import { buildUpstreamHeaders, buildUpstreamUrl, methodMayHaveBody, streamResponse, writeResponseHead } from "../core/runner/openai-usage-http.js";
+import { recordUsageFromResponse } from "../core/runner/openai-usage-recording.js";
+import { buildChatCompletionsResponsesSse, isResponsesStreamRequest, shouldFallbackResponsesToChat } from "../core/runner/openai-usage-responses.js";
+import { getToolBaseUrl } from "../core/runner/tool-runner.js";
+import { createTelegramEngine } from "../telegram/engine/registry.js";
+const DEFAULT_MAX_REQUEST_BYTES = 16 * 1024 * 1024;
+const DEFAULT_HEADERS_TIMEOUT_MS = 45_000;
+const ALLOWED_PROXY_PATHS = new Set([
+    "/v1/chat/completions",
+    "/v1/responses",
+    "/v1/embeddings"
+]);
+export async function startRuntimeServer(options) {
+    const host = options.host ?? "127.0.0.1";
+    const port = options.port ?? 8080;
+    const token = options.token.trim();
+    if (!token)
+        throw new Error("AI Gateway server token cannot be empty.");
+    const dispatcher = new Agent({
+        connections: 32,
+        pipelining: 0,
+        headersTimeout: normalizePositiveInteger(options.upstreamHeadersTimeoutMs, DEFAULT_HEADERS_TIMEOUT_MS),
+        bodyTimeout: 0
+    });
+    const maxRequestBytes = normalizePositiveInteger(options.maxRequestBytes, DEFAULT_MAX_REQUEST_BYTES);
+    const agentRuntime = {
+        workspaceRoot: path.resolve(options.agentWorkspaceRoot ?? path.join(process.cwd(), ".ai-gateway-workspaces")),
+        maxConcurrentRuns: normalizePositiveInteger(options.agentMaxConcurrentRuns, 2),
+        timeoutMs: normalizePositiveInteger(options.agentTimeoutMs, 10 * 60 * 1000),
+        activeRuns: 0
+    };
+    await fs.mkdir(agentRuntime.workspaceRoot, { recursive: true });
+    const server = http.createServer(async (req, res) => {
+        const requestId = normalizeRequestId(req.headers["x-request-id"]);
+        res.setHeader("x-request-id", requestId);
+        try {
+            await handleRequest({ req, res, requestId, token, maxRequestBytes, dispatcher, agentRuntime });
+        }
+        catch (error) {
+            if (error instanceof RequestBodyTooLargeError && !res.headersSent) {
+                sendJson(res, 413, { error: { message: error.message, request_id: requestId } });
+                return;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            await writeLog({
+                level: "error",
+                category: "error",
+                action: "runtime_server_request_failed",
+                message: `Runtime server request failed: ${message}`,
+                metadata: { requestId, path: req.url ?? "/" }
+            });
+            if (!res.headersSent)
+                sendJson(res, 500, { error: { message: "Internal AI Gateway error.", request_id: requestId } });
+            else
+                res.end();
+        }
+    });
+    await new Promise((resolve, reject) => {
+        const onError = (error) => reject(error);
+        server.once("error", onError);
+        server.listen(port, host, () => {
+            server.off("error", onError);
+            resolve();
+        });
+    });
+    const address = server.address();
+    if (!address || typeof address === "string")
+        throw new Error("Failed to bind AI Gateway runtime server.");
+    return {
+        baseUrl: `http://${displayHost(host)}:${address.port}`,
+        async close() {
+            const closeServer = server.listening
+                ? new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()))
+                : Promise.resolve();
+            await Promise.all([closeServer, dispatcher.close()]);
+        }
+    };
+}
+async function handleRequest(input) {
+    const { req, res, requestId } = input;
+    const path = new URL(req.url ?? "/", "http://127.0.0.1").pathname;
+    if (req.method === "GET" && path === "/health/live") {
+        sendJson(res, 200, { status: "ok" });
+        return;
+    }
+    if (req.method === "GET" && path === "/health/ready") {
+        const providers = await readProviders();
+        sendJson(res, providers.length ? 200 : 503, {
+            status: providers.length ? "ready" : "not_ready",
+            providers: providers.length
+        });
+        return;
+    }
+    if (!isAuthorized(req.headers.authorization, input.token)) {
+        res.setHeader("www-authenticate", "Bearer");
+        sendJson(res, 401, { error: { message: "Unauthorized.", request_id: requestId } });
+        return;
+    }
+    if (req.method === "GET" && path === "/v1/models") {
+        await sendModels(res);
+        return;
+    }
+    if (req.method === "POST" && path === "/v1/agent/runs") {
+        const requestBody = await readBoundedRequestBody(req, input.maxRequestBytes);
+        await runAgent(input.res, requestBody, requestId, input.agentRuntime);
+        return;
+    }
+    if (req.method !== "POST" || !ALLOWED_PROXY_PATHS.has(path)) {
+        sendJson(res, 404, { error: { message: "Route not found.", request_id: requestId } });
+        return;
+    }
+    const requestBody = await readBoundedRequestBody(req, input.maxRequestBytes);
+    const requestedModel = extractModel(requestBody);
+    if (!requestedModel) {
+        sendJson(res, 400, { error: { message: "Request body must include model.", request_id: requestId } });
+        return;
+    }
+    const candidates = await resolveProviderCandidatesForTool("codex", undefined, requestedModel);
+    if (!candidates.length) {
+        sendJson(res, 503, { error: { message: `No healthy provider offers model ${requestedModel}.`, request_id: requestId } });
+        return;
+    }
+    await proxyWithFallback({ ...input, requestBody, requestedModel, candidates });
+}
+async function runAgent(res, body, requestId, runtime) {
+    const request = parseAgentRunRequest(body);
+    if (!request) {
+        sendJson(res, 400, {
+            error: {
+                message: "Agent run requires engine, prompt, and a safe workspace_id.",
+                request_id: requestId
+            }
+        });
+        return;
+    }
+    if (runtime.activeRuns >= runtime.maxConcurrentRuns) {
+        res.setHeader("retry-after", "5");
+        sendJson(res, 429, { error: { message: "Agent run concurrency limit reached.", request_id: requestId } });
+        return;
+    }
+    const cwd = path.join(runtime.workspaceRoot, request.workspaceId);
+    await fs.mkdir(cwd, { recursive: true });
+    const engine = createTelegramEngine(request.engine);
+    const runId = stableRunId(requestId);
+    runtime.activeRuns += 1;
+    try {
+        const result = await engine.execute({
+            chatId: runId,
+            prompt: request.prompt,
+            cwd,
+            permissionMode: request.permissionMode === "workspace_write" ? "acceptEdits" : "readOnly",
+            providerName: request.providerName,
+            modelName: request.modelName,
+            timeoutMs: runtime.timeoutMs,
+            onPermission: async () => false
+        });
+        sendJson(res, 200, serializeAgentResult(requestId, request, result));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        sendJson(res, 502, { error: { message, request_id: requestId } });
+    }
+    finally {
+        runtime.activeRuns -= 1;
+    }
+}
+function parseAgentRunRequest(body) {
+    try {
+        const value = JSON.parse(body.toString("utf8"));
+        const engine = value.engine;
+        const prompt = typeof value.prompt === "string" ? value.prompt.trim() : "";
+        const workspaceId = typeof value.workspace_id === "string" ? value.workspace_id.trim() : "";
+        const permissionMode = value.permission_mode === "workspace_write" ? "workspace_write" : "read_only";
+        if ((engine !== "claude" && engine !== "codex") || !prompt || prompt.length > 200_000)
+            return null;
+        if (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(workspaceId))
+            return null;
+        return {
+            engine,
+            prompt,
+            workspaceId,
+            permissionMode,
+            ...(typeof value.provider === "string" && value.provider.trim() ? { providerName: value.provider.trim() } : {}),
+            ...(typeof value.model === "string" && value.model.trim() ? { modelName: value.model.trim() } : {})
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function serializeAgentResult(requestId, request, result) {
+    return {
+        id: requestId,
+        object: "agent.run",
+        engine: request.engine,
+        workspace_id: request.workspaceId,
+        response: result.response,
+        session_id: result.sessionId ?? null,
+        provider: result.provider ?? null,
+        model: result.model ?? null,
+        usage: result.usage ?? null,
+        cost_usd: result.cost ?? null,
+        duration_ms: result.duration ?? null,
+        files_changed: result.filesChanged ?? [],
+        tool_calls: result.toolCalls ?? []
+    };
+}
+function stableRunId(requestId) {
+    const digest = crypto.createHash("sha256").update(requestId).digest();
+    return digest.readUInt32BE(0) || 1;
+}
+async function proxyWithFallback(input) {
+    const records = [];
+    let lastFailure = null;
+    for (const [index, candidate] of input.candidates.entries()) {
+        const upstreamBaseUrl = getToolBaseUrl("codex", candidate.provider);
+        const upstreamUrl = buildUpstreamUrl(upstreamBaseUrl, input.req.url ?? "/");
+        try {
+            const response = await fetch(upstreamUrl, {
+                method: input.req.method,
+                headers: buildUpstreamHeaders(input.req.headers, candidate.provider.apiKey),
+                body: input.requestBody.length && methodMayHaveBody(input.req.method) ? input.requestBody : undefined,
+                dispatcher: input.dispatcher
+            });
+            const responsesStream = isResponsesStreamRequest(input.req.url ?? "/", input.requestBody);
+            if (responsesStream && !isUsableEventStream(response)) {
+                const nativeFailure = await bufferUpstream(response);
+                if (shouldFallbackResponsesToChat({
+                    status: nativeFailure.status,
+                    contentType: nativeFailure.contentType,
+                    bodyText: nativeFailure.body.toString("utf8")
+                })) {
+                    const translated = await buildChatCompletionsResponsesSse({
+                        upstreamBaseUrl,
+                        requestBody: input.requestBody,
+                        apiKey: candidate.provider.apiKey,
+                        dispatcher: input.dispatcher
+                    });
+                    const fallbackResponse = {
+                        status: translated.status,
+                        statusText: translated.statusText,
+                        contentType: translated.contentType,
+                        body: translated.body
+                    };
+                    if (isRetryableStatus(fallbackResponse.status) && index < input.candidates.length - 1) {
+                        await recordCandidateFailure(candidate, fallbackResponse);
+                        lastFailure = fallbackResponse;
+                        continue;
+                    }
+                    await sendBufferedResult(input.res, candidate, fallbackResponse, records, input.requestedModel);
+                    return;
+                }
+                if (isRetryableStatus(nativeFailure.status) && index < input.candidates.length - 1) {
+                    await recordCandidateFailure(candidate, nativeFailure);
+                    lastFailure = nativeFailure;
+                    continue;
+                }
+                await sendBufferedResult(input.res, candidate, nativeFailure, records, input.requestedModel);
+                return;
+            }
+            if (isRetryableStatus(response.status) && index < input.candidates.length - 1) {
+                const failure = await bufferUpstream(response);
+                await recordCandidateFailure(candidate, failure);
+                lastFailure = failure;
+                continue;
+            }
+            input.res.setHeader("x-agent-router-provider", candidate.provider.name);
+            writeResponseHead(input.res, response);
+            const captured = await streamResponse(response, input.res);
+            await recordUsageFromResponse({
+                text: captured.toString("utf8"),
+                contentType: response.headers.get("content-type") ?? "",
+                fallbackModel: input.requestedModel,
+                provider: candidate.provider.name,
+                tool: "codex",
+                records
+            });
+            if (response.ok)
+                await recordProviderRuntimeSuccess(candidate.provider.name);
+            else
+                await recordProviderRuntimeFailure(candidate.provider.name, `HTTP ${response.status}`);
+            input.res.end();
+            return;
+        }
+        catch (error) {
+            await recordProviderRuntimeFailure(candidate.provider.name, error);
+            await logFallback(candidate, input.requestId, error);
+            if (index === input.candidates.length - 1) {
+                sendJson(input.res, 502, {
+                    error: { message: "All configured AI providers failed.", request_id: input.requestId }
+                });
+                return;
+            }
+        }
+    }
+    if (lastFailure) {
+        sendBuffered(input.res, lastFailure);
+        return;
+    }
+    sendJson(input.res, 503, { error: { message: "No usable AI provider.", request_id: input.requestId } });
+}
+async function sendModels(res) {
+    const [providers, cache] = await Promise.all([readProviders(), readCache()]);
+    const ids = new Set();
+    for (const provider of providers) {
+        if (provider.model)
+            ids.add(provider.model);
+        for (const model of cache.providers[provider.name]?.models ?? [])
+            ids.add(model);
+    }
+    sendJson(res, 200, {
+        object: "list",
+        data: [...ids].sort().map((id) => ({ id, object: "model", owned_by: "agent-router" }))
+    });
+}
+async function sendBufferedResult(res, candidate, result, records, fallbackModel) {
+    res.setHeader("x-agent-router-provider", candidate.provider.name);
+    await recordUsageFromResponse({
+        text: result.body.toString("utf8"),
+        contentType: result.contentType,
+        fallbackModel,
+        provider: candidate.provider.name,
+        tool: "codex",
+        records
+    });
+    if (result.status >= 200 && result.status < 400)
+        await recordProviderRuntimeSuccess(candidate.provider.name);
+    else
+        await recordProviderRuntimeFailure(candidate.provider.name, `HTTP ${result.status}`);
+    sendBuffered(res, result);
+}
+async function bufferUpstream(response) {
+    return {
+        status: response.status,
+        statusText: response.statusText,
+        contentType: response.headers.get("content-type") ?? "application/json; charset=utf-8",
+        body: Buffer.from(await response.arrayBuffer())
+    };
+}
+function sendBuffered(res, result) {
+    res.statusCode = result.status;
+    res.statusMessage = result.statusText;
+    res.setHeader("content-type", result.contentType);
+    res.setHeader("content-length", String(result.body.length));
+    res.end(result.body);
+}
+async function recordCandidateFailure(candidate, failure) {
+    await recordProviderRuntimeFailure(candidate.provider.name, `HTTP ${failure.status}`);
+    await logFallback(candidate, crypto.randomUUID(), `HTTP ${failure.status}`);
+}
+async function logFallback(candidate, requestId, error) {
+    await writeLog({
+        level: "warn",
+        category: "strategy",
+        action: "runtime_server_provider_fallback",
+        message: `Provider ${candidate.provider.name} failed; trying the next candidate.`,
+        metadata: {
+            requestId,
+            provider: candidate.provider.name,
+            model: candidate.model,
+            error: error instanceof Error ? error.message : String(error)
+        }
+    });
+}
+async function readBoundedRequestBody(req, maxBytes) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of req) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        total += buffer.length;
+        if (total > maxBytes)
+            throw new RequestBodyTooLargeError();
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks);
+}
+class RequestBodyTooLargeError extends Error {
+    constructor() {
+        super("Request body exceeds configured limit.");
+    }
+}
+function extractModel(body) {
+    try {
+        const value = JSON.parse(body.toString("utf8"));
+        return typeof value.model === "string" && value.model.trim() ? value.model.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isAuthorized(header, token) {
+    if (!header?.startsWith("Bearer "))
+        return false;
+    const supplied = Buffer.from(header.slice(7));
+    const expected = Buffer.from(token);
+    return supplied.length === expected.length && crypto.timingSafeEqual(supplied, expected);
+}
+function isRetryableStatus(status) {
+    return status === 401 || status === 403 || status === 404 || status === 408 || status === 409
+        || status === 425 || status === 429 || status >= 500;
+}
+function isUsableEventStream(response) {
+    return response.ok && (response.headers.get("content-type") ?? "").toLowerCase().includes("text/event-stream");
+}
+function normalizePositiveInteger(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function normalizeRequestId(value) {
+    const candidate = Array.isArray(value) ? value[0] : value;
+    return candidate?.trim().slice(0, 128) || `req_${crypto.randomUUID()}`;
+}
+function displayHost(host) {
+    return host === "0.0.0.0" ? "127.0.0.1" : host;
+}
+function sendJson(res, status, value) {
+    const body = Buffer.from(JSON.stringify(value));
+    res.statusCode = status;
+    res.setHeader("content-type", "application/json; charset=utf-8");
+    res.setHeader("content-length", String(body.length));
+    res.end(body);
+}

package/dist/telegram/bot-registry.js

@@ -0,0 +1,80 @@
+import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+import path from "node:path";
+import { getConfigRoot, getTelegramBotConfigPath, getTelegramBotDbPath, getTelegramBotDir, getTelegramBotLogPath, getTelegramBotPidPath, getTelegramConfigPath, getTelegramDbPath } from "../core/config/paths.js";
+const BOT_NAME_RE = /^[a-z0-9]([a-z0-9_-]*[a-z0-9])?$/;
+export function isValidBotName(name) {
+    return BOT_NAME_RE.test(name) && name.length <= 32;
+}
+export function listBots() {
+    const dir = getTelegramBotDir();
+    if (!fs.existsSync(dir))
+        return [];
+    const entries = [];
+    for (const file of fs.readdirSync(dir)) {
+        if (file.endsWith(".json")) {
+            const name = file.slice(0, -5);
+            entries.push({ name, configPath: path.join(dir, file) });
+        }
+    }
+    return entries.sort((a, b) => a.name.localeCompare(b.name));
+}
+export function botExists(name) {
+    return fs.existsSync(getTelegramBotConfigPath(name));
+}
+export function isBotRunning(name) {
+    const pidPath = getTelegramBotPidPath(name);
+    if (!fs.existsSync(pidPath))
+        return { running: false, pid: null };
+    const raw = fs.readFileSync(pidPath, "utf8").trim();
+    const pid = Number(raw);
+    if (!Number.isInteger(pid) || pid <= 0)
+        return { running: false, pid: null };
+    try {
+        process.kill(pid, 0);
+        return { running: true, pid };
+    }
+    catch {
+        return { running: false, pid };
+    }
+}
+export async function migrateLegacyConfig() {
+    const legacyPath = getTelegramConfigPath();
+    if (!fs.existsSync(legacyPath))
+        return;
+    if (botExists("default"))
+        return;
+    const dir = getTelegramBotDir();
+    await fsPromises.mkdir(dir, { recursive: true });
+    await fsPromises.copyFile(legacyPath, getTelegramBotConfigPath("default"));
+}
+export async function removeBotFiles(name, configuredDbPath) {
+    const managedConfiguredDbPath = configuredDbPath && isManagedConfigPath(configuredDbPath)
+        ? path.resolve(configuredDbPath)
+        : undefined;
+    const dbPaths = new Set([
+        getTelegramBotDbPath(name),
+        ...(managedConfiguredDbPath ? [managedConfiguredDbPath] : []),
+        ...(name === "default" ? [getTelegramDbPath()] : [])
+    ]);
+    const paths = [
+        getTelegramBotConfigPath(name),
+        getTelegramBotPidPath(name),
+        getTelegramBotLogPath(name),
+        ...[...dbPaths].flatMap((dbPath) => [dbPath, `${dbPath}-shm`, `${dbPath}-wal`]),
+        ...(name === "default" ? [getTelegramConfigPath()] : [])
+    ];
+    for (const p of paths) {
+        try {
+            await fsPromises.unlink(p);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+}
+function isManagedConfigPath(filePath) {
+    const relative = path.relative(getConfigRoot(), path.resolve(filePath));
+    return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+}

package/dist/telegram/bot.js

@@ -0,0 +1,128 @@
+import { Bot } from "grammy";
+import { loadBotConfig, loadTelegramConfig, updateBotConfig, updateTelegramConfig } from "./config.js";
+import { createTelegramEngines } from "./engine/registry.js";
+import { registerCallbackHandler } from "./handlers/callback.js";
+import { registerCommands } from "./handlers/command.js";
+import { registerDocumentHandler } from "./handlers/document.js";
+import { registerMessageHandler } from "./handlers/message.js";
+import { isProviderSecretInput } from "./handlers/provider.js";
+import { installTelegramHandlers, registerTelegramHandler } from "./handler-registry.js";
+import { ApprovalManager } from "./interaction/approval.js";
+import { safeResetChatCommandMenu, safeSetChatCommandMenu, safeSetDefaultCommandMenu } from "./interaction/command-menu.js";
+import { getBotIdFromToken, MemoryService } from "./memory/memory-service.js";
+import { SessionManager } from "./session/manager.js";
+import { SessionStore } from "./session/store.js";
+import { writeTelegramLog } from "./log.js";
+import { configureTelegramNetwork, createTelegramApiClientOptions } from "./network.js";
+export async function createBot(botName) {
+    const config = botName ? await loadBotConfig(botName) : await loadTelegramConfig();
+    if (!config.token) {
+        throw new Error("Telegram token is not configured. Run `ai telegram config set token <token>`.");
+    }
+    if (!config.allowAllUsers && !config.allowedUserIds.length) {
+        throw new Error("No Telegram users are allowed. Run `ai telegram config set allowedUserIds <id>` or `ai telegram config set allowAllUsers true`.");
+    }
+    const proxyUrl = configureTelegramNetwork(config);
+    if (proxyUrl) {
+        await writeTelegramLog({
+            action: "proxy_enabled",
+            message: `Telegram API proxy enabled: ${proxyUrl}`
+        });
+    }
+    const bot = new Bot(config.token, {
+        client: createTelegramApiClientOptions(proxyUrl)
+    });
+    const store = new SessionStore(config.dbPath);
+    const sessionManager = new SessionManager(store, config);
+    const memoryService = new MemoryService({ botId: getBotIdFromToken(config.token) });
+    const engines = createTelegramEngines();
+    const approvalManager = new ApprovalManager(bot);
+    sessionManager.cleanupExpired();
+    const orphanCount = sessionManager.resetOrphanSessions();
+    if (orphanCount > 0) {
+        void writeTelegramLog({
+            action: "orphan_reset",
+            message: `Reset ${orphanCount} orphan session(s) stuck in running/waiting_approval`
+        });
+    }
+    memoryService.cleanupExpired();
+    void memoryService.backup();
+    bot.catch((error) => {
+        void writeTelegramLog({
+            level: "error",
+            action: "bot_error",
+            message: error.error instanceof Error ? error.error.message : String(error.error),
+            metadata: { updateId: error.ctx.update.update_id }
+        });
+    });
+    bot.use(async (ctx, next) => {
+        const text = ctx.message && "text" in ctx.message ? ctx.message.text : undefined;
+        const loggedText = isProviderSecretInput(ctx.chat?.id, ctx.me.id) ? "[REDACTED_PROVIDER_API_KEY]" : text;
+        await writeTelegramLog({
+            action: "update_received",
+            message: loggedText ? `Received Telegram message: ${loggedText.slice(0, 80)}` : `Received Telegram update ${ctx.update.update_id}`,
+            metadata: {
+                updateId: ctx.update.update_id,
+                userId: ctx.from?.id,
+                chatId: ctx.chat?.id,
+                messageType: ctx.message ? "message" : "other",
+                command: text?.startsWith("/") ? text.split(/\s+/, 1)[0] : undefined
+            }
+        });
+        const userId = ctx.from?.id;
+        if (!userId || (!config.allowAllUsers && !config.allowedUserIds.includes(userId))) {
+            await ctx.reply("Access denied.");
+            await writeTelegramLog({
+                level: "warn",
+                action: "access_denied",
+                message: `Denied Telegram user ${userId ?? "(missing)"}`,
+                metadata: { userId, chatId: ctx.chat?.id }
+            });
+            return;
+        }
+        await next();
+    });
+    const deps = {
+        bot,
+        sessionManager,
+        claudeEngine: engines.claude,
+        codexEngine: engines.codex,
+        approvalManager,
+        config,
+        engines,
+        memoryService,
+        updateConfig: (patch) => botName
+            ? updateBotConfig(botName, patch)
+            : updateTelegramConfig(patch)
+    };
+    registerBuiltInTelegramHandlers();
+    installTelegramHandlers(bot, deps);
+    await safeSetDefaultCommandMenu(bot);
+    await refreshStoredChatCommandMenus(bot, sessionManager);
+    return {
+        bot,
+        config,
+        store,
+        sessionManager,
+        memoryService,
+        engines
+    };
+}
+function registerBuiltInTelegramHandlers() {
+    registerTelegramHandler("commands", registerCommands);
+    registerTelegramHandler("callbacks", registerCallbackHandler);
+    registerTelegramHandler("documents", registerDocumentHandler);
+    registerTelegramHandler("messages", registerMessageHandler);
+}
+async function refreshStoredChatCommandMenus(bot, sessionManager) {
+    const sessions = sessionManager.getActiveSessions();
+    for (const session of sessions) {
+        if (session.setupStep === "ready") {
+            const customCommands = sessionManager.listCustomCommands(session.chatId, session.cwd);
+            await safeSetChatCommandMenu(bot, session.chatId, session.engine, customCommands);
+        }
+        else {
+            await safeResetChatCommandMenu(bot, session.chatId);
+        }
+    }
+}