@agi-cli/sdk 0.1.99 → 0.1.100

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/sdk",
-	"version": "0.1.99",
+	"version": "0.1.100",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "ntishxyz",
 	"license": "MIT",
@@ -92,12 +92,16 @@
 		"@ai-sdk/openai-compatible": "^1.0.18",
 		"@openauthjs/openauth": "^0.4.3",
 		"@openrouter/ai-sdk-provider": "^1.2.0",
+		"@solana/web3.js": "^1.95.2",
 		"ai": "^5.0.43",
+		"bs58": "^6.0.0",
 		"bun-pty": "^0.3.2",
 		"diff": "^8.0.2",
 		"fast-glob": "^3.3.2",
 		"hono": "^4.9.7",
 		"opencode-anthropic-auth": "^0.0.2",
+		"tweetnacl": "^1.0.3",
+		"x402": "^0.7.1",
 		"zod": "^4.1.8"
 	},
 	"devDependencies": {

package/src/config/src/index.ts

@@ -24,6 +24,7 @@ const DEFAULTS: {
 		google: { enabled: true },
 		openrouter: { enabled: false },
 		opencode: { enabled: false },
+		solforge: { enabled: false },
 	},
 };
 

package/src/config/src/manager.ts

@@ -31,6 +31,7 @@ export async function isAuthorized(
 	const info = auth[provider];
 	if (info?.type === 'api' && info.key) return true;
 	if (info?.type === 'oauth' && info.refresh && info.access) return true;
+	if (info?.type === 'wallet' && info.secret) return true;
 	return false;
 }
 
@@ -42,8 +43,13 @@ export async function ensureEnv(
 	if (readEnvKey(provider)) return;
 	const { auth } = await read(projectRoot);
 	const stored = auth[provider];
-	const key = stored?.type === 'api' ? stored.key : undefined;
-	if (key) setEnvKey(provider, key);
+	const value =
+		stored?.type === 'api'
+			? stored.key
+			: stored?.type === 'wallet'
+				? stored.secret
+				: undefined;
+	if (value) setEnvKey(provider, value);
 }
 
 export async function writeDefaults(

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

@@ -3,14 +3,15 @@ import { anthropic, createAnthropic } from '@ai-sdk/anthropic';
 import { google } from '@ai-sdk/google';
 import { createOpenRouter } from '@openrouter/ai-sdk-provider';
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
-import { catalog } from '../../../providers/src/index.ts';
+import { catalog, createSolforgeModel } from '../../../providers/src/index.ts';
 
 export type ProviderName =
 	| 'openai'
 	| 'anthropic'
 	| 'google'
 	| 'openrouter'
-	| 'opencode';
+	| 'opencode'
+	| 'solforge';
 
 export type ModelConfig = {
 	apiKey?: string;
@@ -110,6 +111,27 @@ export async function resolveModel(
 		return ocOpenAI(resolvedModelId);
 	}
 
+	if (provider === 'solforge') {
+		const privateKey = config.apiKey || process.env.SOLFORGE_PRIVATE_KEY || '';
+		if (!privateKey) {
+			throw new Error(
+				'Solforge provider requires SOLFORGE_PRIVATE_KEY (base58 Solana secret).',
+			);
+		}
+		const baseURL = config.baseURL || process.env.SOLFORGE_BASE_URL;
+		const rpcURL = process.env.SOLFORGE_SOLANA_RPC_URL;
+		const topupAmount = process.env.SOLFORGE_TOPUP_MICRO_USDC;
+		return createSolforgeModel(
+			model,
+			{ privateKey },
+			{
+				baseURL,
+				rpcURL,
+				topupAmountMicroUsdc: topupAmount,
+			},
+		);
+	}
+
 	throw new Error(`Unsupported provider: ${provider}`);
 }
 

package/src/core/src/terminals/manager.ts

@@ -20,8 +20,6 @@ export class TerminalManager {
 	private terminals = new Map<string, Terminal>();
 	private cleanupTimers = new Map<string, NodeJS.Timeout>();
 
-	constructor() {}
-
 	create(options: CreateTerminalOptions): Terminal {
 		if (this.terminals.size >= MAX_TERMINALS) {
 			throw new Error(`Maximum ${MAX_TERMINALS} terminals reached`);

package/src/core/src/tools/builtin/terminal.ts

@@ -186,7 +186,8 @@ export function buildTerminalTool(
 
 						const output = term.read(params.lines);
 						const normalized = output.map(normalizeTerminalLine);
-						const text = normalized.join('\n').replace(/\u0000/g, '');
+						const joined = normalized.join('\n');
+						const text = joined.split(String.fromCharCode(0)).join('');
 
 						const response: {
 							ok: true;

package/src/index.ts

@@ -52,6 +52,14 @@ export {
 	readEnvKey,
 	setEnvKey,
 } from './providers/src/index.ts';
+export {
+	createSolforgeFetch,
+	createSolforgeModel,
+} from './providers/src/index.ts';
+export type {
+	SolforgeAuth,
+	SolforgeProviderOptions,
+} from './providers/src/index.ts';
 
 // =======================
 // Authentication (from internal auth module)

package/src/prompts/src/providers.ts

@@ -64,8 +64,11 @@ export async function providerBasePrompt(
 		}
 	}
 
-	// 2) Provider-family fallback for openrouter/opencode using embedded defaults
-	if ((id === 'openrouter' || id === 'opencode') && modelId) {
+	// 2) Provider-family fallback for openrouter/opencode/solforge using embedded defaults
+	if (
+		(id === 'openrouter' || id === 'opencode' || id === 'solforge') &&
+		modelId
+	) {
 		const family = inferFamilyFromModel(modelId);
 		if (family) {
 			const embedded = (

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

@@ -0,0 +1,83 @@
+import type {
+	ModelInfo,
+	ProviderCatalogEntry,
+	ProviderId,
+} from '../../types/src/index.ts';
+
+type CatalogMap = Partial<Record<ProviderId, ProviderCatalogEntry>>;
+
+const SOLFORGE_ID: ProviderId = 'solforge';
+const ACCEPTED_BINDINGS = new Set(['@ai-sdk/openai', '@ai-sdk/anthropic']);
+
+function cloneModel(model: ModelInfo): ModelInfo {
+	return {
+		...model,
+		modalities: model.modalities
+			? {
+					input: model.modalities.input
+						? [...model.modalities.input]
+						: undefined,
+					output: model.modalities.output
+						? [...model.modalities.output]
+						: undefined,
+				}
+			: undefined,
+		cost: model.cost ? { ...model.cost } : undefined,
+		limit: model.limit ? { ...model.limit } : undefined,
+		provider: model.provider ? { ...model.provider } : undefined,
+	};
+}
+
+function buildSolforgeEntry(base: CatalogMap): ProviderCatalogEntry | null {
+	const opencodeModels = base.opencode?.models ?? [];
+	const solforgeModels = opencodeModels
+		.filter((model) => {
+			const npm = model.provider?.npm;
+			return npm != null && ACCEPTED_BINDINGS.has(npm);
+		})
+		.map(cloneModel);
+
+	if (!solforgeModels.length) return null;
+
+	// Prefer OpenAI-family models first so defaults are stable
+	solforgeModels.sort((a, b) => {
+		const providerA = a.provider?.npm ?? '';
+		const providerB = b.provider?.npm ?? '';
+		if (providerA === providerB) {
+			return a.id.localeCompare(b.id);
+		}
+		if (providerA === '@ai-sdk/openai') return -1;
+		if (providerB === '@ai-sdk/openai') return 1;
+		return providerA.localeCompare(providerB);
+	});
+
+	const defaultModelId = 'gpt-4o-mini';
+	const defaultIdx = solforgeModels.findIndex((m) => m.id === defaultModelId);
+	if (defaultIdx > 0) {
+		const [picked] = solforgeModels.splice(defaultIdx, 1);
+		solforgeModels.unshift(picked);
+	}
+
+	return {
+		id: SOLFORGE_ID,
+		label: 'Solforge',
+		env: ['SOLFORGE_PRIVATE_KEY'],
+		api: 'https://ai.solforge.sh/v1',
+		doc: 'https://ai.solforge.sh/docs',
+		npm: '@ai-sdk/openai-compatible',
+		models: solforgeModels,
+	};
+}
+
+export function mergeManualCatalog(
+	base: CatalogMap,
+): Record<ProviderId, ProviderCatalogEntry> {
+	const manualEntry = buildSolforgeEntry(base);
+	const merged: Record<ProviderId, ProviderCatalogEntry> = {
+		...(base as Record<ProviderId, ProviderCatalogEntry>),
+	};
+	if (manualEntry) {
+		merged[SOLFORGE_ID] = manualEntry;
+	}
+	return merged;
+}

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

@@ -0,0 +1,9 @@
+import type {
+	ProviderCatalogEntry,
+	ProviderId,
+} from '../../types/src/index.ts';
+import { catalog as generatedCatalog } from './catalog.ts';
+import { mergeManualCatalog } from './catalog-manual.ts';
+
+export const catalog: Record<ProviderId, ProviderCatalogEntry> =
+	mergeManualCatalog(generatedCatalog);

package/src/providers/src/catalog.ts

@@ -4598,4 +4598,4 @@ export const catalog: Record<ProviderId, ProviderCatalogEntry> = {
 		api: 'https://opencode.ai/zen/v1',
 		doc: 'https://opencode.ai/docs/zen',
 	},
-} as const satisfies Record<ProviderId, ProviderCatalogEntry>;
+} as const satisfies Partial<Record<ProviderId, ProviderCatalogEntry>>;

package/src/providers/src/env.ts

@@ -6,6 +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',
 };
 
 export function providerEnvVar(provider: ProviderId): string {

package/src/providers/src/index.ts

@@ -1,5 +1,5 @@
 export { isProviderAuthorized, ensureProviderEnv } from './authorization.ts';
-export { catalog } from './catalog.ts';
+export { catalog } from './catalog-merged.ts';
 export type {
 	ProviderId,
 	ModelInfo,
@@ -15,3 +15,11 @@ export {
 export { validateProviderModel } from './validate.ts';
 export { estimateModelCostUsd } from './pricing.ts';
 export { providerEnvVar, readEnvKey, setEnvKey } from './env.ts';
+export {
+	createSolforgeFetch,
+	createSolforgeModel,
+} from './solforge-client.ts';
+export type {
+	SolforgeAuth,
+	SolforgeProviderOptions,
+} from './solforge-client.ts';

package/src/providers/src/pricing.ts

@@ -1,4 +1,4 @@
-import { catalog } from './catalog.ts';
+import { catalog } from './catalog-merged.ts';
 import type { ModelInfo, ProviderId } from '../../types/src/index.ts';
 
 type ProviderName = ProviderId;

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

@@ -0,0 +1,305 @@
+import { Buffer } from 'node:buffer';
+import { Keypair } from '@solana/web3.js';
+import bs58 from 'bs58';
+import { createPaymentHeader } from 'x402/client';
+import type { PaymentRequirements } from 'x402/types';
+import { svm } from 'x402/shared';
+import nacl from 'tweetnacl';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+
+const DEFAULT_BASE_URL = 'http://localhost:4000';
+const DEFAULT_RPC_URL = 'https://api.devnet.solana.com';
+const DEFAULT_TOPUP_AMOUNT = '100000'; // $0.10
+const DEFAULT_MAX_ATTEMPTS = 3;
+const DEFAULT_MAX_PAYMENT_ATTEMPTS = 20;
+
+export type SolforgeProviderOptions = {
+	baseURL?: string;
+	rpcURL?: string;
+	network?: string;
+	topupAmountMicroUsdc?: string;
+	maxRequestAttempts?: number;
+	maxPaymentAttempts?: number;
+};
+
+export type SolforgeAuth = {
+	privateKey: string;
+};
+
+type ExactPaymentRequirement = {
+	scheme: 'exact';
+	network: string;
+	maxAmountRequired: string;
+	asset: string;
+	payTo: string;
+	description?: string;
+	resource?: string;
+	extra?: Record<string, unknown>;
+	maxTimeoutSeconds?: number;
+};
+
+type PaymentPayload = {
+	x402Version: 1;
+	scheme: 'exact';
+	network: string;
+	payload: { transaction: string };
+};
+
+type PaymentResponse = {
+	amount_usd: number;
+	new_balance: number;
+};
+
+export function createSolforgeFetch(
+	auth: SolforgeAuth,
+	options: SolforgeProviderOptions = {},
+): typeof fetch {
+	const privateKeyBytes = bs58.decode(auth.privateKey);
+	const keypair = Keypair.fromSecretKey(privateKeyBytes);
+	const walletAddress = keypair.publicKey.toBase58();
+	const baseURL = trimTrailingSlash(options.baseURL ?? DEFAULT_BASE_URL);
+	const rpcURL = options.rpcURL ?? DEFAULT_RPC_URL;
+	const targetTopup = options.topupAmountMicroUsdc ?? DEFAULT_TOPUP_AMOUNT;
+	const maxAttempts = options.maxRequestAttempts ?? DEFAULT_MAX_ATTEMPTS;
+	const maxPaymentAttempts =
+		options.maxPaymentAttempts ?? DEFAULT_MAX_PAYMENT_ATTEMPTS;
+
+	const baseFetch = globalThis.fetch.bind(globalThis);
+	let paymentAttempts = 0;
+
+	const buildWalletHeaders = () => {
+		const nonce = Date.now().toString();
+		const signature = signNonce(nonce, privateKeyBytes);
+		return {
+			'x-wallet-address': walletAddress,
+			'x-wallet-nonce': nonce,
+			'x-wallet-signature': signature,
+		};
+	};
+
+	return async (
+		input: Parameters<typeof fetch>[0],
+		init?: Parameters<typeof fetch>[1],
+	) => {
+		let attempt = 0;
+
+		while (attempt < maxAttempts) {
+			attempt++;
+			const headers = new Headers(init?.headers);
+			const walletHeaders = buildWalletHeaders();
+			headers.set('x-wallet-address', walletHeaders['x-wallet-address']);
+			headers.set('x-wallet-nonce', walletHeaders['x-wallet-nonce']);
+			headers.set('x-wallet-signature', walletHeaders['x-wallet-signature']);
+			const response = await baseFetch(input, { ...init, headers });
+
+			if (response.status !== 402) {
+				return response;
+			}
+
+			const payload = await response.json().catch(() => ({}));
+			const requirement = pickPaymentRequirement(payload, targetTopup);
+			if (!requirement) {
+				throw new Error('Solforge: unsupported payment requirement');
+			}
+			if (attempt >= maxAttempts) {
+				throw new Error('Solforge: payment failed after multiple attempts');
+			}
+
+			const remainingPayments = maxPaymentAttempts - paymentAttempts;
+			if (remainingPayments <= 0) {
+				throw new Error(
+					'Solforge: payment failed after maximum payment attempts.',
+				);
+			}
+
+			const outcome = await handlePayment({
+				requirement,
+				keypair,
+				rpcURL,
+				baseURL,
+				baseFetch,
+				buildWalletHeaders,
+				maxAttempts: remainingPayments,
+			});
+			paymentAttempts += outcome.attemptsUsed;
+		}
+
+		throw new Error('Solforge: max attempts exceeded');
+	};
+}
+
+export function createSolforgeModel(
+	model: string,
+	auth: SolforgeAuth,
+	options: SolforgeProviderOptions = {},
+) {
+	const baseURL = `${trimTrailingSlash(
+		options.baseURL ?? DEFAULT_BASE_URL,
+	)}/v1`;
+	const fetch = createSolforgeFetch(auth, options);
+	const provider = createOpenAICompatible({
+		name: 'solforge',
+		baseURL,
+		headers: { 'Content-Type': 'application/json' },
+		fetch,
+	});
+	return provider(model);
+}
+
+function trimTrailingSlash(url: string) {
+	return url.endsWith('/') ? url.slice(0, -1) : url;
+}
+
+function signNonce(nonce: string, secretKey: Uint8Array): string {
+	const data = new TextEncoder().encode(nonce);
+	const signature = nacl.sign.detached(data, secretKey);
+	return bs58.encode(signature);
+}
+
+type PaymentRequirementResponse = {
+	accepts?: unknown;
+};
+
+function pickPaymentRequirement(
+	payload: unknown,
+	targetAmount: string,
+): ExactPaymentRequirement | null {
+	const acceptsValue =
+		typeof payload === 'object' && payload !== null
+			? (payload as PaymentRequirementResponse).accepts
+			: undefined;
+	const accepts = Array.isArray(acceptsValue)
+		? (acceptsValue as ExactPaymentRequirement[])
+		: [];
+	const exactMatch = accepts.find(
+		(option) =>
+			option &&
+			option.scheme === 'exact' &&
+			option.maxAmountRequired === targetAmount,
+	);
+	if (exactMatch) return exactMatch;
+	const fallback = accepts.find(
+		(option) => option && option.scheme === 'exact',
+	);
+	return fallback ?? null;
+}
+
+async function handlePayment(args: {
+	requirement: ExactPaymentRequirement;
+	keypair: Keypair;
+	rpcURL: string;
+	baseURL: string;
+	baseFetch: typeof fetch;
+	buildWalletHeaders: () => Record<string, string>;
+	maxAttempts: number;
+}): Promise<{ attemptsUsed: number }> {
+	let attempts = 0;
+	while (attempts < args.maxAttempts) {
+		const result = await processSinglePayment(args);
+		attempts += result.attempts;
+		const balanceValue =
+			typeof result.balance === 'number'
+				? result.balance
+				: result.balance != null
+					? Number(result.balance)
+					: undefined;
+		if (
+			balanceValue == null ||
+			Number.isNaN(balanceValue) ||
+			balanceValue >= 0
+		) {
+			return { attemptsUsed: attempts };
+		}
+		console.log(
+			`Solforge balance still negative (${balanceValue.toFixed(8)}). Sending another top-up...`,
+		);
+	}
+	throw new Error(
+		`Solforge: payment failed after ${attempts} additional top-ups.`,
+	);
+}
+
+async function processSinglePayment(args: {
+	requirement: ExactPaymentRequirement;
+	keypair: Keypair;
+	rpcURL: string;
+	baseURL: string;
+	baseFetch: typeof fetch;
+	buildWalletHeaders: () => Record<string, string>;
+}): Promise<{ attempts: number; balance?: number | string }> {
+	const paymentPayload = await createPaymentPayload(args);
+	const walletHeaders = args.buildWalletHeaders();
+	const headers = {
+		'Content-Type': 'application/json',
+		...walletHeaders,
+	};
+	const response = await args.baseFetch(`${args.baseURL}/v1/topup`, {
+		method: 'POST',
+		headers,
+		body: JSON.stringify({
+			paymentPayload,
+			paymentRequirement: args.requirement,
+		}),
+	});
+
+	const rawBody = await response.text().catch(() => '');
+	if (!response.ok) {
+		if (
+			response.status === 400 &&
+			rawBody.toLowerCase().includes('already processed')
+		) {
+			console.log('Solforge payment already processed; continuing.');
+			return { attempts: 1 };
+		}
+		throw new Error(`Solforge topup failed (${response.status}): ${rawBody}`);
+	}
+
+	let parsed: PaymentResponse | undefined;
+	try {
+		parsed = rawBody ? (JSON.parse(rawBody) as PaymentResponse) : undefined;
+	} catch {
+		parsed = undefined;
+	}
+
+	if (parsed) {
+		console.log(
+			`Solforge payment complete: +$${parsed.amount_usd ?? 0} (balance: $${parsed.new_balance ?? 0})`,
+		);
+		return { attempts: 1, balance: parsed.new_balance };
+	}
+	console.log('Solforge payment complete.');
+	return { attempts: 1 };
+}
+
+async function createPaymentPayload(args: {
+	requirement: ExactPaymentRequirement;
+	keypair: Keypair;
+	rpcURL: string;
+}) {
+	const privateKeyBase58 = bs58.encode(args.keypair.secretKey);
+	const signer = await svm.createSignerFromBase58(privateKeyBase58);
+	const header = await createPaymentHeader(
+		signer,
+		1,
+		args.requirement as PaymentRequirements,
+		{
+			svmConfig: {
+				rpcUrl: args.rpcURL,
+			},
+		},
+	);
+	const decoded = JSON.parse(
+		Buffer.from(header, 'base64').toString('utf-8'),
+	) as {
+		payload: { transaction: string };
+	};
+
+	return {
+		x402Version: 1,
+		scheme: 'exact',
+		network: args.requirement.network,
+		payload: {
+			transaction: decoded.payload.transaction,
+		},
+	} as PaymentPayload;
+}

package/src/providers/src/utils.ts

@@ -1,4 +1,4 @@
-import { catalog } from './catalog.ts';
+import { catalog } from './catalog-merged.ts';
 import type { ProviderId } from '../../types/src/index.ts';
 
 export const providerIds = Object.keys(catalog) as ProviderId[];

package/src/providers/src/validate.ts

@@ -1,4 +1,4 @@
-import { catalog } from './catalog.ts';
+import { catalog } from './catalog-merged.ts';
 import type { ProviderId } from '../../types/src/index.ts';
 
 export type CapabilityRequest = {

package/src/types/src/auth.ts

@@ -5,6 +5,11 @@ import type { ProviderId } from './provider';
  */
 export type ApiAuth = { type: 'api'; key: string };
 
+/**
+ * Wallet/private-key authentication
+ */
+export type WalletAuth = { type: 'wallet'; secret: string };
+
 /**
  * OAuth authentication tokens
  */
@@ -18,7 +23,7 @@ export type OAuth = {
 /**
  * Union of all auth types
  */
-export type AuthInfo = ApiAuth | OAuth;
+export type AuthInfo = ApiAuth | OAuth | WalletAuth;
 
 /**
  * Collection of auth credentials per provider

package/src/types/src/provider.ts

@@ -6,7 +6,8 @@ export type ProviderId =
 	| 'anthropic'
 	| 'google'
 	| 'openrouter'
-	| 'opencode';
+	| 'opencode'
+	| 'solforge';
 
 export type ModelProviderBinding = {
 	id?: string;