@bolloon/bolloon-agent 0.1.0

package/src/constraint-runtime/src/tools/WalletTools/autoPay.ts

@@ -0,0 +1,58 @@
+export interface AutoPayConfig {
+  enabled: boolean;
+  walletPrivateKey: string;
+  rpcUrl: string;
+  maxGasPrice?: string;
+  whitelist?: string[];
+}
+
+const autoPayStore: Map<string, AutoPayConfig> = new Map();
+
+export interface SetAutoPayParams {
+  agentId: string;
+  walletPrivateKey: string;
+  rpcUrl?: string;
+  maxGasPrice?: string;
+  whitelist?: string[];
+}
+
+export interface AutoPayResult {
+  agentId: string;
+  enabled: boolean;
+  walletAddress: string;
+  rpcUrl: string;
+}
+
+export async function setAutoPay(params: SetAutoPayParams): Promise<AutoPayResult> {
+  const { Wallet } = await import('ethers');
+  const wallet = new Wallet(params.walletPrivateKey);
+
+  const config: AutoPayConfig = {
+    enabled: true,
+    walletPrivateKey: params.walletPrivateKey,
+    rpcUrl: params.rpcUrl ?? 'https://eth.llamarpc.com',
+    maxGasPrice: params.maxGasPrice,
+    whitelist: params.whitelist,
+  };
+
+  autoPayStore.set(params.agentId, config);
+
+  return {
+    agentId: params.agentId,
+    enabled: true,
+    walletAddress: wallet.address,
+    rpcUrl: config.rpcUrl,
+  };
+}
+
+export async function getAutoPayConfig(agentId: string): Promise<AutoPayConfig | null> {
+  return autoPayStore.get(agentId) ?? null;
+}
+
+export async function disableAutoPay(agentId: string): Promise<{ agentId: string; enabled: boolean }> {
+  const config = autoPayStore.get(agentId);
+  if (config) {
+    config.enabled = false;
+  }
+  return { agentId, enabled: false };
+}

package/src/constraint-runtime/src/tools/WalletTools/createWallet.ts

@@ -0,0 +1,19 @@
+import { randomBytes } from 'crypto';
+import { Wallet } from 'ethers';
+
+export interface CreateWalletResult {
+  address: string;
+  privateKey: string;
+  mnemonic: string;
+  createdAt: string;
+}
+
+export async function createWallet(): Promise<CreateWalletResult> {
+  const wallet = Wallet.createRandom();
+  return {
+    address: wallet.address,
+    privateKey: wallet.privateKey,
+    mnemonic: wallet.mnemonic?.phrase ?? '',
+    createdAt: new Date().toISOString(),
+  };
+}

package/src/constraint-runtime/src/tools/WalletTools/getBalance.ts

@@ -0,0 +1,28 @@
+import { JsonRpcProvider } from 'ethers';
+
+export interface GetBalanceParams {
+  address: string;
+  rpcUrl?: string;
+}
+
+export interface GetBalanceResult {
+  address: string;
+  balance: string;
+  balanceEth: string;
+  symbol: string;
+}
+
+export async function getBalance(params: GetBalanceParams): Promise<GetBalanceResult> {
+  const rpcUrl = params.rpcUrl ?? 'https://eth.llamarpc.com';
+  const provider = new JsonRpcProvider(rpcUrl);
+
+  const balance = await provider.getBalance(params.address);
+  const balanceEth = Number(balance) / 1e18;
+
+  return {
+    address: params.address,
+    balance: balance.toString(),
+    balanceEth: balanceEth.toFixed(6),
+    symbol: 'ETH',
+  };
+}

package/src/constraint-runtime/src/tools/WalletTools/importWallet.ts

@@ -0,0 +1,34 @@
+export interface ImportWalletParams {
+  mnemonic?: string;
+  privateKey?: string;
+}
+
+export interface ImportWalletResult {
+  address: string;
+  privateKey: string;
+  source: 'mnemonic' | 'privateKey';
+}
+
+export async function importWallet(params: ImportWalletParams): Promise<ImportWalletResult> {
+  if (!params.mnemonic && !params.privateKey) {
+    throw new Error('Either mnemonic or privateKey must be provided');
+  }
+
+  const { ethers } = await import('ethers');
+
+  if (params.mnemonic) {
+    const wallet = ethers.Wallet.fromPhrase(params.mnemonic);
+    return {
+      address: wallet.address,
+      privateKey: wallet.privateKey,
+      source: 'mnemonic' as const,
+    };
+  } else {
+    const wallet = new ethers.Wallet(params.privateKey!);
+    return {
+      address: wallet.address,
+      privateKey: wallet.privateKey,
+      source: 'privateKey' as const,
+    };
+  }
+}

package/src/constraint-runtime/src/tools/WalletTools/sendTransaction.ts

@@ -0,0 +1,50 @@
+import { Wallet, TransactionRequest, JsonRpcProvider } from 'ethers';
+
+export interface SendTransactionParams {
+  to: string;
+  value: string;
+  data?: string;
+  gasLimit?: string;
+  maxFeePerGas?: string;
+  maxPriorityFeePerGas?: string;
+  rpcUrl?: string;
+  privateKey: string;
+}
+
+export interface SendTransactionResult {
+  hash: string;
+  from: string;
+  to: string;
+  value: string;
+  status: 'pending' | 'success' | 'failed';
+  blockNumber?: number;
+  gasUsed?: string;
+}
+
+export async function sendTransaction(params: SendTransactionParams): Promise<SendTransactionResult> {
+  const rpcUrl = params.rpcUrl ?? 'https://eth.llamarpc.com';
+  const provider = new JsonRpcProvider(rpcUrl);
+  const wallet = new Wallet(params.privateKey, provider);
+
+  const tx: TransactionRequest = {
+    to: params.to,
+    value: BigInt(params.value),
+    data: params.data ? `0x${params.data}` : undefined,
+    gasLimit: params.gasLimit ? BigInt(params.gasLimit) : undefined,
+    maxFeePerGas: params.maxFeePerGas ? BigInt(params.maxFeePerGas) : undefined,
+    maxPriorityFeePerGas: params.maxPriorityFeePerGas ? BigInt(params.maxPriorityFeePerGas) : undefined,
+  };
+
+  const response = await wallet.sendTransaction(tx);
+  const receipt = await response.wait();
+
+  return {
+    hash: response.hash,
+    from: wallet.address,
+    to: params.to,
+    value: params.value,
+    status: receipt?.status === 1 ? 'success' : 'failed',
+    blockNumber: receipt?.blockNumber,
+    gasUsed: receipt?.gasUsed?.toString(),
+  };
+}

package/src/constraint-runtime/src/tools/WalletTools/signMessage.ts

@@ -0,0 +1,23 @@
+import { Wallet } from 'ethers';
+
+export interface SignMessageParams {
+  message: string;
+  privateKey: string;
+}
+
+export interface SignMessageResult {
+  address: string;
+  message: string;
+  signature: string;
+}
+
+export async function signMessage(params: SignMessageParams): Promise<SignMessageResult> {
+  const wallet = new Wallet(params.privateKey);
+  const signature = await wallet.signMessage(params.message);
+
+  return {
+    address: wallet.address,
+    message: params.message,
+    signature,
+  };
+}

package/src/constraint-runtime/src/tools/WalletTools/transferToken.ts

@@ -0,0 +1,49 @@
+import { Wallet, Contract } from 'ethers';
+
+export interface TransferTokenParams {
+  tokenAddress: string;
+  to: string;
+  amount: string;
+  rpcUrl?: string;
+  privateKey: string;
+  decimals?: number;
+}
+
+export interface TransferTokenResult {
+  hash: string;
+  from: string;
+  to: string;
+  tokenAddress: string;
+  amount: string;
+  status: 'pending' | 'success' | 'failed';
+}
+
+const ERC20_ABI = [
+  'function transfer(address to, uint256 amount) returns (bool)',
+  'function decimals() view returns (uint8)',
+  'function symbol() view returns (string)',
+];
+
+export async function transferToken(params: TransferTokenParams): Promise<TransferTokenResult> {
+  const rpcUrl = params.rpcUrl ?? 'https://eth.llamarpc.com';
+  const provider = new JsonRpcProvider(rpcUrl);
+  const wallet = new Wallet(params.privateKey, provider);
+
+  const tokenContract = new Contract(params.tokenAddress, ERC20_ABI, wallet);
+  const decimals = params.decimals ?? (await tokenContract.decimals());
+  const amount = BigInt(params.amount) * BigInt(10) ** BigInt(decimals);
+
+  const tx = await tokenContract.transfer(params.to, amount);
+  const receipt = await tx.wait();
+
+  return {
+    hash: tx.hash,
+    from: wallet.address,
+    to: params.to,
+    tokenAddress: params.tokenAddress,
+    amount: params.amount,
+    status: receipt?.status === 1 ? 'success' : 'failed',
+  };
+}
+
+import { JsonRpcProvider } from 'ethers';

package/src/constraint-runtime/src/tools.ts

@@ -0,0 +1,100 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { PortingModule } from './models.js';
+import { executeToolFromSnapshot } from './dynamic-tool-loader.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const SNAPSHOT_PATH = path.join(__dirname, 'reference_data', 'tools_snapshot.json');
+
+export interface ToolExecution {
+  name: string;
+  sourceHint: string;
+  payload: string;
+  handled: boolean;
+  message: string;
+}
+
+function loadToolSnapshot(): PortingModule[] {
+  try {
+    if (!fs.existsSync(SNAPSHOT_PATH)) {
+      console.warn(`[tools] Snapshot not found: ${SNAPSHOT_PATH}, using empty list`);
+      return [];
+    }
+    const raw = JSON.parse(fs.readFileSync(SNAPSHOT_PATH, 'utf-8'));
+    return raw.map((e: any) => ({
+      name: e.name,
+      responsibility: e.responsibility,
+      sourceHint: e.source_hint,
+      status: 'mirrored' as const,
+    }));
+  } catch (error) {
+    console.warn(`[tools] Failed to load snapshot: ${error}, using empty list`);
+    return [];
+  }
+}
+
+export const PORTED_TOOLS = loadToolSnapshot();
+
+export { PortingModule };
+
+export function getTool(name: string): PortingModule | undefined {
+  const needle = name.toLowerCase();
+  return PORTED_TOOLS.find(m => m.name.toLowerCase() === needle);
+}
+
+export function getTools(simpleMode: boolean = false): PortingModule[] {
+  let tools = [...PORTED_TOOLS];
+  if (simpleMode) {
+    tools = tools.filter(m => ['BashTool', 'FileReadTool', 'FileEditTool'].includes(m.name));
+  }
+  return tools;
+}
+
+export function findTools(query: string, limit: number = 20): PortingModule[] {
+  const needle = query.toLowerCase();
+  return PORTED_TOOLS.filter(
+    m => m.name.toLowerCase().includes(needle) || m.sourceHint.toLowerCase().includes(needle)
+  ).slice(0, limit);
+}
+
+export async function executeTool(name: string, payload: string = ''): Promise<ToolExecution> {
+  const module = getTool(name);
+  if (!module) {
+    return { name, sourceHint: '', payload, handled: false, message: `Unknown mirrored tool: ${name}` };
+  }
+
+  let params = {};
+  try {
+    params = payload ? JSON.parse(payload) : {};
+  } catch {
+    return {
+      name: module.name,
+      sourceHint: module.sourceHint,
+      payload,
+      handled: false,
+      message: `Invalid JSON payload for tool '${module.name}'`,
+    };
+  }
+
+  const result = await executeToolFromSnapshot(module.sourceHint, params);
+
+  if (result.success) {
+    return {
+      name: module.name,
+      sourceHint: module.sourceHint,
+      payload: JSON.stringify(result.data),
+      handled: true,
+      message: `Tool '${module.name}' executed successfully`,
+    };
+  } else {
+    return {
+      name: module.name,
+      sourceHint: module.sourceHint,
+      payload,
+      handled: false,
+      message: `Tool '${module.name}' failed: ${result.error}`,
+    };
+  }
+}

package/src/constraint-runtime/src/transcript.ts

@@ -0,0 +1,23 @@
+export class TranscriptStore {
+  entries: string[] = [];
+  flushed: boolean = false;
+
+  append(entry: string): void {
+    this.entries.push(entry);
+    this.flushed = false;
+  }
+
+  compact(keepLast: number = 10): void {
+    if (this.entries.length > keepLast) {
+      this.entries = this.entries.slice(-keepLast);
+    }
+  }
+
+  replay(): string[] {
+    return [...this.entries];
+  }
+
+  flush(): void {
+    this.flushed = true;
+  }
+}

package/src/constraint-runtime/src/types/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('types');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/upstream_proxy/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('upstream_proxy');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/utils/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('utils');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/vim/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('vim');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/src/voice/index.ts

@@ -0,0 +1,15 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+
+const SNAPSHOT = loadArchiveMetadata('voice');
+
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'] as string;
+export const MODULE_COUNT = SNAPSHOT['module_count'] as number;
+export const SAMPLE_FILES = SNAPSHOT['sample_files'] as string[];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+
+export default {
+  ARCHIVE_NAME,
+  MODULE_COUNT,
+  PORTING_NOTE,
+  SAMPLE_FILES,
+};

package/src/constraint-runtime/tests/agent.test.ts

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import { AgentCoordinator } from '../src/agent/coordinator.js';
+
+describe('AgentCoordinator', () => {
+  it('dispatches parallel tasks', async () => {
+    const coordinator = new AgentCoordinator(2);
+    const results = await coordinator.dispatch('one two three four', 2);
+    
+    expect(results.length).toBe(2);
+    expect(results.every(r => r.success)).toBe(true);
+  });
+
+  it('aggregates results in order', async () => {
+    const coordinator = new AgentCoordinator(2);
+    const results = await coordinator.dispatch('a b c d', 3);
+    
+    const ids = results.map(r => r.taskId);
+    expect(ids).toEqual(ids.sort());
+  });
+});

package/src/constraint-runtime/tests/constraint.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from 'vitest';
+import { ToolPermissionContext } from '../src/constraint/permission.js';
+import { BudgetTracker } from '../src/constraint/budget.js';
+
+describe('ToolPermissionContext', () => {
+  it('blocks denied tools by exact name', () => {
+    const ctx = ToolPermissionContext.fromIterables(['BashTool', 'FileEditTool'], []);
+    expect(ctx.blocks('BashTool')).toBe(true);
+    expect(ctx.blocks('FileEditTool')).toBe(true);
+    expect(ctx.blocks('FileReadTool')).toBe(false);
+  });
+
+  it('blocks tools by prefix', () => {
+    const ctx = ToolPermissionContext.fromIterables([], ['mcp_']);
+    expect(ctx.blocks('mcp_server')).toBe(true);
+    expect(ctx.blocks('mcp_client')).toBe(true);
+    expect(ctx.blocks('bash_tool')).toBe(false);
+  });
+
+  it('creates permission denial', () => {
+    const ctx = ToolPermissionContext.fromIterables(['BashTool'], []);
+    const denial = ctx.createDenial('BashTool', 'destructive shell execution');
+    expect(denial.toolName).toBe('BashTool');
+    expect(denial.reason).toBe('destructive shell execution');
+  });
+});
+
+describe('BudgetTracker', () => {
+  it('tracks token usage', () => {
+    const tracker = new BudgetTracker(1000, 8, 12);
+    const usage = tracker.addTurn(100, 50);
+    expect(usage.inputTokens).toBe(100);
+    expect(usage.outputTokens).toBe(50);
+  });
+
+  it('detects budget exceeded', () => {
+    const tracker = new BudgetTracker(100, 8, 12);
+    expect(tracker.isBudgetExceeded({ inputTokens: 60, outputTokens: 50 })).toBe(true);
+    expect(tracker.isBudgetExceeded({ inputTokens: 30, outputTokens: 30 })).toBe(false);
+  });
+
+  it('detects turn limit', () => {
+    const tracker = new BudgetTracker(1000, 5, 12);
+    expect(tracker.isTurnLimitExceeded(4)).toBe(false);
+    expect(tracker.isTurnLimitExceeded(5)).toBe(true);
+  });
+});

package/src/constraint-runtime/tests/skill.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { SkillRegistry } from '../src/skills/skill-registry.js';
+
+describe('SkillRegistry', () => {
+  it('registers and retrieves skills', async () => {
+    const registry = new SkillRegistry();
+    
+    registry.register({
+      name: 'testSkill',
+      description: 'A test skill',
+      execute: async (params) => `executed with ${params.input}`
+    });
+    
+    expect(registry.has('testSkill')).toBe(true);
+    const result = await registry.execute('testSkill', { input: 'hello' });
+    expect(result).toBe('executed with hello');
+  });
+
+  it('throws on unknown skill', async () => {
+    const registry = new SkillRegistry();
+    await expect(registry.execute('unknown', {})).rejects.toThrow('Skill not found');
+  });
+});

package/src/constraint-runtime/tests/thinking.test.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest';
+import { DeepThinkingEngine } from '../src/thinking/engine.js';
+
+describe('DeepThinkingEngine', () => {
+  it('performs thinking steps', async () => {
+    const engine = new DeepThinkingEngine(2);
+    const result = await engine.think('test prompt');
+    
+    expect(result.originalPrompt).toBe('test prompt');
+    expect(result.steps.length).toBe(2);
+    expect(result.depth).toBe(2);
+  });
+
+  it('respects max depth', async () => {
+    const engine = new DeepThinkingEngine(5);
+    const result = await engine.think('deep thought');
+    
+    expect(result.steps.length).toBe(5);
+  });
+
+  it('allows depth adjustment', async () => {
+    const engine = new DeepThinkingEngine(1);
+    engine.setDepth(3);
+    const result = await engine.think('adjustable');
+    
+    expect(result.steps.length).toBe(3);
+  });
+});

package/src/constraint-runtime/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "types": ["node"]
+  },
+  "include": ["src/**/*"]
+}

package/src/constraints/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Constraints Module
+ * Re-exports LLM initialization functions for pi-sdk compatibility
+ */
+
+export { initMinimax, getMinimax } from '../llm/pi-ai.js';