roe-typescript 0.1.2 → 1.0.0

package/dist/models/job.js

@@ -1,4 +1,13 @@
-import { JobStatus } from "./responses.js";
+export var JobStatus;
+(function (JobStatus) {
+    JobStatus[JobStatus["PENDING"] = 0] = "PENDING";
+    JobStatus[JobStatus["STARTED"] = 1] = "STARTED";
+    JobStatus[JobStatus["RETRY"] = 2] = "RETRY";
+    JobStatus[JobStatus["SUCCESS"] = 3] = "SUCCESS";
+    JobStatus[JobStatus["FAILURE"] = 4] = "FAILURE";
+    JobStatus[JobStatus["CANCELLED"] = 5] = "CANCELLED";
+    JobStatus[JobStatus["CACHED"] = 6] = "CACHED";
+})(JobStatus || (JobStatus = {}));
 export class Job {
     constructor(opts) {
         this.agentsApi = opts.agentsApi;
@@ -20,11 +29,32 @@ export class Job {
         while (true) {
             const status = await this.retrieveStatus();
             const code = status.status;
-            if (code === JobStatus.SUCCESS || code === JobStatus.CACHED) {
-                return this.retrieveResult();
-            }
-            if (code === JobStatus.FAILURE || code === JobStatus.CANCELLED) {
-                throw new Error(`Job ${this.jobId} failed with status ${code}${status.error_message ? `: ${status.error_message}` : ""}`);
+            if (code === JobStatus.SUCCESS ||
+                code === JobStatus.CACHED ||
+                code === JobStatus.FAILURE ||
+                code === JobStatus.CANCELLED) {
+                const isFailed = code === JobStatus.FAILURE || code === JobStatus.CANCELLED;
+                let result;
+                try {
+                    result = await this.retrieveResult();
+                }
+                catch (err) {
+                    if (!isFailed)
+                        throw err;
+                    result = {
+                        agent_id: "",
+                        agent_version_id: "",
+                        inputs: [],
+                        outputs: [],
+                        input_tokens: null,
+                        output_tokens: null,
+                    };
+                }
+                return {
+                    ...result,
+                    status: code,
+                    error_message: status.error_message ?? null,
+                };
             }
             if (Date.now() - start > timeoutSeconds * 1000) {
                 throw new Error(`Job ${this.jobId} did not complete within ${timeoutSeconds} seconds`);
@@ -42,7 +72,7 @@ export class Job {
 export class JobBatch {
     constructor(opts) {
         this.completed = {};
-        this.statusCache = {};
+        this.statuses = {};
         this.agentsApi = opts.agentsApi;
         this.jobIds = opts.jobIds;
         this.timeoutSeconds = opts.timeoutSeconds ?? 7200;
@@ -64,45 +94,88 @@ export class JobBatch {
             if (!pending.length)
                 break;
             const statusBatch = await this.agentsApi.jobs.retrieveStatusMany(pending);
-            const failures = statusBatch.filter((s) => s.status === JobStatus.FAILURE || s.status === JobStatus.CANCELLED);
-            if (failures.length) {
-                const detail = failures.map((f) => `${f.id}:${f.status ?? "unknown"}`).join(', ');
-                throw new Error(`Jobs failed or cancelled: ${detail}`);
-            }
             const completedIds = [];
             for (const status of statusBatch) {
+                // The bulk status endpoint returns AgentJobStatus[]; the schema lacks an `id`
+                // field on each, but the backend includes it in practice — extract via cast.
+                const id = status.id;
+                if (!id) {
+                    throw new Error("AgentJobStatus response is missing an `id` field; backend schema may have changed");
+                }
                 const code = status.status;
-                if (code === JobStatus.SUCCESS || code === JobStatus.CACHED) {
-                    completedIds.push(status.id);
+                if (code === JobStatus.SUCCESS ||
+                    code === JobStatus.CACHED ||
+                    code === JobStatus.FAILURE ||
+                    code === JobStatus.CANCELLED) {
+                    completedIds.push(id);
                 }
                 if (code !== undefined && code !== null) {
-                    this.statusCache[status.id] = code;
+                    this.statuses[id] = {
+                        id,
+                        status: code,
+                        timestamp: status.timestamp,
+                        error_message: status.error_message,
+                    };
                 }
             }
             if (completedIds.length) {
-                const resultBatch = await this.agentsApi.jobs.retrieveResultMany(completedIds);
+                let resultBatch;
+                try {
+                    resultBatch = await this.agentsApi.jobs.retrieveResultMany(completedIds);
+                }
+                catch (err) {
+                    // Only synthesize for failed/cancelled — can't fake results for success/cached
+                    const failedIds = completedIds.filter((id) => {
+                        const s = this.statuses[id]?.status;
+                        return s === JobStatus.FAILURE || s === JobStatus.CANCELLED;
+                    });
+                    if (failedIds.length < completedIds.length) {
+                        throw err;
+                    }
+                    resultBatch = failedIds.map((id) => ({
+                        id,
+                        status: this.statuses[id]?.status ?? null,
+                        agent_id: null,
+                        agent_version_id: null,
+                        cost: null,
+                        inputs: null,
+                        result: null,
+                        corrected_outputs: null,
+                        input_tokens: null,
+                        output_tokens: null,
+                    }));
+                }
                 for (const res of resultBatch) {
+                    const jobStatus = res.status ?? this.statuses[res.id]?.status ?? null;
+                    const isFailed = jobStatus === JobStatus.FAILURE || jobStatus === JobStatus.CANCELLED;
                     if (!res.agent_id || !res.agent_version_id) {
-                        const id = res.id ?? 'unknown';
-                        throw new Error(`Job ${id} missing agent identifiers`);
+                        if (!isFailed) {
+                            const id = res.id ?? "unknown";
+                            throw new Error(`Job ${id} missing agent identifiers`);
+                        }
                     }
-                    // Use corrected_outputs as fallback if result is null/undefined
-                    const outputs = res.result ?? res.corrected_outputs;
-                    if (outputs == null) {
-                        // Both result and corrected_outputs are null - this may indicate an error or incomplete job
-                        throw new Error(`Job ${res.id} returned null or undefined result`);
+                    const rawOutputs = res.result ?? res.corrected_outputs;
+                    let outputs;
+                    if (rawOutputs == null) {
+                        if (!isFailed) {
+                            throw new Error(`Job ${res.id} returned null or undefined result`);
+                        }
+                        outputs = [];
                     }
-                    if (!Array.isArray(outputs)) {
-                        // Result exists but is not an array - unexpected format
-                        throw new Error(`Job ${res.id} returned unexpected result format: ${typeof outputs}`);
+                    else if (!Array.isArray(rawOutputs)) {
+                        if (!isFailed) {
+                            throw new Error(`Job ${res.id} returned unexpected result format: ${typeof rawOutputs}`);
+                        }
+                        outputs = [];
+                    }
+                    else {
+                        outputs = rawOutputs;
                     }
                     this.completed[res.id] = {
-                        agent_id: res.agent_id,
-                        agent_version_id: res.agent_version_id,
-                        inputs: res.inputs ?? [],
-                        input_tokens: res.input_tokens,
-                        output_tokens: res.output_tokens,
+                        ...res,
+                        status: jobStatus,
                         outputs,
+                        error_message: this.statuses[res.id]?.error_message ?? null,
                     };
                 }
             }
@@ -117,14 +190,34 @@ export class JobBatch {
         return this.jobIds.map((id) => this.completed[id]);
     }
     async retrieveStatus() {
-        const statusMap = { ...this.statusCache };
-        const toQuery = this.jobIds.filter((id) => statusMap[id] === undefined);
+        const statusMap = {};
+        const toQuery = [];
+        const TERMINAL = new Set([JobStatus.SUCCESS, JobStatus.CACHED, JobStatus.FAILURE, JobStatus.CANCELLED]);
+        for (const id of this.jobIds) {
+            const cached = this.statuses[id];
+            if (cached !== undefined && TERMINAL.has(cached.status)) {
+                statusMap[id] = cached;
+            }
+            else {
+                toQuery.push(id);
+            }
+        }
         if (toQuery.length) {
-            const statuses = await this.agentsApi.jobs.retrieveStatusMany(toQuery);
-            for (const s of statuses) {
+            const batchStatuses = await this.agentsApi.jobs.retrieveStatusMany(toQuery);
+            for (const s of batchStatuses) {
+                const id = s.id;
+                if (!id) {
+                    throw new Error("AgentJobStatus response is missing an `id` field; backend schema may have changed");
+                }
                 if (s.status !== undefined && s.status !== null) {
-                    statusMap[s.id] = s.status;
-                    this.statusCache[s.id] = s.status;
+                    const js = {
+                        id,
+                        status: s.status,
+                        timestamp: s.timestamp,
+                        error_message: s.error_message,
+                    };
+                    this.statuses[id] = js;
+                    statusMap[id] = js;
                 }
             }
         }

package/dist/utils/dynamicInputs.d.ts

@@ -0,0 +1,30 @@
+import type { RoeRawClient } from "../generated/client.js";
+import { FileUpload } from "../models/file.js";
+export type ClassifiedInputs = {
+    formData: Record<string, string>;
+    files: Record<string, FileUpload>;
+};
+/**
+ * Splits a free-form `inputs` dict into form fields + file uploads, mirroring
+ * the detection rules from the legacy `RoeHTTPClient.postWithDynamicInputs`:
+ *
+ *   - `FileUpload` instance -> file part
+ *   - object with a `pipe` function (Node Readable) -> wrapped in FileUpload
+ *   - string that's a valid UUID -> form field (treated as a Roe file ref)
+ *   - string that resolves to a real file path -> opened as a FileUpload
+ *   - other strings / numbers / booleans -> form field (stringified)
+ */
+export declare function classifyInputs(inputs: Record<string, unknown>): Promise<ClassifiedInputs>;
+/**
+ * Posts a multipart body built from a free-form `inputs` dict (with optional
+ * sibling `metadata`) to a generated raw-client path. Bypasses openapi-fetch's
+ * default JSON serialization via the `bodySerializer` escape hatch and runs
+ * its own retry loop because Node `Readable` bodies cannot be re-read.
+ *
+ * The path / pathParams are intentionally typed loosely (`string` /
+ * `Record<string, string>`) — multipart agent-run endpoints have dynamic
+ * input keys that aren't statically modeled in the OpenAPI spec, so the
+ * generated typed-body variant is unusable here. Callers pass the path
+ * literal that matches `paths` in schema.d.ts.
+ */
+export declare function postDynamicInputs<T = unknown>(raw: RoeRawClient, path: string, pathParams: Record<string, string>, queryParams: Record<string, string | undefined>, inputs: Record<string, unknown>, metadata: Record<string, unknown> | undefined, maxRetries: number): Promise<T>;

package/dist/utils/dynamicInputs.js

@@ -0,0 +1,114 @@
+import { FileUpload } from "../models/file.js";
+import { isFilePath, isUuidString } from "./fileDetection.js";
+/**
+ * Sentinel header read by `retryMiddleware`. Multipart bodies aren't safely
+ * cloneable for retry by the middleware — the wrapper-side loop in
+ * `postDynamicInputs` rebuilds FormData per attempt instead.
+ */
+const RETRY_BYPASS_HEADER = "x-roe-retry-bypass";
+const isRetriable = (status) => status >= 500 || status === 429 || status === 408;
+/**
+ * Splits a free-form `inputs` dict into form fields + file uploads, mirroring
+ * the detection rules from the legacy `RoeHTTPClient.postWithDynamicInputs`:
+ *
+ *   - `FileUpload` instance -> file part
+ *   - object with a `pipe` function (Node Readable) -> wrapped in FileUpload
+ *   - string that's a valid UUID -> form field (treated as a Roe file ref)
+ *   - string that resolves to a real file path -> opened as a FileUpload
+ *   - other strings / numbers / booleans -> form field (stringified)
+ */
+export async function classifyInputs(inputs) {
+    const formData = {};
+    const files = {};
+    for (const [key, value] of Object.entries(inputs)) {
+        if (value === undefined || value === null)
+            continue;
+        if (value instanceof FileUpload) {
+            files[key] = value;
+            continue;
+        }
+        if (typeof value === "object" && typeof value.pipe === "function") {
+            files[key] = new FileUpload({ file: value });
+            continue;
+        }
+        if (typeof value === "string") {
+            if (isUuidString(value)) {
+                formData[key] = value;
+            }
+            else if (await isFilePath(value)) {
+                files[key] = new FileUpload({ path: value });
+            }
+            else {
+                formData[key] = value;
+            }
+            continue;
+        }
+        if (typeof value === "boolean" || typeof value === "number") {
+            formData[key] = String(value);
+            continue;
+        }
+        // Unknown shape — JSON-encode so e.g. nested objects survive the round-trip.
+        formData[key] = JSON.stringify(value);
+    }
+    return { formData, files };
+}
+async function buildFormData(formData, files, metadata) {
+    const fd = new FormData();
+    for (const [k, v] of Object.entries(formData))
+        fd.append(k, v);
+    if (metadata !== undefined)
+        fd.append("metadata", JSON.stringify(metadata));
+    for (const [k, fu] of Object.entries(files)) {
+        fd.append(k, await fu.toBlob(), fu.effectiveFilename);
+    }
+    return fd;
+}
+/**
+ * Posts a multipart body built from a free-form `inputs` dict (with optional
+ * sibling `metadata`) to a generated raw-client path. Bypasses openapi-fetch's
+ * default JSON serialization via the `bodySerializer` escape hatch and runs
+ * its own retry loop because Node `Readable` bodies cannot be re-read.
+ *
+ * The path / pathParams are intentionally typed loosely (`string` /
+ * `Record<string, string>`) — multipart agent-run endpoints have dynamic
+ * input keys that aren't statically modeled in the OpenAPI spec, so the
+ * generated typed-body variant is unusable here. Callers pass the path
+ * literal that matches `paths` in schema.d.ts.
+ */
+export async function postDynamicInputs(raw, path, pathParams, queryParams, inputs, metadata, maxRetries) {
+    const { formData, files } = await classifyInputs(inputs);
+    let attempt = 0;
+    let lastErr;
+    while (attempt <= maxRetries) {
+        const fd = await buildFormData(formData, files, metadata);
+        try {
+            // openapi-fetch's typed POST is keyed on `paths`; we deliberately escape
+            // the type system here for multipart agent-run endpoints.
+            // NOTE: openapi-fetch skips `bodySerializer` entirely when `body` is
+            // `undefined`, so we pass the FormData as the body itself and use
+            // bodySerializer as an identity to preserve the FormData type signal
+            // (openapi-fetch then refrains from forcing Content-Type: application/json).
+            const result = await raw.POST(path, {
+                params: { path: pathParams, query: queryParams },
+                body: fd,
+                bodySerializer: (b) => b,
+                headers: { [RETRY_BYPASS_HEADER]: "1" },
+            });
+            // errorMiddleware throws on non-2xx, so reaching here means success.
+            // `error` is therefore always undefined; surface `data` directly.
+            return result.data;
+        }
+        catch (err) {
+            lastErr = err;
+            const status = err?.statusCode;
+            if (status !== undefined && isRetriable(status) && attempt < maxRetries) {
+                const backoff = Math.min(1000 * 2 ** attempt, 10000);
+                await new Promise((r) => setTimeout(r, backoff));
+                attempt += 1;
+                continue;
+            }
+            throw err;
+        }
+    }
+    throw lastErr ?? new Error("postDynamicInputs exhausted retries without producing an error");
+}

package/dist/utils/middleware.d.ts

@@ -0,0 +1,6 @@
+import type { Middleware } from "openapi-fetch";
+import { RoeAuth } from "../auth.js";
+export declare function shouldBypassRetry(request: Request): boolean;
+export declare function authMiddleware(auth: RoeAuth): Middleware;
+export declare function retryMiddleware(maxRetries: number): Middleware;
+export declare const errorMiddleware: Middleware;

package/dist/utils/middleware.js

@@ -0,0 +1,80 @@
+import { extractErrorMessage, getExceptionForStatusCode } from "../exceptions.js";
+const RETRY_BYPASS_HEADER = "x-roe-retry-bypass";
+export function shouldBypassRetry(request) {
+    if (request.headers.get(RETRY_BYPASS_HEADER))
+        return true;
+    const ct = request.headers.get("content-type");
+    return !!ct && ct.toLowerCase().startsWith("multipart/");
+}
+export function authMiddleware(auth) {
+    return {
+        onRequest({ request }) {
+            for (const [k, v] of Object.entries(auth.getHeaders())) {
+                request.headers.set(k, v);
+            }
+            return request;
+        },
+    };
+}
+// Per-request body cache populated in onRequest (where the body is still
+// fresh) and consumed in onResponse to rebuild Requests on retry. Cloning
+// the original request post-fetch fails in Node 18+ undici with
+// `TypeError: Cannot perform 'clone' on a Request with a disturbed body`,
+// because the body stream has already been consumed by the initial fetch.
+const bodyCache = new WeakMap();
+export function retryMiddleware(maxRetries) {
+    return {
+        async onRequest({ request }) {
+            if (!shouldBypassRetry(request) && request.body) {
+                // Clone-then-buffer here is safe — the original `request` is still
+                // un-disturbed and goes on to fetch unchanged. Only the clone is
+                // consumed.
+                bodyCache.set(request, await request.clone().arrayBuffer());
+            }
+            return request;
+        },
+        async onResponse({ request, response, options }) {
+            if (shouldBypassRetry(request))
+                return response;
+            const retriable = (status) => status >= 500 || status === 429 || status === 408;
+            let attempt = 0;
+            let res = response;
+            const doFetch = options.fetch;
+            const cachedBody = bodyCache.get(request);
+            while (attempt < maxRetries && retriable(res.status)) {
+                const backoffMs = Math.min(1000 * 2 ** attempt, 10000);
+                await new Promise((resolve) => setTimeout(resolve, backoffMs));
+                // Build a fresh Request per attempt — the original's body stream
+                // was disturbed by the previous fetch.
+                const retryReq = new Request(request.url, {
+                    method: request.method,
+                    headers: request.headers,
+                    body: cachedBody ?? null,
+                });
+                res = await doFetch(retryReq);
+                attempt += 1;
+            }
+            bodyCache.delete(request);
+            return res;
+        },
+    };
+}
+export const errorMiddleware = {
+    async onResponse({ response }) {
+        if (response.ok)
+            return response;
+        let data = null;
+        try {
+            data = await response.clone().json();
+        }
+        catch {
+            data = null;
+        }
+        const ExceptionClass = getExceptionForStatusCode(response.status);
+        const message = extractErrorMessage(data, response.status);
+        const responseObj = data && typeof data === "object" && !Array.isArray(data)
+            ? data
+            : null;
+        throw new ExceptionClass(message, response.status, responseObj);
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roe-typescript",
-  "version": "0.1.2",
+  "version": "1.0.0",
   "description": "TypeScript SDK for the Roe AI API (feature parity with roe-python).",
   "type": "module",
   "main": "dist/index.js",
@@ -13,24 +13,24 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "generate-sdk": "bash scripts/generate-sdk",
     "lint": "tsc --noEmit",
     "test": "vitest run tests/unit --passWithNoTests",
     "test:watch": "vitest",
     "prepublishOnly": "npm run lint && npm run test && npm run build"
   },
   "dependencies": {
-    "axios": "^1.7.7",
-    "form-data": "^4.0.0",
     "mime-types": "^2.1.35",
+    "openapi-fetch": "^0.13.8",
+    "undici": "^6.25.0",
     "uuid": "^11.0.3"
   },
   "devDependencies": {
-    "@types/form-data": "^2.5.0",
     "@types/mime-types": "^2.1.4",
-    "@types/uuid": "^10.0.0",
     "@types/node": "^22.9.0",
+    "@types/uuid": "^10.0.0",
+    "openapi-typescript": "^7.6.1",
     "typescript": "^5.6.3",
     "vitest": "^1.6.0"
   }
 }
-

package/dist/models/agent.d.ts

@@ -1,78 +0,0 @@
-import { UserInfo } from "./user.js";
-import { AgentsAPI } from "../api/agents.js";
-import { Job } from "./job.js";
-export type AgentInputDefinition = {
-    key: string;
-    data_type: string;
-    description: string;
-    example?: string;
-    accepts_multiple_files?: boolean | null;
-};
-export type BaseAgent = {
-    id: string;
-    name: string;
-    creator?: UserInfo | null;
-    created_at: string;
-    disable_cache: boolean;
-    cache_failed_jobs: boolean;
-    organization_id: string;
-    engine_class_id: string;
-    current_version_id?: string | null;
-    job_count?: number;
-    most_recent_job?: string | null;
-    engine_name?: string;
-};
-export declare class BaseAgentWithApi implements BaseAgent {
-    id: string;
-    name: string;
-    creator?: UserInfo | null;
-    created_at: string;
-    disable_cache: boolean;
-    cache_failed_jobs: boolean;
-    organization_id: string;
-    engine_class_id: string;
-    current_version_id?: string | null;
-    job_count?: number;
-    most_recent_job?: string | null;
-    engine_name?: string;
-    private _agentsApi?;
-    constructor(data: BaseAgent);
-    setAgentsApi(api: AgentsAPI): void;
-    run(inputs: Record<string, unknown>): Promise<Job>;
-    listVersions(): Promise<AgentVersionWithApi[]>;
-    getCurrentVersion(): Promise<AgentVersionWithApi> | null;
-}
-export type AgentVersion = {
-    id: string;
-    name: string;
-    version_name: string;
-    creator?: UserInfo | null;
-    created_at: string;
-    description?: string | null;
-    engine_class_id: string;
-    engine_name: string;
-    input_definitions: AgentInputDefinition[];
-    engine_config: Record<string, unknown>;
-    organization_id: string;
-    readonly: boolean;
-    base_agent: BaseAgent;
-};
-export declare class AgentVersionWithApi implements AgentVersion {
-    id: string;
-    name: string;
-    version_name: string;
-    creator?: UserInfo | null;
-    created_at: string;
-    description?: string | null;
-    engine_class_id: string;
-    engine_name: string;
-    input_definitions: AgentInputDefinition[];
-    engine_config: Record<string, unknown>;
-    organization_id: string;
-    readonly: boolean;
-    base_agent: BaseAgent;
-    private _agentsApi?;
-    constructor(data: AgentVersion);
-    setAgentsApi(api: AgentsAPI): void;
-    run(inputs: Record<string, unknown>): Promise<Job>;
-}

package/dist/models/agent.js

@@ -1,40 +0,0 @@
-export class BaseAgentWithApi {
-    constructor(data) {
-        Object.assign(this, data);
-    }
-    setAgentsApi(api) {
-        this._agentsApi = api;
-    }
-    run(inputs) {
-        if (!this._agentsApi)
-            throw new Error("Agents API not set");
-        return this._agentsApi.run({ agentId: this.id, inputs });
-    }
-    listVersions() {
-        if (!this._agentsApi)
-            throw new Error("Agents API not set");
-        return this._agentsApi.versions.list(this.id);
-    }
-    getCurrentVersion() {
-        if (!this._agentsApi)
-            throw new Error("Agents API not set");
-        if (!this.current_version_id)
-            return null;
-        return this._agentsApi.versions.retrieve(this.id, this.current_version_id);
-    }
-}
-export class AgentVersionWithApi {
-    constructor(data) {
-        Object.assign(this, data);
-    }
-    setAgentsApi(api) {
-        this._agentsApi = api;
-    }
-    run(inputs) {
-        if (!this._agentsApi)
-            throw new Error("Agents API not set");
-        if (!this.base_agent?.id)
-            throw new Error("AgentVersion missing base_agent id");
-        return this._agentsApi.runVersion({ agentId: this.base_agent.id, versionId: this.id, inputs });
-    }
-}

package/dist/models/policy.d.ts

@@ -1,19 +0,0 @@
-export type Policy = {
-    id: string;
-    name: string;
-    description: string;
-    organization_id: string;
-    current_version_id: string | null;
-    created_at: string;
-    updated_at: string;
-};
-export type PolicyVersion = {
-    id: string;
-    version_name: string;
-    content: Record<string, unknown>;
-    created_at: string;
-    updated_at: string;
-    policy: Policy | null;
-    created_by: Record<string, unknown> | null;
-    base_version_id: string | null;
-};

package/dist/models/policy.js

@@ -1 +0,0 @@
-export {};