@ottocode/server 0.1.204 → 0.1.206

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/server",
-	"version": "0.1.204",
+	"version": "0.1.206",
 	"description": "HTTP API server for ottocode",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -49,8 +49,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@ottocode/sdk": "0.1.204",
-		"@ottocode/database": "0.1.204",
+		"@ottocode/sdk": "0.1.206",
+		"@ottocode/database": "0.1.206",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.1.8"

package/src/openapi/paths/git.ts

@@ -500,4 +500,139 @@ export const gitPaths = {
 			},
 		},
 	},
+	'/v1/git/remotes': {
+		get: {
+			tags: ['git'],
+			operationId: 'getGitRemotes',
+			summary: 'List git remotes',
+			parameters: [projectQueryParam()],
+			responses: {
+				200: {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									status: { type: 'string', enum: ['ok'] },
+									data: {
+										type: 'object',
+										properties: {
+											remotes: {
+												type: 'array',
+												items: {
+													type: 'object',
+													properties: {
+														name: { type: 'string' },
+														url: { type: 'string' },
+														type: { type: 'string' },
+													},
+													required: ['name', 'url', 'type'],
+												},
+											},
+										},
+										required: ['remotes'],
+									},
+								},
+								required: ['status', 'data'],
+							},
+						},
+					},
+				},
+				400: gitErrorResponse(),
+				500: gitErrorResponse(),
+			},
+		},
+		post: {
+			tags: ['git'],
+			operationId: 'addGitRemote',
+			summary: 'Add a git remote',
+			requestBody: {
+				required: true,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							properties: {
+								project: { type: 'string' },
+								name: { type: 'string' },
+								url: { type: 'string' },
+							},
+							required: ['name', 'url'],
+						},
+					},
+				},
+			},
+			responses: {
+				200: {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									status: { type: 'string', enum: ['ok'] },
+									data: {
+										type: 'object',
+										properties: {
+											name: { type: 'string' },
+											url: { type: 'string' },
+										},
+										required: ['name', 'url'],
+									},
+								},
+								required: ['status', 'data'],
+							},
+						},
+					},
+				},
+				400: gitErrorResponse(),
+				500: gitErrorResponse(),
+			},
+		},
+		delete: {
+			tags: ['git'],
+			operationId: 'removeGitRemote',
+			summary: 'Remove a git remote',
+			requestBody: {
+				required: true,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							properties: {
+								project: { type: 'string' },
+								name: { type: 'string' },
+							},
+							required: ['name'],
+						},
+					},
+				},
+			},
+			responses: {
+				200: {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									status: { type: 'string', enum: ['ok'] },
+									data: {
+										type: 'object',
+										properties: {
+											removed: { type: 'string' },
+										},
+										required: ['removed'],
+									},
+								},
+								required: ['status', 'data'],
+							},
+						},
+					},
+				},
+				500: gitErrorResponse(),
+			},
+		},
+	},
 } as const;

package/src/openapi/schemas.ts

@@ -234,6 +234,11 @@ export const schemas = {
 			},
 			hasChanges: { type: 'boolean' },
 			hasConflicts: { type: 'boolean' },
+			hasUpstream: { type: 'boolean' },
+			remotes: {
+				type: 'array',
+				items: { type: 'string' },
+			},
 		},
 		required: [
 			'branch',
@@ -245,6 +250,8 @@ export const schemas = {
 			'conflicted',
 			'hasChanges',
 			'hasConflicts',
+			'hasUpstream',
+			'remotes',
 		],
 	},
 	GitFile: {

package/src/routes/files.ts

@@ -346,4 +346,45 @@ export function registerFilesRoutes(app: Hono) {
 			return c.json({ error: serializeError(err) }, 500);
 		}
 	});
+
+	app.get('/v1/files/raw', async (c) => {
+		try {
+			const projectRoot = c.req.query('project') || process.cwd();
+			const filePath = c.req.query('path');
+
+			if (!filePath) {
+				return c.json({ error: 'Missing required query parameter: path' }, 400);
+			}
+
+			const absPath = join(projectRoot, filePath);
+			if (!absPath.startsWith(projectRoot)) {
+				return c.json({ error: 'Path traversal not allowed' }, 403);
+			}
+
+			const ext = filePath.split('.').pop()?.toLowerCase() ?? '';
+			const mimeTypes: Record<string, string> = {
+				png: 'image/png',
+				jpg: 'image/jpeg',
+				jpeg: 'image/jpeg',
+				gif: 'image/gif',
+				svg: 'image/svg+xml',
+				webp: 'image/webp',
+				ico: 'image/x-icon',
+				bmp: 'image/bmp',
+				avif: 'image/avif',
+			};
+			const contentType = mimeTypes[ext] || 'application/octet-stream';
+
+			const data = await readFile(absPath);
+			return new Response(data, {
+				headers: {
+					'Content-Type': contentType,
+					'Cache-Control': 'no-cache',
+				},
+			});
+		} catch (err) {
+			logger.error('Files raw route error:', err);
+			return c.json({ error: serializeError(err) }, 500);
+		}
+	});
 }

package/src/routes/git/index.ts

@@ -7,6 +7,7 @@ import { registerCommitRoutes } from './commit.ts';
 import { registerPushRoute } from './push.ts';
 import { registerPullRoute } from './pull.ts';
 import { registerInitRoute } from './init.ts';
+import { registerRemoteRoutes } from './remote.ts';
 
 export type { GitFile } from './types.ts';
 
@@ -19,4 +20,5 @@ export function registerGitRoutes(app: Hono) {
 	registerPushRoute(app);
 	registerPullRoute(app);
 	registerInitRoute(app);
+	registerRemoteRoutes(app);
 }

package/src/routes/git/remote.ts

@@ -0,0 +1,121 @@
+import type { Hono } from 'hono';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { gitRemoteAddSchema, gitRemoteRemoveSchema } from './schemas.ts';
+import { validateAndGetGitRoot } from './utils.ts';
+
+const execFileAsync = promisify(execFile);
+
+export function registerRemoteRoutes(app: Hono) {
+	app.get('/v1/git/remotes', async (c) => {
+		try {
+			const project = c.req.query('project');
+			const requestedPath = project || process.cwd();
+
+			const validation = await validateAndGetGitRoot(requestedPath);
+			if ('error' in validation) {
+				return c.json(
+					{ status: 'error', error: validation.error, code: validation.code },
+					400,
+				);
+			}
+
+			const { gitRoot } = validation;
+
+			const { stdout } = await execFileAsync('git', ['remote', '-v'], {
+				cwd: gitRoot,
+			});
+
+			const remotes: { name: string; url: string; type: string }[] = [];
+			const seen = new Set<string>();
+			for (const line of stdout.trim().split('\n').filter(Boolean)) {
+				const match = line.match(/^(\S+)\s+(\S+)\s+\((\w+)\)$/);
+				if (match) {
+					const key = `${match[1]}:${match[3]}`;
+					if (!seen.has(key)) {
+						seen.add(key);
+						remotes.push({
+							name: match[1],
+							url: match[2],
+							type: match[3],
+						});
+					}
+				}
+			}
+
+			return c.json({ status: 'ok', data: { remotes } });
+		} catch (error) {
+			return c.json(
+				{
+					status: 'error',
+					error:
+						error instanceof Error ? error.message : 'Failed to list remotes',
+				},
+				500,
+			);
+		}
+	});
+
+	app.post('/v1/git/remotes', async (c) => {
+		try {
+			const body = await c.req.json().catch(() => ({}));
+			const { project, name, url } = gitRemoteAddSchema.parse(body);
+			const requestedPath = project || process.cwd();
+
+			const validation = await validateAndGetGitRoot(requestedPath);
+			if ('error' in validation) {
+				return c.json(
+					{ status: 'error', error: validation.error, code: validation.code },
+					400,
+				);
+			}
+
+			const { gitRoot } = validation;
+
+			await execFileAsync('git', ['remote', 'add', name, url], {
+				cwd: gitRoot,
+			});
+
+			return c.json({
+				status: 'ok',
+				data: { name, url },
+			});
+		} catch (error) {
+			const message =
+				error instanceof Error ? error.message : 'Failed to add remote';
+			const status = message.includes('already exists') ? 400 : 500;
+			return c.json({ status: 'error', error: message }, status);
+		}
+	});
+
+	app.delete('/v1/git/remotes', async (c) => {
+		try {
+			const body = await c.req.json().catch(() => ({}));
+			const { project, name } = gitRemoteRemoveSchema.parse(body);
+			const requestedPath = project || process.cwd();
+
+			const validation = await validateAndGetGitRoot(requestedPath);
+			if ('error' in validation) {
+				return c.json(
+					{ status: 'error', error: validation.error, code: validation.code },
+					400,
+				);
+			}
+
+			const { gitRoot } = validation;
+
+			await execFileAsync('git', ['remote', 'remove', name], {
+				cwd: gitRoot,
+			});
+
+			return c.json({
+				status: 'ok',
+				data: { removed: name },
+			});
+		} catch (error) {
+			const message =
+				error instanceof Error ? error.message : 'Failed to remove remote';
+			return c.json({ status: 'error', error: message }, 500);
+		}
+	});
+}

package/src/routes/git/schemas.ts

@@ -50,3 +50,14 @@ export const gitPushSchema = z.object({
 export const gitPullSchema = z.object({
 	project: z.string().optional(),
 });
+
+export const gitRemoteAddSchema = z.object({
+	project: z.string().optional(),
+	name: z.string().min(1),
+	url: z.string().min(1),
+});
+
+export const gitRemoteRemoveSchema = z.object({
+	project: z.string().optional(),
+	name: z.string().min(1),
+});

package/src/routes/git/status.ts

@@ -45,6 +45,26 @@ export function registerStatusRoute(app: Hono) {
 
 			const branch = await getCurrentBranch(gitRoot);
 
+			let hasUpstream = false;
+			try {
+				await execFileAsync(
+					'git',
+					['rev-parse', '--abbrev-ref', '@{upstream}'],
+					{ cwd: gitRoot },
+				);
+				hasUpstream = true;
+			} catch {}
+
+			let remotes: string[] = [];
+			try {
+				const { stdout: remotesOutput } = await execFileAsync(
+					'git',
+					['remote'],
+					{ cwd: gitRoot },
+				);
+				remotes = remotesOutput.trim().split('\n').filter(Boolean);
+			} catch {}
+
 			const hasChanges =
 				staged.length > 0 ||
 				unstaged.length > 0 ||
@@ -59,6 +79,8 @@ export function registerStatusRoute(app: Hono) {
 					branch,
 					ahead,
 					behind,
+					hasUpstream,
+					remotes,
 					gitRoot,
 					workingDir: requestedPath,
 					staged,

package/src/routes/mcp.ts

@@ -104,6 +104,10 @@ export function registerMCPRoutes(app: Hono) {
 		try {
 			const manager = getMCPManager();
 			if (manager) {
+				const config = await loadMCPConfig(projectRoot, getGlobalConfigDir());
+				const serverConfig = config.servers.find((s) => s.name === name);
+				const scope = serverConfig?.scope ?? 'global';
+				await manager.clearAuthData(name, scope, projectRoot);
 				await manager.stopServer(name);
 			}
 

package/src/routes/setu.ts

@@ -4,7 +4,6 @@ import {
 	getPublicKeyFromPrivate,
 	getAuth,
 	loadConfig,
-	fetchSolanaUsdcBalance,
 } from '@ottocode/sdk';
 import { logger } from '@ottocode/sdk';
 import { serializeError } from '../runtime/errors/api-error.ts';
@@ -117,18 +116,44 @@ export function registerSetuRoutes(app: Hono) {
 				return c.json({ error: 'Setu wallet not configured' }, 401);
 			}
 
-			const network =
-				(c.req.query('network') as 'mainnet' | 'devnet') || 'mainnet';
+			const publicKey = getPublicKeyFromPrivate(privateKey);
+			if (!publicKey) {
+				return c.json({ error: 'Invalid private key' }, 400);
+			}
 
-			const balance = await fetchSolanaUsdcBalance({ privateKey }, network);
-			if (!balance) {
-				return c.json(
-					{ error: 'Failed to fetch USDC balance from Solana' },
-					502,
-				);
+			const baseUrl = getSetuBaseUrl();
+			const response = await fetch(
+				`${baseUrl}/v1/wallet/${publicKey}/balances?limit=100&showNative=false&showNfts=false&showZeroBalance=false`,
+				{
+					method: 'GET',
+					headers: { 'Content-Type': 'application/json' },
+				},
+			);
+
+			if (!response.ok) {
+				return c.json({ error: 'Failed to fetch wallet balances' }, 502);
 			}
 
-			return c.json(balance);
+			const data = (await response.json()) as {
+				balances: Array<{
+					mint: string;
+					symbol: string;
+					name: string;
+					balance: number;
+					decimals: number;
+					pricePerToken: number | null;
+					usdValue: number | null;
+				}>;
+				totalUsdValue: number;
+			};
+
+			const usdcEntry = data.balances.find((b) => b.symbol === 'USDC');
+
+			return c.json({
+				walletAddress: publicKey,
+				usdcBalance: usdcEntry?.balance ?? 0,
+				network: 'mainnet' as const,
+			});
 		} catch (error) {
 			logger.error('Failed to fetch USDC balance', error);
 			const errorResponse = serializeError(error);

package/src/runtime/agent/mcp-prepare-step.ts

@@ -0,0 +1,69 @@
+import type { Tool } from 'ai';
+import { debugLog } from '../debug/index.ts';
+
+export interface MCPPrepareStepState {
+	mcpToolsRecord: Record<string, Tool>;
+	loadedMCPTools: Set<string>;
+	baseToolNames: string[];
+	canonicalToRegistration: Record<string, string>;
+	loadToolRegistrationName: string;
+}
+
+export function createMCPPrepareStepState(
+	mcpToolsRecord: Record<string, Tool>,
+	baseToolNames: string[],
+	canonicalToRegistration: Record<string, string>,
+	loadToolRegistrationName: string,
+): MCPPrepareStepState {
+	return {
+		mcpToolsRecord,
+		loadedMCPTools: new Set(),
+		baseToolNames,
+		canonicalToRegistration,
+		loadToolRegistrationName,
+	};
+}
+
+export function buildPrepareStep(state: MCPPrepareStepState) {
+	return async ({
+		stepNumber,
+		steps,
+	}: {
+		stepNumber: number;
+		steps: unknown[];
+	}) => {
+		const previousSteps = steps as Array<{
+			toolCalls?: Array<{ toolName: string; input: unknown }>;
+			toolResults?: Array<{ toolName: string; output: unknown }>;
+		}>;
+
+		for (const step of previousSteps) {
+			if (!step.toolCalls) continue;
+			for (const call of step.toolCalls) {
+				if (call.toolName !== state.loadToolRegistrationName) continue;
+				const result = (step.toolResults ?? []).find(
+					(r) => r.toolName === state.loadToolRegistrationName,
+				);
+				const output = result?.output as { loaded?: string[] } | undefined;
+				if (!output?.loaded) continue;
+				for (const canonicalName of output.loaded) {
+					const regName =
+						state.canonicalToRegistration[canonicalName] ?? canonicalName;
+					if (!state.loadedMCPTools.has(regName)) {
+						state.loadedMCPTools.add(regName);
+					}
+				}
+			}
+		}
+
+		const activeTools = [...state.baseToolNames, ...state.loadedMCPTools];
+
+		if (state.loadedMCPTools.size > 0) {
+			debugLog(
+				`[MCP prepareStep] step=${stepNumber}, active MCP tools: ${[...state.loadedMCPTools].join(', ')}`,
+			);
+		}
+
+		return { activeTools };
+	};
+}

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

@@ -8,6 +8,7 @@ import { resolveModel } from '../provider/index.ts';
 import { resolveAgentConfig } from './registry.ts';
 import { composeSystemPrompt } from '../prompt/builder.ts';
 import { discoverProjectTools } from '@ottocode/sdk';
+import type { Tool } from 'ai';
 import { adaptTools } from '../../tools/adapter.ts';
 import { buildDatabaseTools } from '../../tools/database/index.ts';
 import { debugLog, time, isDebugEnabled } from '../debug/index.ts';
@@ -39,6 +40,7 @@ export interface SetupResult {
 	providerOptions: Record<string, unknown>;
 	needsSpoof: boolean;
 	isOpenAIOAuth: boolean;
+	mcpToolsRecord: Record<string, Tool>;
 }
 
 const THINKING_BUDGET = 16000;
@@ -143,7 +145,9 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	}
 
 	const toolsTimer = time('runner:discoverTools');
-	const allTools = await discoverProjectTools(cfg.projectRoot);
+	const discovered = await discoverProjectTools(cfg.projectRoot);
+	const allTools = discovered.tools;
+	const { mcpToolsRecord } = discovered;
 
 	if (opts.agent === 'research') {
 		const currentSession = sessionRows[0];
@@ -151,19 +155,23 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 
 		const dbTools = buildDatabaseTools(cfg.projectRoot, parentSessionId);
 		for (const dt of dbTools) {
-			allTools.push(dt);
+			discovered.tools.push(dt);
 		}
 		debugLog(
 			`[tools] Added ${dbTools.length} database tools for research agent (parent: ${parentSessionId ?? 'none'})`,
 		);
 	}
 
-	toolsTimer.end({ count: allTools.length });
+	toolsTimer.end({
+		count: allTools.length + Object.keys(mcpToolsRecord).length,
+	});
 	const allowedNames = new Set([...(agentCfg.tools || []), 'finish']);
 	const gated = allTools.filter(
-		(tool) => allowedNames.has(tool.name) || tool.name.includes('__'),
+		(tool) => allowedNames.has(tool.name) || tool.name === 'load_mcp_tools',
+	);
+	debugLog(
+		`[tools] ${gated.length} gated tools, ${Object.keys(mcpToolsRecord).length} lazy MCP tools`,
 	);
-	debugLog(`[tools] ${gated.length} allowed tools (including MCP)`);
 
 	debugLog(`[RUNNER] About to create model with provider: ${opts.provider}`);
 	debugLog(`[RUNNER] About to create model ID: ${opts.model}`);
@@ -249,6 +257,7 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 		providerOptions,
 		needsSpoof: oauth.needsSpoof,
 		isOpenAIOAuth: oauth.isOpenAIOAuth,
+		mcpToolsRecord,
 	};
 }
 

package/src/runtime/agent/runner.ts

@@ -26,6 +26,11 @@ import {
 import { pruneSession } from '../message/compaction.ts';
 import { triggerDeferredTitleGeneration } from '../message/service.ts';
 import { setupRunner } from './runner-setup.ts';
+import {
+	createMCPPrepareStepState,
+	buildPrepareStep,
+} from './mcp-prepare-step.ts';
+import { adaptTools as adaptToolsFn } from '../../tools/adapter.ts';
 import {
 	type ReasoningState,
 	handleReasoningStart,
@@ -83,13 +88,54 @@ async function runAssistant(opts: RunOpts) {
 		additionalSystemMessages,
 		model,
 		effectiveMaxOutputTokens,
-		toolset,
 		sharedCtx,
 		firstToolTimer,
 		firstToolSeen,
 		providerOptions,
 		isOpenAIOAuth,
+		mcpToolsRecord,
 	} = setup;
+	let { toolset } = setup;
+
+	const hasMCPTools = Object.keys(mcpToolsRecord).length > 0;
+	let prepareStep: ReturnType<typeof buildPrepareStep> | undefined;
+
+	if (hasMCPTools) {
+		const baseToolNames = Object.keys(toolset);
+		const { getAuth: getAuthFn } = await import('@ottocode/sdk');
+		const providerAuth = await getAuthFn(opts.provider, cfg.projectRoot);
+		const adaptedMCP = adaptToolsFn(
+			Object.entries(mcpToolsRecord).map(([name, tool]) => ({ name, tool })),
+			sharedCtx,
+			opts.provider,
+			providerAuth?.type,
+		);
+		toolset = { ...toolset, ...adaptedMCP };
+		const canonicalToRegistration: Record<string, string> = {};
+		for (const canonical of Object.keys(mcpToolsRecord)) {
+			const regKeys = Object.keys(adaptedMCP);
+			const regName = regKeys.find(
+				(k) =>
+					k === canonical ||
+					k.toLowerCase().replace(/_/g, '') ===
+						canonical.toLowerCase().replace(/_/g, ''),
+			);
+			canonicalToRegistration[canonical] = regName ?? canonical;
+		}
+		const loadToolRegName =
+			Object.keys(toolset).find(
+				(k) =>
+					k === 'load_mcp_tools' ||
+					k.toLowerCase().replace(/_/g, '') === 'loadmcptools',
+			) ?? 'load_mcp_tools';
+		const mcpState = createMCPPrepareStepState(
+			mcpToolsRecord,
+			baseToolNames,
+			canonicalToRegistration,
+			loadToolRegName,
+		);
+		prepareStep = buildPrepareStep(mcpState);
+	}
 
 	const isFirstMessage = !history.some((m) => m.role === 'assistant');
 
@@ -213,6 +259,7 @@ async function runAssistant(opts: RunOpts) {
 			...(Object.keys(providerOptions).length > 0 ? { providerOptions } : {}),
 			abortSignal: opts.abortSignal,
 			stopWhen: stopWhenCondition,
+			...(prepareStep ? { prepareStep } : {}),
 			// biome-ignore lint/suspicious/noExplicitAny: AI SDK callback types mismatch
 			onStepFinish: onStepFinish as any,
 			// biome-ignore lint/suspicious/noExplicitAny: AI SDK callback types mismatch

package/src/runtime/message/tool-history-tracker.ts

@@ -80,6 +80,9 @@ function describeToolResult(info: ToolResultInfo): TargetDescriptor | null {
 		case 'multiedit':
 			return describeEdit(info);
 		default:
+			if (toolName.includes('__')) {
+				return describeMcpTool(info);
+			}
 			return null;
 	}
 }
@@ -215,3 +218,54 @@ function describeEdit(info: ToolResultInfo): TargetDescriptor | null {
 	const summary = `[previous edit] ${normalized}`;
 	return { keys: [key], summary };
 }
+
+function describeMcpTool(info: ToolResultInfo): TargetDescriptor | null {
+	const { toolName } = info;
+	const result = getRecord(info.result);
+	const args = getRecord(info.args);
+
+	const hasImages =
+		result && Array.isArray(result.images) && result.images.length > 0;
+	const resultStr =
+		result && typeof result.result === 'string' ? result.result : null;
+	const estimatedSize = hasImages
+		? estimateBase64Size(result.images as Array<{ data: string }>)
+		: resultStr
+			? resultStr.length
+			: 0;
+
+	if (estimatedSize < 2000 && !hasImages) return null;
+
+	const argsHint = args
+		? Object.entries(args)
+				.slice(0, 3)
+				.map(([k, v]) => {
+					const val =
+						typeof v === 'string'
+							? v.length > 30
+								? `${v.slice(0, 27)}…`
+								: v
+							: JSON.stringify(v);
+					return `${k}=${val}`;
+				})
+				.join(' ')
+		: '';
+
+	const sizeLabel = hasImages
+		? `${(result.images as unknown[]).length} image(s), ~${Math.round(estimatedSize / 1024)}KB`
+		: `~${Math.round(estimatedSize / 1024)}KB`;
+
+	const key = `mcp:${toolName}`;
+	const summary = `[previous MCP call] ${toolName}${argsHint ? ` (${argsHint})` : ''} → ${sizeLabel}`;
+	return { keys: [key], summary };
+}
+
+function estimateBase64Size(images: Array<{ data: string }>): number {
+	let total = 0;
+	for (const img of images) {
+		if (typeof img.data === 'string') {
+			total += Math.floor(img.data.length * 0.75);
+		}
+	}
+	return total;
+}

package/src/runtime/provider/index.ts

@@ -21,6 +21,7 @@ export async function resolveModel(
 		sessionId?: string;
 		messageId?: string;
 		topupApprovalMode?: ResolveSetuModelOptions['topupApprovalMode'];
+		autoPayThresholdUsd?: ResolveSetuModelOptions['autoPayThresholdUsd'];
 	},
 ) {
 	if (provider === 'openai') {
@@ -46,6 +47,7 @@ export async function resolveModel(
 		return await resolveSetuModel(model, options?.sessionId, {
 			messageId: options?.messageId,
 			topupApprovalMode: options?.topupApprovalMode,
+			autoPayThresholdUsd: options?.autoPayThresholdUsd,
 		});
 	}
 	if (provider === 'zai') {

package/src/runtime/provider/setu.ts

@@ -21,6 +21,7 @@ function getProviderNpm(model: string): string | undefined {
 export interface ResolveSetuModelOptions {
 	messageId?: string;
 	topupApprovalMode?: 'auto' | 'approval';
+	autoPayThresholdUsd?: number;
 }
 
 async function getSetuPrivateKey(): Promise<string> {
@@ -50,7 +51,11 @@ export async function resolveSetuModel(
 	}
 	const baseURL = process.env.SETU_BASE_URL;
 	const rpcURL = process.env.SETU_SOLANA_RPC_URL;
-	const { messageId, topupApprovalMode = 'approval' } = options;
+	const {
+		messageId,
+		topupApprovalMode = 'approval',
+		autoPayThresholdUsd = MIN_TOPUP_USD,
+	} = options;
 
 	const callbacks: SetuPaymentCallbacks = sessionId
 		? {
@@ -128,6 +133,7 @@ export async function resolveSetuModel(
 			callbacks,
 			providerNpm,
 			topupApprovalMode,
+			autoPayThresholdUsd,
 		},
 	);
 }