@to11ai/sdk 2.0.0-rc.3 → 2.0.0-rc.4

package/src/prompts/resource.ts

@@ -1,9 +1,10 @@
-import { z } from "zod";
-import { EnvNotFoundError, To11aiNetworkError } from "../errors";
+import {
+	MissingLabelError,
+	To11aiApiError,
+	To11aiNetworkError,
+} from "../errors";
 import { zResolvedPrompt } from "../generated/zod.gen";
 import type { ApiEnvelope, Transport } from "../transport";
-import type { CacheConfig } from "./cache";
-import { buildRenderCacheKey, PromptCache } from "./cache";
 import type {
 	AnthropicRenderedPrompt,
 	OpenAiRenderedPrompt,
@@ -56,13 +57,12 @@ import type {
 } from "./types";
 import { ENV_SLUG_REGEX } from "./types";
 
-// Re-export CacheConfig so callers can import from this module
-export type { CacheConfig } from "./cache";
 export type {
 	ArchivePromptInput,
 	ArchivePromptResult,
 	BlockRenderRecord,
 	ChatMessage,
+	ChatRole,
 	CreateProjectPromptLabelInput,
 	CreateProjectPromptLabelResult,
 	CreatePromptInput,
@@ -111,8 +111,6 @@ export type {
 	ResolvedToolCall,
 	ResolvedToolDefinition,
 	RowError,
-	TextChatMessage,
-	TextChatRole,
 	UnknownRoleMode,
 	UpdateProjectPromptLabelInput,
 	UpdateProjectPromptLabelResult,
@@ -120,9 +118,7 @@ export type {
 	UpdatePromptResult,
 } from "./types";
 
-const zResolvedPromptEnvelope = zResolvedPrompt
-	.partial({ releaseId: true })
-	.extend({ strategy: z.enum(["single", "weighted"]).optional() });
+const zResolvedPromptEnvelope = zResolvedPrompt.partial({ releaseId: true });
 
 function unwrap<T>(envelope: ApiEnvelope<T>): T {
 	if (envelope.data === null || envelope.data === undefined) {
@@ -293,7 +289,6 @@ export interface PromptResourceConfig {
 
 export class PromptResource<F extends RenderFormat | undefined = undefined> {
 	private readonly transport: Transport;
-	private readonly cache: PromptCache;
 	private readonly projectId: string | undefined;
 	private readonly env: string | undefined;
 	private readonly format: RenderFormat | undefined;
@@ -301,14 +296,12 @@ export class PromptResource<F extends RenderFormat | undefined = undefined> {
 
 	constructor(
 		transport: Transport,
-		cacheConfig?: CacheConfig,
 		// `format` is bound to the class generic `F` (not the wider `RenderFormat`)
 		// so the constructed default shape cannot disagree with what `render()`'s
 		// return type (`RenderResult<F>`) promises.
 		config?: Omit<PromptResourceConfig, "format"> & { format?: F },
 	) {
 		this.transport = transport;
-		this.cache = new PromptCache(cacheConfig);
 		this.projectId = config?.projectId;
 		this.env = config?.env;
 		this.format = config?.format;
@@ -527,17 +520,14 @@ export class PromptResource<F extends RenderFormat | undefined = undefined> {
 
 	/**
 	 * Env-aware resolution → neutral `RenderedPrompt`. Carries the resolve /
-	 * cache / offline-fallback logic; `render()` is the public shaping surface.
+	 * offline-fallback logic; `render()` is the public shaping surface.
 	 *
-	 * - **env→label wire mapping:** the resolve route is label-based
+	 * - **label wire mapping:** the resolve route is label-based
 	 *   (`/v1/projects/:projectId/prompts:resolve`, body `labels[]`); the
-	 *   resolved env slug is sent as the single resolution label.
-	 * - **No silent fallback (R4):** if no env is resolvable (none at init AND
-	 *   none per call) this throws `EnvNotFoundError` CLIENT-side, eagerly,
-	 *   before any transport call.
-	 * - **Cache (D8):** caches `single`-strategy releases and weighted releases
-	 *   WITH a `subject`; BYPASSES the cache for weighted releases with NO
-	 *   `subject` (a uniform-random assignment must not be pinned for the TTL).
+	 *   resolved label is sent as the single resolution label.
+	 * - **No silent fallback (R4):** if no label is resolvable (none per call
+	 *   AND no client `env` fallback) this throws `MissingLabelError`
+	 *   CLIENT-side, eagerly, before any transport call.
 	 */
 	private async resolveToRendered(
 		slug: string,
@@ -549,41 +539,28 @@ export class PromptResource<F extends RenderFormat | undefined = undefined> {
 			);
 		}
 
-		// R2 precedence: per-call env > init-time env. No third source.
-		const env = options.env ?? this.env;
+		// R2 precedence: per-call label > client `env` fallback. No third source.
+		const label = options.label ?? this.env;
 
-		// R4 / AC4: no env resolvable → throw eagerly, ZERO transport calls.
-		if (env === undefined) {
-			throw EnvNotFoundError.missing();
+		// R4 / AC4: no label resolvable → throw eagerly, ZERO transport calls.
+		if (label === undefined) {
+			throw new MissingLabelError();
 		}
 
-		// Validate the RESOLVED env (per-call OR init). createClient validates the
-		// init-time env, but PromptResource has a public constructor that can
-		// bypass createClient, so re-validate here so a malformed env (e.g.
-		// "Prod") never reaches the wire as a resolution label (CodeRabbit).
-		if (!ENV_SLUG_REGEX.test(env)) {
+		// Validate the RESOLVED label (per-call OR the client `env` fallback).
+		// createClient validates the init-time env, but PromptResource has a
+		// public constructor that can bypass createClient, so re-validate here so
+		// a malformed label (e.g. "Prod") never reaches the wire (CodeRabbit).
+		if (!ENV_SLUG_REGEX.test(label)) {
 			throw new Error(
-				`[to11ai/sdk] \`env\` must match ${ENV_SLUG_REGEX} (lowercase-kebab, 1-63 chars). Received: ${JSON.stringify(env)}`,
+				`[to11ai/sdk] \`label\` must match ${ENV_SLUG_REGEX} (lowercase-kebab, 1-63 chars). Received: ${JSON.stringify(label)}`,
 			);
 		}
 
-		const { subject, variables, cache: useCache = true, fallback } = options;
+		const { subject, variables, fallback } = options;
 
-		const cacheKey = buildRenderCacheKey(
-			this.projectId,
-			slug,
-			env,
-			subject,
-			variables,
-		);
-
-		if (useCache) {
-			const cached = this.cache.get(cacheKey);
-			if (cached) return structuredClone(cached);
-		}
-
-		// env→label mapping: the env slug is the single resolution label.
-		const body: Record<string, unknown> = { slug, labels: [env] };
+		// The resolved label is sent as the single resolution label.
+		const body: Record<string, unknown> = { slug, labels: [label] };
 		if (subject !== undefined) body.subject = subject;
 		if (variables !== undefined) body.variables = variables;
 
@@ -598,31 +575,16 @@ export class PromptResource<F extends RenderFormat | undefined = undefined> {
 				},
 			);
 			const raw = unwrap(envelope);
-			const result = normalizeResolvedEnvelope(raw, slug);
-
-			// D8: bypass the cache for a weighted release with NO subject —
-			// caching a uniform-random assignment would pin one variant for the
-			// whole TTL. Cache `single` releases and `subject`-keyed weighted
-			// releases (deterministic, safe to cache). Weighted-ness is inferred
-			// from `strategy === "weighted"` OR the presence of `variantName`
-			// (which the server stamps iff weighted) — so a result that carries a
-			// variant but omits `strategy` is still correctly bypassed rather than
-			// pinning one random variant for the TTL (Cursor / Greptile).
-			const isWeighted =
-				raw.strategy === "weighted" || result.variantName !== undefined;
-			const cacheable = !(isWeighted && subject === undefined);
-			if (useCache && cacheable) {
-				this.cache.set(cacheKey, structuredClone(result));
-			}
-
-			return result;
+			return normalizeResolvedEnvelope(raw, slug);
 		} catch (err) {
-			// D7: offline fallback is consulted ONLY on a network outage with an
-			// empty cache. A server `ENV_NOT_FOUND` is a typed application error
-			// (not a To11aiNetworkError), so it bypasses this branch. R4's
-			// client-eager throw already happened above the try, so there is no
-			// network error to trigger it on the env-missing path.
-			if (err instanceof To11aiNetworkError && fallback !== undefined) {
+			// Serve the offline fallback on a TRANSIENT outage — a network error
+			// or a 5xx from the control plane. A typed 4xx (not-found / policy /
+			// validation) is a real application error and is NOT masked. The
+			// client-eager MissingLabelError already threw above the try.
+			const transient =
+				err instanceof To11aiNetworkError ||
+				(err instanceof To11aiApiError && err.statusCode >= 500);
+			if (transient && fallback !== undefined) {
 				return liftFallbackToRendered(fallback, slug);
 			}
 			throw err;

package/src/prompts/shape.ts

@@ -135,7 +135,7 @@ export function shapeAnthropic(
 	return result;
 }
 
-/** Shape a fetched prompt for `format`, or return it neutral when unset. */
+/** Shape a rendered prompt for `format`, or return it neutral when unset. */
 export function shapePrompt(
 	prompt: RenderedPrompt,
 	format: RenderFormat | undefined,

package/src/prompts/types.ts

@@ -23,16 +23,14 @@ export type PromptVersion = GenPromptVersion;
 export type PromptFormat = PromptVersion["format"];
 export type PromptLabelPointer = GenPromptLabelPointer;
 
-export type TextChatRole = "system" | "user" | "assistant" | "developer";
+export type ChatRole = "system" | "user" | "assistant" | "developer";
 
-export interface TextChatMessage {
-	role: TextChatRole;
+export interface ChatMessage {
+	role: ChatRole;
 	content: string;
 	disabled?: boolean;
 }
 
-export type ChatMessage = TextChatMessage;
-
 export type RenderedChatMessage = GenRenderedChatPrompt["messages"][number];
 
 /** Provider shape for `prompts.render()` output. Omit for the neutral result. */
@@ -174,6 +172,13 @@ export interface ListPromptLabelsInput {
 
 export type ListPromptLabelsResult = PromptLabelPointer[];
 
+/**
+ * Slug rule for a `render()` label — lowercase-kebab, 1-63 chars. Env slugs are
+ * a special case of a label value, so labels are held to the same strict rule
+ * (no uppercase, no underscores): a label is a routing key, and case-insensitive
+ * routing keys invite silent "production" vs "Production" mismatches. Intentionally
+ * strict — do not loosen.
+ */
 export const ENV_SLUG_REGEX = /^[a-z0-9-]{1,63}$/;
 
 export type BlockRenderRecord = Record<string, "rendered" | "dimmed">;
@@ -223,20 +228,18 @@ export interface RenderedPrompt {
 	toolChoice?: NonNullable<ResolvedPrompt["toolChoice"]>;
 }
 
-export type ResolvedPromptEnvelope = GenResolvedPrompt & {
-	/** Active release strategy. Used to decide weighted-no-subject cache bypass (D8). */
-	strategy?: "single" | "weighted";
-};
+export type ResolvedPromptEnvelope = GenResolvedPrompt;
 
 export interface RenderOptions {
-	/** Serving environment for this call; overrides the client default. */
-	env?: string;
+	/**
+	 * Label to resolve this call's prompt version; overrides the client default.
+	 * When omitted, falls back to the client's `env` (env is a label value).
+	 */
+	label?: string;
 	/** Stable id so a weighted release sends the same caller to the same variant. */
 	subject?: string;
 	variables?: Record<string, unknown>;
-	/** Set false to bypass the LRU cache for this call. Default: true */
-	cache?: boolean;
-	/** Prompt served if the API is unreachable on a network error and cache is empty. */
+	/** Prompt served if the API is unreachable on a network error. */
 	fallback?: RenderedPrompt;
 	/** Provider shape for this call's output; overrides the client default. */
 	format?: RenderFormat;

package/src/transport.ts

@@ -1,8 +1,7 @@
 import type { BehaviorStore } from "./behaviors/store";
 import {
-	AmbiguousEnvLabelsError,
 	EnvNotEnabledForProviderError,
-	EnvNotFoundError,
+	LabelNotFoundError,
 	NoActiveReleaseError,
 	NoApplicableRouteError,
 	PromptLabelNotRegisteredError,
@@ -108,14 +107,11 @@ function mapPromptResolveError(
 		);
 	}
 	if (detailsCode === "ENV_NOT_FOUND") {
-		// Server-side unknown-env. (The client-eager "missing" variant is
-		// raised in resource.ts before any request — never here.)
-		return new EnvNotFoundError(
-			message,
-			{ env, source: "unknown" },
-			details,
-			status,
-		);
+		// Server-side unknown-label. (The client-side MissingLabelError — no
+		// label supplied at all — is raised in resource.ts before any request.)
+		// Prefer `details.label`, falling back to `details.env`.
+		const label = typeof d.label === "string" ? d.label : env;
+		return new LabelNotFoundError(message, label, details, status);
 	}
 	if (detailsCode === "NO_ACTIVE_RELEASE") {
 		return new NoActiveReleaseError(
@@ -125,9 +121,6 @@ function mapPromptResolveError(
 			status,
 		);
 	}
-	if (detailsCode === "AMBIGUOUS_ENV_LABELS") {
-		return new AmbiguousEnvLabelsError(message, { env, slug }, details, status);
-	}
 	if (PROMPT_POLICY_VIOLATION_DETAILS_CODES.has(detailsCode)) {
 		const policy = typeof d.policy === "string" ? d.policy : undefined;
 		return new PromptPolicyViolationError(
@@ -140,9 +133,9 @@ function mapPromptResolveError(
 	return undefined;
 }
 
-export type AuthConfig =
-	| { readonly apiKey: string; readonly getAccessToken?: never }
-	| { readonly getAccessToken: () => Promise<string>; readonly apiKey?: never };
+export interface AuthConfig {
+	readonly apiKey: string;
+}
 
 export interface TransportConfig {
 	readonly baseUrl: string;
@@ -248,12 +241,25 @@ function mapHttpError(
 	}
 	if (status === 429) {
 		const retryAfterHeader = headers?.get("retry-after");
-		const retryAfterSeconds = retryAfterHeader
-			? Number(retryAfterHeader)
-			: undefined;
+		let retryAfterSeconds: number | undefined;
+		if (retryAfterHeader) {
+			const numeric = Number(retryAfterHeader);
+			if (Number.isFinite(numeric)) {
+				retryAfterSeconds = Math.max(0, numeric);
+			} else {
+				// RFC 9110 HTTP-date form → seconds until that instant.
+				const when = Date.parse(retryAfterHeader);
+				if (!Number.isNaN(when)) {
+					retryAfterSeconds = Math.max(
+						0,
+						Math.round((when - Date.now()) / 1000),
+					);
+				}
+			}
+		}
 		return new To11aiRateLimitError(
 			message,
-			Number.isFinite(retryAfterSeconds) ? retryAfterSeconds : undefined,
+			retryAfterSeconds,
 			errorCode,
 			details,
 		);
@@ -395,25 +401,20 @@ export class Transport {
 	private readonly behaviorStore: BehaviorStore | undefined;
 
 	constructor(config: TransportConfig) {
-		this.baseUrl = config.baseUrl.replace(/\/$/, "");
+		this.baseUrl = config.baseUrl.replace(/\/+$/, "");
 		this.auth = config.auth;
 		this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
 		this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
 		this.behaviorStore = config.behaviorStore;
 	}
 
-	private async buildHeaders(): Promise<Record<string, string>> {
+	private buildHeaders(): Record<string, string> {
 		const headers: Record<string, string> = {
 			"content-type": "application/json",
 			accept: "application/json",
 		};
 
-		if (this.auth.apiKey !== undefined) {
-			headers.authorization = `Bearer ${this.auth.apiKey}`;
-		} else if (this.auth.getAccessToken) {
-			const token = await this.auth.getAccessToken();
-			headers.authorization = `Bearer ${token}`;
-		}
+		headers.authorization = `Bearer ${this.auth.apiKey}`;
 
 		const tp = activeTraceContext();
 		if (tp) {
@@ -452,7 +453,7 @@ export class Transport {
 		let attempt = 0;
 
 		while (true) {
-			const headers = await this.buildHeaders();
+			const headers = this.buildHeaders();
 			const controller = new AbortController();
 			const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
 
@@ -495,16 +496,28 @@ export class Transport {
 				let json: ApiEnvelope<T> | undefined;
 				const text = await response.text();
 
-				try {
-					json = JSON.parse(text) as ApiEnvelope<T>;
-				} catch {
-					// Not a JSON body — treat as generic API error
-					throw mapHttpError(
-						response.status,
-						null,
-						text || response.statusText,
-						response.headers,
-					);
+				if (text === "" && response.ok) {
+					// A successful empty body (e.g. 204): synthesize an empty-data
+					// envelope rather than mis-mapping it to an API error.
+					json = {
+						success: true,
+						code: response.status,
+						data: null,
+						error: null,
+						pagination: null,
+					} as ApiEnvelope<T>;
+				} else {
+					try {
+						json = JSON.parse(text) as ApiEnvelope<T>;
+					} catch {
+						// Not a JSON body — treat as generic API error
+						throw mapHttpError(
+							response.status,
+							null,
+							text || response.statusText,
+							response.headers,
+						);
+					}
 				}
 
 				if (!response.ok) {
@@ -554,7 +567,7 @@ export class Transport {
 				const isTimeout =
 					err instanceof DOMException && err.name === "AbortError";
 				// Only retry on genuine network failures (fetch throws TypeError) or timeouts.
-				// Unexpected errors (e.g. getAccessToken rejections) propagate immediately.
+				// Other unexpected errors propagate immediately.
 				const isNetworkError = err instanceof TypeError;
 
 				if (

package/dist/prompts/cache.d.ts

@@ -1,58 +0,0 @@
-import type { RenderedPrompt } from "./types";
-export interface CacheConfig {
-    /** Time-to-live in seconds. Default: 300 (5 minutes) */
-    ttlSeconds?: number;
-    /** Maximum number of entries. Default: 100 */
-    maxEntries?: number;
-}
-/**
- * The cache stores enriched `render()` results, which are JSON-cloneable.
- */
-export type CacheableRendered = RenderedPrompt;
-/**
- * Build a canonical base cache key from project/slug/labels/variables.
- *
- * - projectId is included to prevent cross-project cache collisions: a single
- *   PromptResource can serve multiple projects, so the same slug+labels must
- *   not share a cache entry across different projects.
- * - Labels are sorted alphabetically so ["production", "en"] and ["en", "production"]
- *   map to the same key.
- * - Variables are canonicalized with deterministic sorted-keys JSON before hashing.
- * - Each segment is JSON-encoded so that separator characters in slug or label
- *   values cannot cause key collisions (e.g. a slug containing "|" or ",").
- */
-export declare function buildCacheKey(projectId: string, slug: string, labels: string[], variables?: Record<string, unknown>): string;
-/**
- * Build a cache key for an env-aware `render()` call.
- *
- * Folds in `env` and `subject` ON TOP of the base
- * project/slug/labels/variables key so two calls that differ only by
- * env/subject do not return a stale cross-env / cross-cohort hit
- * (spec §3 "Caching key changes"). The env slug is also forwarded as the
- * single resolution label (env→label mapping, correction #3), so it appears
- * in the `labels` segment too; including it explicitly here keeps the key
- * unambiguous and self-documenting.
- *
- * `subject` participates in the key so a `subject`-keyed weighted assignment
- * caches as the same deterministic variant on repeat (D8); the
- * weighted-no-subject bypass is handled in the resource, not here.
- */
-export declare function buildRenderCacheKey(projectId: string, slug: string, env: string, subject?: string, variables?: Record<string, unknown>): string;
-/**
- * In-memory LRU cache for RenderedPrompt objects.
- *
- * Uses a Map (insertion-ordered) as the backing store. On every access, the
- * entry is deleted and re-inserted to maintain LRU order — oldest entries sit
- * at the front of the Map.
- */
-export declare class PromptCache {
-    private readonly ttlMs;
-    private readonly maxEntries;
-    private readonly store;
-    constructor(config?: CacheConfig);
-    get(key: string): CacheableRendered | undefined;
-    set(key: string, value: CacheableRendered): void;
-    delete(key: string): void;
-    clear(): void;
-    get size(): number;
-}

package/dist/routingRules/resource.cjs

@@ -1,138 +0,0 @@
-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);
-var import_zod = require("zod");
-var import_zod2 = require("../generated/zod.gen");
-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), {
-      decode: (data) => import_zod2.zRuleVersion.parse(data)
-    });
-    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,
-      decode: (data) => import_zod.z.array(import_zod2.zRuleRelease).parse(data)
-    });
-    return unwrap(envelope);
-  }
-}
-
-class RoutingRulesResource {
-  versions;
-  releases;
-  constructor(transport) {
-    this.versions = new RoutingRuleVersionResource(transport);
-    this.releases = new RoutingRuleReleaseResource(transport);
-  }
-}