@ottocode/sdk 0.1.204 → 0.1.206

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/sdk",
-	"version": "0.1.204",
+	"version": "0.1.206",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "nitishxyz",
 	"license": "MIT",

package/src/core/src/index.ts

@@ -30,7 +30,7 @@ export type { ProviderId, ModelInfo } from '../../types/src/index.ts';
 // Tools
 // =======================
 export { discoverProjectTools } from './tools/loader';
-export type { DiscoveredTool } from './tools/loader';
+export type { DiscoveredTool, DiscoverResult } from './tools/loader';
 export { setTerminalManager, getTerminalManager } from './tools/loader';
 
 // Tool error handling utilities

package/src/core/src/mcp/client.ts

@@ -166,15 +166,18 @@ export class MCPClientWrapper {
 		args: Record<string, unknown>,
 	): Promise<unknown> {
 		const result = await this.client.callTool({ name, arguments: args });
+		const images = extractImages(result.content);
 		if (result.isError) {
 			return {
 				ok: false,
 				error: formatContent(result.content),
+				...(images.length > 0 && { images }),
 			};
 		}
 		return {
 			ok: true,
 			result: formatContent(result.content),
+			...(images.length > 0 && { images }),
 		};
 	}
 
@@ -218,12 +221,34 @@ function formatContent(content: unknown): string {
 		if (item && typeof item === 'object' && 'text' in item) {
 			parts.push(String(item.text));
 		} else if (item && typeof item === 'object' && 'data' in item) {
-			parts.push(
-				`[binary data: ${(item as { mimeType?: string }).mimeType ?? 'unknown'}]`,
-			);
+			const mimeType = (item as { mimeType?: string }).mimeType ?? 'unknown';
+			if (mimeType.startsWith('image/')) {
+				parts.push(`[image: ${mimeType}]`);
+			} else {
+				parts.push(`[binary data: ${mimeType}]`);
+			}
 		} else {
 			parts.push(JSON.stringify(item));
 		}
 	}
 	return parts.join('\n');
 }
+
+function extractImages(
+	content: unknown,
+): Array<{ data: string; mimeType: string }> {
+	if (!Array.isArray(content)) return [];
+	const images: Array<{ data: string; mimeType: string }> = [];
+	for (const item of content) {
+		if (item && typeof item === 'object' && 'data' in item) {
+			const mimeType = (item as { mimeType?: string }).mimeType ?? 'unknown';
+			if (mimeType.startsWith('image/')) {
+				images.push({
+					data: String((item as { data: unknown }).data),
+					mimeType,
+				});
+			}
+		}
+	}
+	return images;
+}

package/src/core/src/mcp/index.ts

@@ -13,6 +13,14 @@ export { MCPServerManager } from './server-manager.ts';
 
 export { convertMCPToolsToAISDK } from './tools.ts';
 
+export {
+	getMCPToolBriefs,
+	buildLoadMCPToolsTool,
+	getMCPToolsRecord,
+	buildMCPToolCatalogDescription,
+	type MCPToolBrief,
+} from './lazy-tools.ts';
+
 export {
 	getMCPManager,
 	initializeMCP,

package/src/core/src/mcp/lazy-tools.ts

@@ -0,0 +1,89 @@
+import { tool, type Tool } from 'ai';
+import { z } from 'zod/v3';
+import type { MCPServerManager } from './server-manager.ts';
+import { convertMCPToolsToAISDK } from './tools.ts';
+
+export type MCPToolBrief = {
+	name: string;
+	server: string;
+	description: string;
+};
+
+export function getMCPToolBriefs(manager: MCPServerManager): MCPToolBrief[] {
+	return manager.getTools().map(({ name, server, tool: t }) => ({
+		name,
+		server,
+		description: t.description ?? `MCP tool: ${t.name}`,
+	}));
+}
+
+export function buildMCPToolCatalogDescription(briefs: MCPToolBrief[]): string {
+	if (briefs.length === 0) return 'No MCP tools available.';
+	const grouped = new Map<string, MCPToolBrief[]>();
+	for (const b of briefs) {
+		const list = grouped.get(b.server) ?? [];
+		list.push(b);
+		grouped.set(b.server, list);
+	}
+	const lines: string[] = [];
+	for (const [server, tools] of grouped) {
+		lines.push(`[${server}]`);
+		for (const t of tools) {
+			lines.push(`  ${t.name}: ${t.description.slice(0, 120)}`);
+		}
+	}
+	return lines.join('\n');
+}
+
+export function buildLoadMCPToolsTool(briefs: MCPToolBrief[]): {
+	name: string;
+	tool: Tool;
+} {
+	const catalog = buildMCPToolCatalogDescription(briefs);
+	const validNames = new Set(briefs.map((b) => b.name));
+
+	return {
+		name: 'load_mcp_tools',
+		tool: tool({
+			description: `Load MCP tools by name so they become available for use in the next step. Call this with the tool names you need before using them.\n\nAvailable MCP tools:\n${catalog}`,
+			inputSchema: z.object({
+				tools: z
+					.array(z.string())
+					.describe(
+						'Array of MCP tool names to load (e.g. ["chrome__click", "chrome__screenshot"])',
+					),
+			}),
+			execute: async ({ tools: requested }) => {
+				const loaded: string[] = [];
+				const notFound: string[] = [];
+				for (const name of requested) {
+					if (validNames.has(name)) {
+						loaded.push(name);
+					} else {
+						notFound.push(name);
+					}
+				}
+				return {
+					ok: true,
+					loaded,
+					...(notFound.length > 0 ? { notFound } : {}),
+					message:
+						loaded.length > 0
+							? `Loaded ${loaded.length} tool(s). They are now available for use.`
+							: 'No valid tools to load.',
+				};
+			},
+		}),
+	};
+}
+
+export function getMCPToolsRecord(
+	manager: MCPServerManager,
+): Record<string, Tool> {
+	const mcpTools = convertMCPToolsToAISDK(manager);
+	const record: Record<string, Tool> = {};
+	for (const { name, tool: t } of mcpTools) {
+		record[name] = t;
+	}
+	return record;
+}

package/src/core/src/mcp/server-manager.ts

@@ -220,6 +220,7 @@ export class MCPServerManager {
 
 		this.serverScopes.set(config.name, config.scope ?? 'global');
 		const key = this.oauthKey(config.name);
+		await this.oauthStore.clearServer(key);
 		const provider = new OttoOAuthProvider(key, this.oauthStore, {
 			clientId: config.oauth?.clientId,
 			callbackPort: config.oauth?.callbackPort,
@@ -244,6 +245,7 @@ export class MCPServerManager {
 
 			if (provider.pendingAuthUrl) {
 				this.pendingAuth.set(config.name, provider.pendingAuthUrl);
+				this.waitForAuthAndReconnect(config.name, provider);
 				return provider.pendingAuthUrl;
 			}
 			return null;
@@ -295,6 +297,30 @@ export class MCPServerManager {
 		await this.stopServer(name);
 	}
 
+	async clearAuthData(
+		name: string,
+		scope?: 'global' | 'project',
+		projectRoot?: string,
+	): Promise<void> {
+		const provider = this.authProviders.get(name);
+		if (provider) {
+			await provider.clearCredentials();
+			provider.cleanup();
+		}
+		this.authProviders.delete(name);
+		if (scope) {
+			this.serverScopes.set(name, scope);
+		}
+		if (projectRoot) {
+			this.projectRoot = projectRoot;
+		}
+		const key = this.oauthKey(name);
+		await this.oauthStore.clearServer(key);
+		if (key !== name) {
+			await this.oauthStore.clearServer(name);
+		}
+	}
+
 	async getAuthStatus(
 		name: string,
 	): Promise<{ authenticated: boolean; expiresAt?: number }> {

package/src/core/src/mcp/tools.ts

@@ -1,7 +1,15 @@
 import { tool, type Tool } from 'ai';
+import type { ToolResultOutput } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v3';
 import type { MCPServerManager } from './server-manager.ts';
 
+type MCPToolResult = {
+	ok: boolean;
+	result?: string;
+	error?: string;
+	images?: Array<{ data: string; mimeType: string }>;
+};
+
 export function convertMCPToolsToAISDK(
 	manager: MCPServerManager,
 ): Array<{ name: string; tool: Tool }> {
@@ -16,13 +24,38 @@ export function convertMCPToolsToAISDK(
 			) as z.ZodObject<z.ZodRawShape>,
 			async execute(args: Record<string, unknown>) {
 				try {
-					return await manager.callTool(name, args);
+					return (await manager.callTool(name, args)) as MCPToolResult;
 				} catch (err) {
 					return {
 						ok: false,
 						error: err instanceof Error ? err.message : String(err),
-					};
+					} satisfies MCPToolResult;
+				}
+			},
+			toModelOutput({ output }): ToolResultOutput {
+				const result = output as MCPToolResult;
+				if (result.images && result.images.length > 0) {
+					const parts: Array<
+						| { type: 'text'; text: string }
+						| { type: 'image-data'; data: string; mediaType: string }
+					> = [];
+					const text = result.ok ? result.result : result.error;
+					if (text) {
+						parts.push({ type: 'text', text });
+					}
+					for (const img of result.images) {
+						parts.push({
+							type: 'image-data',
+							data: img.data,
+							mediaType: img.mimeType,
+						});
+					}
+					return { type: 'content', value: parts } as ToolResultOutput;
 				}
+				return {
+					type: 'json',
+					value: result as unknown as import('@ai-sdk/provider').JSONValue,
+				};
 			},
 		}),
 	}));

package/src/core/src/tools/loader.ts

@@ -16,7 +16,12 @@ import { buildTerminalTool } from './builtin/terminal.ts';
 import type { TerminalManager } from '../terminals/index.ts';
 import { initializeSkills, buildSkillTool } from '../../../skills/index.ts';
 import { getMCPManager } from '../mcp/index.ts';
-import { convertMCPToolsToAISDK } from '../mcp/tools.ts';
+import {
+	getMCPToolBriefs,
+	buildLoadMCPToolsTool,
+	getMCPToolsRecord,
+	type MCPToolBrief,
+} from '../mcp/lazy-tools.ts';
 import fg from 'fast-glob';
 import { dirname, isAbsolute, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
@@ -25,6 +30,11 @@ import { spawn as nodeSpawn } from 'node:child_process';
 
 export type DiscoveredTool = { name: string; tool: Tool };
 
+export type DiscoverResult = {
+	tools: DiscoveredTool[];
+	mcpToolsRecord: Record<string, Tool>;
+};
+
 type PluginParameter = {
 	type: 'string' | 'number' | 'boolean';
 	description?: string;
@@ -108,7 +118,7 @@ export function getTerminalManager(): TerminalManager | null {
 export async function discoverProjectTools(
 	projectRoot: string,
 	globalConfigDir?: string,
-): Promise<DiscoveredTool[]> {
+): Promise<DiscoverResult> {
 	const tools = new Map<string, Tool>();
 	for (const { name, tool } of buildFsTools(projectRoot)) tools.set(name, tool);
 	for (const { name, tool } of buildGitTools(projectRoot))
@@ -148,10 +158,14 @@ export async function discoverProjectTools(
 	tools.set(skillTool.name, skillTool.tool);
 
 	const mcpManager = getMCPManager();
+	let mcpToolsRecord: Record<string, Tool> = {};
+	let mcpBriefs: MCPToolBrief[] = [];
 	if (mcpManager?.started) {
-		const mcpTools = convertMCPToolsToAISDK(mcpManager);
-		for (const { name, tool } of mcpTools) {
-			tools.set(name, tool);
+		mcpBriefs = getMCPToolBriefs(mcpManager);
+		if (mcpBriefs.length > 0) {
+			mcpToolsRecord = getMCPToolsRecord(mcpManager);
+			const loadTool = buildLoadMCPToolsTool(mcpBriefs);
+			tools.set(loadTool.name, loadTool.tool);
 		}
 	}
 
@@ -210,7 +224,10 @@ export async function discoverProjectTools(
 
 	await loadFromBase(globalConfigDir);
 	await loadFromBase(join(projectRoot, '.otto'));
-	return Array.from(tools.entries()).map(([name, tool]) => ({ name, tool }));
+	return {
+		tools: Array.from(tools.entries()).map(([name, tool]) => ({ name, tool })),
+		mcpToolsRecord,
+	};
 }
 
 async function loadPlugin(

package/src/index.ts

@@ -218,7 +218,7 @@ export type { ProviderName, ModelConfig } from './core/src/index.ts';
 
 // Tools
 export { discoverProjectTools } from './core/src/index.ts';
-export type { DiscoveredTool } from './core/src/index.ts';
+export type { DiscoveredTool, DiscoverResult } from './core/src/index.ts';
 export { setTerminalManager, getTerminalManager } from './core/src/index.ts';
 export { buildFsTools } from './core/src/index.ts';
 export { buildGitTools } from './core/src/index.ts';

package/src/providers/src/setu-client.ts

@@ -78,6 +78,7 @@ export type SetuProviderOptions = {
 	promptCacheKey?: string;
 	promptCacheRetention?: 'in_memory' | '24h';
 	topupApprovalMode?: 'auto' | 'approval';
+	autoPayThresholdUsd?: number;
 };
 
 export type SetuAuth = {
@@ -163,6 +164,7 @@ export function createSetuFetch(
 	const promptCacheKey = options.promptCacheKey;
 	const promptCacheRetention = options.promptCacheRetention;
 	const topupApprovalMode = options.topupApprovalMode ?? 'auto';
+	const autoPayThresholdUsd = options.autoPayThresholdUsd ?? 0;
 
 	const baseFetch = globalThis.fetch.bind(globalThis);
 
@@ -232,39 +234,62 @@ export function createSetuFetch(
 				const amountUsd =
 					parseInt(requirement.maxAmountRequired, 10) / 1_000_000;
 
-				if (topupApprovalMode === 'approval' && callbacks.onPaymentApproval) {
+				let walletUsdcBalance = 0;
+				if (autoPayThresholdUsd > 0) {
+					walletUsdcBalance = await getWalletUsdcBalance(walletAddress, rpcURL);
+				}
+
+				const canAutoPay =
+					autoPayThresholdUsd > 0 && walletUsdcBalance >= autoPayThresholdUsd;
+
+				const requestApproval = async () => {
+					if (!callbacks.onPaymentApproval) return;
 					const approval = await callbacks.onPaymentApproval({
 						amountUsd,
-						currentBalance: 0,
+						currentBalance: walletUsdcBalance,
 					});
-
 					if (approval === 'cancel') {
 						callbacks.onPaymentError?.('Payment cancelled by user');
 						throw new Error('Setu: payment cancelled by user');
 					}
-
 					if (approval === 'fiat') {
 						const err = new Error('Setu: fiat payment selected');
 						(err as Error & { code: string }).code = 'SETU_FIAT_SELECTED';
 						throw err;
 					}
+				};
+
+				if (!canAutoPay && topupApprovalMode === 'approval') {
+					await requestApproval();
 				}
 
-				callbacks.onPaymentRequired?.(amountUsd, 0);
-
-				const outcome = await handlePayment({
-					requirement,
-					keypair,
-					rpcURL,
-					baseURL,
-					baseFetch,
-					buildWalletHeaders,
-					maxAttempts: remainingPayments,
-					callbacks,
-				});
-
-				const newTotal = currentAttempts + outcome.attemptsUsed;
-				globalPaymentAttempts.set(walletAddress, newTotal);
+				callbacks.onPaymentRequired?.(amountUsd, walletUsdcBalance);
+
+				const doPayment = async () => {
+					const outcome = await handlePayment({
+						requirement,
+						keypair,
+						rpcURL,
+						baseURL,
+						baseFetch,
+						buildWalletHeaders,
+						maxAttempts: remainingPayments,
+						callbacks,
+					});
+					const newTotal = currentAttempts + outcome.attemptsUsed;
+					globalPaymentAttempts.set(walletAddress, newTotal);
+				};
+
+				if (canAutoPay) {
+					try {
+						await doPayment();
+					} catch (_autoPayErr) {
+						await requestApproval();
+						await doPayment();
+					}
+				} else {
+					await doPayment();
+				}
 			} finally {
 				releaseLock();
 			}
@@ -638,6 +663,48 @@ export function getPublicKeyFromPrivate(privateKey: string): string | null {
 	}
 }
 
+async function getWalletUsdcBalance(
+	walletAddress: string,
+	rpcUrl: string,
+): Promise<number> {
+	try {
+		const usdcMint = rpcUrl.includes('devnet')
+			? USDC_MINT_DEVNET
+			: USDC_MINT_MAINNET;
+		const response = await fetch(rpcUrl, {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({
+				jsonrpc: '2.0',
+				id: 1,
+				method: 'getTokenAccountsByOwner',
+				params: [walletAddress, { mint: usdcMint }, { encoding: 'jsonParsed' }],
+			}),
+		});
+		if (!response.ok) return 0;
+		const data = (await response.json()) as {
+			result?: {
+				value?: Array<{
+					account: {
+						data: {
+							parsed: {
+								info: { tokenAmount: { uiAmount: number } };
+							};
+						};
+					};
+				}>;
+			};
+		};
+		let total = 0;
+		for (const acct of data.result?.value ?? []) {
+			total += acct.account.data.parsed.info.tokenAmount.uiAmount ?? 0;
+		}
+		return total;
+	} catch {
+		return 0;
+	}
+}
+
 const USDC_MINT_MAINNET = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';
 const USDC_MINT_DEVNET = '4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU';