@modelrelay/sdk 1.25.0 → 1.28.0

package/dist/index.js

@@ -1,283 +1,76 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/errors.ts
-var ErrorCodes = {
-  NOT_FOUND: "NOT_FOUND",
-  VALIDATION_ERROR: "VALIDATION_ERROR",
-  RATE_LIMIT: "RATE_LIMIT",
-  UNAUTHORIZED: "UNAUTHORIZED",
-  FORBIDDEN: "FORBIDDEN",
-  CONFLICT: "CONFLICT",
-  INTERNAL_ERROR: "INTERNAL_ERROR",
-  SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE",
-  INVALID_INPUT: "INVALID_INPUT",
-  PAYMENT_REQUIRED: "PAYMENT_REQUIRED",
-  METHOD_NOT_ALLOWED: "METHOD_NOT_ALLOWED",
-  /** Identity provider + subject required for identity-based auth. */
-  IDENTITY_REQUIRED: "IDENTITY_REQUIRED",
-  /** Auto-provision disabled for the project. */
-  AUTO_PROVISION_DISABLED: "AUTO_PROVISION_DISABLED",
-  /** Auto-provision tier misconfigured for the project. */
-  AUTO_PROVISION_MISCONFIGURED: "AUTO_PROVISION_MISCONFIGURED",
-  /** Email required for auto-provisioning a new customer. */
-  EMAIL_REQUIRED: "EMAIL_REQUIRED"
-};
-var ModelRelayError = class extends Error {
-  constructor(message, opts) {
-    super(message);
-    this.name = this.constructor.name;
-    this.category = opts.category;
-    this.status = opts.status;
-    this.code = opts.code;
-    this.requestId = opts.requestId;
-    this.fields = opts.fields;
-    this.data = opts.data;
-    this.retries = opts.retries;
-    this.cause = opts.cause;
-  }
-};
-var ConfigError = class extends ModelRelayError {
-  constructor(message, data) {
-    super(message, { category: "config", status: 400, data });
-  }
-};
-var TransportError = class extends ModelRelayError {
-  constructor(message, opts) {
-    super(message, {
-      category: "transport",
-      status: opts.kind === "timeout" ? 408 : 0,
-      retries: opts.retries,
-      cause: opts.cause,
-      data: opts.cause
-    });
-    this.kind = opts.kind;
-  }
-};
-var StreamProtocolError = class extends TransportError {
-  constructor(opts) {
-    const got = opts.receivedContentType?.trim() || "<missing>";
-    super(`expected NDJSON stream (${opts.expectedContentType}), got Content-Type ${got}`, {
-      kind: "request"
-    });
-    this.expectedContentType = opts.expectedContentType;
-    this.receivedContentType = opts.receivedContentType?.trim() || void 0;
-    this.status = opts.status;
-  }
-};
-var StreamTimeoutError = class extends ModelRelayError {
-  constructor(streamKind, timeoutMs) {
-    const label = streamKind === "ttft" ? "TTFT" : streamKind === "idle" ? "idle" : "total";
-    super(`stream ${label} timeout after ${timeoutMs}ms`, { category: "transport", status: 408 });
-    this.kind = streamKind;
-    this.timeoutMs = timeoutMs;
-  }
-};
-var APIError = class extends ModelRelayError {
-  constructor(message, opts) {
-    super(message, {
-      category: "api",
-      status: opts.status,
-      code: opts.code,
-      requestId: opts.requestId,
-      fields: opts.fields,
-      data: opts.data,
-      retries: opts.retries
-    });
-  }
-  /** Returns true if the error is a not found error. */
-  isNotFound() {
-    return this.code === ErrorCodes.NOT_FOUND;
-  }
-  /** Returns true if the error is a validation error. */
-  isValidation() {
-    return this.code === ErrorCodes.VALIDATION_ERROR || this.code === ErrorCodes.INVALID_INPUT;
-  }
-  /** Returns true if the error is a rate limit error. */
-  isRateLimit() {
-    return this.code === ErrorCodes.RATE_LIMIT;
-  }
-  /** Returns true if the error is an unauthorized error. */
-  isUnauthorized() {
-    return this.code === ErrorCodes.UNAUTHORIZED;
-  }
-  /** Returns true if the error is a forbidden error. */
-  isForbidden() {
-    return this.code === ErrorCodes.FORBIDDEN;
-  }
-  /** Returns true if the error is a service unavailable error. */
-  isUnavailable() {
-    return this.code === ErrorCodes.SERVICE_UNAVAILABLE;
-  }
-  /**
-   * Returns true if the error indicates identity is missing/invalid for identity-based auth.
-   */
-  isIdentityRequired() {
-    return this.code === ErrorCodes.IDENTITY_REQUIRED;
-  }
-  /**
-   * Returns true if auto-provisioning is disabled for the project.
-   * To resolve: configure customer auto-provisioning on the project (select a default tier).
-   */
-  isAutoProvisionDisabled() {
-    return this.code === ErrorCodes.AUTO_PROVISION_DISABLED;
-  }
-  /**
-   * Returns true if email is required for auto-provisioning a new customer.
-   * To resolve: provide the 'email' field in your frontend token request.
-   */
-  isEmailRequired() {
-    return this.code === ErrorCodes.EMAIL_REQUIRED;
-  }
-  /**
-   * Returns true if auto-provisioning is misconfigured for the project.
-   * To resolve: ensure the configured auto-provision tier exists and belongs to the project.
-   */
-  isAutoProvisionMisconfigured() {
-    return this.code === ErrorCodes.AUTO_PROVISION_MISCONFIGURED;
-  }
-  /**
-   * Returns true if this is a customer provisioning error (identity not found + auto-provision disabled/misconfigured, or email required).
-   */
-  isProvisioningError() {
-    return this.isAutoProvisionDisabled() || this.isAutoProvisionMisconfigured() || this.isEmailRequired();
-  }
-};
-var WorkflowValidationError = class extends ModelRelayError {
-  constructor(opts) {
-    const msg = opts.issues.length === 0 ? "workflow validation error" : opts.issues[0]?.message || "workflow validation error";
-    super(msg, {
-      category: "api",
-      status: opts.status,
-      requestId: opts.requestId,
-      data: opts.data,
-      retries: opts.retries
-    });
-    this.issues = opts.issues;
-  }
-};
-var ToolArgumentError = class extends ModelRelayError {
-  constructor(opts) {
-    super(opts.message, {
-      category: "config",
-      status: 400,
-      cause: opts.cause
-    });
-    this.toolCallId = opts.toolCallId;
-    this.toolName = opts.toolName;
-    this.rawArguments = opts.rawArguments;
-  }
-};
-var PathEscapeError = class extends ModelRelayError {
-  constructor(opts) {
-    super(`path escapes sandbox: ${opts.requestedPath}`, {
-      category: "config",
-      status: 403
-    });
-    this.requestedPath = opts.requestedPath;
-    this.resolvedPath = opts.resolvedPath;
-  }
-};
-function isEmailRequired(err) {
-  return err instanceof APIError && err.isEmailRequired();
-}
-function isIdentityRequired(err) {
-  return err instanceof APIError && err.isIdentityRequired();
-}
-function isAutoProvisionDisabled(err) {
-  return err instanceof APIError && err.isAutoProvisionDisabled();
-}
-function isAutoProvisionMisconfigured(err) {
-  return err instanceof APIError && err.isAutoProvisionMisconfigured();
-}
-function isProvisioningError(err) {
-  return err instanceof APIError && err.isProvisioningError();
-}
-async function parseErrorResponse(response, retries) {
-  const requestId = response.headers.get("X-ModelRelay-Request-Id") || response.headers.get("X-Request-Id") || void 0;
-  const fallbackMessage = response.statusText || "Request failed";
-  const status = response.status || 500;
-  let bodyText = "";
-  let bodyReadErr;
-  try {
-    bodyText = await response.text();
-  } catch (err) {
-    bodyReadErr = err;
-  }
-  if (!bodyText) {
-    return new APIError(fallbackMessage, {
-      status,
-      requestId,
-      retries,
-      data: bodyReadErr ? {
-        body_read_error: bodyReadErr instanceof Error ? bodyReadErr.message : String(bodyReadErr)
-      } : void 0
-    });
-  }
-  try {
-    const parsed = JSON.parse(bodyText);
-    const parsedObj = typeof parsed === "object" && parsed !== null ? parsed : null;
-    const issues = Array.isArray(parsedObj?.issues) ? parsedObj?.issues : null;
-    if (status === 400 && issues && issues.length > 0) {
-      const normalized = [];
-      for (const raw of issues) {
-        if (!raw || typeof raw !== "object") continue;
-        const obj = raw;
-        const code = typeof obj.code === "string" ? obj.code : "";
-        const path2 = typeof obj.path === "string" ? obj.path : "";
-        const message = typeof obj.message === "string" ? obj.message : "";
-        if (!code || !path2 || !message) continue;
-        normalized.push({ code, path: path2, message });
-      }
-      if (normalized.length > 0) {
-        return new WorkflowValidationError({
-          status,
-          requestId,
-          issues: normalized,
-          retries,
-          data: parsed
-        });
-      }
-    }
-    if (parsedObj?.error && typeof parsedObj.error === "object") {
-      const errPayload = parsedObj.error;
-      const message = errPayload?.message || fallbackMessage;
-      const code = errPayload?.code || void 0;
-      const fields = Array.isArray(errPayload?.fields) ? errPayload?.fields : void 0;
-      const parsedStatus = typeof errPayload?.status === "number" ? errPayload.status : status;
-      return new APIError(message, {
-        status: parsedStatus,
-        code,
-        fields,
-        requestId: parsedObj?.request_id || parsedObj?.requestId || requestId,
-        data: parsed,
-        retries
-      });
-    }
-    if (parsedObj?.message || parsedObj?.code) {
-      const message = parsedObj.message || fallbackMessage;
-      return new APIError(message, {
-        status,
-        code: parsedObj.code,
-        fields: parsedObj.fields,
-        requestId: parsedObj?.request_id || parsedObj?.requestId || requestId,
-        data: parsed,
-        retries
-      });
-    }
-    return new APIError(fallbackMessage, {
-      status,
-      requestId,
-      data: parsed,
-      retries
-    });
-  } catch {
-    return new APIError(bodyText, { status, requestId, retries });
-  }
-}
+import {
+  APIError,
+  BillingProviders,
+  ConfigError,
+  ContentPartTypes,
+  DEFAULT_BASE_URL,
+  DEFAULT_CLIENT_HEADER,
+  DEFAULT_CONNECT_TIMEOUT_MS,
+  DEFAULT_REQUEST_TIMEOUT_MS,
+  ErrorCodes,
+  InputItemTypes,
+  MessageRoles,
+  ModelRelayError,
+  OutputFormatTypes,
+  OutputItemTypes,
+  PathEscapeError,
+  SDK_VERSION,
+  StopReasons,
+  StreamProtocolError,
+  StreamTimeoutError,
+  SubscriptionStatuses,
+  ToolArgsError,
+  ToolArgumentError,
+  ToolCallAccumulator,
+  ToolChoiceTypes,
+  ToolRegistry,
+  ToolTypes,
+  TransportError,
+  WebToolIntents,
+  WorkflowValidationError,
+  __export,
+  asModelId,
+  asProviderId,
+  asTierCode,
+  assistantMessageWithToolCalls,
+  createAssistantMessage,
+  createFunctionCall,
+  createFunctionTool,
+  createFunctionToolFromSchema,
+  createRetryMessages,
+  createSystemMessage,
+  createToolCall,
+  createUsage,
+  createUserMessage,
+  createWebTool,
+  executeWithRetry,
+  firstToolCall,
+  formatToolErrorForModel,
+  getRetryableErrors,
+  hasRetryableErrors,
+  hasToolCalls,
+  isAutoProvisionDisabled,
+  isAutoProvisionMisconfigured,
+  isEmailRequired,
+  isIdentityRequired,
+  isProvisioningError,
+  mergeMetrics,
+  mergeTrace,
+  modelToString,
+  normalizeModelId,
+  normalizeStopReason,
+  parseErrorResponse,
+  parseToolArgs,
+  parseToolArgsRaw,
+  respondToToolCall,
+  stopReasonToString,
+  toolChoiceAuto,
+  toolChoiceNone,
+  toolChoiceRequired,
+  toolResultMessage,
+  tryParseToolArgs,
+  zodToJsonSchema
+} from "./chunk-G5H7EY4F.js";
 
 // src/api_keys.ts
 var PUBLISHABLE_PREFIX = "mr_pk_";
@@ -580,8 +373,8 @@ var AuthClient = class {
       params.set("provider", request.provider);
     }
     const queryString = params.toString();
-    const path2 = queryString ? `/auth/device/start?${queryString}` : "/auth/device/start";
-    const apiResp = await this.http.json(path2, {
+    const path = queryString ? `/auth/device/start?${queryString}` : "/auth/device/start";
+    const apiResp = await this.http.json(path, {
       method: "POST",
       apiKey: this.apiKey
     });
@@ -701,1216 +494,378 @@ function isTokenReusable(token) {
   return token.expiresAt.getTime() - Date.now() > 6e4;
 }
 
-// package.json
-var package_default = {
-  name: "@modelrelay/sdk",
-  version: "1.25.0",
-  description: "TypeScript SDK for the ModelRelay API",
-  type: "module",
-  main: "dist/index.cjs",
-  module: "dist/index.js",
-  types: "dist/index.d.ts",
-  exports: {
-    ".": {
-      types: "./dist/index.d.ts",
-      import: "./dist/index.js",
-      require: "./dist/index.cjs"
-    }
-  },
-  publishConfig: {
-    access: "public"
-  },
-  files: [
-    "dist"
-  ],
-  scripts: {
-    build: "tsup src/index.ts --format esm,cjs --dts --external playwright",
-    dev: "tsup src/index.ts --format esm,cjs --dts --watch",
-    lint: "tsc --noEmit --project tsconfig.lint.json",
-    test: "vitest run",
-    "generate:types": "openapi-typescript ../../api/openapi/api.json -o src/generated/api.ts"
-  },
-  keywords: [
-    "modelrelay",
-    "llm",
-    "sdk",
-    "typescript"
-  ],
-  author: "Shane Vitarana",
-  license: "Apache-2.0",
-  dependencies: {
-    "fast-json-patch": "^3.1.1",
-    zod: "^3.23.0"
-  },
-  peerDependencies: {
-    playwright: ">=1.40.0"
-  },
-  peerDependenciesMeta: {
-    playwright: {
-      optional: true
-    }
-  },
-  devDependencies: {
-    "@types/node": "^25.0.3",
-    "openapi-typescript": "^7.4.4",
-    playwright: "^1.49.0",
-    tsup: "^8.2.4",
-    typescript: "^5.6.3",
-    vitest: "^2.1.4"
+// src/structured.ts
+var StructuredDecodeError = class extends Error {
+  constructor(message, rawJson, attempt) {
+    super(`structured output decode error (attempt ${attempt}): ${message}`);
+    this.name = "StructuredDecodeError";
+    this.rawJson = rawJson;
+    this.attempt = attempt;
   }
 };
-
-// src/types.ts
-var SDK_VERSION = package_default.version || "0.0.0";
-var DEFAULT_BASE_URL = "https://api.modelrelay.ai/api/v1";
-var DEFAULT_CLIENT_HEADER = `modelrelay-ts/${SDK_VERSION}`;
-var DEFAULT_CONNECT_TIMEOUT_MS = 5e3;
-var DEFAULT_REQUEST_TIMEOUT_MS = 6e4;
-var StopReasons = {
-  Completed: "completed",
-  Stop: "stop",
-  StopSequence: "stop_sequence",
-  EndTurn: "end_turn",
-  MaxTokens: "max_tokens",
-  MaxLength: "max_len",
-  MaxContext: "max_context",
-  ToolCalls: "tool_calls",
-  TimeLimit: "time_limit",
-  ContentFilter: "content_filter",
-  Incomplete: "incomplete",
-  Unknown: "unknown"
-};
-function asProviderId(value) {
-  return value;
-}
-function asModelId(value) {
-  return value;
-}
-function asTierCode(value) {
-  return value;
-}
-var SubscriptionStatuses = {
-  Active: "active",
-  Trialing: "trialing",
-  PastDue: "past_due",
-  Canceled: "canceled",
-  Unpaid: "unpaid",
-  Incomplete: "incomplete",
-  IncompleteExpired: "incomplete_expired",
-  Paused: "paused"
-};
-var BillingProviders = {
-  Stripe: "stripe",
-  Crypto: "crypto",
-  AppStore: "app_store",
-  External: "external"
-};
-function createUsage(inputTokens, outputTokens, totalTokens) {
-  return {
-    inputTokens,
-    outputTokens,
-    totalTokens: totalTokens ?? inputTokens + outputTokens
-  };
-}
-var MessageRoles = {
-  User: "user",
-  Assistant: "assistant",
-  System: "system",
-  Tool: "tool"
-};
-var ContentPartTypes = {
-  Text: "text"
-};
-var InputItemTypes = {
-  Message: "message"
-};
-var OutputItemTypes = {
-  Message: "message"
-};
-var ToolTypes = {
-  Function: "function",
-  Web: "web",
-  XSearch: "x_search",
-  CodeExecution: "code_execution"
-};
-var WebToolModes = {
-  Auto: "auto",
-  SearchOnly: "search_only",
-  FetchOnly: "fetch_only",
-  SearchAndFetch: "search_and_fetch"
-};
-var ToolChoiceTypes = {
-  Auto: "auto",
-  Required: "required",
-  None: "none"
+var StructuredExhaustedError = class extends Error {
+  constructor(lastRawJson, allAttempts, finalError) {
+    const errorMsg = finalError.kind === "decode" ? finalError.message : finalError.issues.map((i) => i.message).join("; ");
+    super(
+      `structured output failed after ${allAttempts.length} attempts: ${errorMsg}`
+    );
+    this.name = "StructuredExhaustedError";
+    this.lastRawJson = lastRawJson;
+    this.allAttempts = allAttempts;
+    this.finalError = finalError;
+  }
 };
-var OutputFormatTypes = {
-  Text: "text",
-  JsonSchema: "json_schema"
+var defaultRetryHandler = {
+  onValidationError(_attempt, _rawJson, error, _originalInput) {
+    const errorMsg = error.kind === "decode" ? error.message : error.issues.map((i) => `${i.path ?? ""}: ${i.message}`).join("; ");
+    return [{
+      type: "message",
+      role: "user",
+      content: [{ type: "text", text: `The previous response did not match the expected schema. Error: ${errorMsg}. Please provide a response that matches the schema exactly.` }]
+    }];
+  }
 };
-function mergeMetrics(base, override) {
-  if (!base && !override) return void 0;
-  return {
-    ...base || {},
-    ...override || {}
-  };
-}
-function mergeTrace(base, override) {
-  if (!base && !override) return void 0;
+function outputFormatFromZod(schema, name = "response") {
+  const jsonSchema = zodToJsonSchema(schema);
   return {
-    ...base || {},
-    ...override || {}
+    type: "json_schema",
+    json_schema: {
+      name,
+      schema: jsonSchema,
+      strict: true
+    }
   };
 }
-function normalizeStopReason(value) {
-  if (value === void 0 || value === null) return void 0;
-  const str = String(value).trim();
-  const lower = str.toLowerCase();
-  for (const reason of Object.values(StopReasons)) {
-    if (lower === reason) return reason;
-  }
-  switch (lower) {
-    case "length":
-      return StopReasons.MaxLength;
-    default:
-      return { other: str };
+function validateWithZod(schema, data) {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
   }
+  const err = result.error;
+  const issuesRaw = err && typeof err === "object" && "issues" in err ? err.issues : void 0;
+  if (Array.isArray(issuesRaw)) {
+    return {
+      success: false,
+      issues: issuesRaw.map((i) => {
+        const ii = i && typeof i === "object" ? i : {};
+        return {
+          path: Array.isArray(ii.path) ? ii.path.filter((p) => typeof p === "string" || typeof p === "number").join(".") : void 0,
+          message: typeof ii.message === "string" && ii.message.trim() ? ii.message : "validation failed"
+        };
+      })
+    };
+  }
+  const message = err && typeof err === "object" && "message" in err ? String(err.message) : "validation failed";
+  return { success: false, issues: [{ message }] };
 }
-function stopReasonToString(value) {
-  if (!value) return void 0;
-  if (typeof value === "string") return value;
-  return value.other?.trim() || void 0;
-}
-function normalizeModelId(value) {
-  if (value === void 0 || value === null) return void 0;
-  const str = String(value).trim();
-  if (!str) return void 0;
-  return str;
+
+// src/responses_request.ts
+var RESPONSES_PATH = "/responses";
+var CUSTOMER_ID_HEADER = "X-ModelRelay-Customer-Id";
+var REQUEST_ID_HEADER = "X-ModelRelay-Request-Id";
+function makeResponsesRequest(body, options) {
+  return { body, options };
 }
-function modelToString(value) {
-  return String(value).trim();
+function asInternal(req) {
+  return req;
 }
-
-// src/tools.ts
-function createUserMessage(content) {
+function mergeOptions(base, override) {
   return {
-    type: "message",
-    role: "user",
-    content: [{ type: "text", text: content }]
+    ...base,
+    ...override,
+    headers: {
+      ...base.headers || {},
+      ...override.headers || {}
+    }
   };
 }
-function createAssistantMessage(content) {
-  return {
-    type: "message",
-    role: "assistant",
-    content: [{ type: "text", text: content }]
-  };
-}
-function createSystemMessage(content) {
-  return {
-    type: "message",
-    role: "system",
-    content: [{ type: "text", text: content }]
-  };
-}
-function createToolCall(id, name, args, type = ToolTypes.Function) {
-  return {
-    id,
-    type,
-    function: createFunctionCall(name, args)
-  };
-}
-function createFunctionCall(name, args) {
-  return { name, arguments: args };
+function requestIdFromHeaders(headers) {
+  return headers.get(REQUEST_ID_HEADER);
 }
-function zodToJsonSchema(schema, options = {}) {
-  const result = convertZodType(schema);
-  if (options.includeSchema) {
-    const schemaVersion = options.target === "draft-04" ? "http://json-schema.org/draft-04/schema#" : options.target === "draft-2019-09" ? "https://json-schema.org/draft/2019-09/schema" : options.target === "draft-2020-12" ? "https://json-schema.org/draft/2020-12/schema" : "http://json-schema.org/draft-07/schema#";
-    return { $schema: schemaVersion, ...result };
+
+// src/responses_builder.ts
+var ResponseBuilder = class _ResponseBuilder {
+  constructor(body = { input: [] }, options = {}) {
+    this.body = body;
+    this.options = options;
   }
-  return result;
-}
-function convertZodType(schema) {
-  const def = schema._def;
-  const typeName = def.typeName;
-  switch (typeName) {
-    case "ZodString":
-      return convertZodString(def);
-    case "ZodNumber":
-      return convertZodNumber(def);
-    case "ZodBoolean":
-      return { type: "boolean" };
-    case "ZodNull":
-      return { type: "null" };
-    case "ZodArray":
-      return convertZodArray(def);
-    case "ZodObject":
-      return convertZodObject(def);
-    case "ZodEnum":
-      return convertZodEnum(def);
-    case "ZodNativeEnum":
-      return convertZodNativeEnum(def);
-    case "ZodLiteral":
-      return { const: def.value };
-    case "ZodUnion":
-      return convertZodUnion(def);
-    case "ZodOptional": {
-      const inner = convertZodType(def.innerType);
-      if (def.description && !inner.description) {
-        inner.description = def.description;
-      }
-      return inner;
-    }
-    case "ZodNullable":
-      return convertZodNullable(def);
-    case "ZodDefault":
-      return { ...convertZodType(def.innerType), default: def.defaultValue() };
-    case "ZodEffects":
-      return convertZodType(def.schema);
-    case "ZodRecord":
-      return convertZodRecord(def);
-    case "ZodTuple":
-      return convertZodTuple(def);
-    case "ZodAny":
-    case "ZodUnknown":
-      return {};
-    default:
-      throw new ConfigError(
-        `sdk: unsupported Zod schema type ${JSON.stringify(typeName)}; pass JSON Schema directly or use a full converter like zod-to-json-schema`,
-        { typeName }
-      );
+  with(patch) {
+    return new _ResponseBuilder(
+      patch.body ? { ...this.body, ...patch.body } : this.body,
+      patch.options ? { ...this.options, ...patch.options } : this.options
+    );
   }
-}
-function convertZodString(def) {
-  const result = { type: "string" };
-  const checks = def.checks;
-  if (checks) {
-    for (const check of checks) {
-      switch (check.kind) {
-        case "min":
-          result.minLength = check.value;
-          break;
-        case "max":
-          result.maxLength = check.value;
-          break;
-        case "length":
-          result.minLength = check.value;
-          result.maxLength = check.value;
-          break;
-        case "email":
-          result.format = "email";
-          break;
-        case "url":
-          result.format = "uri";
-          break;
-        case "uuid":
-          result.format = "uuid";
-          break;
-        case "datetime":
-          result.format = "date-time";
-          break;
-        case "regex":
-          result.pattern = check.value.source;
-          break;
-      }
-    }
+  /** @returns A new builder with the provider set. */
+  provider(provider) {
+    return this.with({ body: { provider } });
   }
-  if (def.description) {
-    result.description = def.description;
+  /** @returns A new builder with the model set. */
+  model(model) {
+    return this.with({ body: { model } });
   }
-  return result;
-}
-function convertZodNumber(def) {
-  const result = { type: "number" };
-  const checks = def.checks;
-  if (checks) {
-    for (const check of checks) {
-      switch (check.kind) {
-        case "int":
-          result.type = "integer";
-          break;
-        case "min":
-          if (check.inclusive === false) {
-            result.exclusiveMinimum = check.value;
-          } else {
-            result.minimum = check.value;
-          }
-          break;
-        case "max":
-          if (check.inclusive === false) {
-            result.exclusiveMaximum = check.value;
-          } else {
-            result.maximum = check.value;
-          }
-          break;
-        case "multipleOf":
-          result.multipleOf = check.value;
-          break;
-      }
-    }
+  /** @returns A new builder with the full input array replaced. */
+  input(items) {
+    return this.with({ body: { input: items.slice() } });
   }
-  if (def.description) {
-    result.description = def.description;
+  /** @returns A new builder with the input item appended. */
+  item(item) {
+    const input = [...this.body.input ?? [], item];
+    return this.with({ body: { input } });
   }
-  return result;
-}
-function convertZodArray(def) {
-  const result = {
-    type: "array",
-    items: convertZodType(def.type)
-  };
-  if (def.minLength !== void 0 && def.minLength !== null) {
-    result.minItems = def.minLength.value;
+  /** @returns A new builder with a message input item appended. */
+  message(role, content) {
+    return this.item({
+      type: "message",
+      role,
+      content: [{ type: "text", text: content }]
+    });
   }
-  if (def.maxLength !== void 0 && def.maxLength !== null) {
-    result.maxItems = def.maxLength.value;
+  /** @returns A new builder with a system message appended. */
+  system(content) {
+    return this.message("system", content);
   }
-  if (def.description) {
-    result.description = def.description;
+  /** @returns A new builder with a user message appended. */
+  user(content) {
+    return this.message("user", content);
   }
-  return result;
-}
-function convertZodObject(def) {
-  const shape = def.shape;
-  const shapeObj = typeof shape === "function" ? shape() : shape;
-  const properties = {};
-  const required = [];
-  for (const [key, value] of Object.entries(shapeObj)) {
-    properties[key] = convertZodType(value);
-    const valueDef = value._def;
-    const isOptional = valueDef.typeName === "ZodOptional" || valueDef.typeName === "ZodDefault" || valueDef.typeName === "ZodNullable" && valueDef.innerType?._def?.typeName === "ZodDefault";
-    if (!isOptional) {
-      required.push(key);
-    }
-  }
-  const result = {
-    type: "object",
-    properties
-  };
-  if (required.length > 0) {
-    result.required = required;
+  /** @returns A new builder with an assistant message appended. */
+  assistant(content) {
+    return this.message("assistant", content);
   }
-  if (def.description) {
-    result.description = def.description;
+  /** @returns A new builder with a tool result message appended. */
+  toolResultText(toolCallId, content) {
+    return this.item({
+      type: "message",
+      role: "tool",
+      toolCallId: toolCallId.trim(),
+      content: [{ type: "text", text: content }]
+    });
   }
-  const unknownKeys = def.unknownKeys;
-  if (unknownKeys === "strict") {
-    result.additionalProperties = false;
+  /** @returns A new builder with the output format set. */
+  outputFormat(format) {
+    return this.with({ body: { output_format: format } });
   }
-  return result;
-}
-function convertZodEnum(def) {
-  const result = {
-    type: "string",
-    enum: def.values
-  };
-  if (def.description) {
-    result.description = def.description;
+  /** @returns A new builder with max output tokens set. */
+  maxOutputTokens(max) {
+    return this.with({ body: { max_output_tokens: max } });
   }
-  return result;
-}
-function convertZodNativeEnum(def) {
-  const enumValues = def.values;
-  const values = Object.values(enumValues).filter(
-    (v) => typeof v === "string" || typeof v === "number"
-  );
-  const result = { enum: values };
-  if (def.description) {
-    result.description = def.description;
+  /** @returns A new builder with temperature set. */
+  temperature(temp) {
+    return this.with({ body: { temperature: temp } });
   }
-  return result;
-}
-function convertZodUnion(def) {
-  const options = def.options;
-  const result = {
-    anyOf: options.map(convertZodType)
-  };
-  if (def.description) {
-    result.description = def.description;
+  /** @returns A new builder with stop sequences set. */
+  stop(...stop) {
+    const clean = stop.map((s) => s.trim()).filter(Boolean);
+    return this.with({ body: { stop: clean.length ? clean : void 0 } });
   }
-  return result;
-}
-function convertZodNullable(def) {
-  const inner = convertZodType(def.innerType);
-  return {
-    anyOf: [inner, { type: "null" }]
-  };
-}
-function convertZodRecord(def) {
-  const result = {
-    type: "object",
-    additionalProperties: convertZodType(def.valueType)
-  };
-  if (def.description) {
-    result.description = def.description;
+  /** @returns A new builder with tools replaced. */
+  tools(tools) {
+    return this.with({ body: { tools: tools.slice() } });
   }
-  return result;
-}
-function convertZodTuple(def) {
-  const items = def.items;
-  const result = {
-    type: "array",
-    items: items.map(convertZodType),
-    minItems: items.length,
-    maxItems: items.length
-  };
-  if (def.description) {
-    result.description = def.description;
+  /** @returns A new builder with a tool appended. */
+  tool(tool) {
+    const tools = [...this.body.tools ?? [], tool];
+    return this.with({ body: { tools } });
   }
-  return result;
-}
-function createFunctionToolFromSchema(name, description, schema, options) {
-  const jsonSchema = zodToJsonSchema(schema, options);
-  return createFunctionTool(name, description, jsonSchema);
-}
-function createFunctionTool(name, description, parameters) {
-  const fn = { name, description };
-  if (parameters) {
-    fn.parameters = parameters;
+  /** @returns A new builder with tool choice set. */
+  toolChoice(choice) {
+    return this.with({ body: { tool_choice: choice } });
   }
-  return {
-    type: ToolTypes.Function,
-    function: fn
-  };
-}
-function createWebTool(options) {
-  return {
-    type: ToolTypes.Web,
-    web: options ? {
-      mode: options.mode,
-      allowedDomains: options.allowedDomains,
-      excludedDomains: options.excludedDomains,
-      maxUses: options.maxUses
-    } : void 0
-  };
-}
-function toolChoiceAuto() {
-  return { type: ToolChoiceTypes.Auto };
-}
-function toolChoiceRequired() {
-  return { type: ToolChoiceTypes.Required };
-}
-function toolChoiceNone() {
-  return { type: ToolChoiceTypes.None };
-}
-function hasToolCalls(response) {
-  for (const item of response.output || []) {
-    if (item?.toolCalls?.length) return true;
+  /** @returns A new builder with tool choice set to auto. */
+  toolChoiceAuto() {
+    return this.toolChoice({ type: "auto" });
   }
-  return false;
-}
-function firstToolCall(response) {
-  for (const item of response.output || []) {
-    const call = item?.toolCalls?.[0];
-    if (call) return call;
+  /** @returns A new builder with tool choice set to required. */
+  toolChoiceRequired(functionName) {
+    return this.toolChoice({ type: "required", function: functionName });
   }
-  return void 0;
-}
-function toolResultMessage(toolCallId, result) {
-  const content = typeof result === "string" ? result : JSON.stringify(result);
-  return {
-    type: "message",
-    role: "tool",
-    toolCallId,
-    content: [{ type: "text", text: content }]
-  };
-}
-function respondToToolCall(call, result) {
-  return toolResultMessage(call.id, result);
-}
-function assistantMessageWithToolCalls(content, toolCalls) {
-  return {
-    type: "message",
-    role: "assistant",
-    content: [{ type: "text", text: content }],
-    toolCalls
-  };
-}
-var ToolCallAccumulator = class {
-  constructor() {
-    this.calls = /* @__PURE__ */ new Map();
+  /** @returns A new builder with tool choice set to none. */
+  toolChoiceNone() {
+    return this.toolChoice({ type: "none" });
   }
-  /**
-   * Processes a streaming tool call delta.
-   * Returns true if this started a new tool call.
-   */
-  processDelta(delta) {
-    const existing = this.calls.get(delta.index);
-    if (!existing) {
-      this.calls.set(delta.index, {
-        id: delta.id ?? "",
-        type: delta.type ?? ToolTypes.Function,
-        function: {
-          name: delta.function?.name ?? "",
-          arguments: delta.function?.arguments ?? ""
-        }
-      });
-      return true;
-    }
-    if (delta.function) {
-      if (delta.function.name) {
-        existing.function = existing.function ?? { name: "", arguments: "" };
-        existing.function.name = delta.function.name;
-      }
-      if (delta.function.arguments) {
-        existing.function = existing.function ?? { name: "", arguments: "" };
-        existing.function.arguments += delta.function.arguments;
-      }
-    }
-    return false;
+  /** @returns A new builder with the customer ID option set. */
+  customerId(customerId) {
+    return this.with({ options: { customerId: customerId.trim() } });
   }
-  /**
-   * Returns all accumulated tool calls in index order.
-   */
-  getToolCalls() {
-    if (this.calls.size === 0) {
-      return [];
-    }
-    const maxIdx = Math.max(...this.calls.keys());
-    const result = [];
-    for (let i = 0; i <= maxIdx; i++) {
-      const call = this.calls.get(i);
-      if (call) {
-        result.push(call);
-      }
-    }
-    return result;
+  /** @returns A new builder with the request ID option set. */
+  requestId(requestId) {
+    return this.with({ options: { requestId: requestId.trim() } });
   }
-  /**
-   * Returns a specific tool call by index, or undefined if not found.
-   */
-  getToolCall(index) {
-    return this.calls.get(index);
+  /** @returns A new builder with a single header set/overridden. */
+  header(key, value) {
+    const headers = { ...this.options.headers || {}, [key]: value };
+    return this.with({ options: { headers } });
   }
-  /**
-   * Clears all accumulated tool calls.
-   */
-  reset() {
-    this.calls.clear();
+  /** @returns A new builder with headers merged. */
+  headers(headers) {
+    const merged = { ...this.options.headers || {}, ...headers };
+    return this.with({ options: { headers: merged } });
   }
-};
-var ToolArgsError = class extends Error {
-  constructor(message, toolCallId, toolName, rawArguments) {
-    super(message);
-    this.name = "ToolArgsError";
-    this.toolCallId = toolCallId;
-    this.toolName = toolName;
-    this.rawArguments = rawArguments;
+  /** @returns A new builder with the request timeout option set. */
+  timeoutMs(timeoutMs) {
+    return this.with({ options: { timeoutMs: Math.max(0, timeoutMs) } });
   }
-};
-function parseToolArgs(call, schema) {
-  const toolName = call.function?.name ?? "unknown";
-  const rawArgs = call.function?.arguments ?? "";
-  let parsed;
-  try {
-    parsed = rawArgs ? JSON.parse(rawArgs) : {};
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Invalid JSON in arguments";
-    throw new ToolArgsError(
-      `Failed to parse arguments for tool '${toolName}': ${message}`,
-      call.id,
-      toolName,
-      rawArgs
-    );
+  /** @returns A new builder with the connect timeout option set. */
+  connectTimeoutMs(connectTimeoutMs) {
+    return this.with({
+      options: { connectTimeoutMs: Math.max(0, connectTimeoutMs) }
+    });
   }
-  try {
-    return schema.parse(parsed);
-  } catch (err) {
-    let message;
-    if (err instanceof Error) {
-      const zodErr = err;
-      if (zodErr.errors && Array.isArray(zodErr.errors)) {
-        const issues = zodErr.errors.map((e) => {
-          const path2 = e.path.length > 0 ? `${e.path.join(".")}: ` : "";
-          return `${path2}${e.message}`;
-        }).join("; ");
-        message = issues;
-      } else {
-        message = err.message;
-      }
-    } else {
-      message = String(err);
-    }
-    throw new ToolArgsError(
-      `Invalid arguments for tool '${toolName}': ${message}`,
-      call.id,
-      toolName,
-      rawArgs
-    );
+  /** @returns A new builder with retry configuration set. */
+  retry(cfg) {
+    return this.with({ options: { retry: cfg } });
   }
-}
-function tryParseToolArgs(call, schema) {
-  try {
-    const data = parseToolArgs(call, schema);
-    return { success: true, data };
-  } catch (err) {
-    if (err instanceof ToolArgsError) {
-      return { success: false, error: err };
-    }
-    const toolName = call.function?.name ?? "unknown";
-    const rawArgs = call.function?.arguments ?? "";
-    return {
-      success: false,
-      error: new ToolArgsError(
-        err instanceof Error ? err.message : String(err),
-        call.id,
-        toolName,
-        rawArgs
-      )
-    };
+  /** @returns A new builder with retries disabled. */
+  disableRetry() {
+    return this.with({ options: { retry: false } });
   }
-}
-function parseToolArgsRaw(call) {
-  const toolName = call.function?.name ?? "unknown";
-  const rawArgs = call.function?.arguments ?? "";
-  try {
-    return rawArgs ? JSON.parse(rawArgs) : {};
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Invalid JSON in arguments";
-    throw new ToolArgsError(
-      `Failed to parse arguments for tool '${toolName}': ${message}`,
-      call.id,
-      toolName,
-      rawArgs
-    );
+  /** @returns A new builder with metrics callbacks set. */
+  metrics(metrics) {
+    return this.with({ options: { metrics } });
   }
-}
-var ToolRegistry = class {
-  constructor() {
-    this.handlers = /* @__PURE__ */ new Map();
+  /** @returns A new builder with trace callbacks set. */
+  trace(trace) {
+    return this.with({ options: { trace } });
   }
-  /**
-   * Registers a handler function for a tool name.
-   * @param name - The tool name (must match the function name in the tool definition)
-   * @param handler - Function to execute when this tool is called
-   * @returns this for chaining
-   */
-  register(name, handler) {
-    this.handlers.set(name, handler);
-    return this;
+  /** @returns A new builder with stream time-to-first-token timeout set. */
+  streamTTFTTimeoutMs(timeoutMs) {
+    return this.with({
+      options: { streamTTFTTimeoutMs: Math.max(0, timeoutMs) }
+    });
   }
-  /**
-   * Unregisters a tool handler.
-   * @param name - The tool name to unregister
-   * @returns true if the handler was removed, false if it didn't exist
-   */
-  unregister(name) {
-    return this.handlers.delete(name);
+  /** @returns A new builder with stream idle timeout set. */
+  streamIdleTimeoutMs(timeoutMs) {
+    return this.with({
+      options: { streamIdleTimeoutMs: Math.max(0, timeoutMs) }
+    });
   }
-  /**
-   * Checks if a handler is registered for the given tool name.
-   */
-  has(name) {
-    return this.handlers.has(name);
+  /** @returns A new builder with total stream timeout set. */
+  streamTotalTimeoutMs(timeoutMs) {
+    return this.with({
+      options: { streamTotalTimeoutMs: Math.max(0, timeoutMs) }
+    });
   }
-  /**
-   * Returns the list of registered tool names.
-   */
-  getRegisteredTools() {
-    return Array.from(this.handlers.keys());
+  /** @returns A new builder with the abort signal set. */
+  signal(signal) {
+    return this.with({ options: { signal } });
   }
-  /**
-   * Executes a single tool call.
-   * @param call - The tool call to execute
-   * @returns The execution result
-   */
-  async execute(call) {
-    const toolName = call.function?.name ?? "";
-    const handler = this.handlers.get(toolName);
-    if (!handler) {
-      return {
-        toolCallId: call.id,
-        toolName,
-        result: null,
-        error: `Unknown tool: '${toolName}'. Available tools: ${this.getRegisteredTools().join(", ") || "none"}`
-      };
-    }
-    let args;
-    try {
-      args = call.function?.arguments ? JSON.parse(call.function.arguments) : {};
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      return {
-        toolCallId: call.id,
-        toolName,
-        result: null,
-        error: `Invalid JSON in arguments: ${errorMessage}`,
-        isRetryable: true
-      };
-    }
-    try {
-      const result = await handler(args, call);
-      return {
-        toolCallId: call.id,
-        toolName,
-        result
-      };
-    } catch (err) {
-      const isRetryable = err instanceof ToolArgsError || err instanceof ToolArgumentError;
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      return {
-        toolCallId: call.id,
-        toolName,
-        result: null,
-        error: errorMessage,
-        isRetryable
-      };
+  /** @returns A finalized, immutable request payload. */
+  build() {
+    const input = (this.body.input ?? []).slice();
+    if (input.length === 0) {
+      throw new ConfigError("at least one input item is required");
     }
-  }
-  /**
-   * Executes multiple tool calls in parallel.
-   * @param calls - Array of tool calls to execute
-   * @returns Array of execution results in the same order as input
-   */
-  async executeAll(calls) {
-    return Promise.all(calls.map((call) => this.execute(call)));
-  }
-  /**
-   * Converts execution results to tool result messages.
-   * Useful for appending to the conversation history.
-   * @param results - Array of execution results
-   * @returns Array of tool result input items (role "tool")
-   */
-  resultsToMessages(results) {
-    return results.map((r) => {
-      const content = r.error ? `Error: ${r.error}` : typeof r.result === "string" ? r.result : JSON.stringify(r.result);
-      return toolResultMessage(r.toolCallId, content);
-    });
+    const body = {
+      provider: this.body.provider,
+      model: this.body.model,
+      input,
+      output_format: this.body.output_format,
+      max_output_tokens: this.body.max_output_tokens,
+      temperature: this.body.temperature,
+      stop: this.body.stop,
+      tools: this.body.tools,
+      tool_choice: this.body.tool_choice
+    };
+    return makeResponsesRequest(body, { ...this.options || {} });
   }
 };
-function formatToolErrorForModel(result) {
-  const lines = [
-    `Tool call error for '${result.toolName}': ${result.error}`
-  ];
-  if (result.isRetryable) {
-    lines.push("");
-    lines.push("Please correct the arguments and try again.");
-  }
-  return lines.join("\n");
-}
-function hasRetryableErrors(results) {
-  return results.some((r) => r.error && r.isRetryable);
-}
-function getRetryableErrors(results) {
-  return results.filter((r) => r.error && r.isRetryable);
+
+// src/responses_normalize.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function createRetryMessages(results) {
-  return results.filter((r) => r.error && r.isRetryable).map((r) => toolResultMessage(r.toolCallId, formatToolErrorForModel(r)));
+function normalizeUsage(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const input = Number(value.input_tokens ?? 0);
+  const output = Number(value.output_tokens ?? 0);
+  const total = value.total_tokens === void 0 || value.total_tokens === null ? void 0 : Number(value.total_tokens);
+  return createUsage(
+    input,
+    output,
+    Number.isFinite(total) ? total : void 0
+  );
 }
-async function executeWithRetry(registry, toolCalls, options = {}) {
-  const maxRetries = options.maxRetries ?? 2;
-  let currentCalls = toolCalls;
-  let attempt = 0;
-  const successfulResults = /* @__PURE__ */ new Map();
-  while (attempt <= maxRetries) {
-    const results = await registry.executeAll(currentCalls);
-    for (const result of results) {
-      if (!result.error || !result.isRetryable) {
-        successfulResults.set(result.toolCallId, result);
-      }
-    }
-    const retryableResults = getRetryableErrors(results);
-    if (retryableResults.length === 0 || !options.onRetry) {
-      for (const result of results) {
-        if (result.error && result.isRetryable) {
-          successfulResults.set(result.toolCallId, result);
-        }
-      }
-      return Array.from(successfulResults.values());
-    }
-    attempt++;
-    if (attempt > maxRetries) {
-      for (const result of retryableResults) {
-        successfulResults.set(result.toolCallId, result);
-      }
-      return Array.from(successfulResults.values());
-    }
-    const errorMessages = createRetryMessages(retryableResults);
-    const newCalls = await options.onRetry(errorMessages, attempt);
-    if (newCalls.length === 0) {
-      for (const result of retryableResults) {
-        successfulResults.set(result.toolCallId, result);
-      }
-      return Array.from(successfulResults.values());
-    }
-    currentCalls = newCalls;
+function normalizeCitations(value) {
+  if (!Array.isArray(value) || value.length === 0) return void 0;
+  const citations = [];
+  for (const item of value) {
+    if (!isRecord(item)) continue;
+    const url = item.url;
+    const title = item.title;
+    citations.push({
+      ...typeof url === "string" && url.trim() ? { url } : {},
+      ...typeof title === "string" && title.trim() ? { title } : {}
+    });
   }
-  return Array.from(successfulResults.values());
+  return citations.length ? citations : void 0;
 }
-
-// src/structured.ts
-var StructuredDecodeError = class extends Error {
-  constructor(message, rawJson, attempt) {
-    super(`structured output decode error (attempt ${attempt}): ${message}`);
-    this.name = "StructuredDecodeError";
-    this.rawJson = rawJson;
-    this.attempt = attempt;
+function normalizeResponsesResponse(payload, requestId) {
+  if (!isRecord(payload)) {
+    throw new APIError("invalid response payload", { status: 200, data: payload });
   }
-};
-var StructuredExhaustedError = class extends Error {
-  constructor(lastRawJson, allAttempts, finalError) {
-    const errorMsg = finalError.kind === "decode" ? finalError.message : finalError.issues.map((i) => i.message).join("; ");
-    super(
-      `structured output failed after ${allAttempts.length} attempts: ${errorMsg}`
-    );
-    this.name = "StructuredExhaustedError";
-    this.lastRawJson = lastRawJson;
-    this.allAttempts = allAttempts;
-    this.finalError = finalError;
+  const output = Array.isArray(payload.output) ? payload.output : [];
+  const usage = normalizeUsage(payload.usage);
+  if (!usage) {
+    throw new APIError("missing usage in response", { status: 200, data: payload });
   }
-};
-var defaultRetryHandler = {
-  onValidationError(_attempt, _rawJson, error, _originalInput) {
-    const errorMsg = error.kind === "decode" ? error.message : error.issues.map((i) => `${i.path ?? ""}: ${i.message}`).join("; ");
-    return [{
-      type: "message",
-      role: "user",
-      content: [{ type: "text", text: `The previous response did not match the expected schema. Error: ${errorMsg}. Please provide a response that matches the schema exactly.` }]
-    }];
+  const model = normalizeModelId(payload.model);
+  if (!model) {
+    throw new APIError("missing model in response", { status: 200, data: payload });
   }
-};
-function outputFormatFromZod(schema, name = "response") {
-  const jsonSchema = zodToJsonSchema(schema);
   return {
-    type: "json_schema",
-    json_schema: {
-      name,
-      schema: jsonSchema,
-      strict: true
-    }
+    id: typeof payload.id === "string" ? payload.id : String(payload.id || ""),
+    output,
+    stopReason: normalizeStopReason(payload.stop_reason),
+    model,
+    usage,
+    provider: typeof payload.provider === "string" ? asProviderId(payload.provider) : void 0,
+    citations: normalizeCitations(payload.citations),
+    requestId
   };
 }
-function validateWithZod(schema, data) {
-  const result = schema.safeParse(data);
-  if (result.success) {
-    return { success: true, data: result.data };
-  }
-  const err = result.error;
-  const issuesRaw = err && typeof err === "object" && "issues" in err ? err.issues : void 0;
-  if (Array.isArray(issuesRaw)) {
-    return {
-      success: false,
-      issues: issuesRaw.map((i) => {
-        const ii = i && typeof i === "object" ? i : {};
-        return {
-          path: Array.isArray(ii.path) ? ii.path.filter((p) => typeof p === "string" || typeof p === "number").join(".") : void 0,
-          message: typeof ii.message === "string" && ii.message.trim() ? ii.message : "validation failed"
-        };
-      })
-    };
-  }
-  const message = err && typeof err === "object" && "message" in err ? String(err.message) : "validation failed";
-  return { success: false, issues: [{ message }] };
-}
-
-// src/responses_request.ts
-var RESPONSES_PATH = "/responses";
-var CUSTOMER_ID_HEADER = "X-ModelRelay-Customer-Id";
-var REQUEST_ID_HEADER = "X-ModelRelay-Request-Id";
-function makeResponsesRequest(body, options) {
-  return { body, options };
-}
-function asInternal(req) {
-  return req;
-}
-function mergeOptions(base, override) {
+function assistantItem(content) {
   return {
-    ...base,
-    ...override,
-    headers: {
-      ...base.headers || {},
-      ...override.headers || {}
-    }
+    type: "message",
+    role: "assistant",
+    content: [{ type: "text", text: content }]
   };
 }
-function requestIdFromHeaders(headers) {
-  return headers.get(REQUEST_ID_HEADER);
+function extractAssistantText(output) {
+  const parts = [];
+  for (const item of output || []) {
+    if (item.type !== "message") continue;
+    if (item.role !== "assistant") continue;
+    if (Array.isArray(item.content)) {
+      parts.push(...item.content);
+    }
+  }
+  const text = parts.filter((p) => p.type === "text").map((p) => p.type === "text" ? p.text : "").join("");
+  if (!text.trim()) {
+    throw new TransportError("response contained no assistant text output", {
+      kind: "empty_response"
+    });
+  }
+  return text;
 }
 
-// src/responses_builder.ts
-var ResponseBuilder = class _ResponseBuilder {
-  constructor(body = { input: [] }, options = {}) {
-    this.body = body;
-    this.options = options;
-  }
-  with(patch) {
-    return new _ResponseBuilder(
-      patch.body ? { ...this.body, ...patch.body } : this.body,
-      patch.options ? { ...this.options, ...patch.options } : this.options
+// src/responses_ndjson.ts
+function mapNDJSONResponseEvent(line, requestId) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch (err) {
+    throw new TransportError(
+      `Failed to parse NDJSON line: ${err instanceof Error ? err.message : String(err)}`,
+      { kind: "request", cause: err }
     );
   }
-  /** @returns A new builder with the provider set. */
-  provider(provider) {
-    return this.with({ body: { provider } });
-  }
-  /** @returns A new builder with the model set. */
-  model(model) {
-    return this.with({ body: { model } });
-  }
-  /** @returns A new builder with the full input array replaced. */
-  input(items) {
-    return this.with({ body: { input: items.slice() } });
-  }
-  /** @returns A new builder with the input item appended. */
-  item(item) {
-    const input = [...this.body.input ?? [], item];
-    return this.with({ body: { input } });
-  }
-  /** @returns A new builder with a message input item appended. */
-  message(role, content) {
-    return this.item({
-      type: "message",
-      role,
-      content: [{ type: "text", text: content }]
-    });
-  }
-  /** @returns A new builder with a system message appended. */
-  system(content) {
-    return this.message("system", content);
-  }
-  /** @returns A new builder with a user message appended. */
-  user(content) {
-    return this.message("user", content);
-  }
-  /** @returns A new builder with an assistant message appended. */
-  assistant(content) {
-    return this.message("assistant", content);
-  }
-  /** @returns A new builder with a tool result message appended. */
-  toolResultText(toolCallId, content) {
-    return this.item({
-      type: "message",
-      role: "tool",
-      toolCallId: toolCallId.trim(),
-      content: [{ type: "text", text: content }]
-    });
-  }
-  /** @returns A new builder with the output format set. */
-  outputFormat(format) {
-    return this.with({ body: { output_format: format } });
-  }
-  /** @returns A new builder with max output tokens set. */
-  maxOutputTokens(max) {
-    return this.with({ body: { max_output_tokens: max } });
-  }
-  /** @returns A new builder with temperature set. */
-  temperature(temp) {
-    return this.with({ body: { temperature: temp } });
-  }
-  /** @returns A new builder with stop sequences set. */
-  stop(...stop) {
-    const clean = stop.map((s) => s.trim()).filter(Boolean);
-    return this.with({ body: { stop: clean.length ? clean : void 0 } });
-  }
-  /** @returns A new builder with tools replaced. */
-  tools(tools) {
-    return this.with({ body: { tools: tools.slice() } });
-  }
-  /** @returns A new builder with a tool appended. */
-  tool(tool) {
-    const tools = [...this.body.tools ?? [], tool];
-    return this.with({ body: { tools } });
-  }
-  /** @returns A new builder with tool choice set. */
-  toolChoice(choice) {
-    return this.with({ body: { tool_choice: choice } });
-  }
-  /** @returns A new builder with tool choice set to auto. */
-  toolChoiceAuto() {
-    return this.toolChoice({ type: "auto" });
-  }
-  /** @returns A new builder with tool choice set to required. */
-  toolChoiceRequired(functionName) {
-    return this.toolChoice({ type: "required", function: functionName });
-  }
-  /** @returns A new builder with tool choice set to none. */
-  toolChoiceNone() {
-    return this.toolChoice({ type: "none" });
-  }
-  /** @returns A new builder with the customer ID option set. */
-  customerId(customerId) {
-    return this.with({ options: { customerId: customerId.trim() } });
-  }
-  /** @returns A new builder with the request ID option set. */
-  requestId(requestId) {
-    return this.with({ options: { requestId: requestId.trim() } });
-  }
-  /** @returns A new builder with a single header set/overridden. */
-  header(key, value) {
-    const headers = { ...this.options.headers || {}, [key]: value };
-    return this.with({ options: { headers } });
-  }
-  /** @returns A new builder with headers merged. */
-  headers(headers) {
-    const merged = { ...this.options.headers || {}, ...headers };
-    return this.with({ options: { headers: merged } });
-  }
-  /** @returns A new builder with the request timeout option set. */
-  timeoutMs(timeoutMs) {
-    return this.with({ options: { timeoutMs: Math.max(0, timeoutMs) } });
-  }
-  /** @returns A new builder with the connect timeout option set. */
-  connectTimeoutMs(connectTimeoutMs) {
-    return this.with({
-      options: { connectTimeoutMs: Math.max(0, connectTimeoutMs) }
-    });
-  }
-  /** @returns A new builder with retry configuration set. */
-  retry(cfg) {
-    return this.with({ options: { retry: cfg } });
-  }
-  /** @returns A new builder with retries disabled. */
-  disableRetry() {
-    return this.with({ options: { retry: false } });
-  }
-  /** @returns A new builder with metrics callbacks set. */
-  metrics(metrics) {
-    return this.with({ options: { metrics } });
-  }
-  /** @returns A new builder with trace callbacks set. */
-  trace(trace) {
-    return this.with({ options: { trace } });
-  }
-  /** @returns A new builder with stream time-to-first-token timeout set. */
-  streamTTFTTimeoutMs(timeoutMs) {
-    return this.with({
-      options: { streamTTFTTimeoutMs: Math.max(0, timeoutMs) }
-    });
-  }
-  /** @returns A new builder with stream idle timeout set. */
-  streamIdleTimeoutMs(timeoutMs) {
-    return this.with({
-      options: { streamIdleTimeoutMs: Math.max(0, timeoutMs) }
-    });
-  }
-  /** @returns A new builder with total stream timeout set. */
-  streamTotalTimeoutMs(timeoutMs) {
-    return this.with({
-      options: { streamTotalTimeoutMs: Math.max(0, timeoutMs) }
-    });
-  }
-  /** @returns A new builder with the abort signal set. */
-  signal(signal) {
-    return this.with({ options: { signal } });
-  }
-  /** @returns A finalized, immutable request payload. */
-  build() {
-    const input = (this.body.input ?? []).slice();
-    if (input.length === 0) {
-      throw new ConfigError("at least one input item is required");
-    }
-    const body = {
-      provider: this.body.provider,
-      model: this.body.model,
-      input,
-      output_format: this.body.output_format,
-      max_output_tokens: this.body.max_output_tokens,
-      temperature: this.body.temperature,
-      stop: this.body.stop,
-      tools: this.body.tools,
-      tool_choice: this.body.tool_choice
-    };
-    return makeResponsesRequest(body, { ...this.options || {} });
-  }
-};
-
-// src/responses_normalize.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizeUsage(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const input = Number(value.input_tokens ?? 0);
-  const output = Number(value.output_tokens ?? 0);
-  const total = value.total_tokens === void 0 || value.total_tokens === null ? void 0 : Number(value.total_tokens);
-  return createUsage(
-    input,
-    output,
-    Number.isFinite(total) ? total : void 0
-  );
-}
-function normalizeCitations(value) {
-  if (!Array.isArray(value) || value.length === 0) return void 0;
-  const citations = [];
-  for (const item of value) {
-    if (!isRecord(item)) continue;
-    const url = item.url;
-    const title = item.title;
-    citations.push({
-      ...typeof url === "string" && url.trim() ? { url } : {},
-      ...typeof title === "string" && title.trim() ? { title } : {}
-    });
-  }
-  return citations.length ? citations : void 0;
-}
-function normalizeResponsesResponse(payload, requestId) {
-  if (!isRecord(payload)) {
-    throw new APIError("invalid response payload", { status: 200, data: payload });
-  }
-  const output = Array.isArray(payload.output) ? payload.output : [];
-  const usage = normalizeUsage(payload.usage);
-  if (!usage) {
-    throw new APIError("missing usage in response", { status: 200, data: payload });
-  }
-  const model = normalizeModelId(payload.model);
-  if (!model) {
-    throw new APIError("missing model in response", { status: 200, data: payload });
-  }
-  return {
-    id: typeof payload.id === "string" ? payload.id : String(payload.id || ""),
-    output,
-    stopReason: normalizeStopReason(payload.stop_reason),
-    model,
-    usage,
-    provider: typeof payload.provider === "string" ? asProviderId(payload.provider) : void 0,
-    citations: normalizeCitations(payload.citations),
-    requestId
-  };
-}
-function assistantItem(content) {
-  return {
-    type: "message",
-    role: "assistant",
-    content: [{ type: "text", text: content }]
-  };
-}
-function extractAssistantText(output) {
-  const parts = [];
-  for (const item of output || []) {
-    if (item.type !== "message") continue;
-    if (item.role !== "assistant") continue;
-    if (Array.isArray(item.content)) {
-      parts.push(...item.content);
-    }
-  }
-  const text = parts.filter((p) => p.type === "text").map((p) => p.type === "text" ? p.text : "").join("");
-  if (!text.trim()) {
-    throw new TransportError("response contained no assistant text output", {
-      kind: "empty_response"
-    });
-  }
-  return text;
-}
-
-// src/responses_ndjson.ts
-function mapNDJSONResponseEvent(line, requestId) {
-  let parsed;
-  try {
-    parsed = JSON.parse(line);
-  } catch (err) {
-    throw new TransportError(
-      `Failed to parse NDJSON line: ${err instanceof Error ? err.message : String(err)}`,
-      { kind: "request", cause: err }
-    );
-  }
-  if (!parsed || typeof parsed !== "object") {
-    throw new TransportError(
-      `NDJSON record is not an object: ${JSON.stringify(parsed)}`,
-      { kind: "request" }
-    );
+  if (!parsed || typeof parsed !== "object") {
+    throw new TransportError(
+      `NDJSON record is not an object: ${JSON.stringify(parsed)}`,
+      { kind: "request" }
+    );
   }
   if (!isRecord(parsed)) {
     throw new TransportError(
@@ -3550,10 +2505,10 @@ var RunsClient = class {
     const metrics = mergeMetrics(this.metrics, options.metrics);
     const trace = mergeTrace(this.trace, options.trace);
     const authHeaders = await this.auth.authForResponses();
-    const path2 = runByIdPath(runId);
+    const path = runByIdPath(runId);
     const headers = { ...options.headers || {} };
     this.applyCustomerHeader(headers, options.customerId);
-    const out = await this.http.json(path2, {
+    const out = await this.http.json(path, {
       method: "GET",
       headers,
       signal: options.signal,
@@ -3564,7 +2519,7 @@ var RunsClient = class {
       retry: options.retry,
       metrics,
       trace,
-      context: { method: "GET", path: path2 }
+      context: { method: "GET", path }
     });
     return {
       ...out,
@@ -3588,10 +2543,10 @@ var RunsClient = class {
     if (options.wait === false) {
       params.set("wait", "0");
     }
-    const path2 = params.toString() ? `${basePath}?${params}` : basePath;
+    const path = params.toString() ? `${basePath}?${params}` : basePath;
     const headers = { ...options.headers || {} };
     this.applyCustomerHeader(headers, options.customerId);
-    const resp = await this.http.request(path2, {
+    const resp = await this.http.request(path, {
       method: "GET",
       headers,
       signal: options.signal,
@@ -3642,10 +2597,10 @@ var RunsClient = class {
     const metrics = mergeMetrics(this.metrics, options.metrics);
     const trace = mergeTrace(this.trace, options.trace);
     const authHeaders = await this.auth.authForResponses();
-    const path2 = runToolResultsPath(runId);
+    const path = runToolResultsPath(runId);
     const headers = { ...options.headers || {} };
     this.applyCustomerHeader(headers, options.customerId);
-    const out = await this.http.json(path2, {
+    const out = await this.http.json(path, {
       method: "POST",
       headers,
       body: req,
@@ -3657,7 +2612,7 @@ var RunsClient = class {
       retry: options.retry,
       metrics,
       trace,
-      context: { method: "POST", path: path2 }
+      context: { method: "POST", path }
     });
     return out;
   }
@@ -3665,10 +2620,10 @@ var RunsClient = class {
     const metrics = mergeMetrics(this.metrics, options.metrics);
     const trace = mergeTrace(this.trace, options.trace);
     const authHeaders = await this.auth.authForResponses();
-    const path2 = runPendingToolsPath(runId);
+    const path = runPendingToolsPath(runId);
     const headers = { ...options.headers || {} };
     this.applyCustomerHeader(headers, options.customerId);
-    const out = await this.http.json(path2, {
+    const out = await this.http.json(path, {
       method: "GET",
       headers,
       signal: options.signal,
@@ -3679,7 +2634,7 @@ var RunsClient = class {
       retry: options.retry,
       metrics,
       trace,
-      context: { method: "GET", path: path2 }
+      context: { method: "GET", path }
     });
     return {
       ...out,
@@ -4182,8 +3137,8 @@ var ModelsClient = class {
     if (params.capability) {
       qs.set("capability", params.capability);
     }
-    const path2 = qs.toString() ? `/models?${qs.toString()}` : "/models";
-    const resp = await this.http.json(path2, { method: "GET" });
+    const path = qs.toString() ? `/models?${qs.toString()}` : "/models";
+    const resp = await this.http.json(path, { method: "GET" });
     return resp.models;
   }
 };
@@ -5650,7 +4605,7 @@ var HTTPClient = class {
     this.metrics = cfg.metrics;
     this.trace = cfg.trace;
   }
-  async request(path2, options = {}) {
+  async request(path, options = {}) {
     const fetchFn = this.fetchImpl ?? globalThis.fetch;
     if (!fetchFn) {
       throw new ConfigError(
@@ -5658,12 +4613,12 @@ var HTTPClient = class {
       );
     }
     const method = options.method || "GET";
-    const url = buildUrl(this.baseUrl, path2);
+    const url = buildUrl(this.baseUrl, path);
     const metrics = mergeMetrics(this.metrics, options.metrics);
     const trace = mergeTrace(this.trace, options.trace);
     const context = {
       method,
-      path: path2,
+      path,
       ...options.context || {}
     };
     trace?.requestStart?.(context);
@@ -5804,8 +4759,8 @@ var HTTPClient = class {
       retries: buildRetryMetadata(attempts, lastStatus)
     });
   }
-  async json(path2, options = {}) {
-    const response = await this.request(path2, {
+  async json(path, options = {}) {
+    const response = await this.request(path, {
       ...options,
       raw: true,
       accept: options.accept || "application/json"
@@ -5826,14 +4781,14 @@ var HTTPClient = class {
     }
   }
 };
-function buildUrl(baseUrl, path2) {
-  if (/^https?:\/\//i.test(path2)) {
-    return path2;
+function buildUrl(baseUrl, path) {
+  if (/^https?:\/\//i.test(path)) {
+    return path;
   }
-  if (!path2.startsWith("/")) {
-    path2 = `/${path2}`;
+  if (!path.startsWith("/")) {
+    path = `/${path}`;
   }
-  return `${baseUrl}${path2}`;
+  return `${baseUrl}${path}`;
 }
 function normalizeBaseUrl(value) {
   const trimmed = value.trim();
@@ -5876,7 +4831,7 @@ function backoff(attempt, cfg) {
   const jitter = 0.5 + Math.random();
   const delay = Math.min(cfg.maxBackoffMs, capped * jitter);
   if (delay <= 0) return Promise.resolve();
-  return new Promise((resolve2) => setTimeout(resolve2, delay));
+  return new Promise((resolve) => setTimeout(resolve, delay));
 }
 function mergeSignals(...signals) {
   const active = signals.filter(Boolean);
@@ -6322,13 +5277,13 @@ async function sleep(ms, signal) {
     return;
   }
   if (!signal) {
-    await new Promise((resolve2) => setTimeout(resolve2, ms));
+    await new Promise((resolve) => setTimeout(resolve, ms));
     return;
   }
   if (signal.aborted) {
     throw new TransportError("oauth device flow aborted", { kind: "request" });
   }
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve, reject) => {
     const onAbort = () => {
       signal.removeEventListener("abort", onAbort);
       reject(new TransportError("oauth device flow aborted", { kind: "request" }));
@@ -6336,15 +5291,15 @@ async function sleep(ms, signal) {
     signal.addEventListener("abort", onAbort);
     setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve2();
+      resolve();
     }, ms);
   });
 }
 
 // src/json_path.ts
 var LLMOutputPath = class {
-  constructor(path2 = "/output") {
-    this.path = path2;
+  constructor(path = "/output") {
+    this.path = path;
   }
   /** Select an output by index */
   index(i) {
@@ -6356,8 +5311,8 @@ var LLMOutputPath = class {
   }
 };
 var LLMOutputContentPath = class {
-  constructor(path2) {
-    this.path = path2;
+  constructor(path) {
+    this.path = path;
   }
   /** Select a content item by index */
   content(i) {
@@ -6365,8 +5320,8 @@ var LLMOutputContentPath = class {
   }
 };
 var LLMOutputContentItemPath = class {
-  constructor(path2) {
-    this.path = path2;
+  constructor(path) {
+    this.path = path;
   }
   /** Get the text field pointer */
   text() {
@@ -6382,8 +5337,8 @@ var LLMOutputContentItemPath = class {
   }
 };
 var LLMInputPath = class {
-  constructor(path2 = "/input") {
-    this.path = path2;
+  constructor(path = "/input") {
+    this.path = path;
   }
   /**
    * Select a message by index.
@@ -6402,8 +5357,8 @@ var LLMInputPath = class {
   }
 };
 var LLMInputMessagePath = class {
-  constructor(path2) {
-    this.path = path2;
+  constructor(path) {
+    this.path = path;
   }
   /** Select a content item by index */
   content(i) {
@@ -6415,8 +5370,8 @@ var LLMInputMessagePath = class {
   }
 };
 var LLMInputContentItemPath = class {
-  constructor(path2) {
-    this.path = path2;
+  constructor(path) {
+    this.path = path;
   }
   /** Get the text field pointer */
   text() {
@@ -6442,8 +5397,8 @@ var LLMInputSystemText = LLMInput().systemMessage().text();
 var LLMInputUserText = LLMInput().userMessage().text();
 var LLMInputFirstMessageText = LLMInput().message(0).text();
 var JoinOutputPath = class {
-  constructor(path2) {
-    this.path = path2;
+  constructor(path) {
+    this.path = path;
   }
   /** Access the output array of the node */
   output() {
@@ -8490,173 +7445,16 @@ var ParallelBuilder = class _ParallelBuilder {
           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 });
-    }
-    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 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 };
-    }
-  };
-}
-var MapReduceBuilder = class _MapReduceBuilder {
-  constructor(state) {
-    this.state = state;
-  }
-  static create(name, items) {
-    return new _MapReduceBuilder({ name, items, outputs: [] });
-  }
-  with(patch) {
-    return new _MapReduceBuilder({ ...this.state, ...patch });
-  }
-  /**
-   * 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 }]
-    });
-  }
-  /**
-   * Adds a mapper item with streaming enabled.
-   */
-  itemWithStream(id, request) {
-    return this.with({
-      items: [...this.state.items, { id, request: wireRequest2(request), stream: true }]
-    });
-  }
-  /**
-   * Sets the workflow execution configuration.
-   */
-  execution(exec) {
-    return this.with({ execution: exec });
-  }
-  /**
-   * 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
-      }
-    });
-  }
-  /**
-   * Like reduce() but enables streaming on the reducer node.
-   */
-  reduceWithStream(id, request) {
-    return this.with({
-      reducer: {
-        id,
-        request: wireRequest2(request),
-        stream: true
-      }
-    });
-  }
-  /**
-   * Adds an output reference from a specific node.
-   * Typically used to output from the reducer node.
-   */
-  output(name, from) {
-    return this.with({
-      outputs: [
-        ...this.state.outputs,
-        {
-          name,
-          from,
-          pointer: LLM_TEXT_OUTPUT_INTERNAL
-        }
-      ]
-    });
-  }
-  /**
-   * 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 } : {}
+              // Empty pointer = full join output
+              to: LLM_USER_MESSAGE_TEXT_INTERNAL,
+              encoding: "json_string"
+            }
+          ]
         }
       };
-      nodes.push(input);
-      edges.push({ from: mapperId, to: joinId });
+      nodes.push(aggInput);
+      edges.push({ from: joinId, to: this.state.aggregate.id });
     }
-    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 });
     return {
       kind: WorkflowKinds.WorkflowV0,
       name: this.state.name,
@@ -8667,672 +7465,231 @@ var MapReduceBuilder = class _MapReduceBuilder {
     };
   }
 };
-function MapReduce(name, items = []) {
-  return MapReduceBuilder.create(name, items);
-}
-
-// src/testing.ts
-function buildNDJSONResponse(lines, headers = {}, status = 200) {
-  const encoder = new TextEncoder();
-  const stream = new ReadableStream({
-    start(controller) {
-      for (const line of lines) {
-        controller.enqueue(encoder.encode(`${line}
-`));
-      }
-      controller.close();
-    }
-  });
-  return new Response(stream, {
-    status,
-    headers: {
-      "Content-Type": "application/x-ndjson",
-      ...headers
-    }
-  });
-}
-function buildDelayedNDJSONResponse(steps, headers = {}, status = 200) {
-  const encoder = new TextEncoder();
-  const stream = new ReadableStream({
-    start(controller) {
-      let idx = 0;
-      const pushNext = () => {
-        if (idx >= steps.length) {
-          controller.close();
-          return;
-        }
-        const step = steps[idx++];
-        setTimeout(() => {
-          controller.enqueue(encoder.encode(`${step.line}
-`));
-          pushNext();
-        }, Math.max(0, step.delayMs));
-      };
-      pushNext();
-    }
-  });
-  return new Response(stream, {
-    status,
-    headers: {
-      "Content-Type": "application/x-ndjson",
-      ...headers
-    }
-  });
+function Parallel(name, steps) {
+  return ParallelBuilder.create(name, steps);
 }
-function createMockFetchQueue(responses) {
-  const calls = [];
-  const queue = [...responses];
-  const fetchImpl = async (url, init) => {
-    const call = { url: String(url), init };
-    calls.push(call);
-    const responder = queue.shift();
-    if (!responder) {
-      throw new Error("mock fetch queue exhausted");
-    }
-    if (typeof responder === "function") {
-      return responder(call, calls.length - 1);
+function MapItem(id, request) {
+  const config = {
+    id,
+    request: wireRequest2(request),
+    stream: false
+  };
+  return {
+    ...config,
+    withStream() {
+      return { ...config, stream: true };
     }
-    return responder;
   };
-  return { fetch: fetchImpl, calls };
 }
-
-// src/tools_local_fs.ts
-import { promises as fs } from "fs";
-import * as path from "path";
-import { spawn } from "child_process";
-var ToolNames = {
-  FS_READ_FILE: "fs.read_file",
-  FS_LIST_FILES: "fs.list_files",
-  FS_SEARCH: "fs.search"
-};
-var FSDefaults = {
-  MAX_READ_BYTES: 64e3,
-  HARD_MAX_READ_BYTES: 1e6,
-  MAX_LIST_ENTRIES: 2e3,
-  HARD_MAX_LIST_ENTRIES: 2e4,
-  MAX_SEARCH_MATCHES: 100,
-  HARD_MAX_SEARCH_MATCHES: 2e3,
-  SEARCH_TIMEOUT_MS: 5e3,
-  MAX_SEARCH_BYTES_PER_FILE: 1e6
-};
-var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
-  ".git",
-  "node_modules",
-  "vendor",
-  "dist",
-  "build",
-  ".next",
-  "target",
-  ".idea",
-  ".vscode",
-  "__pycache__",
-  ".pytest_cache",
-  "coverage"
-]);
-var LocalFSToolPack = class {
-  constructor(options) {
-    this.rgPath = null;
-    this.rgChecked = false;
-    const root = options.root?.trim();
-    if (!root) {
-      throw new Error("LocalFSToolPack: root directory required");
-    }
-    this.rootAbs = path.resolve(root);
-    this.cfg = {
-      ignoreDirs: options.ignoreDirs ?? new Set(DEFAULT_IGNORE_DIRS),
-      maxReadBytes: options.maxReadBytes ?? FSDefaults.MAX_READ_BYTES,
-      hardMaxReadBytes: options.hardMaxReadBytes ?? FSDefaults.HARD_MAX_READ_BYTES,
-      maxListEntries: options.maxListEntries ?? FSDefaults.MAX_LIST_ENTRIES,
-      hardMaxListEntries: options.hardMaxListEntries ?? FSDefaults.HARD_MAX_LIST_ENTRIES,
-      maxSearchMatches: options.maxSearchMatches ?? FSDefaults.MAX_SEARCH_MATCHES,
-      hardMaxSearchMatches: options.hardMaxSearchMatches ?? FSDefaults.HARD_MAX_SEARCH_MATCHES,
-      searchTimeoutMs: options.searchTimeoutMs ?? FSDefaults.SEARCH_TIMEOUT_MS,
-      maxSearchBytesPerFile: options.maxSearchBytesPerFile ?? FSDefaults.MAX_SEARCH_BYTES_PER_FILE
-    };
+var MapReduceBuilder = class _MapReduceBuilder {
+  constructor(state) {
+    this.state = state;
   }
-  /**
-   * Returns the tool definitions for LLM requests.
-   * Use these when constructing the tools array for /responses requests.
-   */
-  getToolDefinitions() {
-    return [
-      {
-        type: "function",
-        function: {
-          name: ToolNames.FS_READ_FILE,
-          description: "Read the contents of a file. Returns the file contents as UTF-8 text.",
-          parameters: {
-            type: "object",
-            properties: {
-              path: {
-                type: "string",
-                description: "Workspace-relative path to the file (e.g., 'src/index.ts')"
-              },
-              max_bytes: {
-                type: "integer",
-                description: `Maximum bytes to read. Default: ${this.cfg.maxReadBytes}, max: ${this.cfg.hardMaxReadBytes}`
-              }
-            },
-            required: ["path"]
-          }
-        }
-      },
-      {
-        type: "function",
-        function: {
-          name: ToolNames.FS_LIST_FILES,
-          description: "List files recursively in a directory. Returns newline-separated workspace-relative paths.",
-          parameters: {
-            type: "object",
-            properties: {
-              path: {
-                type: "string",
-                description: "Workspace-relative directory path. Default: '.' (workspace root)"
-              },
-              max_entries: {
-                type: "integer",
-                description: `Maximum files to list. Default: ${this.cfg.maxListEntries}, max: ${this.cfg.hardMaxListEntries}`
-              }
-            }
-          }
-        }
-      },
-      {
-        type: "function",
-        function: {
-          name: ToolNames.FS_SEARCH,
-          description: "Search for text matching a regex pattern. Returns matches as 'path:line:content' format.",
-          parameters: {
-            type: "object",
-            properties: {
-              query: {
-                type: "string",
-                description: "Regex pattern to search for"
-              },
-              path: {
-                type: "string",
-                description: "Workspace-relative directory to search. Default: '.' (workspace root)"
-              },
-              max_matches: {
-                type: "integer",
-                description: `Maximum matches to return. Default: ${this.cfg.maxSearchMatches}, max: ${this.cfg.hardMaxSearchMatches}`
-              }
-            },
-            required: ["query"]
-          }
-        }
-      }
-    ];
+  static create(name, items) {
+    return new _MapReduceBuilder({ name, items, outputs: [] });
+  }
+  with(patch) {
+    return new _MapReduceBuilder({ ...this.state, ...patch });
   }
   /**
-   * Registers handlers into an existing ToolRegistry.
-   * @param registry - The registry to register into
-   * @returns The registry for chaining
+   * Adds a mapper item to the workflow.
+   * Each item becomes a separate LLM node that runs in parallel.
    */
-  registerInto(registry) {
-    registry.register(ToolNames.FS_READ_FILE, this.readFile.bind(this));
-    registry.register(ToolNames.FS_LIST_FILES, this.listFiles.bind(this));
-    registry.register(ToolNames.FS_SEARCH, this.search.bind(this));
-    return registry;
+  item(id, request) {
+    return this.with({
+      items: [...this.state.items, { id, request: wireRequest2(request), stream: false }]
+    });
   }
   /**
-   * Creates a new ToolRegistry with fs.* tools pre-registered.
+   * Adds a mapper item with streaming enabled.
    */
-  toRegistry() {
-    return this.registerInto(new ToolRegistry());
-  }
-  // ========================================================================
-  // Tool Handlers
-  // ========================================================================
-  async readFile(_args, call) {
-    const args = this.parseArgs(call, ["path"]);
-    const func = call.function;
-    const relPath = this.requireString(args, "path", call);
-    const requestedMax = this.optionalPositiveInt(args, "max_bytes", call);
-    let maxBytes = this.cfg.maxReadBytes;
-    if (requestedMax !== void 0) {
-      if (requestedMax > this.cfg.hardMaxReadBytes) {
-        throw new ToolArgumentError({
-          message: `max_bytes exceeds hard cap (${this.cfg.hardMaxReadBytes})`,
-          toolCallId: call.id,
-          toolName: func.name,
-          rawArguments: func.arguments
-        });
-      }
-      maxBytes = requestedMax;
-    }
-    const absPath = await this.resolveAndValidatePath(relPath, call);
-    const stat = await fs.stat(absPath);
-    if (stat.isDirectory()) {
-      throw new Error(`fs.read_file: path is a directory: ${relPath}`);
-    }
-    if (stat.size > maxBytes) {
-      throw new Error(`fs.read_file: file exceeds max_bytes (${maxBytes})`);
-    }
-    const data = await fs.readFile(absPath);
-    if (!this.isValidUtf8(data)) {
-      throw new Error(`fs.read_file: file is not valid UTF-8: ${relPath}`);
-    }
-    return data.toString("utf-8");
-  }
-  async listFiles(_args, call) {
-    const args = this.parseArgs(call, []);
-    const func = call.function;
-    const startPath = this.optionalString(args, "path", call)?.trim() || ".";
-    let maxEntries = this.cfg.maxListEntries;
-    const requestedMax = this.optionalPositiveInt(args, "max_entries", call);
-    if (requestedMax !== void 0) {
-      if (requestedMax > this.cfg.hardMaxListEntries) {
-        throw new ToolArgumentError({
-          message: `max_entries exceeds hard cap (${this.cfg.hardMaxListEntries})`,
-          toolCallId: call.id,
-          toolName: func.name,
-          rawArguments: func.arguments
-        });
-      }
-      maxEntries = requestedMax;
-    }
-    const absPath = await this.resolveAndValidatePath(startPath, call);
-    let rootReal;
-    try {
-      rootReal = await fs.realpath(this.rootAbs);
-    } catch {
-      rootReal = this.rootAbs;
-    }
-    const stat = await fs.stat(absPath);
-    if (!stat.isDirectory()) {
-      throw new Error(`fs.list_files: path is not a directory: ${startPath}`);
-    }
-    const files = [];
-    await this.walkDir(absPath, async (filePath, dirent) => {
-      if (files.length >= maxEntries) {
-        return false;
-      }
-      if (dirent.isDirectory()) {
-        if (this.cfg.ignoreDirs.has(dirent.name)) {
-          return false;
-        }
-        return true;
-      }
-      if (dirent.isFile()) {
-        const relPath = path.relative(rootReal, filePath);
-        files.push(relPath.split(path.sep).join("/"));
-      }
-      return true;
+  itemWithStream(id, request) {
+    return this.with({
+      items: [...this.state.items, { id, request: wireRequest2(request), stream: true }]
     });
-    return files.join("\n");
-  }
-  async search(_args, call) {
-    const args = this.parseArgs(call, ["query"]);
-    const func = call.function;
-    const query = this.requireString(args, "query", call);
-    const startPath = this.optionalString(args, "path", call)?.trim() || ".";
-    let maxMatches = this.cfg.maxSearchMatches;
-    const requestedMax = this.optionalPositiveInt(args, "max_matches", call);
-    if (requestedMax !== void 0) {
-      if (requestedMax > this.cfg.hardMaxSearchMatches) {
-        throw new ToolArgumentError({
-          message: `max_matches exceeds hard cap (${this.cfg.hardMaxSearchMatches})`,
-          toolCallId: call.id,
-          toolName: func.name,
-          rawArguments: func.arguments
-        });
-      }
-      maxMatches = requestedMax;
-    }
-    const absPath = await this.resolveAndValidatePath(startPath, call);
-    const rgPath = await this.detectRipgrep();
-    if (rgPath) {
-      return this.searchWithRipgrep(
-        rgPath,
-        query,
-        absPath,
-        maxMatches
-      );
-    }
-    return this.searchWithJS(query, absPath, maxMatches, call);
   }
-  // ========================================================================
-  // Path Safety
-  // ========================================================================
   /**
-   * Resolves a workspace-relative path and validates it stays within the sandbox.
-   * @throws {ToolArgumentError} if path is invalid
-   * @throws {PathEscapeError} if resolved path escapes root
+   * Sets the workflow execution configuration.
    */
-  async resolveAndValidatePath(relPath, call) {
-    const func = call.function;
-    const cleanRel = relPath.trim();
-    if (!cleanRel) {
-      throw new ToolArgumentError({
-        message: "path cannot be empty",
-        toolCallId: call.id,
-        toolName: func.name,
-        rawArguments: func.arguments
-      });
-    }
-    if (path.isAbsolute(cleanRel)) {
-      throw new ToolArgumentError({
-        message: "path must be workspace-relative (not absolute)",
-        toolCallId: call.id,
-        toolName: func.name,
-        rawArguments: func.arguments
-      });
-    }
-    const normalized = path.normalize(cleanRel);
-    if (normalized.startsWith("..") || normalized.startsWith(`.${path.sep}..`)) {
-      throw new ToolArgumentError({
-        message: "path must not escape the workspace root",
-        toolCallId: call.id,
-        toolName: func.name,
-        rawArguments: func.arguments
-      });
-    }
-    const target = path.join(this.rootAbs, normalized);
-    let rootReal;
-    try {
-      rootReal = await fs.realpath(this.rootAbs);
-    } catch {
-      rootReal = this.rootAbs;
-    }
-    let resolved;
-    try {
-      resolved = await fs.realpath(target);
-    } catch (err) {
-      resolved = path.join(rootReal, normalized);
-    }
-    const relFromRoot = path.relative(rootReal, resolved);
-    if (relFromRoot.startsWith("..") || relFromRoot.startsWith(`.${path.sep}..`) || path.isAbsolute(relFromRoot)) {
-      throw new PathEscapeError({
-        requestedPath: relPath,
-        resolvedPath: resolved
-      });
-    }
-    return resolved;
+  execution(exec) {
+    return this.with({ execution: exec });
   }
-  // ========================================================================
-  // Ripgrep Search
-  // ========================================================================
-  async detectRipgrep() {
-    if (this.rgChecked) {
-      return this.rgPath;
-    }
-    this.rgChecked = true;
-    return new Promise((resolve2) => {
-      const proc = spawn("rg", ["--version"], { stdio: "ignore" });
-      proc.on("error", () => {
-        this.rgPath = null;
-        resolve2(null);
-      });
-      proc.on("close", (code) => {
-        if (code === 0) {
-          this.rgPath = "rg";
-          resolve2("rg");
-        } else {
-          this.rgPath = null;
-          resolve2(null);
-        }
-      });
+  /**
+   * 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
+      }
     });
   }
-  async searchWithRipgrep(rgPath, query, dirAbs, maxMatches) {
-    return new Promise((resolve2, reject) => {
-      const args = ["--line-number", "--no-heading", "--color=never"];
-      for (const name of this.cfg.ignoreDirs) {
-        args.push("--glob", `!**/${name}/**`);
+  /**
+   * Like reduce() but enables streaming on the reducer node.
+   */
+  reduceWithStream(id, request) {
+    return this.with({
+      reducer: {
+        id,
+        request: wireRequest2(request),
+        stream: true
       }
-      args.push(query, dirAbs);
-      const proc = spawn(rgPath, args, {
-        timeout: this.cfg.searchTimeoutMs
-      });
-      const lines = [];
-      let stderr = "";
-      let killed = false;
-      proc.stdout.on("data", (chunk) => {
-        if (killed) return;
-        const text = typeof chunk === "string" ? chunk : chunk.toString("utf-8");
-        const newLines = text.split("\n").filter((l) => l.trim());
-        for (const line of newLines) {
-          lines.push(this.normalizeRipgrepLine(line));
-          if (lines.length >= maxMatches) {
-            killed = true;
-            proc.kill();
-            break;
-          }
-        }
-      });
-      proc.stderr.on("data", (chunk) => {
-        stderr += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
-      });
-      proc.on("error", (err) => {
-        reject(new Error(`fs.search: ripgrep error: ${err.message}`));
-      });
-      proc.on("close", (code) => {
-        if (killed) {
-          resolve2(lines.join("\n"));
-          return;
-        }
-        if (code === 0 || code === 1) {
-          resolve2(lines.join("\n"));
-        } else if (code === 2 && stderr.toLowerCase().includes("regex")) {
-          reject(
-            new ToolArgumentError({
-              message: `invalid query regex: ${stderr.trim()}`,
-              toolCallId: "",
-              toolName: ToolNames.FS_SEARCH,
-              rawArguments: ""
-            })
-          );
-        } else if (stderr) {
-          reject(new Error(`fs.search: ripgrep failed: ${stderr.trim()}`));
-        } else {
-          resolve2(lines.join("\n"));
+    });
+  }
+  /**
+   * Adds an output reference from a specific node.
+   * Typically used to output from the reducer node.
+   */
+  output(name, from) {
+    return this.with({
+      outputs: [
+        ...this.state.outputs,
+        {
+          name,
+          from,
+          pointer: LLM_TEXT_OUTPUT_INTERNAL
         }
-      });
+      ]
     });
   }
-  normalizeRipgrepLine(line) {
-    const trimmed = line.trim();
-    if (!trimmed || !trimmed.includes(":")) {
-      return trimmed;
-    }
-    const colonIdx = trimmed.indexOf(":");
-    const filePath = trimmed.slice(0, colonIdx);
-    const rest = trimmed.slice(colonIdx + 1);
-    if (path.isAbsolute(filePath)) {
-      const rel = path.relative(this.rootAbs, filePath);
-      if (!rel.startsWith("..")) {
-        return rel.split(path.sep).join("/") + ":" + rest;
-      }
+  /**
+   * 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");
     }
-    return filePath.split(path.sep).join("/") + ":" + rest;
-  }
-  // ========================================================================
-  // JavaScript Fallback Search
-  // ========================================================================
-  async searchWithJS(query, dirAbs, maxMatches, call) {
-    const func = call.function;
-    let regex;
-    try {
-      regex = new RegExp(query);
-    } catch (err) {
-      throw new ToolArgumentError({
-        message: `invalid query regex: ${err.message}`,
-        toolCallId: call.id,
-        toolName: func.name,
-        rawArguments: func.arguments
-      });
+    if (!this.state.reducer) {
+      throw new Error("map-reduce requires a reducer (call reduce)");
     }
-    const matches = [];
-    const deadline = Date.now() + this.cfg.searchTimeoutMs;
-    await this.walkDir(dirAbs, async (filePath, dirent) => {
-      if (Date.now() > deadline) {
-        return false;
-      }
-      if (matches.length >= maxMatches) {
-        return false;
-      }
-      if (dirent.isDirectory()) {
-        if (this.cfg.ignoreDirs.has(dirent.name)) {
-          return false;
-        }
-        return true;
+    const seenIds = /* @__PURE__ */ new Set();
+    for (const item of this.state.items) {
+      if (!item.id) {
+        throw new Error("item ID cannot be empty");
       }
-      if (!dirent.isFile()) {
-        return true;
+      if (seenIds.has(item.id)) {
+        throw new Error(`duplicate item ID: "${item.id}"`);
       }
-      try {
-        const stat = await fs.stat(filePath);
-        if (stat.size > this.cfg.maxSearchBytesPerFile) {
-          return true;
+      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 } : {}
         }
-      } catch {
-        return true;
-      }
-      try {
-        const content = await fs.readFile(filePath, "utf-8");
-        const lines = content.split("\n");
-        for (let i = 0; i < lines.length && matches.length < maxMatches; i++) {
-          if (regex.test(lines[i])) {
-            const relPath = path.relative(this.rootAbs, filePath);
-            const normalizedPath = relPath.split(path.sep).join("/");
-            matches.push(`${normalizedPath}:${i + 1}:${lines[i]}`);
+      };
+      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"
           }
-        }
-      } catch {
+        ]
       }
-      return true;
-    });
-    return matches.join("\n");
+    };
+    nodes.push(reducerInput);
+    edges.push({ from: joinId, to: this.state.reducer.id });
+    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)
+    };
   }
-  // ========================================================================
-  // Helpers
-  // ========================================================================
-  parseArgs(call, required) {
-    const func = call.function;
-    if (!func) {
-      throw new ToolArgumentError({
-        message: "tool call missing function",
-        toolCallId: call.id,
-        toolName: "",
-        rawArguments: ""
-      });
-    }
-    const rawArgs = func.arguments || "{}";
-    let parsed;
-    try {
-      parsed = JSON.parse(rawArgs);
-    } catch (err) {
-      throw new ToolArgumentError({
-        message: `invalid JSON arguments: ${err.message}`,
-        toolCallId: call.id,
-        toolName: func.name,
-        rawArguments: rawArgs
-      });
-    }
-    if (typeof parsed !== "object" || parsed === null) {
-      throw new ToolArgumentError({
-        message: "arguments must be an object",
-        toolCallId: call.id,
-        toolName: func.name,
-        rawArguments: rawArgs
-      });
-    }
-    const args = parsed;
-    for (const key of required) {
-      const value = args[key];
-      if (value === void 0 || value === null || value === "") {
-        throw new ToolArgumentError({
-          message: `${key} is required`,
-          toolCallId: call.id,
-          toolName: func.name,
-          rawArguments: rawArgs
-        });
+};
+function MapReduce(name, items = []) {
+  return MapReduceBuilder.create(name, items);
+}
+
+// src/testing.ts
+function buildNDJSONResponse(lines, headers = {}, status = 200) {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    start(controller) {
+      for (const line of lines) {
+        controller.enqueue(encoder.encode(`${line}
+`));
       }
+      controller.close();
     }
-    return args;
-  }
-  toolArgumentError(call, message) {
-    const func = call.function;
-    throw new ToolArgumentError({
-      message,
-      toolCallId: call.id,
-      toolName: func?.name ?? "",
-      rawArguments: func?.arguments ?? ""
-    });
-  }
-  requireString(args, key, call) {
-    const value = args[key];
-    if (typeof value !== "string") {
-      this.toolArgumentError(call, `${key} must be a string`);
-    }
-    if (value.trim() === "") {
-      this.toolArgumentError(call, `${key} is required`);
-    }
-    return value;
-  }
-  optionalString(args, key, call) {
-    const value = args[key];
-    if (value === void 0 || value === null) {
-      return void 0;
-    }
-    if (typeof value !== "string") {
-      this.toolArgumentError(call, `${key} must be a string`);
-    }
-    const trimmed = value.trim();
-    if (trimmed === "") {
-      return void 0;
-    }
-    return value;
-  }
-  optionalPositiveInt(args, key, call) {
-    const value = args[key];
-    if (value === void 0 || value === null) {
-      return void 0;
+  });
+  return new Response(stream, {
+    status,
+    headers: {
+      "Content-Type": "application/x-ndjson",
+      ...headers
     }
-    if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value)) {
-      this.toolArgumentError(call, `${key} must be an integer`);
+  });
+}
+function buildDelayedNDJSONResponse(steps, headers = {}, status = 200) {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    start(controller) {
+      let idx = 0;
+      const pushNext = () => {
+        if (idx >= steps.length) {
+          controller.close();
+          return;
+        }
+        const step = steps[idx++];
+        setTimeout(() => {
+          controller.enqueue(encoder.encode(`${step.line}
+`));
+          pushNext();
+        }, Math.max(0, step.delayMs));
+      };
+      pushNext();
     }
-    if (value <= 0) {
-      this.toolArgumentError(call, `${key} must be > 0`);
+  });
+  return new Response(stream, {
+    status,
+    headers: {
+      "Content-Type": "application/x-ndjson",
+      ...headers
     }
-    return value;
-  }
-  isValidUtf8(buffer) {
-    try {
-      const text = buffer.toString("utf-8");
-      return !text.includes("\uFFFD");
-    } catch {
-      return false;
+  });
+}
+function createMockFetchQueue(responses) {
+  const calls = [];
+  const queue = [...responses];
+  const fetchImpl = async (url, init) => {
+    const call = { url: String(url), init };
+    calls.push(call);
+    const responder = queue.shift();
+    if (!responder) {
+      throw new Error("mock fetch queue exhausted");
     }
-  }
-  /**
-   * Recursively walks a directory, calling visitor for each entry.
-   * Visitor returns true to continue, false to skip (for dirs) or stop.
-   */
-  async walkDir(dir, visitor) {
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      const shouldContinue = await visitor(fullPath, entry);
-      if (!shouldContinue) {
-        if (entry.isDirectory()) {
-          continue;
-        }
-        return;
-      }
-      if (entry.isDirectory()) {
-        await this.walkDir(fullPath, visitor);
-      }
+    if (typeof responder === "function") {
+      return responder(call, calls.length - 1);
     }
-  }
-};
-function createLocalFSToolPack(options) {
-  return new LocalFSToolPack(options);
-}
-function createLocalFSTools(options) {
-  return createLocalFSToolPack(options).toRegistry();
+    return responder;
+  };
+  return { fetch: fetchImpl, calls };
 }
 
 // src/tools_browser.ts
@@ -10087,23 +8444,23 @@ __export(workflow_exports, {
 });
 
 // src/workflow/helpers_v1.ts
-function whenOutputEquals(path2, value) {
-  return { source: "node_output", op: "equals", path: path2, value };
+function whenOutputEquals(path, value) {
+  return { source: "node_output", op: "equals", path, value };
 }
-function whenOutputMatches(path2, pattern) {
-  return { source: "node_output", op: "matches", path: path2, value: pattern };
+function whenOutputMatches(path, pattern) {
+  return { source: "node_output", op: "matches", path, value: pattern };
 }
-function whenOutputExists(path2) {
-  return { source: "node_output", op: "exists", path: path2 };
+function whenOutputExists(path) {
+  return { source: "node_output", op: "exists", path };
 }
-function whenStatusEquals(path2, value) {
-  return { source: "node_status", op: "equals", path: path2, value };
+function whenStatusEquals(path, value) {
+  return { source: "node_status", op: "equals", path, value };
 }
-function whenStatusMatches(path2, pattern) {
-  return { source: "node_status", op: "matches", path: path2, value: pattern };
+function whenStatusMatches(path, pattern) {
+  return { source: "node_status", op: "matches", path, value: pattern };
 }
-function whenStatusExists(path2) {
-  return { source: "node_status", op: "exists", path: path2 };
+function whenStatusExists(path) {
+  return { source: "node_status", op: "exists", path };
 }
 function bindToPlaceholder(from, placeholder, opts) {
   return {
@@ -10407,11 +8764,8 @@ export {
   DEFAULT_BASE_URL,
   DEFAULT_CLIENT_HEADER,
   DEFAULT_CONNECT_TIMEOUT_MS,
-  DEFAULT_IGNORE_DIRS,
   DEFAULT_REQUEST_TIMEOUT_MS,
   ErrorCodes,
-  FSDefaults,
-  ToolNames as FSToolNames,
   FrontendTokenProvider,
   ImagesClient,
   InputItemTypes,
@@ -10433,7 +8787,6 @@ export {
   LLMStep,
   LLM_TEXT_OUTPUT,
   LLM_USER_MESSAGE_TEXT,
-  LocalFSToolPack,
   LocalSession,
   MapFanoutInputError,
   MapItem,
@@ -10474,7 +8827,7 @@ export {
   TransformJSONNodeBuilder,
   TransportError,
   WORKFLOWS_COMPILE_PATH,
-  WebToolModes,
+  WebToolIntents,
   Workflow,
   WorkflowBuilderV0,
   WorkflowBuilderV1,
@@ -10497,8 +8850,6 @@ export {
   createFunctionCall,
   createFunctionTool,
   createFunctionToolFromSchema,
-  createLocalFSToolPack,
-  createLocalFSTools,
   createLocalSession,
   createMemorySessionStore,
   createMockFetchQueue,