computer-agents 0.5.0 → 0.6.0

package/README.md

@@ -51,28 +51,38 @@ npm install computer-agents
 ### Local Computer Agent
 
 ```typescript
-import { Agent, run, LocalRuntime } from 'computer-agents';
+import { Agent, run } from 'computer-agents';
 
 const agent = new Agent({
-  agentType: "computer",
-  runtime: new LocalRuntime(),
-  workspace: "./my-project",
-  instructions: "You are an expert developer."
+  type: "computer",
+  workspace: "./my-project",  // String path = automatic local execution
+  instructions: "You are an expert developer.",
+  debug: true  // Optional: show detailed logs
 });
 
 const result = await run(agent, "Create a Python script that calculates fibonacci numbers");
 console.log(result.finalOutput);
 ```
 
-### Cloud Computer Agent (with workspace sync)
+### Cloud Computer Agent (Coming Soon)
+
+> **Note**: Cloud execution for remote execution is under development and will be available in an upcoming release. The infrastructure is production-ready, and we're finalizing API access for public use.
+
+When cloud execution becomes available, you'll use Projects for cloud workspaces:
 
 ```typescript
-import { Agent, run, CloudRuntime } from 'computer-agents';
+import { Agent, run, CloudClient } from 'computer-agents';
+
+// Cloud execution will be available soon
+const client = new CloudClient({ apiKey: process.env.TESTBASE_API_KEY });
+const project = await client.createProject({
+  name: 'my-project',
+  localPath: './my-project'  // Enable local sync
+});
 
 const agent = new Agent({
-  agentType: "computer",
-  runtime: new CloudRuntime({ apiKey: process.env.TESTBASE_API_KEY }),
-  workspace: "./my-project",
+  type: "computer",
+  workspace: project,  // Project = automatic cloud execution
   instructions: "You are an expert developer."
 });
 
@@ -81,36 +91,17 @@ console.log(result.finalOutput);
 // Files automatically synced from cloud to local workspace
 ```
 
-### Cloud-Only Mode (no local sync)
-
-Perfect for CI/CD, experiments, and parallel tasks:
-
-```typescript
-const runtime = new CloudRuntime({
-  apiKey: process.env.TESTBASE_API_KEY,
-  skipWorkspaceSync: true,  // No upload/download, faster execution
-});
-
-const agent = new Agent({
-  agentType: "computer",
-  runtime,
-  workspace: "./cloud-workspace",  // Placeholder, not synced
-});
-
-const result = await run(agent, "Build a REST API with Express");
-// Executes in fresh cloud workspace, results stay in cloud
-```
+For now, use local execution (workspace as string) for all computer agent tasks.
 
 ### Streaming Progress (Real-Time Visibility)
 
 Track agent execution in real-time with `runStreamed()`:
 
 ```typescript
-import { Agent, runStreamed, LocalRuntime } from 'computer-agents';
+import { Agent, runStreamed } from 'computer-agents';
 
 const agent = new Agent({
-  agentType: "computer",
-  runtime: new LocalRuntime(),
+  type: "computer",
   workspace: "./my-project",
 });
 
@@ -162,29 +153,83 @@ for await (const event of runStreamed(agent, task)) {
 }
 ```
 
-### Parallel Execution (The Game Changer)
+### Project Management (Efficient Workspace Sync) - Coming Soon
 
-Run multiple agents simultaneously:
+> **Note**: Project Management for cloud execution is under development and will be available in an upcoming release.
+
+When available, manage workspaces with the Project API - perfect for organizing code and syncing with cloud storage:
 
 ```typescript
-import { Agent, run, CloudRuntime } from 'computer-agents';
+import { CloudClient, Agent, run } from 'computer-agents';
+
+const client = new CloudClient({ apiKey: process.env.TESTBASE_API_KEY });
+
+// Create a synced project (local ↔ cloud)
+const project = await client.createProject({
+  name: 'my-app',
+  localPath: './src'  // Enables bidirectional sync
+});
 
-const runtime = new CloudRuntime({
-  apiKey: process.env.TESTBASE_API_KEY,
-  skipWorkspaceSync: true,
+// Incremental sync - only uploads changed files (10x faster!)
+await project.sync({ direction: 'up' });  // Upload changes
+await project.sync({ direction: 'down' }); // Download changes
+await project.sync({ direction: 'both' }); // Bi-directional sync
+
+// Agents automatically use project workspaces
+const agent = new Agent({
+  type: 'computer',
+  workspace: project  // Project = cloud execution
 });
 
+await run(agent, 'Add user authentication');
+// Changes are tracked, next sync will be incremental!
+```
+
+**Key Benefits:**
+- **10x faster sync** - Only transfers changed files (SHA-256 hashing)
+- **Organized workspaces** - Manage multiple projects easily
+- **Automatic tracking** - Sync state persisted in `.testbase/sync-state.json`
+- **Flexible sync** - Choose `up`, `down`, or `both` directions
+
+**Example: Incremental Sync Performance**
+- Full workspace (500MB): ~35 seconds
+- Incremental (5MB changes): ~3 seconds
+
+```typescript
+// List all projects
+const projects = await client.listProjects();
+
+// Get existing project
+const project = await client.getProject('project-id');
+
+// Get sync statistics
+const stats = await project.getSyncStats();
+console.log(stats); // { lastSyncAt, fileCount, version }
+
+// Manual file operations
+await project.upload(['file1.txt', 'file2.txt']);
+await project.download(['file1.txt']);
+await project.readFile('config.json');
+await project.writeFile('config.json', '{ "new": "data" }');
+
+// Delete project
+await client.deleteProject(project.id);
+```
+
+### Parallel Execution
+
+**Local Parallel Execution (Available Now):**
+
+You can run multiple agents in parallel for local development:
+
+```typescript
+import { Agent, run } from 'computer-agents';
+
 // Create 5 agents to test different approaches
-const agents = [
-  'Express',
-  'Fastify',
-  'Koa',
-  'Hapi',
-  'Restify'
-].map(framework => new Agent({
+const frameworks = ['Express', 'Fastify', 'Koa', 'Hapi', 'Restify'];
+const agents = frameworks.map(framework => new Agent({
   name: `${framework} Agent`,
-  agentType: 'computer',
-  runtime,
+  type: 'computer',
   workspace: `./test-${framework.toLowerCase()}`,
   instructions: `You are an expert in ${framework}.`
 }));
@@ -198,11 +243,15 @@ const results = await Promise.all(
 console.log('All 5 frameworks tested in parallel!');
 ```
 
+**Cloud Parallel Execution (Coming Soon):**
+
+> **Note**: Large-scale parallel execution with cloud infrastructure is coming soon. When available, you'll be able to scale to 100+ concurrent agents using CloudClient and Projects.
+
 ### LLM Agent (for planning and reasoning)
 
 ```typescript
 const planner = new Agent({
-  agentType: "llm",
+  type: "llm",
   model: "gpt-4o",
   instructions: "You create detailed implementation plans."
 });
@@ -213,7 +262,12 @@ console.log(plan.finalOutput);
 
 ## Core Concepts
 
-### Agent Types
+computer-agents has just **2 core concepts**:
+
+1. **Agent** - Single unified interface for both LLM and computer-use agents
+2. **CloudClient** - Manage cloud projects and infrastructure (coming soon)
+
+### 1. Agent - Unified Interface
 
 ```typescript
 type AgentType = 'llm' | 'computer';
@@ -224,46 +278,37 @@ type AgentType = 'llm' | 'computer';
 | `'llm'` | OpenAI API | Planning, reasoning, reviewing |
 | `'computer'` | Codex SDK | Code, tests, file operations, terminal commands |
 
-### Runtime Abstraction
-
-Switch between local and cloud execution with one config change:
+**Key insight:** Workspace type determines execution mode automatically:
 
 ```typescript
-// Local execution
-const localRuntime = new LocalRuntime();
-
-// Cloud execution
-const cloudRuntime = new CloudRuntime({
-  apiKey: process.env.TESTBASE_API_KEY
+// Local execution (workspace = string path)
+const localAgent = new Agent({
+  type: 'computer',
+  workspace: './my-project'  // String = local execution
 });
 
-// Use either runtime with any agent
-const agent = new Agent({
-  agentType: 'computer',
-  runtime: localRuntime,  // or cloudRuntime
-  workspace: './project'
+// Cloud execution (workspace = Project) - Coming Soon
+const cloudAgent = new Agent({
+  type: 'computer',
+  workspace: project  // Project = cloud execution
 });
 ```
 
-### Workspace Modes
+### 2. CloudClient - Infrastructure Management (Coming Soon)
 
-**Default Mode** - Sync local ↔ cloud:
-```typescript
-const runtime = new CloudRuntime({
-  apiKey: process.env.TESTBASE_API_KEY,
-  // skipWorkspaceSync: false (default)
-});
-// Uploads local files, downloads results
-```
+Single entry point for cloud operations:
 
-**Cloud-Only Mode** - No local sync:
 ```typescript
-const runtime = new CloudRuntime({
-  apiKey: process.env.TESTBASE_API_KEY,
-  skipWorkspaceSync: true,  // NEW in v0.4.6
-});
-// Fresh cloud workspace, no upload/download
-// Perfect for CI/CD, experiments, parallel tasks
+const client = new CloudClient({ apiKey: process.env.TESTBASE_API_KEY });
+
+// Project management
+const projects = await client.listProjects();
+const project = await client.createProject({ name: 'my-app' });
+await client.deleteProject(project.id);
+
+// Infrastructure (future)
+const containers = await client.listContainers();
+const stats = await client.getContainerStats(containerId);
 ```
 
 ### Session Continuity
@@ -272,8 +317,8 @@ Agents automatically maintain context across multiple runs:
 
 ```typescript
 const agent = new Agent({
-  agentType: 'computer',
-  runtime: new LocalRuntime(),
+  type: 'computer',
+  workspace: './my-project'
 });
 
 await run(agent, 'Create app.py');           // New session
@@ -323,25 +368,25 @@ node examples/testbase/hello-world.mjs
 Build custom workflows by composing agents:
 
 ```typescript
-import { Agent, run, LocalRuntime } from 'computer-agents';
+import { Agent, run } from 'computer-agents';
 
 // LLM creates plan
 const planner = new Agent({
-  agentType: 'llm',
+  type: 'llm',
   model: 'gpt-4o',
   instructions: 'Create detailed implementation plans.'
 });
 
 // Computer agent executes plan
 const executor = new Agent({
-  agentType: 'computer',
-  runtime: new LocalRuntime(),
+  type: 'computer',
+  workspace: './my-project',
   instructions: 'Execute implementation plans.'
 });
 
 // LLM reviews result
 const reviewer = new Agent({
-  agentType: 'llm',
+  type: 'llm',
   model: 'gpt-4o',
   instructions: 'Review implementations for quality.'
 });
@@ -361,48 +406,45 @@ const review = await run(reviewer, `Review: ${code.finalOutput}`);
 # Required for LLM agents and computer agents (Codex SDK uses OpenAI)
 OPENAI_API_KEY=your-openai-key
 
-# Optional for CloudRuntime (has default)
+# Optional for CloudClient (when cloud execution becomes available)
 TESTBASE_API_KEY=your-testbase-key  # Get from testbase.ai
 ```
 
-### Runtime Configuration
-
-```typescript
-// LocalRuntime
-const localRuntime = new LocalRuntime({
-  debug: true,              // Show detailed logs
-  skipGitRepoCheck: true,   // Allow execution outside git repos (default: true)
-});
-
-// CloudRuntime
-const cloudRuntime = new CloudRuntime({
-  apiKey: process.env.TESTBASE_API_KEY,  // Required (or use env var)
-  debug: true,                            // Show detailed logs
-  skipWorkspaceSync: false,               // Sync local ↔ cloud (default: false)
-  timeout: 600000,                        // 10 minutes (default)
-});
-```
-
 ### Agent Configuration
 
 ```typescript
 const agent = new Agent({
   name: "My Agent",                    // Optional, auto-generated if omitted
-  agentType: 'computer',               // 'llm' | 'computer'
+  type: 'computer',                    // 'llm' | 'computer'
 
   // Computer agent specific
-  runtime: new LocalRuntime(),         // Required for computer agents
   workspace: './my-project',           // Required for computer agents
+                                       // String = local, Project = cloud
 
   // LLM agent specific
   model: 'gpt-4o',                     // Required for LLM agents
 
+  // Execution settings (computer agents only)
+  debug: true,                         // Show detailed logs
+  timeout: 600000,                     // 10 minutes (default)
+  skipGitRepoCheck: true,              // Allow execution outside git repos (default: true)
+
   // Shared
   instructions: "You are helpful.",    // System prompt
   mcpServers: [...],                   // MCP server configurations (optional)
 });
 ```
 
+### CloudClient Configuration (Coming Soon)
+
+```typescript
+const client = new CloudClient({
+  apiKey: process.env.TESTBASE_API_KEY,  // Required (or use env var)
+  debug: true,                            // Show detailed logs
+  timeout: 600000,                        // 10 minutes (default)
+});
+```
+
 ## MCP Server Integration
 
 Unified MCP configuration works for both agent types:
@@ -427,8 +469,8 @@ const mcpServers: McpServerConfig[] = [
 
 // Works for both LLM and computer agents!
 const agent = new Agent({
-  agentType: 'computer',
-  runtime: new LocalRuntime(),
+  type: 'computer',
+  workspace: './my-project',
   mcpServers  // Automatically converted to appropriate format
 });
 ```
@@ -439,17 +481,17 @@ The SDK handles conversion automatically:
 
 ## Performance
 
-### LocalRuntime
+### Local Execution (workspace = string path)
 - **Cold start**: <1 second
 - **Warm execution**: <100ms overhead
 - **Parallelization**: Limited by local CPU/memory
 
-### CloudRuntime (Default Mode)
+### Cloud Execution (workspace = Project) - Coming Soon
 - **First execution**: 30-45 seconds (includes workspace sync)
 - **Subsequent runs**: ~5-10 seconds
 - **Parallelization**: Scale to 100+ agents
 
-### CloudRuntime (Cloud-Only Mode)
+### Cloud-Only Mode (no localPath in Project) - Coming Soon
 - **Execution**: Faster (no sync overhead)
 - **Parallelization**: Scale to 100+ agents
 - **Perfect for**: CI/CD, experiments, parallel tasks
@@ -465,7 +507,28 @@ class Agent {
   currentThreadId: string | undefined;  // Current session thread ID
   resetSession(): void;                 // Start new session
   workspace: string;                    // Workspace path
-  agentType: 'llm' | 'computer';       // Agent type
+  type: 'llm' | 'computer';            // Agent type
+}
+
+interface AgentConfiguration {
+  name?: string;                       // Optional, auto-generated if omitted
+  type: 'llm' | 'computer';           // Agent type
+
+  // Computer agent specific
+  workspace?: string | Project;        // Required for computer agents
+                                      // String = local, Project = cloud
+
+  // LLM agent specific
+  model?: string;                      // Required for LLM agents
+
+  // Execution settings (computer agents only)
+  debug?: boolean;                     // Show detailed logs
+  timeout?: number;                    // Execution timeout (default: 600000ms)
+  skipGitRepoCheck?: boolean;          // Allow execution outside git repos (default: true)
+
+  // Shared
+  instructions?: string;               // System prompt
+  mcpServers?: McpServerConfig[];      // MCP server configurations
 }
 ```
 
@@ -503,35 +566,89 @@ for await (const event of runStreamed(agent, 'Create app.py')) {
 }
 ```
 
-### LocalRuntime
+### CloudClient (Coming Soon)
+
+> **Note**: CloudClient for cloud execution is under development and will be available in an upcoming release.
 
 ```typescript
-class LocalRuntime implements Runtime {
+class CloudClient {
   constructor(config?: {
+    apiKey?: string;              // Required (or env var TESTBASE_API_KEY)
     debug?: boolean;
-    skipGitRepoCheck?: boolean;  // default: true
+    timeout?: number;             // default: 600000ms (10 min)
   });
 
-  readonly type: 'local';
-  execute(config: RuntimeExecutionConfig): Promise<RuntimeExecutionResult>;
+  // Project management
+  async createProject(config: CreateProjectConfig): Promise<Project>;
+  async listProjects(): Promise<Project[]>;
+  async getProject(id: string): Promise<Project>;
+  async deleteProject(id: string, hard?: boolean): Promise<void>;
+
+  // Infrastructure (future)
+  async listContainers(): Promise<Container[]>;
+  async getContainerStats(id: string): Promise<ContainerStats>;
 }
 ```
 
-### CloudRuntime
+### Project (Coming Soon)
 
-```typescript
-class CloudRuntime implements Runtime {
-  constructor(config?: {
-    apiKey?: string;              // Required (or env var TESTBASE_API_KEY)
-    debug?: boolean;
-    skipWorkspaceSync?: boolean;  // default: false
-    timeout?: number;             // default: 600000ms (10 min)
-  });
+> **Note**: Project API for cloud execution is under development and will be available in an upcoming release.
 
-  readonly type: 'cloud';
-  execute(config: RuntimeExecutionConfig): Promise<RuntimeExecutionResult>;
-  cleanup(): Promise<void>;
+```typescript
+class Project {
+  // Properties
+  readonly id: string;
+  readonly name: string;
+  readonly localPath: string | undefined;
+  readonly cloudPath: string;
+
+  // Sync operations (when localPath provided)
+  async sync(options?: SyncOptions): Promise<SyncResult>;
+  async upload(files: string[]): Promise<void>;
+  async download(files: string[]): Promise<void>;
+
+  // File operations
+  async listFiles(pattern?: string): Promise<ProjectFile[]>;
+  async readFile(path: string): Promise<string>;
+  async writeFile(path: string, content: string): Promise<void>;
+
+  // Management
+  async delete(hard?: boolean): Promise<void>;
+  async getStats(): Promise<ProjectStats>;
+  async getSyncStats(): Promise<SyncStats>;
+  async resetSyncState(): Promise<void>;
+
+  // Workspace path for agents
+  getWorkspacePath(): string;
 }
+
+// Create project via CloudClient
+const client = new CloudClient({ apiKey: process.env.TESTBASE_API_KEY });
+const project = await client.createProject({
+  name: 'my-app',
+  localPath: './src',       // Optional - enables sync if provided
+  description: 'My app',    // Optional
+  metadata: { ... },        // Optional
+});
+
+// Sync options (when localPath provided)
+await project.sync({
+  direction: 'both',        // 'up' | 'down' | 'both'
+  force: false,             // Force full sync (skip incremental)
+  pattern: '*.ts'          // Optional glob pattern
+});
+```
+
+### Runtime Classes (Internal Use)
+
+> **Note**: Runtime classes are used internally by the SDK. Most users should not need to interact with them directly. Use CloudClient for cloud operations instead.
+
+These classes are marked `@internal` and are primarily for advanced use cases:
+
+```typescript
+// For advanced use only - not needed for typical usage
+class LocalRuntime implements Runtime { ... }
+class CloudRuntime implements Runtime { ... }
 ```
 
 ## Architecture
@@ -561,15 +678,15 @@ computer-agents/
 
 ## Best Practices
 
-### Choosing Local vs Cloud
+### Choosing Local vs Cloud Execution
 
-**Use LocalRuntime when:**
+**Use Local Execution (workspace = string) when:**
 - Development and rapid iteration
 - Working with local files/tools
 - No cloud infrastructure needed
 - Testing and debugging
 
-**Use CloudRuntime when:**
+**Use Cloud Execution (workspace = Project) when:** *(Coming Soon)*
 - Parallel execution at scale
 - Production deployments
 - CI/CD pipelines
@@ -578,12 +695,12 @@ computer-agents/
 
 ### Choosing Workspace Sync Mode
 
-**Use Default Mode (skipWorkspaceSync: false) when:**
+**With localPath (bidirectional sync):** *(Coming Soon)*
 - You need results in your local filesystem
 - Continuing work locally after cloud execution
 - Interactive development workflows
 
-**Use Cloud-Only Mode (skipWorkspaceSync: true) when:**
+**Without localPath (cloud-only):** *(Coming Soon)*
 - CI/CD pipelines (no local filesystem)
 - Running experiments at scale
 - Parallel task execution
@@ -595,13 +712,13 @@ Always use the **same agent instance** for session continuity:
 
 ```typescript
 // ✅ Correct - same agent, continuous session
-const agent = new Agent({...});
+const agent = new Agent({ type: 'computer', workspace: './project' });
 await run(agent, 'Task 1');
 await run(agent, 'Task 2');  // Continues session
 
 // ❌ Wrong - different agents, new sessions
-await run(new Agent({...}), 'Task 1');
-await run(new Agent({...}), 'Task 2');  // Different session!
+await run(new Agent({ type: 'computer', workspace: './project' }), 'Task 1');
+await run(new Agent({ type: 'computer', workspace: './project' }), 'Task 2');  // Different session!
 ```
 
 ### Parallel Execution
@@ -625,15 +742,20 @@ for (let i = 0; i < agents.length; i++) {
 
 ## Cloud Infrastructure
 
-computer-agents includes production-ready cloud infrastructure:
+> **Coming Soon**: Public access to cloud execution infrastructure is under development.
+
+computer-agents includes production-ready cloud infrastructure that will soon be available:
 
 - **GCS Bucket** - Workspace storage (`gs://testbase-workspaces`)
 - **GCE VM** - Codex SDK execution server
 - **Pay-per-token** - Credit-based billing system
 - **API Keys** - Database-backed authentication
 - **Budget Protection** - Daily/monthly spending limits
+- **Project Management** - Incremental sync with SHA-256 hashing
 
-See [Cloud Infrastructure docs](./packages/cloud-infrastructure/README.md) for deployment details.
+The infrastructure is fully built and tested. We're finalizing API access for public use. Stay tuned for updates!
+
+For now, `LocalRuntime` provides full computer-use agent capabilities for local development.
 
 ## Documentation
 
@@ -648,24 +770,73 @@ See [Cloud Infrastructure docs](./packages/cloud-infrastructure/README.md) for d
 export OPENAI_API_KEY=sk-...
 ```
 
-### "TESTBASE_API_KEY required"
+### "TESTBASE_API_KEY required" *(When using CloudClient)*
 ```bash
 export TESTBASE_API_KEY=your-key
 # Or provide in constructor:
-new CloudRuntime({ apiKey: 'your-key' })
+new CloudClient({ apiKey: 'your-key' })
 ```
 
 ### Session continuity not working
-Ensure you're using the **same agent instance** across runs.
+Ensure you're using the **same agent instance** across runs:
+```typescript
+const agent = new Agent({ type: 'computer', workspace: './project' });
+await run(agent, 'Task 1');
+await run(agent, 'Task 2');  // Same instance = session continues
+```
 
-### Cloud execution slow
-Use `skipWorkspaceSync: true` to skip upload/download overhead:
+### "Computer agents require a workspace"
+Computer agents need a workspace parameter:
 ```typescript
-new CloudRuntime({ skipWorkspaceSync: true })
+// ✅ Correct
+new Agent({ type: 'computer', workspace: './my-project' })
+
+// ❌ Missing workspace
+new Agent({ type: 'computer' })  // Error!
 ```
 
 ## What's New
 
+### v0.6.0 - Major UX Simplification
+
+**Breaking Changes:**
+- Runtime objects removed from public API - no more `LocalRuntime` or `CloudRuntime` in user code
+- Agent configuration simplified: `agentType` → `type`, workspace accepts `string | Project`
+- CloudClient introduced as single entry point for cloud operations
+- Execution settings moved from Runtime to Agent level
+
+**Benefits:**
+- 40-50% less code for typical use cases
+- Reduced core concepts from 5 to 2 (Agent + CloudClient)
+- More intuitive API with better TypeScript inference
+- Automatic runtime selection based on workspace type
+
+**Migration:**
+```typescript
+// Before (v0.5.x)
+const agent = new Agent({
+  agentType: 'computer',
+  runtime: new LocalRuntime({ debug: true }),
+  workspace: './project'
+});
+
+// After (v0.6.0)
+const agent = new Agent({
+  type: 'computer',
+  workspace: './project',
+  debug: true
+});
+```
+
+See [MIGRATION_v0.5_to_v0.6.md](https://github.com/TestBase-ai/computer-agents/blob/main/MIGRATION_v0.5_to_v0.6.md) for complete migration guide.
+
+### v0.5.0
+- **Project Management System**: Organize and sync workspaces efficiently
+- Incremental sync with SHA-256 hashing - 10x faster than full sync
+- Track sync state automatically in `.testbase/sync-state.json`
+- Native Web API FormData for reliable file uploads
+- Seamless agent integration with project workspaces
+
 ### v0.4.9
 - **Streaming Progress**: New `runStreamed()` function for real-time visibility
 - Stream events: thread.started, turn.started, item.completed, turn.completed
@@ -692,11 +863,12 @@ new CloudRuntime({ skipWorkspaceSync: true })
 computer-agents extends OpenAI's Agents SDK with:
 
 1. **Computer-use agent type** - Direct Codex SDK integration
-2. **Runtime abstraction** - Local and cloud execution modes
-3. **Parallel orchestration** - Native support for concurrent agents
-4. **Session continuity** - Automatic thread management
-5. **Cloud infrastructure** - Production-ready execution platform
-6. **Unified MCP config** - Single configuration for all agent types
+2. **Simplified API** - No runtime objects needed, workspace type determines execution
+3. **CloudClient** - Unified interface for cloud operations and project management
+4. **Parallel orchestration** - Native support for concurrent agents
+5. **Session continuity** - Automatic thread management
+6. **Cloud infrastructure** - Production-ready execution platform (coming soon for public access)
+7. **Unified MCP config** - Single configuration for all agent types
 
 ## License
 

package/dist/index.d.ts

@@ -1,5 +1,3 @@
 import type * as CoreTypes from 'computer-agents-core';
-import { LocalRuntime as CoreLocalRuntime, CloudRuntime as CoreCloudRuntime } from 'computer-agents-core';
 export declare function run<TAgent extends CoreTypes.Agent<any, any>, TContext = undefined>(agent: TAgent, input: string | CoreTypes.AgentInputItem[] | CoreTypes.RunState<TContext, TAgent>, options?: CoreTypes.StreamRunOptions<TContext> | CoreTypes.NonStreamRunOptions<TContext>): Promise<CoreTypes.RunResult<TContext, TAgent> | CoreTypes.StreamedRunResult<TContext, TAgent>>;
 export * from 'computer-agents-core';
-export { CoreLocalRuntime as LocalRuntime, CoreCloudRuntime as CloudRuntime };

package/dist/index.js

@@ -14,14 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CloudRuntime = exports.LocalRuntime = void 0;
 exports.run = run;
 const node_url_1 = require("node:url");
 const node_path_1 = require("node:path");
-// Import runtime classes directly for re-export
-const computer_agents_core_1 = require("computer-agents-core");
-Object.defineProperty(exports, "LocalRuntime", { enumerable: true, get: function () { return computer_agents_core_1.LocalRuntime; } });
-Object.defineProperty(exports, "CloudRuntime", { enumerable: true, get: function () { return computer_agents_core_1.CloudRuntime; } });
 const dynamicImport = new Function('specifier', 'return import(specifier);');
 let coreModule;
 function getCore() {
@@ -74,6 +69,6 @@ async function run(agent, input, options) {
     await ensureProviderForAgent(agent);
     return coreRun(agent, input, options);
 }
-// Re-export everything from core
+// Re-export everything from core (includes LocalRuntime and CloudRuntime)
 __exportStar(require("computer-agents-core"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AA2EA,kBAcC;AAzFD,uCAAyC;AACzC,yCAAoC;AAIpC,gDAAgD;AAChD,+DAA0G;AAyF7E,6FAzFJ,mCAAgB,OAyFA;AAAsB,6FAzFJ,mCAAgB,OAyFA;AAnF3E,MAAM,aAAa,GAAG,IAAI,QAAQ,CAChC,WAAW,EACX,2BAA2B,CACW,CAAC;AAEzC,IAAI,UAAwC,CAAC;AAC7C,SAAS,OAAO;IACd,IAAI,UAAU,EAAE,CAAC;QACf,OAAO,UAAU,CAAC;IACpB,CAAC;IACD,IAAI,CAAC;QACH,UAAU,GAAG,OAAO,CAAC,sBAAsB,CAAqB,CAAC;IACnE,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,SAAS,GAAG,IAAA,mBAAO,EAAC,SAAS,EAAE,iCAAiC,CAAC,CAAC;QACxE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAqB,CAAC;IACtD,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,IAAI,yBAES,CAAC;AAEd,KAAK,UAAU,kBAAkB;IAC/B,IAAI,yBAAyB,EAAE,CAAC;QAC9B,OAAO,yBAAyB,CAAC;IACnC,CAAC;IAED,yBAAyB,GAAG,CAAC,KAAK,IAAI,EAAE;QACtC,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,MAAM,aAAa,CAAC,wBAAwB,CAAC,CAAC;YAC1D,OAAO,GAAG,CAAC,cAA2C,CAAC;QACzD,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,QAAQ,GAAG,IAAA,wBAAa,EAC5B,IAAA,mBAAO,EAAC,SAAS,EAAE,oCAAoC,CAAC,CACzD,CAAC,IAAI,CAAC;YACP,MAAM,GAAG,GAAG,MAAM,aAAa,CAAC,QAAQ,CAAC,CAAC;YAC1C,OAAO,GAAG,CAAC,cAA2C,CAAC;QACzD,CAAC;IACH,CAAC,CAAC,EAAE,CAAC;IAEL,OAAO,yBAAyB,CAAC;AACnC,CAAC;AAED,IAAI,WAA4B,CAAC;AAEjC,KAAK,UAAU,sBAAsB,CAAC,KAAgC;IACpE,MAAM,IAAI,GAAG,OAAO,EAAE,CAAC;IAEvB,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC;IAC3C,IAAI,SAAS,KAAK,KAAK,EAAE,CAAC;QACxB,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,kBAAkB,GAAG,MAAM,kBAAkB,EAAE,CAAC;YACtD,WAAW,GAAG,IAAI,kBAAkB,EAAE,CAAC;QACzC,CAAC;QACD,IAAI,CAAC,uBAAuB,CAAC,WAAW,CAAC,CAAC;IAC5C,CAAC;IACD,qDAAqD;IACrD,wDAAwD;AAC1D,CAAC;AAED,MAAM,OAAO,GAAG,OAAO,EAAE,CAAC,GAAG,CAAC;AAEvB,KAAK,UAAU,GAAG,CAIvB,KAAa,EACb,KAAiF,EACjF,OAE2C;IAI3C,MAAM,sBAAsB,CAAC,KAAK,CAAC,CAAC;IACpC,OAAO,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,OAAc,CAAC,CAAC;AAC/C,CAAC;AAED,iCAAiC;AACjC,uDAAqC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAwEA,kBAcC;AAtFD,uCAAyC;AACzC,yCAAoC;AAQpC,MAAM,aAAa,GAAG,IAAI,QAAQ,CAChC,WAAW,EACX,2BAA2B,CACW,CAAC;AAEzC,IAAI,UAAwC,CAAC;AAC7C,SAAS,OAAO;IACd,IAAI,UAAU,EAAE,CAAC;QACf,OAAO,UAAU,CAAC;IACpB,CAAC;IACD,IAAI,CAAC;QACH,UAAU,GAAG,OAAO,CAAC,sBAAsB,CAAqB,CAAC;IACnE,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,SAAS,GAAG,IAAA,mBAAO,EAAC,SAAS,EAAE,iCAAiC,CAAC,CAAC;QACxE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAqB,CAAC;IACtD,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,IAAI,yBAES,CAAC;AAEd,KAAK,UAAU,kBAAkB;IAC/B,IAAI,yBAAyB,EAAE,CAAC;QAC9B,OAAO,yBAAyB,CAAC;IACnC,CAAC;IAED,yBAAyB,GAAG,CAAC,KAAK,IAAI,EAAE;QACtC,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,MAAM,aAAa,CAAC,wBAAwB,CAAC,CAAC;YAC1D,OAAO,GAAG,CAAC,cAA2C,CAAC;QACzD,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,QAAQ,GAAG,IAAA,wBAAa,EAC5B,IAAA,mBAAO,EAAC,SAAS,EAAE,oCAAoC,CAAC,CACzD,CAAC,IAAI,CAAC;YACP,MAAM,GAAG,GAAG,MAAM,aAAa,CAAC,QAAQ,CAAC,CAAC;YAC1C,OAAO,GAAG,CAAC,cAA2C,CAAC;QACzD,CAAC;IACH,CAAC,CAAC,EAAE,CAAC;IAEL,OAAO,yBAAyB,CAAC;AACnC,CAAC;AAED,IAAI,WAA4B,CAAC;AAEjC,KAAK,UAAU,sBAAsB,CAAC,KAAgC;IACpE,MAAM,IAAI,GAAG,OAAO,EAAE,CAAC;IAEvB,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC;IAC3C,IAAI,SAAS,KAAK,KAAK,EAAE,CAAC;QACxB,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,kBAAkB,GAAG,MAAM,kBAAkB,EAAE,CAAC;YACtD,WAAW,GAAG,IAAI,kBAAkB,EAAE,CAAC;QACzC,CAAC;QACD,IAAI,CAAC,uBAAuB,CAAC,WAAW,CAAC,CAAC;IAC5C,CAAC;IACD,qDAAqD;IACrD,wDAAwD;AAC1D,CAAC;AAED,MAAM,OAAO,GAAG,OAAO,EAAE,CAAC,GAAG,CAAC;AAEvB,KAAK,UAAU,GAAG,CAIvB,KAAa,EACb,KAAiF,EACjF,OAE2C;IAI3C,MAAM,sBAAsB,CAAC,KAAK,CAAC,CAAC;IACpC,OAAO,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,OAAc,CAAC,CAAC;AAC/C,CAAC;AAED,0EAA0E;AAC1E,uDAAqC"}

package/dist/metadata.js

@@ -4,9 +4,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.METADATA = void 0;
 exports.METADATA = {
     "name": "computer-agents",
-    "version": "0.5.0",
+    "version": "0.6.0",
     "versions": {
-        "computer-agents": "0.5.0"
+        "computer-agents": "0.6.0"
     }
 };
 exports.default = exports.METADATA;

package/package.json

@@ -2,7 +2,7 @@
   "name": "computer-agents",
   "repository": "https://github.com/TestBase-ai/computer-agents",
   "homepage": "https://testbase.ai/computer-agents",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Build computer-use agents that write code, run tests, and deploy apps. Seamless local and cloud execution with automatic session continuity.",
   "author": "Testbase",
   "main": "dist/index.js",
@@ -20,8 +20,8 @@
     "build-check": "tsc --noEmit -p ./tsconfig.test.json"
   },
   "dependencies": {
-    "computer-agents-core": "0.5.0",
-    "computer-agents-openai": "0.5.0"
+    "computer-agents-core": "0.6.0",
+    "computer-agents-openai": "0.6.0"
   },
   "keywords": [
     "computer-agents",