roe-typescript 0.1.2 → 1.0.0

package/README.md

@@ -2,6 +2,12 @@
 
 TypeScript/Node SDK for the [Roe AI](https://www.roe-ai.com/) API.
 
+> **v1.0.0** — `RoeHTTPClient`/axios were replaced by the generated
+> `openapi-fetch` client exposed as `client.raw`; use `components["schemas"]`
+> (or inferred types from the wrappers) where you need response shapes from
+> the OpenAPI definitions. Highlights and migration notes across releases live
+> in **[CHANGELOG.md](CHANGELOG.md)**.
+
 ## Installation
 
 ```bash
@@ -37,6 +43,47 @@ export ROE_API_KEY="your-api-key"
 export ROE_ORGANIZATION_ID="your-org-uuid"
 ```
 
+## Job Result Inspection
+
+After waiting for a job, you can inspect its outcome using the `JobStatus` enum:
+
+```typescript
+import { JobStatus } from "roe-typescript";
+
+const result = await job.wait();
+
+if (result.status === JobStatus.SUCCESS || result.status === JobStatus.CACHED) {
+  for (const output of result.outputs) {
+    console.log(`${output.key}: ${output.value}`);
+  }
+} else if (result.status === JobStatus.CANCELLED) {
+  console.log("Job was cancelled");
+} else if (result.status === JobStatus.FAILURE) {
+  console.log("Error:", result.error_message);
+}
+
+// Available fields
+result.status        // JobStatus enum value (PENDING, STARTED, RETRY, SUCCESS, FAILURE, CANCELLED, CACHED) or null
+result.error_message // Error string or null
+result.outputs       // AgentDatum[] from components["schemas"]["AgentDatum"]
+```
+
+## Raw API Access
+
+The generated raw client is exposed as `client.raw`:
+
+```typescript
+import { RoeClient } from "roe-typescript";
+
+const client = new RoeClient({
+  apiKey: "your-api-key",
+  organizationId: "your-org-uuid",
+});
+
+const response = await client.raw.GET("/v1/users/current_user/");
+console.log(response.response.status);
+```
+
 ## Full Example
 
 Create an agent that extracts structured data from websites:
@@ -86,13 +133,6 @@ for (const output of result.outputs) {
   console.log(JSON.stringify(JSON.parse(output.value), null, 2));
 }
 
-// Download saved references (screenshots, HTML, markdown)
-import { getJobReferences } from "roe-typescript";
-for (const ref of getJobReferences(result)) {
-  const content = await client.agents.jobs.downloadReference(job.id, ref.resource_id);
-  // Save content as needed
-}
-
 // Cleanup
 await client.agents.delete(agent.id);
 ```
@@ -432,3 +472,4 @@ const agent = await client.agents.create({
 
 - [Roe AI](https://www.roe-ai.com/)
 - [API Docs](https://docs.roe-ai.com)
+- [Changelog](CHANGELOG.md)

package/dist/api/agents.d.ts

@@ -1,87 +1,100 @@
-import { RoeConfig } from "../config.js";
-import { RoeHTTPClient } from "../utils/httpClient.js";
-import { AgentJobResult, AgentJobResultBatch, AgentJobStatus, AgentJobStatusBatch, AgentDatum, PaginatedResponse, JobDataDeleteResponse } from "../models/responses.js";
-import { AgentInputDefinition, AgentVersionWithApi, BaseAgentWithApi } from "../models/agent.js";
+import type { RoeConfig } from "../config.js";
+import type { RoeRawClient } from "../generated/client.js";
+import type { components } from "../generated/schema.js";
 import { Job, JobBatch } from "../models/job.js";
+type BaseAgent = components["schemas"]["BaseAgent"];
+type PaginatedBaseAgentList = components["schemas"]["PaginatedBaseAgentList"];
+type AgentVersion = components["schemas"]["AgentVersion"];
+type AgentJobStatus = components["schemas"]["AgentJobStatus"];
+type AgentJobResultItem = components["schemas"]["AgentJobResultItem"];
+type AgentJobDeleteDataResponse = components["schemas"]["AgentJobDeleteDataResponse"];
+type AgentDatum = components["schemas"]["AgentDatum"];
 export declare class AgentVersionsAPI {
     private readonly agentsApi;
     constructor(agentsApi: AgentsAPI);
-    private get http();
-    list(agentId: string): Promise<AgentVersionWithApi[]>;
-    retrieve(agentId: string, versionId: string, getSupportsEval?: boolean): Promise<AgentVersionWithApi>;
-    retrieveCurrent(agentId: string): Promise<AgentVersionWithApi>;
+    private get raw();
+    private get organizationId();
+    list(agentId: string): Promise<AgentVersion[]>;
+    retrieve(agentId: string, versionId: string, getSupportsEval?: boolean): Promise<AgentVersion>;
+    retrieveCurrent(agentId: string): Promise<AgentVersion>;
     create(params: {
         agentId: string;
-        inputDefinitions?: AgentInputDefinition[];
+        inputDefinitions?: Array<Record<string, unknown>>;
         engineConfig?: Record<string, unknown>;
         versionName?: string;
         description?: string;
-    }): Promise<AgentVersionWithApi>;
+    }): Promise<AgentVersion>;
     update(agentId: string, versionId: string, updates: {
         versionName?: string;
         description?: string;
     }): Promise<void>;
     delete(agentId: string, versionId: string): Promise<void>;
-    private wrap;
 }
 export declare class AgentJobsAPI {
     private readonly agentsApi;
     private static MAX_BATCH_SIZE;
     constructor(agentsApi: AgentsAPI);
-    private get http();
+    private get raw();
+    private get organizationId();
     retrieveStatus(jobId: string): Promise<AgentJobStatus>;
-    retrieveResult(jobId: string): Promise<AgentJobResult>;
-    retrieveStatusMany(jobIds: string[]): Promise<AgentJobStatusBatch[]>;
-    retrieveResultMany(jobIds: string[]): Promise<AgentJobResultBatch[]>;
+    retrieveResult(jobId: string): Promise<components["schemas"]["AgentJobResultResponse"]>;
+    retrieveStatusMany(jobIds: string[]): Promise<AgentJobStatus[]>;
+    retrieveResultMany(jobIds: string[]): Promise<AgentJobResultItem[]>;
     downloadReference(jobId: string, resourceId: string, asAttachment?: boolean): Promise<Buffer>;
-    deleteData(jobId: string): Promise<JobDataDeleteResponse>;
+    cancel(jobId: string): Promise<void>;
+    cancelAll(agentId: string): Promise<void>;
+    deleteData(jobId: string): Promise<AgentJobDeleteDataResponse>;
     private iterChunks;
 }
 export declare class AgentsAPI {
     readonly config: RoeConfig;
-    readonly httpClient: RoeHTTPClient;
+    readonly raw: RoeRawClient;
     private static MAX_BATCH_SIZE;
     readonly versions: AgentVersionsAPI;
     readonly jobs: AgentJobsAPI;
-    constructor(config: RoeConfig, httpClient: RoeHTTPClient);
-    private wrapBase;
+    constructor(config: RoeConfig, raw: RoeRawClient);
     list(params?: {
         page?: number;
         pageSize?: number;
-    }): Promise<PaginatedResponse<BaseAgentWithApi>>;
-    retrieve(agentId: string): Promise<BaseAgentWithApi>;
+    }): Promise<PaginatedBaseAgentList>;
+    retrieve(agentId: string): Promise<BaseAgent>;
     create(params: {
         name: string;
         engineClassId: string;
-        inputDefinitions?: AgentInputDefinition[];
+        inputDefinitions?: Array<Record<string, unknown>>;
         engineConfig?: Record<string, unknown>;
         versionName?: string;
         description?: string;
-    }): Promise<BaseAgentWithApi>;
+    }): Promise<BaseAgent>;
     update(agentId: string, updates: {
         name?: string;
         disableCache?: boolean;
         cacheFailedJobs?: boolean;
-    }): Promise<BaseAgentWithApi>;
+    }): Promise<BaseAgent>;
     delete(agentId: string): Promise<void>;
-    duplicate(agentId: string): Promise<BaseAgentWithApi>;
+    duplicate(agentId: string): Promise<AgentVersion>;
     run(params: {
         agentId: string;
         inputs: Record<string, unknown>;
         timeoutSeconds?: number;
+        metadata?: Record<string, unknown>;
     }): Promise<Job>;
     runMany(params: {
         agentId: string;
         batchInputs: Record<string, unknown>[];
         timeoutSeconds?: number;
+        metadata?: Record<string, unknown>;
     }): Promise<JobBatch>;
-    runSync(agentId: string, inputs: Record<string, unknown>): Promise<AgentDatum[]>;
+    runSync(agentId: string, inputs: Record<string, unknown>, metadata?: Record<string, unknown>): Promise<AgentDatum[]>;
     runVersion(params: {
         agentId: string;
         versionId: string;
         inputs: Record<string, unknown>;
         timeoutSeconds?: number;
+        metadata?: Record<string, unknown>;
     }): Promise<Job>;
-    runVersionSync(agentId: string, versionId: string, inputs: Record<string, unknown>): Promise<AgentDatum[]>;
+    runVersionSync(agentId: string, versionId: string, inputs: Record<string, unknown>, metadata?: Record<string, unknown>): Promise<AgentDatum[]>;
+    private extractJobId;
     private iterChunks;
 }
+export {};