@to11ai/sdk 0.0.2

package/README.md

@@ -0,0 +1,235 @@
+# @to11ai/sdk
+
+JavaScript/TypeScript SDK for [to11ai](https://to11ai.com) — the AI engineering platform for prompt management, tracing, and evals.
+
+Ships ESM, CommonJS, and raw TypeScript source in the same package. Runtimes and bundlers pick the right variant automatically.
+
+## Installation
+
+```bash
+npm install @to11ai/sdk
+# or
+bun add @to11ai/sdk
+# or
+pnpm add @to11ai/sdk
+# or
+yarn add @to11ai/sdk
+```
+
+## Runtime support
+
+| Runtime / loader            | Resolves to          | Notes                                         |
+| --------------------------- | -------------------- | --------------------------------------------- |
+| Node.js (ESM: `import`)     | `dist/*.js`          | Bundled ESM, Node-targeted                    |
+| Node.js (CJS: `require`)    | `dist/*.cjs`         | Bundled CommonJS                              |
+| TypeScript (type resolution)| `dist/*.d.ts`        | Declarations for editor + tsc                 |
+| Bun                         | `src/*.ts`           | Raw source — zero build overhead, full maps  |
+| Deno                        | `src/*.ts`           | Raw source                                    |
+| Browsers (via bundler)      | `dist/*.js`          | Tree-shakeable ESM                            |
+| Workers / edge runtimes     | `dist/*.js`          | ESM, Node-compatible                          |
+
+Resolution is driven by the package's `exports` conditional map. The tarball ships both `dist/` (compiled) and `src/` (TypeScript) so runtimes that support raw `.ts` can skip the build step.
+
+## Getting started
+
+```typescript
+import { createClient } from "@to11ai/sdk";
+
+const client = createClient({
+  baseUrl: "https://api.to11ai.com",
+  apiKey: process.env.TO11AI_API_KEY!,
+});
+
+const result = await client.prompts.resolve({
+  projectId: "proj_abc123",
+  slug: "chat-system-prompt",
+  labels: ["production"],
+  variables: { userName: "Alice" },
+});
+
+console.log(result.rendered); // { format: "text", text: "Hello, Alice!" }
+```
+
+## Client construction
+
+### Server-side (API key)
+
+Use an API key for server-side Node.js, Bun, Deno, or edge runtimes where a secret is safe:
+
+```typescript
+import { createClient } from "@to11ai/sdk";
+
+const client = createClient({
+  baseUrl: "https://api.to11ai.com",
+  apiKey: process.env.TO11AI_API_KEY!,
+});
+```
+
+### Browser-side (access token callback)
+
+Use a `getAccessToken` callback to avoid shipping a static secret to the browser:
+
+```typescript
+import { createClient } from "@to11ai/sdk";
+
+const client = createClient({
+  baseUrl: "https://api.to11ai.com",
+  getAccessToken: async () => {
+    const res = await fetch("/api/auth/token");
+    const { token } = await res.json();
+    return token;
+  },
+});
+```
+
+Passing `apiKey` in a browser context throws immediately to prevent accidental secret exposure.
+
+## Prompt resolution
+
+`prompts.resolve()` is the primary use case — it fetches a prompt by slug, applies labels to select a version, renders Liquid template variables, and returns the final text or chat messages.
+
+```typescript
+const result = await client.prompts.resolve({
+  projectId: "proj_abc123",
+  slug: "summarise-article",
+  labels: ["production", "en"],
+  variables: {
+    article: "OpenAI releases GPT-5...",
+    maxLength: 200,
+  },
+});
+
+if (result.rendered.format === "text") {
+  console.log(result.rendered.text);
+} else {
+  // chat format
+  for (const msg of result.rendered.messages) {
+    console.log(`[${msg.role}] ${msg.content}`);
+  }
+}
+```
+
+## All prompt methods
+
+| Method | Description |
+|---|---|
+| `prompts.resolve(input)` | Fetch a prompt by slug + labels, render variables, return rendered output. Cached by default. |
+| `prompts.create(input)` | Create a new prompt (name, slug, description, tags). |
+| `prompts.list(input)` | List prompts in a project with optional pagination. |
+| `prompts.get(input)` | Get a single prompt by ID. |
+| `prompts.update(input)` | Update prompt metadata (name, description, tags). |
+| `prompts.archive(input)` | Archive a prompt (soft delete). |
+| `prompts.createVersion(input)` | Create a new version for an existing prompt. |
+| `prompts.listVersions(input)` | List all versions of a prompt. |
+| `prompts.getVersion(input)` | Get a specific version by version number. |
+| `prompts.moveLabel(input)` | Point a label (e.g. `production`) at a specific version. |
+| `prompts.listLabels(input)` | List all label pointers for a prompt. |
+
+All methods require at minimum `projectId` and the relevant resource identifier(s).
+
+## Error handling
+
+The SDK exports five typed error classes. Catch `To11aiError` as a base or catch specific subclasses:
+
+```typescript
+import {
+  To11aiError,
+  To11aiApiError,
+  To11aiAuthError,
+  To11aiRateLimitError,
+  To11aiValidationError,
+  To11aiNetworkError,
+} from "@to11ai/sdk";
+
+try {
+  const result = await client.prompts.resolve({ ... });
+} catch (err) {
+  if (err instanceof To11aiRateLimitError) {
+    const retryAfter = err.retryAfterSeconds ?? 60;
+    console.warn(`Rate limited — retry in ${retryAfter}s`);
+  } else if (err instanceof To11aiAuthError) {
+    console.error("Authentication failed:", err.statusCode, err.message);
+  } else if (err instanceof To11aiValidationError) {
+    console.error("Bad request:", err.message, err.details);
+  } else if (err instanceof To11aiNetworkError) {
+    console.error("Network failure:", err.message, err.cause);
+  } else if (err instanceof To11aiApiError) {
+    console.error(`API error ${err.statusCode} [${err.errorCode}]:`, err.message);
+  } else {
+    throw err;
+  }
+}
+```
+
+| Class | When thrown |
+|---|---|
+| `To11aiError` | Base class for all SDK errors |
+| `To11aiApiError` | Non-2xx API response with structured error envelope |
+| `To11aiValidationError` | 400 schema validation failure |
+| `To11aiAuthError` | 401 or 403 authentication/authorisation failure |
+| `To11aiRateLimitError` | 429 rate limit hit; includes `retryAfterSeconds` |
+| `To11aiNetworkError` | Network failure or request timeout |
+
+## Caching
+
+`prompts.resolve()` uses an in-memory LRU cache by default. Configure it at client construction time:
+
+```typescript
+const client = createClient({
+  baseUrl: "https://api.to11ai.com",
+  apiKey: process.env.TO11AI_API_KEY!,
+  cache: {
+    ttlSeconds: 600,   // default: 300 (5 minutes)
+    maxEntries: 500,   // default: 100
+  },
+});
+```
+
+**Per-call bypass:** pass `cache: false` to skip the cache for a single call:
+
+```typescript
+const fresh = await client.prompts.resolve({
+  projectId: "proj_abc123",
+  slug: "chat-system-prompt",
+  labels: ["production"],
+  cache: false, // bypass cache, always fetch from API
+});
+```
+
+**Fallback on network error:** pass `fallback` to return a pre-defined value if the network request fails (e.g. during a deployment):
+
+```typescript
+const result = await client.prompts.resolve({
+  projectId: "proj_abc123",
+  slug: "chat-system-prompt",
+  labels: ["production"],
+  fallback: {
+    promptId: "...",
+    versionId: "...",
+    version: 1,
+    rendered: { format: "text", text: "You are a helpful assistant." },
+  },
+});
+```
+
+## TypeScript types
+
+All inputs and outputs are fully typed. Import types directly if needed:
+
+```typescript
+import type {
+  ClientOptions,
+  CacheConfig,
+  To11aiClient,
+} from "@to11ai/sdk";
+
+import type {
+  ResolvePromptInput,
+  ResolvePromptResult,
+  ResolvedPrompt,
+  Prompt,
+  PromptVersion,
+} from "@to11ai/sdk/prompts";
+```
+
+Type declarations ship in the package as `dist/*.d.ts`. No separate `@types` package is required. Bun and Deno consumers additionally get the raw TypeScript source.

package/dist/client.cjs

@@ -0,0 +1,85 @@
+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/client.ts
+var exports_client = {};
+__export(exports_client, {
+  gatewayPromptHeaders: () => import_gateway.gatewayPromptHeaders,
+  gatewayAuthHeaders: () => import_gateway.gatewayAuthHeaders,
+  createClient: () => createClient,
+  To11aiValidationError: () => import_errors.To11aiValidationError,
+  To11aiRateLimitError: () => import_errors.To11aiRateLimitError,
+  To11aiNetworkError: () => import_errors.To11aiNetworkError,
+  To11aiError: () => import_errors.To11aiError,
+  To11aiAuthError: () => import_errors.To11aiAuthError,
+  To11aiApiError: () => import_errors.To11aiApiError,
+  PromptResource: () => import_resource2.PromptResource
+});
+module.exports = __toCommonJS(exports_client);
+var import_resource = require("./prompts/resource");
+var import_transport = require("./transport");
+var import_errors = require("./errors");
+var import_gateway = require("./gateway");
+var import_resource2 = require("./prompts/resource");
+function createClient(options) {
+  const isDomBrowser = typeof globalThis === "object" && typeof globalThis.document !== "undefined";
+  const workerLikeGlobal = globalThis;
+  const isBunMainThread = workerLikeGlobal.Bun?.isMainThread === true;
+  const isWorkerBrowser = typeof globalThis === "object" && (typeof workerLikeGlobal.importScripts === "function" || !isBunMainThread && typeof workerLikeGlobal.postMessage === "function" && typeof workerLikeGlobal.onmessage !== "undefined");
+  if ((isDomBrowser || isWorkerBrowser) && options.apiKey !== undefined) {
+    throw new Error("[to11ai/sdk] Do not use `apiKey` in browser contexts — use `getAccessToken` instead.");
+  }
+  if (options.apiKey !== undefined && options.apiKey.trim() === "") {
+    throw new Error("[to11ai/sdk] `apiKey` must not be an empty string.");
+  }
+  const hasApiKey = options.apiKey !== undefined;
+  const hasGetAccessToken = options.getAccessToken !== undefined;
+  const getAccessToken = options.getAccessToken;
+  if (hasApiKey === hasGetAccessToken) {
+    throw new Error("[to11ai/sdk] Provide exactly one of `apiKey` (server) or `getAccessToken` (browser).");
+  }
+  const auth = options.apiKey !== undefined ? { apiKey: options.apiKey } : { getAccessToken };
+  const transport = new import_transport.Transport({
+    baseUrl: options.baseUrl,
+    auth,
+    timeoutMs: options.timeoutMs,
+    maxRetries: options.maxRetries
+  });
+  const prompts = new import_resource.PromptResource(transport, options.cache);
+  return { prompts };
+}

package/dist/client.d.ts

@@ -0,0 +1,39 @@
+import type { CacheConfig } from "./prompts/cache";
+import { PromptResource } from "./prompts/resource";
+export { To11aiApiError, To11aiAuthError, To11aiError, To11aiNetworkError, To11aiRateLimitError, To11aiValidationError, } from "./errors";
+export type { GatewayAuthOptions } from "./gateway";
+export { gatewayAuthHeaders, gatewayPromptHeaders } from "./gateway";
+export type { CacheConfig } from "./prompts/cache";
+export { PromptResource } from "./prompts/resource";
+export type { Transport } from "./transport";
+interface ServerAuthOptions {
+    /** API key for server-side use. Must not be used in browser contexts. */
+    apiKey: string;
+    getAccessToken?: never;
+}
+interface BrowserAuthOptions {
+    /** Token callback for browser / edge contexts — avoids static secrets. */
+    getAccessToken: () => Promise<string>;
+    apiKey?: never;
+}
+type AuthOptions = ServerAuthOptions | BrowserAuthOptions;
+export type ClientOptions = AuthOptions & {
+    baseUrl: string;
+    /** LRU cache configuration for resolve(). Defaults: ttlSeconds=300, maxEntries=100 */
+    cache?: CacheConfig;
+    /** Request timeout in milliseconds. Default: 30_000 */
+    timeoutMs?: number;
+    /** Max retry attempts for network errors / 5xx. Default: 3 */
+    maxRetries?: number;
+};
+export interface To11aiClient {
+    readonly prompts: PromptResource;
+}
+/**
+ * Create a to11ai SDK client.
+ *
+ * Auth mode is inferred from options:
+ *  - `apiKey`          → server-side; rejected in browser contexts.
+ *  - `getAccessToken`  → browser-safe; token fetched per request.
+ */
+export declare function createClient(options: ClientOptions): To11aiClient;

package/dist/client.js

@@ -0,0 +1,52 @@
+// src/client.ts
+import { PromptResource } from "./prompts/resource";
+import { Transport } from "./transport";
+import {
+  To11aiApiError,
+  To11aiAuthError,
+  To11aiError,
+  To11aiNetworkError,
+  To11aiRateLimitError,
+  To11aiValidationError
+} from "./errors";
+import { gatewayAuthHeaders, gatewayPromptHeaders } from "./gateway";
+import { PromptResource as PromptResource2 } from "./prompts/resource";
+function createClient(options) {
+  const isDomBrowser = typeof globalThis === "object" && typeof globalThis.document !== "undefined";
+  const workerLikeGlobal = globalThis;
+  const isBunMainThread = workerLikeGlobal.Bun?.isMainThread === true;
+  const isWorkerBrowser = typeof globalThis === "object" && (typeof workerLikeGlobal.importScripts === "function" || !isBunMainThread && typeof workerLikeGlobal.postMessage === "function" && typeof workerLikeGlobal.onmessage !== "undefined");
+  if ((isDomBrowser || isWorkerBrowser) && options.apiKey !== undefined) {
+    throw new Error("[to11ai/sdk] Do not use `apiKey` in browser contexts — use `getAccessToken` instead.");
+  }
+  if (options.apiKey !== undefined && options.apiKey.trim() === "") {
+    throw new Error("[to11ai/sdk] `apiKey` must not be an empty string.");
+  }
+  const hasApiKey = options.apiKey !== undefined;
+  const hasGetAccessToken = options.getAccessToken !== undefined;
+  const getAccessToken = options.getAccessToken;
+  if (hasApiKey === hasGetAccessToken) {
+    throw new Error("[to11ai/sdk] Provide exactly one of `apiKey` (server) or `getAccessToken` (browser).");
+  }
+  const auth = options.apiKey !== undefined ? { apiKey: options.apiKey } : { getAccessToken };
+  const transport = new Transport({
+    baseUrl: options.baseUrl,
+    auth,
+    timeoutMs: options.timeoutMs,
+    maxRetries: options.maxRetries
+  });
+  const prompts = new PromptResource(transport, options.cache);
+  return { prompts };
+}
+export {
+  gatewayPromptHeaders,
+  gatewayAuthHeaders,
+  createClient,
+  To11aiValidationError,
+  To11aiRateLimitError,
+  To11aiNetworkError,
+  To11aiError,
+  To11aiAuthError,
+  To11aiApiError,
+  PromptResource2 as PromptResource
+};

package/dist/errors.cjs

@@ -0,0 +1,105 @@
+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/errors.ts
+var exports_errors = {};
+__export(exports_errors, {
+  To11aiValidationError: () => To11aiValidationError,
+  To11aiRateLimitError: () => To11aiRateLimitError,
+  To11aiNetworkError: () => To11aiNetworkError,
+  To11aiError: () => To11aiError,
+  To11aiAuthError: () => To11aiAuthError,
+  To11aiApiError: () => To11aiApiError
+});
+module.exports = __toCommonJS(exports_errors);
+
+class To11aiError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "To11aiError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+class To11aiApiError extends To11aiError {
+  statusCode;
+  errorCode;
+  details;
+  constructor(message, statusCode, errorCode, details) {
+    super(message);
+    this.name = "To11aiApiError";
+    this.statusCode = statusCode;
+    this.errorCode = errorCode;
+    this.details = details;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+class To11aiValidationError extends To11aiApiError {
+  constructor(message, errorCode, details) {
+    super(message, 400, errorCode, details);
+    this.name = "To11aiValidationError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+class To11aiAuthError extends To11aiApiError {
+  constructor(message, statusCode, errorCode, details) {
+    super(message, statusCode, errorCode, details);
+    this.name = "To11aiAuthError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+class To11aiRateLimitError extends To11aiApiError {
+  retryAfterSeconds;
+  constructor(message, retryAfterSeconds, errorCode, details) {
+    super(message, 429, errorCode, details);
+    this.name = "To11aiRateLimitError";
+    this.retryAfterSeconds = retryAfterSeconds;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+class To11aiNetworkError extends To11aiError {
+  constructor(message, cause) {
+    super(message, { cause });
+    this.name = "To11aiNetworkError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}

package/dist/errors.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Base class for all @to11ai/sdk errors.
+ */
+export declare class To11aiError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Thrown when the API returns a non-2xx response with an error envelope.
+ */
+export declare class To11aiApiError extends To11aiError {
+    readonly statusCode: number;
+    readonly errorCode: string | undefined;
+    readonly details: unknown;
+    constructor(message: string, statusCode: number, errorCode?: string, details?: unknown);
+}
+/**
+ * Thrown on 400 / schema validation failures.
+ */
+export declare class To11aiValidationError extends To11aiApiError {
+    constructor(message: string, errorCode?: string, details?: unknown);
+}
+/**
+ * Thrown on 401 or 403 responses.
+ */
+export declare class To11aiAuthError extends To11aiApiError {
+    constructor(message: string, statusCode: 401 | 403, errorCode?: string, details?: unknown);
+}
+/**
+ * Thrown on 429 rate limit responses.
+ */
+export declare class To11aiRateLimitError extends To11aiApiError {
+    readonly retryAfterSeconds: number | undefined;
+    constructor(message: string, retryAfterSeconds?: number, errorCode?: string, details?: unknown);
+}
+/**
+ * Thrown on network failure or request timeout.
+ */
+export declare class To11aiNetworkError extends To11aiError {
+    constructor(message: string, cause?: unknown);
+}

package/dist/errors.js

@@ -0,0 +1,64 @@
+// src/errors.ts
+class To11aiError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "To11aiError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+class To11aiApiError extends To11aiError {
+  statusCode;
+  errorCode;
+  details;
+  constructor(message, statusCode, errorCode, details) {
+    super(message);
+    this.name = "To11aiApiError";
+    this.statusCode = statusCode;
+    this.errorCode = errorCode;
+    this.details = details;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+class To11aiValidationError extends To11aiApiError {
+  constructor(message, errorCode, details) {
+    super(message, 400, errorCode, details);
+    this.name = "To11aiValidationError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+class To11aiAuthError extends To11aiApiError {
+  constructor(message, statusCode, errorCode, details) {
+    super(message, statusCode, errorCode, details);
+    this.name = "To11aiAuthError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+class To11aiRateLimitError extends To11aiApiError {
+  retryAfterSeconds;
+  constructor(message, retryAfterSeconds, errorCode, details) {
+    super(message, 429, errorCode, details);
+    this.name = "To11aiRateLimitError";
+    this.retryAfterSeconds = retryAfterSeconds;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+class To11aiNetworkError extends To11aiError {
+  constructor(message, cause) {
+    super(message, { cause });
+    this.name = "To11aiNetworkError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+export {
+  To11aiValidationError,
+  To11aiRateLimitError,
+  To11aiNetworkError,
+  To11aiError,
+  To11aiAuthError,
+  To11aiApiError
+};

package/dist/gateway.cjs

@@ -0,0 +1,67 @@
+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/gateway.ts
+var exports_gateway = {};
+__export(exports_gateway, {
+  gatewayPromptHeaders: () => gatewayPromptHeaders,
+  gatewayAuthHeaders: () => gatewayAuthHeaders
+});
+module.exports = __toCommonJS(exports_gateway);
+function gatewayAuthHeaders(options) {
+  if (options.apiKey.trim().length === 0) {
+    throw new Error("[to11ai/sdk] `apiKey` must not be empty.");
+  }
+  if (options.projectId.trim().length === 0) {
+    throw new Error("[to11ai/sdk] `projectId` must not be empty.");
+  }
+  return {
+    "x-to11-authorization": `Bearer ${options.apiKey}`,
+    "x-to11-project-id": options.projectId
+  };
+}
+function gatewayPromptHeaders(prompt) {
+  const headers = {
+    "x-to11-prompt-id": prompt.promptId,
+    "x-to11-prompt-version": String(prompt.version)
+  };
+  if (prompt.labels.length > 0) {
+    headers["x-to11-prompt-labels"] = prompt.labels.join(",");
+  }
+  return headers;
+}