roe-typescript 0.1.2 → 1.0.0

package/dist/api/policies.js

@@ -1,4 +1,3 @@
-import { PaginationHelper } from "../utils/pagination.js";
 import { isUuidString } from "../utils/fileDetection.js";
 import { BadRequestError, RoeAPIException } from "../exceptions.js";
 /**
@@ -14,77 +13,122 @@ export class PolicyVersionsAPI {
     constructor(policiesApi) {
         this.policiesApi = policiesApi;
     }
-    get http() {
-        return this.policiesApi.httpClient;
+    get raw() {
+        return this.policiesApi.raw;
+    }
+    get organizationId() {
+        return this.policiesApi.config.organizationId;
     }
     async list(policyId) {
         validateUuid(policyId, "policyId");
-        const data = await this.http.get(`/v1/policies/${policyId}/versions/`);
-        if (Array.isArray(data))
-            return data;
-        return data.results ?? [];
+        const { data } = await this.raw.GET("/v1/policies/{policy_id}/versions/", {
+            params: {
+                path: { policy_id: policyId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+        return data?.results ?? [];
     }
     async retrieve(policyId, versionId) {
         validateUuid(policyId, "policyId");
         validateUuid(versionId, "versionId");
-        return this.http.get(`/v1/policies/${policyId}/versions/${versionId}/`);
+        const { data } = await this.raw.GET("/v1/policies/{policy_id}/versions/{version_id}/", {
+            params: {
+                path: { policy_id: policyId, version_id: versionId },
+                query: { organization_id: this.organizationId },
+            },
+        });
+        return data;
     }
     async create(params) {
         validateUuid(params.policyId, "policyId");
         if (params.baseVersionId !== undefined)
             validateUuid(params.baseVersionId, "baseVersionId");
-        const payload = { content: params.content };
+        const body = {
+            content: params.content,
+        };
         if (params.versionName !== undefined)
-            payload.version_name = params.versionName;
+            body.version_name = params.versionName;
         if (params.baseVersionId !== undefined)
-            payload.base_version_id = params.baseVersionId;
-        const data = await this.http.post({
-            url: `/v1/policies/${params.policyId}/versions/`,
-            json: payload,
+            body.base_version_id = params.baseVersionId;
+        const { data } = await this.raw.POST("/v1/policies/{policy_id}/versions/", {
+            params: {
+                path: { policy_id: params.policyId },
+                query: { organization_id: this.organizationId },
+            },
+            body,
         });
-        if (!data.id) {
+        if (!data?.id) {
             throw new RoeAPIException(`Unexpected response from server: ${JSON.stringify(data)}`);
         }
-        // POST returns partial data; re-fetch to get the full version
+        // POST returns a partial CreatePolicyVersion; re-fetch to get the full version.
         return this.retrieve(params.policyId, data.id);
     }
 }
 export class PoliciesAPI {
-    constructor(config, httpClient) {
+    constructor(config, raw) {
         this.config = config;
-        this.httpClient = httpClient;
+        this.raw = raw;
         this.versions = new PolicyVersionsAPI(this);
     }
     async list(params) {
-        const query = PaginationHelper.buildQueryParams(this.config.organizationId, params?.page, params?.pageSize);
-        return this.httpClient.get("/v1/policies/", query);
+        const { data } = await this.raw.GET("/v1/policies/", {
+            params: {
+                query: {
+                    organization_id: this.config.organizationId,
+                    page: params?.page,
+                    page_size: params?.pageSize,
+                },
+            },
+        });
+        return data;
     }
     async retrieve(policyId) {
         validateUuid(policyId, "policyId");
-        return this.httpClient.get(`/v1/policies/${policyId}/`);
+        const { data } = await this.raw.GET("/v1/policies/{id}/", {
+            params: {
+                path: { id: policyId },
+                query: { organization_id: this.config.organizationId },
+            },
+        });
+        return data;
     }
     async create(params) {
-        const payload = {
+        const body = {
             name: params.name,
             content: params.content,
             description: params.description ?? "",
-            organization_id: this.config.organizationId,
+            version_name: params.versionName ?? "version 1",
         };
-        if (params.versionName !== undefined)
-            payload.version_name = params.versionName;
-        return this.httpClient.post({ url: "/v1/policies/", json: payload });
+        const { data } = await this.raw.POST("/v1/policies/", {
+            params: { query: { organization_id: this.config.organizationId } },
+            body,
+        });
+        return data;
     }
     async update(policyId, updates) {
         validateUuid(policyId, "policyId");
-        const payload = {};
+        const body = {};
         if (updates.name !== undefined)
-            payload.name = updates.name;
+            body.name = updates.name;
         if (updates.description !== undefined)
-            payload.description = updates.description;
-        return this.httpClient.put(`/v1/policies/${policyId}/`, payload);
+            body.description = updates.description;
+        const { data } = await this.raw.PATCH("/v1/policies/{id}/", {
+            params: {
+                path: { id: policyId },
+                query: { organization_id: this.config.organizationId },
+            },
+            body,
+        });
+        return data;
     }
     async delete(policyId) {
         validateUuid(policyId, "policyId");
-        await this.httpClient.delete(`/v1/policies/${policyId}/`);
+        await this.raw.DELETE("/v1/policies/{id}/", {
+            params: {
+                path: { id: policyId },
+                query: { organization_id: this.config.organizationId },
+            },
+        });
     }
 }

package/dist/api/users.d.ts

@@ -0,0 +1,18 @@
+import type { RoeConfig } from "../config.js";
+import type { RoeRawClient } from "../generated/client.js";
+import type { components } from "../generated/schema.js";
+type User = components["schemas"]["UserInfo"];
+export declare class UsersAPI {
+    readonly config: RoeConfig;
+    readonly raw: RoeRawClient;
+    constructor(config: RoeConfig, raw: RoeRawClient);
+    /**
+     * Retrieve the currently authenticated user.
+     *
+     * Wraps `GET /v1/users/current_user/`. The OpenAPI spec marks the response
+     * body as undocumented, so we read JSON via openapi-fetch's `parseAs` escape
+     * hatch and cast the result to `UserInfo` (the schema the backend returns).
+     */
+    me(): Promise<User>;
+}
+export {};

package/dist/api/users.js

@@ -0,0 +1,17 @@
+export class UsersAPI {
+    constructor(config, raw) {
+        this.config = config;
+        this.raw = raw;
+    }
+    /**
+     * Retrieve the currently authenticated user.
+     *
+     * Wraps `GET /v1/users/current_user/`. The OpenAPI spec marks the response
+     * body as undocumented, so we read JSON via openapi-fetch's `parseAs` escape
+     * hatch and cast the result to `UserInfo` (the schema the backend returns).
+     */
+    async me() {
+        const result = await this.raw.GET("/v1/users/current_user/", { parseAs: "json" });
+        return result.data;
+    }
+}

package/dist/client.d.ts

@@ -1,16 +1,20 @@
 import { AgentsAPI } from "./api/agents.js";
 import { PoliciesAPI } from "./api/policies.js";
+import { UsersAPI } from "./api/users.js";
 import { RoeAuth } from "./auth.js";
 import { RoeConfig, RoeConfigInput } from "./config.js";
-import { RoeHTTPClient } from "./utils/httpClient.js";
+import { type RoeRawClient } from "./generated/client.js";
 export declare class RoeClient {
     readonly config: RoeConfig;
     readonly auth: RoeAuth;
-    readonly httpClient: RoeHTTPClient;
+    readonly raw: RoeRawClient;
     private readonly _agents;
     private readonly _policies;
+    private readonly _users;
     constructor(input?: RoeConfigInput);
     get agents(): AgentsAPI;
     get policies(): PoliciesAPI;
+    get users(): UsersAPI;
+    /** No-op kept for source compatibility; the raw client manages its own connections. */
     close(): void;
 }

package/dist/client.js

@@ -1,15 +1,23 @@
 import { AgentsAPI } from "./api/agents.js";
 import { PoliciesAPI } from "./api/policies.js";
+import { UsersAPI } from "./api/users.js";
 import { RoeAuth } from "./auth.js";
 import { RoeConfig } from "./config.js";
-import { RoeHTTPClient } from "./utils/httpClient.js";
+import { createRoeRawClient } from "./generated/client.js";
 export class RoeClient {
     constructor(input = {}) {
         this.config = RoeConfig.fromEnv(input);
         this.auth = new RoeAuth(this.config);
-        this.httpClient = new RoeHTTPClient(this.config, this.auth);
-        this._agents = new AgentsAPI(this.config, this.httpClient);
-        this._policies = new PoliciesAPI(this.config, this.httpClient);
+        this.raw = createRoeRawClient({
+            baseUrl: this.config.baseUrl,
+            // Auth headers are injected per-request by authMiddleware; no static
+            // headers option here so a stale snapshot can't shadow the live token.
+            auth: this.auth,
+            maxRetries: this.config.maxRetries,
+        });
+        this._agents = new AgentsAPI(this.config, this.raw);
+        this._policies = new PoliciesAPI(this.config, this.raw);
+        this._users = new UsersAPI(this.config, this.raw);
     }
     get agents() {
         return this._agents;
@@ -17,7 +25,11 @@ export class RoeClient {
     get policies() {
         return this._policies;
     }
+    get users() {
+        return this._users;
+    }
+    /** No-op kept for source compatibility; the raw client manages its own connections. */
     close() {
-        this.httpClient.close();
+        /* no-op */
     }
 }

package/dist/exceptions.js

@@ -74,6 +74,14 @@ export function extractErrorMessage(data, statusCode) {
                 return firstError.message;
             }
         }
+        for (const value of Object.values(obj)) {
+            if (Array.isArray(value) && value.length > 0) {
+                return value.map(String).join("; ");
+            }
+            if (typeof value === "string" && value.length > 0) {
+                return value;
+            }
+        }
     }
     // Fallback to generic message
     return `HTTP ${statusCode} error`;

package/dist/generated/client.d.ts

@@ -0,0 +1,12 @@
+import type { components, paths } from "./schema.js";
+import type { RoeAuth } from "../auth.js";
+export type RoeApiComponents = components;
+export type RoeApiPaths = paths;
+export type RoeRawClient = ReturnType<typeof createRoeRawClient>;
+export declare function createRoeRawClient(options: {
+    baseUrl: string;
+    headers?: HeadersInit;
+    fetch?: typeof fetch;
+    auth?: RoeAuth;
+    maxRetries?: number;
+}): import("openapi-fetch").Client<paths, `${string}/${string}`>;

package/dist/generated/client.js

@@ -0,0 +1,55 @@
+// Hand-maintained boilerplate. Lives under src/generated/ alongside schema.d.ts
+// because it imports from it. Drift CI regenerates schema.d.ts and verifies
+// this file is unchanged.
+import createClient from "openapi-fetch";
+import { authMiddleware, errorMiddleware, retryMiddleware, } from "../utils/middleware.js";
+// Default fetch: resolves globalThis.fetch at call time so vitest's
+// vi.stubGlobal('fetch', ...) is honored. In Node 18+ globalThis.fetch is
+// undici-backed, so streaming bodies work end-to-end. For the multipart-with-
+// Node-stream case in AgentsAPI we'll import undici.fetch directly.
+const defaultFetch = (...args) => globalThis.fetch(...args);
+function isNetworkFetchError(error) {
+    return error instanceof TypeError && /fetch failed/i.test(error.message);
+}
+function networkRetryFetch(fetchImpl, maxRetries) {
+    return async (input, init) => {
+        let attempt = 0;
+        while (true) {
+            try {
+                // `Request` bodies are single-use. Clone before each attempt so a
+                // transient socket failure can be retried without disturbing the
+                // original request object openapi-fetch handed us.
+                const retryableInput = maxRetries > 0 && input instanceof Request ? input.clone() : input;
+                return await fetchImpl(retryableInput, init);
+            }
+            catch (error) {
+                if (attempt >= maxRetries || !isNetworkFetchError(error)) {
+                    throw error;
+                }
+                const backoffMs = Math.min(1000 * 2 ** attempt, 10000);
+                await new Promise((resolve) => setTimeout(resolve, backoffMs));
+                attempt += 1;
+            }
+        }
+    };
+}
+export function createRoeRawClient(options) {
+    const maxRetries = options.maxRetries ?? 0;
+    const client = createClient({
+        baseUrl: options.baseUrl,
+        headers: options.headers,
+        fetch: networkRetryFetch(options.fetch ?? defaultFetch, maxRetries),
+    });
+    // openapi-fetch runs onRequest in registration order and onResponse in
+    // REVERSE registration order. We want responses to flow auth -> retry ->
+    // error so the error middleware sees the final post-retry response.
+    // Registration order is therefore the inverse: error -> retry -> auth.
+    client.use(errorMiddleware);
+    if (maxRetries > 0) {
+        client.use(retryMiddleware(maxRetries));
+    }
+    if (options.auth) {
+        client.use(authMiddleware(options.auth));
+    }
+    return client;
+}

package/dist/index.d.ts

@@ -2,11 +2,13 @@ export { RoeClient } from "./client.js";
 export { RoeConfig } from "./config.js";
 export type { RoeConfigInput } from "./config.js";
 export { RoeAuth } from "./auth.js";
+export { createRoeRawClient } from "./generated/client.js";
+export type { RoeApiComponents, RoeApiPaths, RoeRawClient } from "./generated/client.js";
+export type { components, paths } from "./generated/schema.js";
 export * from "./exceptions.js";
 export * from "./api/agents.js";
 export * from "./api/policies.js";
-export * from "./models/agent.js";
-export * from "./models/policy.js";
-export * from "./models/job.js";
-export * from "./models/responses.js";
-export * from "./models/file.js";
+export * from "./api/users.js";
+export { Job, JobBatch, JobStatus } from "./models/job.js";
+export type { JobResult, JobBatchItem } from "./models/job.js";
+export { FileUpload } from "./models/file.js";

package/dist/index.js

@@ -1,11 +1,15 @@
 export { RoeClient } from "./client.js";
 export { RoeConfig } from "./config.js";
 export { RoeAuth } from "./auth.js";
+export { createRoeRawClient } from "./generated/client.js";
 export * from "./exceptions.js";
 export * from "./api/agents.js";
 export * from "./api/policies.js";
-export * from "./models/agent.js";
-export * from "./models/policy.js";
-export * from "./models/job.js";
-export * from "./models/responses.js";
-export * from "./models/file.js";
+export * from "./api/users.js";
+export { Job, JobBatch, JobStatus } from "./models/job.js";
+export { FileUpload } from "./models/file.js";
+// Hand-written response models removed in v1.0 (Agent, BaseAgent, Policy, PolicyVersion,
+// AgentVersion, AgentDatum, AgentJobResult, AgentJobStatus, Reference, JobDataDeleteResponse,
+// PaginatedResponse, UserInfo). Import the generated equivalents instead, e.g.:
+//   import type { components } from "@roe-ai/typescript";
+//   type Policy = components["schemas"]["Policy"];

package/dist/models/file.d.ts

@@ -10,6 +10,13 @@ export declare class FileUpload {
     readonly filename?: string;
     readonly mimeType?: string;
     private _openedStream;
+    /**
+     * Cached Blob built from the stream-backed source. Streams can only be read
+     * once, so we buffer their bytes on the first `toBlob()` call and reuse the
+     * result on retries — otherwise repeated calls would silently upload an
+     * empty file.
+     */
+    private _streamBlob;
     constructor(init: FileUploadInit);
     get effectiveFilename(): string;
     get effectiveMimeType(): string;
@@ -18,6 +25,16 @@ export declare class FileUpload {
      * Track opened streams so they can be closed later.
      */
     open(): NodeJS.ReadableStream;
+    /**
+     * Loads the file contents as a Blob with the resolved MIME type.
+     *
+     * Path-backed uploads are read fully into memory before the Blob is built.
+     * That keeps the wrapper cross-runtime (browser + Node) at the cost of
+     * peak RAM = file size. Real-world files are well under MAX_FILE_SIZE,
+     * but if you hit memory pressure switch to a streaming `Readable` and
+     * use `undici`-flavored FormData.
+     */
+    toBlob(): Promise<Blob>;
     /**
      * Closes any opened file stream to prevent resource leaks.
      * Should be called after the file upload is complete.

package/dist/models/file.js

@@ -7,6 +7,13 @@ const MAX_FILE_SIZE = 2 * 1024 * 1024 * 1024;
 export class FileUpload {
     constructor(init) {
         this._openedStream = null;
+        /**
+         * Cached Blob built from the stream-backed source. Streams can only be read
+         * once, so we buffer their bytes on the first `toBlob()` call and reuse the
+         * result on retries — otherwise repeated calls would silently upload an
+         * empty file.
+         */
+        this._streamBlob = null;
         this.path = init.path;
         this.file = init.file;
         this.filename = init.filename;
@@ -58,6 +65,35 @@ export class FileUpload {
         }
         throw new Error("No file source available");
     }
+    /**
+     * Loads the file contents as a Blob with the resolved MIME type.
+     *
+     * Path-backed uploads are read fully into memory before the Blob is built.
+     * That keeps the wrapper cross-runtime (browser + Node) at the cost of
+     * peak RAM = file size. Real-world files are well under MAX_FILE_SIZE,
+     * but if you hit memory pressure switch to a streaming `Readable` and
+     * use `undici`-flavored FormData.
+     */
+    async toBlob() {
+        if (this.path) {
+            const buf = await fs.promises.readFile(this.path);
+            return new Blob([buf], { type: this.effectiveMimeType });
+        }
+        if (this.file) {
+            // Streams are single-shot. Buffer the bytes once and cache the resulting
+            // Blob so retry attempts (which call `toBlob()` again) don't end up
+            // uploading a zero-byte body.
+            if (this._streamBlob)
+                return this._streamBlob;
+            const chunks = [];
+            for await (const chunk of this.file) {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            }
+            this._streamBlob = new Blob([Buffer.concat(chunks)], { type: this.effectiveMimeType });
+            return this._streamBlob;
+        }
+        throw new Error("No file source available");
+    }
     /**
      * Closes any opened file stream to prevent resource leaks.
      * Should be called after the file upload is complete.

package/dist/models/job.d.ts

@@ -1,5 +1,28 @@
 import { AgentsAPI } from "../api/agents.js";
-import { AgentJobResult, AgentJobStatus } from "./responses.js";
+import type { components } from "../generated/schema.js";
+export declare enum JobStatus {
+    PENDING = 0,
+    STARTED = 1,
+    RETRY = 2,
+    SUCCESS = 3,
+    FAILURE = 4,
+    CANCELLED = 5,
+    CACHED = 6
+}
+type AgentJobStatus = components["schemas"]["AgentJobStatus"];
+type AgentJobResultResponse = components["schemas"]["AgentJobResultResponse"];
+type AgentJobResultItem = components["schemas"]["AgentJobResultItem"];
+type AgentDatum = components["schemas"]["AgentDatum"];
+/** Result returned by `Job.wait()` — generated body merged with terminal status + error. */
+export type JobResult = AgentJobResultResponse & {
+    status: number | null;
+    error_message: string | null;
+};
+/** Result returned by `JobBatch.wait()` — per-job item merged with normalized error message. */
+export type JobBatchItem = AgentJobResultItem & {
+    outputs: AgentDatum[];
+    error_message: string | null;
+};
 export declare class Job {
     private readonly agentsApi;
     private readonly jobId;
@@ -13,16 +36,16 @@ export declare class Job {
     wait(params?: {
         intervalSeconds?: number;
         timeoutSeconds?: number;
-    }): Promise<AgentJobResult>;
+    }): Promise<JobResult>;
     retrieveStatus(): Promise<AgentJobStatus>;
-    retrieveResult(): Promise<AgentJobResult>;
+    retrieveResult(): Promise<AgentJobResultResponse>;
 }
 export declare class JobBatch {
     private readonly agentsApi;
     private readonly jobIds;
     private readonly timeoutSeconds;
     private completed;
-    private statusCache;
+    private statuses;
     constructor(opts: {
         agentsApi: AgentsAPI;
         jobIds: string[];
@@ -32,6 +55,7 @@ export declare class JobBatch {
     wait(params?: {
         intervalSeconds?: number;
         timeoutSeconds?: number;
-    }): Promise<AgentJobResult[]>;
-    retrieveStatus(): Promise<Record<string, number>>;
+    }): Promise<JobBatchItem[]>;
+    retrieveStatus(): Promise<Record<string, AgentJobStatus>>;
 }
+export {};