@to11ai/sdk 0.0.2 → 0.1.1

package/dist/routingRules/resource.cjs

@@ -0,0 +1,131 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/routingRules/resource.ts
+var exports_resource = {};
+__export(exports_resource, {
+  RoutingRulesResource: () => RoutingRulesResource,
+  RoutingRuleVersionResource: () => RoutingRuleVersionResource,
+  RoutingRuleReleaseResource: () => RoutingRuleReleaseResource
+});
+module.exports = __toCommonJS(exports_resource);
+function unwrap(envelope) {
+  if (envelope.data === null || envelope.data === undefined) {
+    throw new Error("API returned success but data is null");
+  }
+  return envelope.data;
+}
+function rulePath(projectId, ruleId) {
+  return `/v1/projects/${encodeURIComponent(projectId)}/routing/rules/${encodeURIComponent(ruleId)}`;
+}
+function versionsPath(projectId, ruleId) {
+  return `${rulePath(projectId, ruleId)}/versions`;
+}
+function versionPath(projectId, ruleId, versionId) {
+  return `${versionsPath(projectId, ruleId)}/${encodeURIComponent(versionId)}`;
+}
+function releasesPath(projectId, ruleId) {
+  return `${rulePath(projectId, ruleId)}/releases`;
+}
+function releasePath(projectId, ruleId, envSlug) {
+  return `${releasesPath(projectId, ruleId)}/${encodeURIComponent(envSlug)}`;
+}
+function releaseRollbackPath(projectId, ruleId, envSlug) {
+  return `${releasePath(projectId, ruleId, envSlug)}/rollback`;
+}
+
+class RoutingRuleVersionResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async create(input) {
+    const { projectId, ruleId, ...body } = input;
+    const envelope = await this.transport.request("POST", versionsPath(projectId, ruleId), { body });
+    return unwrap(envelope);
+  }
+  async list(input) {
+    const query = {};
+    if (input.cursor !== undefined)
+      query.cursor = input.cursor;
+    if (input.limit !== undefined)
+      query.limit = input.limit;
+    const envelope = await this.transport.request("GET", versionsPath(input.projectId, input.ruleId), { query });
+    return unwrap(envelope);
+  }
+  async get(input) {
+    const envelope = await this.transport.request("GET", versionPath(input.projectId, input.ruleId, input.versionId));
+    return unwrap(envelope);
+  }
+}
+
+class RoutingRuleReleaseResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async set(input) {
+    const { projectId, ruleId, envSlug, ...body } = input;
+    const envelope = await this.transport.request("PUT", releasePath(projectId, ruleId, envSlug), { body });
+    return unwrap(envelope);
+  }
+  async rollback(input) {
+    const { projectId, ruleId, envSlug, ...body } = input;
+    const envelope = await this.transport.request("POST", releaseRollbackPath(projectId, ruleId, envSlug), { body });
+    return unwrap(envelope);
+  }
+  async list(input) {
+    const query = {};
+    if (input.cursor !== undefined)
+      query.cursor = input.cursor;
+    if (input.limit !== undefined)
+      query.limit = input.limit;
+    const path = input.envSlug !== undefined ? releasePath(input.projectId, input.ruleId, input.envSlug) : releasesPath(input.projectId, input.ruleId);
+    const envelope = await this.transport.request("GET", path, { query });
+    return unwrap(envelope);
+  }
+}
+
+class RoutingRulesResource {
+  versions;
+  releases;
+  constructor(transport) {
+    this.versions = new RoutingRuleVersionResource(transport);
+    this.releases = new RoutingRuleReleaseResource(transport);
+  }
+}

package/dist/routingRules/resource.d.ts

@@ -0,0 +1,22 @@
+import type { Transport } from "../transport";
+import type { CreateRuleVersionInput, CreateRuleVersionResult, GetRuleVersionInput, GetRuleVersionResult, ListRuleReleasesInput, ListRuleReleasesResult, ListRuleVersionsInput, ListRuleVersionsResult, RollbackRuleReleaseInput, RollbackRuleReleaseResult, SetRuleReleaseInput, SetRuleReleaseResult } from "./types";
+export type { CreateRuleVersionInput, CreateRuleVersionResult, GetRuleVersionInput, GetRuleVersionResult, ListRuleReleasesInput, ListRuleReleasesResult, ListRuleVersionsInput, ListRuleVersionsResult, RollbackRuleReleaseInput, RollbackRuleReleaseResult, RuleModelBinding, RuleProviderRef, RuleRelease, RuleReleaseActorType, RuleReleaseApprovalStatus, RuleReleaseChangeKind, RuleReleaseStrategy, RuleReleaseWeight, RuleSnapshot, RuleStrategy, RuleVersion, SetRuleReleaseInput, SetRuleReleaseResult, } from "./types";
+export declare class RoutingRuleVersionResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    create(input: CreateRuleVersionInput): Promise<CreateRuleVersionResult>;
+    list(input: ListRuleVersionsInput): Promise<ListRuleVersionsResult>;
+    get(input: GetRuleVersionInput): Promise<GetRuleVersionResult>;
+}
+export declare class RoutingRuleReleaseResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    set(input: SetRuleReleaseInput): Promise<SetRuleReleaseResult>;
+    rollback(input: RollbackRuleReleaseInput): Promise<RollbackRuleReleaseResult>;
+    list(input: ListRuleReleasesInput): Promise<ListRuleReleasesResult>;
+}
+export declare class RoutingRulesResource {
+    readonly versions: RoutingRuleVersionResource;
+    readonly releases: RoutingRuleReleaseResource;
+    constructor(transport: Transport);
+}

package/dist/routingRules/resource.js

@@ -0,0 +1,91 @@
+// src/routingRules/resource.ts
+function unwrap(envelope) {
+  if (envelope.data === null || envelope.data === undefined) {
+    throw new Error("API returned success but data is null");
+  }
+  return envelope.data;
+}
+function rulePath(projectId, ruleId) {
+  return `/v1/projects/${encodeURIComponent(projectId)}/routing/rules/${encodeURIComponent(ruleId)}`;
+}
+function versionsPath(projectId, ruleId) {
+  return `${rulePath(projectId, ruleId)}/versions`;
+}
+function versionPath(projectId, ruleId, versionId) {
+  return `${versionsPath(projectId, ruleId)}/${encodeURIComponent(versionId)}`;
+}
+function releasesPath(projectId, ruleId) {
+  return `${rulePath(projectId, ruleId)}/releases`;
+}
+function releasePath(projectId, ruleId, envSlug) {
+  return `${releasesPath(projectId, ruleId)}/${encodeURIComponent(envSlug)}`;
+}
+function releaseRollbackPath(projectId, ruleId, envSlug) {
+  return `${releasePath(projectId, ruleId, envSlug)}/rollback`;
+}
+
+class RoutingRuleVersionResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async create(input) {
+    const { projectId, ruleId, ...body } = input;
+    const envelope = await this.transport.request("POST", versionsPath(projectId, ruleId), { body });
+    return unwrap(envelope);
+  }
+  async list(input) {
+    const query = {};
+    if (input.cursor !== undefined)
+      query.cursor = input.cursor;
+    if (input.limit !== undefined)
+      query.limit = input.limit;
+    const envelope = await this.transport.request("GET", versionsPath(input.projectId, input.ruleId), { query });
+    return unwrap(envelope);
+  }
+  async get(input) {
+    const envelope = await this.transport.request("GET", versionPath(input.projectId, input.ruleId, input.versionId));
+    return unwrap(envelope);
+  }
+}
+
+class RoutingRuleReleaseResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async set(input) {
+    const { projectId, ruleId, envSlug, ...body } = input;
+    const envelope = await this.transport.request("PUT", releasePath(projectId, ruleId, envSlug), { body });
+    return unwrap(envelope);
+  }
+  async rollback(input) {
+    const { projectId, ruleId, envSlug, ...body } = input;
+    const envelope = await this.transport.request("POST", releaseRollbackPath(projectId, ruleId, envSlug), { body });
+    return unwrap(envelope);
+  }
+  async list(input) {
+    const query = {};
+    if (input.cursor !== undefined)
+      query.cursor = input.cursor;
+    if (input.limit !== undefined)
+      query.limit = input.limit;
+    const path = input.envSlug !== undefined ? releasePath(input.projectId, input.ruleId, input.envSlug) : releasesPath(input.projectId, input.ruleId);
+    const envelope = await this.transport.request("GET", path, { query });
+    return unwrap(envelope);
+  }
+}
+
+class RoutingRulesResource {
+  versions;
+  releases;
+  constructor(transport) {
+    this.versions = new RoutingRuleVersionResource(transport);
+    this.releases = new RoutingRuleReleaseResource(transport);
+  }
+}
+export {
+  RoutingRulesResource,
+  RoutingRuleVersionResource,
+  RoutingRuleReleaseResource
+};

package/dist/routingRules/types.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Reference to a provider config bound to a specific environment. Mirrors
+ * `RuleProviderRef` in the API domain model. `envSlug` is optional — when
+ * omitted, the gateway falls back to the project's `is_gateway_fallback`
+ * environment.
+ */
+export interface RuleProviderRef {
+    providerId: string;
+    envSlug?: string;
+}
+/**
+ * Per-variant model binding inside a rule snapshot. Identifies which
+ * `(provider, model)` pair serves a strategy variant; the gateway resolves
+ * the actual credential at request time. `weight` is intentionally
+ * permissive (0..100 in v1) so weighted/experimental strategies can evolve
+ * without a SDK churn.
+ */
+export interface RuleModelBinding {
+    modelId: string;
+    provider: RuleProviderRef;
+    weight?: number;
+}
+export type RuleStrategy = "single" | "weighted" | "fallback" | "experiment";
+/**
+ * Frozen rule snapshot — the JSONB payload stored in
+ * `rule_versions.snapshot_json`. Mirrors the API domain `RuleSnapshot`:
+ *
+ *   * `alias`        — optional `function::<alias>` indirection (S1).
+ *   * `strategy`     — `single`, `weighted`, `fallback`, `experiment`.
+ *   * `endpoint`     — `chat`, `embeddings`, …
+ *   * `variants[]` | `steps[]` | `chain[]` — strategy-shape arrays.
+ *   * `when`         — optional condition AST that gates the rule.
+ *   * `retry`        — optional `{ maxRetries?, backoffBaseMs?, retryableStatusCodes? }`.
+ *   * `modelBindings[]` — which `(providerId, modelId, envSlug)` serves each variant.
+ *   * `providerRefs[]` — flat denormalized list of referenced providers.
+ *
+ * No credential field exists; the gateway resolves credentials lazily from
+ * the per-env `routing_snapshots` ciphertext.
+ */
+export interface RuleSnapshot {
+    alias?: string;
+    strategy: RuleStrategy | string;
+    endpoint: string;
+    variants?: unknown[];
+    steps?: unknown[];
+    chain?: unknown[];
+    when?: unknown;
+    retry?: {
+        maxRetries?: number;
+        backoffBaseMs?: number;
+        retryableStatusCodes?: number[];
+    };
+    modelBindings?: RuleModelBinding[];
+    providerRefs?: RuleProviderRef[];
+}
+/**
+ * The persisted form of a rule version row as returned by
+ * `GET /v1/projects/:projectId/routing/rules/:ruleId/versions/:versionId`.
+ *
+ * `version` is monotonic per `ruleId` — the server allocates it inside a
+ * `SELECT MAX … FOR UPDATE` transaction. `snapshotJson` is typed as
+ * `unknown` to mirror the API contract (the storage path persists JSONB
+ * verbatim); callers that need the typed shape should cast through
+ * `RuleSnapshot`.
+ */
+export interface RuleVersion {
+    id: string;
+    ruleId: string;
+    version: number;
+    snapshotJson: unknown;
+    description: string | null;
+    createdBy: string;
+    /** ISO-8601 timestamp. */
+    createdAt: string;
+}
+/**
+ * Wire input accepted by
+ * `POST /v1/projects/:p/routing/rules/:ruleId/versions`. Requires the
+ * `routing:write` capability.
+ *
+ * `snapshot` is the cleartext snapshot JSON the gateway uses to resolve
+ * runtime traffic — stored verbatim in `rule_versions.snapshot_json`.
+ * `description` is an optional commit message; the API surfaces it on the
+ * audit timeline.
+ */
+export interface CreateRuleVersionInput {
+    projectId: string;
+    ruleId: string;
+    snapshot: RuleSnapshot | unknown;
+    description?: string;
+}
+export type CreateRuleVersionResult = RuleVersion;
+/**
+ * Cursor-paginated list input. `cursor` is the `version` number BELOW which
+ * to fetch (keyset pagination — pass the last item's `version` to continue).
+ * `limit` is clamped server-side to `MAX_LIST_LIMIT` (200 at the time of
+ * writing); default is 50.
+ */
+export interface ListRuleVersionsInput {
+    projectId: string;
+    ruleId: string;
+    /**
+     * The `version` number BELOW which to fetch (the route uses a keyset
+     * `WHERE version < cursor` clause and returns versions in `version DESC`
+     * order). Omit for the first page.
+     */
+    cursor?: number;
+    /** Page size. Server clamps to `[1, MAX_LIST_LIMIT]`. */
+    limit?: number;
+}
+export type ListRuleVersionsResult = RuleVersion[];
+export interface GetRuleVersionInput {
+    projectId: string;
+    ruleId: string;
+    versionId: string;
+}
+export type GetRuleVersionResult = RuleVersion;
+export type RuleReleaseStrategy = "single" | "weighted";
+export type RuleReleaseChangeKind = "release_initial" | "release_promoted" | "release_rolled_back" | "release_weight_changed";
+export type RuleReleaseApprovalStatus = "committed" | "pending" | "rejected";
+export type RuleReleaseActorType = "user" | "api_key" | "worker";
+export interface RuleReleaseWeight {
+    versionId: string;
+    weight: number;
+}
+export interface RuleRelease {
+    id: string;
+    ruleId: string;
+    environmentId: string;
+    envSlug: string;
+    strategy: RuleReleaseStrategy;
+    versionId: string | null;
+    weights: RuleReleaseWeight[] | null;
+    changeKind: RuleReleaseChangeKind;
+    priorReleaseId: string | null;
+    actorId: string;
+    actorType: RuleReleaseActorType;
+    reason: string | null;
+    approvalStatus: RuleReleaseApprovalStatus;
+    activeFrom: string | null;
+    activeTo: string | null;
+    createdAt: string;
+}
+export interface SetRuleReleaseInput {
+    projectId: string;
+    ruleId: string;
+    envSlug: string;
+    strategy: RuleReleaseStrategy;
+    versionId?: string;
+    weights?: RuleReleaseWeight[];
+    reason?: string;
+}
+export type SetRuleReleaseResult = RuleRelease;
+export interface RollbackRuleReleaseInput {
+    projectId: string;
+    ruleId: string;
+    envSlug: string;
+    reason: string;
+    targetReleaseId?: string;
+}
+export type RollbackRuleReleaseResult = RuleRelease;
+export interface ListRuleReleasesInput {
+    projectId: string;
+    ruleId: string;
+    envSlug?: string;
+    cursor?: string;
+    limit?: number;
+}
+export type ListRuleReleasesResult = RuleRelease[];

package/dist/traceparent.d.ts

@@ -0,0 +1,61 @@
+/**
+ * W3C Trace Context propagation for outbound SDK calls.
+ *
+ * Reads the host process's active OpenTelemetry span — if any — and formats a
+ * W3C `traceparent` (and optional `tracestate`) string for injection as
+ * outbound HTTP headers. Lets customers correlate their tracer's spans with
+ * the gateway-emitted span we record.
+ *
+ * Design constraints (from TO11-1016 / S8c spec):
+ *   1. NO runtime dependency on `@opentelemetry/api`. The package is detected
+ *      at runtime via a try/require shim; if it is not loadable, this module
+ *      is a strict no-op and `activeTraceContext()` returns `null`.
+ *   2. NO SDK config surface change. There is no constructor option or env
+ *      var; behavior is invisible if the host has no OTel installed.
+ *   3. Header omitted, not zero-filled — W3C §3.2.2.5 forbids all-zero
+ *      trace/span ids in `traceparent`. We return `null` (caller omits).
+ *
+ * @see https://www.w3.org/TR/trace-context/ for the wire format.
+ * @see docs/product-specs/2026-05-20-to11-1016-sdk-traceparent-propagation.md
+ */
+interface OtelTraceState {
+    serialize(): string;
+}
+interface OtelSpanContext {
+    traceId: string;
+    spanId: string;
+    traceFlags: number;
+    traceState?: OtelTraceState;
+}
+interface OtelSpan {
+    spanContext(): OtelSpanContext;
+}
+interface OtelTrace {
+    getActiveSpan(): OtelSpan | undefined;
+}
+interface OtelApi {
+    trace: OtelTrace;
+}
+type OtelLoader = () => OtelApi | null;
+/**
+ * Return the W3C `traceparent` (and optional `tracestate`) string pair for
+ * the currently active OpenTelemetry span in the host process, or `null` if
+ * no active span exists or `@opentelemetry/api` is not installed.
+ *
+ * Idempotent and side-effect-free past the one-time module probe. Callers
+ * inject the returned strings as outbound HTTP headers when non-null.
+ */
+export declare function activeTraceContext(): {
+    traceparent: string;
+    tracestate?: string;
+} | null;
+/**
+ * Test-only seam: install a deterministic OTel loader and reset the
+ * module-level cache. Underscore-prefixed and intentionally NOT re-exported
+ * from the package entry-point.
+ *
+ * Production code never calls this. Tests call it to simulate
+ * "OTel installed" / "OTel absent" / "broken OTel install" cells.
+ */
+export declare function _loadOtelForTests(injected: OtelLoader | undefined): void;
+export {};

package/dist/transport.d.ts

@@ -10,7 +10,12 @@ export interface TransportConfig {
     readonly auth: AuthConfig;
     /** Request timeout in milliseconds. Default: 30_000 */
     readonly timeoutMs?: number;
-    /** Max number of retries for network errors / 5xx (not counting the initial attempt). Default: 3 */
+    /**
+     * Max number of retries for network errors / 5xx on idempotent methods
+     * (GET/HEAD/OPTIONS/PUT/DELETE/TRACE per RFC 9110 §9.2.2). POST/PATCH are
+     * never auto-retried regardless of this value. Not counting the initial
+     * attempt. Default: 3
+     */
     readonly maxRetries?: number;
 }
 /** Standard API envelope returned by the to11ai server. */

package/package.json

@@ -1,6 +1,7 @@
 {
 	"name": "@to11ai/sdk",
-	"version": "0.0.2",
+	"version": "0.1.1",
+	"license": "MPL-2.0",
 	"type": "module",
 	"main": "./dist/client.cjs",
 	"module": "./dist/client.js",
@@ -10,6 +11,7 @@
 		"src",
 		"!src/**/*.test.ts",
 		"!src/**/*.fixture.ts",
+		"LICENSE",
 		"README.md"
 	],
 	"exports": {
@@ -29,6 +31,22 @@
 			"require": "./dist/prompts/resource.cjs",
 			"default": "./dist/prompts/resource.js"
 		},
+		"./projectEnvironments": {
+			"types": "./src/projectEnvironments/resource.ts",
+			"bun": "./src/projectEnvironments/resource.ts",
+			"deno": "./src/projectEnvironments/resource.ts",
+			"import": "./dist/projectEnvironments/resource.js",
+			"require": "./dist/projectEnvironments/resource.cjs",
+			"default": "./dist/projectEnvironments/resource.js"
+		},
+		"./routingRules": {
+			"types": "./src/routingRules/resource.ts",
+			"bun": "./src/routingRules/resource.ts",
+			"deno": "./src/routingRules/resource.ts",
+			"import": "./dist/routingRules/resource.js",
+			"require": "./dist/routingRules/resource.cjs",
+			"default": "./dist/routingRules/resource.js"
+		},
 		"./errors": {
 			"types": "./src/errors.ts",
 			"bun": "./src/errors.ts",
@@ -47,16 +65,17 @@
 		}
 	},
 	"publishConfig": {
-		"access": "restricted"
+		"access": "public"
 	},
 	"scripts": {
 		"build": "bun run build:clean && bun run build:esm && bun run build:cjs && bun run build:types",
 		"build:clean": "rm -rf dist",
-		"build:esm": "bun build src/client.ts src/prompts/resource.ts src/errors.ts src/gateway.ts --outdir dist --target node --format esm --external '*'",
-		"build:cjs": "bun build src/client.ts src/prompts/resource.ts src/errors.ts src/gateway.ts --outdir dist --target node --format cjs --external '*' --entry-naming '[dir]/[name].cjs'",
+		"build:esm": "bun build src/client.ts src/prompts/resource.ts src/projectEnvironments/resource.ts src/routingRules/resource.ts src/errors.ts src/gateway.ts --outdir dist --target node --format esm --external '*'",
+		"build:cjs": "bun build src/client.ts src/prompts/resource.ts src/projectEnvironments/resource.ts src/routingRules/resource.ts src/errors.ts src/gateway.ts --outdir dist --target node --format cjs --external '*' --entry-naming '[dir]/[name].cjs'",
 		"build:types": "tsc -p tsconfig.build.json",
 		"prepack": "bun run build",
 		"test": "bun test",
+		"test:coverage": "bun test --coverage --coverage-reporter=text --coverage-reporter=lcov",
 		"typecheck": "bun x tsc --noEmit",
 		"lint": "biome check .",
 		"lint:check": "biome check --error-on-warnings .",
@@ -64,7 +83,8 @@
 		"format": "biome format --write ."
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.4.15",
+		"@biomejs/biome": "2.4.15",
+		"@opentelemetry/api": "^1.9.0",
 		"@types/bun": "^1.3.13",
 		"typescript": "^5.9.3"
 	}

package/src/client.ts

@@ -1,9 +1,17 @@
+import { ProjectEnvironmentResource } from "./projectEnvironments/resource";
 import type { CacheConfig } from "./prompts/cache";
 import { PromptResource } from "./prompts/resource";
+import { RoutingRulesResource } from "./routingRules/resource";
 import { Transport } from "./transport";
 
 // Re-export all error types for convenience
+export type { NoApplicableRouteReason } from "./errors";
 export {
+	EnvNotEnabledForProviderError,
+	NoApplicableRouteError,
+	PromptLabelNotRegisteredError,
+	RuleNotFoundError,
+	RuleVersionInvalidSnapshotError,
 	To11aiApiError,
 	To11aiAuthError,
 	To11aiError,
@@ -13,8 +21,55 @@ export {
 } from "./errors";
 export type { GatewayAuthOptions } from "./gateway";
 export { gatewayAuthHeaders, gatewayPromptHeaders } from "./gateway";
+export type {
+	ArchiveProjectEnvironmentInput,
+	ArchiveProjectEnvironmentResult,
+	CreateProjectEnvironmentInput,
+	CreateProjectEnvironmentResult,
+	GetProjectEnvironmentInput,
+	GetProjectEnvironmentResult,
+	ListProjectEnvironmentsInput,
+	ListProjectEnvironmentsResult,
+	LivePointerCounts,
+	ProjectEnvironment,
+	RestoreProjectEnvironmentInput,
+	RestoreProjectEnvironmentResult,
+	UpdateProjectEnvironmentInput,
+	UpdateProjectEnvironmentResult,
+} from "./projectEnvironments/resource";
+export { ProjectEnvironmentResource } from "./projectEnvironments/resource";
 export type { CacheConfig } from "./prompts/cache";
 export { PromptResource } from "./prompts/resource";
+export type {
+	CreateRuleVersionInput,
+	CreateRuleVersionResult,
+	GetRuleVersionInput,
+	GetRuleVersionResult,
+	ListRuleReleasesInput,
+	ListRuleReleasesResult,
+	ListRuleVersionsInput,
+	ListRuleVersionsResult,
+	RollbackRuleReleaseInput,
+	RollbackRuleReleaseResult,
+	RuleModelBinding,
+	RuleProviderRef,
+	RuleRelease,
+	RuleReleaseActorType,
+	RuleReleaseApprovalStatus,
+	RuleReleaseChangeKind,
+	RuleReleaseStrategy,
+	RuleReleaseWeight,
+	RuleSnapshot,
+	RuleStrategy,
+	RuleVersion,
+	SetRuleReleaseInput,
+	SetRuleReleaseResult,
+} from "./routingRules/resource";
+export {
+	RoutingRuleReleaseResource,
+	RoutingRulesResource,
+	RoutingRuleVersionResource,
+} from "./routingRules/resource";
 export type { Transport } from "./transport";
 
 // ─── Auth option shapes ────────────────────────────────────────────────────
@@ -49,6 +104,8 @@ export type ClientOptions = AuthOptions & {
 
 export interface To11aiClient {
 	readonly prompts: PromptResource;
+	readonly projectEnvironments: ProjectEnvironmentResource;
+	readonly routingRules: RoutingRulesResource;
 }
 
 // ─── Factory ───────────────────────────────────────────────────────────────
@@ -115,6 +172,8 @@ export function createClient(options: ClientOptions): To11aiClient {
 	});
 
 	const prompts = new PromptResource(transport, options.cache);
+	const projectEnvironments = new ProjectEnvironmentResource(transport);
+	const routingRules = new RoutingRulesResource(transport);
 
-	return { prompts };
+	return { prompts, projectEnvironments, routingRules };
 }