@agi-cli/server 0.1.145 → 0.1.147

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/server",
-	"version": "0.1.145",
+	"version": "0.1.147",
 	"description": "HTTP API server for AGI CLI",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -29,8 +29,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@agi-cli/sdk": "0.1.145",
-		"@agi-cli/database": "0.1.145",
+		"@agi-cli/sdk": "0.1.147",
+		"@agi-cli/database": "0.1.147",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.1.8"

package/src/events/types.ts

@@ -5,6 +5,10 @@ export type AGIEventType =
 	| 'setu.payment.signing'
 	| 'setu.payment.complete'
 	| 'setu.payment.error'
+	| 'setu.topup.required'
+	| 'setu.topup.method_selected'
+	| 'setu.topup.cancelled'
+	| 'setu.fiat.checkout_created'
 	| 'session.created'
 	| 'session.updated'
 	| 'message.created'

package/src/routes/sessions.ts

@@ -696,4 +696,108 @@ export function registerSessionsRoutes(app: Hono) {
 			newMessages: newMessages.length,
 		});
 	});
+
+	// Retry a failed assistant message
+	app.post('/v1/sessions/:sessionId/messages/:messageId/retry', async (c) => {
+		try {
+			const sessionId = c.req.param('sessionId');
+			const messageId = c.req.param('messageId');
+			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
+			const db = await getDb(cfg.projectRoot);
+
+			// Get the assistant message
+			const [assistantMsg] = await db
+				.select()
+				.from(messages)
+				.where(
+					and(
+						eq(messages.id, messageId),
+						eq(messages.sessionId, sessionId),
+						eq(messages.role, 'assistant'),
+					),
+				)
+				.limit(1);
+
+			if (!assistantMsg) {
+				return c.json({ error: 'Message not found' }, 404);
+			}
+
+			// Only allow retry on error or complete messages
+			if (
+				assistantMsg.status !== 'error' &&
+				assistantMsg.status !== 'complete'
+			) {
+				return c.json(
+					{ error: 'Can only retry error or complete messages' },
+					400,
+				);
+			}
+
+			// Get session for context
+			const [session] = await db
+				.select()
+				.from(sessions)
+				.where(eq(sessions.id, sessionId))
+				.limit(1);
+
+			if (!session) {
+				return c.json({ error: 'Session not found' }, 404);
+			}
+
+			// Delete existing message parts (the error content)
+			await db
+				.delete(messageParts)
+				.where(eq(messageParts.messageId, messageId));
+
+			// Reset message status to pending
+			await db
+				.update(messages)
+				.set({
+					status: 'pending',
+					error: null,
+					errorType: null,
+					errorDetails: null,
+					completedAt: null,
+				})
+				.where(eq(messages.id, messageId));
+
+			// Emit event so UI updates
+			const { publish } = await import('../events/bus.ts');
+			publish({
+				type: 'message.updated',
+				sessionId,
+				payload: { id: messageId, status: 'pending' },
+			});
+
+			// Re-enqueue the assistant run
+			const { enqueueAssistantRun } = await import(
+				'../runtime/session/queue.ts'
+			);
+			const { runSessionLoop } = await import('../runtime/agent/runner.ts');
+
+			const toolApprovalMode = cfg.defaults.toolApproval ?? 'auto';
+
+			enqueueAssistantRun(
+				{
+					sessionId,
+					assistantMessageId: messageId,
+					agent: assistantMsg.agent ?? 'build',
+					provider: (assistantMsg.provider ??
+						cfg.defaults.provider) as ProviderId,
+					model: assistantMsg.model ?? cfg.defaults.model,
+					projectRoot: cfg.projectRoot,
+					oneShot: false,
+					toolApprovalMode,
+				},
+				runSessionLoop,
+			);
+
+			return c.json({ success: true, messageId });
+		} catch (err) {
+			logger.error('Failed to retry message', err);
+			const errorResponse = serializeError(err);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
 }

package/src/routes/setu.ts

@@ -8,6 +8,24 @@ import {
 } from '@agi-cli/sdk';
 import { logger } from '@agi-cli/sdk';
 import { serializeError } from '../runtime/errors/api-error.ts';
+import { Keypair } from '@solana/web3.js';
+import bs58 from 'bs58';
+import nacl from 'tweetnacl';
+import { publish } from '../events/bus.ts';
+import {
+	resolveTopupMethodSelection,
+	rejectTopupSelection,
+	getPendingTopup,
+	type TopupMethod,
+} from '../runtime/topup/manager.ts';
+
+const SETU_BASE_URL = process.env.SETU_BASE_URL || 'https://setu.agi.nitish.sh';
+
+function getSetuBaseUrl(): string {
+	return SETU_BASE_URL.endsWith('/')
+		? SETU_BASE_URL.slice(0, -1)
+		: SETU_BASE_URL;
+}
 
 async function getSetuPrivateKey(): Promise<string | null> {
 	if (process.env.SETU_PRIVATE_KEY) {
@@ -25,6 +43,25 @@ async function getSetuPrivateKey(): Promise<string | null> {
 	return null;
 }
 
+function signNonce(nonce: string, privateKeyBytes: Uint8Array): string {
+	const data = new TextEncoder().encode(nonce);
+	const signature = nacl.sign.detached(data, privateKeyBytes);
+	return bs58.encode(signature);
+}
+
+function buildWalletHeaders(privateKey: string): Record<string, string> {
+	const privateKeyBytes = bs58.decode(privateKey);
+	const keypair = Keypair.fromSecretKey(privateKeyBytes);
+	const walletAddress = keypair.publicKey.toBase58();
+	const nonce = Date.now().toString();
+	const signature = signNonce(nonce, privateKeyBytes);
+	return {
+		'x-wallet-address': walletAddress,
+		'x-wallet-nonce': nonce,
+		'x-wallet-signature': signature,
+	};
+}
+
 export function registerSetuRoutes(app: Hono) {
 	app.get('/v1/setu/balance', async (c) => {
 		try {
@@ -97,4 +134,213 @@ export function registerSetuRoutes(app: Hono) {
 			return c.json(errorResponse, errorResponse.error.status || 500);
 		}
 	});
+
+	app.get('/v1/setu/topup/polar/estimate', async (c) => {
+		try {
+			const amount = c.req.query('amount');
+			if (!amount) {
+				return c.json({ error: 'Missing amount parameter' }, 400);
+			}
+
+			const baseUrl = getSetuBaseUrl();
+			const response = await fetch(
+				`${baseUrl}/v1/topup/polar/estimate?amount=${amount}`,
+				{
+					method: 'GET',
+					headers: { 'Content-Type': 'application/json' },
+				},
+			);
+
+			const data = await response.json();
+			if (!response.ok) {
+				return c.json(data, response.status as 400 | 500);
+			}
+
+			return c.json(data);
+		} catch (error) {
+			logger.error('Failed to get Polar estimate', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
+	app.post('/v1/setu/topup/polar', async (c) => {
+		try {
+			const privateKey = await getSetuPrivateKey();
+			if (!privateKey) {
+				return c.json({ error: 'Setu wallet not configured' }, 401);
+			}
+
+			const body = await c.req.json();
+			const { amount, successUrl } = body as {
+				amount: number;
+				successUrl: string;
+			};
+
+			if (!amount || typeof amount !== 'number') {
+				return c.json({ error: 'Invalid amount' }, 400);
+			}
+
+			if (!successUrl || typeof successUrl !== 'string') {
+				return c.json({ error: 'Missing successUrl' }, 400);
+			}
+
+			const walletHeaders = buildWalletHeaders(privateKey);
+			const baseUrl = getSetuBaseUrl();
+
+			const response = await fetch(`${baseUrl}/v1/topup/polar`, {
+				method: 'POST',
+				headers: {
+					'Content-Type': 'application/json',
+					...walletHeaders,
+				},
+				body: JSON.stringify({ amount, successUrl }),
+			});
+
+			const data = await response.json();
+			if (!response.ok) {
+				return c.json(data, response.status as 400 | 500);
+			}
+
+			return c.json(data);
+		} catch (error) {
+			logger.error('Failed to create Polar checkout', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
+	app.post('/v1/setu/topup/select', async (c) => {
+		try {
+			const body = await c.req.json();
+			const { sessionId, method } = body as {
+				sessionId: string;
+				method: TopupMethod;
+			};
+
+			if (!sessionId || typeof sessionId !== 'string') {
+				return c.json({ error: 'Missing sessionId' }, 400);
+			}
+
+			if (!method || !['crypto', 'fiat'].includes(method)) {
+				return c.json(
+					{ error: 'Invalid method, must be "crypto" or "fiat"' },
+					400,
+				);
+			}
+
+			const resolved = resolveTopupMethodSelection(sessionId, method);
+			if (!resolved) {
+				return c.json(
+					{ error: 'No pending topup request found for this session' },
+					404,
+				);
+			}
+
+			publish({
+				type: 'setu.topup.method_selected',
+				sessionId,
+				payload: { method },
+			});
+
+			return c.json({ success: true, method });
+		} catch (error) {
+			logger.error('Failed to select topup method', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
+	app.post('/v1/setu/topup/cancel', async (c) => {
+		try {
+			const body = await c.req.json();
+			const { sessionId, reason } = body as {
+				sessionId: string;
+				reason?: string;
+			};
+
+			if (!sessionId || typeof sessionId !== 'string') {
+				return c.json({ error: 'Missing sessionId' }, 400);
+			}
+
+			const rejected = rejectTopupSelection(
+				sessionId,
+				reason ?? 'User cancelled',
+			);
+			if (!rejected) {
+				return c.json(
+					{ error: 'No pending topup request found for this session' },
+					404,
+				);
+			}
+
+			publish({
+				type: 'setu.topup.cancelled',
+				sessionId,
+				payload: { reason: reason ?? 'User cancelled' },
+			});
+
+			return c.json({ success: true });
+		} catch (error) {
+			logger.error('Failed to cancel topup', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
+	app.get('/v1/setu/topup/pending', async (c) => {
+		try {
+			const sessionId = c.req.query('sessionId');
+			if (!sessionId) {
+				return c.json({ error: 'Missing sessionId parameter' }, 400);
+			}
+
+			const pending = getPendingTopup(sessionId);
+			if (!pending) {
+				return c.json({ hasPending: false });
+			}
+
+			return c.json({
+				hasPending: true,
+				sessionId: pending.sessionId,
+				messageId: pending.messageId,
+				amountUsd: pending.amountUsd,
+				currentBalance: pending.currentBalance,
+				createdAt: pending.createdAt,
+			});
+		} catch (error) {
+			logger.error('Failed to get pending topup', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
+	app.get('/v1/setu/topup/polar/status', async (c) => {
+		try {
+			const checkoutId = c.req.query('checkoutId');
+			if (!checkoutId) {
+				return c.json({ error: 'Missing checkoutId parameter' }, 400);
+			}
+
+			const baseUrl = getSetuBaseUrl();
+			const response = await fetch(
+				`${baseUrl}/v1/topup/polar/status?checkoutId=${checkoutId}`,
+				{
+					method: 'GET',
+					headers: { 'Content-Type': 'application/json' },
+				},
+			);
+
+			const data = await response.json();
+			if (!response.ok) {
+				return c.json(data, response.status as 400 | 500);
+			}
+
+			return c.json(data);
+		} catch (error) {
+			logger.error('Failed to check Polar status', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
 }

package/src/runtime/agent/runner-setup.ts

@@ -201,6 +201,7 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	const model = await resolveModel(opts.provider, opts.model, cfg, {
 		systemPrompt: oauthSystemPrompt,
 		sessionId: opts.sessionId,
+		messageId: opts.assistantMessageId,
 	});
 	debugLog(
 		`[RUNNER] Model created: ${JSON.stringify({ id: model.modelId, provider: model.provider })}`,

package/src/runtime/provider/index.ts

@@ -3,7 +3,7 @@ import { getAnthropicInstance } from './anthropic.ts';
 import { resolveOpenAIModel } from './openai.ts';
 import { resolveGoogleModel } from './google.ts';
 import { resolveOpenRouterModel } from './openrouter.ts';
-import { resolveSetuModel } from './setu.ts';
+import { resolveSetuModel, type ResolveSetuModelOptions } from './setu.ts';
 import { getZaiInstance, getZaiCodingInstance } from './zai.ts';
 import { resolveOpencodeModel } from './opencode.ts';
 import { getMoonshotInstance } from './moonshot.ts';
@@ -14,7 +14,12 @@ export async function resolveModel(
 	provider: ProviderName,
 	model: string,
 	cfg: AGIConfig,
-	options?: { systemPrompt?: string; sessionId?: string },
+	options?: {
+		systemPrompt?: string;
+		sessionId?: string;
+		messageId?: string;
+		topupApprovalMode?: ResolveSetuModelOptions['topupApprovalMode'];
+	},
 ) {
 	if (provider === 'openai') {
 		return resolveOpenAIModel(model, cfg, {
@@ -35,7 +40,10 @@ export async function resolveModel(
 		return resolveOpencodeModel(model, cfg);
 	}
 	if (provider === 'setu') {
-		return resolveSetuModel(model, options?.sessionId);
+		return resolveSetuModel(model, options?.sessionId, {
+			messageId: options?.messageId,
+			topupApprovalMode: options?.topupApprovalMode,
+		});
 	}
 	if (provider === 'zai') {
 		return getZaiInstance(cfg, model);

package/src/runtime/provider/setu.ts

@@ -4,13 +4,28 @@ import {
 	type SetuPaymentCallbacks,
 } from '@agi-cli/sdk';
 import { publish } from '../../events/bus.ts';
+import {
+	waitForTopupMethodSelection,
+	type TopupMethod,
+} from '../topup/manager.ts';
+
+const MIN_TOPUP_USD = 5;
 
 function getProviderNpm(model: string): string | undefined {
 	const entry = catalog.setu?.models?.find((m) => m.id === model);
 	return entry?.provider?.npm;
 }
 
-export function resolveSetuModel(model: string, sessionId?: string) {
+export interface ResolveSetuModelOptions {
+	messageId?: string;
+	topupApprovalMode?: 'auto' | 'approval';
+}
+
+export function resolveSetuModel(
+	model: string,
+	sessionId?: string,
+	options: ResolveSetuModelOptions = {},
+) {
 	const privateKey = process.env.SETU_PRIVATE_KEY ?? '';
 	if (!privateKey) {
 		throw new Error(
@@ -19,14 +34,15 @@ export function resolveSetuModel(model: string, sessionId?: string) {
 	}
 	const baseURL = process.env.SETU_BASE_URL;
 	const rpcURL = process.env.SETU_SOLANA_RPC_URL;
+	const { messageId, topupApprovalMode = 'approval' } = options;
 
 	const callbacks: SetuPaymentCallbacks = sessionId
 		? {
-				onPaymentRequired: (amountUsd) => {
+				onPaymentRequired: (amountUsd, currentBalance) => {
 					publish({
 						type: 'setu.payment.required',
 						sessionId,
-						payload: { amountUsd },
+						payload: { amountUsd, currentBalance },
 					});
 				},
 				onPaymentSigning: () => {
@@ -50,6 +66,31 @@ export function resolveSetuModel(model: string, sessionId?: string) {
 						payload: { error },
 					});
 				},
+				onPaymentApproval: async (info): Promise<TopupMethod | 'cancel'> => {
+					const suggestedTopupUsd = Math.max(
+						MIN_TOPUP_USD,
+						Math.ceil(info.amountUsd * 2),
+					);
+
+					publish({
+						type: 'setu.topup.required',
+						sessionId,
+						payload: {
+							messageId,
+							amountUsd: info.amountUsd,
+							currentBalance: info.currentBalance,
+							minTopupUsd: MIN_TOPUP_USD,
+							suggestedTopupUsd,
+						},
+					});
+
+					return waitForTopupMethodSelection(
+						sessionId,
+						messageId ?? '',
+						info.amountUsd,
+						info.currentBalance,
+					);
+				},
 			}
 		: {};
 
@@ -63,6 +104,7 @@ export function resolveSetuModel(model: string, sessionId?: string) {
 			rpcURL,
 			callbacks,
 			providerNpm,
+			topupApprovalMode,
 		},
 	);
 }

package/src/runtime/stream/error-handler.ts

@@ -9,6 +9,7 @@ import type { ToolAdapterContext } from '../../tools/adapter.ts';
 import { pruneSession, performAutoCompaction } from '../message/compaction.ts';
 import { debugLog } from '../debug/index.ts';
 import { enqueueAssistantRun } from '../session/queue.ts';
+import { clearPendingTopup } from '../topup/manager.ts';
 
 export function createErrorHandler(
 	opts: RunOpts,
@@ -26,21 +27,155 @@ export function createErrorHandler(
 		const nestedError = (errObj?.error as Record<string, unknown>)?.error as
 			| Record<string, unknown>
 			| undefined;
+		const causeError = errObj?.cause as Record<string, unknown> | undefined;
+
+		// Check for SETU_FIAT_SELECTED code specifically (not string matching)
 		const errorCode =
-			(errObj?.code as string) ?? (nestedError?.code as string) ?? '';
+			(errObj?.code as string) ??
+			((errObj?.error as Record<string, unknown>)?.code as string) ??
+			((
+				(errObj?.error as Record<string, unknown>)?.error as Record<
+					string,
+					unknown
+				>
+			)?.code as string) ??
+			((errObj?.data as Record<string, unknown>)?.code as string) ??
+			((errObj?.cause as Record<string, unknown>)?.code as string) ??
+			((
+				(errObj?.cause as Record<string, unknown>)?.error as Record<
+					string,
+					unknown
+				>
+			)?.code as string) ??
+			(nestedError?.code as string) ??
+			(causeError?.code as string) ??
+			'';
+
+		// Also check error message for the exact fiat selection message
+		const errorMessage =
+			(errObj?.message as string) ??
+			((errObj?.error as Record<string, unknown>)?.message as string) ??
+			((
+				(errObj?.error as Record<string, unknown>)?.error as Record<
+					string,
+					unknown
+				>
+			)?.message as string) ??
+			((errObj?.data as Record<string, unknown>)?.message as string) ??
+			((errObj?.cause as Record<string, unknown>)?.message as string) ??
+			((
+				(errObj?.cause as Record<string, unknown>)?.error as Record<
+					string,
+					unknown
+				>
+			)?.message as string) ??
+			(nestedError?.message as string) ??
+			(causeError?.message as string) ??
+			'';
+
+		// Also do a JSON stringify check specifically for the code
+		const fullErrorStr = JSON.stringify(err);
+		const hasSetuFiatCode =
+			fullErrorStr.includes('"code":"SETU_FIAT_SELECTED"') ||
+			fullErrorStr.includes("'code':'SETU_FIAT_SELECTED'");
+
+		// Only match if the error code is SETU_FIAT_SELECTED OR the exact error message
+		const isFiatSelected =
+			errorCode === 'SETU_FIAT_SELECTED' ||
+			errorMessage === 'Setu: fiat payment selected' ||
+			hasSetuFiatCode;
+
+		// Handle fiat payment selected - this is not an error, just a signal to pause
+		if (isFiatSelected) {
+			debugLog('[stream-handlers] Fiat payment selected, pausing request');
+			clearPendingTopup(opts.sessionId);
+
+			// Add a helpful message part telling user to complete payment
+			const partId = crypto.randomUUID();
+			await db.insert(messageParts).values({
+				id: partId,
+				messageId: opts.assistantMessageId,
+				index: await sharedCtx.nextIndex(),
+				stepIndex: getStepIndex(),
+				type: 'error',
+				content: JSON.stringify({
+					message: 'Balance too low — Complete your top-up, then retry.',
+					type: 'balance_low',
+					errorType: 'balance_low',
+					isRetryable: true,
+				}),
+				agent: opts.agent,
+				provider: opts.provider,
+				model: opts.model,
+				startedAt: Date.now(),
+				completedAt: Date.now(),
+			});
+
+			// Mark the message as completed (not error, not pending)
+			await db
+				.update(messages)
+				.set({
+					status: 'complete',
+					completedAt: Date.now(),
+					error: null,
+					errorType: null,
+					errorDetails: null,
+				})
+				.where(eq(messages.id, opts.assistantMessageId));
+
+			// Emit the message part
+			publish({
+				type: 'message.part.delta',
+				sessionId: opts.sessionId,
+				payload: {
+					messageId: opts.assistantMessageId,
+					partId,
+					type: 'error',
+					content: JSON.stringify({
+						message: 'Balance too low — Complete your top-up, then retry.',
+						type: 'balance_low',
+						errorType: 'balance_low',
+						isRetryable: true,
+					}),
+				},
+			});
+
+			// Emit message completed
+			publish({
+				type: 'message.completed',
+				sessionId: opts.sessionId,
+				payload: {
+					id: opts.assistantMessageId,
+					fiatTopupRequired: true,
+				},
+			});
+
+			// Emit a special event so UI knows to show topup modal
+			publish({
+				type: 'setu.fiat.checkout_created',
+				sessionId: opts.sessionId,
+				payload: {
+					messageId: opts.assistantMessageId,
+					needsTopup: true,
+				},
+			});
+
+			return;
+		}
+
 		const errorType =
 			(errObj?.apiErrorType as string) ?? (nestedError?.type as string) ?? '';
-		const fullErrorStr = JSON.stringify(err).toLowerCase();
+		const fullErrorStrLower = JSON.stringify(err).toLowerCase();
 
 		const isPromptTooLong =
-			fullErrorStr.includes('prompt is too long') ||
-			fullErrorStr.includes('maximum context length') ||
-			fullErrorStr.includes('too many tokens') ||
-			fullErrorStr.includes('context_length_exceeded') ||
-			fullErrorStr.includes('request too large') ||
-			fullErrorStr.includes('exceeds the model') ||
-			fullErrorStr.includes('context window') ||
-			fullErrorStr.includes('input is too long') ||
+			fullErrorStrLower.includes('prompt is too long') ||
+			fullErrorStrLower.includes('maximum context length') ||
+			fullErrorStrLower.includes('too many tokens') ||
+			fullErrorStrLower.includes('context_length_exceeded') ||
+			fullErrorStrLower.includes('request too large') ||
+			fullErrorStrLower.includes('exceeds the model') ||
+			fullErrorStrLower.includes('context window') ||
+			fullErrorStrLower.includes('input is too long') ||
 			errorCode === 'context_length_exceeded' ||
 			errorType === 'invalid_request_error';
 

package/src/runtime/topup/manager.ts

@@ -0,0 +1,110 @@
+import { logger } from '@agi-cli/sdk';
+
+export type TopupMethod = 'crypto' | 'fiat';
+
+export interface PendingTopup {
+	sessionId: string;
+	messageId: string;
+	amountUsd: number;
+	currentBalance: number;
+	resolve: (method: TopupMethod) => void;
+	reject: (error: Error) => void;
+	createdAt: number;
+}
+
+const TOPUP_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+
+const pendingTopups = new Map<string, PendingTopup>();
+const timeoutIds = new Map<string, ReturnType<typeof setTimeout>>();
+
+export function waitForTopupMethodSelection(
+	sessionId: string,
+	messageId: string,
+	amountUsd: number,
+	currentBalance: number,
+): Promise<TopupMethod> {
+	return new Promise((resolve, reject) => {
+		const existing = pendingTopups.get(sessionId);
+		if (existing) {
+			existing.reject(new Error('Superseded by new topup request'));
+			clearPendingTopup(sessionId);
+		}
+
+		const pending: PendingTopup = {
+			sessionId,
+			messageId,
+			amountUsd,
+			currentBalance,
+			resolve,
+			reject,
+			createdAt: Date.now(),
+		};
+
+		pendingTopups.set(sessionId, pending);
+
+		const timeoutId = setTimeout(() => {
+			const p = pendingTopups.get(sessionId);
+			if (p) {
+				logger.warn(`Topup selection timeout for session ${sessionId}`);
+				p.reject(new Error('Topup selection timeout'));
+				clearPendingTopup(sessionId);
+			}
+		}, TOPUP_TIMEOUT_MS);
+
+		timeoutIds.set(sessionId, timeoutId);
+	});
+}
+
+export function resolveTopupMethodSelection(
+	sessionId: string,
+	method: TopupMethod,
+): boolean {
+	const pending = pendingTopups.get(sessionId);
+	if (!pending) {
+		logger.warn(
+			`No pending topup found for session ${sessionId} when trying to resolve`,
+		);
+		return false;
+	}
+
+	pending.resolve(method);
+	clearPendingTopup(sessionId);
+	return true;
+}
+
+export function rejectTopupSelection(
+	sessionId: string,
+	reason: string,
+): boolean {
+	const pending = pendingTopups.get(sessionId);
+	if (!pending) {
+		return false;
+	}
+
+	pending.reject(new Error(reason));
+	clearPendingTopup(sessionId);
+	return true;
+}
+
+export function getPendingTopup(sessionId: string): PendingTopup | undefined {
+	return pendingTopups.get(sessionId);
+}
+
+export function hasPendingTopup(sessionId: string): boolean {
+	return pendingTopups.has(sessionId);
+}
+
+export function clearPendingTopup(sessionId: string): void {
+	const timeoutId = timeoutIds.get(sessionId);
+	if (timeoutId) {
+		clearTimeout(timeoutId);
+		timeoutIds.delete(sessionId);
+	}
+	pendingTopups.delete(sessionId);
+}
+
+export function clearAllPendingTopups(): void {
+	for (const sessionId of pendingTopups.keys()) {
+		clearPendingTopup(sessionId);
+	}
+}