@intella/sdk 0.0.1

package/examples/integrated-task/integrated-usage.ts

@@ -0,0 +1,193 @@
+/**
+ * Integrated Task Example
+ * 
+ * This example demonstrates how to use Agent, FileSystem, and Sandbox together
+ * to carry out a complete task:
+ * 1. Use an Agent to generate code
+ * 2. Save the code to FileSystem
+ * 3. Execute the code in a Sandbox
+ * 4. Read and process results
+ * 
+ * Prerequisites:
+ * - For E2B: Set E2B_API_KEY environment variable
+ * - For AgentFS: Configure your agent backend
+ * - For Claude: Set ANTHROPIC_API_KEY environment variable
+ */
+
+import { IntellaSDK } from '../../src/index.js';
+import 'dotenv/config';
+
+async function main() {
+  const sdk = new IntellaSDK();
+
+  console.log('🚀 Starting Integrated Task Example\n');
+
+  try {
+    // Step 1: Initialize Filesystem
+    console.log('📁 Step 1: Initializing Filesystem...');
+    await sdk.initializeFilesystem('memory', {
+      // Using memory provider for this example
+      // You can also use 'agentfs' for persistent storage
+    });
+    console.log('✓ Filesystem initialized\n');
+
+    // Step 2: Initialize Sandbox
+    console.log('🏖️  Step 2: Initializing Sandbox...');
+    await sdk.initializeSandbox('e2b', {
+      templateId: 'base', // Use 'base' template or your custom template ID
+      env: {
+        NODE_ENV: 'development',
+      },
+    });
+    console.log('✓ Sandbox initialized\n');
+
+    // Step 3: Configure Agent
+    console.log('🤖 Step 3: Configuring Agent...');
+    sdk.selectAgent('claude', {
+      model: 'sonnet', // or 'haiku', 'opus'
+      temperature: 0.7,
+    });
+    console.log('✓ Agent configured (Claude Sonnet)\n');
+
+    // Step 4: Task - Generate a Python script that calculates Fibonacci numbers
+    console.log('📝 Step 4: Generating code with Agent...');
+    const taskPrompt = `Write a Python script that:
+1. Calculates the first 20 Fibonacci numbers
+2. Saves them to a file called 'fibonacci.txt'
+3. Prints each number as it calculates
+
+Make the code clean and well-commented.`;
+
+    const agentResponse = await sdk.executeTask({
+      prompt: taskPrompt,
+      systemPrompt: 'You are a helpful coding assistant. Generate clean, working code.',
+    });
+
+    console.log('✓ Code generated by agent');
+    console.log('Agent response preview:', agentResponse.text.substring(0, 200) + '...\n');
+
+    // Step 5: Extract and save code to filesystem
+    console.log('💾 Step 5: Saving code to Filesystem...');
+    
+    // Extract Python code from the agent response (simple extraction)
+    // In a real scenario, you might use more sophisticated parsing
+    const codeMatch = agentResponse.text.match(/```python\n([\s\S]*?)\n```/) ||
+                      agentResponse.text.match(/```\n([\s\S]*?)\n```/);
+    
+    if (!codeMatch) {
+      throw new Error('Could not extract code from agent response');
+    }
+
+    const pythonCode = codeMatch[1];
+    const scriptPath = '/tmp/fibonacci.py';
+    
+    // Save to filesystem
+    await sdk.writeFile(scriptPath, pythonCode);
+    console.log(`✓ Code saved to ${scriptPath} in filesystem\n`);
+
+    // Step 6: Copy code from filesystem to sandbox
+    console.log('📤 Step 6: Copying code to Sandbox...');
+    const sandbox = sdk.getActiveSandbox();
+    if (!sandbox) {
+      throw new Error('No active sandbox');
+    }
+
+    // Read from filesystem and write to sandbox
+    const codeContent = await sdk.readFile(scriptPath);
+    // Convert to string if it's a Buffer
+    const codeString = typeof codeContent === 'string' ? codeContent : codeContent.toString('utf-8');
+    await sandbox.writeFile('/tmp/fibonacci.py', codeString);
+    console.log('✓ Code copied to sandbox\n');
+
+    // Step 7: Execute the script in sandbox
+    console.log('⚡ Step 7: Executing script in Sandbox...');
+    const executionResult = await sdk.executeInSandbox('python3 /tmp/fibonacci.py', {
+      cwd: '/tmp',
+      timeout: 30000, // 30 seconds
+    });
+
+    console.log('✓ Script executed');
+    console.log('Exit code:', executionResult.result.exitCode);
+    console.log('Output:', executionResult.result.stdout);
+    if (executionResult.result.stderr) {
+      console.log('Errors:', executionResult.result.stderr);
+    }
+    console.log();
+
+    // Step 8: Read results from sandbox
+    console.log('📥 Step 8: Reading results from Sandbox...');
+    const resultFile = await sandbox.readFile('/tmp/fibonacci.txt');
+    console.log('✓ Results file read');
+    console.log('Fibonacci numbers:', resultFile);
+    console.log();
+
+    // Step 9: Save results back to filesystem for persistence
+    console.log('💾 Step 9: Saving results to Filesystem...');
+    await sdk.writeFile('/results/fibonacci.txt', resultFile);
+    await sdk.setValue('task:fibonacci:completed', {
+      timestamp: new Date().toISOString(),
+      count: 20,
+      status: 'success',
+    });
+    console.log('✓ Results saved to filesystem\n');
+
+    // Step 10: Use agent to analyze results
+    console.log('🔍 Step 10: Analyzing results with Agent...');
+    const analysisResponse = await sdk.executeTask({
+      prompt: `Analyze these Fibonacci numbers: ${resultFile}\n\nProvide insights about the sequence.`,
+    });
+    console.log('✓ Analysis complete');
+    console.log('Analysis:', analysisResponse.text);
+    console.log();
+
+    // Step 11: Record tool call metadata
+    console.log('📊 Step 11: Recording tool call metadata...');
+    await sdk.recordToolCall({
+      tool: 'python_execution',
+      startedAt: Date.now() / 1000 - 10,
+      endedAt: Date.now() / 1000,
+      input: { script: scriptPath, command: 'python3 /tmp/fibonacci.py' },
+      output: { result: resultFile, exitCode: executionResult.result.exitCode },
+      status: executionResult.result.exitCode === 0 ? 'success' : 'error',
+    });
+    console.log('✓ Tool call recorded\n');
+
+    // Step 12: Retrieve tool call history
+    console.log('📜 Step 12: Retrieving tool call history...');
+    const history = await sdk.getToolCallHistory({ limit: 5 });
+    console.log(`✓ Retrieved ${history.length} tool calls`);
+    history.forEach((call, index) => {
+      console.log(`  ${index + 1}. ${call.tool} - ${call.status} (${new Date(call.startedAt * 1000).toLocaleTimeString()})`);
+    });
+    console.log();
+
+    console.log('✅ Task completed successfully!');
+
+  } catch (error) {
+    console.error('❌ Error during task execution:', error);
+    throw error;
+  } finally {
+    // Cleanup
+    console.log('\n🧹 Cleaning up...');
+    try {
+      await sdk.closeSandbox();
+      console.log('✓ Sandbox closed');
+    } catch (error) {
+      console.warn('Warning: Error closing sandbox:', error);
+    }
+
+    try {
+      await sdk.closeFilesystem();
+      console.log('✓ Filesystem closed');
+    } catch (error) {
+      console.warn('Warning: Error closing filesystem:', error);
+    }
+  }
+}
+
+// Run the example
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});
+

package/examples/integrated-task/simple-example.ts

@@ -0,0 +1,51 @@
+/**
+ * Simple Integrated Example
+ * 
+ * A concise example showing Agent + FileSystem + Sandbox integration
+ */
+
+import { IntellaSDK } from '../../src/index.js';
+import 'dotenv/config';
+
+async function simpleTask() {
+  const sdk = new IntellaSDK();
+
+  // 1. Initialize all components
+  await sdk.initializeFilesystem('memory');
+  await sdk.initializeSandbox('e2b', { templateId: 'base' });
+  sdk.selectAgent('intella-lite', { model: 'gpt-4o' });
+
+  // 2. Generate code with Agent
+  const { text } = await sdk.executeTask({
+    prompt: 'Write a Python script that prints "Hello from integrated SDK!"',
+  });
+
+  console.log('Text:', text);
+
+  // 3. Extract and save code
+  const code = text.match(/```python\n([\s\S]*?)\n```/)?.[1] || text;
+  await sdk.writeFile('/script.py', code);
+
+  // 4. Copy to sandbox and execute
+  const codeContent = await sdk.readFile('/script.py');
+  console.log('Code content:', codeContent);
+  const codeString = typeof codeContent === 'string' ? codeContent : codeContent.toString('utf-8');
+
+  console.log('Code string:', codeString);
+  
+  const sandbox = sdk.getActiveSandbox()!;
+  await sandbox.writeFile('/tmp/script.py', codeString);
+  console.log('Script written to sandbox');
+
+  console.log('Executing script in sandbox', sandbox);
+  const result = await sdk.executeInSandbox('python3 /tmp/script.py')
+  console.log('Result:', result);
+  console.log('Output:', result.result.stdout);
+
+  // 5. Cleanup
+  await sdk.closeSandbox();
+  await sdk.closeFilesystem();
+}
+
+simpleTask().catch(console.error);
+

package/examples/integrated-task/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "../..",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "types": ["node"],
+    "lib": ["ES2020"],
+    "baseUrl": "../..",
+    "paths": {
+      "@intella/sdk": ["./src/index.ts"]
+    }
+  },
+  "include": ["*.ts", "../../src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}
+

package/examples/sandbox/basic-usage.ts

@@ -0,0 +1,173 @@
+/**
+ * Basic Sandbox Usage Example
+ * 
+ * This example demonstrates how to use the sandbox functionality
+ * with E2B, Daytona, and Modal providers.
+ * 
+ * Prerequisites:
+ * - For E2B: Set E2B_API_KEY environment variable
+ * - For Daytona: Set DAYTONA_API_KEY and DAYTONA_API_URL environment variables
+ * - For Modal: Set MODAL_TOKEN_ID and MODAL_TOKEN_SECRET environment variables
+ */
+
+import { IntellaSDK } from '../../src/index.js';
+import 'dotenv/config';
+
+async function main() {
+  const sdk = new IntellaSDK();
+
+  console.log('Available sandbox providers:', sdk.listSandboxProviders());
+
+  try {
+    // Example 1: Using E2B Sandbox
+    console.log('\n=== E2B Sandbox Example ===');
+    
+    await sdk.initializeSandbox('e2b', {
+      templateId: 'base', // Use 'base' template or your custom template ID
+      env: {
+        NODE_ENV: 'development',
+      },
+    });
+
+    console.log('E2B Sandbox initialized');
+
+    // Execute a command
+    const result = await sdk.executeInSandbox('echo "Hello from E2B Sandbox!"');
+    console.log('Command result:', result.result.stdout);
+    console.log('Exit code:', result.result.exitCode);
+
+    // Write a file
+    const sandbox = sdk.getActiveSandbox();
+    if (sandbox) {
+      await sandbox.writeFile('/tmp/test.txt', 'Hello, World!');
+      const content = await sandbox.readFile('/tmp/test.txt');
+      console.log('File content:', content);
+    }
+
+    // Close the sandbox
+    await sdk.closeSandbox();
+    console.log('E2B Sandbox closed');
+
+  } catch (error) {
+    console.error('E2B Error:', error);
+  }
+
+  try {
+    // Example 2: Using Daytona Sandbox
+    console.log('\n=== Daytona Sandbox Example ===');
+    
+    await sdk.initializeSandbox('daytona', {
+      templateId: 'default', // Workspace template ID
+      baseURL: process.env.DAYTONA_API_URL || 'http://localhost:3000',
+      env: {
+        NODE_ENV: 'development',
+      },
+    });
+
+    console.log('Daytona Sandbox initialized');
+
+    // Execute a command
+    const result = await sdk.executeInSandbox('echo "Hello from Daytona Sandbox!"');
+    console.log('Command result:', result.result.stdout);
+    console.log('Exit code:', result.result.exitCode);
+
+    // Get sandbox status
+    const sandbox = sdk.getActiveSandbox();
+    if (sandbox) {
+      const status = await sandbox.getStatus();
+      console.log('Sandbox status:', status);
+      
+      // Get detailed sandbox information
+      const info = await sandbox.getInfo();
+      console.log('Sandbox info:', {
+        sandboxId: info.sandboxId,
+        provider: info.provider,
+        isRunning: info.isRunning,
+        isInitialized: info.isInitialized,
+      });
+    }
+
+    // Close the sandbox
+    await sdk.closeSandbox();
+    console.log('Daytona Sandbox closed');
+
+  } catch (error) {
+    console.error('Daytona Error:', error);
+  }
+
+  // Example 3: Execute task with sandbox
+  console.log('\n=== Task Execution with Sandbox ===');
+  
+  try {
+    await sdk.initializeSandbox('e2b', {
+      templateId: 'base',
+    });
+
+    // Configure an agent
+    sdk.selectAgent('claude', {
+      model: 'sonnet',
+    });
+
+    // Execute a task and then run it in sandbox
+    const combinedResult = await sdk.executeTaskInSandbox(
+      'Write a simple Python script that prints "Hello, World!"',
+      'python3 /tmp/script.py',
+      'claude',
+      {
+        cwd: '/tmp',
+      }
+    );
+
+    console.log('Agent response:', combinedResult.agentResponse.text);
+    console.log('Sandbox execution:', combinedResult.sandboxResult.result.stdout);
+
+    await sdk.closeSandbox();
+  } catch (error) {
+    console.error('Combined execution error:', error);
+  }
+
+  // Example 4: Connecting to existing sandbox and getting info
+  console.log('\n=== Connecting to Existing Sandbox ===');
+  
+  try {
+    // First, create a sandbox and get its ID
+    await sdk.initializeSandbox('e2b', {
+      templateId: 'base',
+    });
+    
+    const initialSandbox = sdk.getActiveSandbox();
+    if (initialSandbox) {
+      const sandboxId = initialSandbox.getSandboxId();
+      console.log('Created sandbox ID:', sandboxId);
+      
+      // Get info for the active sandbox
+      const info = await initialSandbox.getInfo();
+      console.log('Sandbox info:', {
+        sandboxId: info.sandboxId,
+        provider: info.provider,
+        isRunning: info.isRunning,
+        createdAt: info.createdAt,
+      });
+      
+      await sdk.closeSandbox();
+      
+      // Now connect to the same sandbox (if it still exists)
+      // Note: E2B sandboxes are ephemeral, so this may not work
+      // This example is more useful for Modal and Daytona
+      try {
+        await sdk.initializeSandbox('e2b', {
+          fromSandboxId: sandboxId || '',
+        });
+        console.log('Reconnected to existing sandbox');
+        await sdk.closeSandbox();
+      } catch (reconnectError) {
+        console.log('Could not reconnect (sandbox may have expired):', reconnectError);
+      }
+    }
+  } catch (error) {
+    console.error('Existing sandbox example error:', error);
+  }
+}
+
+main().catch(console.error);
+

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@intella/sdk",
+  "version": "0.0.1",
+  "description": "Agent orchestrator SDK for managing tasks across multiple AI agents using AI SDK v6",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "example:basic": "tsx examples/claude-code/basic-usage.ts",
+    "example:streaming": "tsx examples/claude-code/streaming.ts",
+    "example:orchestration": "tsx examples/claude-code/orchestration.ts",
+    "example:model-comparison": "tsx examples/claude-code/model-comparison.ts",
+    "example:integrated-task": "tsx examples/integrated-task/integrated-usage.ts",
+    "example:simple-example": "tsx examples/integrated-task/simple-example.ts",
+    "example:sandbox": "tsx examples/sandbox/basic-usage.ts"
+  },
+  "keywords": [
+    "ai",
+    "sdk",
+    "agent",
+    "orchestrator",
+    "ai-sdk"
+  ],
+  "author": "hi@mielto.com",
+  "license": "ISC",
+  "dependencies": {
+    "@daytonaio/sdk": "^0.129.0",
+    "@e2b/code-interpreter": "^2.3.3",
+    "agentfs-sdk": "^0.5.0",
+    "ai": "^6.0.0",
+    "ai-sdk-provider-claude-code": "^3.1.0",
+    "ai-sdk-provider-codex-cli": "^1.0.4",
+    "ai-sdk-provider-opencode-sdk": "^1.0.0",
+    "dotenv": "^17.2.3",
+    "modal": "^0.6.0",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.21.0",
+    "zod": "^3.25.76"
+  },
+  "peerDependencies": {
+    "@ai-sdk/openai": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.3",
+    "typescript": "^5.8.3"
+  }
+}

package/src/agent-manager.ts

@@ -0,0 +1,104 @@
+import type { AgentType, AgentConfig, IAgent } from './types.js';
+import { IntellaLiteAgent } from './agents/intella-lite-agent.js';
+import { ClaudeAgent } from './agents/claude-agent.js';
+import { CodexAgent } from './agents/codex-agent.js';
+import { OpenCodeAgent } from './agents/opencode-agent.js';
+
+/**
+ * Agent Manager
+ * Manages agent instances and configurations
+ */
+export class AgentManager {
+  private agents: Map<AgentType, IAgent> = new Map();
+  private defaultAgentType: AgentType = 'intella-lite';
+
+  constructor() {
+    // Initialize default agents
+    this.registerAgent('intella-lite', new IntellaLiteAgent());
+    this.registerAgent('claude', new ClaudeAgent());
+    this.registerAgent('codex', new CodexAgent());
+    this.registerAgent('opencode', new OpenCodeAgent());
+  }
+
+  /**
+   * Register or update an agent instance
+   */
+  registerAgent(type: AgentType, agent: IAgent): void {
+    if (agent.type !== type) {
+      throw new Error(`Agent type mismatch: expected ${type}, got ${agent.type}`);
+    }
+    this.agents.set(type, agent);
+  }
+
+  /**
+   * Get an agent instance
+   */
+  getAgent(type?: AgentType): IAgent {
+    const agentType = type || this.defaultAgentType;
+    const agent = this.agents.get(agentType);
+    
+    if (!agent) {
+      throw new Error(`Agent ${agentType} is not registered`);
+    }
+    
+    return agent;
+  }
+
+  /**
+   * List all available agents
+   */
+  listAgents(): AgentType[] {
+    return Array.from(this.agents.keys());
+  }
+
+  /**
+   * Check if an agent is registered
+   */
+  hasAgent(type: AgentType): boolean {
+    return this.agents.has(type);
+  }
+
+  /**
+   * Update agent configuration
+   */
+  updateConfig(type: AgentType, config: AgentConfig): void {
+    const agent = this.getAgent(type);
+    agent.configure(config);
+  }
+
+  /**
+   * Get agent configuration
+   */
+  getConfig(type: AgentType): AgentConfig {
+    const agent = this.getAgent(type);
+    return agent.getConfig();
+  }
+
+  /**
+   * Set the default agent type
+   */
+  setDefaultAgent(type: AgentType): void {
+    if (!this.agents.has(type)) {
+      throw new Error(`Agent ${type} is not registered`);
+    }
+    this.defaultAgentType = type;
+  }
+
+  /**
+   * Get the default agent type
+   */
+  getDefaultAgentType(): AgentType {
+    return this.defaultAgentType;
+  }
+
+  /**
+   * Remove an agent (cannot remove default agent)
+   */
+  removeAgent(type: AgentType): void {
+    if (type === this.defaultAgentType) {
+      throw new Error('Cannot remove the default agent');
+    }
+    this.agents.delete(type);
+  }
+}
+