@agi-cli/sdk 0.1.141 → 0.1.143

package/README.md

@@ -72,7 +72,7 @@ import {
 } from '@agi-cli/sdk';
 
 // Check available providers
-console.log(providerIds); // ['openai', 'anthropic', 'google', 'openrouter', 'opencode', 'solforge']
+console.log(providerIds); // ['openai', 'anthropic', 'google', 'openrouter', 'opencode', 'setu']
 
 // Get model information
 const models = catalog.anthropic.models;

package/package.json

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

package/src/config/src/index.ts

@@ -25,7 +25,7 @@ const DEFAULTS: {
 		google: { enabled: true },
 		openrouter: { enabled: false },
 		opencode: { enabled: false },
-		solforge: { enabled: false },
+		setu: { enabled: false },
 		zai: { enabled: false },
 		'zai-coding': { enabled: false },
 		moonshot: { enabled: false },

package/src/core/src/providers/resolver.ts

@@ -5,7 +5,7 @@ import { createOpenRouter } from '@openrouter/ai-sdk-provider';
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
 import {
 	catalog,
-	createSolforgeModel,
+	createSetuModel,
 	createOpenAIOAuthModel,
 } from '../../../providers/src/index.ts';
 import type { OAuth } from '../../../types/src/index.ts';
@@ -33,7 +33,7 @@ export type ProviderName =
 	| 'google'
 	| 'openrouter'
 	| 'opencode'
-	| 'solforge'
+	| 'setu'
 	| 'zai'
 	| 'zai-coding'
 	| 'moonshot';
@@ -152,16 +152,16 @@ export async function resolveModel(
 		return ocOpenAI(resolvedModelId);
 	}
 
-	if (provider === 'solforge') {
-		const privateKey = config.apiKey || process.env.SOLFORGE_PRIVATE_KEY || '';
+	if (provider === 'setu') {
+		const privateKey = config.apiKey || process.env.SETU_PRIVATE_KEY || '';
 		if (!privateKey) {
 			throw new Error(
-				'Solforge provider requires SOLFORGE_PRIVATE_KEY (base58 Solana secret).',
+				'Setu provider requires SETU_PRIVATE_KEY (base58 Solana secret).',
 			);
 		}
-		const baseURL = config.baseURL || process.env.SOLFORGE_BASE_URL;
-		const rpcURL = process.env.SOLFORGE_SOLANA_RPC_URL;
-		return createSolforgeModel(
+		const baseURL = config.baseURL || process.env.SETU_BASE_URL;
+		const rpcURL = process.env.SETU_SOLANA_RPC_URL;
+		return createSetuModel(
 			model,
 			{ privateKey },
 			{

package/src/index.ts

@@ -61,16 +61,16 @@ export {
 	setEnvKey,
 } from './providers/src/index.ts';
 export {
-	createSolforgeFetch,
-	createSolforgeModel,
-	fetchSolforgeBalance,
+	createSetuFetch,
+	createSetuModel,
+	fetchSetuBalance,
 	getPublicKeyFromPrivate,
 	fetchSolanaUsdcBalance,
 } from './providers/src/index.ts';
 export type {
-	SolforgeAuth,
-	SolforgeProviderOptions,
-	SolforgeBalanceResponse,
+	SetuAuth,
+	SetuProviderOptions,
+	SetuBalanceResponse,
 	SolanaUsdcBalanceResponse,
 } from './providers/src/index.ts';
 export {

package/src/prompts/src/providers.ts

@@ -62,12 +62,12 @@ export async function providerBasePrompt(
 		}
 	}
 
-	// 2) Provider-family fallback for openrouter/opencode/solforge using embedded defaults
+	// 2) Provider-family fallback for openrouter/opencode/setu using embedded defaults
 	if (
 		isProviderId(id) &&
 		(id === 'openrouter' ||
 			id === 'opencode' ||
-			id === 'solforge' ||
+			id === 'setu' ||
 			id === 'zai' ||
 			id === 'zai-coding') &&
 		modelId

package/src/providers/src/catalog-manual.ts

@@ -6,7 +6,7 @@ import type {
 
 type CatalogMap = Partial<Record<ProviderId, ProviderCatalogEntry>>;
 
-const SOLFORGE_ID: ProviderId = 'solforge';
+const SETU_ID: ProviderId = 'setu';
 
 const isAllowedOpenAIModel = (id: string): boolean => {
 	if (id === 'codex-mini-latest') return true;
@@ -23,7 +23,7 @@ const isAllowedAnthropicModel = (id: string): boolean => {
 	return false;
 };
 
-const SOLFORGE_SOURCES: Array<{ id: ProviderId; npm: string }> = [
+const SETU_SOURCES: Array<{ id: ProviderId; npm: string }> = [
 	{
 		id: 'openai',
 		npm: '@ai-sdk/openai',
@@ -32,6 +32,10 @@ const SOLFORGE_SOURCES: Array<{ id: ProviderId; npm: string }> = [
 		id: 'anthropic',
 		npm: '@ai-sdk/anthropic',
 	},
+	{
+		id: 'moonshot',
+		npm: '@ai-sdk/openai-compatible',
+	},
 ];
 
 function cloneModel(model: ModelInfo): ModelInfo {
@@ -53,8 +57,8 @@ function cloneModel(model: ModelInfo): ModelInfo {
 	};
 }
 
-function buildSolforgeEntry(base: CatalogMap): ProviderCatalogEntry | null {
-	const solforgeModels = SOLFORGE_SOURCES.flatMap(({ id, npm }) => {
+function buildSetuEntry(base: CatalogMap): ProviderCatalogEntry | null {
+	const setuModels = SETU_SOURCES.flatMap(({ id, npm }) => {
 		const allModels = base[id]?.models ?? [];
 		const sourceModels = allModels.filter((model) => {
 			if (id === 'openai') return isAllowedOpenAIModel(model.id);
@@ -68,10 +72,10 @@ function buildSolforgeEntry(base: CatalogMap): ProviderCatalogEntry | null {
 		});
 	});
 
-	if (!solforgeModels.length) return null;
+	if (!setuModels.length) return null;
 
 	// Prefer OpenAI-family models first so defaults are stable
-	solforgeModels.sort((a, b) => {
+	setuModels.sort((a, b) => {
 		const providerA = a.provider?.npm ?? '';
 		const providerB = b.provider?.npm ?? '';
 		if (providerA === providerB) {
@@ -83,31 +87,31 @@ function buildSolforgeEntry(base: CatalogMap): ProviderCatalogEntry | null {
 	});
 
 	const defaultModelId = 'codex-mini-latest';
-	const defaultIdx = solforgeModels.findIndex((m) => m.id === defaultModelId);
+	const defaultIdx = setuModels.findIndex((m) => m.id === defaultModelId);
 	if (defaultIdx > 0) {
-		const [picked] = solforgeModels.splice(defaultIdx, 1);
-		solforgeModels.unshift(picked);
+		const [picked] = setuModels.splice(defaultIdx, 1);
+		setuModels.unshift(picked);
 	}
 
 	return {
-		id: SOLFORGE_ID,
-		label: 'Solforge',
-		env: ['SOLFORGE_PRIVATE_KEY'],
-		api: 'https://router.solforge.sh/v1',
-		doc: 'https://router.solforge.sh/docs',
-		models: solforgeModels,
+		id: SETU_ID,
+		label: 'Setu',
+		env: ['SETU_PRIVATE_KEY'],
+		api: 'https://setu.agi.nitish.sh/v1',
+		doc: 'https://setu.agi.nitish.sh/docs',
+		models: setuModels,
 	};
 }
 
 export function mergeManualCatalog(
 	base: CatalogMap,
 ): Record<ProviderId, ProviderCatalogEntry> {
-	const manualEntry = buildSolforgeEntry(base);
+	const manualEntry = buildSetuEntry(base);
 	const merged: Record<ProviderId, ProviderCatalogEntry> = {
 		...(base as Record<ProviderId, ProviderCatalogEntry>),
 	};
 	if (manualEntry) {
-		merged[SOLFORGE_ID] = manualEntry;
+		merged[SETU_ID] = manualEntry;
 	}
 	return merged;
 }

package/src/providers/src/env.ts

@@ -6,7 +6,7 @@ const ENV_VARS: Record<ProviderId, string> = {
 	google: 'GOOGLE_GENERATIVE_AI_API_KEY',
 	openrouter: 'OPENROUTER_API_KEY',
 	opencode: 'OPENCODE_API_KEY',
-	solforge: 'SOLFORGE_PRIVATE_KEY',
+	setu: 'SETU_PRIVATE_KEY',
 	zai: 'ZAI_API_KEY',
 	'zai-coding': 'ZAI_API_KEY',
 	moonshot: 'MOONSHOT_API_KEY',

package/src/providers/src/index.ts

@@ -24,19 +24,19 @@ export { validateProviderModel } from './validate.ts';
 export { estimateModelCostUsd } from './pricing.ts';
 export { providerEnvVar, readEnvKey, setEnvKey } from './env.ts';
 export {
-	createSolforgeFetch,
-	createSolforgeModel,
-	fetchSolforgeBalance,
+	createSetuFetch,
+	createSetuModel,
+	fetchSetuBalance,
 	getPublicKeyFromPrivate,
 	fetchSolanaUsdcBalance,
-} from './solforge-client.ts';
+} from './setu-client.ts';
 export type {
-	SolforgeAuth,
-	SolforgeProviderOptions,
-	SolforgePaymentCallbacks,
-	SolforgeBalanceResponse,
+	SetuAuth,
+	SetuProviderOptions,
+	SetuPaymentCallbacks,
+	SetuBalanceResponse,
 	SolanaUsdcBalanceResponse,
-} from './solforge-client.ts';
+} from './setu-client.ts';
 export {
 	createOpenAIOAuthFetch,
 	createOpenAIOAuthModel,

package/src/providers/src/pricing.ts

@@ -76,7 +76,7 @@ const pricingTable: Record<ProviderName, PricingEntry[]> = {
 	opencode: [
 		// Pricing from catalog entries; leave empty here
 	],
-	solforge: [
+	setu: [
 		// Pricing from catalog entries; leave empty here
 	],
 	zai: [

package/src/providers/src/{solforge-client.ts → setu-client.ts}

@@ -7,6 +7,7 @@ import { svm } from 'x402/shared';
 import nacl from 'tweetnacl';
 import { createOpenAI } from '@ai-sdk/openai';
 import { createAnthropic } from '@ai-sdk/anthropic';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
 import { addAnthropicCacheControl } from './anthropic-caching.ts';
 
 function simplifyPaymentError(errMsg: string): string {
@@ -37,12 +38,12 @@ function simplifyPaymentError(errMsg: string): string {
 	return short.length < errMsg.length ? `${short}...` : errMsg;
 }
 
-const DEFAULT_BASE_URL = 'https://router.solforge.sh';
+const DEFAULT_BASE_URL = 'https://setu.agi.nitish.sh';
 const DEFAULT_RPC_URL = 'https://api.mainnet-beta.solana.com';
 const DEFAULT_MAX_ATTEMPTS = 3;
 const DEFAULT_MAX_PAYMENT_ATTEMPTS = 20;
 
-export type SolforgePaymentCallbacks = {
+export type SetuPaymentCallbacks = {
 	onPaymentRequired?: (amountUsd: number) => void;
 	onPaymentSigning?: () => void;
 	onPaymentComplete?: (data: {
@@ -53,19 +54,19 @@ export type SolforgePaymentCallbacks = {
 	onPaymentError?: (error: string) => void;
 };
 
-export type SolforgeProviderOptions = {
+export type SetuProviderOptions = {
 	baseURL?: string;
 	rpcURL?: string;
 	network?: string;
 	maxRequestAttempts?: number;
 	maxPaymentAttempts?: number;
-	callbacks?: SolforgePaymentCallbacks;
+	callbacks?: SetuPaymentCallbacks;
 	providerNpm?: string;
 	promptCacheKey?: string;
 	promptCacheRetention?: 'in_memory' | '24h';
 };
 
-export type SolforgeAuth = {
+export type SetuAuth = {
 	privateKey: string;
 };
 
@@ -120,7 +121,7 @@ async function acquirePaymentLock(walletAddress: string): Promise<() => void> {
 	paymentQueues.set(walletAddress, entry);
 
 	if (existing) {
-		console.log('[Solforge] Waiting for pending payment to complete...');
+		console.log('[Setu] Waiting for pending payment to complete...');
 		await existing.promise;
 	}
 
@@ -132,9 +133,9 @@ async function acquirePaymentLock(walletAddress: string): Promise<() => void> {
 	};
 }
 
-export function createSolforgeFetch(
-	auth: SolforgeAuth,
-	options: SolforgeProviderOptions = {},
+export function createSetuFetch(
+	auth: SetuAuth,
+	options: SetuProviderOptions = {},
 ): typeof fetch {
 	const privateKeyBytes = bs58.decode(auth.privateKey);
 	const keypair = Keypair.fromSecretKey(privateKeyBytes);
@@ -196,20 +197,18 @@ export function createSolforgeFetch(
 			const requirement = pickPaymentRequirement(payload);
 			if (!requirement) {
 				callbacks.onPaymentError?.('Unsupported payment requirement');
-				throw new Error('Solforge: unsupported payment requirement');
+				throw new Error('Setu: unsupported payment requirement');
 			}
 			if (attempt >= maxAttempts) {
 				callbacks.onPaymentError?.('Payment failed after multiple attempts');
-				throw new Error('Solforge: payment failed after multiple attempts');
+				throw new Error('Setu: payment failed after multiple attempts');
 			}
 
 			const currentAttempts = globalPaymentAttempts.get(walletAddress) ?? 0;
 			const remainingPayments = maxPaymentAttempts - currentAttempts;
 			if (remainingPayments <= 0) {
 				callbacks.onPaymentError?.('Maximum payment attempts exceeded');
-				throw new Error(
-					'Solforge: payment failed after maximum payment attempts.',
-				);
+				throw new Error('Setu: payment failed after maximum payment attempts.');
 			}
 
 			const releaseLock = await acquirePaymentLock(walletAddress);
@@ -237,43 +236,56 @@ export function createSolforgeFetch(
 			}
 		}
 
-		throw new Error('Solforge: max attempts exceeded');
+		throw new Error('Setu: max attempts exceeded');
 	};
 }
 
 /**
- * Create a Solforge-backed AI model.
+ * Create a Setu-backed AI model.
  *
  * Uses native AI SDK providers:
  * - OpenAI models → /v1/responses (via @ai-sdk/openai)
  * - Anthropic models → /v1/messages (via @ai-sdk/anthropic)
+ * - Moonshot models → /v1/chat/completions (via @ai-sdk/openai-compatible)
  *
  * Provider is determined by options.providerNpm from catalog.
  */
-export function createSolforgeModel(
+export function createSetuModel(
 	model: string,
-	auth: SolforgeAuth,
-	options: SolforgeProviderOptions = {},
+	auth: SetuAuth,
+	options: SetuProviderOptions = {},
 ) {
 	const baseURL = `${trimTrailingSlash(
 		options.baseURL ?? DEFAULT_BASE_URL,
 	)}/v1`;
-	const customFetch = createSolforgeFetch(auth, options);
+	const customFetch = createSetuFetch(auth, options);
 	const providerNpm = options.providerNpm ?? '@ai-sdk/openai';
 
 	if (providerNpm === '@ai-sdk/anthropic') {
 		const anthropic = createAnthropic({
 			baseURL,
-			apiKey: 'solforge-wallet-auth',
+			apiKey: 'setu-wallet-auth',
 			fetch: customFetch,
 		});
 		return anthropic(model);
 	}
 
+	if (providerNpm === '@ai-sdk/openai-compatible') {
+		const compatible = createOpenAICompatible({
+			name: 'setu-moonshot',
+			baseURL,
+			headers: {
+				Authorization: 'Bearer setu-wallet-auth',
+			},
+			fetch: customFetch,
+		});
+		return compatible(model);
+	}
+
 	// Default to OpenAI
 	const openai = createOpenAI({
 		baseURL,
-		apiKey: 'solforge-wallet-auth',
+		apiKey: 'setu-wallet-auth',
 		fetch: customFetch,
 	});
 	return openai.responses(model);
@@ -314,7 +326,7 @@ async function handlePayment(args: {
 	baseFetch: typeof fetch;
 	buildWalletHeaders: () => Record<string, string>;
 	maxAttempts: number;
-	callbacks: SolforgePaymentCallbacks;
+	callbacks: SetuPaymentCallbacks;
 }): Promise<{ attemptsUsed: number }> {
 	let attempts = 0;
 	while (attempts < args.maxAttempts) {
@@ -334,12 +346,10 @@ async function handlePayment(args: {
 			return { attemptsUsed: attempts };
 		}
 		console.log(
-			`Solforge balance still negative (${balanceValue.toFixed(8)}). Sending another top-up...`,
+			`Setu balance still negative (${balanceValue.toFixed(8)}). Sending another top-up...`,
 		);
 	}
-	throw new Error(
-		`Solforge: payment failed after ${attempts} additional top-ups.`,
-	);
+	throw new Error(`Setu: payment failed after ${attempts} additional top-ups.`);
 }
 
 async function processSinglePayment(args: {
@@ -349,7 +359,7 @@ async function processSinglePayment(args: {
 	baseURL: string;
 	baseFetch: typeof fetch;
 	buildWalletHeaders: () => Record<string, string>;
-	callbacks: SolforgePaymentCallbacks;
+	callbacks: SetuPaymentCallbacks;
 }): Promise<{ attempts: number; balance?: number | string }> {
 	args.callbacks.onPaymentSigning?.();
 
@@ -360,7 +370,7 @@ async function processSinglePayment(args: {
 		const errMsg = err instanceof Error ? err.message : String(err);
 		const userMsg = `Payment failed: ${simplifyPaymentError(errMsg)}`;
 		args.callbacks.onPaymentError?.(userMsg);
-		throw new Error(`Solforge: ${userMsg}`);
+		throw new Error(`Setu: ${userMsg}`);
 	}
 	const walletHeaders = args.buildWalletHeaders();
 	const headers = {
@@ -382,11 +392,11 @@ async function processSinglePayment(args: {
 			response.status === 400 &&
 			rawBody.toLowerCase().includes('already processed')
 		) {
-			console.log('Solforge payment already processed; continuing.');
+			console.log('Setu payment already processed; continuing.');
 			return { attempts: 1 };
 		}
 		args.callbacks.onPaymentError?.(`Topup failed: ${response.status}`);
-		throw new Error(`Solforge topup failed (${response.status}): ${rawBody}`);
+		throw new Error(`Setu topup failed (${response.status}): ${rawBody}`);
 	}
 
 	let parsed: PaymentResponse | undefined;
@@ -411,11 +421,11 @@ async function processSinglePayment(args: {
 			transactionId: parsed.transaction,
 		});
 		console.log(
-			`Solforge payment complete: +$${amountUsd} (balance: $${newBalance})`,
+			`Setu payment complete: +$${amountUsd} (balance: $${newBalance})`,
 		);
 		return { attempts: 1, balance: newBalance };
 	}
-	console.log('Solforge payment complete.');
+	console.log('Setu payment complete.');
 	return { attempts: 1 };
 }
 
@@ -452,7 +462,7 @@ async function createPaymentPayload(args: {
 	} as PaymentPayload;
 }
 
-export type SolforgeBalanceResponse = {
+export type SetuBalanceResponse = {
 	walletAddress: string;
 	balance: number;
 	totalSpent: number;
@@ -462,10 +472,10 @@ export type SolforgeBalanceResponse = {
 	lastRequest?: string;
 };
 
-export async function fetchSolforgeBalance(
-	auth: SolforgeAuth,
+export async function fetchSetuBalance(
+	auth: SetuAuth,
 	baseURL?: string,
-): Promise<SolforgeBalanceResponse | null> {
+): Promise<SetuBalanceResponse | null> {
 	try {
 		const privateKeyBytes = bs58.decode(auth.privateKey);
 		const keypair = Keypair.fromSecretKey(privateKeyBytes);
@@ -531,7 +541,7 @@ export type SolanaUsdcBalanceResponse = {
 };
 
 export async function fetchSolanaUsdcBalance(
-	auth: SolforgeAuth,
+	auth: SetuAuth,
 	network: 'mainnet' | 'devnet' = 'mainnet',
 ): Promise<SolanaUsdcBalanceResponse | null> {
 	try {

package/src/providers/src/utils.ts

@@ -42,7 +42,7 @@ const PREFERRED_FAST_MODELS: Partial<Record<ProviderId, string[]>> = {
 		'google/gemini-2.0-flash-001',
 	],
 	opencode: ['claude-3-5-haiku', 'gpt-5-nano', 'gemini-3-flash'],
-	solforge: [
+	setu: [
 		'claude-3-5-haiku-latest',
 		'claude-3-5-haiku-20241022',
 		'codex-mini-latest',

package/src/types/src/provider.ts

@@ -7,7 +7,7 @@ export type ProviderId =
 	| 'google'
 	| 'openrouter'
 	| 'opencode'
-	| 'solforge'
+	| 'setu'
 	| 'zai'
 	| 'zai-coding'
 	| 'moonshot';