@ottocode/ai-sdk 0.1.4 → 0.1.6

package/src/setu.ts

@@ -1,5 +1,14 @@
-import type { SetuConfig, ProviderId, ProviderApiFormat, FetchFunction, BalanceResponse, WalletUsdcBalance } from './types.ts';
-import { createWalletContext, getPublicKeyFromPrivate } from './auth.ts';
+import type {
+	SetuConfig,
+	ProviderId,
+	ProviderApiFormat,
+	FetchFunction,
+	BalanceResponse,
+	WalletUsdcBalance,
+	SetuAuth,
+} from './types.ts';
+import { createWalletContext } from './auth.ts';
+import type { WalletContext } from './auth.ts';
 import { createSetuFetch } from './fetch.ts';
 import { ProviderRegistry } from './providers/registry.ts';
 import { createModel } from './providers/factory.ts';
@@ -8,86 +17,121 @@ import { fetchBalance, fetchWalletUsdcBalance } from './balance.ts';
 const DEFAULT_BASE_URL = 'https://api.setu.ottocode.io';
 
 function trimTrailingSlash(url: string) {
-  return url.endsWith('/') ? url.slice(0, -1) : url;
+	return url.endsWith('/') ? url.slice(0, -1) : url;
 }
 
 export interface SetuProvider {
-  model(modelId: string): ReturnType<typeof createModel>;
+	model(modelId: string): ReturnType<typeof createModel>;
 }
 
 export interface SetuInstance {
-  model(modelId: string): ReturnType<typeof createModel>;
-  provider(providerId: ProviderId, apiFormat?: ProviderApiFormat): SetuProvider;
-  fetch(): FetchFunction;
-  balance(): Promise<BalanceResponse | null>;
-  walletBalance(network?: 'mainnet' | 'devnet'): Promise<WalletUsdcBalance | null>;
-  walletAddress: string | null;
-  registry: ProviderRegistry;
+	model(modelId: string): ReturnType<typeof createModel>;
+	provider(providerId: ProviderId, apiFormat?: ProviderApiFormat): SetuProvider;
+	fetch(): FetchFunction;
+	balance(): Promise<BalanceResponse | null>;
+	walletBalance(
+		network?: 'mainnet' | 'devnet',
+	): Promise<WalletUsdcBalance | null>;
+	walletAddress: string | null;
+	registry: ProviderRegistry;
+}
+
+function resolveAuth(auth: SetuAuth): {
+	auth: SetuAuth;
+	wallet: WalletContext;
+} {
+	if (auth.signer) {
+		return { auth, wallet: createWalletContext(auth) };
+	}
+
+	const privateKey = auth.privateKey || process.env.SETU_PRIVATE_KEY;
+	if (!privateKey) {
+		throw new Error(
+			'Setu: either privateKey (or SETU_PRIVATE_KEY env) or signer is required.',
+		);
+	}
+	const resolvedAuth = { ...auth, privateKey };
+	return { auth: resolvedAuth, wallet: createWalletContext(resolvedAuth) };
 }
 
 export function createSetu(config: SetuConfig): SetuInstance {
-  const baseURL = trimTrailingSlash(config.baseURL ?? DEFAULT_BASE_URL);
-  const privateKey = config.auth.privateKey || process.env.SETU_PRIVATE_KEY;
-  if (!privateKey) {
-    throw new Error('Setu: privateKey is required. Pass it via config.auth.privateKey or set SETU_PRIVATE_KEY env variable.');
-  }
-  const resolvedAuth = { ...config.auth, privateKey };
-  const wallet = createWalletContext(resolvedAuth);
-  const registry = new ProviderRegistry(config.providers, config.modelMap);
-
-  const setuFetch = createSetuFetch({
-    wallet,
-    baseURL,
-    rpcURL: config.rpcURL,
-    callbacks: config.callbacks,
-    cache: config.cache,
-    payment: config.payment,
-  });
-
-  const modelBaseURL = `${baseURL}/v1`;
-
-  return {
-    model(modelId: string) {
-      const resolved = registry.resolve(modelId);
-      if (!resolved) {
-        throw new Error(
-          `Setu: unknown model "${modelId}". Register it via providers or modelMap config.`,
-        );
-      }
-      return createModel(
-        modelId,
-        resolved.apiFormat,
-        resolved.providerId,
-        modelBaseURL,
-        setuFetch,
-        config.middleware,
-      );
-    },
-
-    provider(providerId: ProviderId, apiFormat?: ProviderApiFormat): SetuProvider {
-      return {
-        model(modelId: string) {
-          const resolved = registry.resolve(modelId);
-          const format = apiFormat ?? resolved?.apiFormat ?? 'openai-chat';
-          return createModel(modelId, format, providerId, modelBaseURL, setuFetch, config.middleware);
-        },
-      };
-    },
-
-    fetch(): FetchFunction {
-      return setuFetch;
-    },
-
-    async balance() {
-      return fetchBalance(resolvedAuth, baseURL);
-    },
-
-    async walletBalance(network?: 'mainnet' | 'devnet') {
-      return fetchWalletUsdcBalance(resolvedAuth, network);
-    },
-
-    walletAddress: getPublicKeyFromPrivate(resolvedAuth.privateKey),
-
-    registry,
-  };
+	const baseURL = trimTrailingSlash(config.baseURL ?? DEFAULT_BASE_URL);
+	const { auth: resolvedAuth, wallet } = resolveAuth(config.auth);
+	const registry = new ProviderRegistry(config.providers, config.modelMap);
+
+	const setuFetch = createSetuFetch({
+		wallet,
+		baseURL,
+		rpcURL: config.rpcURL,
+		callbacks: config.callbacks,
+		cache: config.cache,
+		payment: config.payment,
+	});
+
+	const modelBaseURL = `${baseURL}/v1`;
+
+	return {
+		model(modelId: string) {
+			const resolved = registry.resolve(modelId);
+			if (!resolved) {
+				throw new Error(
+					`Setu: unknown model "${modelId}". Register it via providers or modelMap config.`,
+				);
+			}
+			return createModel(
+				modelId,
+				resolved.apiFormat,
+				resolved.providerId,
+				modelBaseURL,
+				setuFetch,
+				config.middleware,
+			);
+		},
+
+		provider(
+			providerId: ProviderId,
+			apiFormat?: ProviderApiFormat,
+		): SetuProvider {
+			return {
+				model(modelId: string) {
+					const resolved = registry.resolve(modelId);
+					const format = apiFormat ?? resolved?.apiFormat ?? 'openai-chat';
+					return createModel(
+						modelId,
+						format,
+						providerId,
+						modelBaseURL,
+						setuFetch,
+						config.middleware,
+					);
+				},
+			};
+		},
+
+		fetch(): FetchFunction {
+			return setuFetch;
+		},
+
+		async balance() {
+			return fetchBalance(wallet, baseURL);
+		},
+
+		async walletBalance(network?: 'mainnet' | 'devnet') {
+			const walletAddr = wallet.walletAddress;
+			if (!resolvedAuth.privateKey && !walletAddr) {
+				return null;
+			}
+			if (resolvedAuth.privateKey) {
+				return fetchWalletUsdcBalance(
+					resolvedAuth as Required<Pick<SetuAuth, 'privateKey'>>,
+					network,
+				);
+			}
+			return fetchWalletUsdcBalance({ walletAddress: walletAddr }, network);
+		},
+
+		walletAddress: wallet.walletAddress,
+
+		registry,
+	};
 }

package/src/types.ts

@@ -1,50 +1,64 @@
 import type { LanguageModelV3Middleware } from '@ai-sdk/provider';
 
 export type ProviderId =
-  | 'openai'
-  | 'anthropic'
-  | 'google'
-  | 'moonshot'
-  | 'zai'
-  | 'minimax'
-  | (string & {});
-
-export type ProviderApiFormat = 'openai-responses' | 'anthropic-messages' | 'openai-chat' | 'google-native';
-
-export type FetchFunction = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+	| 'openai'
+	| 'anthropic'
+	| 'google'
+	| 'moonshot'
+	| 'zai'
+	| 'minimax'
+	| (string & {});
+
+export type ProviderApiFormat =
+	| 'openai-responses'
+	| 'anthropic-messages'
+	| 'openai-chat'
+	| 'google-native';
+
+export type FetchFunction = (
+	input: string | URL | Request,
+	init?: RequestInit,
+) => Promise<Response>;
 
 export interface ProviderConfig {
-  id: ProviderId;
-  apiFormat: ProviderApiFormat;
-  models?: string[];
-  modelPrefix?: string;
+	id: ProviderId;
+	apiFormat: ProviderApiFormat;
+	models?: string[];
+	modelPrefix?: string;
+}
+
+export interface ExternalSigner {
+	walletAddress: string;
+	signNonce: (nonce: string) => Promise<string> | string;
+	signTransaction?: (transaction: Uint8Array) => Promise<Uint8Array>;
 }
 
 export interface SetuAuth {
-  privateKey?: string;
+	privateKey?: string;
+	signer?: ExternalSigner;
 }
 
 export interface BalanceUpdate {
-  costUsd: number;
-  balanceRemaining: number;
-  inputTokens?: number;
-  outputTokens?: number;
+	costUsd: number;
+	balanceRemaining: number;
+	inputTokens?: number;
+	outputTokens?: number;
 }
 
 export interface PaymentCallbacks {
-  onPaymentRequired?: (amountUsd: number, currentBalance?: number) => void;
-  onPaymentSigning?: () => void;
-  onPaymentComplete?: (data: {
-    amountUsd: number;
-    newBalance: number;
-    transactionId?: string;
-  }) => void;
-  onPaymentError?: (error: string) => void;
-  onPaymentApproval?: (info: {
-    amountUsd: number;
-    currentBalance: number;
-  }) => Promise<'crypto' | 'fiat' | 'cancel'>;
-  onBalanceUpdate?: (update: BalanceUpdate) => void;
+	onPaymentRequired?: (amountUsd: number, currentBalance?: number) => void;
+	onPaymentSigning?: () => void;
+	onPaymentComplete?: (data: {
+		amountUsd: number;
+		newBalance: number;
+		transactionId?: string;
+	}) => void;
+	onPaymentError?: (error: string) => void;
+	onPaymentApproval?: (info: {
+		amountUsd: number;
+		currentBalance: number;
+	}) => Promise<'crypto' | 'fiat' | 'cancel'>;
+	onBalanceUpdate?: (update: BalanceUpdate) => void;
 }
 
 export type AnthropicCacheStrategy = 'auto' | 'manual' | 'custom' | false;
@@ -52,71 +66,71 @@ export type AnthropicCacheStrategy = 'auto' | 'manual' | 'custom' | false;
 export type AnthropicCachePlacement = 'first' | 'last' | 'all';
 
 export interface AnthropicCacheConfig {
-  strategy?: AnthropicCacheStrategy;
-  systemBreakpoints?: number;
-  messageBreakpoints?: number;
-  systemPlacement?: AnthropicCachePlacement;
-  messagePlacement?: AnthropicCachePlacement;
-  cacheType?: 'ephemeral';
-  transform?: (body: Record<string, unknown>) => Record<string, unknown>;
+	strategy?: AnthropicCacheStrategy;
+	systemBreakpoints?: number;
+	messageBreakpoints?: number;
+	systemPlacement?: AnthropicCachePlacement;
+	messagePlacement?: AnthropicCachePlacement;
+	cacheType?: 'ephemeral';
+	transform?: (body: Record<string, unknown>) => Record<string, unknown>;
 }
 
 export interface CacheOptions {
-  promptCacheKey?: string;
-  promptCacheRetention?: 'in_memory' | '24h';
-  anthropicCaching?: boolean | AnthropicCacheConfig;
+	promptCacheKey?: string;
+	promptCacheRetention?: 'in_memory' | '24h';
+	anthropicCaching?: boolean | AnthropicCacheConfig;
 }
 
 export interface PaymentOptions {
-  topupApprovalMode?: 'auto' | 'approval';
-  autoPayThresholdUsd?: number;
-  maxRequestAttempts?: number;
-  maxPaymentAttempts?: number;
+	topupApprovalMode?: 'auto' | 'approval';
+	autoPayThresholdUsd?: number;
+	maxRequestAttempts?: number;
+	maxPaymentAttempts?: number;
 }
 
 export interface SetuConfig {
-  auth: SetuAuth;
-  baseURL?: string;
-  rpcURL?: string;
-  providers?: ProviderConfig[];
-  modelMap?: Record<string, ProviderId>;
-  callbacks?: PaymentCallbacks;
-  cache?: CacheOptions;
-  payment?: PaymentOptions;
-  middleware?: LanguageModelV3Middleware | LanguageModelV3Middleware[];
+	auth: SetuAuth;
+	baseURL?: string;
+	rpcURL?: string;
+	providers?: ProviderConfig[];
+	modelMap?: Record<string, ProviderId>;
+	callbacks?: PaymentCallbacks;
+	cache?: CacheOptions;
+	payment?: PaymentOptions;
+	middleware?: LanguageModelV3Middleware | LanguageModelV3Middleware[];
 }
 
 export interface ExactPaymentRequirement {
-  scheme: 'exact';
-  network: string;
-  maxAmountRequired: string;
-  asset: string;
-  payTo: string;
-  description?: string;
-  resource?: string;
-  extra?: Record<string, unknown>;
-  maxTimeoutSeconds?: number;
+	scheme: 'exact';
+	network: string;
+	maxAmountRequired: string;
+	asset: string;
+	payTo: string;
+	description?: string;
+	resource?: string;
+	extra?: Record<string, unknown>;
+	maxTimeoutSeconds?: number;
 }
 
 export interface PaymentPayload {
-  x402Version: 1;
-  scheme: 'exact';
-  network: string;
-  payload: { transaction: string };
+	x402Version: 1;
+	scheme: 'exact';
+	network: string;
+	payload: { transaction: string };
 }
 
 export interface BalanceResponse {
-  walletAddress: string;
-  balance: number;
-  totalSpent: number;
-  totalTopups: number;
-  requestCount: number;
-  createdAt?: string;
-  lastRequest?: string;
+	walletAddress: string;
+	balance: number;
+	totalSpent: number;
+	totalTopups: number;
+	requestCount: number;
+	createdAt?: string;
+	lastRequest?: string;
 }
 
 export interface WalletUsdcBalance {
-  walletAddress: string;
-  usdcBalance: number;
-  network: 'mainnet' | 'devnet';
+	walletAddress: string;
+	usdcBalance: number;
+	network: 'mainnet' | 'devnet';
 }

package/src/wallet.ts

@@ -2,33 +2,33 @@ import { Keypair } from '@solana/web3.js';
 import bs58 from 'bs58';
 
 export interface WalletInfo {
-  publicKey: string;
-  privateKey: string;
+	publicKey: string;
+	privateKey: string;
 }
 
 export function generateWallet(): WalletInfo {
-  const keypair = Keypair.generate();
-  return {
-    privateKey: bs58.encode(keypair.secretKey),
-    publicKey: keypair.publicKey.toBase58(),
-  };
+	const keypair = Keypair.generate();
+	return {
+		privateKey: bs58.encode(keypair.secretKey),
+		publicKey: keypair.publicKey.toBase58(),
+	};
 }
 
 export function importWallet(privateKey: string): WalletInfo {
-  const privateKeyBytes = bs58.decode(privateKey);
-  const keypair = Keypair.fromSecretKey(privateKeyBytes);
-  return {
-    privateKey,
-    publicKey: keypair.publicKey.toBase58(),
-  };
+	const privateKeyBytes = bs58.decode(privateKey);
+	const keypair = Keypair.fromSecretKey(privateKeyBytes);
+	return {
+		privateKey,
+		publicKey: keypair.publicKey.toBase58(),
+	};
 }
 
 export function isValidPrivateKey(privateKey: string): boolean {
-  try {
-    const bytes = bs58.decode(privateKey);
-    Keypair.fromSecretKey(bytes);
-    return true;
-  } catch {
-    return false;
-  }
+	try {
+		const bytes = bs58.decode(privateKey);
+		Keypair.fromSecretKey(bytes);
+		return true;
+	} catch {
+		return false;
+	}
 }