@agi-cli/sdk 0.1.99 → 0.1.101

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/sdk",
-	"version": "0.1.99",
+	"version": "0.1.101",
 	"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,93 @@
+import type {
+	ModelInfo,
+	ProviderCatalogEntry,
+	ProviderId,
+} from '../../types/src/index.ts';
+
+type CatalogMap = Partial<Record<ProviderId, ProviderCatalogEntry>>;
+
+const SOLFORGE_ID: ProviderId = 'solforge';
+const SOLFORGE_SOURCES: Array<{ id: ProviderId; npm: string }> = [
+	{
+		id: 'openai',
+		npm: '@ai-sdk/openai',
+	},
+	{
+		id: 'anthropic',
+		npm: '@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 solforgeModels = SOLFORGE_SOURCES.flatMap(({ id, npm }) => {
+		const sourceModels = base[id]?.models ?? [];
+		return sourceModels.map((model) => {
+			const cloned = cloneModel(model);
+			cloned.provider = { ...(cloned.provider ?? {}), npm };
+			return cloned;
+		});
+	});
+
+	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);