@modelrelay/sdk 1.14.0 → 1.27.0

package/dist/index.cjs

@@ -33,6 +33,7 @@ __export(index_exports, {
   APIError: () => APIError,
   AuthClient: () => AuthClient,
   BillingProviders: () => BillingProviders,
+  BindingTargetError: () => BindingTargetError,
   BrowserDefaults: () => BrowserDefaults,
   BrowserToolNames: () => BrowserToolNames,
   BrowserToolPack: () => BrowserToolPack,
@@ -47,20 +48,31 @@ __export(index_exports, {
   DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
   DEFAULT_CLIENT_HEADER: () => DEFAULT_CLIENT_HEADER,
   DEFAULT_CONNECT_TIMEOUT_MS: () => DEFAULT_CONNECT_TIMEOUT_MS,
-  DEFAULT_IGNORE_DIRS: () => DEFAULT_IGNORE_DIRS,
   DEFAULT_REQUEST_TIMEOUT_MS: () => DEFAULT_REQUEST_TIMEOUT_MS,
   ErrorCodes: () => ErrorCodes,
-  FSDefaults: () => FSDefaults,
-  FSToolNames: () => ToolNames,
   FrontendTokenProvider: () => FrontendTokenProvider,
   ImagesClient: () => ImagesClient,
   InputItemTypes: () => InputItemTypes,
+  JoinOutput: () => JoinOutput,
+  JoinOutputPath: () => JoinOutputPath,
+  LLMInput: () => LLMInput,
+  LLMInputContentItemPath: () => LLMInputContentItemPath,
+  LLMInputFirstMessageText: () => LLMInputFirstMessageText,
+  LLMInputMessagePath: () => LLMInputMessagePath,
+  LLMInputPath: () => LLMInputPath,
+  LLMInputSystemText: () => LLMInputSystemText,
+  LLMInputUserText: () => LLMInputUserText,
   LLMNodeBuilder: () => LLMNodeBuilder,
+  LLMOutput: () => LLMOutput,
+  LLMOutputContentItemPath: () => LLMOutputContentItemPath,
+  LLMOutputContentPath: () => LLMOutputContentPath,
+  LLMOutputPath: () => LLMOutputPath,
+  LLMOutputText: () => LLMOutputText,
   LLMStep: () => LLMStep,
   LLM_TEXT_OUTPUT: () => LLM_TEXT_OUTPUT,
   LLM_USER_MESSAGE_TEXT: () => LLM_USER_MESSAGE_TEXT,
-  LocalFSToolPack: () => LocalFSToolPack,
   LocalSession: () => LocalSession,
+  MapFanoutInputError: () => MapFanoutInputError,
   MapItem: () => MapItem,
   MapReduce: () => MapReduce,
   MapReduceBuilder: () => MapReduceBuilder,
@@ -99,9 +111,10 @@ __export(index_exports, {
   TransformJSONNodeBuilder: () => TransformJSONNodeBuilder,
   TransportError: () => TransportError,
   WORKFLOWS_COMPILE_PATH: () => WORKFLOWS_COMPILE_PATH,
-  WebToolModes: () => WebToolModes,
+  WebToolIntents: () => WebToolIntents,
   Workflow: () => Workflow,
   WorkflowBuilderV0: () => WorkflowBuilderV0,
+  WorkflowBuilderV1: () => WorkflowBuilderV1,
   WorkflowKinds: () => WorkflowKinds,
   WorkflowNodeTypes: () => WorkflowNodeTypes,
   WorkflowValidationError: () => WorkflowValidationError,
@@ -111,6 +124,8 @@ __export(index_exports, {
   asSessionId: () => asSessionId,
   asTierCode: () => asTierCode,
   assistantMessageWithToolCalls: () => assistantMessageWithToolCalls,
+  buildDelayedNDJSONResponse: () => buildDelayedNDJSONResponse,
+  buildNDJSONResponse: () => buildNDJSONResponse,
   createAccessTokenAuth: () => createAccessTokenAuth,
   createApiKeyAuth: () => createApiKeyAuth,
   createAssistantMessage: () => createAssistantMessage,
@@ -119,10 +134,9 @@ __export(index_exports, {
   createFunctionCall: () => createFunctionCall,
   createFunctionTool: () => createFunctionTool,
   createFunctionToolFromSchema: () => createFunctionToolFromSchema,
-  createLocalFSToolPack: () => createLocalFSToolPack,
-  createLocalFSTools: () => createLocalFSTools,
   createLocalSession: () => createLocalSession,
   createMemorySessionStore: () => createMemorySessionStore,
+  createMockFetchQueue: () => createMockFetchQueue,
   createRetryMessages: () => createRetryMessages,
   createSystemMessage: () => createSystemMessage,
   createToolCall: () => createToolCall,
@@ -164,6 +178,7 @@ __export(index_exports, {
   parseToolArgs: () => parseToolArgs,
   parseToolArgsRaw: () => parseToolArgsRaw,
   pollOAuthDeviceToken: () => pollOAuthDeviceToken,
+  pollUntil: () => pollUntil,
   respondToToolCall: () => respondToToolCall,
   runOAuthDeviceFlowForIDToken: () => runOAuthDeviceFlowForIDToken,
   startOAuthDeviceAuthorization: () => startOAuthDeviceAuthorization,
@@ -173,13 +188,18 @@ __export(index_exports, {
   toolChoiceRequired: () => toolChoiceRequired,
   toolResultMessage: () => toolResultMessage,
   transformJSONMerge: () => transformJSONMerge,
+  transformJSONMergeV1: () => transformJSONMergeV1,
   transformJSONObject: () => transformJSONObject,
+  transformJSONObjectV1: () => transformJSONObjectV1,
   transformJSONValue: () => transformJSONValue,
+  transformJSONValueV1: () => transformJSONValueV1,
   tryParseToolArgs: () => tryParseToolArgs,
   validateWithZod: () => validateWithZod,
   workflow: () => workflow_exports,
   workflowV0: () => workflowV0,
   workflowV0Schema: () => workflow_v0_schema_default,
+  workflowV1: () => workflowV1,
+  workflowV1Schema: () => workflow_v1_schema_default,
   zodToJsonSchema: () => zodToJsonSchema
 });
 module.exports = __toCommonJS(index_exports);
@@ -248,11 +268,11 @@ var StreamProtocolError = class extends TransportError {
     this.status = opts.status;
   }
 };
-var StreamTimeoutError = class extends TransportError {
+var StreamTimeoutError = class extends ModelRelayError {
   constructor(streamKind, timeoutMs) {
     const label = streamKind === "ttft" ? "TTFT" : streamKind === "idle" ? "idle" : "total";
-    super(`stream ${label} timeout after ${timeoutMs}ms`, { kind: "timeout" });
-    this.streamKind = streamKind;
+    super(`stream ${label} timeout after ${timeoutMs}ms`, { category: "transport", status: 408 });
+    this.kind = streamKind;
     this.timeoutMs = timeoutMs;
   }
 };
@@ -407,10 +427,10 @@ async function parseErrorResponse(response, retries) {
         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 path = 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 (!code || !path || !message) continue;
+        normalized.push({ code, path, message });
       }
       if (normalized.length > 0) {
         return new WorkflowValidationError({
@@ -760,8 +780,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
     });
@@ -884,7 +904,7 @@ function isTokenReusable(token) {
 // package.json
 var package_default = {
   name: "@modelrelay/sdk",
-  version: "1.14.0",
+  version: "1.27.0",
   description: "TypeScript SDK for the ModelRelay API",
   type: "module",
   main: "dist/index.cjs",
@@ -895,6 +915,11 @@ var package_default = {
       types: "./dist/index.d.ts",
       import: "./dist/index.js",
       require: "./dist/index.cjs"
+    },
+    "./node": {
+      types: "./dist/node.d.ts",
+      import: "./dist/node.js",
+      require: "./dist/node.cjs"
     }
   },
   publishConfig: {
@@ -904,8 +929,8 @@ var package_default = {
     "dist"
   ],
   scripts: {
-    build: "tsup src/index.ts --format esm,cjs --dts --external playwright",
-    dev: "tsup src/index.ts --format esm,cjs --dts --watch",
+    build: "tsup src/index.ts src/node.ts --format esm,cjs --dts --external playwright",
+    dev: "tsup src/index.ts src/node.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"
@@ -1013,11 +1038,10 @@ var ToolTypes = {
   XSearch: "x_search",
   CodeExecution: "code_execution"
 };
-var WebToolModes = {
+var WebToolIntents = {
   Auto: "auto",
-  SearchOnly: "search_only",
-  FetchOnly: "fetch_only",
-  SearchAndFetch: "search_and_fetch"
+  SearchWeb: "search_web",
+  FetchURL: "fetch_url"
 };
 var ToolChoiceTypes = {
   Auto: "auto",
@@ -1358,7 +1382,7 @@ function createWebTool(options) {
   return {
     type: ToolTypes.Web,
     web: options ? {
-      mode: options.mode,
+      intent: options.intent,
       allowedDomains: options.allowedDomains,
       excludedDomains: options.excludedDomains,
       maxUses: options.maxUses
@@ -1502,8 +1526,8 @@ function parseToolArgs(call, schema) {
       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}`;
+          const path = e.path.length > 0 ? `${e.path.join(".")}: ` : "";
+          return `${path}${e.message}`;
         }).join("; ");
         message = issues;
       } else {
@@ -2069,7 +2093,7 @@ function extractAssistantText(output) {
   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: "request"
+      kind: "empty_response"
     });
   }
   return text;
@@ -2763,6 +2787,101 @@ var ResponsesClient = class {
     const resp = await this.create(req, options);
     return extractAssistantText(resp.output);
   }
+  /**
+   * Generate a typed object from a Zod schema with a single function call.
+   *
+   * This is the most ergonomic way to get structured output - all configuration
+   * is passed in a single object argument, matching the Vercel AI SDK pattern.
+   *
+   * @example
+   * ```typescript
+   * import { z } from 'zod';
+   *
+   * const review = await client.responses.object({
+   *   model: 'claude-sonnet-4-20250514',
+   *   schema: z.object({
+   *     vulnerabilities: z.array(z.string()),
+   *     riskLevel: z.enum(['low', 'medium', 'high']),
+   *   }),
+   *   system: 'You are a security expert.',
+   *   prompt: `Review this code:\n${code}`,
+   * });
+   *
+   * console.log(review.riskLevel); // 'low' | 'medium' | 'high'
+   * ```
+   *
+   * @example Parallel execution with Promise.all
+   * ```typescript
+   * const [security, performance] = await Promise.all([
+   *   client.responses.object({
+   *     model,
+   *     schema: SecuritySchema,
+   *     system: 'Security expert...',
+   *     prompt: code,
+   *   }),
+   *   client.responses.object({
+   *     model,
+   *     schema: PerformanceSchema,
+   *     system: 'Performance expert...',
+   *     prompt: code,
+   *   }),
+   * ]);
+   * ```
+   */
+  async object(args) {
+    let builder = this.new().model(args.model);
+    if (args.system) {
+      builder = builder.system(args.system);
+    }
+    builder = builder.user(args.prompt);
+    if (args.customerId) {
+      builder = builder.customerId(args.customerId);
+    }
+    const request = builder.build();
+    const result = await this.structured(args.schema, request, {
+      maxRetries: args.maxRetries,
+      retryHandler: args.retryHandler,
+      schemaName: args.schemaName,
+      ...args.options
+    });
+    return result.value;
+  }
+  /**
+   * Generate a typed object with full result metadata.
+   *
+   * Like `object()` but returns the full `StructuredResult<T>` including
+   * attempt count and request ID.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.responses.objectWithMetadata({
+   *   model: 'claude-sonnet-4-20250514',
+   *   schema: ReviewSchema,
+   *   prompt: 'Review this code...',
+   * });
+   *
+   * console.log(result.value);     // The parsed object
+   * console.log(result.attempts);  // Number of attempts (1 = first try succeeded)
+   * console.log(result.requestId); // Server request ID
+   * ```
+   */
+  async objectWithMetadata(args) {
+    let builder = this.new().model(args.model);
+    if (args.system) {
+      builder = builder.system(args.system);
+    }
+    builder = builder.user(args.prompt);
+    if (args.customerId) {
+      builder = builder.customerId(args.customerId);
+    }
+    const request = builder.build();
+    return this.structured(args.schema, request, {
+      maxRetries: args.maxRetries,
+      retryHandler: args.retryHandler,
+      schemaName: args.schemaName,
+      ...args.options
+    });
+  }
   async textForCustomer(customerIdOrArgs, system, user, options = {}) {
     const args = typeof customerIdOrArgs === "string" ? { customerId: customerIdOrArgs, system, user, options } : customerIdOrArgs;
     if (args.system === void 0 || args.user === void 0) {
@@ -3203,13 +3322,23 @@ function parseOutputName(raw) {
 
 // src/runs_types.ts
 var WorkflowKinds = {
-  WorkflowV0: "workflow.v0"
+  WorkflowV0: "workflow.v0",
+  WorkflowV1: "workflow.v1"
 };
 var WorkflowNodeTypes = {
   LLMResponses: "llm.responses",
   JoinAll: "join.all",
   TransformJSON: "transform.json"
 };
+var WorkflowNodeTypesV1 = {
+  LLMResponses: "llm.responses",
+  RouteSwitch: "route.switch",
+  JoinAll: "join.all",
+  JoinAny: "join.any",
+  JoinCollect: "join.collect",
+  TransformJSON: "transform.json",
+  MapFanout: "map.fanout"
+};
 var nodeErrorSchema = import_zod.default.object({
   code: import_zod.default.string().optional(),
   message: import_zod.default.string().min(1)
@@ -3567,6 +3696,9 @@ var RunsClient = class {
     const headers = { ...options.headers || {} };
     this.applyCustomerHeader(headers, options.customerId);
     const payload = { spec };
+    if (options.sessionId?.trim()) {
+      payload.session_id = options.sessionId.trim();
+    }
     if (options.idempotencyKey?.trim()) {
       payload.options = { idempotency_key: options.idempotencyKey.trim() };
     }
@@ -3622,10 +3754,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,
@@ -3636,7 +3768,7 @@ var RunsClient = class {
       retry: options.retry,
       metrics,
       trace,
-      context: { method: "GET", path: path2 }
+      context: { method: "GET", path }
     });
     return {
       ...out,
@@ -3660,10 +3792,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,
@@ -3714,10 +3846,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,
@@ -3729,7 +3861,7 @@ var RunsClient = class {
       retry: options.retry,
       metrics,
       trace,
-      context: { method: "POST", path: path2 }
+      context: { method: "POST", path }
     });
     return out;
   }
@@ -3737,10 +3869,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,
@@ -3751,7 +3883,7 @@ var RunsClient = class {
       retry: options.retry,
       metrics,
       trace,
-      context: { method: "GET", path: path2 }
+      context: { method: "GET", path }
     });
     return {
       ...out,
@@ -3835,6 +3967,65 @@ var WorkflowsClient = class {
       throw err;
     }
   }
+  async compileV1(spec, options = {}) {
+    const metrics = mergeMetrics(this.metrics, options.metrics);
+    const trace = mergeTrace(this.trace, options.trace);
+    const authHeaders = await this.auth.authForResponses();
+    const headers = { ...options.headers || {} };
+    const customerId = options.customerId?.trim();
+    if (customerId) {
+      headers[CUSTOMER_ID_HEADER] = customerId;
+    }
+    try {
+      const out = await this.http.json(
+        WORKFLOWS_COMPILE_PATH,
+        {
+          method: "POST",
+          headers,
+          body: spec,
+          signal: options.signal,
+          apiKey: authHeaders.apiKey,
+          accessToken: authHeaders.accessToken,
+          timeoutMs: options.timeoutMs,
+          connectTimeoutMs: options.connectTimeoutMs,
+          retry: options.retry,
+          metrics,
+          trace,
+          context: { method: "POST", path: WORKFLOWS_COMPILE_PATH }
+        }
+      );
+      return {
+        ok: true,
+        plan_json: out.plan_json,
+        plan_hash: parsePlanHash(out.plan_hash)
+      };
+    } catch (err) {
+      if (err instanceof WorkflowValidationError) {
+        return { ok: false, error_type: "validation_error", issues: err.issues };
+      }
+      if (err instanceof APIError) {
+        return {
+          ok: false,
+          error_type: "internal_error",
+          status: err.status ?? 0,
+          message: err.message,
+          code: err.code,
+          requestId: err.requestId
+        };
+      }
+      if (err instanceof ModelRelayError && err.category === "api") {
+        return {
+          ok: false,
+          error_type: "internal_error",
+          status: err.status ?? 0,
+          message: err.message,
+          code: err.code,
+          requestId: err.requestId
+        };
+      }
+      throw err;
+    }
+  }
 };
 
 // src/customers.ts
@@ -4195,8 +4386,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;
   }
 };
@@ -4230,8 +4421,287 @@ var ImagesClient = class {
       accessToken: auth.accessToken
     });
   }
+  /**
+   * Get information about a specific image.
+   *
+   * Returns the image's pinned status, expiration time, and URL.
+   *
+   * @param imageId - The image ID to retrieve
+   * @returns Image details including pinned status and URL
+   * @throws {Error} If imageId is empty
+   */
+  async get(imageId) {
+    if (!imageId?.trim()) {
+      throw new Error("imageId is required");
+    }
+    const auth = await this.auth.authForResponses();
+    return await this.http.json(`/images/${imageId}`, {
+      method: "GET",
+      apiKey: auth.apiKey,
+      accessToken: auth.accessToken
+    });
+  }
+  /**
+   * Pin an image to prevent it from expiring.
+   *
+   * Pinned images remain accessible permanently (subject to tier limits).
+   *
+   * @param imageId - The image ID to pin
+   * @returns Updated image state including permanent URL
+   * @throws {Error} If imageId is empty
+   */
+  async pin(imageId) {
+    if (!imageId?.trim()) {
+      throw new Error("imageId is required");
+    }
+    const auth = await this.auth.authForResponses();
+    return await this.http.json(`/images/${imageId}/pin`, {
+      method: "POST",
+      apiKey: auth.apiKey,
+      accessToken: auth.accessToken
+    });
+  }
+  /**
+   * Unpin an image, allowing it to expire.
+   *
+   * The image will expire after the default ephemeral period (7 days).
+   *
+   * @param imageId - The image ID to unpin
+   * @returns Updated image state including new expiration time
+   * @throws {Error} If imageId is empty
+   */
+  async unpin(imageId) {
+    if (!imageId?.trim()) {
+      throw new Error("imageId is required");
+    }
+    const auth = await this.auth.authForResponses();
+    return await this.http.json(`/images/${imageId}/pin`, {
+      method: "DELETE",
+      apiKey: auth.apiKey,
+      accessToken: auth.accessToken
+    });
+  }
 };
 
+// src/sessions/context_management.ts
+var DEFAULT_CONTEXT_BUFFER_TOKENS = 256;
+var CONTEXT_BUFFER_RATIO = 0.02;
+var MESSAGE_OVERHEAD_TOKENS = 6;
+var TOOL_CALL_OVERHEAD_TOKENS = 4;
+var CHARS_PER_TOKEN = 4;
+var IMAGE_TOKENS_LOW_DETAIL = 85;
+var IMAGE_TOKENS_HIGH_DETAIL = 1e3;
+var modelContextCache = /* @__PURE__ */ new WeakMap();
+function createModelContextResolver(client) {
+  return async (modelId) => {
+    const entry = getModelContextCacheEntry(client);
+    const key = String(modelId);
+    const cached = entry.byId.get(key);
+    if (cached !== void 0) {
+      return cached;
+    }
+    await populateModelContextCache(client, entry);
+    const resolved = entry.byId.get(key);
+    if (resolved === void 0) {
+      throw new ConfigError(
+        `Unknown model "${key}"; ensure the model exists in the ModelRelay catalog`
+      );
+    }
+    return resolved;
+  };
+}
+async function buildSessionInputWithContext(messages, options, defaultModel, resolveModelContext) {
+  const strategy = options.contextManagement ?? "none";
+  if (strategy === "none") {
+    return messagesToInput(messages);
+  }
+  if (strategy === "summarize") {
+    throw new ConfigError("contextManagement 'summarize' is not implemented yet");
+  }
+  if (strategy !== "truncate") {
+    throw new ConfigError(`Unknown contextManagement strategy: ${strategy}`);
+  }
+  const modelId = options.model ?? defaultModel;
+  if (!modelId) {
+    throw new ConfigError(
+      "model is required for context management; set options.model or a session defaultModel"
+    );
+  }
+  const budget = await resolveHistoryBudget(
+    modelId,
+    options,
+    resolveModelContext
+  );
+  const truncated = truncateMessagesByTokens(
+    messages,
+    budget.maxHistoryTokens
+  );
+  if (options.onContextTruncate && truncated.length < messages.length) {
+    const info = {
+      model: modelId,
+      originalMessages: messages.length,
+      keptMessages: truncated.length,
+      maxHistoryTokens: budget.maxHistoryTokens,
+      reservedOutputTokens: budget.reservedOutputTokens
+    };
+    options.onContextTruncate(info);
+  }
+  return messagesToInput(truncated);
+}
+function messagesToInput(messages) {
+  return messages.map((m) => ({
+    type: m.type,
+    role: m.role,
+    content: m.content,
+    toolCalls: m.toolCalls,
+    toolCallId: m.toolCallId
+  }));
+}
+function truncateMessagesByTokens(messages, maxHistoryTokens) {
+  const maxTokens = normalizePositiveInt(maxHistoryTokens, "maxHistoryTokens");
+  if (messages.length === 0) return [];
+  const tokensByIndex = messages.map((msg) => estimateTokensForMessage(msg));
+  const systemIndices = messages.map((msg, idx) => msg.role === "system" ? idx : -1).filter((idx) => idx >= 0);
+  let selectedSystem = [...systemIndices];
+  let systemTokens = sumTokens(tokensByIndex, selectedSystem);
+  while (systemTokens > maxTokens && selectedSystem.length > 1) {
+    selectedSystem.shift();
+    systemTokens = sumTokens(tokensByIndex, selectedSystem);
+  }
+  if (systemTokens > maxTokens) {
+    throw new ConfigError(
+      "maxHistoryTokens is too small to fit the latest system message"
+    );
+  }
+  const selected = new Set(selectedSystem);
+  let remaining = maxTokens - systemTokens;
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    if (selected.has(i)) continue;
+    const tokens = tokensByIndex[i];
+    if (tokens <= remaining) {
+      selected.add(i);
+      remaining -= tokens;
+    }
+  }
+  const result = messages.filter((_, idx) => selected.has(idx));
+  if (result.length === 0) {
+    throw new ConfigError("No messages fit within maxHistoryTokens");
+  }
+  return result;
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function isImagePart(part) {
+  if (typeof part !== "object" || part === null) return false;
+  const p = part;
+  return p.type === "image" || p.type === "image_url";
+}
+function estimateImageTokens(part) {
+  const detail = part.detail ?? "auto";
+  if (detail === "low") return IMAGE_TOKENS_LOW_DETAIL;
+  return IMAGE_TOKENS_HIGH_DETAIL;
+}
+function estimateTokensForMessage(message) {
+  const segments = [message.role];
+  let imageTokens = 0;
+  for (const part of message.content || []) {
+    if (part.type === "text" && part.text) {
+      segments.push(part.text);
+    } else if (isImagePart(part)) {
+      imageTokens += estimateImageTokens(part);
+    }
+  }
+  if (message.toolCalls) {
+    for (const call of message.toolCalls) {
+      if (call.function?.name) segments.push(call.function.name);
+      if (call.function?.arguments) segments.push(call.function.arguments);
+    }
+  }
+  if (message.toolCallId) {
+    segments.push(message.toolCallId);
+  }
+  const textTokens = estimateTokens(segments.join("\n"));
+  const toolOverhead = message.toolCalls ? message.toolCalls.length * TOOL_CALL_OVERHEAD_TOKENS : 0;
+  return textTokens + MESSAGE_OVERHEAD_TOKENS + toolOverhead + imageTokens;
+}
+function normalizePositiveInt(value, label) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new ConfigError(`${label} must be a positive number`);
+  }
+  return Math.floor(value);
+}
+function sumTokens(tokensByIndex, indices) {
+  return indices.reduce((sum, idx) => sum + tokensByIndex[idx], 0);
+}
+async function resolveHistoryBudget(modelId, options, resolveModelContext) {
+  const reservedOutputTokens = options.reserveOutputTokens === void 0 ? void 0 : normalizeNonNegativeInt(
+    options.reserveOutputTokens,
+    "reserveOutputTokens"
+  );
+  if (options.maxHistoryTokens !== void 0) {
+    return {
+      maxHistoryTokens: normalizePositiveInt(
+        options.maxHistoryTokens,
+        "maxHistoryTokens"
+      ),
+      reservedOutputTokens
+    };
+  }
+  const model = await resolveModelContext(modelId);
+  if (!model) {
+    throw new ConfigError(
+      `Unknown model "${modelId}"; ensure the model exists in the ModelRelay catalog`
+    );
+  }
+  const contextWindow = normalizePositiveInt(model.contextWindow, "context_window");
+  const modelOutputTokens = model.maxOutputTokens === void 0 ? 0 : normalizeNonNegativeInt(model.maxOutputTokens, "max_output_tokens");
+  const effectiveReserve = reservedOutputTokens ?? modelOutputTokens;
+  const buffer = Math.max(
+    DEFAULT_CONTEXT_BUFFER_TOKENS,
+    Math.ceil(contextWindow * CONTEXT_BUFFER_RATIO)
+  );
+  const maxHistoryTokens = contextWindow - effectiveReserve - buffer;
+  if (maxHistoryTokens <= 0) {
+    throw new ConfigError(
+      "model context window is too small after reserving output tokens; set maxHistoryTokens explicitly"
+    );
+  }
+  return {
+    maxHistoryTokens,
+    reservedOutputTokens: effectiveReserve
+  };
+}
+function normalizeNonNegativeInt(value, label) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new ConfigError(`${label} must be a non-negative number`);
+  }
+  return Math.floor(value);
+}
+function getModelContextCacheEntry(client) {
+  const existing = modelContextCache.get(client);
+  if (existing) return existing;
+  const entry = { byId: /* @__PURE__ */ new Map() };
+  modelContextCache.set(client, entry);
+  return entry;
+}
+async function populateModelContextCache(client, entry) {
+  if (!entry.listPromise) {
+    entry.listPromise = (async () => {
+      const models = await client.models.list();
+      for (const model of models) {
+        entry.byId.set(String(model.model_id), {
+          contextWindow: model.context_window,
+          maxOutputTokens: model.max_output_tokens
+        });
+      }
+    })().finally(() => {
+      entry.listPromise = void 0;
+    });
+  }
+  await entry.listPromise;
+}
+
 // src/sessions/types.ts
 function asSessionId(value) {
   return value;
@@ -4296,6 +4766,7 @@ var LocalSession = class _LocalSession {
     this.defaultProvider = options.defaultProvider;
     this.defaultTools = options.defaultTools;
     this.metadata = options.metadata || {};
+    this.resolveModelContext = createModelContextResolver(client);
     if (existingState) {
       this.id = existingState.id;
       this.messages = existingState.messages.map((m) => ({
@@ -4362,7 +4833,7 @@ var LocalSession = class _LocalSession {
     this.currentNodeId = void 0;
     this.currentWaiting = void 0;
     try {
-      const input = this.buildInput();
+      const input = await this.buildInput(options);
       const tools = mergeTools(this.defaultTools, options.tools);
       const spec = {
         kind: "workflow.v0",
@@ -4424,6 +4895,68 @@ var LocalSession = class _LocalSession {
     await this.persist();
     await this.store.close();
   }
+  /**
+   * Sync this local session's messages to a remote session.
+   *
+   * This uploads all local messages to the remote session, enabling
+   * cross-device access and server-side backup. Messages are synced
+   * in order and the remote session's history will contain all local
+   * messages after sync completes.
+   *
+   * @param remoteSession - The remote session to sync to
+   * @param options - Optional sync configuration
+   * @returns Sync result with message count
+   *
+   * @example
+   * ```typescript
+   * // Create local session and work offline
+   * const local = LocalSession.create(client, { ... });
+   * await local.run("Implement the feature");
+   *
+   * // Later, sync to remote for backup/sharing
+   * const remote = await RemoteSession.create(client);
+   * const result = await local.syncTo(remote, {
+   *   onProgress: (synced, total) => console.log(`${synced}/${total}`),
+   * });
+   * ```
+   */
+  async syncTo(remoteSession, options = {}) {
+    const { onProgress, signal } = options;
+    const total = this.messages.length;
+    if (total === 0) {
+      return {
+        messagesSynced: 0,
+        remoteSessionId: remoteSession.id
+      };
+    }
+    if (remoteSession.history.length > 0) {
+      throw new ConfigError(
+        `Cannot sync to non-empty remote session (has ${remoteSession.history.length} messages). syncTo() is for initial migration only. Create a new remote session or use bidirectional sync.`
+      );
+    }
+    const http = this.client.http;
+    let synced = 0;
+    for (const message of this.messages) {
+      if (signal?.aborted) {
+        throw new Error("Sync aborted");
+      }
+      await http.request(`/sessions/${remoteSession.id}/messages`, {
+        method: "POST",
+        body: {
+          role: message.role,
+          content: message.content,
+          run_id: message.runId ? String(message.runId) : void 0
+        }
+      });
+      synced++;
+      onProgress?.(synced, total);
+    }
+    await remoteSession.refresh();
+    return {
+      messagesSynced: synced,
+      remoteSessionId: remoteSession.id
+    };
+  }
   // ============================================================================
   // Private Methods
   // ============================================================================
@@ -4438,14 +4971,13 @@ var LocalSession = class _LocalSession {
     this.updatedAt = /* @__PURE__ */ new Date();
     return message;
   }
-  buildInput() {
-    return this.messages.map((m) => ({
-      type: m.type,
-      role: m.role,
-      content: m.content,
-      toolCalls: m.toolCalls,
-      toolCallId: m.toolCallId
-    }));
+  async buildInput(options) {
+    return buildSessionInputWithContext(
+      this.messages,
+      options,
+      this.defaultModel,
+      this.resolveModelContext
+    );
   }
   async processRunEvents(signal) {
     if (!this.currentRunId) {
@@ -4670,6 +5202,7 @@ var RemoteSession = class _RemoteSession {
     this.defaultModel = options.defaultModel;
     this.defaultProvider = options.defaultProvider;
     this.defaultTools = options.defaultTools;
+    this.resolveModelContext = createModelContextResolver(client);
     if ("messages" in sessionData && sessionData.messages) {
       this.messages = sessionData.messages.map((m) => ({
         type: "message",
@@ -4780,7 +5313,7 @@ var RemoteSession = class _RemoteSession {
     });
     this.resetRunState();
     try {
-      const input = this.buildInput();
+      const input = await this.buildInput(options);
       const tools = mergeTools2(this.defaultTools, options.tools);
       const spec = {
         kind: "workflow.v0",
@@ -4803,7 +5336,8 @@ var RemoteSession = class _RemoteSession {
         outputs: [{ name: "result", from: "main" }]
       };
       const run = await this.client.runs.create(spec, {
-        customerId: options.customerId || this.endUserId
+        customerId: options.customerId || this.endUserId,
+        sessionId: String(this.id)
       });
       this.currentRunId = run.run_id;
       return await this.processRunEvents(options.signal);
@@ -4888,14 +5422,13 @@ var RemoteSession = class _RemoteSession {
     this.updatedAt = /* @__PURE__ */ new Date();
     return message;
   }
-  buildInput() {
-    return this.messages.map((m) => ({
-      type: m.type,
-      role: m.role,
-      content: m.content,
-      toolCalls: m.toolCalls,
-      toolCallId: m.toolCallId
-    }));
+  async buildInput(options) {
+    return buildSessionInputWithContext(
+      this.messages,
+      options,
+      this.defaultModel,
+      this.resolveModelContext
+    );
   }
   resetRunState() {
     this.currentRunId = void 0;
@@ -4972,10 +5505,7 @@ var RemoteSession = class _RemoteSession {
           break;
         case "run_completed": {
           const runState2 = await this.client.runs.get(this.currentRunId);
-          let output2;
-          if (runState2.outputs && Array.isArray(runState2.outputs)) {
-            output2 = runState2.outputs.filter((o) => o.type === "text").map((o) => o.text || "").join("");
-          }
+          const output2 = this.extractOutputText(runState2.outputs);
           if (output2) {
             this.addMessage(
               {
@@ -4983,7 +5513,8 @@ var RemoteSession = class _RemoteSession {
                 role: "assistant",
                 content: [{ type: "text", text: output2 }]
               },
-              this.currentRunId
+              this.currentRunId,
+              false
             );
           }
           await this.flushPendingMessages();
@@ -5013,10 +5544,7 @@ var RemoteSession = class _RemoteSession {
       }
     }
     const runState = await this.client.runs.get(this.currentRunId);
-    let output;
-    if (runState.outputs && Array.isArray(runState.outputs)) {
-      output = runState.outputs.filter((o) => o.type === "text").map((o) => o.text || "").join("");
-    }
+    const output = this.extractOutputText(runState.outputs);
     if (output) {
       this.addMessage(
         {
@@ -5024,7 +5552,8 @@ var RemoteSession = class _RemoteSession {
           role: "assistant",
           content: [{ type: "text", text: output }]
         },
-        this.currentRunId
+        this.currentRunId,
+        false
       );
     }
     await this.flushPendingMessages();
@@ -5111,6 +5640,45 @@ var RemoteSession = class _RemoteSession {
       runId: data.run_id ? parseRunId(data.run_id) : void 0
     };
   }
+  extractOutputText(outputs) {
+    if (!outputs) return void 0;
+    for (const value of Object.values(outputs)) {
+      const text = this.extractTextFromOutputValue(value);
+      if (text) return text;
+    }
+    return void 0;
+  }
+  extractTextFromOutputValue(value) {
+    if (!value || typeof value !== "object") return void 0;
+    if ("output" in value && Array.isArray(value.output)) {
+      return this.extractTextFromOutputItems(value.output);
+    }
+    if (Array.isArray(value)) {
+      const arr = value;
+      if (arr.length === 0 || typeof arr[0] !== "object") return void 0;
+      if ("content" in arr[0]) {
+        return this.extractTextFromOutputItems(arr);
+      }
+      if ("type" in arr[0] && "text" in arr[0]) {
+        return this.extractTextFromContentParts(arr);
+      }
+    }
+    return void 0;
+  }
+  extractTextFromOutputItems(items) {
+    const texts = [];
+    for (const item of items) {
+      if (item.type !== "message" || item.role !== "assistant") continue;
+      texts.push(this.extractTextFromContentParts(item.content) || "");
+    }
+    const combined = texts.join("");
+    return combined.trim() ? combined : void 0;
+  }
+  extractTextFromContentParts(parts) {
+    if (!parts || parts.length === 0) return void 0;
+    const text = parts.filter((p) => p.type === "text").map((p) => p.text || "").join("");
+    return text.trim() ? text : void 0;
+  }
 };
 function getHTTPClient(client) {
   return client.http;
@@ -5286,7 +5854,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(
@@ -5294,12 +5862,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);
@@ -5440,8 +6008,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"
@@ -5462,14 +6030,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();
@@ -5512,7 +6080,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);
@@ -5768,6 +6336,23 @@ var OIDCExchangeTokenProvider = class {
 };
 
 // src/device_flow.ts
+async function pollUntil(opts) {
+  let intervalMs = Math.max(1, opts.intervalMs);
+  let attempt = 0;
+  while (true) {
+    if (opts.deadline && Date.now() >= opts.deadline.getTime()) {
+      throw opts.onTimeout?.() ?? new TransportError("polling timed out", { kind: "timeout" });
+    }
+    const result = await opts.poll(attempt);
+    if (result.done) {
+      return result.value;
+    }
+    const delay = Math.max(1, result.retryAfterMs ?? intervalMs);
+    intervalMs = delay;
+    await sleep(delay, opts.signal);
+    attempt += 1;
+  }
+}
 async function startOAuthDeviceAuthorization(req) {
   const deviceAuthorizationEndpoint = req.deviceAuthorizationEndpoint?.trim();
   if (!deviceAuthorizationEndpoint) {
@@ -5825,58 +6410,59 @@ async function pollOAuthDeviceToken(req) {
   }
   const deadline = req.deadline ?? new Date(Date.now() + 10 * 60 * 1e3);
   let intervalMs = Math.max(1, req.intervalSeconds ?? 5) * 1e3;
-  while (true) {
-    if (Date.now() >= deadline.getTime()) {
-      throw new TransportError("oauth device flow timed out", { kind: "timeout" });
-    }
-    const form = new URLSearchParams();
-    form.set("grant_type", "urn:ietf:params:oauth:grant-type:device_code");
-    form.set("device_code", deviceCode);
-    form.set("client_id", clientId);
-    const payload = await postOAuthForm(tokenEndpoint, form, {
-      fetch: req.fetch,
-      signal: req.signal,
-      allowErrorPayload: true
-    });
-    const err = String(payload.error || "").trim();
-    if (err) {
-      switch (err) {
-        case "authorization_pending":
-          await sleep(intervalMs, req.signal);
-          continue;
-        case "slow_down":
-          intervalMs += 5e3;
-          await sleep(intervalMs, req.signal);
-          continue;
-        case "expired_token":
-        case "access_denied":
-        case "invalid_grant":
-          throw new TransportError(`oauth device flow failed: ${err}`, {
-            kind: "request",
-            cause: payload
-          });
-        default:
-          throw new TransportError(`oauth device flow error: ${err}`, {
-            kind: "request",
-            cause: payload
-          });
-      }
-    }
-    const accessToken = String(payload.access_token || "").trim() || void 0;
-    const idToken = String(payload.id_token || "").trim() || void 0;
-    const refreshToken = String(payload.refresh_token || "").trim() || void 0;
-    const tokenType = String(payload.token_type || "").trim() || void 0;
-    const scope = String(payload.scope || "").trim() || void 0;
-    const expiresIn = payload.expires_in !== void 0 ? Number(payload.expires_in) : void 0;
-    const expiresAt = typeof expiresIn === "number" && Number.isFinite(expiresIn) && expiresIn > 0 ? new Date(Date.now() + expiresIn * 1e3) : void 0;
-    if (!accessToken && !idToken) {
-      throw new TransportError("oauth device flow returned an invalid token response", {
-        kind: "request",
-        cause: payload
+  return pollUntil({
+    intervalMs,
+    deadline,
+    signal: req.signal,
+    onTimeout: () => new TransportError("oauth device flow timed out", { kind: "timeout" }),
+    poll: async () => {
+      const form = new URLSearchParams();
+      form.set("grant_type", "urn:ietf:params:oauth:grant-type:device_code");
+      form.set("device_code", deviceCode);
+      form.set("client_id", clientId);
+      const payload = await postOAuthForm(tokenEndpoint, form, {
+        fetch: req.fetch,
+        signal: req.signal,
+        allowErrorPayload: true
       });
+      const err = String(payload.error || "").trim();
+      if (err) {
+        switch (err) {
+          case "authorization_pending":
+            return { done: false };
+          case "slow_down":
+            intervalMs += 5e3;
+            return { done: false, retryAfterMs: intervalMs };
+          case "expired_token":
+          case "access_denied":
+          case "invalid_grant":
+            throw new TransportError(`oauth device flow failed: ${err}`, {
+              kind: "request",
+              cause: payload
+            });
+          default:
+            throw new TransportError(`oauth device flow error: ${err}`, {
+              kind: "request",
+              cause: payload
+            });
+        }
+      }
+      const accessToken = String(payload.access_token || "").trim() || void 0;
+      const idToken = String(payload.id_token || "").trim() || void 0;
+      const refreshToken = String(payload.refresh_token || "").trim() || void 0;
+      const tokenType = String(payload.token_type || "").trim() || void 0;
+      const scope = String(payload.scope || "").trim() || void 0;
+      const expiresIn = payload.expires_in !== void 0 ? Number(payload.expires_in) : void 0;
+      const expiresAt = typeof expiresIn === "number" && Number.isFinite(expiresIn) && expiresIn > 0 ? new Date(Date.now() + expiresIn * 1e3) : void 0;
+      if (!accessToken && !idToken) {
+        throw new TransportError("oauth device flow returned an invalid token response", {
+          kind: "request",
+          cause: payload
+        });
+      }
+      return { done: true, value: { accessToken, idToken, refreshToken, tokenType, scope, expiresAt } };
     }
-    return { accessToken, idToken, refreshToken, tokenType, scope, expiresAt };
-  }
+  });
 }
 async function runOAuthDeviceFlowForIDToken(cfg) {
   const auth = await startOAuthDeviceAuthorization({
@@ -5940,13 +6526,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" }));
@@ -5954,27 +6540,154 @@ async function sleep(ms, signal) {
     signal.addEventListener("abort", onAbort);
     setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve2();
+      resolve();
     }, ms);
   });
 }
 
-// src/workflow_builder.ts
-var LLM_TEXT_OUTPUT = "/output/0/content/0/text";
-var LLM_USER_MESSAGE_TEXT = "/request/input/1/content/0/text";
-function transformJSONValue(from, pointer) {
-  return pointer ? { from, pointer } : { from };
-}
-function transformJSONObject(object) {
-  return { object };
-}
-function transformJSONMerge(merge) {
-  return { merge: merge.slice() };
-}
-function wireRequest(req) {
-  const raw = req;
-  if (raw && typeof raw === "object") {
-    if ("input" in raw) {
+// src/json_path.ts
+var LLMOutputPath = class {
+  constructor(path = "/output") {
+    this.path = path;
+  }
+  /** Select an output by index */
+  index(i) {
+    return new LLMOutputContentPath(`${this.path}/${i}`);
+  }
+  /** Shorthand for index(0).content(i) */
+  content(i) {
+    return this.index(0).content(i);
+  }
+};
+var LLMOutputContentPath = class {
+  constructor(path) {
+    this.path = path;
+  }
+  /** Select a content item by index */
+  content(i) {
+    return new LLMOutputContentItemPath(`${this.path}/content/${i}`);
+  }
+};
+var LLMOutputContentItemPath = class {
+  constructor(path) {
+    this.path = path;
+  }
+  /** Get the text field pointer */
+  text() {
+    return `${this.path}/text`;
+  }
+  /** Get the type field pointer */
+  type() {
+    return `${this.path}/type`;
+  }
+  /** Get the path as a string */
+  toString() {
+    return this.path;
+  }
+};
+var LLMInputPath = class {
+  constructor(path = "/input") {
+    this.path = path;
+  }
+  /**
+   * Select a message by index.
+   * Index 0 is typically the system message, index 1 is the first user message.
+   */
+  message(i) {
+    return new LLMInputMessagePath(`${this.path}/${i}`);
+  }
+  /** Shorthand for message(0) - the first message slot */
+  systemMessage() {
+    return this.message(0);
+  }
+  /** Shorthand for message(1) - typically the user message after system */
+  userMessage() {
+    return this.message(1);
+  }
+};
+var LLMInputMessagePath = class {
+  constructor(path) {
+    this.path = path;
+  }
+  /** Select a content item by index */
+  content(i) {
+    return new LLMInputContentItemPath(`${this.path}/content/${i}`);
+  }
+  /** Shorthand for content(0).text() */
+  text() {
+    return this.content(0).text();
+  }
+};
+var LLMInputContentItemPath = class {
+  constructor(path) {
+    this.path = path;
+  }
+  /** Get the text field pointer */
+  text() {
+    return `${this.path}/text`;
+  }
+  /** Get the type field pointer */
+  type() {
+    return `${this.path}/type`;
+  }
+  /** Get the path as a string */
+  toString() {
+    return this.path;
+  }
+};
+function LLMOutput() {
+  return new LLMOutputPath();
+}
+function LLMInput() {
+  return new LLMInputPath();
+}
+var LLMOutputText = LLMOutput().content(0).text();
+var LLMInputSystemText = LLMInput().systemMessage().text();
+var LLMInputUserText = LLMInput().userMessage().text();
+var LLMInputFirstMessageText = LLMInput().message(0).text();
+var JoinOutputPath = class {
+  constructor(path) {
+    this.path = path;
+  }
+  /** Access the output array of the node */
+  output() {
+    return new LLMOutputPath(`${this.path}/output`);
+  }
+  /**
+   * Shorthand for accessing the first text content from the node.
+   * Equivalent to: JoinOutput(nodeId).output().content(0).text()
+   */
+  text() {
+    return this.output().content(0).text();
+  }
+  /** Get the path as a string */
+  toString() {
+    return this.path;
+  }
+};
+function JoinOutput(nodeId) {
+  return new JoinOutputPath(`/${nodeId}`);
+}
+
+// src/workflow_builder.ts
+var LLM_TEXT_OUTPUT = LLMOutputText;
+var LLM_USER_MESSAGE_TEXT = LLMInputUserText;
+function transformJSONValue(from, pointer) {
+  return pointer ? { from, pointer } : { from };
+}
+function transformJSONObject(object) {
+  return { object };
+}
+function transformJSONMerge(merge) {
+  return { merge: merge.slice() };
+}
+var transformJSONValueV1 = transformJSONValue;
+var transformJSONObjectV1 = transformJSONObject;
+var transformJSONMergeV1 = transformJSONMerge;
+function wireRequest(req) {
+  const raw = req;
+  if (raw && typeof raw === "object") {
+    if ("input" in raw) {
       return req;
     }
     if ("body" in raw) {
@@ -5983,6 +6696,98 @@ function wireRequest(req) {
   }
   return asInternal(req).body;
 }
+var INPUT_POINTER_PATTERN = /^\/input\/(\d+)(?:\/content\/(\d+))?/;
+var BindingTargetError = class extends Error {
+  constructor(nodeId, bindingIndex, pointer, message) {
+    super(`node "${nodeId}" binding ${bindingIndex}: ${message}`);
+    this.name = "BindingTargetError";
+    this.nodeId = nodeId;
+    this.bindingIndex = bindingIndex;
+    this.pointer = pointer;
+  }
+};
+var MapFanoutInputError = class extends Error {
+  constructor(nodeId, message) {
+    super(`node "${nodeId}": ${message}`);
+    this.name = "MapFanoutInputError";
+    this.nodeId = nodeId;
+  }
+};
+function validateBindingTargets(nodeId, input, bindings) {
+  for (let i = 0; i < bindings.length; i++) {
+    const binding = bindings[i];
+    if (!binding.to) continue;
+    const error = validateInputPointer(binding.to, input);
+    if (error) {
+      throw new BindingTargetError(nodeId, i, binding.to, error);
+    }
+  }
+}
+function validateInputPointer(pointer, input) {
+  if (!pointer.startsWith("/input/")) {
+    return void 0;
+  }
+  const match = pointer.match(INPUT_POINTER_PATTERN);
+  if (!match) {
+    return void 0;
+  }
+  const msgIndex = parseInt(match[1], 10);
+  if (msgIndex >= input.length) {
+    return `targets ${pointer} but request only has ${input.length} messages (indices 0-${input.length - 1}); add placeholder messages or adjust binding target`;
+  }
+  if (match[2] !== void 0) {
+    const contentIndex = parseInt(match[2], 10);
+    const msg = input[msgIndex];
+    if (contentIndex >= msg.content.length) {
+      return `targets ${pointer} but message ${msgIndex} only has ${msg.content.length} content blocks (indices 0-${msg.content.length - 1})`;
+    }
+  }
+  return void 0;
+}
+function validateMapFanoutInput(nodeId, input) {
+  const subnode = input.subnode;
+  if ((subnode.type === WorkflowNodeTypesV1.LLMResponses || subnode.type === WorkflowNodeTypesV1.RouteSwitch) && subnode.input.bindings && subnode.input.bindings.length > 0) {
+    throw new MapFanoutInputError(nodeId, "map.fanout subnode bindings are not allowed");
+  }
+  if (subnode.type !== WorkflowNodeTypesV1.TransformJSON) {
+    return;
+  }
+  if (input.item_bindings && input.item_bindings.length > 0) {
+    throw new MapFanoutInputError(
+      nodeId,
+      "map.fanout transform.json subnode cannot use item_bindings"
+    );
+  }
+  const hasObject = !!subnode.input.object && Object.keys(subnode.input.object).length > 0;
+  const hasMerge = !!subnode.input.merge && subnode.input.merge.length > 0;
+  if (hasObject === hasMerge) {
+    throw new MapFanoutInputError(
+      nodeId,
+      "map.fanout transform.json must provide exactly one of object or merge"
+    );
+  }
+  if (hasObject) {
+    for (const [key, value] of Object.entries(subnode.input.object ?? {})) {
+      if (!key.trim()) continue;
+      if (String(value.from) !== "item") {
+        throw new MapFanoutInputError(
+          nodeId,
+          `map.fanout transform.json object.${key}.from must be "item"`
+        );
+      }
+    }
+  }
+  if (hasMerge) {
+    for (const [index, value] of (subnode.input.merge ?? []).entries()) {
+      if (String(value.from) !== "item") {
+        throw new MapFanoutInputError(
+          nodeId,
+          `map.fanout transform.json merge[${index}].from must be "item"`
+        );
+      }
+    }
+  }
+}
 var WorkflowBuilderV0 = class _WorkflowBuilderV0 {
   constructor(state = { nodes: [], edges: [], outputs: [] }) {
     this.state = state;
@@ -6006,8 +6811,12 @@ var WorkflowBuilderV0 = class _WorkflowBuilderV0 {
     return this.with({ nodes: [...this.state.nodes, node] });
   }
   llmResponses(id, request, options = {}) {
+    const wiredRequest = wireRequest(request);
+    if (options.bindings) {
+      validateBindingTargets(id, wiredRequest.input, options.bindings);
+    }
     const input = {
-      request: wireRequest(request),
+      request: wiredRequest,
       ...options.stream === void 0 ? {} : { stream: options.stream },
       ...options.toolExecution === void 0 ? {} : { tool_execution: { mode: options.toolExecution } },
       ...options.toolLimits === void 0 ? {} : { tool_limits: { ...options.toolLimits } },
@@ -6076,6 +6885,141 @@ var WorkflowBuilderV0 = class _WorkflowBuilderV0 {
 function workflowV0() {
   return WorkflowBuilderV0.new();
 }
+var WorkflowBuilderV1 = class _WorkflowBuilderV1 {
+  constructor(state = { nodes: [], edges: [], outputs: [] }) {
+    this.state = state;
+  }
+  static new() {
+    return new _WorkflowBuilderV1();
+  }
+  with(patch) {
+    return new _WorkflowBuilderV1({
+      ...this.state,
+      ...patch
+    });
+  }
+  name(name) {
+    return this.with({ name: name.trim() || void 0 });
+  }
+  execution(execution) {
+    return this.with({ execution });
+  }
+  node(node) {
+    return this.with({ nodes: [...this.state.nodes, node] });
+  }
+  llmResponses(id, request, options = {}) {
+    const wiredRequest = wireRequest(request);
+    if (options.bindings) {
+      validateBindingTargets(id, wiredRequest.input, options.bindings);
+    }
+    const input = {
+      request: wiredRequest,
+      ...options.stream === void 0 ? {} : { stream: options.stream },
+      ...options.toolExecution === void 0 ? {} : { tool_execution: { mode: options.toolExecution } },
+      ...options.toolLimits === void 0 ? {} : { tool_limits: { ...options.toolLimits } },
+      ...options.bindings === void 0 ? {} : { bindings: options.bindings.slice() }
+    };
+    return this.node({
+      id,
+      type: WorkflowNodeTypesV1.LLMResponses,
+      input
+    });
+  }
+  routeSwitch(id, request, options = {}) {
+    const wiredRequest = wireRequest(request);
+    if (options.bindings) {
+      validateBindingTargets(id, wiredRequest.input, options.bindings);
+    }
+    const input = {
+      request: wiredRequest,
+      ...options.stream === void 0 ? {} : { stream: options.stream },
+      ...options.toolExecution === void 0 ? {} : { tool_execution: { mode: options.toolExecution } },
+      ...options.toolLimits === void 0 ? {} : { tool_limits: { ...options.toolLimits } },
+      ...options.bindings === void 0 ? {} : { bindings: options.bindings.slice() }
+    };
+    return this.node({
+      id,
+      type: WorkflowNodeTypesV1.RouteSwitch,
+      input
+    });
+  }
+  joinAll(id) {
+    return this.node({ id, type: WorkflowNodeTypesV1.JoinAll });
+  }
+  joinAny(id, input) {
+    return this.node({
+      id,
+      type: WorkflowNodeTypesV1.JoinAny,
+      ...input ? { input } : {}
+    });
+  }
+  joinCollect(id, input) {
+    return this.node({ id, type: WorkflowNodeTypesV1.JoinCollect, input });
+  }
+  transformJSON(id, input) {
+    return this.node({ id, type: WorkflowNodeTypesV1.TransformJSON, input });
+  }
+  mapFanout(id, input) {
+    validateMapFanoutInput(id, input);
+    return this.node({ id, type: WorkflowNodeTypesV1.MapFanout, input });
+  }
+  edge(from, to, when) {
+    return this.with({
+      edges: [...this.state.edges, { from, to, ...when ? { when } : {} }]
+    });
+  }
+  output(name, from, pointer) {
+    return this.with({
+      outputs: [
+        ...this.state.outputs,
+        { name, from, ...pointer ? { pointer } : {} }
+      ]
+    });
+  }
+  build() {
+    const edges = this.state.edges.slice().sort((a, b) => {
+      const af = String(a.from);
+      const bf = String(b.from);
+      if (af < bf) return -1;
+      if (af > bf) return 1;
+      const at = String(a.to);
+      const bt = String(b.to);
+      if (at < bt) return -1;
+      if (at > bt) return 1;
+      const aw = a.when ? JSON.stringify(a.when) : "";
+      const bw = b.when ? JSON.stringify(b.when) : "";
+      if (aw < bw) return -1;
+      if (aw > bw) return 1;
+      return 0;
+    });
+    const outputs = this.state.outputs.slice().sort((a, b) => {
+      const an = String(a.name);
+      const bn = String(b.name);
+      if (an < bn) return -1;
+      if (an > bn) return 1;
+      const af = String(a.from);
+      const bf = String(b.from);
+      if (af < bf) return -1;
+      if (af > bf) return 1;
+      const ap = a.pointer ?? "";
+      const bp = b.pointer ?? "";
+      if (ap < bp) return -1;
+      if (ap > bp) return 1;
+      return 0;
+    });
+    return {
+      kind: WorkflowKinds.WorkflowV1,
+      ...this.state.name ? { name: this.state.name } : {},
+      ...this.state.execution ? { execution: this.state.execution } : {},
+      nodes: this.state.nodes.slice(),
+      ...edges.length ? { edges } : {},
+      outputs
+    };
+  }
+};
+function workflowV1() {
+  return WorkflowBuilderV1.new();
+}
 var Workflow = class _Workflow {
   constructor(name) {
     this._nodes = [];
@@ -6208,6 +7152,9 @@ var Workflow = class _Workflow {
     const pending = this._pendingNode;
     if (!pending) return;
     this._pendingNode = null;
+    if (pending.bindings.length > 0) {
+      validateBindingTargets(pending.id, pending.request.input, pending.bindings);
+    }
     const input = {
       id: pending.id,
       type: WorkflowNodeTypes.LLMResponses,
@@ -6271,6 +7218,31 @@ var LLMNodeBuilder = class {
     }
     return this;
   }
+  /**
+   * Add a binding that replaces a {{placeholder}} in the prompt text.
+   * This is useful when the prompt contains placeholder markers like {{tier_data}}.
+   * The edge from the source node is automatically inferred.
+   */
+  bindToPlaceholder(from, fromPointer, placeholder) {
+    const pending = this.workflow._getPendingNode();
+    if (pending) {
+      pending.bindings.push({
+        from,
+        ...fromPointer ? { pointer: fromPointer } : {},
+        to_placeholder: placeholder,
+        encoding: "json_string"
+      });
+    }
+    return this;
+  }
+  /**
+   * Add a binding from an LLM node's text output to a placeholder.
+   * This is the most common placeholder binding: LLM text → {{placeholder}}.
+   * The edge from the source node is automatically inferred.
+   */
+  bindTextToPlaceholder(from, placeholder) {
+    return this.bindToPlaceholder(from, LLM_TEXT_OUTPUT, placeholder);
+  }
   /**
    * Set the tool execution mode (server or client).
    */
@@ -6412,6 +7384,18 @@ var workflow_v0_schema_default = {
     },
     llmResponsesBinding: {
       additionalProperties: false,
+      oneOf: [
+        {
+          required: [
+            "to"
+          ]
+        },
+        {
+          required: [
+            "to_placeholder"
+          ]
+        }
+      ],
       properties: {
         encoding: {
           enum: [
@@ -6431,11 +7415,14 @@ var workflow_v0_schema_default = {
         to: {
           pattern: "^/.*$",
           type: "string"
+        },
+        to_placeholder: {
+          minLength: 1,
+          type: "string"
         }
       },
       required: [
-        "from",
-        "to"
+        "from"
       ],
       type: "object"
     },
@@ -6702,41 +7689,808 @@ var workflow_v0_schema_default = {
   type: "object"
 };
 
-// src/workflow_patterns.ts
-var LLM_TEXT_OUTPUT_INTERNAL = "/output/0/content/0/text";
-var LLM_USER_MESSAGE_TEXT_INTERNAL = "/request/input/1/content/0/text";
-function wireRequest2(req) {
-  const raw = req;
-  if (raw && typeof raw === "object") {
-    if ("input" in raw) {
-      return req;
-    }
-    if ("body" in raw) {
-      return raw.body ?? {};
-    }
-  }
-  return asInternal(req).body;
-}
-function sortEdges(edges) {
-  return edges.slice().sort((a, b) => {
-    const af = String(a.from);
-    const bf = String(b.from);
-    if (af < bf) return -1;
-    if (af > bf) return 1;
-    const at = String(a.to);
-    const bt = String(b.to);
-    if (at < bt) return -1;
-    if (at > bt) return 1;
-    return 0;
-  });
-}
-function sortOutputs(outputs) {
-  return outputs.slice().sort((a, b) => {
-    const an = String(a.name);
-    const bn = String(b.name);
-    if (an < bn) return -1;
-    if (an > bn) return 1;
-    const af = String(a.from);
+// src/workflow_v1.schema.json
+var workflow_v1_schema_default = {
+  $id: "https://modelrelay.ai/schemas/workflow_v1.schema.json",
+  $schema: "http://json-schema.org/draft-07/schema#",
+  additionalProperties: false,
+  definitions: {
+    condition: {
+      additionalProperties: false,
+      properties: {
+        op: {
+          enum: [
+            "equals",
+            "matches",
+            "exists"
+          ],
+          type: "string"
+        },
+        path: {
+          pattern: "^\\$.*$",
+          type: "string"
+        },
+        source: {
+          enum: [
+            "node_output",
+            "node_status"
+          ],
+          type: "string"
+        },
+        value: {}
+      },
+      required: [
+        "source",
+        "op"
+      ],
+      type: "object"
+    },
+    edge: {
+      additionalProperties: false,
+      properties: {
+        from: {
+          minLength: 1,
+          type: "string"
+        },
+        to: {
+          minLength: 1,
+          type: "string"
+        },
+        when: {
+          $ref: "#/definitions/condition"
+        }
+      },
+      required: [
+        "from",
+        "to"
+      ],
+      type: "object"
+    },
+    fragmentBindInput: {
+      additionalProperties: false,
+      oneOf: [
+        {
+          required: [
+            "from_node"
+          ]
+        },
+        {
+          required: [
+            "from_input"
+          ]
+        }
+      ],
+      properties: {
+        from_input: {
+          minLength: 1,
+          type: "string"
+        },
+        from_node: {
+          minLength: 1,
+          type: "string"
+        },
+        pointer: {
+          pattern: "^(/.*)?$",
+          type: "string"
+        }
+      },
+      type: "object"
+    },
+    fragmentDef: {
+      additionalProperties: false,
+      properties: {
+        edges: {
+          items: {
+            $ref: "#/definitions/edge"
+          },
+          type: "array"
+        },
+        inputs: {
+          items: {
+            $ref: "#/definitions/fragmentInput"
+          },
+          type: "array"
+        },
+        nodes: {
+          items: {
+            $ref: "#/definitions/node"
+          },
+          minItems: 1,
+          type: "array"
+        },
+        outputs: {
+          items: {
+            $ref: "#/definitions/fragmentOutput"
+          },
+          minItems: 1,
+          type: "array"
+        }
+      },
+      required: [
+        "outputs",
+        "nodes"
+      ],
+      type: "object"
+    },
+    fragmentInput: {
+      additionalProperties: false,
+      properties: {
+        name: {
+          minLength: 1,
+          type: "string"
+        },
+        type: {
+          type: "string"
+        }
+      },
+      required: [
+        "name"
+      ],
+      type: "object"
+    },
+    fragmentOutput: {
+      additionalProperties: false,
+      properties: {
+        from_node: {
+          minLength: 1,
+          type: "string"
+        },
+        name: {
+          minLength: 1,
+          type: "string"
+        },
+        pointer: {
+          pattern: "^(/.*)?$",
+          type: "string"
+        }
+      },
+      required: [
+        "name",
+        "from_node"
+      ],
+      type: "object"
+    },
+    llmResponsesBinding: {
+      additionalProperties: false,
+      oneOf: [
+        {
+          required: [
+            "to"
+          ]
+        },
+        {
+          required: [
+            "to_placeholder"
+          ]
+        }
+      ],
+      properties: {
+        encoding: {
+          enum: [
+            "json",
+            "json_string"
+          ],
+          type: "string"
+        },
+        from: {
+          minLength: 1,
+          type: "string"
+        },
+        pointer: {
+          pattern: "^(/.*)?$",
+          type: "string"
+        },
+        to: {
+          pattern: "^/.*$",
+          type: "string"
+        },
+        to_placeholder: {
+          minLength: 1,
+          type: "string"
+        }
+      },
+      required: [
+        "from"
+      ],
+      type: "object"
+    },
+    mapFanoutItemBinding: {
+      additionalProperties: false,
+      oneOf: [
+        {
+          required: [
+            "to"
+          ]
+        },
+        {
+          required: [
+            "to_placeholder"
+          ]
+        }
+      ],
+      properties: {
+        encoding: {
+          enum: [
+            "json",
+            "json_string"
+          ],
+          type: "string"
+        },
+        path: {
+          pattern: "^(/.*)?$",
+          type: "string"
+        },
+        to: {
+          pattern: "^/.*$",
+          type: "string"
+        },
+        to_placeholder: {
+          minLength: 1,
+          type: "string"
+        }
+      },
+      type: "object"
+    },
+    node: {
+      additionalProperties: false,
+      oneOf: [
+        {
+          allOf: [
+            {
+              properties: {
+                input: {
+                  properties: {
+                    bindings: {
+                      items: {
+                        $ref: "#/definitions/llmResponsesBinding"
+                      },
+                      type: "array"
+                    },
+                    request: {
+                      type: "object"
+                    },
+                    stream: {
+                      type: "boolean"
+                    },
+                    tool_execution: {
+                      additionalProperties: false,
+                      properties: {
+                        mode: {
+                          default: "server",
+                          enum: [
+                            "server",
+                            "client"
+                          ],
+                          type: "string"
+                        }
+                      },
+                      required: [
+                        "mode"
+                      ],
+                      type: "object"
+                    },
+                    tool_limits: {
+                      additionalProperties: false,
+                      properties: {
+                        max_llm_calls: {
+                          default: 8,
+                          maximum: 64,
+                          minimum: 1,
+                          type: "integer"
+                        },
+                        max_tool_calls_per_step: {
+                          default: 16,
+                          maximum: 64,
+                          minimum: 1,
+                          type: "integer"
+                        },
+                        wait_ttl_ms: {
+                          default: 9e5,
+                          maximum: 864e5,
+                          minimum: 1,
+                          type: "integer"
+                        }
+                      },
+                      type: "object"
+                    }
+                  },
+                  required: [
+                    "request"
+                  ],
+                  type: "object"
+                }
+              }
+            }
+          ],
+          properties: {
+            type: {
+              const: "llm.responses"
+            }
+          },
+          required: [
+            "input"
+          ]
+        },
+        {
+          allOf: [
+            {
+              properties: {
+                input: {
+                  properties: {
+                    bindings: {
+                      items: {
+                        $ref: "#/definitions/llmResponsesBinding"
+                      },
+                      type: "array"
+                    },
+                    request: {
+                      type: "object"
+                    },
+                    stream: {
+                      type: "boolean"
+                    },
+                    tool_execution: {
+                      additionalProperties: false,
+                      properties: {
+                        mode: {
+                          default: "server",
+                          enum: [
+                            "server",
+                            "client"
+                          ],
+                          type: "string"
+                        }
+                      },
+                      required: [
+                        "mode"
+                      ],
+                      type: "object"
+                    },
+                    tool_limits: {
+                      additionalProperties: false,
+                      properties: {
+                        max_llm_calls: {
+                          default: 8,
+                          maximum: 64,
+                          minimum: 1,
+                          type: "integer"
+                        },
+                        max_tool_calls_per_step: {
+                          default: 16,
+                          maximum: 64,
+                          minimum: 1,
+                          type: "integer"
+                        },
+                        wait_ttl_ms: {
+                          default: 9e5,
+                          maximum: 864e5,
+                          minimum: 1,
+                          type: "integer"
+                        }
+                      },
+                      type: "object"
+                    }
+                  },
+                  required: [
+                    "request"
+                  ],
+                  type: "object"
+                }
+              }
+            }
+          ],
+          properties: {
+            type: {
+              const: "route.switch"
+            }
+          },
+          required: [
+            "input"
+          ]
+        },
+        {
+          properties: {
+            type: {
+              const: "join.all"
+            }
+          }
+        },
+        {
+          allOf: [
+            {
+              properties: {
+                input: {
+                  additionalProperties: false,
+                  properties: {
+                    predicate: {
+                      $ref: "#/definitions/condition"
+                    }
+                  },
+                  type: "object"
+                }
+              }
+            }
+          ],
+          properties: {
+            type: {
+              const: "join.any"
+            }
+          }
+        },
+        {
+          allOf: [
+            {
+              properties: {
+                input: {
+                  additionalProperties: false,
+                  properties: {
+                    limit: {
+                      minimum: 1,
+                      type: "integer"
+                    },
+                    predicate: {
+                      $ref: "#/definitions/condition"
+                    },
+                    timeout_ms: {
+                      minimum: 1,
+                      type: "integer"
+                    }
+                  },
+                  type: "object"
+                }
+              }
+            }
+          ],
+          properties: {
+            type: {
+              const: "join.collect"
+            }
+          },
+          required: [
+            "input"
+          ]
+        },
+        {
+          allOf: [
+            {
+              properties: {
+                input: {
+                  additionalProperties: false,
+                  oneOf: [
+                    {
+                      not: {
+                        required: [
+                          "merge"
+                        ]
+                      },
+                      required: [
+                        "object"
+                      ]
+                    },
+                    {
+                      not: {
+                        required: [
+                          "object"
+                        ]
+                      },
+                      required: [
+                        "merge"
+                      ]
+                    }
+                  ],
+                  properties: {
+                    merge: {
+                      items: {
+                        $ref: "#/definitions/transformValue"
+                      },
+                      minItems: 1,
+                      type: "array"
+                    },
+                    object: {
+                      additionalProperties: {
+                        $ref: "#/definitions/transformValue"
+                      },
+                      minProperties: 1,
+                      type: "object"
+                    }
+                  },
+                  type: "object"
+                }
+              }
+            }
+          ],
+          properties: {
+            type: {
+              const: "transform.json"
+            }
+          },
+          required: [
+            "input"
+          ]
+        },
+        {
+          allOf: [
+            {
+              properties: {
+                input: {
+                  additionalProperties: false,
+                  properties: {
+                    item_bindings: {
+                      items: {
+                        $ref: "#/definitions/mapFanoutItemBinding"
+                      },
+                      type: "array"
+                    },
+                    items: {
+                      additionalProperties: false,
+                      properties: {
+                        from: {
+                          minLength: 1,
+                          type: "string"
+                        },
+                        path: {
+                          pattern: "^(/.*)?$",
+                          type: "string"
+                        },
+                        pointer: {
+                          pattern: "^(/.*)?$",
+                          type: "string"
+                        }
+                      },
+                      required: [
+                        "from"
+                      ],
+                      type: "object"
+                    },
+                    max_parallelism: {
+                      minimum: 1,
+                      type: "integer"
+                    },
+                    subnode: {
+                      additionalProperties: false,
+                      properties: {
+                        id: {
+                          minLength: 1,
+                          type: "string"
+                        },
+                        input: {},
+                        type: {
+                          enum: [
+                            "llm.responses",
+                            "route.switch",
+                            "transform.json"
+                          ],
+                          type: "string"
+                        }
+                      },
+                      required: [
+                        "id",
+                        "type"
+                      ],
+                      type: "object"
+                    }
+                  },
+                  required: [
+                    "items",
+                    "subnode"
+                  ],
+                  type: "object"
+                }
+              }
+            }
+          ],
+          properties: {
+            type: {
+              const: "map.fanout"
+            }
+          },
+          required: [
+            "input"
+          ]
+        },
+        {
+          allOf: [
+            {
+              properties: {
+                input: {
+                  additionalProperties: false,
+                  properties: {
+                    bind_inputs: {
+                      additionalProperties: {
+                        $ref: "#/definitions/fragmentBindInput"
+                      },
+                      type: "object"
+                    },
+                    ref: {
+                      minLength: 1,
+                      type: "string"
+                    }
+                  },
+                  required: [
+                    "ref"
+                  ],
+                  type: "object"
+                }
+              }
+            }
+          ],
+          properties: {
+            type: {
+              const: "fragment"
+            }
+          },
+          required: [
+            "input"
+          ]
+        }
+      ],
+      properties: {
+        id: {
+          minLength: 1,
+          type: "string"
+        },
+        input: {},
+        type: {
+          enum: [
+            "llm.responses",
+            "route.switch",
+            "join.all",
+            "join.any",
+            "join.collect",
+            "transform.json",
+            "map.fanout",
+            "fragment"
+          ],
+          type: "string"
+        }
+      },
+      required: [
+        "id",
+        "type"
+      ],
+      type: "object"
+    },
+    output: {
+      additionalProperties: false,
+      properties: {
+        from: {
+          minLength: 1,
+          type: "string"
+        },
+        name: {
+          minLength: 1,
+          type: "string"
+        },
+        output: {
+          minLength: 1,
+          type: "string"
+        },
+        pointer: {
+          pattern: "^(/.*)?$",
+          type: "string"
+        }
+      },
+      required: [
+        "name",
+        "from"
+      ],
+      type: "object"
+    },
+    transformValue: {
+      additionalProperties: false,
+      properties: {
+        from: {
+          minLength: 1,
+          type: "string"
+        },
+        pointer: {
+          pattern: "^(/.*)?$",
+          type: "string"
+        }
+      },
+      required: [
+        "from"
+      ],
+      type: "object"
+    }
+  },
+  properties: {
+    edges: {
+      items: {
+        $ref: "#/definitions/edge"
+      },
+      type: "array"
+    },
+    execution: {
+      additionalProperties: false,
+      properties: {
+        max_parallelism: {
+          minimum: 1,
+          type: "integer"
+        },
+        node_timeout_ms: {
+          minimum: 1,
+          type: "integer"
+        },
+        run_timeout_ms: {
+          minimum: 1,
+          type: "integer"
+        }
+      },
+      type: "object"
+    },
+    fragments: {
+      additionalProperties: {
+        $ref: "#/definitions/fragmentDef"
+      },
+      type: "object"
+    },
+    kind: {
+      const: "workflow.v1",
+      type: "string"
+    },
+    name: {
+      type: "string"
+    },
+    nodes: {
+      items: {
+        $ref: "#/definitions/node"
+      },
+      minItems: 1,
+      type: "array"
+    },
+    outputs: {
+      items: {
+        $ref: "#/definitions/output"
+      },
+      minItems: 1,
+      type: "array"
+    }
+  },
+  required: [
+    "kind",
+    "nodes",
+    "outputs"
+  ],
+  title: "ModelRelay workflow.v1",
+  type: "object"
+};
+
+// src/workflow_patterns.ts
+var LLM_TEXT_OUTPUT_INTERNAL = "/output/0/content/0/text";
+var LLM_USER_MESSAGE_TEXT_INTERNAL = "/input/1/content/0/text";
+function wireRequest2(req) {
+  const raw = req;
+  if (raw && typeof raw === "object") {
+    if ("input" in raw) {
+      return req;
+    }
+    if ("body" in raw) {
+      return raw.body ?? {};
+    }
+  }
+  return asInternal(req).body;
+}
+function sortEdges(edges) {
+  return edges.slice().sort((a, b) => {
+    const af = String(a.from);
+    const bf = String(b.from);
+    if (af < bf) return -1;
+    if (af > bf) return 1;
+    const at = String(a.to);
+    const bt = String(b.to);
+    if (at < bt) return -1;
+    if (at > bt) return 1;
+    return 0;
+  });
+}
+function sortOutputs(outputs) {
+  return outputs.slice().sort((a, b) => {
+    const an = String(a.name);
+    const bn = String(b.name);
+    if (an < bn) return -1;
+    if (an > bn) return 1;
+    const af = String(a.from);
     const bf = String(b.from);
     if (af < bf) return -1;
     if (af > bf) return 1;
@@ -7042,681 +8796,149 @@ var MapReduceBuilder = class _MapReduceBuilder {
   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 } : {}
-        }
-      };
-      nodes.push(input);
-      edges.push({ from: mapperId, to: joinId });
-    }
-    nodes.push({ id: joinId, type: WorkflowNodeTypes.JoinAll });
-    const reducerInput = {
-      id: this.state.reducer.id,
-      type: WorkflowNodeTypes.LLMResponses,
-      input: {
-        request: this.state.reducer.request,
-        ...this.state.reducer.stream ? { stream: true } : {},
-        bindings: [
-          {
-            from: joinId,
-            // Empty pointer = full join output
-            to: LLM_USER_MESSAGE_TEXT_INTERNAL,
-            encoding: "json_string"
-          }
-        ]
-      }
-    };
-    nodes.push(reducerInput);
-    edges.push({ from: joinId, to: this.state.reducer.id });
-    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 MapReduce(name, items = []) {
-  return MapReduceBuilder.create(name, items);
-}
-
-// src/tools_local_fs.ts
-var import_fs = require("fs");
-var path = __toESM(require("path"), 1);
-var import_child_process = require("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
-    };
-  }
-  /**
-   * 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"]
-          }
-        }
-      }
-    ];
-  }
-  /**
-   * Registers handlers into an existing ToolRegistry.
-   * @param registry - The registry to register into
-   * @returns The registry for chaining
-   */
-  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;
-  }
-  /**
-   * Creates a new ToolRegistry with fs.* tools pre-registered.
-   */
-  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 import_fs.promises.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 import_fs.promises.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 import_fs.promises.realpath(this.rootAbs);
-    } catch {
-      rootReal = this.rootAbs;
-    }
-    const stat = await import_fs.promises.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;
-    });
-    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
-   */
-  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 import_fs.promises.realpath(this.rootAbs);
-    } catch {
-      rootReal = this.rootAbs;
-    }
-    let resolved;
-    try {
-      resolved = await import_fs.promises.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;
-  }
-  // ========================================================================
-  // Ripgrep Search
-  // ========================================================================
-  async detectRipgrep() {
-    if (this.rgChecked) {
-      return this.rgPath;
-    }
-    this.rgChecked = true;
-    return new Promise((resolve2) => {
-      const proc = (0, import_child_process.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);
-        }
-      });
-    });
-  }
-  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}/**`);
-      }
-      args.push(query, dirAbs);
-      const proc = (0, import_child_process.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"));
+        ...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 import_fs.promises.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 import_fs.promises.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 import_fs.promises.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
@@ -8444,23 +9666,259 @@ var generated_exports = {};
 // src/workflow/index.ts
 var workflow_exports = {};
 __export(workflow_exports, {
+  BindingBuilder: () => BindingBuilder,
   BindingEncodings: () => BindingEncodings,
+  FanoutReduceV1: () => FanoutReduceV1,
   KindV0: () => KindV0,
-  LLM_TEXT_OUTPUT: () => LLM_TEXT_OUTPUT2,
-  LLM_USER_MESSAGE_TEXT: () => LLM_USER_MESSAGE_TEXT2,
+  KindV1: () => KindV1,
+  LLM_TEXT_OUTPUT: () => LLM_TEXT_OUTPUT,
+  LLM_USER_MESSAGE_TEXT: () => LLM_USER_MESSAGE_TEXT,
   NodeTypes: () => NodeTypes,
+  NodeTypesV1: () => NodeTypesV1,
+  RouterV1: () => RouterV1,
   ToolExecutionModes: () => ToolExecutionModes,
+  bindFrom: () => bindFrom,
+  bindToPlaceholder: () => bindToPlaceholder,
+  bindToPointer: () => bindToPointer,
   parseNodeId: () => parseNodeId,
   parseOutputName: () => parseOutputName,
   parsePlanHash: () => parsePlanHash,
-  parseRunId: () => parseRunId
+  parseRunId: () => parseRunId,
+  whenOutputEquals: () => whenOutputEquals,
+  whenOutputExists: () => whenOutputExists,
+  whenOutputMatches: () => whenOutputMatches,
+  whenStatusEquals: () => whenStatusEquals,
+  whenStatusExists: () => whenStatusExists,
+  whenStatusMatches: () => whenStatusMatches
 });
+
+// src/workflow/helpers_v1.ts
+function whenOutputEquals(path, value) {
+  return { source: "node_output", op: "equals", path, value };
+}
+function whenOutputMatches(path, pattern) {
+  return { source: "node_output", op: "matches", path, value: pattern };
+}
+function whenOutputExists(path) {
+  return { source: "node_output", op: "exists", path };
+}
+function whenStatusEquals(path, value) {
+  return { source: "node_status", op: "equals", path, value };
+}
+function whenStatusMatches(path, pattern) {
+  return { source: "node_status", op: "matches", path, value: pattern };
+}
+function whenStatusExists(path) {
+  return { source: "node_status", op: "exists", path };
+}
+function bindToPlaceholder(from, placeholder, opts) {
+  return {
+    from,
+    ...opts?.pointer ? { pointer: opts.pointer } : {},
+    to_placeholder: placeholder,
+    encoding: opts?.encoding ?? "json_string"
+  };
+}
+function bindToPointer(from, to, opts) {
+  return {
+    from,
+    ...opts?.pointer ? { pointer: opts.pointer } : {},
+    to,
+    encoding: opts?.encoding ?? "json_string"
+  };
+}
+function bindFrom(from) {
+  return new BindingBuilder(from);
+}
+var BindingBuilder = class {
+  constructor(from) {
+    this._encoding = "json_string";
+    this._from = from;
+  }
+  /**
+   * Set the source pointer to extract from the node's output.
+   */
+  pointer(ptr) {
+    this._pointer = ptr;
+    return this;
+  }
+  /**
+   * Set the destination JSON pointer in the request.
+   */
+  to(ptr) {
+    this._to = ptr;
+    this._toPlaceholder = void 0;
+    return this;
+  }
+  /**
+   * Set the destination placeholder name.
+   */
+  toPlaceholder(name) {
+    this._toPlaceholder = name;
+    this._to = void 0;
+    return this;
+  }
+  /**
+   * Set the encoding for the binding value.
+   */
+  encoding(enc) {
+    this._encoding = enc;
+    return this;
+  }
+  /**
+   * Build the binding object.
+   */
+  build() {
+    const binding = {
+      from: this._from,
+      encoding: this._encoding
+    };
+    if (this._pointer) binding.pointer = this._pointer;
+    if (this._to) binding.to = this._to;
+    if (this._toPlaceholder) binding.to_placeholder = this._toPlaceholder;
+    return binding;
+  }
+};
+
+// src/workflow/patterns_v1.ts
+function wireRequest3(req) {
+  const raw = req;
+  if (raw && typeof raw === "object") {
+    if ("input" in raw) {
+      return req;
+    }
+    if ("body" in raw) {
+      return raw.body ?? {};
+    }
+  }
+  return asInternal(req).body;
+}
+var RouterV1 = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Build the workflow specification.
+   */
+  build() {
+    const {
+      name,
+      classifier,
+      classifierId = "router",
+      routePath = "$.route",
+      routes,
+      aggregator,
+      outputName = "final"
+    } = this.config;
+    let builder = new WorkflowBuilderV1();
+    if (name) {
+      builder = builder.name(name);
+    }
+    builder = builder.routeSwitch(classifierId, classifier);
+    const joinId = "__router_join";
+    builder = builder.joinAny(joinId);
+    for (let i = 0; i < routes.length; i++) {
+      const route = routes[i];
+      const handlerId = route.id ?? `handler_${i}`;
+      builder = builder.llmResponses(handlerId, route.handler, {
+        bindings: route.bindings
+      });
+      builder = builder.edge(classifierId, handlerId, whenOutputEquals(routePath, route.value));
+      builder = builder.edge(handlerId, joinId);
+    }
+    if (aggregator) {
+      const aggId = aggregator.id ?? "aggregate";
+      const placeholder = aggregator.placeholder ?? "route_output";
+      builder = builder.llmResponses(aggId, aggregator.request, {
+        bindings: [bindToPlaceholder(joinId, placeholder)]
+      });
+      builder = builder.edge(joinId, aggId);
+      builder = builder.output(outputName, aggId);
+    } else {
+      builder = builder.output(outputName, joinId);
+    }
+    return builder.build();
+  }
+};
+var FanoutReduceV1 = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Build the workflow specification.
+   */
+  build() {
+    const {
+      name,
+      generator,
+      generatorId = "generator",
+      itemsPath = "/items",
+      mapper,
+      mapperPlaceholder = "item",
+      maxParallelism = 4,
+      reducer,
+      reducerId = "reducer",
+      reducerBinding,
+      outputName = "final"
+    } = this.config;
+    let builder = new WorkflowBuilderV1();
+    if (name) {
+      builder = builder.name(name);
+    }
+    builder = builder.llmResponses(generatorId, generator);
+    const fanoutId = "__fanout";
+    const itemBindings = [
+      {
+        path: "$",
+        to_placeholder: mapperPlaceholder,
+        encoding: "json_string"
+      }
+    ];
+    const mapperRequest = wireRequest3(mapper);
+    builder = builder.mapFanout(fanoutId, {
+      items: { from: generatorId, path: itemsPath },
+      item_bindings: itemBindings,
+      subnode: {
+        id: "__mapper",
+        type: "llm.responses",
+        input: { request: mapperRequest }
+      },
+      max_parallelism: maxParallelism
+    });
+    builder = builder.edge(generatorId, fanoutId);
+    const pointer = reducerBinding?.pointer ?? "/results";
+    const binding = reducerBinding?.placeholder ? bindToPlaceholder(fanoutId, reducerBinding.placeholder, { pointer }) : {
+      from: fanoutId,
+      pointer,
+      to: reducerBinding?.to ?? "/input/0/content/0/text",
+      encoding: "json_string"
+    };
+    builder = builder.llmResponses(reducerId, reducer, {
+      bindings: [binding]
+    });
+    builder = builder.edge(fanoutId, reducerId);
+    builder = builder.output(outputName, reducerId);
+    return builder.build();
+  }
+};
+
+// src/workflow/index.ts
 var KindV0 = WorkflowKinds.WorkflowV0;
+var KindV1 = WorkflowKinds.WorkflowV1;
 var NodeTypes = {
   LLMResponses: WorkflowNodeTypes.LLMResponses,
   JoinAll: WorkflowNodeTypes.JoinAll,
   TransformJSON: WorkflowNodeTypes.TransformJSON
 };
+var NodeTypesV1 = {
+  LLMResponses: WorkflowNodeTypesV1.LLMResponses,
+  RouteSwitch: WorkflowNodeTypesV1.RouteSwitch,
+  JoinAll: WorkflowNodeTypesV1.JoinAll,
+  JoinAny: WorkflowNodeTypesV1.JoinAny,
+  JoinCollect: WorkflowNodeTypesV1.JoinCollect,
+  TransformJSON: WorkflowNodeTypesV1.TransformJSON,
+  MapFanout: WorkflowNodeTypesV1.MapFanout
+};
 var BindingEncodings = {
   JSON: "json",
   JSONString: "json_string"
@@ -8469,8 +9927,6 @@ var ToolExecutionModes = {
   Server: "server",
   Client: "client"
 };
-var LLM_TEXT_OUTPUT2 = "/output/0/content/0/text";
-var LLM_USER_MESSAGE_TEXT2 = "/request/input/1/content/0/text";
 
 // src/index.ts
 var ModelRelay = class _ModelRelay {
@@ -8492,7 +9948,7 @@ var ModelRelay = class _ModelRelay {
     const accessToken = "token" in cfg ? cfg.token : void 0;
     const tokenProvider = "tokenProvider" in cfg ? cfg.tokenProvider : void 0;
     this.baseUrl = resolveBaseUrl(cfg.baseUrl);
-    const http = new HTTPClient({
+    this.http = new HTTPClient({
       baseUrl: this.baseUrl,
       apiKey,
       accessToken,
@@ -8505,30 +9961,30 @@ var ModelRelay = class _ModelRelay {
       metrics: cfg.metrics,
       trace: cfg.trace
     });
-    const auth = new AuthClient(http, {
+    const auth = new AuthClient(this.http, {
       apiKey,
       accessToken,
       customer: cfg.customer,
       tokenProvider
     });
     this.auth = auth;
-    this.responses = new ResponsesClient(http, auth, {
+    this.responses = new ResponsesClient(this.http, auth, {
       metrics: cfg.metrics,
       trace: cfg.trace
     });
-    this.runs = new RunsClient(http, auth, {
+    this.runs = new RunsClient(this.http, auth, {
       metrics: cfg.metrics,
       trace: cfg.trace
     });
-    this.workflows = new WorkflowsClient(http, auth, {
+    this.workflows = new WorkflowsClient(this.http, auth, {
       metrics: cfg.metrics,
       trace: cfg.trace
     });
-    this.images = new ImagesClient(http, auth);
-    this.customers = new CustomersClient(http, { apiKey, accessToken, tokenProvider });
-    this.tiers = new TiersClient(http, { apiKey });
-    this.models = new ModelsClient(http);
-    this.sessions = new SessionsClient(this, http, auth);
+    this.images = new ImagesClient(this.http, auth);
+    this.customers = new CustomersClient(this.http, { apiKey, accessToken, tokenProvider });
+    this.tiers = new TiersClient(this.http, { apiKey });
+    this.models = new ModelsClient(this.http);
+    this.sessions = new SessionsClient(this, this.http, auth);
   }
   forCustomer(customerId) {
     return new CustomerScopedModelRelay(this.responses, customerId, this.baseUrl);
@@ -8543,6 +9999,7 @@ function resolveBaseUrl(override) {
   APIError,
   AuthClient,
   BillingProviders,
+  BindingTargetError,
   BrowserDefaults,
   BrowserToolNames,
   BrowserToolPack,
@@ -8557,20 +10014,31 @@ function resolveBaseUrl(override) {
   DEFAULT_BASE_URL,
   DEFAULT_CLIENT_HEADER,
   DEFAULT_CONNECT_TIMEOUT_MS,
-  DEFAULT_IGNORE_DIRS,
   DEFAULT_REQUEST_TIMEOUT_MS,
   ErrorCodes,
-  FSDefaults,
-  FSToolNames,
   FrontendTokenProvider,
   ImagesClient,
   InputItemTypes,
+  JoinOutput,
+  JoinOutputPath,
+  LLMInput,
+  LLMInputContentItemPath,
+  LLMInputFirstMessageText,
+  LLMInputMessagePath,
+  LLMInputPath,
+  LLMInputSystemText,
+  LLMInputUserText,
   LLMNodeBuilder,
+  LLMOutput,
+  LLMOutputContentItemPath,
+  LLMOutputContentPath,
+  LLMOutputPath,
+  LLMOutputText,
   LLMStep,
   LLM_TEXT_OUTPUT,
   LLM_USER_MESSAGE_TEXT,
-  LocalFSToolPack,
   LocalSession,
+  MapFanoutInputError,
   MapItem,
   MapReduce,
   MapReduceBuilder,
@@ -8609,9 +10077,10 @@ function resolveBaseUrl(override) {
   TransformJSONNodeBuilder,
   TransportError,
   WORKFLOWS_COMPILE_PATH,
-  WebToolModes,
+  WebToolIntents,
   Workflow,
   WorkflowBuilderV0,
+  WorkflowBuilderV1,
   WorkflowKinds,
   WorkflowNodeTypes,
   WorkflowValidationError,
@@ -8621,6 +10090,8 @@ function resolveBaseUrl(override) {
   asSessionId,
   asTierCode,
   assistantMessageWithToolCalls,
+  buildDelayedNDJSONResponse,
+  buildNDJSONResponse,
   createAccessTokenAuth,
   createApiKeyAuth,
   createAssistantMessage,
@@ -8629,10 +10100,9 @@ function resolveBaseUrl(override) {
   createFunctionCall,
   createFunctionTool,
   createFunctionToolFromSchema,
-  createLocalFSToolPack,
-  createLocalFSTools,
   createLocalSession,
   createMemorySessionStore,
+  createMockFetchQueue,
   createRetryMessages,
   createSystemMessage,
   createToolCall,
@@ -8674,6 +10144,7 @@ function resolveBaseUrl(override) {
   parseToolArgs,
   parseToolArgsRaw,
   pollOAuthDeviceToken,
+  pollUntil,
   respondToToolCall,
   runOAuthDeviceFlowForIDToken,
   startOAuthDeviceAuthorization,
@@ -8683,12 +10154,17 @@ function resolveBaseUrl(override) {
   toolChoiceRequired,
   toolResultMessage,
   transformJSONMerge,
+  transformJSONMergeV1,
   transformJSONObject,
+  transformJSONObjectV1,
   transformJSONValue,
+  transformJSONValueV1,
   tryParseToolArgs,
   validateWithZod,
   workflow,
   workflowV0,
   workflowV0Schema,
+  workflowV1,
+  workflowV1Schema,
   zodToJsonSchema
 });