responses-proxy 0.1.0

package/dist/telegram-bot/commands/start.js

@@ -0,0 +1,212 @@
+import { ADMIN_CALLBACK_PATTERN, buildAdminStartKeyboard, buildApplyClientKeyboard, renderAdminScreen, } from "../admin-actions.js";
+import { loadClientsText, loadModelsText, loadOauthStatusText, loadProvidersText, loadStatusText, replyWithProxyError, } from "../actions.js";
+import { isAdmin } from "../auth.js";
+import { answerCallbackQuerySafely } from "../callbacks.js";
+import { renderCustomerActionText } from "../customer-actions.js";
+import { buildAdminKeyListKeyboard } from "./apikey.js";
+import { formatDateTime, formatField, formatSection } from "../message-format.js";
+export function registerStartCommand(bot, deps, identities, workspaces, customerKeys, billing) {
+    bot.command("start", async (ctx) => {
+        if (isAdmin(ctx, deps.config)) {
+            await ctx.reply(formatAdminStartPanel(), {
+                reply_markup: buildAdminStartKeyboard(),
+            });
+            return;
+        }
+        const userId = ctx.from?.id?.toString();
+        const chatId = ctx.chat?.id?.toString();
+        const user = userId ? identities.getUser(userId) : undefined;
+        const activeKey = userId ? customerKeys.getActiveKeyForUser(userId) : undefined;
+        const workspace = userId && deps.config.publicSignupEnabled
+            ? workspaces.ensureDefaultWorkspace({
+                ownerTelegramUserId: userId,
+                telegramChatId: chatId,
+                defaultClientRoute: deps.config.defaultCustomerRoute,
+                status: deps.config.requireAdminApproval ? "pending_approval" : "active",
+            })
+            : undefined;
+        await renderCustomerActionText(ctx, [
+            "Responses Proxy bot is ready",
+            formatSection("Account", [
+                user ? formatField("Status", formatStatus(user.status)) : formatField("Status", "not registered"),
+                workspace ? formatField("Workspace", formatStatus(workspace.status)) : undefined,
+                workspace ? formatField("Client route", workspace.defaultClientRoute) : undefined,
+            ]),
+            "Use /help to see available commands.",
+        ]
+            .filter(Boolean)
+            .join("\n\n"), !!activeKey);
+    });
+    const adminActions = {
+        status: {
+            loop: "proxy",
+            run: async (ctx) => {
+                await renderAdminScreen(ctx, {
+                    text: await loadStatusText(deps),
+                    loop: "proxy",
+                });
+            },
+        },
+        clients: {
+            loop: "config",
+            run: async (ctx) => {
+                await renderAdminScreen(ctx, {
+                    text: await loadClientsText(deps),
+                    loop: "config",
+                });
+            },
+        },
+        providers: {
+            loop: "proxy",
+            run: async (ctx) => {
+                await renderAdminScreen(ctx, {
+                    text: await loadProvidersText(deps),
+                    loop: "proxy",
+                });
+            },
+        },
+        models: {
+            loop: "proxy",
+            run: async (ctx) => {
+                await renderAdminScreen(ctx, {
+                    text: await loadModelsText(deps),
+                    loop: "proxy",
+                });
+            },
+        },
+        oauth: {
+            loop: "proxy",
+            run: async (ctx) => {
+                await renderAdminScreen(ctx, {
+                    text: await loadOauthStatusText(deps),
+                    loop: "proxy",
+                });
+            },
+        },
+        plans: {
+            loop: "billing",
+            run: async (ctx) => {
+                await renderAdminScreen(ctx, {
+                    text: formatBillingPlans(billing),
+                    loop: "billing",
+                });
+            },
+        },
+        renewals: {
+            loop: "billing",
+            run: async (ctx) => {
+                await renderAdminScreen(ctx, {
+                    text: formatOpenRenewalRequests(billing),
+                    loop: "billing",
+                });
+            },
+        },
+        apikeys: {
+            loop: "keys",
+            run: async (ctx) => {
+                const keys = customerKeys.listRecentKeys(10);
+                await renderAdminScreen(ctx, {
+                    text: formatRecentCustomerKeys(keys),
+                    loop: "keys",
+                    primaryKeyboard: keys.length > 0 ? buildAdminKeyListKeyboard(keys) : undefined,
+                });
+            },
+        },
+        apply: {
+            loop: "apply",
+            run: async (ctx) => {
+                await renderAdminScreen(ctx, {
+                    text: "Choose a client to configure.",
+                    loop: "apply",
+                    primaryKeyboard: buildApplyClientKeyboard(false),
+                });
+            },
+        },
+        menu: {
+            run: async (ctx) => {
+                await renderAdminScreen(ctx, {
+                    text: formatAdminStartPanel(),
+                    loop: "main",
+                });
+            },
+        },
+    };
+    bot.callbackQuery(ADMIN_CALLBACK_PATTERN, async (ctx) => {
+        if (!isAdmin(ctx, deps.config)) {
+            await answerCallbackQuerySafely(ctx, { text: "Admin only.", show_alert: true });
+            return;
+        }
+        const action = ctx.match[1];
+        const definition = adminActions[action];
+        await answerCallbackQuerySafely(ctx, { text: "Loaded" });
+        try {
+            await definition.run(ctx);
+        }
+        catch (error) {
+            await replyWithProxyError(ctx, error);
+        }
+    });
+}
+function formatStatus(value) {
+    return value.replace(/_/g, " ");
+}
+function formatAdminStartPanel() {
+    return [
+        "🛠 Admin panel",
+        "role: admin",
+        "Choose an action below to manage proxy, billing, and customer access.",
+    ].join("\n");
+}
+function formatBillingPlans(billing) {
+    const plans = billing.listPlans();
+    if (plans.length === 0) {
+        return "💳 Billing plans:\nNo billing plans are configured yet.";
+    }
+    return [
+        "💳 Billing plans:",
+        ...plans.map((plan) => `• ${plan.id}: ${plan.name} | status=${plan.status} | price_cents=${plan.priceCents} | currency=${plan.currency} | billing_interval=${plan.billingInterval} | monthly_token_limit=${plan.monthlyTokenLimit} | max_api_keys=${plan.maxApiKeys}`),
+    ].join("\n");
+}
+function formatOpenRenewalRequests(billing) {
+    const openRequests = billing.listRenewalRequests("open");
+    if (openRequests.length === 0) {
+        return "🧾 Open renewal requests:\nNo open renewal requests right now.";
+    }
+    return [
+        "🧾 Open renewal requests:",
+        ...openRequests.slice(0, 10).map(formatRenewalRequestLine),
+    ].join("\n");
+}
+function formatRecentCustomerKeys(keys) {
+    if (keys.length === 0) {
+        return [
+            "🔑 Customer API keys",
+            "No customer API keys found.",
+            "Use /grant or /apikey issue to create one.",
+        ].join("\n");
+    }
+    return [
+        "🔑 Customer API keys",
+        "Recent keys. Tap a key button to copy its id, paste it back into this chat, then send to manage.",
+        ...keys.map((key) => [
+            `- ${key.id}`,
+            key.telegramUserId ? `user=${key.telegramUserId}` : undefined,
+            `status=${key.status}`,
+            `route=${key.clientRoute}`,
+            `preview=${key.apiKeyPreview}`,
+        ]
+            .filter(Boolean)
+            .join(" | ")),
+    ].join("\n");
+}
+function formatRenewalRequestLine(request) {
+    return [
+        `• ${request.id}`,
+        `telegram_user_id=${request.telegramUserId}`,
+        request.requestedPlanId ? `plan_id=${request.requestedPlanId}` : undefined,
+        request.requestedDays ? `days=${request.requestedDays}` : undefined,
+        `requested_at=${formatDateTime(request.requestedAt)}`,
+    ]
+        .filter(Boolean)
+        .join(" ");
+}

package/dist/telegram-bot/commands/start.test.js

@@ -0,0 +1,280 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { BillingRepository } from "../../billing.js";
+import { CustomerKeyRepository } from "../../customer-keys.js";
+import { BotIdentityRepository } from "../bot-identity-repository.js";
+import { CustomerWorkspaceRepository } from "../customer-workspace-repository.js";
+import { registerStartCommand } from "./start.js";
+function createConfig(overrides = {}) {
+    return {
+        telegramBotToken: "token",
+        allowedUserIds: new Set(),
+        allowedChatIds: new Set(),
+        ownerUserIds: new Set(["1"]),
+        adminUserIds: new Set(),
+        botMode: "polling",
+        proxyAdminBaseUrl: "http://127.0.0.1:8318",
+        defaultModel: "gpt-5.5",
+        publicSignupEnabled: true,
+        requireAdminApproval: false,
+        defaultCustomerRoute: "customers",
+        publicResponsesBaseUrl: "http://127.0.0.1:8318/v1",
+        proxyRequestTimeoutMs: 30_000,
+        sessionDbPath: ":memory:",
+        sessionTtlMs: 900_000,
+        rateLimitWindowMs: 60_000,
+        rateLimitMaxRequests: 12,
+        logLevel: "info",
+        ...overrides,
+    };
+}
+function createBotHarness() {
+    const commandHandlers = new Map();
+    const callbackHandlers = [];
+    return {
+        bot: {
+            command(name, handler) {
+                commandHandlers.set(name, handler);
+            },
+            callbackQuery(pattern, handler) {
+                callbackHandlers.push({ pattern, handler });
+            },
+        },
+        handler(name) {
+            const handler = commandHandlers.get(name);
+            assert.ok(handler);
+            return handler;
+        },
+        callbackHandler(data) {
+            for (const entry of callbackHandlers) {
+                if (typeof entry.pattern === "string") {
+                    if (entry.pattern === data) {
+                        return { handler: entry.handler, match: [data] };
+                    }
+                    continue;
+                }
+                const match = data.match(entry.pattern);
+                if (match) {
+                    return { handler: entry.handler, match };
+                }
+            }
+            assert.fail(`No callback handler for ${data}`);
+        },
+    };
+}
+function createContext(input) {
+    const replies = [];
+    const editedReplies = [];
+    const answeredCallbacks = [];
+    return {
+        from: { id: input.fromId, is_bot: false, first_name: "User" },
+        chat: { id: input.chatId, type: "private", first_name: "User" },
+        callbackQuery: {
+            id: "callback-1",
+            from: { id: input.fromId, is_bot: false, first_name: "User" },
+            data: "callback",
+            chat_instance: "chat",
+            message: {
+                message_id: 99,
+                date: 0,
+                chat: { id: input.chatId, type: "private", first_name: "User" },
+                text: "Admin panel",
+            },
+        },
+        match: "",
+        replies,
+        editedReplies,
+        answeredCallbacks,
+        reply(text, options) {
+            replies.push({ text, options });
+            return Promise.resolve({});
+        },
+        editMessageText(text, options) {
+            editedReplies.push({ text, options });
+            return Promise.resolve({});
+        },
+        answerCallbackQuery(payload) {
+            answeredCallbacks.push(payload ?? {});
+            return Promise.resolve(true);
+        },
+    };
+}
+async function withRepos(fn) {
+    const dir = mkdtempSync(path.join(os.tmpdir(), "responses-proxy-start-test-"));
+    const dbFile = path.join(dir, "bot.sqlite");
+    try {
+        const identities = BotIdentityRepository.create(dbFile);
+        const workspaces = CustomerWorkspaceRepository.create(dbFile);
+        const customerKeys = CustomerKeyRepository.create(dbFile);
+        const billing = BillingRepository.create(dbFile);
+        const deps = {
+            config: createConfig({ sessionDbPath: dbFile }),
+            proxyClient: createMockProxyClient(),
+        };
+        await fn({ identities, workspaces, customerKeys, billing, deps });
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+function createMockProxyClient() {
+    return {
+        async getHealth() {
+            return { ok: true };
+        },
+        async getProviders() {
+            return { activeProviderId: "p1", providers: [{ id: "p1", name: "Provider 1" }], clientRoutes: [] };
+        },
+        async getLatestPromptCache() {
+            return { latest: null };
+        },
+        async getUsageStats() {
+            return { stats: { totalRequests: 1 } };
+        },
+        async getClientConfigs() {
+            return { clients: {}, clientRoutes: [] };
+        },
+        async getModels() {
+            return { models: ["gpt-test"] };
+        },
+        async getOauthStatus() {
+            return { enabled: true, accounts: [] };
+        },
+    };
+}
+test("/start shows Buy button when the user has no active token", async () => {
+    await withRepos(async ({ identities, workspaces, customerKeys, billing, deps }) => {
+        const harness = createBotHarness();
+        registerStartCommand(harness.bot, deps, identities, workspaces, customerKeys, billing);
+        const ctx = createContext({ fromId: 42, chatId: 42 });
+        await harness.handler("start")(ctx);
+        const firstResponse = ctx.editedReplies[0] ?? ctx.replies[0];
+        const keyboard = JSON.parse(JSON.stringify(firstResponse?.options?.reply_markup));
+        assert.equal(keyboard.inline_keyboard?.[0]?.[0]?.text, "🔐 View key");
+        assert.equal(keyboard.inline_keyboard?.[0]?.[0]?.callback_data, "v1:customer:key");
+        assert.equal(keyboard.inline_keyboard?.[1]?.[1]?.text, "💳 Buy API key");
+        assert.equal(keyboard.inline_keyboard?.[1]?.[1]?.callback_data, "v1:renew:open");
+    });
+});
+test("/start shows Renew button when the user already has an active token", async () => {
+    await withRepos(async ({ identities, workspaces, customerKeys, billing, deps }) => {
+        const workspace = workspaces.ensureDefaultWorkspace({
+            ownerTelegramUserId: "42",
+            defaultClientRoute: "customers",
+            status: "active",
+        });
+        customerKeys.createKey({
+            workspaceId: workspace.id,
+            telegramUserId: "42",
+            clientRoute: "customers",
+        });
+        const harness = createBotHarness();
+        registerStartCommand(harness.bot, deps, identities, workspaces, customerKeys, billing);
+        const ctx = createContext({ fromId: 42, chatId: 42 });
+        await harness.handler("start")(ctx);
+        const firstResponse = ctx.editedReplies[0] ?? ctx.replies[0];
+        const keyboard = JSON.parse(JSON.stringify(firstResponse?.options?.reply_markup));
+        assert.equal(keyboard.inline_keyboard?.[0]?.[0]?.text, "🔐 View key");
+        assert.equal(keyboard.inline_keyboard?.[0]?.[0]?.callback_data, "v1:customer:key");
+        assert.equal(keyboard.inline_keyboard?.[1]?.[1]?.text, "⏱ Renew 24h");
+        assert.equal(keyboard.inline_keyboard?.[1]?.[1]?.callback_data, "v1:renew:open");
+    });
+});
+test("/start shows admin panel for admins without creating a customer workspace", async () => {
+    await withRepos(async ({ identities, workspaces, customerKeys, billing, deps }) => {
+        const harness = createBotHarness();
+        registerStartCommand(harness.bot, deps, identities, workspaces, customerKeys, billing);
+        const ctx = createContext({ fromId: 1, chatId: 1 });
+        await harness.handler("start")(ctx);
+        assert.equal(ctx.replies[0]?.text.includes("Admin panel"), true);
+        assert.equal(workspaces.getDefaultWorkspace("1"), undefined);
+        const keyboard = JSON.parse(JSON.stringify(ctx.replies[0]?.options?.reply_markup));
+        assert.equal(keyboard.inline_keyboard?.[0]?.[0]?.text, "📈 Status");
+        assert.equal(keyboard.inline_keyboard?.[0]?.[0]?.callback_data, "v1:admin:status");
+        assert.equal(keyboard.inline_keyboard?.[2]?.[1]?.text, "🧾 Renewals");
+        assert.equal(keyboard.inline_keyboard?.[2]?.[1]?.callback_data, "v1:admin:renewals");
+    });
+});
+test("admin start panel buttons run real actions", async () => {
+    await withRepos(async ({ identities, workspaces, customerKeys, billing, deps }) => {
+        const harness = createBotHarness();
+        registerStartCommand(harness.bot, deps, identities, workspaces, customerKeys, billing);
+        const found = harness.callbackHandler("v1:admin:status");
+        const ctx = createContext({ fromId: 1, chatId: 1 });
+        ctx.match = found.match;
+        await found.handler(ctx);
+        assert.equal(ctx.answeredCallbacks[0]?.text, "Loaded");
+        assert.equal(ctx.editedReplies[0]?.text.includes("Proxy status"), true);
+        const loopKeyboard = JSON.parse(JSON.stringify(ctx.editedReplies[0]?.options?.reply_markup));
+        assert.equal(loopKeyboard.inline_keyboard?.[0]?.[0]?.callback_data, "v1:admin:status");
+        assert.equal(loopKeyboard.inline_keyboard?.[0]?.[1]?.callback_data, "v1:admin:providers");
+        assert.equal(loopKeyboard.inline_keyboard?.[2]?.[1]?.callback_data, "v1:admin:menu");
+    });
+});
+test("admin start panel can show billing plans and renewal requests", async () => {
+    await withRepos(async ({ identities, workspaces, customerKeys, billing, deps }) => {
+        const workspace = workspaces.ensureDefaultWorkspace({
+            ownerTelegramUserId: "42",
+            defaultClientRoute: "customers",
+            status: "active",
+        });
+        billing.createRenewalRequest({
+            workspaceId: workspace.id,
+            telegramUserId: "42",
+            requestedPlanId: "basic",
+            requestedDays: 30,
+        });
+        const harness = createBotHarness();
+        registerStartCommand(harness.bot, deps, identities, workspaces, customerKeys, billing);
+        const plans = harness.callbackHandler("v1:admin:plans");
+        const plansCtx = createContext({ fromId: 1, chatId: 1 });
+        plansCtx.match = plans.match;
+        await plans.handler(plansCtx);
+        assert.equal(plansCtx.editedReplies[0]?.text.includes("Billing plans:"), true);
+        assert.equal(plansCtx.editedReplies[0]?.text.includes("price_cents=5000"), true);
+        assert.equal(plansCtx.editedReplies[0]?.text.includes("currency=VND"), true);
+        const plansKeyboard = JSON.parse(JSON.stringify(plansCtx.editedReplies[0]?.options?.reply_markup));
+        assert.equal(plansKeyboard.inline_keyboard?.[0]?.[0]?.callback_data, "v1:admin:plans");
+        assert.equal(plansKeyboard.inline_keyboard?.[0]?.[1]?.callback_data, "v1:admin:renewals");
+        const renewals = harness.callbackHandler("v1:admin:renewals");
+        const renewalsCtx = createContext({ fromId: 1, chatId: 1 });
+        renewalsCtx.match = renewals.match;
+        await renewals.handler(renewalsCtx);
+        assert.equal(renewalsCtx.editedReplies[0]?.text.includes("Open renewal requests:"), true);
+        assert.equal(renewalsCtx.editedReplies[0]?.text.includes("telegram_user_id=42"), true);
+    });
+});
+test("admin start panel shows recent API keys with manage buttons", async () => {
+    await withRepos(async ({ identities, workspaces, customerKeys, billing, deps }) => {
+        const workspace = workspaces.ensureDefaultWorkspace({
+            ownerTelegramUserId: "42",
+            defaultClientRoute: "customers",
+            status: "active",
+        });
+        const created = customerKeys.createKey({
+            workspaceId: workspace.id,
+            telegramUserId: "42",
+            clientRoute: "customers",
+        });
+        const harness = createBotHarness();
+        registerStartCommand(harness.bot, deps, identities, workspaces, customerKeys, billing);
+        const found = harness.callbackHandler("v1:admin:apikeys");
+        const ctx = createContext({ fromId: 1, chatId: 1 });
+        ctx.match = found.match;
+        await found.handler(ctx);
+        assert.equal(ctx.editedReplies[0]?.text.includes("Customer API keys"), true);
+        assert.equal(ctx.editedReplies[0]?.text.includes(`user=42`), true);
+        assert.equal(ctx.editedReplies[0]?.text.includes(created.record.apiKeyPreview), true);
+        const keyKeyboard = JSON.parse(JSON.stringify(ctx.editedReplies[0]?.options?.reply_markup));
+        assert.equal(keyKeyboard.inline_keyboard?.[0]?.[0]?.copy_text?.text, created.record.id);
+        const callbackButtons = keyKeyboard.inline_keyboard
+            ?.flatMap((row) => row)
+            .filter((button) => typeof button?.callback_data === "string")
+            .map((button) => button.callback_data);
+        assert.equal(callbackButtons.includes("v1:admin:apikeys"), true);
+        assert.equal(callbackButtons.includes("v1:admin:plans"), true);
+    });
+});

package/dist/telegram-bot/commands/status.js

@@ -0,0 +1,6 @@
+import { sendStatus } from "../actions.js";
+export function registerStatusCommand(bot, deps) {
+    bot.command("status", async (ctx) => {
+        await sendStatus(ctx, deps);
+    });
+}

package/dist/telegram-bot/commands/tailscale.js

@@ -0,0 +1,15 @@
+export function registerTailscaleCommand(bot, deps) {
+    bot.command("tailscale", async (ctx) => {
+        const lines = [
+            "Join Tailscale",
+            "1. Install Tailscale on your device:",
+            "https://tailscale.com/download",
+            "2. Sign in to Tailscale on your device.",
+            "3. Inbox admin in Telegram to get a fresh invite link for the private network.",
+            "4. Open that invite link, join the tailnet, then connect Tailscale.",
+            `5. Use this Responses base URL after you are connected:\n${deps.config.publicResponsesBaseUrl}`,
+            "6. Run /apikey in this chat to check your key status.",
+        ];
+        await ctx.reply(lines.join("\n"));
+    });
+}

package/dist/telegram-bot/commands/tailscale.test.js

@@ -0,0 +1,76 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { registerTailscaleCommand } from "./tailscale.js";
+function createConfig(overrides = {}) {
+    return {
+        telegramBotToken: "token",
+        allowedUserIds: new Set(),
+        allowedChatIds: new Set(),
+        ownerUserIds: new Set(["1"]),
+        adminUserIds: new Set(),
+        botMode: "polling",
+        webhookUrl: undefined,
+        webhookSecret: undefined,
+        proxyAdminBaseUrl: "http://127.0.0.1:8318",
+        proxyClientApiKey: undefined,
+        defaultModel: "gpt-5.5",
+        publicSignupEnabled: true,
+        requireAdminApproval: false,
+        defaultCustomerRoute: "customers",
+        publicResponsesBaseUrl: "https://example.tailnet.ts.net/v1",
+        proxyRequestTimeoutMs: 30_000,
+        sessionDbPath: ":memory:",
+        sessionTtlMs: 900_000,
+        rateLimitWindowMs: 60_000,
+        rateLimitMaxRequests: 12,
+        logLevel: "info",
+        ...overrides,
+    };
+}
+function createBotHarness() {
+    const handlers = new Map();
+    return {
+        bot: {
+            command(name, handler) {
+                handlers.set(name, handler);
+            },
+        },
+        handler(name) {
+            const handler = handlers.get(name);
+            assert.ok(handler);
+            return handler;
+        },
+    };
+}
+function createContext() {
+    const replies = [];
+    return {
+        from: { id: 42, is_bot: false, first_name: "User" },
+        chat: { id: 42, type: "private", first_name: "User" },
+        message: {
+            message_id: 1,
+            date: 0,
+            chat: { id: 42, type: "private", first_name: "User" },
+            text: "/tailscale",
+        },
+        replies,
+        reply(text) {
+            replies.push(text);
+            return Promise.resolve({});
+        },
+    };
+}
+test("tailscale command tells customer to ask admin for a fresh invite link", async () => {
+    const deps = {
+        config: createConfig(),
+        proxyClient: {},
+    };
+    const harness = createBotHarness();
+    registerTailscaleCommand(harness.bot, deps);
+    const ctx = createContext();
+    await harness.handler("tailscale")(ctx);
+    assert.equal(ctx.replies.length, 1);
+    assert.equal(ctx.replies[0].includes("Inbox admin in Telegram to get a fresh invite link"), true);
+    assert.equal(ctx.replies[0].includes("https://example.tailnet.ts.net/v1"), true);
+    assert.equal(ctx.replies[0].includes("https://login.tailscale.com/"), false);
+});

package/dist/telegram-bot/commands/test.js

@@ -0,0 +1,51 @@
+import { sendTestResult } from "../actions.js";
+import { buildTelegramSessionScope } from "../sessions.js";
+export function registerTestCommand(bot, deps, sessions) {
+    bot.command("test", async (ctx) => {
+        const args = ctx.match?.toString().trim() || "";
+        if (args) {
+            const parsed = parseTestArgs(args);
+            await sendTestResult(ctx, deps, parsed);
+            return;
+        }
+        const chatId = ctx.chat?.id?.toString();
+        const userId = ctx.from?.id?.toString();
+        if (chatId && userId) {
+            sessions.set(buildTelegramSessionScope(chatId, userId), { kind: "awaiting_test_prompt" });
+        }
+        await ctx.reply("Send the test prompt text you want to run through /v1/responses.");
+    });
+    bot.on("message:text", async (ctx, next) => {
+        const chatId = ctx.chat?.id?.toString();
+        const userId = ctx.from?.id?.toString();
+        if (!chatId || !userId) {
+            await next();
+            return;
+        }
+        const scope = buildTelegramSessionScope(chatId, userId);
+        const session = sessions.get(scope);
+        if (session?.kind !== "awaiting_test_prompt") {
+            await next();
+            return;
+        }
+        if (ctx.message.text.startsWith("/")) {
+            await next();
+            return;
+        }
+        sessions.clear(scope);
+        await sendTestResult(ctx, deps, {
+            prompt: ctx.message.text.trim(),
+            model: session.model,
+        });
+    });
+}
+export function parseTestArgs(args) {
+    const match = args.match(/^--provider-id\s+(\S+)\s+([\s\S]+)$/);
+    if (!match) {
+        return { prompt: args };
+    }
+    return {
+        providerId: match[1],
+        prompt: match[2].trim(),
+    };
+}

package/dist/telegram-bot/commands/test.test.js

@@ -0,0 +1,14 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { parseTestArgs } from "./test.js";
+test("parseTestArgs returns raw prompt when no provider flag is present", () => {
+    assert.deepEqual(parseTestArgs("Say hello"), {
+        prompt: "Say hello",
+    });
+});
+test("parseTestArgs extracts provider id and prompt", () => {
+    assert.deepEqual(parseTestArgs("--provider-id account-openai-codex Say hello"), {
+        providerId: "account-openai-codex",
+        prompt: "Say hello",
+    });
+});

package/dist/telegram-bot/commands/usage.js

@@ -0,0 +1,10 @@
+import { replyWithCustomerView } from "../customer-actions.js";
+export function registerUsageCommand(bot, workspaces, customerKeys, billing) {
+    bot.command("usage", async (ctx) => {
+        if (ctx.chat?.type !== "private") {
+            await ctx.reply("For safety, open a private chat with this bot and run /usage there.");
+            return;
+        }
+        await replyWithCustomerView(ctx, "usage", workspaces, customerKeys, billing);
+    });
+}