@runtypelabs/sdk 9.9.0 → 9.10.0

package/dist/index.mjs

@@ -37,6 +37,7 @@ var UNIFIED_EVENT_TYPES = /* @__PURE__ */ new Set([
   "approval_complete",
   "await",
   "error",
+  "context_notice",
   "ping",
   "custom"
 ]);
@@ -2635,11 +2636,12 @@ async function request(client, body) {
   }
 }
 async function ensureFlow(client, definition, options = {}) {
-  const { dryRun, onConflict, release, expectedRemoteHash, expectNoChanges } = options;
+  const { dryRun, onConflict, release, expectedRemoteHash, version, expectNoChanges } = options;
   const passthrough = {
     ...onConflict ? { onConflict } : {},
     ...release ? { release } : {},
-    ...expectedRemoteHash ? { expectedRemoteHash } : {}
+    ...expectedRemoteHash ? { expectedRemoteHash } : {},
+    ...version ? { version } : {}
   };
   const wireDefinition = { name: definition.name, steps: definition.steps };
   if (dryRun || expectNoChanges) {
@@ -4915,11 +4917,12 @@ var AgentsNamespace = class {
    */
   async ensure(definition, options = {}) {
     const client = this.getClient();
-    const { dryRun, onConflict, release, expectedRemoteHash, expectNoChanges } = options;
+    const { dryRun, onConflict, release, expectedRemoteHash, version, expectNoChanges } = options;
     const passthrough = {
       ...onConflict ? { onConflict } : {},
       ...release ? { release } : {},
-      ...expectedRemoteHash ? { expectedRemoteHash } : {}
+      ...expectedRemoteHash ? { expectedRemoteHash } : {},
+      ...version ? { version } : {}
     };
     if (dryRun || expectNoChanges) {
       const plan = await this.request(client, {
@@ -5766,542 +5769,51 @@ function normalizeDispatchRequest(request6) {
   return request6.flow ? { ...normalized, flow: request6.flow } : { ...normalized, agent: request6.agent };
 }
 
-// src/runtype.ts
-var globalConfig = {};
-var globalClient = null;
-var RuntypeClient = class {
-  constructor(config = {}) {
-    const baseUrl = config.baseUrl || "https://api.runtype.com";
-    this.apiVersion = config.apiVersion || "v1";
-    this.baseUrl = this.apiVersion ? `${baseUrl}/${this.apiVersion}` : baseUrl;
-    this.timeout = config.timeout || 3e4;
-    this.headers = {
-      "Content-Type": "application/json",
-      ...config.headers || {}
-    };
-    if (config.apiKey) {
-      this.headers.Authorization = `Bearer ${config.apiKey}`;
-    }
-  }
-  /**
-   * Set the API key for authentication
-   */
-  setApiKey(apiKey) {
-    this.headers.Authorization = `Bearer ${apiKey}`;
-  }
-  /**
-   * Generic GET request
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts typed list-param interfaces (no index signature); `unknown` would reject them
-  async get(path, params) {
-    const url = this.buildUrl(path, params);
-    const response = await this.makeRequest(url, {
-      method: "GET",
-      headers: this.headers
-    });
-    return response;
-  }
-  /**
-   * Generic POST request
-   */
-  async post(path, data, extraHeaders) {
-    const url = this.buildUrl(path);
-    const response = await this.makeRequest(url, {
-      method: "POST",
-      headers: { ...this.headers, ...extraHeaders },
-      body: data ? JSON.stringify(data) : void 0
-    });
-    return response;
-  }
-  /**
-   * Generic PUT request
-   */
-  async put(path, data) {
-    const url = this.buildUrl(path);
-    const response = await this.makeRequest(url, {
-      method: "PUT",
-      headers: this.headers,
-      body: data ? JSON.stringify(data) : void 0
-    });
-    return response;
-  }
-  /**
-   * Generic PATCH request
-   */
-  async patch(path, data) {
-    const url = this.buildUrl(path);
-    const response = await this.makeRequest(url, {
-      method: "PATCH",
-      headers: this.headers,
-      body: data ? JSON.stringify(data) : void 0
-    });
-    return response;
-  }
-  /**
-   * Generic DELETE request
-   */
-  async delete(path) {
-    const url = this.buildUrl(path);
-    const response = await this.makeRequest(url, {
-      method: "DELETE",
-      headers: this.headers
-    });
-    return response;
-  }
-  /**
-   * Generic request that returns raw Response for streaming
-   */
-  async requestStream(path, options = {}) {
-    const url = this.buildUrl(path);
-    const headers = {
-      ...this.headers,
-      ...options.headers
-    };
-    return this.makeRawRequest(url, {
-      ...options,
-      headers
-    });
-  }
-  /**
-   * Dispatch flow execution (streaming).
-   *
-   * This is the sole streaming-dispatch chokepoint for the flow builders
-   * (`RuntypeFlowBuilder`), so it normalizes the request to the canonical
-   * `/v1/dispatch` wire contract here — every builder path inherits the same
-   * normalization the `DispatchEndpoint` applies, with no per-builder call.
-   */
-  async dispatch(config) {
-    const normalized = normalizeDispatchRequest(config);
-    const request6 = {
-      ...normalized,
-      options: {
-        ...normalized.options,
-        streamResponse: true
-      }
-    };
-    return this.requestStream("/dispatch", {
-      method: "POST",
-      body: JSON.stringify(request6)
-    });
-  }
-  /**
-   * Dispatch flow execution (non-streaming JSON).
-   *
-   * The non-streaming sibling of {@link dispatch}; it normalizes to the same
-   * canonical wire contract so builders never post a raw, un-normalized body,
-   * and pins `streamResponse: false` so the server returns buffered JSON.
-   */
-  async dispatchJson(config) {
-    const normalized = normalizeDispatchRequest(config);
-    return this.post("/dispatch", {
-      ...normalized,
-      options: {
-        ...normalized.options,
-        streamResponse: false
-      }
-    });
-  }
-  /** Start a normalized dispatch and return a durable handle immediately. */
-  async dispatchAsync(config) {
-    const normalized = normalizeDispatchRequest(config);
-    return this.post(
-      "/dispatch",
-      {
-        ...normalized,
-        options: { ...normalized.options, streamResponse: false }
-      },
-      { Prefer: "respond-async" }
-    );
-  }
-  async getExecutionStatus(executionId) {
-    return this.get(`/executions/${encodeURIComponent(executionId)}/status`);
-  }
-  /**
-   * Build full URL with query parameters
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- mirrors get()'s permissive params type
-  buildUrl(path, params) {
-    const base = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
-    const relPath = path.startsWith("/") ? path.slice(1) : path;
-    const url = new URL(relPath, base);
-    if (params) {
-      Object.entries(params).forEach(([key, value]) => {
-        if (value !== void 0 && value !== null) {
-          url.searchParams.set(key, String(value));
-        }
-      });
+// src/detached-reconnect.ts
+var TERMINAL_EVENTS = /* @__PURE__ */ new Set(["execution_complete", "execution_error"]);
+var DEFAULT_MAX_DETACHED_RECONNECTS = 12;
+function combineAbortSignals(...signals) {
+  const present = signals.filter((signal) => Boolean(signal));
+  if (present.length === 0) return void 0;
+  if (present.length === 1) return present[0];
+  const anySignal = AbortSignal.any;
+  if (typeof anySignal === "function") return anySignal.call(AbortSignal, present);
+  const controller = new AbortController();
+  for (const signal of present) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      break;
     }
-    return url.toString();
+    signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
   }
-  /**
-   * Make HTTP request with timeout and error handling
-   */
-  async makeRequest(url, options) {
-    const response = await this.makeRawRequest(url, options);
-    if (response.status === 204) {
-      return null;
+  return controller.signal;
+}
+function observeBlock(block, into) {
+  let eventName = null;
+  for (const line of block.split("\n")) {
+    if (line.startsWith("id:")) {
+      into.lastId = line.slice(3).trim();
+      continue;
     }
-    const contentType = response.headers.get("content-type");
-    if (contentType?.includes("application/json")) {
-      return response.json();
+    if (line.startsWith("event:")) {
+      eventName = line.slice(6).trim();
+      continue;
     }
-    return response.text();
-  }
-  /**
-   * Make HTTP request that returns raw Response (for streaming)
-   */
-  async makeRawRequest(url, options) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    if (!line.startsWith("data:")) continue;
+    const raw = line.slice(5).trim();
+    if (!raw || raw === "[DONE]") continue;
+    let payload;
     try {
-      const response = await fetch(url, {
-        ...options,
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(
-          `API request failed: ${response.status} ${response.statusText} - ${errorText}`
-        );
-      }
-      return response;
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new Error(`Request timeout after ${this.timeout}ms`, { cause: error });
-      }
-      throw error;
-    }
-  }
-};
-var Runtype = class {
-  /**
-   * Configure the global Runtype client
-   *
-   * Call this once at app startup to set the API key and other options.
-   * All subsequent calls to Runtype.flows, Runtype.batches, etc. will use this config.
-   *
-   * @example
-   * ```typescript
-   * Runtype.configure({ apiKey: process.env.RUNTYPE_API_KEY })
-   * ```
-   */
-  static configure(config) {
-    globalConfig = { ...globalConfig, ...config };
-    globalClient = new RuntypeClient(globalConfig);
-  }
-  /**
-   * Get the global client instance, creating one if needed
-   */
-  static getClient() {
-    if (!globalClient) {
-      globalClient = new RuntypeClient(globalConfig);
+      const parsed = JSON.parse(raw);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) continue;
+      payload = parsed;
+    } catch {
+      continue;
     }
-    return globalClient;
-  }
-  /**
-   * Create a new client instance with custom configuration
-   *
-   * Use this when you need a client with different settings than the global one.
-   *
-   * @example
-   * ```typescript
-   * const client = Runtype.createClient({ apiKey: 'different_key' })
-   * ```
-   */
-  static createClient(config) {
-    return new RuntypeClient({ ...globalConfig, ...config });
-  }
-  /**
-   * Flows namespace - Build and execute flows
-   *
-   * @example
-   * ```typescript
-   * // Upsert a flow (create or update)
-   * const result = await Runtype.flows.upsert({ name: 'My Flow' })
-   *   .prompt({ name: 'Analyze', model: 'gpt-4o', userPrompt: '...' })
-   *   .stream()
-   *
-   * // Use an existing flow
-   * const result = await Runtype.flows.use('flow_123')
-   *   .withRecord({ name: 'Test' })
-   *   .result()
-   *
-   * // Virtual flow (one-off, not saved)
-   * const result = await Runtype.flows.virtual({ name: 'Temp Flow' })
-   *   .prompt({ ... })
-   *   .stream()
-   * ```
-   */
-  static get flows() {
-    return new FlowsNamespace(() => this.getClient());
-  }
-  /**
-   * Batches namespace - Schedule and manage batch operations
-   *
-   * @example
-   * ```typescript
-   * // Schedule a batch
-   * const batch = await Runtype.batches.schedule({
-   *   flowId: 'flow_123',
-   *   recordType: 'customers',
-   * })
-   *
-   * // Get batch status
-   * const status = await Runtype.batches.get('batch_456')
-   *
-   * // Cancel a batch
-   * await Runtype.batches.cancel('batch_456')
-   *
-   * // List batches
-   * const batches = await Runtype.batches.list({ status: 'running' })
-   * ```
-   */
-  static get batches() {
-    return new BatchesNamespace(() => this.getClient());
-  }
-  /**
-   * Evals namespace - Run evaluations and compare models
-   *
-   * @example
-   * ```typescript
-   * // Run an eval with streaming
-   * const stream = await Runtype.evals.run({
-   *   flowId: 'flow_123',
-   *   recordType: 'test_data',
-   *   models: [{ stepName: 'Analyze', model: 'gpt-4o' }]
-   * }).stream()
-   *
-   * // Submit eval as batch job
-   * const eval = await Runtype.evals.run({
-   *   flowId: 'flow_123',
-   *   recordType: 'test_data',
-   *   models: [
-   *     [{ stepName: 'Analyze', model: 'gpt-5.4' }],
-   *     [{ stepName: 'Analyze', model: 'claude-opus-4-6' }],
-   *   ]
-   * }).submit()
-   * ```
-   */
-  static get evals() {
-    return new EvalsNamespace(() => this.getClient());
-  }
-  /**
-   * Prompts namespace - Manage and execute prompts
-   *
-   * @example
-   * ```typescript
-   * // Execute a prompt with streaming
-   * const stream = await Runtype.prompts.run('prompt_123', {
-   *   recordId: 'rec_456'
-   * }).stream()
-   *
-   * // Get complete result
-   * const result = await Runtype.prompts.run('prompt_123', {
-   *   recordId: 'rec_456'
-   * }).result()
-   *
-   * // CRUD operations
-   * const prompts = await Runtype.prompts.list()
-   * const prompt = await Runtype.prompts.get('prompt_123')
-   * const newPrompt = await Runtype.prompts.create({ ... })
-   * await Runtype.prompts.update('prompt_123', { ... })
-   * await Runtype.prompts.delete('prompt_123')
-   * ```
-   */
-  static get prompts() {
-    return new PromptsNamespace(() => this.getClient());
-  }
-  /**
-   * Skills namespace - Manage Agent Skills (admin/control plane)
-   *
-   * @example
-   * ```typescript
-   * // Create a published skill from a SKILL.md document
-   * const { skill } = await Runtype.skills.create({ markdown: skillMd, publish: true })
-   *
-   * // Bind it to an agent
-   * await Runtype.skills.bind({ agentId: 'agent_123', skillId: skill.id })
-   *
-   * // Review agent-authored proposals
-   * const pending = await Runtype.skills.proposals.list()
-   * await Runtype.skills.proposals.approve(pending[0].id)
-   * ```
-   */
-  static get skills() {
-    return new SkillsNamespace(() => this.getClient());
-  }
-  /**
-   * Agents namespace - Agent config-as-code (define / ensure / pull)
-   *
-   * @example
-   * ```typescript
-   * import { defineAgent, Runtype } from '@runtypelabs/sdk'
-   *
-   * const assistant = defineAgent({
-   *   name: 'Pricing Assistant',
-   *   model: 'claude-sonnet-4-6',
-   *   systemPrompt: renderPrompt(pricingData),
-   * })
-   *
-   * // Converge at deploy time (idempotent; one tiny probe in steady state)
-   * await Runtype.agents.ensure(assistant)
-   *
-   * // CI drift gate
-   * await Runtype.agents.ensure(assistant, { expectNoChanges: true })
-   *
-   * // Absorb a dashboard edit back into the repo
-   * const { definition } = await Runtype.agents.pull('Pricing Assistant')
-   * ```
-   */
-  static get agents() {
-    return new AgentsNamespace(() => this.getClient());
-  }
-  /** Poll durable handles returned by asynchronous execute operations. */
-  static get executions() {
-    return new ExecutionsNamespace(() => this.getClient());
-  }
-  /**
-   * Tools namespace - Tool config-as-code (define / ensure / pull)
-   *
-   * @example
-   * ```typescript
-   * import { defineTool, Runtype } from '@runtypelabs/sdk'
-   *
-   * const weather = defineTool({
-   *   name: 'Weather Lookup',
-   *   description: 'Fetch the current weather for a city',
-   *   toolType: 'external',
-   *   parametersSchema: { type: 'object', properties: { city: { type: 'string' } } },
-   *   config: { url: 'https://api.example.com/weather', method: 'GET' },
-   * })
-   *
-   * // Converge at deploy time (idempotent; one tiny probe in steady state)
-   * await Runtype.tools.ensure(weather)
-   *
-   * // CI drift gate
-   * await Runtype.tools.ensure(weather, { expectNoChanges: true })
-   *
-   * // Absorb a dashboard edit back into the repo
-   * const { definition } = await Runtype.tools.pull('Weather Lookup')
-   * ```
-   */
-  static get tools() {
-    return new ToolsNamespace(() => this.getClient());
-  }
-  /**
-   * Products namespace - Product config-as-code (define / ensure / pull)
-   *
-   * Converges the top-level product record (description, icon, spec). Nested
-   * capabilities/surfaces/tools and the canvas UI layout state are not
-   * converged by ensure.
-   *
-   * @example
-   * ```typescript
-   * import { defineProduct, Runtype } from '@runtypelabs/sdk'
-   *
-   * const product = defineProduct({
-   *   name: 'Support Copilot',
-   *   description: 'An AI support assistant',
-   *   icon: '🤖',
-   *   spec: { productGoal: 'Deflect tier-1 tickets', productStage: 'beta' },
-   * })
-   *
-   * // Converge at deploy time (idempotent; one tiny probe in steady state)
-   * await Runtype.products.ensure(product)
-   *
-   * // CI drift gate
-   * await Runtype.products.ensure(product, { expectNoChanges: true })
-   *
-   * // Absorb a dashboard edit back into the repo
-   * const { definition } = await Runtype.products.pull('Support Copilot')
-   * ```
-   */
-  static get products() {
-    return new ProductsNamespace(() => this.getClient());
-  }
-  /**
-   * Config-as-code operations for product surfaces. `surfaces.ensure` is the
-   * deploy-time, non-executing converge (create-or-update a surface by name
-   * within a product); `surfaces.pull` is the absorb-drift direction.
-   *
-   * @example
-   * ```typescript
-   * import { Runtype, defineSurface } from '@runtypelabs/sdk'
-   *
-   * const chat = defineSurface({
-   *   name: 'Support Chat',
-   *   type: 'chat',
-   *   behavior: { type: 'chat', greeting: 'Hi there!' },
-   *   status: 'active',
-   * })
-   *
-   * // Converge at deploy time (idempotent; one tiny probe in steady state)
-   * await Runtype.surfaces.ensure('product_abc', chat)
-   *
-   * // CI drift gate
-   * await Runtype.surfaces.ensure('product_abc', chat, { expectNoChanges: true })
-   *
-   * // Absorb a dashboard edit back into the repo
-   * const { definition } = await Runtype.surfaces.pull('product_abc', 'Support Chat')
-   * ```
-   */
-  static get surfaces() {
-    return new SurfacesNamespace(() => this.getClient());
-  }
-};
-
-// src/transform.ts
-function transformQueryParams(params) {
-  const result = {};
-  for (const [key, value] of Object.entries(params)) {
-    if (value !== void 0 && value !== null) {
-      if (Array.isArray(value)) {
-        result[key] = value.join(",");
-      } else {
-        result[key] = String(value);
-      }
-    }
-  }
-  return result;
-}
-
-// src/version.ts
-var FALLBACK_VERSION = "0.0.0";
-var SDK_VERSION = "9.9.0".length > 0 ? "9.9.0" : FALLBACK_VERSION;
-var RUNTYPE_CLIENT_KIND = "sdk";
-var SDK_USER_AGENT = `runtype-sdk/${SDK_VERSION} (typescript)`;
-
-// src/detached-reconnect.ts
-var TERMINAL_EVENTS = /* @__PURE__ */ new Set(["execution_complete", "execution_error"]);
-var DEFAULT_MAX_DETACHED_RECONNECTS = 12;
-function observeBlock(block, into) {
-  let eventName = null;
-  for (const line of block.split("\n")) {
-    if (line.startsWith("id:")) {
-      into.lastId = line.slice(3).trim();
-      continue;
-    }
-    if (line.startsWith("event:")) {
-      eventName = line.slice(6).trim();
-      continue;
-    }
-    if (!line.startsWith("data:")) continue;
-    const raw = line.slice(5).trim();
-    if (!raw || raw === "[DONE]") continue;
-    let payload;
-    try {
-      const parsed = JSON.parse(raw);
-      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) continue;
-      payload = parsed;
-    } catch {
-      continue;
-    }
-    if (typeof payload.executionId === "string") into.executionId = payload.executionId;
-    const type = typeof payload.type === "string" ? payload.type : eventName;
-    if (type && TERMINAL_EVENTS.has(type)) into.sawTerminal = true;
-    if (type === "await" && payload.awaitReason === "detached") into.sawDetach = true;
+    if (typeof payload.executionId === "string") into.executionId = payload.executionId;
+    const type = typeof payload.type === "string" ? payload.type : eventName;
+    if (type && TERMINAL_EVENTS.has(type)) into.sawTerminal = true;
+    if (type === "await" && payload.awaitReason === "detached") into.sawDetach = true;
   }
 }
 function withDetachedReconnect(response, reattach, options = {}) {
@@ -8508,6 +8020,13 @@ function buildEmptySessionNudge(consecutiveEmptySessions) {
 }
 
 // src/endpoints.ts
+function buildExecutionEventsPath(executionId, query = {}) {
+  const params = new URLSearchParams();
+  if (query.after) params.set("after", query.after);
+  if (query.conversationId) params.set("conversationId", query.conversationId);
+  const search = params.toString();
+  return `/executions/${encodeURIComponent(executionId)}/events${search ? `?${search}` : ""}`;
+}
 var FlowsEndpoint = class {
   constructor(client) {
     this.client = client;
@@ -9191,10 +8710,15 @@ var DispatchEndpoint = class {
   }
   /**
    * Dispatch with streaming response
+   *
+   * A dispatched agent turn runs on the durable lane, so its socket can close
+   * with `await` / `awaitReason: 'detached'` while the run continues. The
+   * stream follows that detach through the execution-scoped events alias;
+   * `autoReconnect: false` hands back the raw stream instead.
    */
-  async executeStream(data) {
+  async executeStream(data, init) {
     const normalized = normalizeDispatchRequest(data);
-    return this.client.requestStream("/dispatch", {
+    const response = await this.client.requestStream("/dispatch", {
       method: "POST",
       body: JSON.stringify({
         ...normalized,
@@ -9202,8 +8726,32 @@ var DispatchEndpoint = class {
           ...normalized.options,
           streamResponse: true
         }
-      })
+      }),
+      ...init?.signal ? { signal: init.signal } : {}
     });
+    return withDetachedReconnect(
+      response,
+      this.buildDetachedReattach(normalized, init?.signal),
+      init ?? {}
+    );
+  }
+  /**
+   * The `?after=` reattach leg a detached dispatch stream is followed with.
+   *
+   * Unlike an agent execute, a dispatch knows no agent id at the call site, so
+   * it rejoins by execution id alone through the execution-scoped alias. The
+   * cursor is the last SSE `id:` the stream delivered, forwarded verbatim.
+   */
+  buildDetachedReattach(data, signal) {
+    return async ({ executionId, after, signal: reattachSignal }) => {
+      const named = data?.conversationId;
+      const conversationId = typeof named === "string" && named ? named : void 0;
+      const legSignal = combineAbortSignals(signal, reattachSignal);
+      return this.client.requestStream(buildExecutionEventsPath(executionId, { after, conversationId }), {
+        method: "GET",
+        ...legSignal ? { signal: legSignal } : {}
+      }).catch(() => null);
+    };
   }
   /**
    * Resume paused flow execution
@@ -9337,6 +8885,14 @@ var AnalyticsEndpoint = class {
   async getEndUserUsage(params) {
     return this.client.get("/analytics/end-user-usage", params);
   }
+  /**
+   * Get reliability, latency, unit economics, and eval health for the current
+   * period against the preceding period of equal length, plus a derived feed of
+   * notable changes.
+   */
+  async getProductionHealth(params) {
+    return this.client.get("/analytics/production-health", params);
+  }
 };
 var FlowStepsEndpoint = class {
   constructor(client) {
@@ -9547,7 +9103,7 @@ var ToolsEndpoint = class {
     return this.client.get(`/tools/builtin/${toolId}/schema`);
   }
   /**
-   * Deploy code to a persistent Daytona sandbox and get a preview URL
+   * Deploy a Daytona preview; retention defaults to ten minutes and the URL is not durable hosting.
    */
   async deploySandbox(data) {
     return this.client.post("/tools/sandbox/deploy", data);
@@ -9559,7 +9115,7 @@ var ToolsEndpoint = class {
     return this.client.delete(`/tools/sandbox/${sandboxId}`);
   }
   /**
-   * Deploy code to a persistent Cloudflare Sandbox container and get a preview URL
+   * Deploy a Runtype Sandbox preview; omitted retention preserves the legacy unlimited backstop.
    */
   async deployCfSandbox(data) {
     return this.client.post("/tools/sandbox/cf-sandbox/deploy", data);
@@ -10018,14 +9574,15 @@ var _AgentsEndpoint = class _AgentsEndpoint {
    * conversation-key behavior.
    */
   buildDetachedReattach(id, data, signal) {
-    return async ({ executionId, after }) => {
+    return async ({ executionId, after, signal: reattachSignal }) => {
       const named = data?.conversationId;
       const conversationId = typeof named === "string" ? named : "";
       const query = new URLSearchParams({ after });
       if (conversationId) query.set("conversationId", conversationId);
+      const legSignal = combineAbortSignals(signal, reattachSignal);
       return this.client.requestStream(`/agents/${id}/executions/${executionId}/events?${query.toString()}`, {
         method: "GET",
-        ...signal ? { signal } : {}
+        ...legSignal ? { signal: legSignal } : {}
       }).catch(() => null);
     };
   }
@@ -12955,189 +12512,741 @@ var AgentVersionsEndpoint = class {
     return this.client.get(`/agent-versions/${agentId}/${versionId}`);
   }
   /**
-   * Publish a version (promote it to the agent's published version).
+   * Publish a version (promote it to the agent's published version).
+   */
+  async publish(agentId, versionId, options = {}) {
+    return this.client.post(`/agent-versions/${agentId}/publish`, {
+      versionId,
+      ...options
+    });
+  }
+};
+var FlowVersionsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List versions for a flow, optionally filtered by version `type`.
+   */
+  async list(flowId, params) {
+    return this.client.get(`/flow-versions/${flowId}`, params);
+  }
+  /**
+   * Get the published version for a flow.
+   */
+  async getPublished(flowId) {
+    return this.client.get(`/flow-versions/${flowId}/published`);
+  }
+  /**
+   * Get a specific version of a flow.
+   */
+  async get(flowId, versionId) {
+    return this.client.get(`/flow-versions/${flowId}/${versionId}`);
+  }
+  /**
+   * Publish a version (promote it to the flow's published version).
+   */
+  async publish(flowId, versionId, options = {}) {
+    return this.client.post(`/flow-versions/${flowId}/publish`, {
+      versionId,
+      ...options
+    });
+  }
+};
+var IntegrationsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List all integrations with the caller's per-integration configuration status.
+   */
+  async list(params) {
+    return this.client.get("/integrations", params);
+  }
+  /**
+   * Get a single integration by ID.
+   */
+  async get(integrationId) {
+    return this.client.get(`/integrations/${integrationId}`);
+  }
+  /**
+   * List integrations within a category (e.g. `slack`, `mcp`).
+   */
+  async listByCategory(category) {
+    return this.client.get(
+      `/integrations/category/${category}`
+    );
+  }
+  /**
+   * Per-environment credential status across the caller's integrations.
+   */
+  async getCredentialsStatus() {
+    return this.client.get("/integrations/credentials-status");
+  }
+  /**
+   * List all tools exposed across the caller's configured integrations.
+   */
+  async listTools() {
+    return this.client.get("/integrations/tools");
+  }
+  /**
+   * List the tools exposed by a single integration.
+   */
+  async getIntegrationTools(integrationId) {
+    return this.client.get(
+      `/integrations/${integrationId}/tools`
+    );
+  }
+  /**
+   * Get the definition of a single tool within an integration.
+   */
+  async getTool(integrationId, toolName) {
+    return this.client.get(`/integrations/${integrationId}/tools/${toolName}`);
+  }
+  /**
+   * Install a Slack integration from a completed OAuth handshake.
+   */
+  async installSlack(data) {
+    return this.client.post("/integrations/slack/install", data);
+  }
+  /**
+   * Start the Slack "Add to Slack" OAuth handshake. Returns the Slack authorize
+   * URL to open in a popup; the bot token is captured server-side by the
+   * callback (never returned to the browser).
+   */
+  async startSlackOAuth(data) {
+    return this.client.post("/oauth/slack/start", data);
+  }
+  /**
+   * Generate the Slack app manifest for a surface, plus a link to Slack's
+   * app-creation page. The manifest carries absolute API URLs derived
+   * server-side, so it is always valid for Slack (relative proxy paths never
+   * leak in). Slack's create-app modal ignores a manifest passed in the URL, so
+   * `manifestJson` is pasted into its "From a manifest" option rather than
+   * embedded in `createAppUrl`.
+   */
+  async generateSlackManifest(data) {
+    return this.client.post("/integrations/slack/manifest", data);
+  }
+  /**
+   * Report whether Slack has verified a surface's events URL. Slack sends that
+   * challenge when an app is created from a manifest, so a `verifiedAt` newer
+   * than the one read before the manifest was handed out is evidence the app
+   * now exists. Markers expire after an hour.
+   */
+  async getSlackAppStatus(surfaceId) {
+    return this.client.get(
+      `/integrations/slack/app-status?surfaceId=${encodeURIComponent(surfaceId)}`
+    );
+  }
+};
+var BillingEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get the caller's subscription status, plan limits, and current usage.
+   */
+  async getStatus() {
+    return this.client.get("/billing/status");
+  }
+  /**
+   * Get the caller's credit grants and available/used totals.
+   */
+  async getCredits() {
+    return this.client.get("/billing/credits");
+  }
+  /**
+   * Get the caller's exact current UTC-month platform spend from the local
+   * meter used for spend-cap enforcement. Returns 503 when that meter is unavailable.
+   */
+  async getCurrentSpend() {
+    return this.client.get("/billing/current-spend");
+  }
+  /**
+   * Get spend analytics. The window is controlled by either `period` or `days`
+   * (1–365, defaults to 30).
+   */
+  async getSpendAnalytics(params) {
+    return this.client.get("/billing/spend-analytics", params);
+  }
+};
+var ToolApprovalGrantsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List active remembered tool-approval grants for the authenticated owner,
+   * optionally filtered to a single agent.
+   */
+  async list(agentId) {
+    const query = agentId ? `?agentId=${encodeURIComponent(agentId)}` : "";
+    const response = await this.client.get(
+      `/tool-approval-grants${query}`
+    );
+    return response.data;
+  }
+  /**
+   * Revoke (soft-delete) a remembered grant so the tool prompts for approval
+   * again on future dispatches.
+   */
+  async revoke(id) {
+    return this.client.delete(`/tool-approval-grants/${id}`);
+  }
+};
+
+// src/runtype.ts
+var globalConfig = {};
+var globalClient = null;
+var RuntypeClient = class {
+  constructor(config = {}) {
+    const baseUrl = config.baseUrl || "https://api.runtype.com";
+    this.apiVersion = config.apiVersion || "v1";
+    this.baseUrl = this.apiVersion ? `${baseUrl}/${this.apiVersion}` : baseUrl;
+    this.timeout = config.timeout || 3e4;
+    this.headers = {
+      "Content-Type": "application/json",
+      ...config.headers || {}
+    };
+    if (config.apiKey) {
+      this.headers.Authorization = `Bearer ${config.apiKey}`;
+    }
+  }
+  /**
+   * Set the API key for authentication
+   */
+  setApiKey(apiKey) {
+    this.headers.Authorization = `Bearer ${apiKey}`;
+  }
+  /**
+   * Generic GET request
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts typed list-param interfaces (no index signature); `unknown` would reject them
+  async get(path, params) {
+    const url = this.buildUrl(path, params);
+    const response = await this.makeRequest(url, {
+      method: "GET",
+      headers: this.headers
+    });
+    return response;
+  }
+  /**
+   * Generic POST request
+   */
+  async post(path, data, extraHeaders) {
+    const url = this.buildUrl(path);
+    const response = await this.makeRequest(url, {
+      method: "POST",
+      headers: { ...this.headers, ...extraHeaders },
+      body: data ? JSON.stringify(data) : void 0
+    });
+    return response;
+  }
+  /**
+   * Generic PUT request
+   */
+  async put(path, data) {
+    const url = this.buildUrl(path);
+    const response = await this.makeRequest(url, {
+      method: "PUT",
+      headers: this.headers,
+      body: data ? JSON.stringify(data) : void 0
+    });
+    return response;
+  }
+  /**
+   * Generic PATCH request
    */
-  async publish(agentId, versionId, options = {}) {
-    return this.client.post(`/agent-versions/${agentId}/publish`, {
-      versionId,
-      ...options
+  async patch(path, data) {
+    const url = this.buildUrl(path);
+    const response = await this.makeRequest(url, {
+      method: "PATCH",
+      headers: this.headers,
+      body: data ? JSON.stringify(data) : void 0
     });
-  }
-};
-var FlowVersionsEndpoint = class {
-  constructor(client) {
-    this.client = client;
+    return response;
   }
   /**
-   * List versions for a flow, optionally filtered by version `type`.
+   * Generic DELETE request
    */
-  async list(flowId, params) {
-    return this.client.get(`/flow-versions/${flowId}`, params);
+  async delete(path) {
+    const url = this.buildUrl(path);
+    const response = await this.makeRequest(url, {
+      method: "DELETE",
+      headers: this.headers
+    });
+    return response;
   }
   /**
-   * Get the published version for a flow.
+   * Generic request that returns raw Response for streaming
    */
-  async getPublished(flowId) {
-    return this.client.get(`/flow-versions/${flowId}/published`);
+  async requestStream(path, options = {}) {
+    const url = this.buildUrl(path);
+    const headers = {
+      ...this.headers,
+      ...options.headers
+    };
+    return this.makeRawRequest(url, {
+      ...options,
+      headers
+    });
   }
   /**
-   * Get a specific version of a flow.
+   * Dispatch flow execution (streaming).
+   *
+   * This is the sole streaming-dispatch chokepoint for the flow builders
+   * (`RuntypeFlowBuilder`), so it normalizes the request to the canonical
+   * `/v1/dispatch` wire contract here — every builder path inherits the same
+   * normalization the `DispatchEndpoint` applies, with no per-builder call.
+   *
+   * A dispatched agent turn runs on the durable lane, so the stream follows a
+   * detach through {@link executionEvents}; pass `autoReconnect: false` to own
+   * the reconnect yourself.
    */
-  async get(flowId, versionId) {
-    return this.client.get(`/flow-versions/${flowId}/${versionId}`);
+  async dispatch(config, init) {
+    const normalized = normalizeDispatchRequest(config);
+    const request6 = {
+      ...normalized,
+      options: {
+        ...normalized.options,
+        streamResponse: true
+      }
+    };
+    const response = await this.requestStream("/dispatch", {
+      method: "POST",
+      body: JSON.stringify(request6),
+      ...init?.signal ? { signal: init.signal } : {}
+    });
+    const conversationId = typeof normalized.conversationId === "string" && normalized.conversationId ? normalized.conversationId : void 0;
+    return withDetachedReconnect(
+      response,
+      async ({ executionId, after, signal: reattachSignal }) => {
+        const legSignal = combineAbortSignals(init?.signal, reattachSignal);
+        return this.executionEvents(executionId, {
+          after,
+          ...conversationId ? { conversationId } : {},
+          ...legSignal ? { signal: legSignal } : {}
+        }).catch(() => null);
+      },
+      init ?? {}
+    );
   }
   /**
-   * Publish a version (promote it to the flow's published version).
+   * Dispatch flow execution (non-streaming JSON).
+   *
+   * The non-streaming sibling of {@link dispatch}; it normalizes to the same
+   * canonical wire contract so builders never post a raw, un-normalized body,
+   * and pins `streamResponse: false` so the server returns buffered JSON.
    */
-  async publish(flowId, versionId, options = {}) {
-    return this.client.post(`/flow-versions/${flowId}/publish`, {
-      versionId,
-      ...options
+  async dispatchJson(config) {
+    const normalized = normalizeDispatchRequest(config);
+    return this.post("/dispatch", {
+      ...normalized,
+      options: {
+        ...normalized.options,
+        streamResponse: false
+      }
     });
   }
-};
-var IntegrationsEndpoint = class {
-  constructor(client) {
-    this.client = client;
+  /** Start a normalized dispatch and return a durable handle immediately. */
+  async dispatchAsync(config) {
+    const normalized = normalizeDispatchRequest(config);
+    return this.post(
+      "/dispatch",
+      {
+        ...normalized,
+        options: { ...normalized.options, streamResponse: false }
+      },
+      { Prefer: "respond-async" }
+    );
+  }
+  async getExecutionStatus(executionId) {
+    return this.get(`/executions/${encodeURIComponent(executionId)}/status`);
   }
   /**
-   * List all integrations with the caller's per-integration configuration status.
+   * Rejoin a durable execution's Server-Sent Events by execution id.
+   *
+   * The execution-scoped alias of the agent events route, so a turn started
+   * through `/v1/dispatch` reconnects without knowing which agent served it.
+   * Pass the last SSE `id:` the stream delivered as `after` to replay strictly
+   * past that cursor and then live-tail while the run is still going. This is
+   * the same leg a detached dispatch stream follows on its own, exposed for a
+   * caller that stores the cursor and reattaches later or from elsewhere.
+   *
+   * @example
+   * ```typescript
+   * const events = await client.executionEvents('aex_123', { after: '118' })
+   * ```
    */
-  async list(params) {
-    return this.client.get("/integrations", params);
+  async executionEvents(executionId, opts = {}) {
+    const path = buildExecutionEventsPath(executionId, {
+      ...opts.after !== void 0 ? { after: opts.after } : {},
+      ...opts.conversationId !== void 0 ? { conversationId: opts.conversationId } : {}
+    });
+    return this.requestStream(path, {
+      method: "GET",
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
   }
   /**
-   * Get a single integration by ID.
+   * Build full URL with query parameters
    */
-  async get(integrationId) {
-    return this.client.get(`/integrations/${integrationId}`);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- mirrors get()'s permissive params type
+  buildUrl(path, params) {
+    const base = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
+    const relPath = path.startsWith("/") ? path.slice(1) : path;
+    const url = new URL(relPath, base);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      });
+    }
+    return url.toString();
   }
   /**
-   * List integrations within a category (e.g. `slack`, `mcp`).
+   * Make HTTP request with timeout and error handling
    */
-  async listByCategory(category) {
-    return this.client.get(
-      `/integrations/category/${category}`
-    );
+  async makeRequest(url, options) {
+    const response = await this.makeRawRequest(url, options);
+    if (response.status === 204) {
+      return null;
+    }
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+      return response.json();
+    }
+    return response.text();
   }
   /**
-   * Per-environment credential status across the caller's integrations.
+   * Make HTTP request that returns raw Response (for streaming)
    */
-  async getCredentialsStatus() {
-    return this.client.get("/integrations/credentials-status");
+  async makeRawRequest(url, options) {
+    const callerSignal = options.signal ?? void 0;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    const signal = combineAbortSignals(callerSignal, controller.signal) ?? controller.signal;
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `API request failed: ${response.status} ${response.statusText} - ${errorText}`
+        );
+      }
+      return response;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError" && !callerSignal?.aborted) {
+        throw new Error(`Request timeout after ${this.timeout}ms`, { cause: error });
+      }
+      throw error;
+    }
   }
+};
+var Runtype = class {
   /**
-   * List all tools exposed across the caller's configured integrations.
+   * Configure the global Runtype client
+   *
+   * Call this once at app startup to set the API key and other options.
+   * All subsequent calls to Runtype.flows, Runtype.batches, etc. will use this config.
+   *
+   * @example
+   * ```typescript
+   * Runtype.configure({ apiKey: process.env.RUNTYPE_API_KEY })
+   * ```
    */
-  async listTools() {
-    return this.client.get("/integrations/tools");
+  static configure(config) {
+    globalConfig = { ...globalConfig, ...config };
+    globalClient = new RuntypeClient(globalConfig);
   }
   /**
-   * List the tools exposed by a single integration.
+   * Get the global client instance, creating one if needed
    */
-  async getIntegrationTools(integrationId) {
-    return this.client.get(
-      `/integrations/${integrationId}/tools`
-    );
+  static getClient() {
+    if (!globalClient) {
+      globalClient = new RuntypeClient(globalConfig);
+    }
+    return globalClient;
   }
   /**
-   * Get the definition of a single tool within an integration.
+   * Create a new client instance with custom configuration
+   *
+   * Use this when you need a client with different settings than the global one.
+   *
+   * @example
+   * ```typescript
+   * const client = Runtype.createClient({ apiKey: 'different_key' })
+   * ```
    */
-  async getTool(integrationId, toolName) {
-    return this.client.get(`/integrations/${integrationId}/tools/${toolName}`);
+  static createClient(config) {
+    return new RuntypeClient({ ...globalConfig, ...config });
   }
   /**
-   * Install a Slack integration from a completed OAuth handshake.
+   * Flows namespace - Build and execute flows
+   *
+   * @example
+   * ```typescript
+   * // Upsert a flow (create or update)
+   * const result = await Runtype.flows.upsert({ name: 'My Flow' })
+   *   .prompt({ name: 'Analyze', model: 'gpt-4o', userPrompt: '...' })
+   *   .stream()
+   *
+   * // Use an existing flow
+   * const result = await Runtype.flows.use('flow_123')
+   *   .withRecord({ name: 'Test' })
+   *   .result()
+   *
+   * // Virtual flow (one-off, not saved)
+   * const result = await Runtype.flows.virtual({ name: 'Temp Flow' })
+   *   .prompt({ ... })
+   *   .stream()
+   * ```
    */
-  async installSlack(data) {
-    return this.client.post("/integrations/slack/install", data);
+  static get flows() {
+    return new FlowsNamespace(() => this.getClient());
   }
   /**
-   * Start the Slack "Add to Slack" OAuth handshake. Returns the Slack authorize
-   * URL to open in a popup; the bot token is captured server-side by the
-   * callback (never returned to the browser).
+   * Batches namespace - Schedule and manage batch operations
+   *
+   * @example
+   * ```typescript
+   * // Schedule a batch
+   * const batch = await Runtype.batches.schedule({
+   *   flowId: 'flow_123',
+   *   recordType: 'customers',
+   * })
+   *
+   * // Get batch status
+   * const status = await Runtype.batches.get('batch_456')
+   *
+   * // Cancel a batch
+   * await Runtype.batches.cancel('batch_456')
+   *
+   * // List batches
+   * const batches = await Runtype.batches.list({ status: 'running' })
+   * ```
    */
-  async startSlackOAuth(data) {
-    return this.client.post("/oauth/slack/start", data);
+  static get batches() {
+    return new BatchesNamespace(() => this.getClient());
   }
   /**
-   * Generate the Slack app manifest for a surface, plus a link to Slack's
-   * app-creation page. The manifest carries absolute API URLs derived
-   * server-side, so it is always valid for Slack (relative proxy paths never
-   * leak in). Slack's create-app modal ignores a manifest passed in the URL, so
-   * `manifestJson` is pasted into its "From a manifest" option rather than
-   * embedded in `createAppUrl`.
+   * Evals namespace - Run evaluations and compare models
+   *
+   * @example
+   * ```typescript
+   * // Run an eval with streaming
+   * const stream = await Runtype.evals.run({
+   *   flowId: 'flow_123',
+   *   recordType: 'test_data',
+   *   models: [{ stepName: 'Analyze', model: 'gpt-4o' }]
+   * }).stream()
+   *
+   * // Submit eval as batch job
+   * const eval = await Runtype.evals.run({
+   *   flowId: 'flow_123',
+   *   recordType: 'test_data',
+   *   models: [
+   *     [{ stepName: 'Analyze', model: 'gpt-5.4' }],
+   *     [{ stepName: 'Analyze', model: 'claude-opus-4-6' }],
+   *   ]
+   * }).submit()
+   * ```
    */
-  async generateSlackManifest(data) {
-    return this.client.post("/integrations/slack/manifest", data);
+  static get evals() {
+    return new EvalsNamespace(() => this.getClient());
   }
   /**
-   * Report whether Slack has verified a surface's events URL. Slack sends that
-   * challenge when an app is created from a manifest, so a `verifiedAt` newer
-   * than the one read before the manifest was handed out is evidence the app
-   * now exists. Markers expire after an hour.
+   * Prompts namespace - Manage and execute prompts
+   *
+   * @example
+   * ```typescript
+   * // Execute a prompt with streaming
+   * const stream = await Runtype.prompts.run('prompt_123', {
+   *   recordId: 'rec_456'
+   * }).stream()
+   *
+   * // Get complete result
+   * const result = await Runtype.prompts.run('prompt_123', {
+   *   recordId: 'rec_456'
+   * }).result()
+   *
+   * // CRUD operations
+   * const prompts = await Runtype.prompts.list()
+   * const prompt = await Runtype.prompts.get('prompt_123')
+   * const newPrompt = await Runtype.prompts.create({ ... })
+   * await Runtype.prompts.update('prompt_123', { ... })
+   * await Runtype.prompts.delete('prompt_123')
+   * ```
    */
-  async getSlackAppStatus(surfaceId) {
-    return this.client.get(
-      `/integrations/slack/app-status?surfaceId=${encodeURIComponent(surfaceId)}`
-    );
-  }
-};
-var BillingEndpoint = class {
-  constructor(client) {
-    this.client = client;
+  static get prompts() {
+    return new PromptsNamespace(() => this.getClient());
   }
   /**
-   * Get the caller's subscription status, plan limits, and current usage.
+   * Skills namespace - Manage Agent Skills (admin/control plane)
+   *
+   * @example
+   * ```typescript
+   * // Create a published skill from a SKILL.md document
+   * const { skill } = await Runtype.skills.create({ markdown: skillMd, publish: true })
+   *
+   * // Bind it to an agent
+   * await Runtype.skills.bind({ agentId: 'agent_123', skillId: skill.id })
+   *
+   * // Review agent-authored proposals
+   * const pending = await Runtype.skills.proposals.list()
+   * await Runtype.skills.proposals.approve(pending[0].id)
+   * ```
    */
-  async getStatus() {
-    return this.client.get("/billing/status");
+  static get skills() {
+    return new SkillsNamespace(() => this.getClient());
   }
   /**
-   * Get the caller's credit grants and available/used totals.
+   * Agents namespace - Agent config-as-code (define / ensure / pull)
+   *
+   * @example
+   * ```typescript
+   * import { defineAgent, Runtype } from '@runtypelabs/sdk'
+   *
+   * const assistant = defineAgent({
+   *   name: 'Pricing Assistant',
+   *   model: 'claude-sonnet-4-6',
+   *   systemPrompt: renderPrompt(pricingData),
+   * })
+   *
+   * // Converge at deploy time (idempotent; one tiny probe in steady state)
+   * await Runtype.agents.ensure(assistant)
+   *
+   * // CI drift gate
+   * await Runtype.agents.ensure(assistant, { expectNoChanges: true })
+   *
+   * // Absorb a dashboard edit back into the repo
+   * const { definition } = await Runtype.agents.pull('Pricing Assistant')
+   * ```
    */
-  async getCredits() {
-    return this.client.get("/billing/credits");
+  static get agents() {
+    return new AgentsNamespace(() => this.getClient());
   }
-  /**
-   * Get the caller's exact current UTC-month platform spend from the local
-   * meter used for spend-cap enforcement. Returns 503 when that meter is unavailable.
-   */
-  async getCurrentSpend() {
-    return this.client.get("/billing/current-spend");
+  /** Poll durable handles returned by asynchronous execute operations. */
+  static get executions() {
+    return new ExecutionsNamespace(() => this.getClient());
   }
   /**
-   * Get spend analytics. The window is controlled by either `period` or `days`
-   * (1–365, defaults to 30).
+   * Tools namespace - Tool config-as-code (define / ensure / pull)
+   *
+   * @example
+   * ```typescript
+   * import { defineTool, Runtype } from '@runtypelabs/sdk'
+   *
+   * const weather = defineTool({
+   *   name: 'Weather Lookup',
+   *   description: 'Fetch the current weather for a city',
+   *   toolType: 'external',
+   *   parametersSchema: { type: 'object', properties: { city: { type: 'string' } } },
+   *   config: { url: 'https://api.example.com/weather', method: 'GET' },
+   * })
+   *
+   * // Converge at deploy time (idempotent; one tiny probe in steady state)
+   * await Runtype.tools.ensure(weather)
+   *
+   * // CI drift gate
+   * await Runtype.tools.ensure(weather, { expectNoChanges: true })
+   *
+   * // Absorb a dashboard edit back into the repo
+   * const { definition } = await Runtype.tools.pull('Weather Lookup')
+   * ```
    */
-  async getSpendAnalytics(params) {
-    return this.client.get("/billing/spend-analytics", params);
-  }
-};
-var ToolApprovalGrantsEndpoint = class {
-  constructor(client) {
-    this.client = client;
+  static get tools() {
+    return new ToolsNamespace(() => this.getClient());
   }
   /**
-   * List active remembered tool-approval grants for the authenticated owner,
-   * optionally filtered to a single agent.
+   * Products namespace - Product config-as-code (define / ensure / pull)
+   *
+   * Converges the top-level product record (description, icon, spec). Nested
+   * capabilities/surfaces/tools and the canvas UI layout state are not
+   * converged by ensure.
+   *
+   * @example
+   * ```typescript
+   * import { defineProduct, Runtype } from '@runtypelabs/sdk'
+   *
+   * const product = defineProduct({
+   *   name: 'Support Copilot',
+   *   description: 'An AI support assistant',
+   *   icon: '🤖',
+   *   spec: { productGoal: 'Deflect tier-1 tickets', productStage: 'beta' },
+   * })
+   *
+   * // Converge at deploy time (idempotent; one tiny probe in steady state)
+   * await Runtype.products.ensure(product)
+   *
+   * // CI drift gate
+   * await Runtype.products.ensure(product, { expectNoChanges: true })
+   *
+   * // Absorb a dashboard edit back into the repo
+   * const { definition } = await Runtype.products.pull('Support Copilot')
+   * ```
    */
-  async list(agentId) {
-    const query = agentId ? `?agentId=${encodeURIComponent(agentId)}` : "";
-    const response = await this.client.get(
-      `/tool-approval-grants${query}`
-    );
-    return response.data;
+  static get products() {
+    return new ProductsNamespace(() => this.getClient());
   }
   /**
-   * Revoke (soft-delete) a remembered grant so the tool prompts for approval
-   * again on future dispatches.
+   * Config-as-code operations for product surfaces. `surfaces.ensure` is the
+   * deploy-time, non-executing converge (create-or-update a surface by name
+   * within a product); `surfaces.pull` is the absorb-drift direction.
+   *
+   * @example
+   * ```typescript
+   * import { Runtype, defineSurface } from '@runtypelabs/sdk'
+   *
+   * const chat = defineSurface({
+   *   name: 'Support Chat',
+   *   type: 'chat',
+   *   behavior: { type: 'chat', greeting: 'Hi there!' },
+   *   status: 'active',
+   * })
+   *
+   * // Converge at deploy time (idempotent; one tiny probe in steady state)
+   * await Runtype.surfaces.ensure('product_abc', chat)
+   *
+   * // CI drift gate
+   * await Runtype.surfaces.ensure('product_abc', chat, { expectNoChanges: true })
+   *
+   * // Absorb a dashboard edit back into the repo
+   * const { definition } = await Runtype.surfaces.pull('product_abc', 'Support Chat')
+   * ```
    */
-  async revoke(id) {
-    return this.client.delete(`/tool-approval-grants/${id}`);
+  static get surfaces() {
+    return new SurfacesNamespace(() => this.getClient());
   }
 };
 
+// src/transform.ts
+function transformQueryParams(params) {
+  const result = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== null) {
+      if (Array.isArray(value)) {
+        result[key] = value.join(",");
+      } else {
+        result[key] = String(value);
+      }
+    }
+  }
+  return result;
+}
+
+// src/version.ts
+var FALLBACK_VERSION = "0.0.0";
+var SDK_VERSION = "9.10.0".length > 0 ? "9.10.0" : FALLBACK_VERSION;
+var RUNTYPE_CLIENT_KIND = "sdk";
+var SDK_USER_AGENT = `runtype-sdk/${SDK_VERSION} (typescript)`;
+
 // src/client.ts
 function isObjectRecord(value) {
   return typeof value === "object" && value !== null;
@@ -14476,12 +14585,14 @@ export {
   attachRuntimeToolsToDispatchRequest,
   buildAgentAdmissionHeaders,
   buildEmptySessionNudge,
+  buildExecutionEventsPath,
   buildGeneratedRuntimeToolGateOutput,
   buildLedgerOffloadReference,
   buildObservationMaskMarker,
   buildPolicyGuidance,
   buildSendViewOffloadMarker,
   calledTool,
+  combineAbortSignals,
   compileWorkflowConfig,
   completed,
   computeAgentContentHash,