@kimpton-ai/evalrouter 0.1.0 → 0.3.0

package/README.md

@@ -1,16 +1,17 @@
 # EvalRouter TypeScript client
 
 Client for trusted Node.js 22+ applications, using ESM, distributed under the
-proprietary [Kimpton EvalRouter SDK License](LICENSE). Install with
-`npm install @kimpton-ai/evalrouter@0.1.0`. Discover evaluations and models,
-submit bounded evaluation runs, inspect results, and export reports.
+proprietary [Kimpton EvalRouter SDK License](LICENSE). Install the package with
+your Node.js package manager or use a reviewed package archive supplied by your
+operator. Discover evaluations and models, submit bounded evaluation runs,
+inspect results, and export reports.
 
 Use API keys only in a trusted server process, never a browser bundle. Set
 `EVALROUTER_BASE_URL`, `EVALROUTER_API_KEY` and `EVALROUTER_WORKSPACE_ID` after
 creating and funding an account in the web application. The public API origin is
 `https://api.evalrouter.ai`. Package download does not grant service access.
-While website access is restricted, obtain an invitation from your EvalRouter
-operator before setting up the account and workspace key.
+Use an invitation if required by your EvalRouter operator when setting up the
+account and workspace key.
 
 ```typescript
 import { Client } from "@kimpton-ai/evalrouter";
@@ -36,7 +37,8 @@ the same idempotency key. Local timeouts do not establish that a submitted run
 failed to commit.
 
 The supported resources are `catalog`, `evals`, `connections`, `quotes`,
-`evaluations` and `runs`. `catalog.evals` and `catalog.eval` are discovery aliases.
+`evaluations`, `runs` and `agent_builds`; `agents` provides only `register`. `catalog.evals` and
+`catalog.eval` are discovery aliases.
 The package includes named request/response types, `Client` (`EvalRouter` alias),
 `APIError`, `ClientError`, `RequestTimeout`, `WaitCancelled`, and typed
 request/wait options. `runs.wait` supports local abort/deadlines; `runs.cancel`
@@ -46,3 +48,87 @@ also be passed in `ClientOptions`.
 
 The HTTP service enforces account access and workspace permissions. Configure
 the client with an existing workspace API key.
+
+## Repository agents
+
+Repository methods require version 0.2.0 or later and service enablement for the
+workspace. Package installation does not enable qualification. Stop when options
+report it disabled or do not include the exact requested target and model.
+
+Use self-service repository qualification jobs to prepare managed agents.
+Check `client.agent_builds.options()` for available targets and models. The
+flow supports GitHub repositories with the supported locked Node/npm runtime and
+an `evalrouter-agent.json` manifest. Python agent runtimes and custom Docker
+images are not supported by this flow. Public repositories need no GitHub grant.
+For a private repository, first connect GitHub in the web application and
+explicitly select that repository for the current workspace. Include
+`source: {github_connection_id, github_repository_id}` in the same preview JSON,
+using both IDs returned by that connection. The repository URL still identifies
+the selected repository. These IDs select an existing grant; they are not
+credentials. The SDK and CLI do not authorize installations, accept GitHub
+tokens, or bypass revoked access. Repository access remains subject to the
+current workspace grant.
+
+Preview resolves an immutable commit and returns the qualification scope, cost
+components, spending cap and expiry. It creates no job, reserves no credit and
+starts no sandbox or model work. Review it before explicitly creating a job;
+creation reserves the quoted cap and may incur the stated costs.
+
+```typescript
+const options = await client.agent_builds.options();
+const preview = await client.agent_builds.preview({
+  repository_url: "YOUR_PUBLIC_GITHUB_REPOSITORY_URL",
+  ref: "main",
+  manifest_path: "evalrouter-agent.json",
+  qualification: {
+    environment_ref: "EXACT_ENVIRONMENT_FROM_OPTIONS",
+    model: { kind: "managed", route_id: "MODEL_FROM_OPTIONS" },
+  },
+  max_cost_microusd: "1000000",
+});
+console.log(preview); // Review first; this example stops before submitting work.
+```
+
+After review, call
+`client.agent_builds.create({quote_id: preview.id}, durableIdempotencyKey)`.
+Persist the quote ID and key first. If the response is lost, retry that exact
+request and key, or recover with `agent_builds.list({quote_id: preview.id})`.
+A new key is a new submission. Read progress with `agent_builds.get(jobId)` and
+request cancellation with `agent_builds.cancel(jobId)`. Cancellation can remain
+`cancelling` while cleanup finishes; `reconciling` is unresolved, and neither
+state is Ready. Reads do not silently retry failed jobs.
+
+An HTTP 429 with code `agent_build_quota` is returned immediately as `APIError`,
+preserving its status and code. Review the quota before another submission;
+transport backoff cannot resolve that refusal. Other transient rate limits retain
+bounded transport retries with the same idempotency key.
+
+Ready returns `agent.ref` after qualification and cleanup. It establishes only
+the returned supported scope, not benchmark quality or broad task compatibility.
+Build/qualification costs and later evaluation costs have separate caps. To
+preview an evaluation, use the Ready record's exact scope:
+
+```typescript
+if (ready.status === "ready" && ready.agent) {
+  const scope = ready.qualification;
+  const quote = await client.quotes.create({
+    agent: ready.agent.ref,
+    selection: { environment: scope.environment_ref, split: scope.split },
+    coverage: scope.evaluation_coverage,
+    max_charge_microusd: "1000000",
+  });
+  console.log(quote); // Review before separately calling runs.create.
+}
+```
+
+Do not substitute a task ID, guess a seed or expand the returned coverage. Money
+values are decimal strings in micro-USD. API errors retain status and code; an
+error or local timeout does not establish that a create request failed to commit.
+Use plain JSON data for job inputs; serialization hooks and private fields are
+rejected before HTTP.
+
+The advanced `agents.register` method remains available for an existing
+workspace-scoped admission supplied separately: only `ref`, `kind: "managed_acp"`
+and `admission_id` are accepted. Self-service repository jobs do not require the
+customer to obtain an admission ID. The existing model `Client.run` helper and
+`NewQuote` contract remain unchanged; managed evaluation quotes use `NewAgentQuote`.

package/dist/boundary.d.ts

@@ -1,2 +1,2 @@
 /** Validate supported evaluation inputs before issuing a request. */
-export declare function validateSubmission(resource: "quotes" | "evaluations", input: unknown): void;
+export declare function validateSubmission(resource: "quotes" | "evaluations" | "agents" | "agent_builds", input: unknown): unknown;

package/dist/boundary.js

@@ -2,8 +2,111 @@ import { ClientError } from "./transport.js";
 /** Validate supported evaluation inputs before issuing a request. */
 export function validateSubmission(resource, input) {
     const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+    // Snapshot data properties before validation. JSON.stringify must never run
+    // customer accessors or serialization hooks after the boundary has passed.
+    const snapshot = (value, seen = new Set()) => {
+        const invalid = () => {
+            throw new ClientError("unsupported_feature", "Use plain JSON data for registration, repository jobs and quotes.");
+        };
+        if (value === null || value === undefined || typeof value === "string" || typeof value === "boolean")
+            return value;
+        if (typeof value === "number")
+            return Number.isFinite(value) ? value : invalid();
+        if (typeof value !== "object")
+            return invalid();
+        const array = Array.isArray(value);
+        const prototype = Object.getPrototypeOf(value);
+        if ((prototype !== null && prototype !== (array ? Array.prototype : Object.prototype)) ||
+            "toJSON" in value || seen.has(value))
+            return invalid();
+        seen.add(value);
+        const result = array ? Object.setPrototypeOf([], null) : Object.create(null);
+        for (const key of Reflect.ownKeys(value)) {
+            if (array && key === "length")
+                continue;
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (typeof key !== "string" || !descriptor || !descriptor.enumerable || !("value" in descriptor) ||
+                (array && !/^(0|[1-9][0-9]*)$/.test(key)))
+                return invalid();
+            result[key] = snapshot(descriptor.value, seen);
+        }
+        seen.delete(value);
+        return result;
+    };
+    if (resource === "agents" || resource === "quotes" || resource === "agent_builds") {
+        try {
+            input = snapshot(input);
+        }
+        catch {
+            throw new ClientError("unsupported_feature", "Use plain JSON data for registration, repository jobs and quotes.");
+        }
+    }
+    if (resource === "agent_builds") {
+        const invalid = () => { throw new ClientError("unsupported_feature", "Use the supported repository job input."); };
+        if (!object(input))
+            return invalid();
+        if (Object.keys(input).length === 1 && "quote_id" in input) {
+            if (typeof input.quote_id !== "string" || !input.quote_id)
+                return invalid();
+            return input;
+        }
+        if (Object.keys(input).some(key => !["repository_url", "ref", "manifest_path", "max_cost_microusd", "qualification", "source"].includes(key)))
+            return invalid();
+        const repository = input.repository_url;
+        const cost = input.max_cost_microusd;
+        const ref = input.ref;
+        const manifest = input.manifest_path === undefined ? "evalrouter-agent.json" : input.manifest_path;
+        const qualification = input.qualification;
+        const source = input.source;
+        if (source != null && (!object(source) || Object.keys(source).length !== 2 ||
+            Object.keys(source).some(key => !["github_connection_id", "github_repository_id"].includes(key)) ||
+            typeof source.github_connection_id !== "string" || !/^[0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}$/.test(source.github_connection_id) ||
+            typeof source.github_repository_id !== "number" || !Number.isSafeInteger(source.github_repository_id) || source.github_repository_id < 1))
+            return invalid();
+        if (typeof repository !== "string" || repository.length > 300 ||
+            !/^https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repository) ||
+            typeof cost !== "string" || !/^[0-9]{1,9}$/.test(cost) ||
+            (ref != null && (typeof ref !== "string" || !/^[!-~]{1,200}$/.test(ref))) ||
+            typeof manifest !== "string" || manifest.length < 1 || manifest.length > 240 ||
+            !/^[A-Za-z0-9_./-]+$/.test(manifest) || manifest.split("/").some(part => ["", ".", ".."].includes(part)) ||
+            !object(qualification) || Object.keys(qualification).length !== 2 ||
+            Object.keys(qualification).some(key => !["environment_ref", "model"].includes(key)))
+            return invalid();
+        const environment = qualification.environment_ref;
+        const model = qualification.model;
+        if (typeof environment !== "string" || environment.length < 1 || environment.length > 300 ||
+            !object(model) || Object.keys(model).some(key => !["kind", "route_id"].includes(key)) ||
+            (model.kind !== undefined && model.kind !== "managed") ||
+            typeof model.route_id !== "string" || model.route_id.length < 1 || model.route_id.length > 200)
+            return invalid();
+        return input;
+    }
+    if (resource === "agents") {
+        if (!object(input) || input.kind !== "managed_acp" ||
+            Object.keys(input).length !== 3 ||
+            Object.keys(input).some(key => !["ref", "kind", "admission_id"].includes(key)) ||
+            !["ref", "admission_id"].every(key => typeof input[key] === "string" && input[key])) {
+            throw new ClientError("unsupported_feature", "Registration requires ref, managed_acp kind and admission_id.");
+        }
+        return input;
+    }
+    if (resource === "quotes" && object(input) && "concurrency" in input) {
+        const value = input.concurrency;
+        if (!(value === "auto" || value === "max" ||
+            typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 100)) {
+            throw new ClientError("invalid_input", "Concurrency must be auto, max, or an integer from 1 to 100.");
+        }
+    }
+    if (resource === "quotes" && object(input) && "agent" in input) {
+        if (Object.keys(input).some(key => !["agent", "selection", "coverage", "max_charge_microusd", "concurrency"].includes(key)) ||
+            typeof input.agent !== "string" || !input.agent || !object(input.selection) ||
+            !("environment" in input.selection) || Object.keys(input.selection).some(key => !["environment", "split"].includes(key))) {
+            throw new ClientError("unsupported_feature", "Choose a registered agent and an exact environment reference.");
+        }
+        return input;
+    }
     const allowed = new Set(resource === "quotes"
-        ? ["selection", "model", "coverage", "max_charge_microusd"]
+        ? ["selection", "model", "coverage", "max_charge_microusd", "concurrency"]
         : ["model", "eval", "budget_usd", "max_charge_microusd", "provider", "coverage", "name", "metadata", "split"]);
     const fail = () => { throw new ClientError("unsupported_feature", "Choose an admitted eval and a managed model or checked connection."); };
     if (!object(input) || Object.keys(input).some((key) => !allowed.has(key)))
@@ -29,4 +132,5 @@ export function validateSubmission(resource, input) {
             !("eval" in selection && keys.every((key) => ["eval", "provider", "split"].includes(key))))
             return fail();
     }
+    return input;
 }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Catalog, Evals, Evaluations, Connections, Quotes, Runs } from "./resources.js";
+import { AgentBuilds, Agents, Catalog, Connections, Creators, Evals, Evaluations, Protocols, Quotes, Runs } from "./resources.js";
 import type { RunRecord } from "./types.js";
 import { Transport } from "./transport.js";
 export { APIError, ClientError, RequestTimeout, WaitCancelled, } from "./transport.js";
@@ -6,8 +6,12 @@ export type { ClientOptions, RequestOptions } from "./transport.js";
 export type { WaitOptions } from "./helpers.js";
 export type * from "./types.js";
 export declare class Client extends Transport {
+    readonly agent_builds: AgentBuilds;
+    readonly agents: Agents;
     readonly catalog: Catalog;
     readonly connections: Connections;
+    readonly creators: Creators;
+    readonly protocols: Protocols;
     readonly quotes: Quotes;
     readonly runs: Runs;
     readonly evals: Evals;

package/dist/index.js

@@ -1,10 +1,14 @@
-import { Catalog, Evals, Evaluations, Connections, Quotes, Runs } from "./resources.js";
+import { AgentBuilds, Agents, Catalog, Connections, Creators, Evals, Evaluations, Protocols, Quotes, Runs, } from "./resources.js";
 import { randomUUID } from "node:crypto";
 import { Transport } from "./transport.js";
 export { APIError, ClientError, RequestTimeout, WaitCancelled, } from "./transport.js";
 export class Client extends Transport {
+    agent_builds = new AgentBuilds(this);
+    agents = new Agents(this);
     catalog = new Catalog(this);
     connections = new Connections(this);
+    creators = new Creators(this);
+    protocols = new Protocols(this);
     quotes = new Quotes(this);
     runs = new Runs(this);
     evals = new Evals(this);

package/dist/resources.d.ts

@@ -19,7 +19,7 @@ export declare class Connections extends Resource {
     disable(connection_id: string, options?: RequestOptions): Promise<types.OKResponse>;
 }
 export declare class Quotes extends Resource {
-    create(body: types.NewQuote, options?: RequestOptions): Promise<types.QuoteRecord>;
+    create(body: types.QuotesCreateBody, options?: RequestOptions): Promise<types.QuoteRecord>;
     get(quote_id: string, options?: RequestOptions): Promise<types.QuoteRecord>;
 }
 export declare class Runs extends RunHelpers {
@@ -41,3 +41,28 @@ export declare class Evaluations extends Resource {
     create(body: types.NewEvaluation, idempotency_key: string, options?: RequestOptions): Promise<types.RunRecord>;
     get(evaluation_id: string, options?: RequestOptions): Promise<types.RunRecord>;
 }
+export declare class Agents extends Resource {
+    register(body: types.NewManagedACPAgent, options?: RequestOptions): Promise<types.AgentRecord>;
+}
+export declare class AgentBuilds extends Resource {
+    options(options?: RequestOptions): Promise<types.AgentBuildOptions>;
+    preview(body: types.AgentBuildPreview, options?: RequestOptions): Promise<types.AgentBuildQuoteRecord>;
+    create(body: types.CreateAgentBuild, idempotency_key: string, options?: RequestOptions): Promise<types.AgentBuildRecord>;
+    list(params?: types.AgentBuildsListParams, options?: RequestOptions): Promise<types.Page_AgentBuildRecord_>;
+    get(job_id: string, options?: RequestOptions): Promise<types.AgentBuildRecord>;
+    cancel(job_id: string, options?: RequestOptions): Promise<types.AgentBuildRecord>;
+}
+export declare class Creators extends Resource {
+    namespaces(params?: types.CreatorsNamespacesParams, options?: RequestOptions): Promise<types.NamespacePage>;
+    create_upload(body: types.NewUpload, idempotency_key: string, options?: RequestOptions): Promise<types.UploadResult>;
+    put_part(upload_id: string, part_index: string, body: types.NewPart, options?: RequestOptions): Promise<types.PartResult>;
+    submit(upload_id: string, options?: RequestOptions): Promise<types.ValidationResult>;
+    validation(job_id: string, options?: RequestOptions): Promise<types.ValidationResult>;
+    package(package_id: string, options?: RequestOptions): Promise<types.PackageResult>;
+    protocol(package_id: string, options?: RequestOptions): Promise<types.PackageProtocolResult>;
+}
+export declare class Protocols extends Resource {
+    grant(protocol_id: string, body: types.GrantRequest, options?: RequestOptions): Promise<types.ProtocolGrant>;
+    revoke(grant_id: string, body: types.RevokeRequest, options?: RequestOptions): Promise<types.ProtocolGrant>;
+    grants(options?: RequestOptions): Promise<types.Page_ProtocolGrant_>;
+}

package/dist/resources.js

@@ -1,4 +1,4 @@
-import { Resource, segment } from "./transport.js";
+import { Resource, segment, familyPath } from "./transport.js";
 import { RunHelpers } from "./helpers.js";
 import { validateSubmission } from "./boundary.js";
 export class Catalog extends Resource {
@@ -24,7 +24,7 @@ export class Catalog extends Resource {
         return this.client.request("GET", `/catalog/environments`, { retry: true, options, query: params });
     }
     async environment(family, options) {
-        return this.client.request("GET", `/catalog/environments/${segment(family)}`, { retry: true, options });
+        return this.client.request("GET", `/catalog/environments/${familyPath(family)}`, { retry: true, options });
     }
 }
 export class Connections extends Resource {
@@ -46,7 +46,7 @@ export class Connections extends Resource {
 }
 export class Quotes extends Resource {
     async create(body, options) {
-        validateSubmission("quotes", body);
+        body = validateSubmission("quotes", body);
         return this.client.request("POST", `/quotes`, { retry: false, options, body: body });
     }
     async get(quote_id, options) {
@@ -92,10 +92,72 @@ export class Evals extends Resource {
 }
 export class Evaluations extends Resource {
     async create(body, idempotency_key, options) {
-        validateSubmission("evaluations", body);
+        body = validateSubmission("evaluations", body);
         return this.client.request("POST", `/evaluations`, { retry: true, options, body: body, idempotency_key: idempotency_key });
     }
     async get(evaluation_id, options) {
         return this.client.request("GET", `/evaluations/${segment(evaluation_id)}`, { retry: true, options });
     }
 }
+export class Agents extends Resource {
+    async register(body, options) {
+        body = validateSubmission("agents", body);
+        return this.client.request("POST", `/agents`, { retry: false, options, body: body });
+    }
+}
+export class AgentBuilds extends Resource {
+    async options(options) {
+        return this.client.request("GET", `/agent-builds/options`, { retry: true, options });
+    }
+    async preview(body, options) {
+        body = validateSubmission("agent_builds", body);
+        return this.client.request("POST", `/agent-builds/preview`, { retry: false, options, body: body });
+    }
+    async create(body, idempotency_key, options) {
+        body = validateSubmission("agent_builds", body);
+        return this.client.request("POST", `/agent-builds`, { retry: true, options, body: body, idempotency_key: idempotency_key });
+    }
+    async list(params = {}, options) {
+        return this.client.request("GET", `/agent-builds`, { retry: true, options, query: params });
+    }
+    async get(job_id, options) {
+        return this.client.request("GET", `/agent-builds/${segment(job_id)}`, { retry: true, options });
+    }
+    async cancel(job_id, options) {
+        return this.client.request("POST", `/agent-builds/${segment(job_id)}/cancel`, { retry: true, options });
+    }
+}
+export class Creators extends Resource {
+    async namespaces(params = {}, options) {
+        return this.client.request("GET", `/creator/namespaces`, { retry: true, options, query: params });
+    }
+    async create_upload(body, idempotency_key, options) {
+        return this.client.request("POST", `/creator/uploads`, { retry: true, options, body: body, idempotency_key: idempotency_key });
+    }
+    async put_part(upload_id, part_index, body, options) {
+        return this.client.request("PUT", `/creator/uploads/${segment(upload_id)}/parts/${segment(part_index)}`, { retry: true, options, body: body });
+    }
+    async submit(upload_id, options) {
+        return this.client.request("POST", `/creator/uploads/${segment(upload_id)}/submit`, { retry: true, options });
+    }
+    async validation(job_id, options) {
+        return this.client.request("GET", `/creator/validation-jobs/${segment(job_id)}`, { retry: true, options });
+    }
+    async package(package_id, options) {
+        return this.client.request("GET", `/creator/packages/${segment(package_id)}`, { retry: true, options });
+    }
+    async protocol(package_id, options) {
+        return this.client.request("GET", `/creator/packages/${segment(package_id)}/protocol`, { retry: true, options });
+    }
+}
+export class Protocols extends Resource {
+    async grant(protocol_id, body, options) {
+        return this.client.request("POST", `/benchmark-protocols/${segment(protocol_id)}/grants`, { retry: false, options, body: body });
+    }
+    async revoke(grant_id, body, options) {
+        return this.client.request("POST", `/benchmark-protocols/grants/${segment(grant_id)}/revoke`, { retry: false, options, body: body });
+    }
+    async grants(options) {
+        return this.client.request("GET", `/benchmark-protocols/grants`, { retry: true, options });
+    }
+}

package/dist/transport.d.ts

@@ -54,6 +54,7 @@ type Request = {
 };
 export declare function positive(value: number, label: string): number;
 export declare function segment(value: string): string;
+export declare function familyPath(value: string): string;
 export declare function checkpoint(deadline: number, signal?: AbortSignal): number;
 export declare function pause(delay: number, deadline: number, signal?: AbortSignal): Promise<void>;
 export declare class Transport {

package/dist/transport.js

@@ -52,6 +52,13 @@ export function segment(value) {
         throw new ClientError("invalid_input", "Resource identifiers must be nonempty path-safe identifiers.");
     return encodeURIComponent(value);
 }
+export function familyPath(value) {
+    if (typeof value !== "string" ||
+        /^[a-z0-9][a-z0-9_./-]{0,119}$/.exec(value)?.[0] !== value ||
+        value.split("/").some((part) => ["", ".", ".."].includes(part)))
+        throw new ClientError("invalid_input", "Catalog families must be canonical relative paths.");
+    return value.split("/").map(encodeURIComponent).join("/");
+}
 function normalizeBase(value, allowHttp) {
     try {
         if (/[\u0000-\u0020\\]/.test(value))
@@ -336,6 +343,11 @@ export class Transport {
                     secrets.some((secret) => requestId.includes(secret)))
                     requestId = null;
                 error = new APIError(response.status, code, requestId, message, details);
+                // A definite build quota refusal cannot become admissible through
+                // transport backoff. Preserve its API error instead of masking it
+                // with the overall request deadline.
+                if (response.status === 429 && code === "agent_build_quota")
+                    throw error;
                 if (![429, 502, 503, 504].includes(response.status))
                     throw error;
                 delay = retryDelay(attempt, response.headers.get("Retry-After"));

package/dist/types.d.ts

@@ -1,3 +1,133 @@
+export type AgentBuildCoverage = {
+    mode?: "sample";
+    sample_count?: 1;
+    seed: number;
+};
+export type AgentBuildInstallationBudget = {
+    cleanup_seconds: 35;
+    command_seconds: 300;
+    cpu_millis: 1000;
+    duration_seconds: 660;
+    execute_seconds: 325;
+    input_seconds: 150 | 300;
+    memory_mib: 2048;
+    output_seconds: 150;
+    schema_version: "agent-build-installation-budget.v1";
+};
+export type AgentBuildModel = {
+    kind?: "managed";
+    route_id: string;
+};
+export type AgentBuildOptions = {
+    enabled: boolean;
+    limitations: Array<string>;
+    supported_runtimes: Array<"node-npm">;
+    targets: Array<AgentBuildTarget>;
+};
+export type AgentBuildPreview = {
+    manifest_path?: string;
+    max_cost_microusd: string;
+    qualification: AgentBuildQualification;
+    ref?: string | null;
+    repository_url: string;
+    source?: GitHubSourceSelection | null;
+};
+export type AgentBuildQualification = {
+    environment_ref: string;
+    model: AgentBuildModel;
+};
+export type AgentBuildQuoteRecord = {
+    cost_components_microusd: {
+        [key: string]: string;
+    };
+    created_at: string;
+    expires_at: string;
+    full_work_upper_bound_microusd?: string | null;
+    funded_phase_caps_microusd?: {
+        [key: string]: string;
+    } | null;
+    id: string;
+    max_cost_microusd: string;
+    pricing_version: "agent-build-pricing.v1";
+    qualification: AgentBuildScope;
+    qualification_funding?: "cap_limited" | null;
+    reserved_microusd?: string;
+    source: AgentBuildSource;
+    warnings: Array<string>;
+};
+export type AgentBuildRecord = {
+    agent: AgentRecord | null;
+    cleanup_confirmed: boolean;
+    completed_at: string | null;
+    created_at: string;
+    error_code: string | null;
+    held_microusd: string;
+    id: string;
+    max_cost_microusd: string;
+    phase: "preparing" | "building" | "qualifying" | "cleanup" | "complete";
+    pricing_version: "agent-build-pricing.v1";
+    qualification: AgentBuildScope;
+    qualification_run_id: string | null;
+    quote_id: string;
+    retry_allowed: boolean;
+    source: AgentBuildSource;
+    spent_microusd: string;
+    status: "queued" | "running" | "cancelling" | "ready" | "failed" | "cancelled" | "reconciling";
+    updated_at: string;
+};
+export type AgentBuildResourceLimits = {
+    cpu_millis: number;
+    duration_seconds: number;
+    memory_mib: number;
+};
+export type AgentBuildScope = {
+    coverage?: "bounded_qualification";
+    environment_manifest_sha256: string;
+    environment_ref: string;
+    evaluation_coverage: AgentBuildCoverage;
+    installation_budget?: AgentBuildInstallationBudget | null;
+    limitations: Array<string>;
+    model: AgentBuildModel;
+    model_label: string;
+    model_sha256: string;
+    resource_limits: AgentBuildResourceLimits;
+    split: "canonical" | "train" | "development" | "test";
+    task_count: number;
+    task_ids: Array<string>;
+};
+export type AgentBuildSource = {
+    commit_sha: string;
+    github_connection_id?: string | null;
+    github_repository_id?: number | null;
+    manifest_path: string;
+    manifest_sha256: string;
+    name: string;
+    repository_url: string;
+    requested_ref: string | null;
+    runtime: "node-npm";
+    tree_sha: string;
+};
+export type AgentBuildTarget = {
+    environment_ref: string;
+    models: Array<AgentBuildModel>;
+    task_ids: Array<string>;
+};
+export type AgentBuildsListParams = {
+    quote_id?: string | null;
+    limit?: number;
+    cursor?: string | null;
+};
+export type AgentRecord = {
+    id: string;
+    ref: string;
+    kind: string;
+    revision: string;
+    manifest_sha256: string;
+    active: boolean;
+    qualified: boolean;
+    external_costs: boolean;
+    created_at: string;
+};
 export type BenchmarkDetail = {
     slug: string;
     versions: Array<BenchmarkRecord>;
@@ -88,6 +218,18 @@ export type ComparisonModel = {
     model_id: string;
     models: Array<SelectedModel>;
 };
+export type ConcurrencyObservation = {
+    in_flight: number;
+    observed_at: string;
+    source: "gateway_dispatch_records";
+    uncertain: number;
+};
+export type ConcurrencyPlan = {
+    admitted_ceiling: number;
+    profiles: Array<ProfileConcurrency>;
+    requested: "auto" | "max" | number;
+    scope: "run_inference";
+};
 export type ConnectedModel = {
     connection_id: string;
     kind: "connection";
@@ -127,6 +269,13 @@ export type CoverageRecord = {
     sample_count?: number | null;
     seed?: number | null;
 };
+export type CreateAgentBuild = {
+    quote_id: string;
+};
+export type CreatorsNamespacesParams = {
+    cursor?: string | null;
+    limit?: number;
+};
 export type EnvironmentFamily = {
     family: string;
     versions: Array<EnvironmentRecord>;
@@ -176,12 +325,17 @@ export type EnvironmentRights = {
     training: boolean;
     underlying_licenses?: Array<string>;
 };
+export type EnvironmentSelection = {
+    environment: string;
+    split?: "canonical" | "train" | "development" | "test";
+};
 export type EvalPricing = {
     execution_fee_microusd?: string | null;
     price_version: string;
     task_fee_microusd?: string | null;
 };
 export type EvalRecord = {
+    access?: "public" | "private" | "granted";
     availability?: string;
     availability_reason?: string;
     behaviors?: Array<string>;
@@ -236,6 +390,15 @@ export type ExecutionOptions = {
 export type FullCoverage = {
     mode: "full";
 };
+export type GitHubSourceSelection = {
+    github_connection_id: string;
+    github_repository_id: number;
+};
+export type GrantRequest = {
+    grantee_workspace_id: string;
+    permissions: Array<"discover" | "execute">;
+    reason: string;
+};
 export type Interval = {
     approximate: boolean;
     cluster_count?: number | null;
@@ -297,6 +460,18 @@ export type ManagedRoute = {
     revision: number;
     status: string;
 };
+export type MaterialState = {
+    created_at: string;
+    error_code: string | null;
+    findings: Array<string>;
+    name: string;
+    prepared_at: string | null;
+    receipt_sha256: string | null;
+    requested_sha256: string;
+    size_bytes: number;
+    source_kind: string;
+    status: "declared" | "prepared" | "failed";
+};
 export type MetricRecord = {
     direction: "higher_is_better" | "lower_is_better" | null;
     key: string;
@@ -308,6 +483,26 @@ export type MetricRecord = {
     uncertainty?: Uncertainty | null;
     value: number;
 };
+export type NamespacePage = {
+    data: Array<NamespaceResult>;
+    next_cursor?: string | null;
+};
+export type NamespaceResult = {
+    created_at: string;
+    id: string;
+    slug: string;
+    source_url: string;
+    status: "requested" | "verified" | "revoked";
+    verified_at: string | null;
+    workspace_id: string;
+};
+export type NewAgentQuote = {
+    agent: string;
+    selection: EnvironmentSelection;
+    coverage?: SampleCoverage | FullCoverage | null;
+    max_charge_microusd: string;
+    concurrency?: "auto" | "max" | number | null;
+};
 export type NewConnection = {
     api_key: string;
     base_url: string;
@@ -330,11 +525,20 @@ export type NewEvaluation = {
     provider?: string | null;
     split?: string | null;
 };
+export type NewManagedACPAgent = {
+    admission_id: string;
+    kind: "managed_acp";
+    ref: string;
+};
+export type NewPart = {
+    data: string;
+};
 export type NewQuote = {
     selection: Profiles | EvalReference;
     model: ManagedModel | ConnectedModel;
     coverage?: SampleCoverage | FullCoverage | null;
     max_charge_microusd: string;
+    concurrency?: "auto" | "max" | number | null;
 };
 export type NewRun = {
     metadata?: {
@@ -343,9 +547,57 @@ export type NewRun = {
     name?: string;
     quote_id: string;
 };
+export type NewUpload = {
+    archive_sha256: string;
+    name: string;
+    namespace_id: string;
+    size_bytes: number;
+    version: string;
+};
 export type OKResponse = {
     ok: boolean;
 };
+export type PackageProtocolResult = {
+    compiler_version: string;
+    component_sha256: string;
+    created_at: string;
+    id: string;
+    material_receipt_sha256: string | null;
+    package_id: string;
+    package_sha256: string;
+    profile_id: string | null;
+    protocol: {
+        [key: string]: JsonValue;
+    };
+    protocol_execution_class: "contributed_sandboxed" | "maintained_native";
+    protocol_sha256: string;
+    runnable?: false;
+};
+export type PackageResult = {
+    created_at: string;
+    expires_at: string;
+    id: string;
+    manifest: {
+        [key: string]: JsonValue;
+    };
+    material?: Array<MaterialState>;
+    name: string;
+    namespace_id: string;
+    package_sha256: string;
+    protocol_sha256?: string | null;
+    runnable?: false;
+    status: string;
+    upload_id: string;
+    validation: {
+        [key: string]: JsonValue;
+    };
+    version: string;
+    workspace_id: string;
+};
+export type Page_AgentBuildRecord_ = {
+    data: Array<AgentBuildRecord>;
+    next_cursor: string | null;
+};
 export type Page_BenchmarkRecord_ = {
     data: Array<BenchmarkRecord>;
     next_cursor: string | null;
@@ -366,10 +618,26 @@ export type Page_ManagedRoute_ = {
     data: Array<ManagedRoute>;
     next_cursor: string | null;
 };
+export type Page_ProtocolGrant_ = {
+    data: Array<ProtocolGrant>;
+    next_cursor: string | null;
+};
 export type Page_RunRecord_ = {
     data: Array<RunRecord>;
     next_cursor: string | null;
 };
+export type PartResult = {
+    part_index: number;
+    sha256: string | null;
+    size_bytes: number;
+    stored_at: string | null;
+};
+export type ProfileConcurrency = {
+    adapter_ceiling: number;
+    admitted_ceiling: number;
+    profile_id: string;
+    reasons: Array<"auto_heuristic" | "adapter_limit" | "gateway_limit" | "task_count" | "budget_limit">;
+};
 export type ProfileCost = {
     charged_microusd: string;
     model_index?: number | null;
@@ -416,9 +684,16 @@ export type ProfileSelection = {
     environment?: {
         [key: string]: JsonValue_Output;
     } | null;
+    generation_config?: {
+        [key: string]: JsonValue_Output;
+    } | null;
+    granted?: {
+        [key: string]: JsonValue_Output;
+    } | null;
     id: string;
     judge?: JudgeSelection | null;
     manifest_sha256: string;
+    max_output_tokens?: number;
     population_count: number;
     private_test?: boolean | null;
     remote?: {
@@ -427,12 +702,34 @@ export type ProfileSelection = {
     sampling_algorithm: string;
     sandbox?: SandboxPolicyView | null;
     selected_count: number;
+    selection_sha256?: string | null;
     task_ids?: Array<string> | null;
     task_ids_hash: string;
 };
 export type Profiles = {
     profile_ids: Array<string>;
 };
+export type ProtocolGrant = {
+    access: "granted";
+    effective_at: string;
+    expires_at: string | null;
+    grantee_workspace_id: string;
+    id: string;
+    manifest_sha256: string;
+    owner_workspace_id: string | null;
+    permissions: Array<string>;
+    projection: {
+        [key: string]: JsonValue;
+    };
+    projection_sha256: string;
+    protocol_id: string;
+    protocol_sha256: string;
+    qualification_expires_at: string;
+    qualification_policy_version: string;
+    reason: string;
+    revocation_reason: string | null;
+    revoked_at: string | null;
+};
 export type QuotePlan = {
     agent?: {
         [key: string]: JsonValue_Output;
@@ -440,6 +737,7 @@ export type QuotePlan = {
     agents?: Array<{
         [key: string]: JsonValue_Output;
     }> | null;
+    concurrency?: ConcurrencyPlan | null;
     coverage: CoverageRecord;
     model: SelectedModel | ComparisonModel;
     pricing: {
@@ -469,6 +767,7 @@ export type QuoteRecord = {
     price_version: string;
     retention: RetentionPolicy;
 };
+export type QuotesCreateBody = NewQuote | NewAgentQuote;
 export type ResultCosts = {
     as_of: string;
     basis: "managed_total" | "platform_fees_only" | "mixed";
@@ -511,6 +810,9 @@ export type RetentionPolicy = {
     starts_at: "run_created_at";
     summary_days: number;
 };
+export type RevokeRequest = {
+    reason: string;
+};
 export type RunEvent = {
     created_at: string;
     data: {
@@ -541,6 +843,8 @@ export type RunRecord = {
     cancel_requested_at: string | null;
     cap_microusd: string;
     completed_count: number;
+    concurrency?: ConcurrencyPlan | null;
+    concurrency_observation?: ConcurrencyObservation | null;
     coverage: CoverageRecord | null;
     created_at: string;
     error_count: number;
@@ -582,7 +886,7 @@ export type RunsExecutionsParams = {
     limit?: number;
 };
 export type RunsExportParams = {
-    format?: "json" | "csv" | "html";
+    format?: "json" | "csv" | "html" | "bundle";
     version?: number | null;
 };
 export type RunsListParams = {
@@ -678,3 +982,29 @@ export type UpdateConnection = {
     max_output_tokens?: number | null;
     name?: string | null;
 };
+export type UploadResult = {
+    archive_sha256: string;
+    created_at: string;
+    expires_at: string;
+    id: string;
+    name: string;
+    namespace_id: string;
+    parts: Array<PartResult>;
+    size_bytes: number;
+    status: string;
+    version: string;
+};
+export type ValidationResult = {
+    attempts: number;
+    completed_at: string | null;
+    created_at: string;
+    error_code: string | null;
+    expires_at: string;
+    id: string;
+    material?: Array<MaterialState>;
+    next_attempt_at: string;
+    package_id: string | null;
+    protocol_version: number;
+    status: "queued" | "running" | "succeeded" | "failed" | "cancelled";
+    upload_id: string;
+};

package/dist/types.js

@@ -1,2 +1,2 @@
-// Generated by scripts/generate_clients.py; OpenAPI SHA256 3cea8bc29adf3dd7ab60f48b418a77478e3e4502357e1e23de4a2f7e97088a3f.
+// Generated by scripts/generate_clients.py; OpenAPI SHA256 f24a374d13ff31cbb78a8465babd5fef949c86e7867431fa54d07b16d51245d5.
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kimpton-ai/evalrouter",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",