@offerpilot/axiomruntime 0.0.1

package/dist/telegram/network.js

@@ -0,0 +1,53 @@
+import { ProxyAgent, setGlobalDispatcher } from "undici";
+import { HttpsProxyAgent } from "https-proxy-agent";
+export function getTelegramProxyUrl(config) {
+    return config.proxyUrl
+        ?? process.env.AI_GATEWAY_TELEGRAM_PROXY
+        ?? process.env.HTTPS_PROXY
+        ?? process.env.https_proxy
+        ?? process.env.ALL_PROXY
+        ?? process.env.all_proxy
+        ?? process.env.HTTP_PROXY
+        ?? process.env.http_proxy
+        ?? null;
+}
+export function configureTelegramNetwork(config) {
+    const proxyUrl = getTelegramProxyUrl(config);
+    if (!proxyUrl)
+        return null;
+    setGlobalDispatcher(new ProxyAgent(proxyUrl));
+    return proxyUrl;
+}
+export function createTelegramApiClientOptions(proxyUrl) {
+    if (!proxyUrl)
+        return undefined;
+    return {
+        baseFetchConfig: {
+            agent: new HttpsProxyAgent(proxyUrl)
+        }
+    };
+}
+export async function checkTelegramApi(token, proxyUrl) {
+    if (proxyUrl) {
+        setGlobalDispatcher(new ProxyAgent(proxyUrl));
+    }
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 10000);
+        const response = await fetch(`https://api.telegram.org/bot${token}/getMe`, { signal: controller.signal });
+        clearTimeout(timeout);
+        const body = await response.json();
+        return {
+            ok: Boolean(response.ok && body.ok),
+            status: response.status,
+            username: body.result?.username,
+            error: body.description
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error instanceof Error ? `${error.name}: ${error.message}` : String(error)
+        };
+    }
+}

package/dist/telegram/session/manager.js

@@ -0,0 +1,229 @@
+import fs from "node:fs";
+const MAX_CONVERSATION_TURNS = 12;
+const MAX_CONVERSATION_USER_CHARS = 1000;
+const MAX_CONVERSATION_ASSISTANT_CHARS = 1600;
+const MAX_PINNED_TURNS = 3;
+export class SessionManager {
+    store;
+    config;
+    chatQueues = new Map();
+    constructor(store, config) {
+        this.store = store;
+        this.config = config;
+    }
+    async runExclusive(chatId, task) {
+        const previous = this.chatQueues.get(chatId) ?? Promise.resolve();
+        const waitForPrevious = previous.catch(() => undefined);
+        let release;
+        const current = new Promise((resolve) => {
+            release = resolve;
+        });
+        const next = waitForPrevious.then(() => current);
+        this.chatQueues.set(chatId, next);
+        await waitForPrevious;
+        try {
+            return await task();
+        }
+        finally {
+            release();
+            if (this.chatQueues.get(chatId) === next) {
+                this.chatQueues.delete(chatId);
+            }
+        }
+    }
+    getOrCreate(chatId, defaults = {}) {
+        const existing = this.store.getActiveByChatId(chatId);
+        if (existing) {
+            this.store.touch(existing.id);
+            return existing;
+        }
+        return this.store.create({
+            chatId,
+            engine: defaults.engine ?? this.config.defaultEngine,
+            cwd: defaults.cwd ?? this.config.defaultCwd,
+            permissionMode: defaults.permissionMode ?? this.config.defaultPermissionMode,
+            approveAll: defaults.approveAll ?? false,
+            setupStep: defaults.setupStep ?? "ready",
+            status: defaults.status ?? "idle"
+        });
+    }
+    startSetup(chatId) {
+        this.store.closeByChatId(chatId);
+        return this.store.create({
+            chatId,
+            engine: this.config.defaultEngine,
+            cwd: this.config.defaultCwd,
+            permissionMode: this.config.defaultPermissionMode,
+            approveAll: false,
+            setupStep: "model",
+            status: "idle"
+        });
+    }
+    getById(id) {
+        return this.store.getById(id);
+    }
+    update(id, patch) {
+        return this.store.update(id, patch);
+    }
+    newSession(chatId) {
+        const current = this.store.getActiveByChatId(chatId);
+        this.store.closeByChatId(chatId);
+        return this.store.create({
+            chatId,
+            engine: current?.engine ?? this.config.defaultEngine,
+            cwd: current?.cwd ?? this.config.defaultCwd,
+            permissionMode: current?.permissionMode ?? this.config.defaultPermissionMode,
+            approveAll: false,
+            setupStep: current?.setupStep ?? "ready",
+            status: "idle"
+        });
+    }
+    clearConversation(chatId) {
+        const current = this.getOrCreate(chatId);
+        return this.store.update(current.id, {
+            engineSessionId: null,
+            botContextFingerprint: null,
+            approveAll: false,
+            status: "idle",
+            messageCount: 0,
+            attachments: [],
+            conversation: []
+        });
+    }
+    pinTurn(chatId, messageId, turn) {
+        const session = this.getOrCreate(chatId);
+        const existing = session.pinnedTurns.find((p) => p.messageId === messageId);
+        if (existing)
+            return session;
+        const pinned = {
+            messageId,
+            user: truncateConversationText(turn.user, MAX_CONVERSATION_USER_CHARS),
+            assistant: truncateConversationText(turn.assistant, MAX_CONVERSATION_ASSISTANT_CHARS),
+            pinnedAt: new Date().toISOString()
+        };
+        const next = [...session.pinnedTurns, pinned].slice(-MAX_PINNED_TURNS);
+        return this.store.update(session.id, { pinnedTurns: next });
+    }
+    unpinTurn(chatId, messageId) {
+        const session = this.getOrCreate(chatId);
+        const next = session.pinnedTurns.filter((p) => p.messageId !== messageId);
+        if (next.length === session.pinnedTurns.length)
+            return session;
+        return this.store.update(session.id, { pinnedTurns: next });
+    }
+    appendConversationTurn(sessionId, input) {
+        const session = this.store.getById(sessionId);
+        if (!session) {
+            throw new Error(`Telegram session not found: ${sessionId}`);
+        }
+        const turn = {
+            user: truncateConversationText(input.user, MAX_CONVERSATION_USER_CHARS),
+            assistant: truncateConversationText(input.assistant, MAX_CONVERSATION_ASSISTANT_CHARS),
+            createdAt: new Date().toISOString()
+        };
+        return this.store.update(sessionId, {
+            conversation: [...session.conversation, turn].slice(-MAX_CONVERSATION_TURNS)
+        });
+    }
+    prepareEditedPrompt(chatId, previousPrompt) {
+        const session = this.getOrCreate(chatId);
+        const conversation = [...session.conversation];
+        for (let index = conversation.length - 1; index >= 0; index -= 1) {
+            if (conversation[index]?.user === previousPrompt) {
+                conversation.splice(index, 1);
+                break;
+            }
+        }
+        return this.store.update(session.id, {
+            engineSessionId: null,
+            conversation
+        });
+    }
+    recordProviderUsage(sessionId, input) {
+        const session = this.store.getById(sessionId);
+        if (!session) {
+            throw new Error(`Telegram session not found: ${sessionId}`);
+        }
+        const provider = input.provider.trim() || "unknown";
+        const model = input.model?.trim() || "(unknown)";
+        const hasCost = typeof input.costUsd === "number" && Number.isFinite(input.costUsd) && input.costUsd >= 0;
+        const nextUsage = upsertProviderUsage(session.providerUsage, {
+            provider,
+            model,
+            costUsd: hasCost ? input.costUsd : undefined,
+            usage: input.usage
+        });
+        return this.store.update(sessionId, { providerUsage: nextUsage });
+    }
+    resume(chatId, idPrefix) {
+        const sessions = this.getHistory(chatId, 20);
+        const target = idPrefix
+            ? sessions.find((session) => session.id.startsWith(idPrefix))
+            : sessions.find((session) => session.status !== "closed") ?? sessions[0];
+        if (!target)
+            return null;
+        this.store.closeByChatId(chatId);
+        return this.store.update(target.id, { status: "idle", approveAll: false });
+    }
+    getHistory(chatId, limit = 10) {
+        return this.store.listByChatId(chatId, limit);
+    }
+    getActiveSessions(limit = 100) {
+        return this.store.listActiveByChat(limit);
+    }
+    addAttachment(chatId, attachment) {
+        const session = this.getOrCreate(chatId);
+        return this.store.addAttachment(session.id, attachment);
+    }
+    clearAttachments(sessionId) {
+        return this.store.clearAttachments(sessionId);
+    }
+    rememberWorkdir(chatId, cwd) {
+        this.store.rememberWorkdir(chatId, cwd);
+    }
+    getWorkdirs(chatId, limit = 8) {
+        return this.store.listWorkdirs(chatId, limit).filter((p) => fs.existsSync(p));
+    }
+    addCustomCommand(chatId, cwd, cmd) {
+        this.store.addCustomCommand(chatId, cwd, cmd);
+    }
+    listCustomCommands(chatId, cwd) {
+        return this.store.listCustomCommands(chatId, cwd);
+    }
+    deleteCustomCommand(chatId, cwd, name) {
+        return this.store.deleteCustomCommand(chatId, cwd, name);
+    }
+    cleanupExpired() {
+        return this.store.deleteExpired(this.config.sessionTimeoutHours);
+    }
+    resetOrphanSessions() {
+        return this.store.resetRunningToIdle();
+    }
+}
+function truncateConversationText(value, maxLength) {
+    const text = value.trim();
+    if (text.length <= maxLength)
+        return text;
+    return `${text.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+function upsertProviderUsage(usage, input) {
+    const now = new Date().toISOString();
+    const index = usage.findIndex((item) => item.provider === input.provider);
+    const current = index >= 0 ? usage[index] : null;
+    const hasCost = typeof input.costUsd === "number" && Number.isFinite(input.costUsd) && input.costUsd >= 0;
+    const next = {
+        provider: input.provider,
+        model: input.model || current?.model || "(unknown)",
+        requestCount: (current?.requestCount ?? 0) + 1,
+        costUsd: (current?.costUsd ?? 0) + (hasCost ? input.costUsd : 0),
+        unknownCostCount: (current?.unknownCostCount ?? 0) + (hasCost ? 0 : 1),
+        inputTokens: (current?.inputTokens ?? 0) + (input.usage?.inputTokens ?? 0),
+        outputTokens: (current?.outputTokens ?? 0) + (input.usage?.outputTokens ?? 0),
+        totalTokens: (current?.totalTokens ?? 0) + (input.usage?.totalTokens ?? 0),
+        cacheReadInputTokens: (current?.cacheReadInputTokens ?? 0) + (input.usage?.cacheReadInputTokens ?? 0),
+        updatedAt: now
+    };
+    if (index < 0)
+        return [...usage, next];
+    return usage.map((item, itemIndex) => itemIndex === index ? next : item);
+}

package/dist/telegram/session/store.js

@@ -0,0 +1,363 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import Database from "better-sqlite3";
+export class SessionStore {
+    dbPath;
+    db;
+    constructor(dbPath) {
+        this.dbPath = dbPath;
+        fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+        this.db = new Database(dbPath);
+        this.db.pragma("journal_mode = WAL");
+        this.migrate();
+    }
+    close() {
+        this.db.close();
+    }
+    create(input) {
+        const now = new Date().toISOString();
+        const session = {
+            id: randomUUID(),
+            chatId: input.chatId,
+            engine: input.engine,
+            engineSessionId: null,
+            botContextFingerprint: null,
+            cwd: input.cwd,
+            permissionMode: input.permissionMode,
+            approveAll: input.approveAll ?? false,
+            setupStep: input.setupStep ?? "ready",
+            status: input.status ?? "idle",
+            messageCount: 0,
+            attachments: [],
+            conversation: [],
+            pinnedTurns: [],
+            providerUsage: [],
+            createdAt: now,
+            lastActiveAt: now
+        };
+        this.db.prepare(`insert into sessions (
+        id, chat_id, engine, engine_session_id, bot_context_fingerprint, cwd, permission_mode, approve_all, setup_step,
+        status, message_count, attachments_json, conversation_json, pinned_turns_json, provider_usage_json, created_at, last_active_at
+      ) values (
+        @id, @chatId, @engine, @engineSessionId, @botContextFingerprint, @cwd, @permissionMode, @approveAll, @setupStep,
+        @status, @messageCount, @attachmentsJson, @conversationJson, @pinnedTurnsJson, @providerUsageJson, @createdAt, @lastActiveAt
+      )`).run({
+            ...session,
+            approveAll: session.approveAll ? 1 : 0,
+            setupStep: session.setupStep,
+            attachmentsJson: JSON.stringify(session.attachments),
+            conversationJson: JSON.stringify(session.conversation),
+            pinnedTurnsJson: JSON.stringify(session.pinnedTurns),
+            providerUsageJson: JSON.stringify(session.providerUsage)
+        });
+        return session;
+    }
+    getById(id) {
+        const row = this.db.prepare("select * from sessions where id = ?").get(id);
+        return row ? rowToSession(row) : null;
+    }
+    getActiveByChatId(chatId) {
+        const row = this.db.prepare("select * from sessions where chat_id = ? and status != 'closed' order by last_active_at desc limit 1").get(chatId);
+        return row ? rowToSession(row) : null;
+    }
+    listByChatId(chatId, limit = 10) {
+        const rows = this.db.prepare("select * from sessions where chat_id = ? order by last_active_at desc limit ?").all(chatId, limit);
+        return rows.map(rowToSession);
+    }
+    listActiveByChat(limit = 100) {
+        const rows = this.db.prepare("select * from sessions where status != 'closed' order by chat_id asc, last_active_at desc limit ?").all(limit * 5);
+        const seen = new Set();
+        const sessions = [];
+        for (const row of rows) {
+            if (seen.has(row.chat_id))
+                continue;
+            seen.add(row.chat_id);
+            sessions.push(rowToSession(row));
+            if (sessions.length >= limit)
+                break;
+        }
+        return sessions;
+    }
+    update(id, patch) {
+        const current = this.getById(id);
+        if (!current) {
+            throw new Error(`Telegram session not found: ${id}`);
+        }
+        const next = {
+            ...current,
+            ...patch,
+            attachments: patch.attachments ?? current.attachments,
+            conversation: patch.conversation ?? current.conversation,
+            pinnedTurns: patch.pinnedTurns ?? current.pinnedTurns,
+            providerUsage: patch.providerUsage ?? current.providerUsage,
+            lastActiveAt: patch.lastActiveAt ?? new Date().toISOString()
+        };
+        this.db.prepare(`update sessions set
+        engine = @engine,
+        engine_session_id = @engineSessionId,
+        bot_context_fingerprint = @botContextFingerprint,
+        cwd = @cwd,
+        permission_mode = @permissionMode,
+        approve_all = @approveAll,
+        setup_step = @setupStep,
+        status = @status,
+        message_count = @messageCount,
+        attachments_json = @attachmentsJson,
+        conversation_json = @conversationJson,
+        pinned_turns_json = @pinnedTurnsJson,
+        provider_usage_json = @providerUsageJson,
+        last_active_at = @lastActiveAt
+       where id = @id`).run({
+            id,
+            engine: next.engine,
+            engineSessionId: next.engineSessionId,
+            botContextFingerprint: next.botContextFingerprint,
+            cwd: next.cwd,
+            permissionMode: next.permissionMode,
+            approveAll: next.approveAll ? 1 : 0,
+            setupStep: next.setupStep,
+            status: next.status,
+            messageCount: next.messageCount,
+            attachmentsJson: JSON.stringify(next.attachments),
+            conversationJson: JSON.stringify(next.conversation),
+            pinnedTurnsJson: JSON.stringify(next.pinnedTurns),
+            providerUsageJson: JSON.stringify(next.providerUsage),
+            lastActiveAt: next.lastActiveAt
+        });
+        return next;
+    }
+    closeByChatId(chatId) {
+        this.db.prepare("update sessions set status = 'closed', last_active_at = ? where chat_id = ? and status != 'closed'")
+            .run(new Date().toISOString(), chatId);
+    }
+    rememberWorkdir(chatId, cwd) {
+        const now = new Date().toISOString();
+        this.db.prepare(`insert into workdirs (chat_id, cwd, last_used_at)
+       values (?, ?, ?)
+       on conflict(chat_id, cwd) do update set last_used_at = excluded.last_used_at`).run(chatId, cwd, now);
+    }
+    listWorkdirs(chatId, limit = 8) {
+        const rows = this.db.prepare("select cwd from workdirs where chat_id = ? order by last_used_at desc limit ?").all(chatId, limit);
+        return rows.map((row) => row.cwd);
+    }
+    touch(id) {
+        this.db.prepare("update sessions set last_active_at = ? where id = ?").run(new Date().toISOString(), id);
+    }
+    deleteExpired(timeoutHours) {
+        const cutoff = new Date(Date.now() - timeoutHours * 60 * 60 * 1000).toISOString();
+        const result = this.db.prepare("delete from sessions where last_active_at < ?").run(cutoff);
+        return result.changes;
+    }
+    resetRunningToIdle() {
+        const result = this.db.prepare("update sessions set status = 'idle' where status in ('running', 'waiting_approval')").run();
+        return result.changes;
+    }
+    addAttachment(sessionId, attachment) {
+        const session = this.getById(sessionId);
+        if (!session) {
+            throw new Error(`Telegram session not found: ${sessionId}`);
+        }
+        return this.update(sessionId, {
+            attachments: [...session.attachments, attachment].slice(-5)
+        });
+    }
+    clearAttachments(sessionId) {
+        return this.update(sessionId, { attachments: [] });
+    }
+    migrate() {
+        this.db.exec(`
+      create table if not exists sessions (
+        id text primary key,
+        chat_id integer not null,
+        engine text not null,
+        engine_session_id text,
+        bot_context_fingerprint text,
+        cwd text not null,
+        permission_mode text not null,
+        approve_all integer not null default 0,
+        setup_step text not null default 'ready',
+        status text not null,
+        message_count integer not null default 0,
+        attachments_json text not null default '[]',
+        conversation_json text not null default '[]',
+        provider_usage_json text not null default '[]',
+        created_at text not null,
+        last_active_at text not null
+      );
+      create index if not exists idx_sessions_chat_active on sessions(chat_id, status, last_active_at);
+      create table if not exists workdirs (
+        chat_id integer not null,
+        cwd text not null,
+        last_used_at text not null,
+        primary key (chat_id, cwd)
+      );
+      create index if not exists idx_workdirs_chat_last_used on workdirs(chat_id, last_used_at);
+    `);
+        this.ensureColumn("sessions", "setup_step", "setup_step text not null default 'ready'");
+        this.ensureColumn("sessions", "provider_usage_json", "provider_usage_json text not null default '[]'");
+        this.ensureColumn("sessions", "bot_context_fingerprint", "bot_context_fingerprint text");
+        this.ensureColumn("sessions", "conversation_json", "conversation_json text not null default '[]'");
+        this.ensureColumn("sessions", "pinned_turns_json", "pinned_turns_json text not null default '[]'");
+        this.db.exec(`
+      create table if not exists custom_commands (
+        chat_id integer not null,
+        cwd text not null,
+        name text not null,
+        params_json text not null default '[]',
+        template text not null,
+        description text not null,
+        created_at text not null,
+        primary key (chat_id, cwd, name)
+      );
+    `);
+    }
+    addCustomCommand(chatId, cwd, cmd) {
+        this.db.prepare(`insert or replace into custom_commands (chat_id, cwd, name, params_json, template, description, created_at)
+       values (?, ?, ?, ?, ?, ?, ?)`).run(chatId, cwd, cmd.name, JSON.stringify(cmd.params), cmd.template, cmd.description, new Date().toISOString());
+    }
+    listCustomCommands(chatId, cwd) {
+        const rows = this.db.prepare("select name, params_json, template, description from custom_commands where chat_id = ? and cwd = ? order by created_at").all(chatId, cwd);
+        return rows.map((r) => ({
+            name: r.name,
+            params: JSON.parse(r.params_json),
+            template: r.template,
+            description: r.description
+        }));
+    }
+    deleteCustomCommand(chatId, cwd, name) {
+        const result = this.db.prepare("delete from custom_commands where chat_id = ? and cwd = ? and name = ?").run(chatId, cwd, name);
+        return result.changes > 0;
+    }
+    ensureColumn(table, column, definition) {
+        const rows = this.db.prepare(`pragma table_info(${table})`).all();
+        if (!rows.some((row) => row.name === column)) {
+            this.db.exec(`alter table ${table} add column ${definition}`);
+        }
+    }
+}
+function rowToSession(row) {
+    return {
+        id: row.id,
+        chatId: row.chat_id,
+        engine: row.engine === "codex" ? "codex" : "claude",
+        engineSessionId: row.engine_session_id,
+        botContextFingerprint: row.bot_context_fingerprint ?? null,
+        cwd: row.cwd,
+        permissionMode: row.permission_mode === "readOnly" || row.permission_mode === "acceptEdits" || row.permission_mode === "bypassPermissions" ? row.permission_mode : "default",
+        approveAll: row.approve_all === 1,
+        setupStep: normalizeSetupStep(row.setup_step),
+        status: row.status === "running" || row.status === "waiting_approval" || row.status === "closed" ? row.status : "idle",
+        messageCount: row.message_count,
+        attachments: parseAttachments(row.attachments_json),
+        conversation: parseConversation(row.conversation_json),
+        pinnedTurns: parsePinnedTurns(row.pinned_turns_json),
+        providerUsage: parseProviderUsage(row.provider_usage_json),
+        createdAt: row.created_at,
+        lastActiveAt: row.last_active_at
+    };
+}
+function normalizeSetupStep(value) {
+    if (value === "model"
+        || value === "workdir"
+        || value === "custom_workdir"
+        || value === "edit_custom_workdir"
+        || value === "usage_price_input"
+        || value === "remember_global"
+        || value === "remember_bot"
+        || value === "remember_auto"
+        || value === "memory_promote"
+        || value === "cli"
+        || value === "agent_profile"
+        || value === "command_name"
+        || value === "command_template"
+        || value === "ready")
+        return value;
+    return "ready";
+}
+function parseAttachments(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed.filter(isAttachment) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function parseConversation(value) {
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.flatMap((item) => isConversationTurn(item) ? [item] : []);
+    }
+    catch {
+        return [];
+    }
+}
+function parsePinnedTurns(value) {
+    if (!value)
+        return [];
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((item) => {
+            const t = item;
+            return Boolean(t && typeof t.messageId === "number" && typeof t.user === "string" && typeof t.assistant === "string");
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function parseProviderUsage(value) {
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.flatMap((item) => {
+            if (!isProviderUsage(item))
+                return [];
+            return [{
+                    provider: item.provider,
+                    model: item.model,
+                    requestCount: item.requestCount,
+                    costUsd: item.costUsd,
+                    unknownCostCount: item.unknownCostCount,
+                    inputTokens: readNonNegativeNumber(item.inputTokens),
+                    outputTokens: readNonNegativeNumber(item.outputTokens),
+                    totalTokens: readNonNegativeNumber(item.totalTokens),
+                    cacheReadInputTokens: readNonNegativeNumber(item.cacheReadInputTokens),
+                    updatedAt: item.updatedAt
+                }];
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function isAttachment(value) {
+    const item = value;
+    return Boolean(item && typeof item.name === "string" && typeof item.path === "string" && typeof item.text === "string");
+}
+function isConversationTurn(value) {
+    const item = value;
+    return Boolean(item
+        && typeof item.user === "string"
+        && typeof item.assistant === "string"
+        && typeof item.createdAt === "string");
+}
+function isProviderUsage(value) {
+    const item = value;
+    return Boolean(item
+        && typeof item.provider === "string"
+        && typeof item.model === "string"
+        && Number.isFinite(item.requestCount)
+        && Number.isFinite(item.costUsd)
+        && Number.isFinite(item.unknownCostCount)
+        && typeof item.updatedAt === "string");
+}
+function readNonNegativeNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}

package/dist/telegram/session/types.js

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