@modelrelay/sdk 1.42.0 → 2.1.0

package/dist/index.js

@@ -48,11 +48,6 @@ import {
   getRetryableErrors,
   hasRetryableErrors,
   hasToolCalls,
-  isAutoProvisionDisabled,
-  isAutoProvisionMisconfigured,
-  isEmailRequired,
-  isIdentityRequired,
-  isProvisioningError,
   mergeMetrics,
   mergeTrace,
   modelToString,
@@ -69,39 +64,27 @@ import {
   toolResultMessage,
   tryParseToolArgs,
   zodToJsonSchema
-} from "./chunk-PLZWDUOP.js";
+} from "./chunk-AZD5EKLV.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";
 
 // src/api_keys.ts
-var PUBLISHABLE_PREFIX = "mr_pk_";
 var SECRET_PREFIX = "mr_sk_";
 function keyKindHint(raw) {
   const value = raw?.trim?.() ? raw.trim() : "";
-  if (value.startsWith(PUBLISHABLE_PREFIX)) return "publishable";
   if (value.startsWith(SECRET_PREFIX)) return "secret";
   return "unknown";
 }
 function parseApiKey(raw) {
   const value = raw?.trim?.() ? raw.trim() : "";
-  if (value.startsWith(PUBLISHABLE_PREFIX) && value.length > PUBLISHABLE_PREFIX.length) {
-    return value;
-  }
   if (value.startsWith(SECRET_PREFIX) && value.length > SECRET_PREFIX.length) {
     return value;
   }
-  throw new ConfigError("Invalid API key format (expected mr_pk_* or mr_sk_*)", {
+  throw new ConfigError("Invalid API key format (expected mr_sk_*)", {
     keyKind: keyKindHint(raw)
   });
 }
-function parsePublishableKey(raw) {
-  const key = parseApiKey(raw);
-  if (!isPublishableKey(key)) {
-    throw new ConfigError("Publishable key required (expected mr_pk_*)", { keyKind: keyKindHint(raw) });
-  }
-  return key;
-}
 function parseSecretKey(raw) {
   const key = parseApiKey(raw);
   if (!isSecretKey(key)) {
@@ -109,9 +92,6 @@ function parseSecretKey(raw) {
   }
   return key;
 }
-function isPublishableKey(key) {
-  return key.startsWith(PUBLISHABLE_PREFIX);
-}
 function isSecretKey(key) {
   return key.startsWith(SECRET_PREFIX);
 }
@@ -125,102 +105,15 @@ function createAccessTokenAuth(accessToken) {
 }
 var AuthClient = class {
   constructor(http, cfg) {
-    this.cachedFrontend = /* @__PURE__ */ new Map();
     this.http = http;
     this.apiKey = cfg.apiKey ? parseApiKey(cfg.apiKey) : void 0;
-    this.apiKeyIsPublishable = this.apiKey ? isPublishableKey(this.apiKey) : false;
     this.accessToken = cfg.accessToken;
-    this.customer = cfg.customer;
     this.tokenProvider = cfg.tokenProvider;
   }
-  /**
-   * Exchange a publishable key for a short-lived frontend token for an existing customer.
-   * Tokens are cached until they are close to expiry.
-   *
-   * Use this method when the customer already exists in the system.
-   * For auto-provisioning new customers, use frontendTokenAutoProvision instead.
-   */
-  async frontendToken(request) {
-    if (!request.publishableKey?.trim()) {
-      throw new ConfigError("publishableKey is required");
-    }
-    if (!request.identityProvider?.trim()) {
-      throw new ConfigError("identityProvider is required");
-    }
-    if (!request.identitySubject?.trim()) {
-      throw new ConfigError("identitySubject is required");
-    }
-    return this.sendFrontendTokenRequest(request);
-  }
-  /**
-   * Exchange a publishable key for a frontend token, creating the customer if needed.
-   * The customer will be auto-provisioned on the project's free tier.
-   * Tokens are cached until they are close to expiry.
-   *
-   * Use this method when the customer may not exist and should be created automatically.
-   * The email is required for auto-provisioning.
-   */
-  async frontendTokenAutoProvision(request) {
-    if (!request.publishableKey?.trim()) {
-      throw new ConfigError("publishableKey is required");
-    }
-    if (!request.identityProvider?.trim()) {
-      throw new ConfigError("identityProvider is required");
-    }
-    if (!request.identitySubject?.trim()) {
-      throw new ConfigError("identitySubject is required");
-    }
-    if (!request.email?.trim()) {
-      throw new ConfigError("email is required for auto-provisioning");
-    }
-    return this.sendFrontendTokenRequest(request);
-  }
-  /**
-   * Internal method to send frontend token requests.
-   */
-  async sendFrontendTokenRequest(request) {
-    const { publishableKey, identityProvider, identitySubject, deviceId, ttlSeconds } = request;
-    const email = "email" in request ? request.email : void 0;
-    const cacheKey = `${publishableKey}:${identityProvider}:${identitySubject}:${deviceId || ""}`;
-    const cached = this.cachedFrontend.get(cacheKey);
-    if (cached && isTokenReusable(cached)) {
-      return cached;
-    }
-    const payload = {
-      publishable_key: publishableKey,
-      identity_provider: identityProvider,
-      identity_subject: identitySubject
-    };
-    if (deviceId) {
-      payload.device_id = deviceId;
-    }
-    if (typeof ttlSeconds === "number" && ttlSeconds > 0) {
-      payload.ttl_seconds = ttlSeconds;
-    }
-    if (email) {
-      payload.email = email;
-    }
-    const response = await this.http.json(
-      "/auth/frontend-token",
-      {
-        method: "POST",
-        body: payload
-      }
-    );
-    const token = normalizeFrontendToken(response, {
-      publishableKey,
-      deviceId,
-      identityProvider,
-      identitySubject
-    });
-    this.cachedFrontend.set(cacheKey, token);
-    return token;
-  }
   /**
    * Determine the correct auth headers for /responses.
-   * Publishable keys are automatically exchanged for frontend tokens.
    */
-  async authForResponses(overrides) {
+  async authForResponses() {
     if (this.accessToken) {
       return createAccessTokenAuth(this.accessToken);
     }
@@ -234,32 +127,6 @@ var AuthClient = class {
     if (!this.apiKey) {
       throw new ConfigError("API key or token is required");
     }
-    if (this.apiKeyIsPublishable) {
-      const publishableKey = this.apiKey;
-      const identityProvider = overrides?.provider || this.customer?.provider;
-      const identitySubject = overrides?.subject || this.customer?.subject;
-      const deviceId = overrides?.deviceId || this.customer?.deviceId;
-      const ttlSeconds = overrides?.ttlSeconds ?? this.customer?.ttlSeconds;
-      const email = overrides?.email || this.customer?.email;
-      if (!identityProvider || !identitySubject) {
-        throw new ConfigError("identity provider + subject are required to mint a frontend token");
-      }
-      const token = email ? await this.frontendTokenAutoProvision({
-        publishableKey,
-        identityProvider,
-        identitySubject,
-        email,
-        deviceId,
-        ttlSeconds
-      }) : await this.frontendToken({
-        publishableKey,
-        identityProvider,
-        identitySubject,
-        deviceId,
-        ttlSeconds
-      });
-      return createAccessTokenAuth(token.token);
-    }
     return createApiKeyAuth(this.apiKey);
   }
   /**
@@ -274,7 +141,7 @@ var AuthClient = class {
     if (request.ttlSeconds !== void 0 && request.ttlSeconds < 0) {
       throw new ConfigError("ttlSeconds must be non-negative when provided");
     }
-    if (!this.apiKey || this.apiKeyIsPublishable) {
+    if (!this.apiKey) {
       throw new ConfigError("Secret API key is required to mint customer tokens");
     }
     const payload = {};
@@ -299,44 +166,54 @@ var AuthClient = class {
       tokenType: apiResp.token_type,
       projectId: apiResp.project_id,
       customerId: apiResp.customer_id,
+      billingProfileId: apiResp.billing_profile_id,
       customerExternalId: apiResp.customer_external_id,
       tierCode: apiResp.tier_code ? asTierCode(apiResp.tier_code) : void 0
     };
   }
   /**
-   * Verify an OIDC id_token and exchange it for a customer bearer token.
+   * Get or create a customer and mint a bearer token.
+   *
+   * This is a convenience method that:
+   * 1. Upserts the customer (creates if not exists)
+   * 2. Mints a customer-scoped bearer token
+   *
+   * Use this when you want to ensure the customer exists before minting a token,
+   * without needing to handle 404 errors from customerToken().
+   *
+   * Requires a secret key.
    */
-  async oidcExchange(request) {
-    const idToken = request.idToken?.trim();
-    if (!idToken) {
-      throw new ConfigError("idToken is required");
+  async getOrCreateCustomerToken(request) {
+    const externalId = request.externalId?.trim();
+    const email = request.email?.trim();
+    if (!externalId) {
+      throw new ConfigError("externalId is required");
+    }
+    if (!email) {
+      throw new ConfigError("email is required");
     }
     if (!this.apiKey) {
-      throw new ConfigError("API key is required for OIDC exchange");
+      throw new ConfigError("Secret API key is required to get or create customer tokens");
     }
-    const payload = { id_token: idToken };
-    const projectId = request.projectId?.trim();
-    if (projectId) {
-      payload.project_id = projectId;
+    const upsertPayload = {
+      external_id: externalId,
+      email
+    };
+    if (request.metadata) {
+      upsertPayload.metadata = request.metadata;
     }
-    const apiResp = await this.http.json("/auth/oidc/exchange", {
-      method: "POST",
-      body: payload,
+    await this.http.json("/customers", {
+      method: "PUT",
+      body: upsertPayload,
       apiKey: this.apiKey
     });
-    return {
-      token: apiResp.token,
-      expiresAt: new Date(apiResp.expires_at),
-      expiresIn: apiResp.expires_in,
-      tokenType: apiResp.token_type,
-      projectId: apiResp.project_id,
-      customerId: apiResp.customer_id,
-      customerExternalId: apiResp.customer_external_id,
-      tierCode: apiResp.tier_code ? asTierCode(apiResp.tier_code) : void 0
-    };
+    return this.customerToken({
+      customerExternalId: externalId,
+      ttlSeconds: request.ttlSeconds
+    });
   }
   /**
-   * Billing calls accept either bearer tokens or API keys (including publishable keys).
+   * Billing calls accept either bearer tokens or API keys.
    */
   authForBilling() {
     if (this.accessToken) {
@@ -347,207 +224,7 @@ var AuthClient = class {
     }
     return createApiKeyAuth(this.apiKey);
   }
-  /**
-   * Start a device authorization flow (RFC 8628).
-   *
-   * @param request - Optional request options
-   * @param request.provider - Set to "github" to use GitHub's native device flow
-   *
-   * @example Wrapped flow (default)
-   * ```typescript
-   * const auth = await client.auth.deviceStart();
-   * console.log(`Go to ${auth.verificationUri} and enter code: ${auth.userCode}`);
-   * ```
-   *
-   * @example Native GitHub flow
-   * ```typescript
-   * const auth = await client.auth.deviceStart({ provider: "github" });
-   * // verificationUri will be "https://github.com/login/device"
-   * console.log(`Go to ${auth.verificationUri} and enter code: ${auth.userCode}`);
-   * ```
-   */
-  async deviceStart(request) {
-    if (!this.apiKey) {
-      throw new ConfigError("API key is required to start device flow");
-    }
-    const params = new URLSearchParams();
-    if (request?.provider) {
-      params.set("provider", request.provider);
-    }
-    const queryString = params.toString();
-    const path = queryString ? `/auth/device/start?${queryString}` : "/auth/device/start";
-    const apiResp = await this.http.json(path, {
-      method: "POST",
-      apiKey: this.apiKey
-    });
-    return {
-      deviceCode: apiResp.device_code,
-      userCode: apiResp.user_code,
-      verificationUri: apiResp.verification_uri,
-      verificationUriComplete: apiResp.verification_uri_complete,
-      expiresAt: new Date(Date.now() + apiResp.expires_in * 1e3),
-      interval: apiResp.interval
-    };
-  }
-  /**
-   * Poll the device token endpoint for authorization completion.
-   *
-   * Returns a discriminated union:
-   * - `{ status: "approved", token }` - User authorized, token available
-   * - `{ status: "pending", pending }` - User hasn't authorized yet, keep polling
-   * - `{ status: "error", error }` - Authorization failed (expired, denied, etc.)
-   *
-   * @param deviceCode - The device code from deviceStart()
-   *
-   * @example
-   * ```typescript
-   * const auth = await client.auth.deviceStart({ provider: "github" });
-   * console.log(`Go to ${auth.verificationUri} and enter: ${auth.userCode}`);
-   *
-   * let interval = auth.interval;
-   * while (true) {
-   *   await sleep(interval * 1000);
-   *   const result = await client.auth.deviceToken(auth.deviceCode);
-   *
-   *   if (result.status === "approved") {
-   *     console.log("Token:", result.token.token);
-   *     break;
-   *   } else if (result.status === "pending") {
-   *     if (result.pending.interval) interval = result.pending.interval;
-   *     continue;
-   *   } else {
-   *     throw new Error(`Authorization failed: ${result.error}`);
-   *   }
-   * }
-   * ```
-   */
-  async deviceToken(deviceCode) {
-    if (!this.apiKey) {
-      throw new ConfigError("API key is required to poll device token");
-    }
-    if (!deviceCode?.trim()) {
-      throw new ConfigError("deviceCode is required");
-    }
-    try {
-      const apiResp = await this.http.json("/auth/device/token", {
-        method: "POST",
-        body: { device_code: deviceCode },
-        apiKey: this.apiKey
-      });
-      return {
-        status: "approved",
-        token: {
-          token: apiResp.token,
-          expiresAt: new Date(apiResp.expires_at),
-          expiresIn: apiResp.expires_in,
-          tokenType: "Bearer",
-          projectId: apiResp.project_id,
-          customerId: apiResp.customer_id,
-          customerExternalId: apiResp.customer_external_id,
-          tierCode: apiResp.tier_code ? asTierCode(apiResp.tier_code) : void 0
-        }
-      };
-    } catch (err) {
-      if (err instanceof APIError && err.status === 400) {
-        const data = err.data;
-        const errorCode = data?.error || err.code || "unknown";
-        if (errorCode === "authorization_pending" || errorCode === "slow_down") {
-          return {
-            status: "pending",
-            pending: {
-              error: errorCode,
-              errorDescription: data?.error_description,
-              interval: data?.interval
-            }
-          };
-        }
-        return {
-          status: "error",
-          error: errorCode,
-          errorDescription: data?.error_description || err.message
-        };
-      }
-      throw err;
-    }
-  }
-  /**
-   * Start an OAuth flow for customer authentication.
-   *
-   * This initiates the OAuth redirect flow where users authenticate with
-   * GitHub or Google and are redirected back to your application with a
-   * customer token.
-   *
-   * @param request - OAuth start parameters
-   * @param request.projectId - The project ID to authenticate against
-   * @param request.provider - OAuth provider: "github" or "google"
-   * @param request.redirectUri - Where to redirect after OAuth. Must be in project's whitelist.
-   * @returns Promise with the redirect URL
-   *
-   * @example
-   * ```typescript
-   * const { redirectUrl } = await client.auth.oauthStart({
-   *   projectId: "your-project-id",
-   *   provider: "github",
-   *   redirectUri: "https://your-app.com/auth/callback",
-   * });
-   *
-   * // Redirect user to the OAuth provider
-   * window.location.href = redirectUrl;
-   *
-   * // After OAuth, your callback receives a POST with:
-   * // token, token_type, expires_at, expires_in, project_id, customer_id, customer_external_id, tier_code
-   * ```
-   */
-  async oauthStart(request) {
-    if (!request.projectId?.trim()) {
-      throw new ConfigError("projectId is required");
-    }
-    if (!request.provider?.trim()) {
-      throw new ConfigError("provider is required");
-    }
-    if (!request.redirectUri?.trim()) {
-      throw new ConfigError("redirectUri is required");
-    }
-    const apiResp = await this.http.json(
-      "/auth/customer/oauth/start",
-      {
-        method: "POST",
-        body: {
-          project_id: request.projectId,
-          provider: request.provider,
-          redirect_uri: request.redirectUri
-        }
-      }
-    );
-    return {
-      redirectUrl: apiResp.redirect_url
-    };
-  }
 };
-function normalizeFrontendToken(payload, meta) {
-  return {
-    token: payload.token,
-    expiresAt: new Date(payload.expires_at),
-    expiresIn: payload.expires_in,
-    tokenType: payload.token_type,
-    keyId: payload.key_id,
-    sessionId: payload.session_id,
-    projectId: payload.project_id,
-    customerId: payload.customer_id,
-    customerExternalId: payload.customer_external_id,
-    tierCode: payload.tier_code,
-    publishableKey: meta.publishableKey,
-    deviceId: meta.deviceId,
-    identityProvider: meta.identityProvider,
-    identitySubject: meta.identitySubject
-  };
-}
-function isTokenReusable(token) {
-  if (!token.token) {
-    return false;
-  }
-  return token.expiresAt.getTime() - Date.now() > 6e4;
-}
 
 // src/structured.ts
 var StructuredDecodeError = class extends Error {
@@ -1604,7 +1281,7 @@ var ResponsesClient = class {
    * import { z } from 'zod';
    *
    * const review = await client.responses.object({
-   *   model: 'claude-sonnet-4-20250514',
+   *   model: 'claude-sonnet-4-5',
    *   schema: z.object({
    *     vulnerabilities: z.array(z.string()),
    *     riskLevel: z.enum(['low', 'medium', 'high']),
@@ -1661,7 +1338,7 @@ var ResponsesClient = class {
    * @example
    * ```typescript
    * const result = await client.responses.objectWithMetadata({
-   *   model: 'claude-sonnet-4-20250514',
+   *   model: 'claude-sonnet-4-5',
    *   schema: ReviewSchema,
    *   prompt: 'Review this code...',
    * });
@@ -2070,7 +1747,6 @@ var ResponsesClient = class {
 
 // src/runs_request.ts
 var RUNS_PATH = "/runs";
-var WORKFLOW_V0_SCHEMA_PATH = "/schemas/workflow_v0.schema.json";
 var RUN_EVENT_V0_SCHEMA_PATH = "/schemas/run_event_v0.schema.json";
 function runByIdPath(runId) {
   return `${RUNS_PATH}/${encodeURIComponent(runId)}`;
@@ -2128,14 +1804,8 @@ function parseOutputName(raw) {
 
 // src/runs_types.ts
 var WorkflowKinds = {
-  WorkflowV0: "workflow.v0",
   WorkflowV1: "workflow.v1"
 };
-var WorkflowNodeTypes = {
-  LLMResponses: "llm.responses",
-  JoinAll: "join.all",
-  TransformJSON: "transform.json"
-};
 var WorkflowNodeTypesV1 = {
   LLMResponses: "llm.responses",
   RouteSwitch: "route.switch",
@@ -2524,22 +2194,6 @@ var RunsClient = class {
     });
     return { ...out, run_id: parseRunId(out.run_id), plan_hash: parsePlanHash(out.plan_hash) };
   }
-  async schemaV0(options = {}) {
-    const metrics = mergeMetrics(this.metrics, options.metrics);
-    const trace = mergeTrace(this.trace, options.trace);
-    return this.http.json(WORKFLOW_V0_SCHEMA_PATH, {
-      method: "GET",
-      headers: options.headers,
-      signal: options.signal,
-      timeoutMs: options.timeoutMs,
-      connectTimeoutMs: options.connectTimeoutMs,
-      retry: options.retry,
-      metrics,
-      trace,
-      context: { method: "GET", path: WORKFLOW_V0_SCHEMA_PATH },
-      accept: "application/schema+json"
-    });
-  }
   async runEventSchemaV0(options = {}) {
     const metrics = mergeMetrics(this.metrics, options.metrics);
     const trace = mergeTrace(this.trace, options.trace);
@@ -2714,65 +2368,6 @@ var WorkflowsClient = class {
     this.metrics = cfg.metrics;
     this.trace = cfg.trace;
   }
-  async compileV0(spec, options = {}) {
-    const metrics = mergeMetrics(this.metrics, options.metrics);
-    const trace = mergeTrace(this.trace, options.trace);
-    const authHeaders = await this.auth.authForResponses();
-    const headers = { ...options.headers || {} };
-    const customerId = options.customerId?.trim();
-    if (customerId) {
-      headers[CUSTOMER_ID_HEADER] = customerId;
-    }
-    try {
-      const out = await this.http.json(
-        WORKFLOWS_COMPILE_PATH,
-        {
-          method: "POST",
-          headers,
-          body: spec,
-          signal: options.signal,
-          apiKey: authHeaders.apiKey,
-          accessToken: authHeaders.accessToken,
-          timeoutMs: options.timeoutMs,
-          connectTimeoutMs: options.connectTimeoutMs,
-          retry: options.retry,
-          metrics,
-          trace,
-          context: { method: "POST", path: WORKFLOWS_COMPILE_PATH }
-        }
-      );
-      return {
-        ok: true,
-        plan_json: out.plan_json,
-        plan_hash: parsePlanHash(out.plan_hash)
-      };
-    } catch (err) {
-      if (err instanceof WorkflowValidationError) {
-        return { ok: false, error_type: "validation_error", issues: err.issues };
-      }
-      if (err instanceof APIError) {
-        return {
-          ok: false,
-          error_type: "internal_error",
-          status: err.status ?? 0,
-          message: err.message,
-          code: err.code,
-          requestId: err.requestId
-        };
-      }
-      if (err instanceof ModelRelayError && err.category === "api") {
-        return {
-          ok: false,
-          error_type: "internal_error",
-          status: err.status ?? 0,
-          message: err.message,
-          code: err.code,
-          requestId: err.requestId
-        };
-      }
-      throw err;
-    }
-  }
   async compileV1(spec, options = {}) {
     const metrics = mergeMetrics(this.metrics, options.metrics);
     const trace = mergeTrace(this.trace, options.trace);
@@ -3278,7 +2873,7 @@ var LocalSession = class _LocalSession {
       const input = await this.buildInput(options);
       const tools = mergeTools(this.defaultTools, options.tools);
       const spec = {
-        kind: "workflow.v0",
+        kind: "workflow.v1",
         name: `session-${this.id}-turn-${this.nextSeq}`,
         nodes: [
           {
@@ -3591,21 +3186,34 @@ function mergeTools(defaults, overrides) {
   }
   return Array.from(merged.values());
 }
+function isOutputMessage(item) {
+  return typeof item === "object" && item !== null && "type" in item && typeof item.type === "string";
+}
+function isContentPiece(c) {
+  return typeof c === "object" && c !== null && "type" in c && typeof c.type === "string";
+}
+function hasOutputArray(obj) {
+  return "output" in obj && Array.isArray(obj.output);
+}
+function hasContentArray(obj) {
+  return "content" in obj && Array.isArray(obj.content);
+}
 function extractTextOutput(outputs) {
   const result = outputs.result;
   if (typeof result === "string") return result;
   if (result && typeof result === "object") {
-    const resp = result;
-    if (Array.isArray(resp.output)) {
-      const textParts = resp.output.filter((item) => item?.type === "message" && item?.role === "assistant").flatMap(
-        (item) => (item.content || []).filter((c) => c?.type === "text").map((c) => c.text)
-      );
+    if (hasOutputArray(result)) {
+      const textParts = result.output.filter(
+        (item) => isOutputMessage(item) && item.type === "message" && item.role === "assistant"
+      ).flatMap(
+        (item) => (item.content || []).filter((c) => isContentPiece(c) && c.type === "text").map((c) => c.text ?? "")
+      ).filter((text) => text.length > 0);
       if (textParts.length > 0) {
         return textParts.join("\n");
       }
     }
-    if (Array.isArray(resp.content)) {
-      const textParts = resp.content.filter((c) => c?.type === "text").map((c) => c.text);
+    if (hasContentArray(result)) {
+      const textParts = result.content.filter((c) => isContentPiece(c) && c.type === "text").map((c) => c.text ?? "").filter((text) => text.length > 0);
       if (textParts.length > 0) {
         return textParts.join("\n");
       }
@@ -3637,7 +3245,7 @@ var RemoteSession = class _RemoteSession {
     this.http = http;
     this.id = asSessionId(sessionData.id);
     this.metadata = sessionData.metadata;
-    this.endUserId = sessionData.end_user_id || options.endUserId;
+    this.customerId = sessionData.customer_id || options.customerId;
     this.createdAt = new Date(sessionData.created_at);
     this.updatedAt = new Date(sessionData.updated_at);
     this.toolRegistry = options.toolRegistry;
@@ -3669,7 +3277,7 @@ var RemoteSession = class _RemoteSession {
     const response = await http.request("/sessions", {
       method: "POST",
       body: {
-        end_user_id: options.endUserId,
+        customer_id: options.customerId,
         metadata: options.metadata || {}
       }
     });
@@ -3705,7 +3313,7 @@ var RemoteSession = class _RemoteSession {
     const params = new URLSearchParams();
     if (options.limit) params.set("limit", String(options.limit));
     if (options.offset) params.set("offset", String(options.offset));
-    if (options.endUserId) params.set("end_user_id", options.endUserId);
+    if (options.customerId) params.set("customer_id", options.customerId);
     const response = await http.request(
       `/sessions${params.toString() ? `?${params.toString()}` : ""}`,
       { method: "GET" }
@@ -3758,7 +3366,7 @@ var RemoteSession = class _RemoteSession {
       const input = await this.buildInput(options);
       const tools = mergeTools2(this.defaultTools, options.tools);
       const spec = {
-        kind: "workflow.v0",
+        kind: "workflow.v1",
         name: `session-${this.id}-turn-${this.nextSeq}`,
         nodes: [
           {
@@ -3778,7 +3386,7 @@ var RemoteSession = class _RemoteSession {
         outputs: [{ name: "result", from: "main" }]
       };
       const run = await this.client.runs.create(spec, {
-        customerId: options.customerId || this.endUserId,
+        customerId: options.customerId || this.customerId,
         sessionId: String(this.id)
       });
       this.currentRunId = run.run_id;
@@ -4240,7 +3848,7 @@ var SessionsClient = class {
   /**
    * List remote sessions.
    *
-   * @param options - List options (limit, cursor, endUserId)
+   * @param options - List options (limit, cursor, customerId)
    * @returns Paginated list of session summaries
    *
    * @example
@@ -4255,13 +3863,13 @@ var SessionsClient = class {
     return RemoteSession.list(this.modelRelay, {
       limit: options.limit,
       offset: options.cursor ? parseInt(options.cursor, 10) : void 0,
-      endUserId: options.endUserId
+      customerId: options.customerId
     });
   }
   /**
    * Delete a remote session.
    *
-   * Requires a secret key (not publishable key).
+   * Requires a secret key.
    *
    * @param sessionId - ID of the session to delete
    *
@@ -4287,11 +3895,12 @@ var TiersClient = class {
     this.http = http;
     this.apiKey = cfg.apiKey ? parseApiKey(cfg.apiKey) : void 0;
     this.hasSecretKey = this.apiKey ? isSecretKey(this.apiKey) : false;
+    this.hasAccessToken = !!cfg.accessToken?.trim();
   }
-  ensureApiKey() {
-    if (!this.apiKey) {
+  ensureAuth() {
+    if (!this.apiKey && !this.hasAccessToken) {
       throw new ConfigError(
-        "API key (mr_pk_* or mr_sk_*) required for tier operations"
+        "API key (mr_sk_*) or bearer token required for tier operations"
       );
     }
   }
@@ -4306,7 +3915,7 @@ var TiersClient = class {
    * List all tiers in the project.
    */
   async list() {
-    this.ensureApiKey();
+    this.ensureAuth();
     const response = await this.http.json("/tiers", {
       method: "GET",
       apiKey: this.apiKey
@@ -4317,7 +3926,7 @@ var TiersClient = class {
    * Get a tier by ID.
    */
   async get(tierId) {
-    this.ensureApiKey();
+    this.ensureAuth();
     if (!tierId?.trim()) {
       throw new ConfigError("tierId is required");
     }
@@ -4332,8 +3941,8 @@ var TiersClient = class {
    *
    * This enables users to subscribe before authenticating. Stripe collects
    * the customer's email during checkout. After checkout completes, a
-   * customer record is created with the email from Stripe. The customer
-   * can later be linked to an identity via POST /customers/claim.
+   * customer record is created with the email from Stripe. Your backend
+   * can map it to your app user and mint customer tokens as needed.
    *
    * Requires a secret key (mr_sk_*).
    *
@@ -4776,47 +4385,6 @@ function isReusable(token) {
   }
   return token.expiresAt.getTime() - Date.now() > 6e4;
 }
-var FrontendTokenProvider = class {
-  constructor(cfg) {
-    const publishableKey = parsePublishableKey(cfg.publishableKey);
-    const http = new HTTPClient({
-      baseUrl: cfg.baseUrl || DEFAULT_BASE_URL,
-      fetchImpl: cfg.fetch,
-      clientHeader: cfg.clientHeader || DEFAULT_CLIENT_HEADER,
-      apiKey: publishableKey
-    });
-    this.publishableKey = publishableKey;
-    this.customer = cfg.customer;
-    this.auth = new AuthClient(http, { apiKey: publishableKey, customer: cfg.customer });
-  }
-  async getToken() {
-    if (!this.customer?.provider || !this.customer?.subject) {
-      throw new ConfigError("customer.provider and customer.subject are required");
-    }
-    const reqBase = {
-      publishableKey: this.publishableKey,
-      identityProvider: this.customer.provider,
-      identitySubject: this.customer.subject,
-      deviceId: this.customer.deviceId,
-      ttlSeconds: this.customer.ttlSeconds
-    };
-    let token;
-    if (this.customer.email) {
-      const req = {
-        ...reqBase,
-        email: this.customer.email
-      };
-      token = await this.auth.frontendTokenAutoProvision(req);
-    } else {
-      const req = reqBase;
-      token = await this.auth.frontendToken(req);
-    }
-    if (!token.token) {
-      throw new ConfigError("frontend token exchange returned an empty token");
-    }
-    return token.token;
-  }
-};
 var CustomerTokenProvider = class {
   constructor(cfg) {
     const key = parseSecretKey(cfg.secretKey);
@@ -4838,247 +4406,11 @@ var CustomerTokenProvider = class {
     return token.token;
   }
 };
-var OIDCExchangeTokenProvider = class {
-  constructor(cfg) {
-    const apiKey = parseApiKey(cfg.apiKey);
-    const http = new HTTPClient({
-      baseUrl: cfg.baseUrl || DEFAULT_BASE_URL,
-      fetchImpl: cfg.fetch,
-      clientHeader: cfg.clientHeader || DEFAULT_CLIENT_HEADER,
-      apiKey
-    });
-    this.auth = new AuthClient(http, { apiKey });
-    this.idTokenProvider = cfg.idTokenProvider;
-    this.request = { idToken: "", projectId: cfg.projectId };
-  }
-  async getToken() {
-    if (this.cached && isReusable(this.cached)) {
-      return this.cached.token;
-    }
-    const idToken = (await this.idTokenProvider())?.trim();
-    if (!idToken) {
-      throw new ConfigError("idTokenProvider returned an empty id_token");
-    }
-    const token = await this.auth.oidcExchange({ ...this.request, idToken });
-    this.cached = token;
-    return token.token;
-  }
-};
 
-// src/device_flow.ts
-async function pollUntil(opts) {
-  let intervalMs = Math.max(1, opts.intervalMs);
-  let attempt = 0;
-  while (true) {
-    if (opts.deadline && Date.now() >= opts.deadline.getTime()) {
-      throw opts.onTimeout?.() ?? new TransportError("polling timed out", { kind: "timeout" });
-    }
-    const result = await opts.poll(attempt);
-    if (result.done) {
-      return result.value;
-    }
-    const delay = Math.max(1, result.retryAfterMs ?? intervalMs);
-    intervalMs = delay;
-    await sleep(delay, opts.signal);
-    attempt += 1;
-  }
-}
-async function startOAuthDeviceAuthorization(req) {
-  const deviceAuthorizationEndpoint = req.deviceAuthorizationEndpoint?.trim();
-  if (!deviceAuthorizationEndpoint) {
-    throw new ConfigError("deviceAuthorizationEndpoint is required");
-  }
-  const clientId = req.clientId?.trim();
-  if (!clientId) {
-    throw new ConfigError("clientId is required");
-  }
-  const form = new URLSearchParams();
-  form.set("client_id", clientId);
-  if (req.scope?.trim()) {
-    form.set("scope", req.scope.trim());
-  }
-  if (req.audience?.trim()) {
-    form.set("audience", req.audience.trim());
-  }
-  const payload = await postOAuthForm(deviceAuthorizationEndpoint, form, {
-    fetch: req.fetch,
-    signal: req.signal
-  });
-  const deviceCode = String(payload.device_code || "").trim();
-  const userCode = String(payload.user_code || "").trim();
-  const verificationUri = String(payload.verification_uri || payload.verification_uri_complete || "").trim();
-  const verificationUriComplete = String(payload.verification_uri_complete || "").trim() || void 0;
-  const expiresIn = Number(payload.expires_in || 0);
-  const intervalSeconds = Math.max(1, Number(payload.interval || 5));
-  if (!deviceCode || !userCode || !verificationUri || !expiresIn) {
-    throw new TransportError("oauth device authorization returned an invalid response", {
-      kind: "request",
-      cause: payload
-    });
-  }
-  return {
-    deviceCode,
-    userCode,
-    verificationUri,
-    verificationUriComplete,
-    expiresAt: new Date(Date.now() + expiresIn * 1e3),
-    intervalSeconds
-  };
-}
-async function pollOAuthDeviceToken(req) {
-  const tokenEndpoint = req.tokenEndpoint?.trim();
-  if (!tokenEndpoint) {
-    throw new ConfigError("tokenEndpoint is required");
-  }
-  const clientId = req.clientId?.trim();
-  if (!clientId) {
-    throw new ConfigError("clientId is required");
-  }
-  const deviceCode = req.deviceCode?.trim();
-  if (!deviceCode) {
-    throw new ConfigError("deviceCode is required");
-  }
-  const deadline = req.deadline ?? new Date(Date.now() + 10 * 60 * 1e3);
-  let intervalMs = Math.max(1, req.intervalSeconds ?? 5) * 1e3;
-  return pollUntil({
-    intervalMs,
-    deadline,
-    signal: req.signal,
-    onTimeout: () => new TransportError("oauth device flow timed out", { kind: "timeout" }),
-    poll: async () => {
-      const form = new URLSearchParams();
-      form.set("grant_type", "urn:ietf:params:oauth:grant-type:device_code");
-      form.set("device_code", deviceCode);
-      form.set("client_id", clientId);
-      const payload = await postOAuthForm(tokenEndpoint, form, {
-        fetch: req.fetch,
-        signal: req.signal,
-        allowErrorPayload: true
-      });
-      const err = String(payload.error || "").trim();
-      if (err) {
-        switch (err) {
-          case "authorization_pending":
-            return { done: false };
-          case "slow_down":
-            intervalMs += 5e3;
-            return { done: false, retryAfterMs: intervalMs };
-          case "expired_token":
-          case "access_denied":
-          case "invalid_grant":
-            throw new TransportError(`oauth device flow failed: ${err}`, {
-              kind: "request",
-              cause: payload
-            });
-          default:
-            throw new TransportError(`oauth device flow error: ${err}`, {
-              kind: "request",
-              cause: payload
-            });
-        }
-      }
-      const accessToken = String(payload.access_token || "").trim() || void 0;
-      const idToken = String(payload.id_token || "").trim() || void 0;
-      const refreshToken = String(payload.refresh_token || "").trim() || void 0;
-      const tokenType = String(payload.token_type || "").trim() || void 0;
-      const scope = String(payload.scope || "").trim() || void 0;
-      const expiresIn = payload.expires_in !== void 0 ? Number(payload.expires_in) : void 0;
-      const expiresAt = typeof expiresIn === "number" && Number.isFinite(expiresIn) && expiresIn > 0 ? new Date(Date.now() + expiresIn * 1e3) : void 0;
-      if (!accessToken && !idToken) {
-        throw new TransportError("oauth device flow returned an invalid token response", {
-          kind: "request",
-          cause: payload
-        });
-      }
-      return { done: true, value: { accessToken, idToken, refreshToken, tokenType, scope, expiresAt } };
-    }
-  });
-}
-async function runOAuthDeviceFlowForIDToken(cfg) {
-  const auth = await startOAuthDeviceAuthorization({
-    deviceAuthorizationEndpoint: cfg.deviceAuthorizationEndpoint,
-    clientId: cfg.clientId,
-    scope: cfg.scope,
-    audience: cfg.audience,
-    fetch: cfg.fetch,
-    signal: cfg.signal
-  });
-  await cfg.onUserCode(auth);
-  const token = await pollOAuthDeviceToken({
-    tokenEndpoint: cfg.tokenEndpoint,
-    clientId: cfg.clientId,
-    deviceCode: auth.deviceCode,
-    intervalSeconds: auth.intervalSeconds,
-    deadline: auth.expiresAt,
-    fetch: cfg.fetch,
-    signal: cfg.signal
-  });
-  if (!token.idToken) {
-    throw new TransportError("oauth device flow did not return an id_token", {
-      kind: "request",
-      cause: token
-    });
-  }
-  return token.idToken;
-}
-async function postOAuthForm(url, form, opts) {
-  const fetchFn = opts.fetch ?? globalThis.fetch;
-  if (!fetchFn) {
-    throw new ConfigError("fetch is not available; provide a fetch implementation");
-  }
-  let resp;
-  try {
-    resp = await fetchFn(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/x-www-form-urlencoded" },
-      body: form.toString(),
-      signal: opts.signal
-    });
-  } catch (cause) {
-    throw new TransportError("oauth request failed", { kind: "request", cause });
-  }
-  let json;
-  try {
-    json = await resp.json();
-  } catch (cause) {
-    throw new TransportError("oauth response was not valid JSON", { kind: "request", cause });
-  }
-  if (!resp.ok && !opts.allowErrorPayload) {
-    throw new TransportError(`oauth request failed (${resp.status})`, {
-      kind: "request",
-      cause: json
-    });
-  }
-  return json || {};
-}
-async function sleep(ms, signal) {
-  if (!ms || ms <= 0) {
-    return;
-  }
-  if (!signal) {
-    await new Promise((resolve) => setTimeout(resolve, ms));
-    return;
-  }
-  if (signal.aborted) {
-    throw new TransportError("oauth device flow aborted", { kind: "request" });
-  }
-  await new Promise((resolve, reject) => {
-    const onAbort = () => {
-      signal.removeEventListener("abort", onAbort);
-      reject(new TransportError("oauth device flow aborted", { kind: "request" }));
-    };
-    signal.addEventListener("abort", onAbort);
-    setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-  });
-}
-
-// src/json_path.ts
-var LLMOutputPath = class {
-  constructor(path = "/output") {
-    this.path = path;
+// src/json_path.ts
+var LLMOutputPath = class {
+  constructor(path = "/output") {
+    this.path = path;
   }
   /** Select an output by index */
   index(i) {
@@ -5211,9 +4543,6 @@ function transformJSONObject(object) {
 function transformJSONMerge(merge) {
   return { merge: merge.slice() };
 }
-var transformJSONValueV1 = transformJSONValue;
-var transformJSONObjectV1 = transformJSONObject;
-var transformJSONMergeV1 = transformJSONMerge;
 function wireRequest(req) {
   const raw = req;
   if (raw && typeof raw === "object") {
@@ -5263,2146 +4592,195 @@ function validateInputPointer(pointer, input) {
   }
   const msgIndex = parseInt(match[1], 10);
   if (msgIndex >= input.length) {
-    return `targets ${pointer} but request only has ${input.length} messages (indices 0-${input.length - 1}); add placeholder messages or adjust binding target`;
-  }
-  if (match[2] !== void 0) {
-    const contentIndex = parseInt(match[2], 10);
-    const msg = input[msgIndex];
-    if (contentIndex >= msg.content.length) {
-      return `targets ${pointer} but message ${msgIndex} only has ${msg.content.length} content blocks (indices 0-${msg.content.length - 1})`;
-    }
-  }
-  return void 0;
-}
-function validateMapFanoutInput(nodeId, input) {
-  const subnode = input.subnode;
-  if ((subnode.type === WorkflowNodeTypesV1.LLMResponses || subnode.type === WorkflowNodeTypesV1.RouteSwitch) && subnode.input.bindings && subnode.input.bindings.length > 0) {
-    throw new MapFanoutInputError(nodeId, "map.fanout subnode bindings are not allowed");
-  }
-  if (subnode.type !== WorkflowNodeTypesV1.TransformJSON) {
-    return;
-  }
-  if (input.item_bindings && input.item_bindings.length > 0) {
-    throw new MapFanoutInputError(
-      nodeId,
-      "map.fanout transform.json subnode cannot use item_bindings"
-    );
-  }
-  const hasObject = !!subnode.input.object && Object.keys(subnode.input.object).length > 0;
-  const hasMerge = !!subnode.input.merge && subnode.input.merge.length > 0;
-  if (hasObject === hasMerge) {
-    throw new MapFanoutInputError(
-      nodeId,
-      "map.fanout transform.json must provide exactly one of object or merge"
-    );
-  }
-  if (hasObject) {
-    for (const [key, value] of Object.entries(subnode.input.object ?? {})) {
-      if (!key.trim()) continue;
-      if (String(value.from) !== "item") {
-        throw new MapFanoutInputError(
-          nodeId,
-          `map.fanout transform.json object.${key}.from must be "item"`
-        );
-      }
-    }
-  }
-  if (hasMerge) {
-    for (const [index, value] of (subnode.input.merge ?? []).entries()) {
-      if (String(value.from) !== "item") {
-        throw new MapFanoutInputError(
-          nodeId,
-          `map.fanout transform.json merge[${index}].from must be "item"`
-        );
-      }
-    }
-  }
-}
-var WorkflowBuilderV0 = class _WorkflowBuilderV0 {
-  constructor(state = { nodes: [], edges: [], outputs: [] }) {
-    this.state = state;
-  }
-  static new() {
-    return new _WorkflowBuilderV0();
-  }
-  with(patch) {
-    return new _WorkflowBuilderV0({
-      ...this.state,
-      ...patch
-    });
-  }
-  name(name) {
-    return this.with({ name: name.trim() || void 0 });
-  }
-  execution(execution) {
-    return this.with({ execution });
-  }
-  node(node) {
-    return this.with({ nodes: [...this.state.nodes, node] });
-  }
-  llmResponses(id, request, options = {}) {
-    const wiredRequest = wireRequest(request);
-    if (options.bindings) {
-      validateBindingTargets(id, wiredRequest.input, options.bindings);
-    }
-    const input = {
-      request: wiredRequest,
-      ...options.stream === void 0 ? {} : { stream: options.stream },
-      ...options.toolExecution === void 0 ? {} : { tool_execution: { mode: options.toolExecution } },
-      ...options.toolLimits === void 0 ? {} : { tool_limits: { ...options.toolLimits } },
-      ...options.bindings === void 0 ? {} : { bindings: options.bindings.slice() }
-    };
-    return this.node({
-      id,
-      type: WorkflowNodeTypes.LLMResponses,
-      input
-    });
-  }
-  joinAll(id) {
-    return this.node({ id, type: WorkflowNodeTypes.JoinAll });
-  }
-  transformJSON(id, input) {
-    return this.node({ id, type: WorkflowNodeTypes.TransformJSON, input });
-  }
-  edge(from, to) {
-    return this.with({ edges: [...this.state.edges, { from, to }] });
-  }
-  output(name, from, pointer) {
-    return this.with({
-      outputs: [
-        ...this.state.outputs,
-        { name, from, ...pointer ? { pointer } : {} }
-      ]
-    });
-  }
-  build() {
-    const edges = this.state.edges.slice().sort((a, b) => {
-      const af = String(a.from);
-      const bf = String(b.from);
-      if (af < bf) return -1;
-      if (af > bf) return 1;
-      const at = String(a.to);
-      const bt = String(b.to);
-      if (at < bt) return -1;
-      if (at > bt) return 1;
-      return 0;
-    });
-    const outputs = this.state.outputs.slice().sort((a, b) => {
-      const an = String(a.name);
-      const bn = String(b.name);
-      if (an < bn) return -1;
-      if (an > bn) return 1;
-      const af = String(a.from);
-      const bf = String(b.from);
-      if (af < bf) return -1;
-      if (af > bf) return 1;
-      const ap = a.pointer ?? "";
-      const bp = b.pointer ?? "";
-      if (ap < bp) return -1;
-      if (ap > bp) return 1;
-      return 0;
-    });
-    return {
-      kind: WorkflowKinds.WorkflowV0,
-      ...this.state.name ? { name: this.state.name } : {},
-      ...this.state.execution ? { execution: this.state.execution } : {},
-      nodes: this.state.nodes.slice(),
-      ...edges.length ? { edges } : {},
-      outputs
-    };
-  }
-};
-function workflowV0() {
-  return WorkflowBuilderV0.new();
-}
-var WorkflowBuilderV1 = class _WorkflowBuilderV1 {
-  constructor(state = { nodes: [], edges: [], outputs: [] }) {
-    this.state = state;
-  }
-  static new() {
-    return new _WorkflowBuilderV1();
-  }
-  with(patch) {
-    return new _WorkflowBuilderV1({
-      ...this.state,
-      ...patch
-    });
-  }
-  name(name) {
-    return this.with({ name: name.trim() || void 0 });
-  }
-  execution(execution) {
-    return this.with({ execution });
-  }
-  node(node) {
-    return this.with({ nodes: [...this.state.nodes, node] });
-  }
-  llmResponses(id, request, options = {}) {
-    const wiredRequest = wireRequest(request);
-    if (options.bindings) {
-      validateBindingTargets(id, wiredRequest.input, options.bindings);
-    }
-    const input = {
-      request: wiredRequest,
-      ...options.stream === void 0 ? {} : { stream: options.stream },
-      ...options.toolExecution === void 0 ? {} : { tool_execution: { mode: options.toolExecution } },
-      ...options.toolLimits === void 0 ? {} : { tool_limits: { ...options.toolLimits } },
-      ...options.bindings === void 0 ? {} : { bindings: options.bindings.slice() }
-    };
-    return this.node({
-      id,
-      type: WorkflowNodeTypesV1.LLMResponses,
-      input
-    });
-  }
-  routeSwitch(id, request, options = {}) {
-    const wiredRequest = wireRequest(request);
-    if (options.bindings) {
-      validateBindingTargets(id, wiredRequest.input, options.bindings);
-    }
-    const input = {
-      request: wiredRequest,
-      ...options.stream === void 0 ? {} : { stream: options.stream },
-      ...options.toolExecution === void 0 ? {} : { tool_execution: { mode: options.toolExecution } },
-      ...options.toolLimits === void 0 ? {} : { tool_limits: { ...options.toolLimits } },
-      ...options.bindings === void 0 ? {} : { bindings: options.bindings.slice() }
-    };
-    return this.node({
-      id,
-      type: WorkflowNodeTypesV1.RouteSwitch,
-      input
-    });
-  }
-  joinAll(id) {
-    return this.node({ id, type: WorkflowNodeTypesV1.JoinAll });
-  }
-  joinAny(id, input) {
-    return this.node({
-      id,
-      type: WorkflowNodeTypesV1.JoinAny,
-      ...input ? { input } : {}
-    });
-  }
-  joinCollect(id, input) {
-    return this.node({ id, type: WorkflowNodeTypesV1.JoinCollect, input });
-  }
-  transformJSON(id, input) {
-    return this.node({ id, type: WorkflowNodeTypesV1.TransformJSON, input });
-  }
-  mapFanout(id, input) {
-    validateMapFanoutInput(id, input);
-    return this.node({ id, type: WorkflowNodeTypesV1.MapFanout, input });
-  }
-  edge(from, to, when) {
-    return this.with({
-      edges: [...this.state.edges, { from, to, ...when ? { when } : {} }]
-    });
-  }
-  output(name, from, pointer) {
-    return this.with({
-      outputs: [
-        ...this.state.outputs,
-        { name, from, ...pointer ? { pointer } : {} }
-      ]
-    });
-  }
-  build() {
-    const edges = this.state.edges.slice().sort((a, b) => {
-      const af = String(a.from);
-      const bf = String(b.from);
-      if (af < bf) return -1;
-      if (af > bf) return 1;
-      const at = String(a.to);
-      const bt = String(b.to);
-      if (at < bt) return -1;
-      if (at > bt) return 1;
-      const aw = a.when ? JSON.stringify(a.when) : "";
-      const bw = b.when ? JSON.stringify(b.when) : "";
-      if (aw < bw) return -1;
-      if (aw > bw) return 1;
-      return 0;
-    });
-    const outputs = this.state.outputs.slice().sort((a, b) => {
-      const an = String(a.name);
-      const bn = String(b.name);
-      if (an < bn) return -1;
-      if (an > bn) return 1;
-      const af = String(a.from);
-      const bf = String(b.from);
-      if (af < bf) return -1;
-      if (af > bf) return 1;
-      const ap = a.pointer ?? "";
-      const bp = b.pointer ?? "";
-      if (ap < bp) return -1;
-      if (ap > bp) return 1;
-      return 0;
-    });
-    return {
-      kind: WorkflowKinds.WorkflowV1,
-      ...this.state.name ? { name: this.state.name } : {},
-      ...this.state.execution ? { execution: this.state.execution } : {},
-      nodes: this.state.nodes.slice(),
-      ...edges.length ? { edges } : {},
-      outputs
-    };
-  }
-};
-function workflowV1() {
-  return WorkflowBuilderV1.new();
-}
-var Workflow = class _Workflow {
-  constructor(name) {
-    this._nodes = [];
-    this._edges = /* @__PURE__ */ new Set();
-    this._outputs = [];
-    this._pendingNode = null;
-    this._name = name?.trim() || void 0;
-  }
-  /**
-   * Create a new workflow builder with the given name.
-   */
-  static create(name) {
-    return new _Workflow(name);
-  }
-  /**
-   * Set the workflow execution configuration.
-   */
-  execution(exec) {
-    this.flushPendingNode();
-    this._execution = exec;
-    return this;
-  }
-  /**
-   * Add an LLM responses node and return a node builder for configuration.
-   */
-  addLLMNode(id, request) {
-    this.flushPendingNode();
-    this._pendingNode = {
-      id,
-      request: wireRequest(request),
-      bindings: []
-    };
-    return new LLMNodeBuilder(this);
-  }
-  /**
-   * Add a join.all node that waits for all incoming edges.
-   */
-  addJoinAllNode(id) {
-    this.flushPendingNode();
-    this._nodes.push({ id, type: WorkflowNodeTypes.JoinAll });
-    return this;
-  }
-  /**
-   * Add a transform.json node and return a builder for configuration.
-   */
-  addTransformJSONNode(id) {
-    this.flushPendingNode();
-    return new TransformJSONNodeBuilder(this, id);
-  }
-  /**
-   * Add an output reference extracting the full node output.
-   */
-  output(name, from, pointer) {
-    this.flushPendingNode();
-    this._outputs.push({ name, from, ...pointer ? { pointer } : {} });
-    return this;
-  }
-  /**
-   * Add an output reference extracting text content from an LLM response.
-   * This is a convenience method that uses the LLM_TEXT_OUTPUT pointer.
-   */
-  outputText(name, from) {
-    return this.output(name, from, LLM_TEXT_OUTPUT);
-  }
-  /**
-   * Explicitly add an edge between nodes.
-   * Note: edges are automatically inferred from bindings, so this is rarely needed.
-   */
-  edge(from, to) {
-    this.flushPendingNode();
-    this._edges.add(`${from}->${to}`);
-    return this;
-  }
-  /**
-   * Build the workflow specification.
-   */
-  build() {
-    this.flushPendingNode();
-    const edges = Array.from(this._edges).map((key) => {
-      const [from, to] = key.split("->");
-      return { from, to };
-    }).sort((a, b) => {
-      const af = String(a.from);
-      const bf = String(b.from);
-      if (af < bf) return -1;
-      if (af > bf) return 1;
-      const at = String(a.to);
-      const bt = String(b.to);
-      if (at < bt) return -1;
-      if (at > bt) return 1;
-      return 0;
-    });
-    const outputs = this._outputs.slice().sort((a, b) => {
-      const an = String(a.name);
-      const bn = String(b.name);
-      if (an < bn) return -1;
-      if (an > bn) return 1;
-      const af = String(a.from);
-      const bf = String(b.from);
-      if (af < bf) return -1;
-      if (af > bf) return 1;
-      const ap = a.pointer ?? "";
-      const bp = b.pointer ?? "";
-      if (ap < bp) return -1;
-      if (ap > bp) return 1;
-      return 0;
-    });
-    return {
-      kind: WorkflowKinds.WorkflowV0,
-      ...this._name ? { name: this._name } : {},
-      ...this._execution ? { execution: this._execution } : {},
-      nodes: this._nodes.slice(),
-      ...edges.length ? { edges } : {},
-      outputs
-    };
-  }
-  /** @internal */
-  _getPendingNode() {
-    return this._pendingNode;
-  }
-  /** @internal */
-  _addEdge(from, to) {
-    this._edges.add(`${from}->${to}`);
-  }
-  /** @internal */
-  _addNode(node) {
-    this._nodes.push(node);
-  }
-  flushPendingNode() {
-    const pending = this._pendingNode;
-    if (!pending) return;
-    this._pendingNode = null;
-    if (pending.bindings.length > 0) {
-      validateBindingTargets(pending.id, pending.request.input, pending.bindings);
-    }
-    const input = {
-      id: pending.id,
-      type: WorkflowNodeTypes.LLMResponses,
-      input: {
-        request: pending.request,
-        ...pending.stream !== void 0 ? { stream: pending.stream } : {},
-        ...pending.toolExecution ? { tool_execution: { mode: pending.toolExecution } } : {},
-        ...pending.toolLimits ? { tool_limits: pending.toolLimits } : {},
-        ...pending.bindings.length ? { bindings: pending.bindings } : {}
-      }
-    };
-    this._nodes.push(input);
-    for (const binding of pending.bindings) {
-      this._edges.add(`${binding.from}->${pending.id}`);
-    }
-  }
-};
-var LLMNodeBuilder = class {
-  constructor(workflow) {
-    this.workflow = workflow;
-  }
-  /**
-   * Enable or disable streaming for this node.
-   */
-  stream(enabled) {
-    const pending = this.workflow._getPendingNode();
-    if (pending) {
-      pending.stream = enabled;
-    }
-    return this;
-  }
-  /**
-   * Add a binding from another LLM node's text output to this node's user message.
-   * This is the most common binding pattern: LLM text → user message with json_string encoding.
-   * The edge from the source node is automatically inferred.
-   */
-  bindTextFrom(from) {
-    return this.bindFromTo(from, LLM_TEXT_OUTPUT, LLM_USER_MESSAGE_TEXT, "json_string");
-  }
-  /**
-   * Add a binding from another node's output to this node's user message text.
-   * Use bindTextFrom for the common case of binding LLM text output.
-   * The edge from the source node is automatically inferred.
-   */
-  bindFrom(from, pointer) {
-    return this.bindFromTo(from, pointer, LLM_USER_MESSAGE_TEXT, "json_string");
-  }
-  /**
-   * Add a full binding with explicit source/destination pointers and encoding.
-   * The edge from the source node is automatically inferred.
-   */
-  bindFromTo(from, fromPointer, toPointer, encoding) {
-    const pending = this.workflow._getPendingNode();
-    if (pending) {
-      pending.bindings.push({
-        from,
-        ...fromPointer ? { pointer: fromPointer } : {},
-        to: toPointer,
-        ...encoding ? { encoding } : {}
-      });
-    }
-    return this;
-  }
-  /**
-   * Add a binding that replaces a {{placeholder}} in the prompt text.
-   * This is useful when the prompt contains placeholder markers like {{tier_data}}.
-   * The edge from the source node is automatically inferred.
-   */
-  bindToPlaceholder(from, fromPointer, placeholder) {
-    const pending = this.workflow._getPendingNode();
-    if (pending) {
-      pending.bindings.push({
-        from,
-        ...fromPointer ? { pointer: fromPointer } : {},
-        to_placeholder: placeholder,
-        encoding: "json_string"
-      });
-    }
-    return this;
-  }
-  /**
-   * Add a binding from an LLM node's text output to a placeholder.
-   * This is the most common placeholder binding: LLM text → {{placeholder}}.
-   * The edge from the source node is automatically inferred.
-   */
-  bindTextToPlaceholder(from, placeholder) {
-    return this.bindToPlaceholder(from, LLM_TEXT_OUTPUT, placeholder);
-  }
-  /**
-   * Set the tool execution mode (server or client).
-   */
-  toolExecution(mode) {
-    const pending = this.workflow._getPendingNode();
-    if (pending) {
-      pending.toolExecution = mode;
-    }
-    return this;
-  }
-  /**
-   * Set the tool execution limits.
-   */
-  toolLimits(limits) {
-    const pending = this.workflow._getPendingNode();
-    if (pending) {
-      pending.toolLimits = limits;
-    }
-    return this;
-  }
-  // Workflow methods for chaining back
-  addLLMNode(id, request) {
-    return this.workflow.addLLMNode(id, request);
-  }
-  addJoinAllNode(id) {
-    return this.workflow.addJoinAllNode(id);
-  }
-  addTransformJSONNode(id) {
-    return this.workflow.addTransformJSONNode(id);
-  }
-  edge(from, to) {
-    return this.workflow.edge(from, to);
-  }
-  output(name, from, pointer) {
-    return this.workflow.output(name, from, pointer);
-  }
-  outputText(name, from) {
-    return this.workflow.outputText(name, from);
-  }
-  execution(exec) {
-    return this.workflow.execution(exec);
-  }
-  build() {
-    return this.workflow.build();
-  }
-};
-var TransformJSONNodeBuilder = class {
-  constructor(workflow, id) {
-    this.workflow = workflow;
-    this.id = id;
-  }
-  /**
-   * Set the object transformation with field mappings.
-   */
-  object(fields) {
-    this._object = fields;
-    return this;
-  }
-  /**
-   * Set the merge transformation with source references.
-   */
-  merge(items) {
-    this._merge = items;
-    return this;
-  }
-  finalize() {
-    const input = {};
-    if (this._object) input.object = this._object;
-    if (this._merge) input.merge = this._merge;
-    this.workflow._addNode({
-      id: this.id,
-      type: WorkflowNodeTypes.TransformJSON,
-      input
-    });
-    if (this._object) {
-      for (const ref of Object.values(this._object)) {
-        this.workflow._addEdge(ref.from, this.id);
-      }
-    }
-    if (this._merge) {
-      for (const ref of this._merge) {
-        this.workflow._addEdge(ref.from, this.id);
-      }
-    }
-  }
-  // Workflow methods for chaining back
-  addLLMNode(id, request) {
-    this.finalize();
-    return this.workflow.addLLMNode(id, request);
-  }
-  addJoinAllNode(id) {
-    this.finalize();
-    return this.workflow.addJoinAllNode(id);
-  }
-  edge(from, to) {
-    this.finalize();
-    return this.workflow.edge(from, to);
-  }
-  output(name, from, pointer) {
-    this.finalize();
-    return this.workflow.output(name, from, pointer);
-  }
-  execution(exec) {
-    this.finalize();
-    return this.workflow.execution(exec);
-  }
-  build() {
-    this.finalize();
-    return this.workflow.build();
-  }
-};
-function newWorkflow(name) {
-  return Workflow.create(name);
-}
-
-// src/workflow_v0.schema.json
-var workflow_v0_schema_default = {
-  $id: "https://modelrelay.ai/schemas/workflow_v0.schema.json",
-  $schema: "http://json-schema.org/draft-07/schema#",
-  additionalProperties: false,
-  definitions: {
-    edge: {
-      additionalProperties: false,
-      properties: {
-        from: {
-          minLength: 1,
-          type: "string"
-        },
-        to: {
-          minLength: 1,
-          type: "string"
-        }
-      },
-      required: [
-        "from",
-        "to"
-      ],
-      type: "object"
-    },
-    llmResponsesBinding: {
-      additionalProperties: false,
-      oneOf: [
-        {
-          required: [
-            "to"
-          ]
-        },
-        {
-          required: [
-            "to_placeholder"
-          ]
-        }
-      ],
-      properties: {
-        encoding: {
-          enum: [
-            "json",
-            "json_string"
-          ],
-          type: "string"
-        },
-        from: {
-          minLength: 1,
-          type: "string"
-        },
-        pointer: {
-          pattern: "^(/.*)?$",
-          type: "string"
-        },
-        to: {
-          pattern: "^/.*$",
-          type: "string"
-        },
-        to_placeholder: {
-          minLength: 1,
-          type: "string"
-        }
-      },
-      required: [
-        "from"
-      ],
-      type: "object"
-    },
-    node: {
-      additionalProperties: false,
-      oneOf: [
-        {
-          allOf: [
-            {
-              properties: {
-                input: {
-                  properties: {
-                    bindings: {
-                      items: {
-                        $ref: "#/definitions/llmResponsesBinding"
-                      },
-                      type: "array"
-                    },
-                    request: {
-                      type: "object"
-                    },
-                    stream: {
-                      type: "boolean"
-                    },
-                    tool_execution: {
-                      additionalProperties: false,
-                      properties: {
-                        mode: {
-                          default: "server",
-                          enum: [
-                            "server",
-                            "client"
-                          ],
-                          type: "string"
-                        }
-                      },
-                      required: [
-                        "mode"
-                      ],
-                      type: "object"
-                    },
-                    tool_limits: {
-                      additionalProperties: false,
-                      properties: {
-                        max_llm_calls: {
-                          default: 8,
-                          maximum: 64,
-                          minimum: 1,
-                          type: "integer"
-                        },
-                        max_tool_calls_per_step: {
-                          default: 16,
-                          maximum: 64,
-                          minimum: 1,
-                          type: "integer"
-                        },
-                        wait_ttl_ms: {
-                          default: 9e5,
-                          maximum: 864e5,
-                          minimum: 1,
-                          type: "integer"
-                        }
-                      },
-                      type: "object"
-                    }
-                  },
-                  required: [
-                    "request"
-                  ],
-                  type: "object"
-                }
-              }
-            }
-          ],
-          properties: {
-            type: {
-              const: "llm.responses"
-            }
-          },
-          required: [
-            "input"
-          ]
-        },
-        {
-          properties: {
-            type: {
-              const: "join.all"
-            }
-          }
-        },
-        {
-          allOf: [
-            {
-              properties: {
-                input: {
-                  additionalProperties: false,
-                  oneOf: [
-                    {
-                      not: {
-                        required: [
-                          "merge"
-                        ]
-                      },
-                      required: [
-                        "object"
-                      ]
-                    },
-                    {
-                      not: {
-                        required: [
-                          "object"
-                        ]
-                      },
-                      required: [
-                        "merge"
-                      ]
-                    }
-                  ],
-                  properties: {
-                    merge: {
-                      items: {
-                        $ref: "#/definitions/transformValue"
-                      },
-                      minItems: 1,
-                      type: "array"
-                    },
-                    object: {
-                      additionalProperties: {
-                        $ref: "#/definitions/transformValue"
-                      },
-                      minProperties: 1,
-                      type: "object"
-                    }
-                  },
-                  type: "object"
-                }
-              }
-            }
-          ],
-          properties: {
-            type: {
-              const: "transform.json"
-            }
-          },
-          required: [
-            "input"
-          ]
-        }
-      ],
-      properties: {
-        id: {
-          minLength: 1,
-          type: "string"
-        },
-        input: {},
-        type: {
-          enum: [
-            "llm.responses",
-            "join.all",
-            "transform.json"
-          ],
-          type: "string"
-        }
-      },
-      required: [
-        "id",
-        "type"
-      ],
-      type: "object"
-    },
-    output: {
-      additionalProperties: false,
-      properties: {
-        from: {
-          minLength: 1,
-          type: "string"
-        },
-        name: {
-          minLength: 1,
-          type: "string"
-        },
-        pointer: {
-          pattern: "^(/.*)?$",
-          type: "string"
-        }
-      },
-      required: [
-        "name",
-        "from"
-      ],
-      type: "object"
-    },
-    transformValue: {
-      additionalProperties: false,
-      properties: {
-        from: {
-          minLength: 1,
-          type: "string"
-        },
-        pointer: {
-          pattern: "^(/.*)?$",
-          type: "string"
-        }
-      },
-      required: [
-        "from"
-      ],
-      type: "object"
-    }
-  },
-  properties: {
-    edges: {
-      items: {
-        $ref: "#/definitions/edge"
-      },
-      type: "array"
-    },
-    execution: {
-      additionalProperties: false,
-      properties: {
-        max_parallelism: {
-          minimum: 1,
-          type: "integer"
-        },
-        node_timeout_ms: {
-          minimum: 1,
-          type: "integer"
-        },
-        run_timeout_ms: {
-          minimum: 1,
-          type: "integer"
-        }
-      },
-      type: "object"
-    },
-    kind: {
-      const: "workflow.v0",
-      type: "string"
-    },
-    name: {
-      type: "string"
-    },
-    nodes: {
-      items: {
-        $ref: "#/definitions/node"
-      },
-      minItems: 1,
-      type: "array"
-    },
-    outputs: {
-      items: {
-        $ref: "#/definitions/output"
-      },
-      minItems: 1,
-      type: "array"
-    }
-  },
-  required: [
-    "kind",
-    "nodes",
-    "outputs"
-  ],
-  title: "ModelRelay workflow.v0",
-  type: "object"
-};
-
-// src/workflow_v1.schema.json
-var workflow_v1_schema_default = {
-  $id: "https://modelrelay.ai/schemas/workflow_v1.schema.json",
-  $schema: "http://json-schema.org/draft-07/schema#",
-  additionalProperties: false,
-  definitions: {
-    condition: {
-      additionalProperties: false,
-      properties: {
-        op: {
-          enum: [
-            "equals",
-            "matches",
-            "exists"
-          ],
-          type: "string"
-        },
-        path: {
-          pattern: "^\\$.*$",
-          type: "string"
-        },
-        source: {
-          enum: [
-            "node_output",
-            "node_status"
-          ],
-          type: "string"
-        },
-        value: {}
-      },
-      required: [
-        "source",
-        "op"
-      ],
-      type: "object"
-    },
-    edge: {
-      additionalProperties: false,
-      properties: {
-        from: {
-          minLength: 1,
-          type: "string"
-        },
-        to: {
-          minLength: 1,
-          type: "string"
-        },
-        when: {
-          $ref: "#/definitions/condition"
-        }
-      },
-      required: [
-        "from",
-        "to"
-      ],
-      type: "object"
-    },
-    fragmentBindInput: {
-      additionalProperties: false,
-      oneOf: [
-        {
-          required: [
-            "from_node"
-          ]
-        },
-        {
-          required: [
-            "from_input"
-          ]
-        }
-      ],
-      properties: {
-        from_input: {
-          minLength: 1,
-          type: "string"
-        },
-        from_node: {
-          minLength: 1,
-          type: "string"
-        },
-        pointer: {
-          pattern: "^(/.*)?$",
-          type: "string"
-        }
-      },
-      type: "object"
-    },
-    fragmentDef: {
-      additionalProperties: false,
-      properties: {
-        edges: {
-          items: {
-            $ref: "#/definitions/edge"
-          },
-          type: "array"
-        },
-        inputs: {
-          items: {
-            $ref: "#/definitions/fragmentInput"
-          },
-          type: "array"
-        },
-        nodes: {
-          items: {
-            $ref: "#/definitions/node"
-          },
-          minItems: 1,
-          type: "array"
-        },
-        outputs: {
-          items: {
-            $ref: "#/definitions/fragmentOutput"
-          },
-          minItems: 1,
-          type: "array"
-        }
-      },
-      required: [
-        "outputs",
-        "nodes"
-      ],
-      type: "object"
-    },
-    fragmentInput: {
-      additionalProperties: false,
-      properties: {
-        name: {
-          minLength: 1,
-          type: "string"
-        },
-        type: {
-          type: "string"
-        }
-      },
-      required: [
-        "name"
-      ],
-      type: "object"
-    },
-    fragmentOutput: {
-      additionalProperties: false,
-      properties: {
-        from_node: {
-          minLength: 1,
-          type: "string"
-        },
-        name: {
-          minLength: 1,
-          type: "string"
-        },
-        pointer: {
-          pattern: "^(/.*)?$",
-          type: "string"
-        }
-      },
-      required: [
-        "name",
-        "from_node"
-      ],
-      type: "object"
-    },
-    llmResponsesBinding: {
-      additionalProperties: false,
-      oneOf: [
-        {
-          required: [
-            "to"
-          ]
-        },
-        {
-          required: [
-            "to_placeholder"
-          ]
-        }
-      ],
-      properties: {
-        encoding: {
-          enum: [
-            "json",
-            "json_string"
-          ],
-          type: "string"
-        },
-        from: {
-          minLength: 1,
-          type: "string"
-        },
-        pointer: {
-          pattern: "^(/.*)?$",
-          type: "string"
-        },
-        to: {
-          pattern: "^/.*$",
-          type: "string"
-        },
-        to_placeholder: {
-          minLength: 1,
-          type: "string"
-        }
-      },
-      required: [
-        "from"
-      ],
-      type: "object"
-    },
-    mapFanoutItemBinding: {
-      additionalProperties: false,
-      oneOf: [
-        {
-          required: [
-            "to"
-          ]
-        },
-        {
-          required: [
-            "to_placeholder"
-          ]
-        }
-      ],
-      properties: {
-        encoding: {
-          enum: [
-            "json",
-            "json_string"
-          ],
-          type: "string"
-        },
-        path: {
-          pattern: "^(/.*)?$",
-          type: "string"
-        },
-        to: {
-          pattern: "^/.*$",
-          type: "string"
-        },
-        to_placeholder: {
-          minLength: 1,
-          type: "string"
-        }
-      },
-      type: "object"
-    },
-    node: {
-      additionalProperties: false,
-      oneOf: [
-        {
-          allOf: [
-            {
-              properties: {
-                input: {
-                  properties: {
-                    bindings: {
-                      items: {
-                        $ref: "#/definitions/llmResponsesBinding"
-                      },
-                      type: "array"
-                    },
-                    request: {
-                      type: "object"
-                    },
-                    stream: {
-                      type: "boolean"
-                    },
-                    tool_execution: {
-                      additionalProperties: false,
-                      properties: {
-                        mode: {
-                          default: "server",
-                          enum: [
-                            "server",
-                            "client"
-                          ],
-                          type: "string"
-                        }
-                      },
-                      required: [
-                        "mode"
-                      ],
-                      type: "object"
-                    },
-                    tool_limits: {
-                      additionalProperties: false,
-                      properties: {
-                        max_llm_calls: {
-                          default: 8,
-                          maximum: 64,
-                          minimum: 1,
-                          type: "integer"
-                        },
-                        max_tool_calls_per_step: {
-                          default: 16,
-                          maximum: 64,
-                          minimum: 1,
-                          type: "integer"
-                        },
-                        wait_ttl_ms: {
-                          default: 9e5,
-                          maximum: 864e5,
-                          minimum: 1,
-                          type: "integer"
-                        }
-                      },
-                      type: "object"
-                    }
-                  },
-                  required: [
-                    "request"
-                  ],
-                  type: "object"
-                }
-              }
-            }
-          ],
-          properties: {
-            type: {
-              const: "llm.responses"
-            }
-          },
-          required: [
-            "input"
-          ]
-        },
-        {
-          allOf: [
-            {
-              properties: {
-                input: {
-                  properties: {
-                    bindings: {
-                      items: {
-                        $ref: "#/definitions/llmResponsesBinding"
-                      },
-                      type: "array"
-                    },
-                    request: {
-                      type: "object"
-                    },
-                    stream: {
-                      type: "boolean"
-                    },
-                    tool_execution: {
-                      additionalProperties: false,
-                      properties: {
-                        mode: {
-                          default: "server",
-                          enum: [
-                            "server",
-                            "client"
-                          ],
-                          type: "string"
-                        }
-                      },
-                      required: [
-                        "mode"
-                      ],
-                      type: "object"
-                    },
-                    tool_limits: {
-                      additionalProperties: false,
-                      properties: {
-                        max_llm_calls: {
-                          default: 8,
-                          maximum: 64,
-                          minimum: 1,
-                          type: "integer"
-                        },
-                        max_tool_calls_per_step: {
-                          default: 16,
-                          maximum: 64,
-                          minimum: 1,
-                          type: "integer"
-                        },
-                        wait_ttl_ms: {
-                          default: 9e5,
-                          maximum: 864e5,
-                          minimum: 1,
-                          type: "integer"
-                        }
-                      },
-                      type: "object"
-                    }
-                  },
-                  required: [
-                    "request"
-                  ],
-                  type: "object"
-                }
-              }
-            }
-          ],
-          properties: {
-            type: {
-              const: "route.switch"
-            }
-          },
-          required: [
-            "input"
-          ]
-        },
-        {
-          properties: {
-            type: {
-              const: "join.all"
-            }
-          }
-        },
-        {
-          allOf: [
-            {
-              properties: {
-                input: {
-                  additionalProperties: false,
-                  properties: {
-                    predicate: {
-                      $ref: "#/definitions/condition"
-                    }
-                  },
-                  type: "object"
-                }
-              }
-            }
-          ],
-          properties: {
-            type: {
-              const: "join.any"
-            }
-          }
-        },
-        {
-          allOf: [
-            {
-              properties: {
-                input: {
-                  additionalProperties: false,
-                  properties: {
-                    limit: {
-                      minimum: 1,
-                      type: "integer"
-                    },
-                    predicate: {
-                      $ref: "#/definitions/condition"
-                    },
-                    timeout_ms: {
-                      minimum: 1,
-                      type: "integer"
-                    }
-                  },
-                  type: "object"
-                }
-              }
-            }
-          ],
-          properties: {
-            type: {
-              const: "join.collect"
-            }
-          },
-          required: [
-            "input"
-          ]
-        },
-        {
-          allOf: [
-            {
-              properties: {
-                input: {
-                  additionalProperties: false,
-                  oneOf: [
-                    {
-                      not: {
-                        required: [
-                          "merge"
-                        ]
-                      },
-                      required: [
-                        "object"
-                      ]
-                    },
-                    {
-                      not: {
-                        required: [
-                          "object"
-                        ]
-                      },
-                      required: [
-                        "merge"
-                      ]
-                    }
-                  ],
-                  properties: {
-                    merge: {
-                      items: {
-                        $ref: "#/definitions/transformValue"
-                      },
-                      minItems: 1,
-                      type: "array"
-                    },
-                    object: {
-                      additionalProperties: {
-                        $ref: "#/definitions/transformValue"
-                      },
-                      minProperties: 1,
-                      type: "object"
-                    }
-                  },
-                  type: "object"
-                }
-              }
-            }
-          ],
-          properties: {
-            type: {
-              const: "transform.json"
-            }
-          },
-          required: [
-            "input"
-          ]
-        },
-        {
-          allOf: [
-            {
-              properties: {
-                input: {
-                  additionalProperties: false,
-                  properties: {
-                    item_bindings: {
-                      items: {
-                        $ref: "#/definitions/mapFanoutItemBinding"
-                      },
-                      type: "array"
-                    },
-                    items: {
-                      additionalProperties: false,
-                      properties: {
-                        from: {
-                          minLength: 1,
-                          type: "string"
-                        },
-                        path: {
-                          pattern: "^(/.*)?$",
-                          type: "string"
-                        },
-                        pointer: {
-                          pattern: "^(/.*)?$",
-                          type: "string"
-                        }
-                      },
-                      required: [
-                        "from"
-                      ],
-                      type: "object"
-                    },
-                    max_parallelism: {
-                      minimum: 1,
-                      type: "integer"
-                    },
-                    subnode: {
-                      additionalProperties: false,
-                      properties: {
-                        id: {
-                          minLength: 1,
-                          type: "string"
-                        },
-                        input: {},
-                        type: {
-                          enum: [
-                            "llm.responses",
-                            "route.switch",
-                            "transform.json"
-                          ],
-                          type: "string"
-                        }
-                      },
-                      required: [
-                        "id",
-                        "type"
-                      ],
-                      type: "object"
-                    }
-                  },
-                  required: [
-                    "items",
-                    "subnode"
-                  ],
-                  type: "object"
-                }
-              }
-            }
-          ],
-          properties: {
-            type: {
-              const: "map.fanout"
-            }
-          },
-          required: [
-            "input"
-          ]
-        },
-        {
-          allOf: [
-            {
-              properties: {
-                input: {
-                  additionalProperties: false,
-                  properties: {
-                    bind_inputs: {
-                      additionalProperties: {
-                        $ref: "#/definitions/fragmentBindInput"
-                      },
-                      type: "object"
-                    },
-                    ref: {
-                      minLength: 1,
-                      type: "string"
-                    }
-                  },
-                  required: [
-                    "ref"
-                  ],
-                  type: "object"
-                }
-              }
-            }
-          ],
-          properties: {
-            type: {
-              const: "fragment"
-            }
-          },
-          required: [
-            "input"
-          ]
-        }
-      ],
-      properties: {
-        id: {
-          minLength: 1,
-          type: "string"
-        },
-        input: {},
-        type: {
-          enum: [
-            "llm.responses",
-            "route.switch",
-            "join.all",
-            "join.any",
-            "join.collect",
-            "transform.json",
-            "map.fanout",
-            "fragment"
-          ],
-          type: "string"
-        }
-      },
-      required: [
-        "id",
-        "type"
-      ],
-      type: "object"
-    },
-    output: {
-      additionalProperties: false,
-      properties: {
-        from: {
-          minLength: 1,
-          type: "string"
-        },
-        name: {
-          minLength: 1,
-          type: "string"
-        },
-        output: {
-          minLength: 1,
-          type: "string"
-        },
-        pointer: {
-          pattern: "^(/.*)?$",
-          type: "string"
-        }
-      },
-      required: [
-        "name",
-        "from"
-      ],
-      type: "object"
-    },
-    transformValue: {
-      additionalProperties: false,
-      properties: {
-        from: {
-          minLength: 1,
-          type: "string"
-        },
-        pointer: {
-          pattern: "^(/.*)?$",
-          type: "string"
-        }
-      },
-      required: [
-        "from"
-      ],
-      type: "object"
-    }
-  },
-  properties: {
-    edges: {
-      items: {
-        $ref: "#/definitions/edge"
-      },
-      type: "array"
-    },
-    execution: {
-      additionalProperties: false,
-      properties: {
-        max_parallelism: {
-          minimum: 1,
-          type: "integer"
-        },
-        node_timeout_ms: {
-          minimum: 1,
-          type: "integer"
-        },
-        run_timeout_ms: {
-          minimum: 1,
-          type: "integer"
-        }
-      },
-      type: "object"
-    },
-    fragments: {
-      additionalProperties: {
-        $ref: "#/definitions/fragmentDef"
-      },
-      type: "object"
-    },
-    kind: {
-      const: "workflow.v1",
-      type: "string"
-    },
-    name: {
-      type: "string"
-    },
-    nodes: {
-      items: {
-        $ref: "#/definitions/node"
-      },
-      minItems: 1,
-      type: "array"
-    },
-    outputs: {
-      items: {
-        $ref: "#/definitions/output"
-      },
-      minItems: 1,
-      type: "array"
-    }
-  },
-  required: [
-    "kind",
-    "nodes",
-    "outputs"
-  ],
-  title: "ModelRelay workflow.v1",
-  type: "object"
-};
-
-// src/workflow_patterns.ts
-var LLM_TEXT_OUTPUT_INTERNAL = "/output/0/content/0/text";
-var LLM_USER_MESSAGE_TEXT_INTERNAL = "/input/1/content/0/text";
-function wireRequest2(req) {
-  const raw = req;
-  if (raw && typeof raw === "object") {
-    if ("input" in raw) {
-      return req;
-    }
-    if ("body" in raw) {
-      return raw.body ?? {};
-    }
+    return `targets ${pointer} but request only has ${input.length} messages (indices 0-${input.length - 1}); add placeholder messages or adjust binding target`;
   }
-  return asInternal(req).body;
-}
-function sortEdges(edges) {
-  return edges.slice().sort((a, b) => {
-    const af = String(a.from);
-    const bf = String(b.from);
-    if (af < bf) return -1;
-    if (af > bf) return 1;
-    const at = String(a.to);
-    const bt = String(b.to);
-    if (at < bt) return -1;
-    if (at > bt) return 1;
-    return 0;
-  });
-}
-function sortOutputs(outputs) {
-  return outputs.slice().sort((a, b) => {
-    const an = String(a.name);
-    const bn = String(b.name);
-    if (an < bn) return -1;
-    if (an > bn) return 1;
-    const af = String(a.from);
-    const bf = String(b.from);
-    if (af < bf) return -1;
-    if (af > bf) return 1;
-    const ap = a.pointer ?? "";
-    const bp = b.pointer ?? "";
-    if (ap < bp) return -1;
-    if (ap > bp) return 1;
-    return 0;
-  });
-}
-function LLMStep(id, request) {
-  const config = {
-    id,
-    request: wireRequest2(request),
-    stream: false
-  };
-  return {
-    ...config,
-    withStream() {
-      return { ...config, stream: true };
+  if (match[2] !== void 0) {
+    const contentIndex = parseInt(match[2], 10);
+    const msg = input[msgIndex];
+    if (contentIndex >= msg.content.length) {
+      return `targets ${pointer} but message ${msgIndex} only has ${msg.content.length} content blocks (indices 0-${msg.content.length - 1})`;
     }
-  };
-}
-var ChainBuilder = class _ChainBuilder {
-  constructor(state) {
-    this.state = state;
   }
-  static create(name, steps) {
-    return new _ChainBuilder({ name, steps, outputs: [] });
+  return void 0;
+}
+function validateMapFanoutInput(nodeId, input) {
+  const subnode = input.subnode;
+  if ((subnode.type === WorkflowNodeTypesV1.LLMResponses || subnode.type === WorkflowNodeTypesV1.RouteSwitch) && subnode.input.bindings && subnode.input.bindings.length > 0) {
+    throw new MapFanoutInputError(nodeId, "map.fanout subnode bindings are not allowed");
   }
-  with(patch) {
-    return new _ChainBuilder({ ...this.state, ...patch });
+  if (subnode.type !== WorkflowNodeTypesV1.TransformJSON) {
+    return;
   }
-  /**
-   * Sets the workflow execution configuration.
-   */
-  execution(exec) {
-    return this.with({ execution: exec });
+  if (input.item_bindings && input.item_bindings.length > 0) {
+    throw new MapFanoutInputError(
+      nodeId,
+      "map.fanout transform.json subnode cannot use item_bindings"
+    );
   }
-  /**
-   * Adds an output reference from a specific step.
-   */
-  output(name, from) {
-    return this.with({
-      outputs: [
-        ...this.state.outputs,
-        {
-          name,
-          from,
-          pointer: LLM_TEXT_OUTPUT_INTERNAL
-        }
-      ]
-    });
+  const hasObject = !!subnode.input.object && Object.keys(subnode.input.object).length > 0;
+  const hasMerge = !!subnode.input.merge && subnode.input.merge.length > 0;
+  if (hasObject === hasMerge) {
+    throw new MapFanoutInputError(
+      nodeId,
+      "map.fanout transform.json must provide exactly one of object or merge"
+    );
   }
-  /**
-   * Adds an output reference from the last step.
-   */
-  outputLast(name) {
-    if (this.state.steps.length === 0) {
-      return this;
+  if (hasObject) {
+    for (const [key, value] of Object.entries(subnode.input.object ?? {})) {
+      if (!key.trim()) continue;
+      if (String(value.from) !== "item") {
+        throw new MapFanoutInputError(
+          nodeId,
+          `map.fanout transform.json object.${key}.from must be "item"`
+        );
+      }
     }
-    return this.output(name, this.state.steps[this.state.steps.length - 1].id);
   }
-  /**
-   * Builds and returns the compiled workflow spec.
-   * @throws Error if no steps are provided
-   */
-  build() {
-    if (this.state.steps.length === 0) {
-      throw new Error("chain requires at least one step");
-    }
-    const nodes = [];
-    const edges = [];
-    for (let i = 0; i < this.state.steps.length; i++) {
-      const step = this.state.steps[i];
-      const bindings = [];
-      if (i > 0) {
-        const prevId = this.state.steps[i - 1].id;
-        bindings.push({
-          from: prevId,
-          pointer: LLM_TEXT_OUTPUT_INTERNAL,
-          to: LLM_USER_MESSAGE_TEXT_INTERNAL,
-          encoding: "json_string"
-        });
-        edges.push({ from: prevId, to: step.id });
+  if (hasMerge) {
+    for (const [index, value] of (subnode.input.merge ?? []).entries()) {
+      if (String(value.from) !== "item") {
+        throw new MapFanoutInputError(
+          nodeId,
+          `map.fanout transform.json merge[${index}].from must be "item"`
+        );
       }
-      const input = {
-        id: step.id,
-        type: WorkflowNodeTypes.LLMResponses,
-        input: {
-          request: step.request,
-          ...step.stream ? { stream: true } : {},
-          ...bindings.length > 0 ? { bindings } : {}
-        }
-      };
-      nodes.push(input);
     }
-    return {
-      kind: WorkflowKinds.WorkflowV0,
-      name: this.state.name,
-      ...this.state.execution ? { execution: this.state.execution } : {},
-      nodes,
-      ...edges.length > 0 ? { edges: sortEdges(edges) } : {},
-      outputs: sortOutputs(this.state.outputs)
-    };
   }
-};
-function Chain(name, steps) {
-  return ChainBuilder.create(name, steps);
 }
-var ParallelBuilder = class _ParallelBuilder {
-  constructor(state) {
+var WorkflowBuilderV1 = class _WorkflowBuilderV1 {
+  constructor(state = { nodes: [], edges: [], outputs: [] }) {
     this.state = state;
   }
-  static create(name, steps) {
-    return new _ParallelBuilder({ name, steps, outputs: [] });
+  static new() {
+    return new _WorkflowBuilderV1();
   }
   with(patch) {
-    return new _ParallelBuilder({ ...this.state, ...patch });
-  }
-  /**
-   * Sets the workflow execution configuration.
-   */
-  execution(exec) {
-    return this.with({ execution: exec });
-  }
-  /**
-   * Adds a join node that waits for all parallel steps,
-   * followed by an aggregator LLM node that receives the combined output.
-   * The join node ID is automatically generated as "<id>_join".
-   */
-  aggregate(id, request) {
-    return this.with({
-      aggregate: {
-        id,
-        request: wireRequest2(request),
-        stream: false
-      }
+    return new _WorkflowBuilderV1({
+      ...this.state,
+      ...patch
     });
   }
-  /**
-   * Like aggregate() but enables streaming on the aggregator node.
-   */
-  aggregateWithStream(id, request) {
-    return this.with({
-      aggregate: {
-        id,
-        request: wireRequest2(request),
-        stream: true
-      }
-    });
+  name(name) {
+    return this.with({ name: name.trim() || void 0 });
   }
-  /**
-   * Adds an output reference from a specific step.
-   */
-  output(name, from) {
-    return this.with({
-      outputs: [
-        ...this.state.outputs,
-        {
-          name,
-          from,
-          pointer: LLM_TEXT_OUTPUT_INTERNAL
-        }
-      ]
-    });
+  execution(execution) {
+    return this.with({ execution });
   }
-  /**
-   * Builds and returns the compiled workflow spec.
-   * @throws Error if no steps are provided
-   */
-  build() {
-    if (this.state.steps.length === 0) {
-      throw new Error("parallel requires at least one step");
-    }
-    const nodes = [];
-    const edges = [];
-    for (const step of this.state.steps) {
-      const input = {
-        id: step.id,
-        type: WorkflowNodeTypes.LLMResponses,
-        input: {
-          request: step.request,
-          ...step.stream ? { stream: true } : {}
-        }
-      };
-      nodes.push(input);
-    }
-    if (this.state.aggregate) {
-      const joinId = `${this.state.aggregate.id}_join`;
-      nodes.push({ id: joinId, type: WorkflowNodeTypes.JoinAll });
-      for (const step of this.state.steps) {
-        edges.push({ from: step.id, to: joinId });
-      }
-      const aggInput = {
-        id: this.state.aggregate.id,
-        type: WorkflowNodeTypes.LLMResponses,
-        input: {
-          request: this.state.aggregate.request,
-          ...this.state.aggregate.stream ? { stream: true } : {},
-          bindings: [
-            {
-              from: joinId,
-              // Empty pointer = full join output
-              to: LLM_USER_MESSAGE_TEXT_INTERNAL,
-              encoding: "json_string"
-            }
-          ]
-        }
-      };
-      nodes.push(aggInput);
-      edges.push({ from: joinId, to: this.state.aggregate.id });
+  node(node) {
+    return this.with({ nodes: [...this.state.nodes, node] });
+  }
+  llmResponses(id, request, options = {}) {
+    const wiredRequest = wireRequest(request);
+    if (options.bindings) {
+      validateBindingTargets(id, wiredRequest.input, options.bindings);
     }
-    return {
-      kind: WorkflowKinds.WorkflowV0,
-      name: this.state.name,
-      ...this.state.execution ? { execution: this.state.execution } : {},
-      nodes,
-      ...edges.length > 0 ? { edges: sortEdges(edges) } : {},
-      outputs: sortOutputs(this.state.outputs)
+    const input = {
+      request: wiredRequest,
+      ...options.stream === void 0 ? {} : { stream: options.stream },
+      ...options.toolExecution === void 0 ? {} : { tool_execution: { mode: options.toolExecution } },
+      ...options.toolLimits === void 0 ? {} : { tool_limits: { ...options.toolLimits } },
+      ...options.bindings === void 0 ? {} : { bindings: options.bindings.slice() }
     };
+    return this.node({
+      id,
+      type: WorkflowNodeTypesV1.LLMResponses,
+      input
+    });
   }
-};
-function Parallel(name, steps) {
-  return ParallelBuilder.create(name, steps);
-}
-function MapItem(id, request) {
-  const config = {
-    id,
-    request: wireRequest2(request),
-    stream: false
-  };
-  return {
-    ...config,
-    withStream() {
-      return { ...config, stream: true };
+  routeSwitch(id, request, options = {}) {
+    const wiredRequest = wireRequest(request);
+    if (options.bindings) {
+      validateBindingTargets(id, wiredRequest.input, options.bindings);
     }
-  };
-}
-var MapReduceBuilder = class _MapReduceBuilder {
-  constructor(state) {
-    this.state = state;
-  }
-  static create(name, items) {
-    return new _MapReduceBuilder({ name, items, outputs: [] });
+    const input = {
+      request: wiredRequest,
+      ...options.stream === void 0 ? {} : { stream: options.stream },
+      ...options.toolExecution === void 0 ? {} : { tool_execution: { mode: options.toolExecution } },
+      ...options.toolLimits === void 0 ? {} : { tool_limits: { ...options.toolLimits } },
+      ...options.bindings === void 0 ? {} : { bindings: options.bindings.slice() }
+    };
+    return this.node({
+      id,
+      type: WorkflowNodeTypesV1.RouteSwitch,
+      input
+    });
   }
-  with(patch) {
-    return new _MapReduceBuilder({ ...this.state, ...patch });
+  joinAll(id) {
+    return this.node({ id, type: WorkflowNodeTypesV1.JoinAll });
   }
-  /**
-   * Adds a mapper item to the workflow.
-   * Each item becomes a separate LLM node that runs in parallel.
-   */
-  item(id, request) {
-    return this.with({
-      items: [...this.state.items, { id, request: wireRequest2(request), stream: false }]
+  joinAny(id, input) {
+    return this.node({
+      id,
+      type: WorkflowNodeTypesV1.JoinAny,
+      ...input ? { input } : {}
     });
   }
-  /**
-   * Adds a mapper item with streaming enabled.
-   */
-  itemWithStream(id, request) {
-    return this.with({
-      items: [...this.state.items, { id, request: wireRequest2(request), stream: true }]
-    });
+  joinCollect(id, input) {
+    return this.node({ id, type: WorkflowNodeTypesV1.JoinCollect, input });
   }
-  /**
-   * Sets the workflow execution configuration.
-   */
-  execution(exec) {
-    return this.with({ execution: exec });
+  transformJSON(id, input) {
+    return this.node({ id, type: WorkflowNodeTypesV1.TransformJSON, input });
   }
-  /**
-   * Adds a reducer node that receives all mapper outputs.
-   * The reducer receives a JSON object mapping each mapper ID to its text output.
-   * The join node ID is automatically generated as "<id>_join".
-   */
-  reduce(id, request) {
-    return this.with({
-      reducer: {
-        id,
-        request: wireRequest2(request),
-        stream: false
-      }
-    });
+  mapFanout(id, input) {
+    validateMapFanoutInput(id, input);
+    return this.node({ id, type: WorkflowNodeTypesV1.MapFanout, input });
   }
-  /**
-   * Like reduce() but enables streaming on the reducer node.
-   */
-  reduceWithStream(id, request) {
+  edge(from, to, when) {
     return this.with({
-      reducer: {
-        id,
-        request: wireRequest2(request),
-        stream: true
-      }
+      edges: [...this.state.edges, { from, to, ...when ? { when } : {} }]
     });
   }
-  /**
-   * Adds an output reference from a specific node.
-   * Typically used to output from the reducer node.
-   */
-  output(name, from) {
+  output(name, from, pointer) {
     return this.with({
       outputs: [
         ...this.state.outputs,
-        {
-          name,
-          from,
-          pointer: LLM_TEXT_OUTPUT_INTERNAL
-        }
+        { name, from, ...pointer ? { pointer } : {} }
       ]
     });
   }
-  /**
-   * Builds and returns the compiled workflow spec.
-   * @throws Error if no items are provided or no reducer is configured
-   */
   build() {
-    if (this.state.items.length === 0) {
-      throw new Error("map-reduce requires at least one item");
-    }
-    if (!this.state.reducer) {
-      throw new Error("map-reduce requires a reducer (call reduce)");
-    }
-    const seenIds = /* @__PURE__ */ new Set();
-    for (const item of this.state.items) {
-      if (!item.id) {
-        throw new Error("item ID cannot be empty");
-      }
-      if (seenIds.has(item.id)) {
-        throw new Error(`duplicate item ID: "${item.id}"`);
-      }
-      seenIds.add(item.id);
-    }
-    const nodes = [];
-    const edges = [];
-    const joinId = `${this.state.reducer.id}_join`;
-    for (const item of this.state.items) {
-      const mapperId = `map_${item.id}`;
-      const input = {
-        id: mapperId,
-        type: WorkflowNodeTypes.LLMResponses,
-        input: {
-          request: item.request,
-          ...item.stream ? { stream: true } : {}
-        }
-      };
-      nodes.push(input);
-      edges.push({ from: mapperId, to: joinId });
-    }
-    nodes.push({ id: joinId, type: WorkflowNodeTypes.JoinAll });
-    const reducerInput = {
-      id: this.state.reducer.id,
-      type: WorkflowNodeTypes.LLMResponses,
-      input: {
-        request: this.state.reducer.request,
-        ...this.state.reducer.stream ? { stream: true } : {},
-        bindings: [
-          {
-            from: joinId,
-            // Empty pointer = full join output
-            to: LLM_USER_MESSAGE_TEXT_INTERNAL,
-            encoding: "json_string"
-          }
-        ]
-      }
-    };
-    nodes.push(reducerInput);
-    edges.push({ from: joinId, to: this.state.reducer.id });
+    const edges = this.state.edges.slice().sort((a, b) => {
+      const af = String(a.from);
+      const bf = String(b.from);
+      if (af < bf) return -1;
+      if (af > bf) return 1;
+      const at = String(a.to);
+      const bt = String(b.to);
+      if (at < bt) return -1;
+      if (at > bt) return 1;
+      const aw = a.when ? JSON.stringify(a.when) : "";
+      const bw = b.when ? JSON.stringify(b.when) : "";
+      if (aw < bw) return -1;
+      if (aw > bw) return 1;
+      return 0;
+    });
+    const outputs = this.state.outputs.slice().sort((a, b) => {
+      const an = String(a.name);
+      const bn = String(b.name);
+      if (an < bn) return -1;
+      if (an > bn) return 1;
+      const af = String(a.from);
+      const bf = String(b.from);
+      if (af < bf) return -1;
+      if (af > bf) return 1;
+      const ap = a.pointer ?? "";
+      const bp = b.pointer ?? "";
+      if (ap < bp) return -1;
+      if (ap > bp) return 1;
+      return 0;
+    });
     return {
-      kind: WorkflowKinds.WorkflowV0,
-      name: this.state.name,
+      kind: WorkflowKinds.WorkflowV1,
+      ...this.state.name ? { name: this.state.name } : {},
       ...this.state.execution ? { execution: this.state.execution } : {},
-      nodes,
-      ...edges.length > 0 ? { edges: sortEdges(edges) } : {},
-      outputs: sortOutputs(this.state.outputs)
+      nodes: this.state.nodes.slice(),
+      ...edges.length ? { edges } : {},
+      outputs
     };
   }
 };
-function MapReduce(name, items = []) {
-  return MapReduceBuilder.create(name, items);
+function workflowV1() {
+  return WorkflowBuilderV1.new();
 }
 
 // src/testing.ts
@@ -7626,14 +5004,13 @@ __export(workflow_exports, {
   BindingBuilder: () => BindingBuilder,
   BindingEncodings: () => BindingEncodings,
   FanoutReduceV1: () => FanoutReduceV1,
-  KindV0: () => KindV0,
   KindV1: () => KindV1,
   LLM_TEXT_OUTPUT: () => LLM_TEXT_OUTPUT,
   LLM_USER_MESSAGE_TEXT: () => LLM_USER_MESSAGE_TEXT,
-  NodeTypes: () => NodeTypes,
   NodeTypesV1: () => NodeTypesV1,
   RouterV1: () => RouterV1,
   ToolExecutionModes: () => ToolExecutionModes,
+  WorkflowBuilderV1: () => WorkflowBuilderV1,
   bindFrom: () => bindFrom,
   bindToPlaceholder: () => bindToPlaceholder,
   bindToPointer: () => bindToPointer,
@@ -7646,7 +5023,8 @@ __export(workflow_exports, {
   whenOutputMatches: () => whenOutputMatches,
   whenStatusEquals: () => whenStatusEquals,
   whenStatusExists: () => whenStatusExists,
-  whenStatusMatches: () => whenStatusMatches
+  whenStatusMatches: () => whenStatusMatches,
+  workflowV1: () => workflowV1
 });
 
 // src/workflow/helpers_v1.ts
@@ -7738,7 +5116,7 @@ var BindingBuilder = class {
 };
 
 // src/workflow/patterns_v1.ts
-function wireRequest3(req) {
+function wireRequest2(req) {
   const raw = req;
   if (raw && typeof raw === "object") {
     if ("input" in raw) {
@@ -7831,7 +5209,7 @@ var FanoutReduceV1 = class {
         encoding: "json_string"
       }
     ];
-    const mapperRequest = wireRequest3(mapper);
+    const mapperRequest = wireRequest2(mapper);
     builder = builder.mapFanout(fanoutId, {
       items: { from: generatorId, path: itemsPath },
       item_bindings: itemBindings,
@@ -7860,13 +5238,7 @@ var FanoutReduceV1 = class {
 };
 
 // src/workflow/index.ts
-var KindV0 = WorkflowKinds.WorkflowV0;
 var KindV1 = WorkflowKinds.WorkflowV1;
-var NodeTypes = {
-  LLMResponses: WorkflowNodeTypes.LLMResponses,
-  JoinAll: WorkflowNodeTypes.JoinAll,
-  TransformJSON: WorkflowNodeTypes.TransformJSON
-};
 var NodeTypesV1 = {
   LLMResponses: WorkflowNodeTypesV1.LLMResponses,
   RouteSwitch: WorkflowNodeTypesV1.RouteSwitch,
@@ -7890,9 +5262,6 @@ var ModelRelay = class _ModelRelay {
   static fromSecretKey(secretKey, options = {}) {
     return new _ModelRelay({ ...options, key: parseSecretKey(secretKey) });
   }
-  static fromPublishableKey(publishableKey, options = {}) {
-    return new _ModelRelay({ ...options, key: parsePublishableKey(publishableKey) });
-  }
   static fromApiKey(apiKey, options = {}) {
     return new _ModelRelay({ ...options, key: parseApiKey(apiKey) });
   }
@@ -7921,7 +5290,6 @@ var ModelRelay = class _ModelRelay {
     const auth = new AuthClient(this.http, {
       apiKey,
       accessToken,
-      customer: cfg.customer,
       tokenProvider
     });
     this.auth = auth;
@@ -7939,7 +5307,7 @@ var ModelRelay = class _ModelRelay {
     });
     this.images = new ImagesClient(this.http, auth);
     this.sessions = new SessionsClient(this, this.http, auth);
-    this.tiers = new TiersClient(this.http, { apiKey });
+    this.tiers = new TiersClient(this.http, { apiKey, accessToken });
   }
   forCustomer(customerId) {
     return new CustomerScopedModelRelay(this.responses, customerId, this.baseUrl);
@@ -7954,8 +5322,6 @@ export {
   AuthClient,
   BillingProviders,
   BindingTargetError,
-  Chain,
-  ChainBuilder,
   ConfigError,
   ContentPartTypes,
   CustomerResponsesClient,
@@ -7966,7 +5332,6 @@ export {
   DEFAULT_CONNECT_TIMEOUT_MS,
   DEFAULT_REQUEST_TIMEOUT_MS,
   ErrorCodes,
-  FrontendTokenProvider,
   ImagesClient,
   InputItemTypes,
   JoinOutput,
@@ -7978,29 +5343,21 @@ export {
   LLMInputPath,
   LLMInputSystemText,
   LLMInputUserText,
-  LLMNodeBuilder,
   LLMOutput,
   LLMOutputContentItemPath,
   LLMOutputContentPath,
   LLMOutputPath,
   LLMOutputText,
-  LLMStep,
   LLM_TEXT_OUTPUT,
   LLM_USER_MESSAGE_TEXT,
   LocalSession,
   MapFanoutInputError,
-  MapItem,
-  MapReduce,
-  MapReduceBuilder,
   MemorySessionStore,
   MessageRoles,
   ModelRelay,
   ModelRelayError,
-  OIDCExchangeTokenProvider,
   OutputFormatTypes,
   OutputItemTypes,
-  Parallel,
-  ParallelBuilder,
   PathEscapeError,
   ResponsesClient,
   ResponsesStream,
@@ -8023,15 +5380,13 @@ export {
   ToolRegistry,
   ToolRunner,
   ToolTypes,
-  TransformJSONNodeBuilder,
   TransportError,
   WORKFLOWS_COMPILE_PATH,
   WebToolIntents,
-  Workflow,
-  WorkflowBuilderV0,
   WorkflowBuilderV1,
   WorkflowKinds,
-  WorkflowNodeTypes,
+  WorkflowNodeTypesV1 as WorkflowNodeTypes,
+  WorkflowNodeTypesV1,
   WorkflowValidationError,
   WorkflowsClient,
   asModelId,
@@ -8067,17 +5422,10 @@ export {
   getRetryableErrors,
   hasRetryableErrors,
   hasToolCalls,
-  isAutoProvisionDisabled,
-  isAutoProvisionMisconfigured,
-  isEmailRequired,
-  isIdentityRequired,
-  isProvisioningError,
-  isPublishableKey,
   isSecretKey,
   mergeMetrics,
   mergeTrace,
   modelToString,
-  newWorkflow,
   normalizeModelId,
   normalizeStopReason,
   outputFormatFromZod,
@@ -8086,33 +5434,22 @@ export {
   parseNodeId,
   parseOutputName,
   parsePlanHash,
-  parsePublishableKey,
   parseRunId,
   parseSecretKey,
   parseToolArgs,
   parseToolArgsRaw,
-  pollOAuthDeviceToken,
-  pollUntil,
   respondToToolCall,
-  runOAuthDeviceFlowForIDToken,
-  startOAuthDeviceAuthorization,
   stopReasonToString,
   toolChoiceAuto,
   toolChoiceNone,
   toolChoiceRequired,
   toolResultMessage,
   transformJSONMerge,
-  transformJSONMergeV1,
   transformJSONObject,
-  transformJSONObjectV1,
   transformJSONValue,
-  transformJSONValueV1,
   tryParseToolArgs,
   validateWithZod,
   workflow_exports as workflow,
-  workflowV0,
-  workflow_v0_schema_default as workflowV0Schema,
   workflowV1,
-  workflow_v1_schema_default as workflowV1Schema,
   zodToJsonSchema
 };