@intella/sdk 0.0.1 → 0.0.2

package/examples/sandbox/basic-usage.ts

@@ -1,173 +0,0 @@
-/**
- * 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/src/agent-manager.ts

@@ -1,104 +0,0 @@
-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);
-  }
-}
-

package/src/agents/base-agent.ts

@@ -1,166 +0,0 @@
-import { generateText, streamText, type LanguageModel, type ModelMessage } from 'ai';
-import type { AgentType, AgentConfig, TaskRequest, TaskResponse, StreamChunk, IAgent, MessageContent } from '../types.js';
-
-/**
- * Abstract base class for all agents
- * Provides common functionality using AI SDK v6
- */
-export abstract class BaseAgent implements IAgent {
-  protected config: AgentConfig;
-  public readonly type: AgentType;
-
-  constructor(type: AgentType, config: AgentConfig = {}) {
-    this.type = type;
-    this.config = { ...config };
-  }
-
-  /**
-   * Get the language model instance
-   * Must be implemented by subclasses
-   */
-  abstract getModel(): LanguageModel | Promise<LanguageModel>;
-
-  /**
-   * Execute a task and return the response
-   */
-  async execute(request: TaskRequest): Promise<TaskResponse> {
-    const model = await Promise.resolve(this.getModel());
-    const messages = this.buildMessages(request);
-
-    const result = await generateText({
-      model,
-      messages,
-      temperature: request.temperature ?? this.config.temperature,
-      maxOutputTokens: request.maxTokens ?? this.config.maxTokens,
-    });
-
-    return {
-      text: result.text,
-      agentType: this.type,
-      metadata: {
-        usage: result.usage,
-        finishReason: result.finishReason,
-      },
-    };
-  }
-
-  /**
-   * Stream a task execution
-   */
-  async *stream(request: TaskRequest): AsyncIterable<StreamChunk> {
-    const model = await Promise.resolve(this.getModel());
-    const messages = this.buildMessages(request);
-
-    const result = streamText({
-      model,
-      messages,
-      temperature: request.temperature ?? this.config.temperature,
-      maxOutputTokens: request.maxTokens ?? this.config.maxTokens,
-    });
-
-    let fullText = '';
-    for await (const chunk of result.textStream) {
-      fullText += chunk;
-      yield {
-        text: chunk,
-        agentType: this.type,
-        isDone: false,
-      };
-    }
-
-    // Final chunk to indicate completion
-    yield {
-      text: '',
-      agentType: this.type,
-      isDone: true,
-    };
-  }
-
-  /**
-   * Configure the agent
-   */
-  configure(config: AgentConfig): void {
-    this.config = { ...this.config, ...config };
-  }
-
-  /**
-   * Get current configuration
-   */
-  getConfig(): AgentConfig {
-    return { ...this.config };
-  }
-
-  /**
-   * Convert TaskRequest content to AI SDK ModelMessage content format
-   */
-  private convertContent(content: MessageContent): string | Array<{ type: 'text'; text: string } | { type: 'file'; data: string | Uint8Array | ArrayBuffer | Buffer | URL; filename?: string; mediaType: string }> {
-    // If content is a string, return as-is
-    if (typeof content === 'string') {
-      return content;
-    }
-
-    // If content is an array, convert to AI SDK format
-    return content.map(part => {
-      if (part.type === 'text') {
-        return {
-          type: 'text' as const,
-          text: part.text,
-        };
-      } else if (part.type === 'file') {
-        return {
-          type: 'file' as const,
-          data: part.data,
-          filename: part.filename,
-          mediaType: part.mediaType,
-        };
-      }
-      // Fallback for unknown types
-      return {
-        type: 'text' as const,
-        text: String(part),
-      };
-    });
-  }
-
-  /**
-   * Build messages array from request
-   */
-  protected buildMessages(request: TaskRequest): ModelMessage[] {
-    const messages: ModelMessage[] = [];
-
-    // Add system prompt if provided
-    if (request.systemPrompt) {
-      messages.push({
-        role: 'system',
-        content: request.systemPrompt,
-      });
-    }
-
-    // Add previous messages if provided
-    if (request.messages && request.messages.length > 0) {
-      for (const msg of request.messages) {
-        // Skip system messages in the messages array (they're handled separately)
-        if (msg.role === 'system') {
-          continue;
-        }
-
-        messages.push({
-          role: msg.role,
-          content: this.convertContent(msg.content),
-        });
-      }
-    }
-
-    // Add the main prompt as user message (only if not empty)
-    // If prompt is empty, the message is likely already in the messages array
-    if (request.prompt && request.prompt.trim()) {
-      messages.push({
-        role: 'user',
-        content: request.prompt,
-      });
-    }
-
-    return messages;
-  }
-}
-

package/src/agents/claude-agent.ts

@@ -1,77 +0,0 @@
-import { BaseAgent } from './base-agent.js';
-import type { AgentConfig } from '../types.js';
-import type { LanguageModel } from 'ai';
-
-import { claudeCode, createClaudeCode, McpServerConfig } from 'ai-sdk-provider-claude-code';
-
-
-/**
- * Claude Agent
- * Powered by Claude Code provider
- */
-export class ClaudeAgent extends BaseAgent {
-  private modelInstance: LanguageModel | null = null;
-
-  constructor(config: AgentConfig = {}) {
-    super('claude', config);
-  }
-
-  /**
-   * Get or create the language model instance
-   * 
-   * Supports Claude Code provider options:
-   * - allowedTools, disallowedTools, mcpServers, permissionMode, maxTurns, cwd, verbose
-   * See: https://ai-sdk.dev/providers/community-providers/claude-code
-   */
-  async getModel(): Promise<LanguageModel> {
-    if (!this.modelInstance) {
-      // Dynamic import to handle optional peer dependency
-
-      // Claude Code provider takes model ID as string parameter
-      // Uses CLI authentication (claude login) - API key not needed in code
-      // Model shortcuts: 'opus', 'sonnet', 'haiku'
-      const modelId = this.config.model || 'sonnet';
-
-      // Check if custom provider options are provided
-      const hasCustomOptions =
-        this.config.allowedTools ||
-        this.config.disallowedTools ||
-        this.config.mcpServers ||
-        this.config.permissionMode ||
-        this.config.maxTurns ||
-        this.config.cwd !== undefined ||
-        this.config.verbose !== undefined;
-
-      if (hasCustomOptions) {
-        // Create custom provider instance with options
-        const customProvider = createClaudeCode({
-          defaultSettings: {
-            allowedTools: this.config.allowedTools as string[] | undefined,
-            disallowedTools: this.config.disallowedTools as string[] | undefined,
-            mcpServers: this.config.mcpServers as Record<string, McpServerConfig> | undefined,
-            permissionMode: this.config.permissionMode as 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan' | undefined,
-            maxTurns: this.config.maxTurns as number | undefined,
-            cwd: this.config.cwd as string | undefined,
-            verbose: this.config.verbose as boolean | undefined,
-          }
-        });
-        this.modelInstance = customProvider(modelId);
-      } else {
-        // Use default provider instance
-        this.modelInstance = claudeCode(modelId);
-      }
-    }
-
-    return this.modelInstance;
-  }
-
-  /**
-   * Override configure to reset model instance when config changes
-   */
-  configure(config: AgentConfig): void {
-    super.configure(config);
-    // Reset model instance so it's recreated with new config
-    this.modelInstance = null;
-  }
-}
-

package/src/agents/codex-agent.ts

@@ -1,72 +0,0 @@
-import { BaseAgent } from './base-agent.js';
-import type { AgentConfig } from '../types.js';
-import type { LanguageModel } from 'ai';
-
-/**
- * Codex Agent
- * Powered by Codex CLI provider
- */
-export class CodexAgent extends BaseAgent {
-  private modelInstance: LanguageModel | null = null;
-
-  constructor(config: AgentConfig = {}) {
-    super('codex', config);
-  }
-
-  /**
-   * Get or create the language model instance
-   * 
-   * Supports Codex CLI provider options:
-   * - reasoningEffort, approvalMode, sandboxMode, mcpServers, verbose, logger
-   * - Can use OPENAI_API_KEY environment variable for authentication
-   * See: https://ai-sdk.dev/providers/community-providers/codex-cli
-   */
-  async getModel(): Promise<LanguageModel> {
-    if (!this.modelInstance) {
-      // Dynamic import to handle optional peer dependency
-      const { codexCli } = await import('ai-sdk-provider-codex-cli');
-      
-      // Codex CLI provider takes model ID as string parameter
-      // Uses CLI authentication or OPENAI_API_KEY env var
-      // Current models: 'gpt-5.2-codex', 'gpt-5.2', 'gpt-5.1-codex-max', 'gpt-5.1-codex-mini'
-      const modelId = this.config.model || 'gpt-5.2-codex';
-      
-      // Check if per-model settings are provided
-      const hasModelSettings =
-        this.config.reasoningEffort !== undefined ||
-        this.config.approvalMode !== undefined ||
-        this.config.sandboxMode !== undefined ||
-        this.config.mcpServers !== undefined ||
-        this.config.verbose !== undefined ||
-        this.config.logger !== undefined;
-
-      if (hasModelSettings) {
-        // Pass settings as second parameter
-        // Using type assertion for flexibility with provider-specific types
-        this.modelInstance = codexCli(modelId, {
-          reasoningEffort: this.config.reasoningEffort as 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | undefined,
-          approvalMode: this.config.approvalMode as 'untrusted' | 'on-failure' | 'on-request' | 'never' | undefined,
-          sandboxMode: this.config.sandboxMode as 'read-only' | 'workspace-write' | 'danger-full-access' | undefined,
-          mcpServers: this.config.mcpServers as any,
-          verbose: this.config.verbose as boolean | undefined,
-          logger: this.config.logger as any,
-        } as any);
-      } else {
-        // Create model instance without additional settings
-        this.modelInstance = codexCli(modelId);
-      }
-    }
-
-    return this.modelInstance;
-  }
-
-  /**
-   * Override configure to reset model instance when config changes
-   */
-  configure(config: AgentConfig): void {
-    super.configure(config);
-    // Reset model instance so it's recreated with new config
-    this.modelInstance = null;
-  }
-}
-

package/src/agents/intella-lite-agent.ts

@@ -1,55 +0,0 @@
-import { createOpenAI } from '@ai-sdk/openai';
-import type { LanguageModel } from 'ai';
-import { BaseAgent } from './base-agent.js';
-import type { AgentConfig } from '../types.js';
-
-/**
- * Intella Lite Agent
- * Lightweight default agent using OpenAI-compatible interface
- * This is a separate implementation from Mielto
- */
-export class IntellaLiteAgent extends BaseAgent {
-  private modelInstance: LanguageModel | null = null;
-
-  constructor(config: AgentConfig = {}) {
-    super('intella-lite', config);
-  }
-
-  /**
-   * Get or create the language model instance
-   */
-  getModel(): LanguageModel {
-    if (!this.modelInstance) {
-      // Use OpenAI provider as base for Intella Lite
-      // Default to a lightweight model if not specified
-      const modelId = this.config.model || 'gpt-4o-mini';
-      
-      const apiKey = this.config.apiKey || process.env.OPENAI_API_KEY;
-      if (!apiKey) {
-        throw new Error(
-          'OpenAI API key is required for Intella Lite agent. Set OPENAI_API_KEY environment variable or provide apiKey in config.'
-        );
-      }
-      
-      const provider = createOpenAI({
-        apiKey,
-        baseURL: this.config.baseURL || process.env.OPENAI_BASE_URL,
-        headers: this.config.headers,
-      });
-
-      this.modelInstance = provider.chat(modelId);
-    }
-
-    return this.modelInstance;
-  }
-
-  /**
-   * Override configure to reset model instance when config changes
-   */
-  configure(config: AgentConfig): void {
-    super.configure(config);
-    // Reset model instance so it's recreated with new config
-    this.modelInstance = null;
-  }
-}
-

package/src/agents/opencode-agent.ts

@@ -1,45 +0,0 @@
-import { BaseAgent } from './base-agent.js';
-import type { AgentConfig } from '../types.js';
-import type { LanguageModel } from 'ai';
-
-/**
- * OpenCode Agent
- * Powered by OpenCode SDK provider
- */
-export class OpenCodeAgent extends BaseAgent {
-  private modelInstance: LanguageModel | null = null;
-
-  constructor(config: AgentConfig = {}) {
-    super('opencode', config);
-  }
-
-  /**
-   * Get or create the language model instance
-   */
-  async getModel(): Promise<LanguageModel> {
-    if (!this.modelInstance) {
-      // Dynamic import to handle optional peer dependency
-      const { opencode } = await import('ai-sdk-provider-opencode-sdk');
-      
-      // OpenCode provider takes model ID as string parameter
-      // Uses CLI authentication (opencode login) - API key not needed in code
-      // Model format: 'provider/model-id' (e.g., 'anthropic/claude-sonnet-4-5-20250929')
-      const modelId = this.config.model || 'anthropic/claude-sonnet-4-5-20250929';
-      
-      // Create model instance directly
-      this.modelInstance = opencode(modelId);
-    }
-
-    return this.modelInstance;
-  }
-
-  /**
-   * Override configure to reset model instance when config changes
-   */
-  configure(config: AgentConfig): void {
-    super.configure(config);
-    // Reset model instance so it's recreated with new config
-    this.modelInstance = null;
-  }
-}
-