Fix tests and formatting for new API

- Update tests to use new Agent, Workspace, and Conversation constructors
- Test both new API and backwards compatibility exports
- Fix code formatting with prettier
- All CI steps now passing: build, lint, test, format:check

Author: openhands-agent

examples/basic-usage.ts

@@ -18,7 +18,7 @@ async function main() {
     const workspace = new Workspace({
       host: 'http://localhost:3000',
       workingDir: '/tmp',
-      apiKey: process.env.SESSION_API_KEY || 'your-session-api-key'
+      apiKey: process.env.SESSION_API_KEY || 'your-session-api-key',
     });
 
     // Create a new conversation
@@ -31,7 +31,7 @@ async function main() {
 
     // Start the conversation with an initial message
     await conversation.start({
-      initialMessage: 'Hello! Can you help me write a simple Python script?'
+      initialMessage: 'Hello! Can you help me write a simple Python script?',
     });
 
     console.log(`Conversation created with ID: ${conversation.id}`);
@@ -96,11 +96,11 @@ async function loadExistingConversation() {
     const workspace = new Workspace({
       host: 'http://localhost:3000',
       workingDir: '/tmp',
-      apiKey: process.env.SESSION_API_KEY || 'your-session-api-key'
+      apiKey: process.env.SESSION_API_KEY || 'your-session-api-key',
     });
 
     const conversation = new Conversation(agent, workspace, {
-      conversationId: 'existing-conversation-id'
+      conversationId: 'existing-conversation-id',
     });
 
     // Connect to the existing conversation

src/__tests__/index.test.ts

@@ -1,51 +1,90 @@
-import { RemoteConversation, RemoteWorkspace } from '../index';
+import { Conversation, Agent, Workspace, RemoteConversation, RemoteWorkspace } from '../index';
 
 describe('OpenHands Agent Server TypeScript Client', () => {
   describe('Exports', () => {
-    it('should export RemoteConversation', () => {
+    it('should export Conversation', () => {
+      expect(Conversation).toBeDefined();
+      expect(typeof Conversation).toBe('function');
+    });
+
+    it('should export Agent', () => {
+      expect(Agent).toBeDefined();
+      expect(typeof Agent).toBe('function');
+    });
+
+    it('should export Workspace', () => {
+      expect(Workspace).toBeDefined();
+      expect(typeof Workspace).toBe('function');
+    });
+
+    it('should export RemoteConversation for backwards compatibility', () => {
       expect(RemoteConversation).toBeDefined();
       expect(typeof RemoteConversation).toBe('function');
     });
 
-    it('should export RemoteWorkspace', () => {
+    it('should export RemoteWorkspace for backwards compatibility', () => {
       expect(RemoteWorkspace).toBeDefined();
       expect(typeof RemoteWorkspace).toBe('function');
     });
   });
 
-  describe('RemoteConversation', () => {
-    it('should create instance with config', () => {
-      const config = {
+  describe('New API - Conversation', () => {
+    it('should create instance with agent and workspace', () => {
+      const agent = new Agent({
+        llm: {
+          model: 'gpt-4',
+          api_key: 'test-key',
+        },
+      });
+
+      const workspace = new Workspace({
         host: 'http://localhost:8000',
+        workingDir: '/tmp',
         apiKey: 'test-key',
-      };
+      });
 
-      const conversation = new RemoteConversation(config);
+      const conversation = new Conversation(agent, workspace);
       expect(conversation).toBeInstanceOf(RemoteConversation);
+      expect(conversation.workspace).toBe(workspace);
     });
+  });
 
-    it('should throw error when accessing workspace before initialization', () => {
-      const config = {
-        host: 'http://localhost:8000',
-        apiKey: 'test-key',
-      };
+  describe('Agent', () => {
+    it('should create instance with LLM config', () => {
+      const agent = new Agent({
+        llm: {
+          model: 'gpt-4',
+          api_key: 'test-key',
+        },
+      });
+
+      expect(agent).toBeInstanceOf(Agent);
+      expect(agent.kind).toBe('Agent');
+      expect(agent.llm.model).toBe('gpt-4');
+      expect(agent.llm.api_key).toBe('test-key');
+    });
+
+    it('should allow custom kind', () => {
+      const agent = new Agent({
+        kind: 'CustomAgent',
+        llm: {
+          model: 'gpt-4',
+          api_key: 'test-key',
+        },
+      });
 
-      const conversation = new RemoteConversation(config);
-      expect(() => conversation.workspace).toThrow(
-        'Workspace not initialized. Create or load a conversation first.'
-      );
+      expect(agent.kind).toBe('CustomAgent');
     });
   });
 
-  describe('RemoteWorkspace', () => {
+  describe('Workspace', () => {
     it('should create instance with options', () => {
-      const options = {
+      const workspace = new Workspace({
         host: 'http://localhost:8000',
         workingDir: '/tmp',
         apiKey: 'test-key',
-      };
+      });
 
-      const workspace = new RemoteWorkspace(options);
       expect(workspace).toBeInstanceOf(RemoteWorkspace);
       expect(workspace.host).toBe('http://localhost:8000');
       expect(workspace.workingDir).toBe('/tmp');

src/agent/agent.ts

@@ -15,7 +15,7 @@ export interface AgentOptions {
 /**
  * Agent class that implements AgentBase interface.
  * Provides a constructor-based API for creating agents.
- * 
+ *
  * Usage:
  *   const agent = new Agent({
  *     llm: {
@@ -34,12 +34,12 @@ export class Agent implements AgentBase {
     this.kind = options.kind || 'Agent';
     this.llm = options.llm;
     this.name = options.name;
-    
+
     // Copy any additional properties
-    Object.keys(options).forEach(key => {
+    Object.keys(options).forEach((key) => {
       if (key !== 'kind' && key !== 'llm' && key !== 'name') {
         this[key] = options[key];
       }
     });
   }
-}
+}

src/agent/index.ts

@@ -1 +1 @@
-export { Agent, AgentOptions } from './agent';
+export { Agent, AgentOptions } from './agent';

src/conversation/conversation-manager.ts

@@ -112,7 +112,10 @@ export class ConversationManager {
   /**
    * Load an existing conversation
    */
-  async loadConversation(conversationId: ConversationID, workingDir: string = '/tmp'): Promise<RemoteConversation> {
+  async loadConversation(
+    conversationId: ConversationID,
+    workingDir: string = '/tmp'
+  ): Promise<RemoteConversation> {
     // Get conversation info to extract the agent
     const conversationInfo = await this.getConversation(conversationId);
 

src/conversation/conversation.ts

@@ -10,21 +10,17 @@ import { RemoteConversation, RemoteConversationOptions } from './remote-conversa
 /**
  * Conversation class that extends RemoteConversation.
  * Provides a cleaner API that matches the Python SDK naming.
- * 
+ *
  * Usage:
  *   const conversation = new Conversation(agent, workspace);
  *   await conversation.start();
- * 
+ *
  * For existing conversations:
  *   const conversation = new Conversation(agent, workspace, { conversationId: 'existing-id' });
  *   await conversation.start();
  */
 export class Conversation extends RemoteConversation {
-  constructor(
-    agent: AgentBase,
-    workspace: RemoteWorkspace,
-    options?: RemoteConversationOptions
-  ) {
+  constructor(agent: AgentBase, workspace: RemoteWorkspace, options?: RemoteConversationOptions) {
     super(agent, workspace, options);
   }
-}
+}

src/conversation/remote-conversation.ts

@@ -70,14 +70,18 @@ export class RemoteConversation {
   get state(): RemoteState {
     if (!this._state) {
       if (!this._conversationId) {
-        throw new Error('Conversation not initialized. Call start() to initialize the conversation.');
+        throw new Error(
+          'Conversation not initialized. Call start() to initialize the conversation.'
+        );
       }
       this._state = new RemoteState(this.client, this._conversationId);
     }
     return this._state;
   }
 
-  async start(options: { initialMessage?: string; maxIterations?: number; stuckDetection?: boolean } = {}): Promise<void> {
+  async start(
+    options: { initialMessage?: string; maxIterations?: number; stuckDetection?: boolean } = {}
+  ): Promise<void> {
     if (this._conversationId) {
       // Existing conversation - verify it exists
       await this.client.get<ConversationInfo>(`/api/conversations/${this._conversationId}`);
@@ -211,13 +215,9 @@ export class RemoteConversation {
     }
   }
 
-
-
   async close(): Promise<void> {
     await this.stopWebSocketClient();
     this.client.close();
     this.workspace.close();
   }
 }
-
-

src/conversation/remote-state.ts

@@ -44,18 +44,16 @@ export class RemoteState {
       }
 
       // Fallback to REST API if no cached state
-      const response = await this.client.get<any>(
-        `/api/conversations/${this.conversationId}`
-      );
-      
+      const response = await this.client.get<any>(`/api/conversations/${this.conversationId}`);
+
       // Handle the case where the API returns a full_state wrapper
       let conversationInfo: ConversationInfo;
       if (response.data.full_state) {
         conversationInfo = response.data.full_state as ConversationInfo;
       } else {
         conversationInfo = response.data as ConversationInfo;
       }
-      
+
       this.cachedState = conversationInfo;
       return conversationInfo;
     });

src/workspace/workspace.ts

@@ -8,12 +8,12 @@ import { RemoteWorkspace, RemoteWorkspaceOptions } from './remote-workspace';
 /**
  * Workspace class that extends RemoteWorkspace.
  * Provides a cleaner API that matches the Python SDK naming.
- * 
+ *
  * Usage:
  *   const workspace = new Workspace({ host: 'http://localhost:8000', apiKey: 'key' });
  */
 export class Workspace extends RemoteWorkspace {
   constructor(options: RemoteWorkspaceOptions) {
     super(options);
   }
-}
+}