@ottocode/ai-sdk 0.1.4 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ottocode/ai-sdk",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "type": "module",
   "exports": {
     ".": "./src/index.ts",
@@ -24,6 +24,6 @@
     "ai": ">=6.0.0"
   },
   "devDependencies": {
-    "typescript": "^5.0.0"
+    "typescript": "~5.9.3"
   }
 }

package/src/auth.ts

@@ -4,41 +4,76 @@ import nacl from 'tweetnacl';
 import type { SetuAuth } from './types.ts';
 
 export interface WalletContext {
-  keypair: Keypair;
-  walletAddress: string;
-  privateKeyBytes: Uint8Array;
+	walletAddress: string;
+	buildHeaders: () => Promise<Record<string, string>> | Record<string, string>;
+	keypair?: Keypair;
+	privateKeyBytes?: Uint8Array;
+	signTransaction?: (transaction: Uint8Array) => Promise<Uint8Array>;
 }
 
-export function createWalletContext(auth: Required<SetuAuth>): WalletContext {
-  const privateKeyBytes = bs58.decode(auth.privateKey!);
-  const keypair = Keypair.fromSecretKey(privateKeyBytes);
-  const walletAddress = keypair.publicKey.toBase58();
-  return { keypair, walletAddress, privateKeyBytes };
+export function createWalletContext(auth: SetuAuth): WalletContext {
+	if (auth.signer) {
+		const {
+			walletAddress,
+			signNonce: customSignNonce,
+			signTransaction,
+		} = auth.signer;
+		return {
+			walletAddress,
+			signTransaction,
+			buildHeaders: async () => {
+				const nonce = Date.now().toString();
+				const signature = await customSignNonce(nonce);
+				return {
+					'x-wallet-address': walletAddress,
+					'x-wallet-nonce': nonce,
+					'x-wallet-signature': signature,
+				};
+			},
+		};
+	}
+
+	if (!auth.privateKey) {
+		throw new Error('Setu: either privateKey or signer is required.');
+	}
+
+	const privateKeyBytes = bs58.decode(auth.privateKey);
+	const keypair = Keypair.fromSecretKey(privateKeyBytes);
+	const walletAddress = keypair.publicKey.toBase58();
+	return {
+		keypair,
+		walletAddress,
+		privateKeyBytes,
+		buildHeaders: () => buildWalletHeaders(walletAddress, privateKeyBytes),
+	};
 }
 
 export function signNonce(nonce: string, secretKey: Uint8Array): string {
-  const data = new TextEncoder().encode(nonce);
-  const signature = nacl.sign.detached(data, secretKey);
-  return bs58.encode(signature);
+	const data = new TextEncoder().encode(nonce);
+	const signature = nacl.sign.detached(data, secretKey);
+	return bs58.encode(signature);
 }
 
-export function buildWalletHeaders(ctx: WalletContext): Record<string, string> {
-  const nonce = Date.now().toString();
-  const signature = signNonce(nonce, ctx.privateKeyBytes);
-  return {
-    'x-wallet-address': ctx.walletAddress,
-    'x-wallet-nonce': nonce,
-    'x-wallet-signature': signature,
-  };
+export function buildWalletHeaders(
+	walletAddress: string,
+	privateKeyBytes: Uint8Array,
+): Record<string, string> {
+	const nonce = Date.now().toString();
+	const signature = signNonce(nonce, privateKeyBytes);
+	return {
+		'x-wallet-address': walletAddress,
+		'x-wallet-nonce': nonce,
+		'x-wallet-signature': signature,
+	};
 }
 
 export function getPublicKeyFromPrivate(privateKey?: string): string | null {
-  if (!privateKey) return null;
-  try {
-    const privateKeyBytes = bs58.decode(privateKey);
-    const keypair = Keypair.fromSecretKey(privateKeyBytes);
-    return keypair.publicKey.toBase58();
-  } catch {
-    return null;
-  }
+	if (!privateKey) return null;
+	try {
+		const privateKeyBytes = bs58.decode(privateKey);
+		const keypair = Keypair.fromSecretKey(privateKeyBytes);
+		return keypair.publicKey.toBase58();
+	} catch {
+		return null;
+	}
 }

package/src/balance.ts

@@ -1,7 +1,8 @@
 import bs58 from 'bs58';
 import { Keypair } from '@solana/web3.js';
 import type { SetuAuth, BalanceResponse, WalletUsdcBalance } from './types.ts';
-import { signNonce } from './auth.ts';
+import type { WalletContext } from './auth.ts';
+import { createWalletContext } from './auth.ts';
 
 const DEFAULT_BASE_URL = 'https://api.setu.ottocode.io';
 const DEFAULT_RPC_URL = 'https://api.mainnet-beta.solana.com';
@@ -9,101 +10,114 @@ const USDC_MINT_MAINNET = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';
 const USDC_MINT_DEVNET = '4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU';
 
 function trimTrailingSlash(url: string) {
-  return url.endsWith('/') ? url.slice(0, -1) : url;
+	return url.endsWith('/') ? url.slice(0, -1) : url;
+}
+
+function isWalletContext(input: unknown): input is WalletContext {
+	return (
+		typeof input === 'object' &&
+		input !== null &&
+		'buildHeaders' in input &&
+		typeof (input as WalletContext).buildHeaders === 'function'
+	);
 }
 
 export async function fetchBalance(
-  auth: Required<SetuAuth>,
-  baseURL?: string,
+	walletOrAuth: WalletContext | SetuAuth,
+	baseURL?: string,
 ): Promise<BalanceResponse | null> {
-  try {
-    const privateKeyBytes = bs58.decode(auth.privateKey!);
-    const keypair = Keypair.fromSecretKey(privateKeyBytes);
-    const walletAddress = keypair.publicKey.toBase58();
-    const url = trimTrailingSlash(baseURL ?? DEFAULT_BASE_URL);
-
-    const nonce = Date.now().toString();
-    const signature = signNonce(nonce, privateKeyBytes);
-
-    const response = await fetch(`${url}/v1/balance`, {
-      headers: {
-        'x-wallet-address': walletAddress,
-        'x-wallet-nonce': nonce,
-        'x-wallet-signature': signature,
-      },
-    });
-
-    if (!response.ok) return null;
-
-    const data = (await response.json()) as {
-      wallet_address: string;
-      balance_usd: number;
-      total_spent: number;
-      total_topups: number;
-      request_count: number;
-      created_at?: string;
-      last_request?: string;
-    };
-
-    return {
-      walletAddress: data.wallet_address,
-      balance: data.balance_usd,
-      totalSpent: data.total_spent,
-      totalTopups: data.total_topups,
-      requestCount: data.request_count,
-      createdAt: data.created_at,
-      lastRequest: data.last_request,
-    };
-  } catch {
-    return null;
-  }
+	try {
+		const wallet = isWalletContext(walletOrAuth)
+			? walletOrAuth
+			: createWalletContext(walletOrAuth);
+		const url = trimTrailingSlash(baseURL ?? DEFAULT_BASE_URL);
+		const headers = await wallet.buildHeaders();
+
+		const response = await fetch(`${url}/v1/balance`, { headers });
+
+		if (!response.ok) return null;
+
+		const data = (await response.json()) as {
+			wallet_address: string;
+			balance_usd: number;
+			total_spent: number;
+			total_topups: number;
+			request_count: number;
+			created_at?: string;
+			last_request?: string;
+		};
+
+		return {
+			walletAddress: data.wallet_address,
+			balance: data.balance_usd,
+			totalSpent: data.total_spent,
+			totalTopups: data.total_topups,
+			requestCount: data.request_count,
+			createdAt: data.created_at,
+			lastRequest: data.last_request,
+		};
+	} catch {
+		return null;
+	}
+}
+
+type WalletUsdcBalanceInput =
+	| Required<Pick<SetuAuth, 'privateKey'>>
+	| { walletAddress: string };
+
+function resolveWalletAddress(input: WalletUsdcBalanceInput): string {
+	if ('walletAddress' in input) return input.walletAddress;
+	const privateKeyBytes = bs58.decode(input.privateKey);
+	const keypair = Keypair.fromSecretKey(privateKeyBytes);
+	return keypair.publicKey.toBase58();
 }
 
 export async function fetchWalletUsdcBalance(
-  auth: Required<SetuAuth>,
-  network: 'mainnet' | 'devnet' = 'mainnet',
+	input: WalletUsdcBalanceInput,
+	network: 'mainnet' | 'devnet' = 'mainnet',
 ): Promise<WalletUsdcBalance | null> {
-  try {
-    const privateKeyBytes = bs58.decode(auth.privateKey!);
-    const keypair = Keypair.fromSecretKey(privateKeyBytes);
-    const walletAddress = keypair.publicKey.toBase58();
-    const rpcUrl = network === 'devnet' ? 'https://api.devnet.solana.com' : DEFAULT_RPC_URL;
-    const usdcMint = network === '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 null;
-
-    const data = (await response.json()) as {
-      result?: {
-        value?: Array<{
-          account: {
-            data: {
-              parsed: {
-                info: { tokenAmount: { uiAmount: number } };
-              };
-            };
-          };
-        }>;
-      };
-    };
-
-    let totalUsdcBalance = 0;
-    for (const account of data.result?.value ?? []) {
-      totalUsdcBalance += account.account.data.parsed.info.tokenAmount.uiAmount ?? 0;
-    }
-
-    return { walletAddress, usdcBalance: totalUsdcBalance, network };
-  } catch {
-    return null;
-  }
+	try {
+		const walletAddress = resolveWalletAddress(input);
+		const rpcUrl =
+			network === 'devnet' ? 'https://api.devnet.solana.com' : DEFAULT_RPC_URL;
+		const usdcMint =
+			network === '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 null;
+
+		const data = (await response.json()) as {
+			result?: {
+				value?: Array<{
+					account: {
+						data: {
+							parsed: {
+								info: { tokenAmount: { uiAmount: number } };
+							};
+						};
+					};
+				}>;
+			};
+		};
+
+		let totalUsdcBalance = 0;
+		for (const account of data.result?.value ?? []) {
+			totalUsdcBalance +=
+				account.account.data.parsed.info.tokenAmount.uiAmount ?? 0;
+		}
+
+		return { walletAddress, usdcBalance: totalUsdcBalance, network };
+	} catch {
+		return null;
+	}
 }

package/src/cache.ts

@@ -1,159 +1,181 @@
 import type { AnthropicCacheConfig, AnthropicCachePlacement } from './types.ts';
 
 interface MessageBlock {
-  type: string;
-  cache_control?: { type: string };
-  [key: string]: unknown;
+	type: string;
+	cache_control?: { type: string };
+	[key: string]: unknown;
 }
 
 interface Message {
-  role: string;
-  content: unknown;
-  [key: string]: unknown;
+	role: string;
+	content: unknown;
+	[key: string]: unknown;
 }
 
 interface ParsedBody {
-  system?: MessageBlock[];
-  messages?: Message[];
-  [key: string]: unknown;
+	system?: MessageBlock[];
+	messages?: Message[];
+	[key: string]: unknown;
 }
 
 const DEFAULT_CONFIG: Required<Omit<AnthropicCacheConfig, 'transform'>> = {
-  strategy: 'auto',
-  systemBreakpoints: 1,
-  messageBreakpoints: 1,
-  systemPlacement: 'first',
-  messagePlacement: 'last',
-  cacheType: 'ephemeral',
+	strategy: 'auto',
+	systemBreakpoints: 1,
+	messageBreakpoints: 1,
+	systemPlacement: 'first',
+	messagePlacement: 'last',
+	cacheType: 'ephemeral',
 };
 
-function resolveConfig(config?: AnthropicCacheConfig): Required<Omit<AnthropicCacheConfig, 'transform'>> & { transform?: AnthropicCacheConfig['transform'] } {
-  if (!config) return { ...DEFAULT_CONFIG };
-  return {
-    strategy: config.strategy ?? DEFAULT_CONFIG.strategy,
-    systemBreakpoints: config.systemBreakpoints ?? DEFAULT_CONFIG.systemBreakpoints,
-    messageBreakpoints: config.messageBreakpoints ?? DEFAULT_CONFIG.messageBreakpoints,
-    systemPlacement: config.systemPlacement ?? DEFAULT_CONFIG.systemPlacement,
-    messagePlacement: config.messagePlacement ?? DEFAULT_CONFIG.messagePlacement,
-    cacheType: config.cacheType ?? DEFAULT_CONFIG.cacheType,
-    transform: config.transform,
-  };
+function resolveConfig(config?: AnthropicCacheConfig): Required<
+	Omit<AnthropicCacheConfig, 'transform'>
+> & {
+	transform?: AnthropicCacheConfig['transform'];
+} {
+	if (!config) return { ...DEFAULT_CONFIG };
+	return {
+		strategy: config.strategy ?? DEFAULT_CONFIG.strategy,
+		systemBreakpoints:
+			config.systemBreakpoints ?? DEFAULT_CONFIG.systemBreakpoints,
+		messageBreakpoints:
+			config.messageBreakpoints ?? DEFAULT_CONFIG.messageBreakpoints,
+		systemPlacement: config.systemPlacement ?? DEFAULT_CONFIG.systemPlacement,
+		messagePlacement:
+			config.messagePlacement ?? DEFAULT_CONFIG.messagePlacement,
+		cacheType: config.cacheType ?? DEFAULT_CONFIG.cacheType,
+		transform: config.transform,
+	};
 }
 
 function shouldCacheAtIndex(
-  index: number,
-  total: number,
-  maxBreakpoints: number,
-  placement: AnthropicCachePlacement,
+	index: number,
+	total: number,
+	maxBreakpoints: number,
+	placement: AnthropicCachePlacement,
 ): boolean {
-  if (maxBreakpoints <= 0) return false;
-
-  switch (placement) {
-    case 'first': {
-      return index < maxBreakpoints;
-    }
-    case 'last': {
-      const startFrom = total - maxBreakpoints;
-      return index >= startFrom && index < total;
-    }
-    case 'all': {
-      return true;
-    }
-  }
+	if (maxBreakpoints <= 0) return false;
+
+	switch (placement) {
+		case 'first': {
+			return index < maxBreakpoints;
+		}
+		case 'last': {
+			const startFrom = total - maxBreakpoints;
+			return index >= startFrom && index < total;
+		}
+		case 'all': {
+			return true;
+		}
+	}
 }
 
 function injectCacheOnBlocks(
-  blocks: MessageBlock[],
-  maxBreakpoints: number,
-  placement: AnthropicCachePlacement,
-  cacheType: string,
+	blocks: MessageBlock[],
+	maxBreakpoints: number,
+	placement: AnthropicCachePlacement,
+	cacheType: string,
 ): { blocks: MessageBlock[]; used: number } {
-  let used = 0;
-  const eligible = blocks.map((_, i) => shouldCacheAtIndex(i, blocks.length, maxBreakpoints, placement));
-  const result = blocks.map((block, i) => {
-    if (block.cache_control) return block;
-    if (used < maxBreakpoints && eligible[i]) {
-      used++;
-      return { ...block, cache_control: { type: cacheType } };
-    }
-    return block;
-  });
-  return { blocks: result, used };
+	let used = 0;
+	const eligible = blocks.map((_, i) =>
+		shouldCacheAtIndex(i, blocks.length, maxBreakpoints, placement),
+	);
+	const result = blocks.map((block, i) => {
+		if (block.cache_control) return block;
+		if (used < maxBreakpoints && eligible[i]) {
+			used++;
+			return { ...block, cache_control: { type: cacheType } };
+		}
+		return block;
+	});
+	return { blocks: result, used };
 }
 
 export function addAnthropicCacheControl(
-  parsed: ParsedBody,
-  config?: AnthropicCacheConfig,
+	parsed: ParsedBody,
+	config?: AnthropicCacheConfig,
 ): ParsedBody {
-  const resolved = resolveConfig(config);
-
-  if (resolved.strategy === false) return parsed;
-
-  if (resolved.strategy === 'manual') return parsed;
-
-  if (resolved.strategy === 'custom' && resolved.transform) {
-    return resolved.transform(parsed as Record<string, unknown>) as ParsedBody;
-  }
-
-  let systemUsed = 0;
-
-  if (parsed.system && Array.isArray(parsed.system)) {
-    const result = injectCacheOnBlocks(
-      parsed.system,
-      resolved.systemBreakpoints,
-      resolved.systemPlacement,
-      resolved.cacheType,
-    );
-    parsed.system = result.blocks;
-    systemUsed = result.used;
-  }
-
-  if (parsed.messages && Array.isArray(parsed.messages)) {
-    let messageUsed = 0;
-    const messageCount = parsed.messages.length;
-
-    const eligibleIndices: number[] = [];
-    for (let i = 0; i < messageCount; i++) {
-      if (shouldCacheAtIndex(i, messageCount, resolved.messageBreakpoints, resolved.messagePlacement)) {
-        eligibleIndices.push(i);
-      }
-    }
-
-    parsed.messages = parsed.messages.map((msg, msgIndex) => {
-      if (messageUsed >= resolved.messageBreakpoints) return msg;
-      if (!eligibleIndices.includes(msgIndex)) return msg;
-
-      if (Array.isArray(msg.content)) {
-        const blocks = msg.content as MessageBlock[];
-        const lastIdx = blocks.length - 1;
-        const content = blocks.map((block, blockIndex) => {
-          if (block.cache_control) return block;
-          if (blockIndex === lastIdx && messageUsed < resolved.messageBreakpoints) {
-            messageUsed++;
-            return { ...block, cache_control: { type: resolved.cacheType } };
-          }
-          return block;
-        });
-        return { ...msg, content };
-      }
-
-      if (typeof msg.content === 'string' && messageUsed < resolved.messageBreakpoints) {
-        messageUsed++;
-        return {
-          ...msg,
-          content: [
-            {
-              type: 'text',
-              text: msg.content,
-              cache_control: { type: resolved.cacheType },
-            },
-          ],
-        };
-      }
-
-      return msg;
-    });
-  }
-
-  return parsed;
+	const resolved = resolveConfig(config);
+
+	if (resolved.strategy === false) return parsed;
+
+	if (resolved.strategy === 'manual') return parsed;
+
+	if (resolved.strategy === 'custom' && resolved.transform) {
+		return resolved.transform(parsed as Record<string, unknown>) as ParsedBody;
+	}
+
+	let _systemUsed = 0;
+
+	if (parsed.system && Array.isArray(parsed.system)) {
+		const result = injectCacheOnBlocks(
+			parsed.system,
+			resolved.systemBreakpoints,
+			resolved.systemPlacement,
+			resolved.cacheType,
+		);
+		parsed.system = result.blocks;
+		_systemUsed = result.used;
+	}
+
+	if (parsed.messages && Array.isArray(parsed.messages)) {
+		let messageUsed = 0;
+		const messageCount = parsed.messages.length;
+
+		const eligibleIndices: number[] = [];
+		for (let i = 0; i < messageCount; i++) {
+			if (
+				shouldCacheAtIndex(
+					i,
+					messageCount,
+					resolved.messageBreakpoints,
+					resolved.messagePlacement,
+				)
+			) {
+				eligibleIndices.push(i);
+			}
+		}
+
+		parsed.messages = parsed.messages.map((msg, msgIndex) => {
+			if (messageUsed >= resolved.messageBreakpoints) return msg;
+			if (!eligibleIndices.includes(msgIndex)) return msg;
+
+			if (Array.isArray(msg.content)) {
+				const blocks = msg.content as MessageBlock[];
+				const lastIdx = blocks.length - 1;
+				const content = blocks.map((block, blockIndex) => {
+					if (block.cache_control) return block;
+					if (
+						blockIndex === lastIdx &&
+						messageUsed < resolved.messageBreakpoints
+					) {
+						messageUsed++;
+						return { ...block, cache_control: { type: resolved.cacheType } };
+					}
+					return block;
+				});
+				return { ...msg, content };
+			}
+
+			if (
+				typeof msg.content === 'string' &&
+				messageUsed < resolved.messageBreakpoints
+			) {
+				messageUsed++;
+				return {
+					...msg,
+					content: [
+						{
+							type: 'text',
+							text: msg.content,
+							cache_control: { type: resolved.cacheType },
+						},
+					],
+				};
+			}
+
+			return msg;
+		});
+	}
+
+	return parsed;
 }