@elizaos/agent 0.25.9 → 2.0.0-alpha.151

package/packages/agent/src/api/streaming-text.d.ts

@@ -0,0 +1,9 @@
+export type StreamingUpdateKind = "noop" | "append" | "replace";
+export interface StreamingUpdate {
+    kind: StreamingUpdateKind;
+    nextText: string;
+    emittedText: string;
+}
+export declare function mergeStreamingText(existing: string, incoming: string): string;
+export declare function resolveStreamingUpdate(existing: string, incoming: string): StreamingUpdate;
+//# sourceMappingURL=streaming-text.d.ts.map

package/packages/agent/src/api/streaming-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-text.d.ts","sourceRoot":"","sources":["../../../../../src/api/streaming-text.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEhE,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,mBAAmB,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB;AAqDD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CA6C7E;AAED,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,eAAe,CAmBjB"}

package/packages/agent/src/api/streaming-text.js

@@ -0,0 +1,85 @@
+function commonPrefixLength(left, right) {
+    const maxLength = Math.min(left.length, right.length);
+    let index = 0;
+    while (index < maxLength &&
+        left.charCodeAt(index) === right.charCodeAt(index)) {
+        index += 1;
+    }
+    return index;
+}
+function commonSuffixLength(left, right, sharedPrefixLength) {
+    const maxLength = Math.min(left.length - sharedPrefixLength, right.length - sharedPrefixLength);
+    let length = 0;
+    while (length < maxLength &&
+        left.charCodeAt(left.length - 1 - length) ===
+            right.charCodeAt(right.length - 1 - length)) {
+        length += 1;
+    }
+    return length;
+}
+function isLikelySnapshotReplacement(existing, incoming) {
+    const sharedPrefixLength = commonPrefixLength(existing, incoming);
+    const sharedSuffixLength = commonSuffixLength(existing, incoming, sharedPrefixLength);
+    const sharedLength = sharedPrefixLength + sharedSuffixLength;
+    const minLength = Math.min(existing.length, incoming.length);
+    return (sharedPrefixLength >= 8 ||
+        sharedLength >= Math.max(4, Math.ceil(minLength * 0.7)));
+}
+export function mergeStreamingText(existing, incoming) {
+    if (!incoming)
+        return existing;
+    if (!existing)
+        return incoming;
+    if (incoming === existing)
+        return existing;
+    if (incoming.startsWith(existing)) {
+        return incoming;
+    }
+    if (incoming.includes(existing)) {
+        return incoming;
+    }
+    if (existing.startsWith(incoming)) {
+        return existing;
+    }
+    const maxOverlap = Math.min(existing.length, incoming.length);
+    const existingLength = existing.length;
+    for (let overlap = maxOverlap; overlap > 0; overlap -= 1) {
+        const existingStart = existingLength - overlap;
+        let match = true;
+        for (let index = 0; index < overlap; index += 1) {
+            if (existing.charCodeAt(existingStart + index) !==
+                incoming.charCodeAt(index)) {
+                match = false;
+                break;
+            }
+        }
+        if (!match)
+            continue;
+        if (overlap === incoming.length) {
+            return incoming.length === 1 ? `${existing}${incoming}` : existing;
+        }
+        return `${existing}${incoming.slice(overlap)}`;
+    }
+    if (isLikelySnapshotReplacement(existing, incoming)) {
+        return incoming;
+    }
+    return `${existing}${incoming}`;
+}
+export function resolveStreamingUpdate(existing, incoming) {
+    const nextText = mergeStreamingText(existing, incoming);
+    if (nextText === existing) {
+        return { kind: "noop", nextText: existing, emittedText: "" };
+    }
+    if (nextText.startsWith(existing)) {
+        return {
+            kind: "append",
+            nextText,
+            emittedText: nextText.slice(existing.length),
+        };
+    }
+    return {
+        kind: "replace",
+        nextText,
+        emittedText: nextText,
+    };
+}

package/packages/agent/src/api/streaming-types.d.ts

@@ -0,0 +1,30 @@
+export interface OverlayWidgetInstance {
+    id: string;
+    type: string;
+    enabled: boolean;
+    position: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    zIndex: number;
+    config: Record<string, unknown>;
+}
+export interface OverlayLayoutData {
+    version: 1;
+    name: string;
+    widgets: OverlayWidgetInstance[];
+}
+export interface StreamingDestination {
+    id: string;
+    name: string;
+    getCredentials(): Promise<{
+        rtmpUrl: string;
+        rtmpKey: string;
+    }>;
+    onStreamStart?(): Promise<void>;
+    onStreamStop?(): Promise<void>;
+    defaultOverlayLayout?: OverlayLayoutData;
+}
+//# sourceMappingURL=streaming-types.d.ts.map

package/packages/agent/src/api/streaming-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-types.d.ts","sourceRoot":"","sources":["../../../../../src/api/streaming-types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAClE,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,CAAC,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,qBAAqB,EAAE,CAAC;CAClC;AAED,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAChE,aAAa,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,oBAAoB,CAAC,EAAE,iBAAiB,CAAC;CAC1C"}

package/packages/agent/src/api/streaming-types.js

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

package/packages/agent/src/api/subscription-routes.d.ts

@@ -0,0 +1,20 @@
+import type { AnthropicFlow } from "../auth/anthropic.js";
+import type { CodexFlow } from "../auth/openai-codex.js";
+import type { ElizaConfig } from "../config/types.eliza.js";
+import type { RouteRequestContext } from "./route-helpers.js";
+type AuthModule = typeof import("../auth/index");
+export type SubscriptionAuthApi = Pick<AuthModule, "getSubscriptionStatus" | "startAnthropicLogin" | "startCodexLogin" | "saveCredentials" | "applySubscriptionCredentials" | "deleteCredentials">;
+export interface SubscriptionRouteState {
+    config: ElizaConfig;
+    _anthropicFlow?: AnthropicFlow;
+    _codexFlow?: CodexFlow;
+    _codexFlowTimer?: ReturnType<typeof setTimeout>;
+}
+export interface SubscriptionRouteContext extends RouteRequestContext {
+    state: SubscriptionRouteState;
+    saveConfig: (config: ElizaConfig) => void;
+    loadSubscriptionAuth: () => Promise<SubscriptionAuthApi>;
+}
+export declare function handleSubscriptionRoutes(ctx: SubscriptionRouteContext): Promise<boolean>;
+export {};
+//# sourceMappingURL=subscription-routes.d.ts.map

package/packages/agent/src/api/subscription-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscription-routes.d.ts","sourceRoot":"","sources":["../../../../../src/api/subscription-routes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,KAAK,UAAU,GAAG,cAAc,eAAe,CAAC,CAAC;AAEjD,MAAM,MAAM,mBAAmB,GAAG,IAAI,CACpC,UAAU,EACR,uBAAuB,GACvB,qBAAqB,GACrB,iBAAiB,GACjB,iBAAiB,GACjB,8BAA8B,GAC9B,mBAAmB,CACtB,CAAC;AAEF,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,WAAW,CAAC;IACpB,cAAc,CAAC,EAAE,aAAa,CAAC;IAC/B,UAAU,CAAC,EAAE,SAAS,CAAC;IACvB,eAAe,CAAC,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;CACjD;AAED,MAAM,WAAW,wBAAyB,SAAQ,mBAAmB;IACnE,KAAK,EAAE,sBAAsB,CAAC;IAC9B,UAAU,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAC;IAC1C,oBAAoB,EAAE,MAAM,OAAO,CAAC,mBAAmB,CAAC,CAAC;CAC1D;AAED,wBAAsB,wBAAwB,CAC5C,GAAG,EAAE,wBAAwB,GAC5B,OAAO,CAAC,OAAO,CAAC,CAgPlB"}

package/packages/agent/src/api/subscription-routes.js

@@ -0,0 +1,213 @@
+import { logger } from "@elizaos/core";
+export async function handleSubscriptionRoutes(ctx) {
+    const { req, res, method, pathname, state, readJsonBody, json, error, loadSubscriptionAuth, } = ctx;
+    if (!pathname.startsWith("/api/subscription/"))
+        return false;
+    if (method === "GET" && pathname === "/api/subscription/status") {
+        try {
+            const { getSubscriptionStatus } = await loadSubscriptionAuth();
+            json(res, { providers: getSubscriptionStatus() });
+        }
+        catch (err) {
+            logger.error(`[api] Failed to get subscription status: ${String(err)}`);
+            error(res, "Failed to get subscription status", 500);
+        }
+        return true;
+    }
+    if (method === "POST" && pathname === "/api/subscription/anthropic/start") {
+        try {
+            const { startAnthropicLogin } = await loadSubscriptionAuth();
+            const flow = await startAnthropicLogin();
+            state._anthropicFlow = flow;
+            json(res, { authUrl: flow.authUrl });
+        }
+        catch (err) {
+            logger.error(`[api] Failed to start Anthropic login: ${String(err)}`);
+            error(res, "Failed to start Anthropic login", 500);
+        }
+        return true;
+    }
+    if (method === "POST" &&
+        pathname === "/api/subscription/anthropic/exchange") {
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        if (!body.code) {
+            error(res, "Missing code", 400);
+            return true;
+        }
+        try {
+            const { saveCredentials, applySubscriptionCredentials } = await loadSubscriptionAuth();
+            const flow = state._anthropicFlow;
+            if (!flow) {
+                error(res, "No active flow — call /start first", 400);
+                return true;
+            }
+            flow.submitCode(body.code);
+            const credentials = await flow.credentials;
+            saveCredentials("anthropic-subscription", credentials);
+            await applySubscriptionCredentials(state.config);
+            delete state._anthropicFlow;
+            json(res, { success: true, expiresAt: credentials.expires });
+        }
+        catch (err) {
+            delete state._anthropicFlow;
+            logger.error(`[api] Anthropic exchange failed: ${String(err)}`);
+            error(res, "Anthropic exchange failed", 500);
+        }
+        return true;
+    }
+    if (method === "POST" &&
+        pathname === "/api/subscription/anthropic/setup-token") {
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        const trimmedToken = body.token?.trim();
+        if (!trimmedToken?.startsWith("sk-ant-")) {
+            error(res, "Invalid token format — expected sk-ant-oat01-...", 400);
+            return true;
+        }
+        try {
+            // Store the setup token in config for task-agent discovery but do
+            // NOT inject it into process.env.ANTHROPIC_API_KEY.  Anthropic's
+            // TOS only permits subscription tokens through the Claude Code CLI.
+            // The task-agent orchestrator spawns `claude` CLI subprocesses
+            // which use the token legitimately.
+            if (!state.config.env)
+                state.config.env = {};
+            state.config.env.__anthropicSubscriptionToken = trimmedToken;
+            ctx.saveConfig(state.config);
+            logger.info("[api] Saved Anthropic setup token for task agents (not applied to runtime — TOS restriction)");
+            json(res, { success: true });
+        }
+        catch (err) {
+            logger.error(`[api] Failed to save setup token: ${String(err)}`);
+            error(res, "Failed to save setup token", 500);
+        }
+        return true;
+    }
+    if (method === "POST" && pathname === "/api/subscription/openai/start") {
+        try {
+            const { startCodexLogin } = await loadSubscriptionAuth();
+            if (state._codexFlow) {
+                try {
+                    state._codexFlow.close();
+                }
+                catch (err) {
+                    logger.debug(`[api] OAuth flow cleanup failed: ${err instanceof Error ? err.message : err}`);
+                }
+            }
+            clearTimeout(state._codexFlowTimer);
+            const flow = await startCodexLogin();
+            state._codexFlow = flow;
+            state._codexFlowTimer = setTimeout(() => {
+                try {
+                    flow.close();
+                }
+                catch (err) {
+                    logger.debug(`[api] OAuth flow cleanup failed: ${err instanceof Error ? err.message : err}`);
+                }
+                delete state._codexFlow;
+                delete state._codexFlowTimer;
+            }, 10 * 60 * 1000);
+            json(res, {
+                authUrl: flow.authUrl,
+                state: flow.state,
+                instructions: "Open the URL in your browser. After login, if auto-redirect doesn't work, paste the full redirect URL.",
+            });
+        }
+        catch (err) {
+            logger.error(`[api] Failed to start OpenAI login: ${String(err)}`);
+            error(res, "Failed to start OpenAI login", 500);
+        }
+        return true;
+    }
+    if (method === "POST" && pathname === "/api/subscription/openai/exchange") {
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        try {
+            const { saveCredentials, applySubscriptionCredentials } = await loadSubscriptionAuth();
+            const flow = state._codexFlow;
+            if (!flow) {
+                error(res, "No active flow — call /start first", 400);
+                return true;
+            }
+            if (body.code) {
+                flow.submitCode(body.code);
+            }
+            else if (!body.waitForCallback) {
+                error(res, "Provide either code or set waitForCallback: true", 400);
+                return true;
+            }
+            let credentials;
+            try {
+                credentials = await flow.credentials;
+            }
+            catch (err) {
+                try {
+                    flow.close();
+                }
+                catch (closeErr) {
+                    logger.debug(`[api] OAuth flow cleanup failed: ${closeErr instanceof Error ? closeErr.message : closeErr}`);
+                }
+                delete state._codexFlow;
+                clearTimeout(state._codexFlowTimer);
+                delete state._codexFlowTimer;
+                logger.error(`[api] OpenAI exchange failed: ${String(err)}`);
+                error(res, "OpenAI exchange failed", 500);
+                return true;
+            }
+            saveCredentials("openai-codex", credentials);
+            await applySubscriptionCredentials(state.config);
+            flow.close();
+            delete state._codexFlow;
+            clearTimeout(state._codexFlowTimer);
+            delete state._codexFlowTimer;
+            json(res, {
+                success: true,
+                expiresAt: credentials.expires,
+            });
+        }
+        catch (err) {
+            logger.error(`[api] OpenAI exchange failed: ${String(err)}`);
+            error(res, "OpenAI exchange failed", 500);
+        }
+        return true;
+    }
+    if (method === "DELETE" && pathname.startsWith("/api/subscription/")) {
+        const provider = pathname.split("/").pop();
+        if (provider === "anthropic-subscription" || provider === "openai-codex") {
+            try {
+                const { deleteCredentials } = await loadSubscriptionAuth();
+                deleteCredentials(provider);
+                if (provider === "anthropic-subscription" && state.config.env) {
+                    delete state.config.env
+                        .__anthropicSubscriptionToken;
+                }
+                if (state.config.agents?.defaults?.subscriptionProvider === provider) {
+                    delete state.config.agents.defaults.subscriptionProvider;
+                }
+                const llmBackend = state.config.serviceRouting?.llmText?.backend;
+                const deletedProviderId = provider === "openai-codex" ? "openai-subscription" : provider;
+                if (llmBackend === deletedProviderId && state.config.serviceRouting) {
+                    delete state.config.serviceRouting.llmText;
+                    if (Object.keys(state.config.serviceRouting).length === 0) {
+                        delete state.config.serviceRouting;
+                    }
+                }
+                ctx.saveConfig(state.config);
+                json(res, { success: true });
+            }
+            catch (err) {
+                logger.error(`[api] Failed to delete credentials: ${String(err)}`);
+                error(res, "Failed to delete credentials", 500);
+            }
+        }
+        else {
+            error(res, `Unknown provider: ${provider}`, 400);
+        }
+        return true;
+    }
+    return false;
+}

package/packages/agent/src/api/task-agent-message-routing.d.ts

@@ -0,0 +1,2 @@
+export * from "@elizaos/app-task-coordinator/api/task-agent-message-routing";
+//# sourceMappingURL=task-agent-message-routing.d.ts.map

package/packages/agent/src/api/task-agent-message-routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-agent-message-routing.d.ts","sourceRoot":"","sources":["../../../../../src/api/task-agent-message-routing.ts"],"names":[],"mappings":"AAAA,cAAc,8DAA8D,CAAC"}

package/packages/agent/src/api/task-agent-message-routing.js

@@ -0,0 +1 @@
+export * from "@elizaos/app-task-coordinator/api/task-agent-message-routing";

package/packages/agent/src/api/telegram-account-routes.d.ts

@@ -0,0 +1,26 @@
+import type http from "node:http";
+import { type TelegramAccountAuthSessionLike } from "../services/telegram-account-auth.js";
+import type { RouteHelpers } from "./route-helpers.js";
+export interface TelegramAccountRouteState {
+    config: Record<string, unknown> & {
+        connectors?: Record<string, Record<string, unknown>>;
+    };
+    saveConfig: () => void;
+    runtime?: {
+        getService(type: string): unknown;
+        getSetting(key: string): string | undefined;
+    };
+    telegramAccountAuthSession?: TelegramAccountAuthSessionLike | null;
+}
+export interface TelegramAccountRouteDeps {
+    createAuthSession: (options: {
+        deviceModel?: string;
+        systemVersion?: string;
+    }) => TelegramAccountAuthSessionLike;
+    authStateExists: () => boolean;
+    sessionExists: () => boolean;
+    clearAuthState: () => void;
+    clearSession: () => void;
+}
+export declare function handleTelegramAccountRoute(req: http.IncomingMessage, res: http.ServerResponse, pathname: string, method: string, state: TelegramAccountRouteState, helpers: RouteHelpers, deps?: TelegramAccountRouteDeps): Promise<boolean>;
+//# sourceMappingURL=telegram-account-routes.d.ts.map

package/packages/agent/src/api/telegram-account-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telegram-account-routes.d.ts","sourceRoot":"","sources":["../../../../../src/api/telegram-account-routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,EAML,KAAK,8BAA8B,EAIpC,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAcvD,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;QAChC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;KACtD,CAAC;IACF,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,OAAO,CAAC,EAAE;QACR,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAClC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;KAC7C,CAAC;IACF,0BAA0B,CAAC,EAAE,8BAA8B,GAAG,IAAI,CAAC;CACpE;AAED,MAAM,WAAW,wBAAwB;IACvC,iBAAiB,EAAE,CAAC,OAAO,EAAE;QAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,KAAK,8BAA8B,CAAC;IACrC,eAAe,EAAE,MAAM,OAAO,CAAC;IAC/B,aAAa,EAAE,MAAM,OAAO,CAAC;IAC7B,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,YAAY,EAAE,MAAM,IAAI,CAAC;CAC1B;AA8LD,wBAAsB,0BAA0B,CAC9C,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,yBAAyB,EAChC,OAAO,EAAE,YAAY,EACrB,IAAI,GAAE,wBAML,GACA,OAAO,CAAC,OAAO,CAAC,CA8HlB"}

package/packages/agent/src/api/telegram-account-routes.js

@@ -0,0 +1,229 @@
+import { clearTelegramAccountAuthState, clearTelegramAccountSession, defaultTelegramAccountDeviceModel, defaultTelegramAccountSystemVersion, TelegramAccountAuthSession, telegramAccountAuthStateExists, telegramAccountSessionExists, } from "../services/telegram-account-auth.js";
+const MAX_BODY_BYTES = 16_384;
+function readConnectorConfig(state) {
+    const connectors = state.config.connectors;
+    const raw = connectors?.telegramAccount;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return {};
+    }
+    return raw;
+}
+function hasConfiguredTelegramAccount(config) {
+    return Boolean(typeof config.phone === "string" &&
+        config.phone.trim() &&
+        (typeof config.appId === "string" || typeof config.appId === "number") &&
+        typeof config.appHash === "string" &&
+        config.appHash.trim() &&
+        typeof config.deviceModel === "string" &&
+        config.deviceModel.trim() &&
+        typeof config.systemVersion === "string" &&
+        config.systemVersion.trim() &&
+        config.enabled !== false);
+}
+function resolveConfiguredPhone(state, config) {
+    if (typeof config.phone === "string" && config.phone.trim().length > 0) {
+        return config.phone.trim();
+    }
+    const setting = state.runtime?.getSetting("TELEGRAM_ACCOUNT_PHONE");
+    return typeof setting === "string" && setting.trim().length > 0
+        ? setting.trim()
+        : null;
+}
+function resolveService(state) {
+    if (!state.runtime) {
+        return null;
+    }
+    const service = state.runtime.getService("telegram-account");
+    return (service ?? null);
+}
+function isServiceConnected(service) {
+    if (!service) {
+        return false;
+    }
+    if (typeof service.isConnected === "function") {
+        return service.isConnected();
+    }
+    const withFlags = service;
+    if (typeof withFlags.isServiceConnected === "function") {
+        return withFlags.isServiceConnected();
+    }
+    return withFlags.connected === true;
+}
+function statusFromState(state, deps) {
+    const connectorConfig = readConnectorConfig(state);
+    const configured = hasConfiguredTelegramAccount(connectorConfig);
+    const sessionExists = deps.sessionExists();
+    const authSnapshot = state.telegramAccountAuthSession?.getSnapshot() ?? null;
+    const service = resolveService(state);
+    const serviceConnected = isServiceConnected(service);
+    const serviceAccount = typeof service?.getAccountSummary === "function"
+        ? service.getAccountSummary()
+        : null;
+    const fallbackPhone = resolveConfiguredPhone(state, connectorConfig);
+    let status = authSnapshot?.status ??
+        (serviceConnected
+            ? "connected"
+            : configured || sessionExists
+                ? "configured"
+                : "idle");
+    if (serviceConnected && status === "configured") {
+        status = "connected";
+    }
+    return {
+        available: true,
+        status,
+        configured,
+        sessionExists,
+        serviceConnected,
+        restartRequired: status === "configured" && !serviceConnected,
+        hasAppCredentials: Boolean((typeof connectorConfig.appId === "string" ||
+            typeof connectorConfig.appId === "number") &&
+            typeof connectorConfig.appHash === "string" &&
+            connectorConfig.appHash.trim().length > 0),
+        phone: authSnapshot?.phone ?? fallbackPhone,
+        isCodeViaApp: authSnapshot?.isCodeViaApp ?? false,
+        account: authSnapshot?.account ?? serviceAccount ?? null,
+        error: authSnapshot?.error ?? null,
+    };
+}
+function ensureConnectorBlock(state) {
+    if (!state.config.connectors) {
+        state.config.connectors = {};
+    }
+    const connectors = state.config.connectors;
+    if (!connectors.telegramAccount ||
+        typeof connectors.telegramAccount !== "object" ||
+        Array.isArray(connectors.telegramAccount)) {
+        connectors.telegramAccount = {};
+    }
+    return connectors.telegramAccount;
+}
+function createSessionOptions(state) {
+    const connectorConfig = readConnectorConfig(state);
+    return {
+        deviceModel: typeof connectorConfig.deviceModel === "string" &&
+            connectorConfig.deviceModel.trim().length > 0
+            ? connectorConfig.deviceModel.trim()
+            : defaultTelegramAccountDeviceModel(),
+        systemVersion: typeof connectorConfig.systemVersion === "string" &&
+            connectorConfig.systemVersion.trim().length > 0
+            ? connectorConfig.systemVersion.trim()
+            : defaultTelegramAccountSystemVersion(),
+    };
+}
+function ensureAuthSession(state, deps) {
+    if (state.telegramAccountAuthSession) {
+        return state.telegramAccountAuthSession;
+    }
+    if (!deps.authStateExists()) {
+        return null;
+    }
+    state.telegramAccountAuthSession = deps.createAuthSession(createSessionOptions(state));
+    return state.telegramAccountAuthSession;
+}
+export async function handleTelegramAccountRoute(req, res, pathname, method, state, helpers, deps = {
+    createAuthSession: (options) => new TelegramAccountAuthSession(options),
+    authStateExists: telegramAccountAuthStateExists,
+    sessionExists: telegramAccountSessionExists,
+    clearAuthState: clearTelegramAccountAuthState,
+    clearSession: clearTelegramAccountSession,
+}) {
+    if (!pathname.startsWith("/api/telegram-account")) {
+        return false;
+    }
+    if (method === "GET" && pathname === "/api/telegram-account/status") {
+        ensureAuthSession(state, deps);
+        helpers.json(res, statusFromState(state, deps));
+        return true;
+    }
+    if (method === "POST" && pathname === "/api/telegram-account/auth/start") {
+        const body = await helpers.readJsonBody(req, res, {
+            maxBytes: MAX_BODY_BYTES,
+        });
+        if (!body) {
+            return true;
+        }
+        const connectorConfig = readConnectorConfig(state);
+        const phone = (typeof body.phone === "string" && body.phone.trim()) ||
+            resolveConfiguredPhone(state, connectorConfig);
+        if (!phone) {
+            helpers.error(res, "telegram phone number is required", 400);
+            return true;
+        }
+        await state.telegramAccountAuthSession?.stop();
+        state.telegramAccountAuthSession = deps.createAuthSession(createSessionOptions(state));
+        const credentials = hasConfiguredTelegramAccount(connectorConfig) &&
+            (typeof connectorConfig.appId === "string" ||
+                typeof connectorConfig.appId === "number") &&
+            typeof connectorConfig.appHash === "string"
+            ? {
+                apiId: Number(connectorConfig.appId),
+                apiHash: connectorConfig.appHash,
+            }
+            : null;
+        try {
+            await state.telegramAccountAuthSession.start({ phone, credentials });
+            const resolved = state.telegramAccountAuthSession.getResolvedConnectorConfig();
+            if (resolved) {
+                Object.assign(ensureConnectorBlock(state), resolved);
+                state.saveConfig();
+            }
+            helpers.json(res, statusFromState(state, deps));
+        }
+        catch (error) {
+            helpers.error(res, error instanceof Error ? error.message : String(error), 500);
+        }
+        return true;
+    }
+    if (method === "POST" && pathname === "/api/telegram-account/auth/submit") {
+        const body = await helpers.readJsonBody(req, res, {
+            maxBytes: MAX_BODY_BYTES,
+        });
+        if (!body) {
+            return true;
+        }
+        if (!ensureAuthSession(state, deps)) {
+            helpers.error(res, "telegram login session has not been started", 400);
+            return true;
+        }
+        const authSession = state.telegramAccountAuthSession;
+        if (!authSession) {
+            helpers.error(res, "telegram login session has not been started", 400);
+            return true;
+        }
+        try {
+            await authSession.submit(body);
+            const resolved = authSession.getResolvedConnectorConfig();
+            if (resolved) {
+                Object.assign(ensureConnectorBlock(state), resolved);
+                state.saveConfig();
+            }
+            helpers.json(res, statusFromState(state, deps));
+        }
+        catch (error) {
+            helpers.error(res, error instanceof Error ? error.message : String(error), 500);
+        }
+        return true;
+    }
+    if (method === "POST" && pathname === "/api/telegram-account/disconnect") {
+        await state.telegramAccountAuthSession?.stop();
+        state.telegramAccountAuthSession = null;
+        deps.clearAuthState();
+        deps.clearSession();
+        const service = resolveService(state);
+        if (typeof service?.stop === "function") {
+            await service.stop();
+        }
+        const connectors = state.config.connectors;
+        if (connectors?.telegramAccount) {
+            delete connectors.telegramAccount;
+            state.saveConfig();
+        }
+        helpers.json(res, {
+            ok: true,
+            ...statusFromState(state, deps),
+        });
+        return true;
+    }
+    return false;
+}