roe-typescript 0.1.2 → 1.0.0

package/dist/api/agents.js

@@ -1,12 +1,7 @@
-import { PaginationHelper } from "../utils/pagination.js";
 import { isUuidString } from "../utils/fileDetection.js";
+import { postDynamicInputs } from "../utils/dynamicInputs.js";
 import { BadRequestError, RoeAPIException } from "../exceptions.js";
-import { AgentVersionWithApi, BaseAgentWithApi, } from "../models/agent.js";
 import { Job, JobBatch } from "../models/job.js";
-/**
- * Validates that a value is a valid UUID string.
- * @throws BadRequestError if the value is not a valid UUID
- */
 function validateUuid(value, fieldName) {
     if (!isUuidString(value)) {
         throw new BadRequestError(`Invalid ${fieldName}: "${value}" is not a valid UUID`, 400);
@@ -16,88 +11,137 @@ export class AgentVersionsAPI {
     constructor(agentsApi) {
         this.agentsApi = agentsApi;
     }
-    get http() {
-        return this.agentsApi.httpClient;
+    get raw() {
+        return this.agentsApi.raw;
+    }
+    get organizationId() {
+        return this.agentsApi.config.organizationId;
     }
     async list(agentId) {
         validateUuid(agentId, "agentId");
-        const data = await this.http.get(`/v1/agents/${agentId}/versions/`);
-        return data.map((v) => this.wrap(v));
+        const { data } = await this.raw.GET("/v1/agents/{agent_id}/versions/", {
+            params: {
+                path: { agent_id: agentId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+        return (data ?? []);
     }
     async retrieve(agentId, versionId, getSupportsEval) {
         validateUuid(agentId, "agentId");
         validateUuid(versionId, "versionId");
-        const params = getSupportsEval === undefined ? undefined : { get_supports_eval: String(getSupportsEval).toLowerCase() };
-        const data = await this.http.get(`/v1/agents/${agentId}/versions/${versionId}/`, params);
-        return this.wrap(data);
+        const query = { organization_id: this.organizationId };
+        if (getSupportsEval !== undefined)
+            query.get_supports_eval = String(getSupportsEval).toLowerCase();
+        const { data } = await this.raw.GET("/v1/agents/{agent_id}/versions/{agent_version_id}/", {
+            params: {
+                path: { agent_id: agentId, agent_version_id: versionId },
+                query: query,
+            },
+        });
+        return data;
     }
     async retrieveCurrent(agentId) {
         validateUuid(agentId, "agentId");
-        const data = await this.http.get(`/v1/agents/${agentId}/versions/current/`);
-        return this.wrap(data);
+        const { data } = await this.raw.GET("/v1/agents/{agent_id}/versions/current/", {
+            params: {
+                path: { agent_id: agentId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+        return data;
     }
     async create(params) {
         validateUuid(params.agentId, "agentId");
-        const payload = {
-            input_definitions: params.inputDefinitions ?? [],
-            engine_config: params.engineConfig ?? {},
+        const body = {
+            input_definitions: (params.inputDefinitions ?? []),
+            engine_config: (params.engineConfig ?? {}),
         };
         if (params.versionName !== undefined)
-            payload.version_name = params.versionName;
+            body.version_name = params.versionName;
         if (params.description !== undefined)
-            payload.description = params.description;
-        const data = await this.http.post({
-            url: `/v1/agents/${params.agentId}/versions/`,
-            json: payload,
+            body.description = params.description;
+        const { data } = await this.raw.POST("/v1/agents/{agent_id}/versions/", {
+            params: {
+                path: { agent_id: params.agentId },
+                query: { organization_id: this.organizationId },
+            },
+            body,
         });
+        if (!data?.id) {
+            throw new RoeAPIException(`Unexpected response from server: ${JSON.stringify(data)}`);
+        }
+        // POST returns a partial create payload; re-fetch to get the full version.
         return this.retrieve(params.agentId, data.id);
     }
     async update(agentId, versionId, updates) {
         validateUuid(agentId, "agentId");
         validateUuid(versionId, "versionId");
-        const payload = {};
+        const body = {};
         if (updates.versionName !== undefined)
-            payload.version_name = updates.versionName;
+            body.version_name = updates.versionName;
         if (updates.description !== undefined)
-            payload.description = updates.description;
-        await this.http.put(`/v1/agents/${agentId}/versions/${versionId}/`, payload);
+            body.description = updates.description;
+        await this.raw.PATCH("/v1/agents/{agent_id}/versions/{agent_version_id}/", {
+            params: {
+                path: { agent_id: agentId, agent_version_id: versionId },
+                query: { organization_id: this.organizationId },
+            },
+            body,
+        });
     }
     async delete(agentId, versionId) {
         validateUuid(agentId, "agentId");
         validateUuid(versionId, "versionId");
-        await this.http.delete(`/v1/agents/${agentId}/versions/${versionId}/`);
-    }
-    wrap(data) {
-        const obj = new AgentVersionWithApi(data);
-        obj.setAgentsApi(this.agentsApi);
-        return obj;
+        await this.raw.DELETE("/v1/agents/{agent_id}/versions/{agent_version_id}/", {
+            params: {
+                path: { agent_id: agentId, agent_version_id: versionId },
+                query: { organization_id: this.organizationId },
+            },
+        });
     }
 }
 export class AgentJobsAPI {
     constructor(agentsApi) {
         this.agentsApi = agentsApi;
     }
-    get http() {
-        return this.agentsApi.httpClient;
+    get raw() {
+        return this.agentsApi.raw;
+    }
+    get organizationId() {
+        return this.agentsApi.config.organizationId;
     }
     async retrieveStatus(jobId) {
         validateUuid(jobId, "jobId");
-        return this.http.get(`/v1/agents/jobs/${jobId}/status/`);
+        const { data } = await this.raw.GET("/v1/agents/jobs/{job_id}/status/", {
+            params: {
+                path: { job_id: jobId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+        return data;
     }
     async retrieveResult(jobId) {
         validateUuid(jobId, "jobId");
-        return this.http.get(`/v1/agents/jobs/${jobId}/result/`);
+        const { data } = await this.raw.GET("/v1/agents/jobs/{agent_job_id}/result/", {
+            params: {
+                path: { agent_job_id: jobId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+        return data;
     }
     async retrieveStatusMany(jobIds) {
         const results = [];
         for (const chunk of this.iterChunks(jobIds, AgentJobsAPI.MAX_BATCH_SIZE)) {
             if (!chunk.length)
                 continue;
-            const data = await this.http.post({
-                url: "/v1/agents/jobs/statuses/",
-                json: { job_ids: chunk },
+            const { data } = await this.raw.POST("/v1/agents/jobs/statuses/", {
+                params: { query: { organization_id: this.organizationId } },
+                body: { job_ids: chunk },
             });
-            results.push(...data);
+            if (data)
+                results.push(...data);
         }
         return results;
     }
@@ -106,25 +150,64 @@ export class AgentJobsAPI {
         for (const chunk of this.iterChunks(jobIds, AgentJobsAPI.MAX_BATCH_SIZE)) {
             if (!chunk.length)
                 continue;
-            const data = await this.http.post({
-                url: "/v1/agents/jobs/results/",
-                json: { job_ids: chunk },
+            const { data } = await this.raw.POST("/v1/agents/jobs/results/", {
+                params: { query: { organization_id: this.organizationId } },
+                body: { job_ids: chunk },
             });
-            results.push(...data);
+            if (Array.isArray(data)) {
+                results.push(...data);
+            }
+            else if (data?.results) {
+                results.push(...data.results);
+            }
         }
         return results;
     }
     async downloadReference(jobId, resourceId, asAttachment = false) {
         validateUuid(jobId, "jobId");
-        validateUuid(resourceId, "resourceId");
-        const params = asAttachment ? { download: "true" } : undefined;
-        return this.http.getBytes(`/v1/agents/jobs/${jobId}/references/${resourceId}/`, params);
+        // The endpoint streams binary; openapi-fetch's typed GET expects a JSON
+        // response per the spec, so we use parseAs:"arrayBuffer" to skip JSON
+        // parsing and read raw bytes.
+        const query = { organization_id: this.organizationId };
+        if (asAttachment)
+            query.download = "true";
+        const result = await this.raw.GET("/v1/agents/jobs/{agent_job_id}/references/{resource_id}/", {
+            params: {
+                path: { agent_job_id: jobId, resource_id: resourceId },
+                query,
+            },
+            parseAs: "arrayBuffer",
+        });
+        const buf = result.data ?? new ArrayBuffer(0);
+        return Buffer.from(buf);
+    }
+    async cancel(jobId) {
+        validateUuid(jobId, "jobId");
+        await this.raw.POST("/v1/agents/jobs/{job_id}/cancel/", {
+            params: {
+                path: { job_id: jobId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+    }
+    async cancelAll(agentId) {
+        validateUuid(agentId, "agentId");
+        await this.raw.POST("/v1/agents/{agent_id}/jobs/cancel-all/", {
+            params: {
+                path: { agent_id: agentId },
+                query: { organization_id: this.organizationId },
+            },
+        });
     }
     async deleteData(jobId) {
         validateUuid(jobId, "jobId");
-        return this.http.post({
-            url: `/v1/agents/jobs/${jobId}/delete-data/`,
+        const { data } = await this.raw.POST("/v1/agents/jobs/{job_id}/delete-data/", {
+            params: {
+                path: { job_id: jobId },
+                query: { organization_id: this.organizationId },
+            },
         });
+        return data;
     }
     *iterChunks(items, size) {
         for (let i = 0; i < items.length; i += size) {
@@ -134,77 +217,93 @@ export class AgentJobsAPI {
 }
 AgentJobsAPI.MAX_BATCH_SIZE = 1000;
 export class AgentsAPI {
-    constructor(config, httpClient) {
+    constructor(config, raw) {
         this.config = config;
-        this.httpClient = httpClient;
+        this.raw = raw;
         this.versions = new AgentVersionsAPI(this);
         this.jobs = new AgentJobsAPI(this);
     }
-    wrapBase(data) {
-        const obj = new BaseAgentWithApi(data);
-        obj.setAgentsApi(this);
-        return obj;
-    }
     async list(params) {
-        const query = PaginationHelper.buildQueryParams(this.config.organizationId, params?.page, params?.pageSize);
-        const resp = await this.httpClient.get("/v1/agents/", query);
-        const wrapped = resp.results.map((a) => this.wrapBase(a));
-        return { ...resp, results: wrapped };
+        const { data } = await this.raw.GET("/v1/agents/", {
+            params: {
+                query: {
+                    organization_id: this.config.organizationId,
+                    page: params?.page,
+                    page_size: params?.pageSize,
+                },
+            },
+        });
+        return data;
     }
     async retrieve(agentId) {
         validateUuid(agentId, "agentId");
-        const data = await this.httpClient.get(`/v1/agents/${agentId}/`);
-        return this.wrapBase(data);
+        const { data } = await this.raw.GET("/v1/agents/{agent_id}/", {
+            params: {
+                path: { agent_id: agentId },
+                query: { organization_id: this.config.organizationId },
+            },
+        });
+        return data;
     }
     async create(params) {
-        const payload = {
+        const body = {
             name: params.name,
             engine_class_id: params.engineClassId,
             organization_id: this.config.organizationId,
-            input_definitions: params.inputDefinitions ?? [],
-            engine_config: params.engineConfig ?? {},
+            input_definitions: (params.inputDefinitions ?? []),
+            engine_config: (params.engineConfig ?? {}),
         };
         if (params.versionName !== undefined)
-            payload.version_name = params.versionName;
+            body.version_name = params.versionName;
         if (params.description !== undefined)
-            payload.description = params.description;
-        const data = await this.httpClient.post({ url: "/v1/agents/", json: payload });
-        return this.wrapBase(data);
+            body.description = params.description;
+        const { data } = await this.raw.POST("/v1/agents/", {
+            params: { query: { organization_id: this.config.organizationId } },
+            body,
+        });
+        return data;
     }
     async update(agentId, updates) {
         validateUuid(agentId, "agentId");
-        const payload = {};
+        const body = {};
         if (updates.name !== undefined)
-            payload.name = updates.name;
+            body.name = updates.name;
         if (updates.disableCache !== undefined)
-            payload.disable_cache = updates.disableCache;
+            body.disable_cache = updates.disableCache;
         if (updates.cacheFailedJobs !== undefined)
-            payload.cache_failed_jobs = updates.cacheFailedJobs;
-        const data = await this.httpClient.put(`/v1/agents/${agentId}/`, payload);
-        return this.wrapBase(data);
+            body.cache_failed_jobs = updates.cacheFailedJobs;
+        const { data } = await this.raw.PATCH("/v1/agents/{agent_id}/", {
+            params: {
+                path: { agent_id: agentId },
+                query: { organization_id: this.config.organizationId },
+            },
+            body,
+        });
+        return data;
     }
     async delete(agentId) {
         validateUuid(agentId, "agentId");
-        await this.httpClient.delete(`/v1/agents/${agentId}/`);
+        await this.raw.DELETE("/v1/agents/{agent_id}/", {
+            params: {
+                path: { agent_id: agentId },
+                query: { organization_id: this.config.organizationId },
+            },
+        });
     }
     async duplicate(agentId) {
         validateUuid(agentId, "agentId");
-        const data = await this.httpClient.post({
-            url: `/v1/agents/${agentId}/duplicate/`,
+        const { data } = await this.raw.POST("/v1/agents/{agent_id}/duplicate/", {
+            params: {
+                path: { agent_id: agentId },
+                query: { organization_id: this.config.organizationId },
+            },
         });
-        return this.wrapBase(data.base_agent);
+        return data;
     }
     async run(params) {
         validateUuid(params.agentId, "agentId");
-        const response = await this.httpClient.postWithDynamicInputs(`/v1/agents/run/${params.agentId}/async/`, params.inputs);
-        // Handle both string response and object response formats
-        const jobId = typeof response === "string" ? response : response?.job_id;
-        if (!jobId || typeof jobId !== "string") {
-            throw new RoeAPIException(`Invalid job ID returned from API: ${JSON.stringify(response)}`);
-        }
-        if (!isUuidString(jobId)) {
-            throw new RoeAPIException(`Invalid job ID format returned from API: ${jobId}`);
-        }
+        const response = await postDynamicInputs(this.raw, "/v1/agents/run/{agent_id}/async/", { agent_id: params.agentId }, { organization_id: this.config.organizationId }, params.inputs, params.metadata, this.config.maxRetries);
+        const jobId = this.extractJobId(response);
         return new Job({ agentsApi: this, jobId, timeoutSeconds: params.timeoutSeconds });
     }
     async runMany(params) {
@@ -213,46 +312,57 @@ export class AgentsAPI {
         for (const chunk of this.iterChunks(params.batchInputs, AgentsAPI.MAX_BATCH_SIZE)) {
             if (!chunk.length)
                 continue;
-            const resp = await this.httpClient.post({
-                url: `/v1/agents/run/${params.agentId}/async/many/`,
-                json: { inputs: chunk },
+            // Generated request type only models { inputs }, but the backend also
+            // accepts a sibling `metadata` field — attach it via a serializer cast.
+            const body = { inputs: chunk };
+            if (params.metadata !== undefined)
+                body.metadata = params.metadata;
+            const { data } = await this.raw.POST("/v1/agents/run/{agent_id}/async/many/", {
+                params: {
+                    path: { agent_id: params.agentId },
+                    query: { organization_id: this.config.organizationId },
+                },
+                body: body,
             });
-            // Validate each returned job ID
-            for (const jobId of resp) {
-                if (!jobId || typeof jobId !== "string") {
+            const ids = Array.isArray(data) ? data : [];
+            for (const jobId of ids) {
+                if (typeof jobId !== "string" || !isUuidString(jobId)) {
                     throw new RoeAPIException(`Invalid job ID returned from batch API: ${JSON.stringify(jobId)}`);
                 }
-                if (!isUuidString(jobId)) {
-                    throw new RoeAPIException(`Invalid job ID format returned from batch API: ${jobId}`);
-                }
                 allJobIds.push(jobId);
             }
         }
         return new JobBatch({ agentsApi: this, jobIds: allJobIds, timeoutSeconds: params.timeoutSeconds });
     }
-    async runSync(agentId, inputs) {
+    async runSync(agentId, inputs, metadata) {
         validateUuid(agentId, "agentId");
-        const resp = await this.httpClient.postWithDynamicInputs(`/v1/agents/run/${agentId}/`, inputs);
-        return resp;
+        return postDynamicInputs(this.raw, "/v1/agents/run/{agent_id}/", { agent_id: agentId }, { organization_id: this.config.organizationId }, inputs, metadata, this.config.maxRetries);
     }
     async runVersion(params) {
         validateUuid(params.agentId, "agentId");
         validateUuid(params.versionId, "versionId");
-        const response = await this.httpClient.postWithDynamicInputs(`/v1/agents/run/${params.agentId}/versions/${params.versionId}/async/`, params.inputs);
-        // Handle both string response and object response formats
-        const jobId = typeof response === "string" ? response : response?.job_id;
-        if (!jobId || typeof jobId !== "string") {
-            throw new RoeAPIException(`Invalid job ID returned from API: ${JSON.stringify(response)}`);
-        }
-        if (!isUuidString(jobId)) {
-            throw new RoeAPIException(`Invalid job ID format returned from API: ${jobId}`);
-        }
+        const response = await postDynamicInputs(this.raw, "/v1/agents/run/{agent_id}/versions/{agent_version_id}/async/", { agent_id: params.agentId, agent_version_id: params.versionId }, { organization_id: this.config.organizationId }, params.inputs, params.metadata, this.config.maxRetries);
+        const jobId = this.extractJobId(response);
         return new Job({ agentsApi: this, jobId, timeoutSeconds: params.timeoutSeconds });
     }
-    async runVersionSync(agentId, versionId, inputs) {
+    async runVersionSync(agentId, versionId, inputs, metadata) {
         validateUuid(agentId, "agentId");
         validateUuid(versionId, "versionId");
-        return this.httpClient.postWithDynamicInputs(`/v1/agents/run/${agentId}/versions/${versionId}/`, inputs);
+        return postDynamicInputs(this.raw, "/v1/agents/run/{agent_id}/versions/{agent_version_id}/", { agent_id: agentId, agent_version_id: versionId }, { organization_id: this.config.organizationId }, inputs, metadata, this.config.maxRetries);
+    }
+    extractJobId(response) {
+        let jobId;
+        if (typeof response === "string") {
+            jobId = response;
+        }
+        else if (response && typeof response === "object") {
+            const obj = response;
+            jobId = obj.job_id ?? obj.id;
+        }
+        if (typeof jobId !== "string" || !isUuidString(jobId)) {
+            throw new RoeAPIException(`Invalid job ID returned from API: ${JSON.stringify(response)}`);
+        }
+        return jobId;
     }
     *iterChunks(items, size) {
         for (let i = 0; i < items.length; i += size) {

package/dist/api/policies.d.ts

@@ -1,11 +1,16 @@
 import { RoeConfig } from "../config.js";
-import { RoeHTTPClient } from "../utils/httpClient.js";
-import { PaginatedResponse } from "../models/responses.js";
-import { Policy, PolicyVersion } from "../models/policy.js";
+import type { RoeRawClient } from "../generated/client.js";
+import type { components } from "../generated/schema.js";
+type Policy = components["schemas"]["Policy"];
+type CreatePolicy = components["schemas"]["CreatePolicy"];
+type UpdatePolicy = components["schemas"]["UpdatePolicy"];
+type PolicyVersion = components["schemas"]["PolicyVersion"];
+type PaginatedPolicyList = components["schemas"]["PaginatedPolicyList"];
 export declare class PolicyVersionsAPI {
     private readonly policiesApi;
     constructor(policiesApi: PoliciesAPI);
-    private get http();
+    private get raw();
+    private get organizationId();
     list(policyId: string): Promise<PolicyVersion[]>;
     retrieve(policyId: string, versionId: string): Promise<PolicyVersion>;
     create(params: {
@@ -17,23 +22,24 @@ export declare class PolicyVersionsAPI {
 }
 export declare class PoliciesAPI {
     readonly config: RoeConfig;
-    readonly httpClient: RoeHTTPClient;
+    readonly raw: RoeRawClient;
     readonly versions: PolicyVersionsAPI;
-    constructor(config: RoeConfig, httpClient: RoeHTTPClient);
+    constructor(config: RoeConfig, raw: RoeRawClient);
     list(params?: {
         page?: number;
         pageSize?: number;
-    }): Promise<PaginatedResponse<Policy>>;
+    }): Promise<PaginatedPolicyList>;
     retrieve(policyId: string): Promise<Policy>;
     create(params: {
         name: string;
         content: Record<string, unknown>;
         description?: string;
         versionName?: string;
-    }): Promise<Policy>;
+    }): Promise<CreatePolicy>;
     update(policyId: string, updates: {
         name?: string;
         description?: string;
-    }): Promise<Policy>;
+    }): Promise<UpdatePolicy>;
     delete(policyId: string): Promise<void>;
 }
+export {};