@modelrelay/sdk 1.10.3 → 1.25.0

package/dist/index.d.ts

@@ -563,7 +563,7 @@ interface RetryMetadata {
     lastStatus?: number;
     lastError?: string;
 }
-type TransportErrorKind = "timeout" | "connect" | "request" | "other";
+type TransportErrorKind = "timeout" | "connect" | "request" | "empty_response" | "other";
 interface RequestContext {
     method: string;
     path: string;
@@ -1714,6 +1714,106 @@ declare class ResponsesClient {
      * This is a thin wrapper around `ResponseBuilder` and `extractAssistantText`.
      */
     text(model: ModelId, system: string, user: string, options?: ResponsesRequestOptions): Promise<string>;
+    /**
+     * 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,
+     *   }),
+     * ]);
+     * ```
+     */
+    object<T>(args: {
+        /** The model to use for generation. */
+        model: ModelId;
+        /** Zod schema defining the expected output structure. */
+        schema: ZodLikeSchema;
+        /** The user prompt/input to send to the model. */
+        prompt: string;
+        /** Optional system prompt to set context for the model. */
+        system?: string;
+        /** Maximum retry attempts on validation failure (default: 0). */
+        maxRetries?: number;
+        /** Handler for customizing retry messages. */
+        retryHandler?: RetryHandler;
+        /** Override the schema name in the JSON schema (defaults to "response"). */
+        schemaName?: string;
+        /** Customer ID for billing attribution. */
+        customerId?: string;
+        /** Request options (timeout, headers, etc). */
+        options?: ResponsesRequestOptions;
+    }): Promise<T>;
+    /**
+     * 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
+     * ```
+     */
+    objectWithMetadata<T>(args: {
+        /** The model to use for generation. */
+        model: ModelId;
+        /** Zod schema defining the expected output structure. */
+        schema: ZodLikeSchema;
+        /** The user prompt/input to send to the model. */
+        prompt: string;
+        /** Optional system prompt to set context for the model. */
+        system?: string;
+        /** Maximum retry attempts on validation failure (default: 0). */
+        maxRetries?: number;
+        /** Handler for customizing retry messages. */
+        retryHandler?: RetryHandler;
+        /** Override the schema name in the JSON schema (defaults to "response"). */
+        schemaName?: string;
+        /** Customer ID for billing attribution. */
+        customerId?: string;
+        /** Request options (timeout, headers, etc). */
+        options?: ResponsesRequestOptions;
+    }): Promise<StructuredResult<T>>;
     /**
      * Convenience helper for customer-attributed requests where the backend selects the model.
      *
@@ -1766,38 +1866,50 @@ declare class ResponsesClient {
 }
 
 declare const runIdBrand: unique symbol;
-type RunId = string & {
+type RunId$1 = string & {
     readonly [runIdBrand]: true;
 };
 declare const nodeIdBrand: unique symbol;
-type NodeId = string & {
+type NodeId$1 = string & {
     readonly [nodeIdBrand]: true;
 };
 declare const planHashBrand: unique symbol;
-type PlanHash = string & {
+type PlanHash$1 = string & {
     readonly [planHashBrand]: true;
 };
 declare const outputNameBrand: unique symbol;
-type OutputName = string & {
+type OutputName$1 = string & {
     readonly [outputNameBrand]: true;
 };
-declare function parseRunId(raw: string): RunId;
-declare function parseNodeId(raw: string): NodeId;
-declare function parsePlanHash(raw: string): PlanHash;
-declare function parseOutputName(raw: string): OutputName;
+declare function parseRunId(raw: string): RunId$1;
+declare function parseNodeId(raw: string): NodeId$1;
+declare function parsePlanHash(raw: string): PlanHash$1;
+declare function parseOutputName(raw: string): OutputName$1;
 
 declare const WorkflowKinds: {
     readonly WorkflowV0: "workflow.v0";
+    readonly WorkflowV1: "workflow.v1";
 };
-type WorkflowKind = (typeof WorkflowKinds)[keyof typeof WorkflowKinds];
+type WorkflowKindV0 = (typeof WorkflowKinds)["WorkflowV0"];
+type WorkflowKindV1 = (typeof WorkflowKinds)["WorkflowV1"];
+type WorkflowKind = WorkflowKindV0 | WorkflowKindV1;
 declare const WorkflowNodeTypes: {
     readonly LLMResponses: "llm.responses";
     readonly JoinAll: "join.all";
     readonly TransformJSON: "transform.json";
 };
 type WorkflowNodeType = (typeof WorkflowNodeTypes)[keyof typeof WorkflowNodeTypes];
+declare const WorkflowNodeTypesV1: {
+    readonly LLMResponses: "llm.responses";
+    readonly RouteSwitch: "route.switch";
+    readonly JoinAll: "join.all";
+    readonly JoinAny: "join.any";
+    readonly JoinCollect: "join.collect";
+    readonly TransformJSON: "transform.json";
+    readonly MapFanout: "map.fanout";
+};
 type WorkflowSpecV0 = {
-    kind: WorkflowKind;
+    kind: WorkflowKindV0;
     name?: string;
     execution?: {
         max_parallelism?: number;
@@ -1809,200 +1921,329 @@ type WorkflowSpecV0 = {
     outputs: ReadonlyArray<WorkflowOutputRefV0>;
 };
 type WorkflowNodeV0 = {
-    id: NodeId;
+    id: NodeId$1;
     type: typeof WorkflowNodeTypes.LLMResponses;
     input: {
         request: WireResponsesRequest;
         stream?: boolean;
-        tool_execution?: ToolExecutionV0;
+        tool_execution?: ToolExecutionV0$1;
         tool_limits?: LLMResponsesToolLimitsV0;
         bindings?: ReadonlyArray<LLMResponsesBindingV0>;
     };
 } | {
-    id: NodeId;
+    id: NodeId$1;
     type: typeof WorkflowNodeTypes.JoinAll;
     input?: Record<string, unknown>;
 } | {
-    id: NodeId;
+    id: NodeId$1;
     type: typeof WorkflowNodeTypes.TransformJSON;
     input: {
         object?: Record<string, {
-            from: NodeId;
+            from: NodeId$1;
             pointer?: string;
         }>;
         merge?: Array<{
-            from: NodeId;
+            from: NodeId$1;
             pointer?: string;
         }>;
     };
 };
 type WorkflowEdgeV0 = {
-    from: NodeId;
-    to: NodeId;
+    from: NodeId$1;
+    to: NodeId$1;
 };
 type WorkflowOutputRefV0 = {
-    name: OutputName;
-    from: NodeId;
+    name: OutputName$1;
+    from: NodeId$1;
     pointer?: string;
 };
 type LLMResponsesBindingEncodingV0 = "json" | "json_string";
 type LLMResponsesBindingV0 = {
-    from: NodeId;
+    from: NodeId$1;
     pointer?: string;
-    to: string;
+    to?: string;
+    to_placeholder?: string;
     encoding?: LLMResponsesBindingEncodingV0;
 };
-type ToolExecutionModeV0 = "server" | "client";
-type ToolExecutionV0 = {
-    mode: ToolExecutionModeV0;
+type ToolExecutionModeV0$1 = "server" | "client";
+type ToolExecutionV0$1 = {
+    mode: ToolExecutionModeV0$1;
 };
 type LLMResponsesToolLimitsV0 = {
     max_llm_calls?: number;
     max_tool_calls_per_step?: number;
     wait_ttl_ms?: number;
 };
+type ConditionSourceV1$1 = "node_output" | "node_status";
+type ConditionOpV1$1 = "equals" | "matches" | "exists";
+type ConditionV1$1 = {
+    source: ConditionSourceV1$1;
+    op: ConditionOpV1$1;
+    path: string;
+    value?: unknown;
+};
+type WorkflowEdgeV1 = {
+    from: NodeId$1;
+    to: NodeId$1;
+    when?: ConditionV1$1;
+};
+type WorkflowOutputRefV1 = {
+    name: OutputName$1;
+    from: NodeId$1;
+    pointer?: string;
+};
+type WorkflowSpecV1 = {
+    kind: WorkflowKindV1;
+    name?: string;
+    execution?: {
+        max_parallelism?: number;
+        node_timeout_ms?: number;
+        run_timeout_ms?: number;
+    };
+    nodes: ReadonlyArray<WorkflowNodeV1>;
+    edges?: ReadonlyArray<WorkflowEdgeV1>;
+    outputs: ReadonlyArray<WorkflowOutputRefV1>;
+};
+type ToolExecutionModeV1$1 = "server" | "client";
+type ToolExecutionV1$1 = {
+    mode: ToolExecutionModeV1$1;
+};
+type LLMResponsesToolLimitsV1 = {
+    max_llm_calls?: number;
+    max_tool_calls_per_step?: number;
+    wait_ttl_ms?: number;
+};
+type LLMResponsesBindingEncodingV1 = "json" | "json_string";
+type LLMResponsesBindingV1 = {
+    from: NodeId$1;
+    pointer?: string;
+    to?: string;
+    to_placeholder?: string;
+    encoding?: LLMResponsesBindingEncodingV1;
+};
+type LLMResponsesNodeInputV1 = {
+    request: WireResponsesRequest;
+    stream?: boolean;
+    tool_execution?: ToolExecutionV1$1;
+    tool_limits?: LLMResponsesToolLimitsV1;
+    bindings?: ReadonlyArray<LLMResponsesBindingV1>;
+};
+type TransformJSONValueV1$1 = {
+    from: NodeId$1;
+    pointer?: string;
+};
+type TransformJSONNodeInputV1 = {
+    object?: Record<string, TransformJSONValueV1$1>;
+    merge?: Array<TransformJSONValueV1$1>;
+};
+type JoinAnyNodeInputV1 = {
+    predicate?: ConditionV1$1;
+};
+type JoinCollectNodeInputV1 = {
+    predicate?: ConditionV1$1;
+    limit?: number;
+    timeout_ms?: number;
+};
+type MapFanoutItemsV1 = {
+    from: NodeId$1;
+    path?: string;
+};
+type MapFanoutItemBindingV1 = {
+    path?: string;
+    to?: string;
+    to_placeholder?: string;
+    encoding?: LLMResponsesBindingEncodingV1;
+};
+type MapFanoutSubNodeV1 = {
+    id: NodeId$1;
+    type: typeof WorkflowNodeTypesV1.LLMResponses;
+    input: LLMResponsesNodeInputV1;
+} | {
+    id: NodeId$1;
+    type: typeof WorkflowNodeTypesV1.RouteSwitch;
+    input: LLMResponsesNodeInputV1;
+} | {
+    id: NodeId$1;
+    type: typeof WorkflowNodeTypesV1.TransformJSON;
+    input: TransformJSONNodeInputV1;
+};
+type MapFanoutNodeInputV1 = {
+    items: MapFanoutItemsV1;
+    item_bindings?: ReadonlyArray<MapFanoutItemBindingV1>;
+    subnode: MapFanoutSubNodeV1;
+    max_parallelism?: number;
+};
+type WorkflowNodeV1 = {
+    id: NodeId$1;
+    type: typeof WorkflowNodeTypesV1.LLMResponses;
+    input: LLMResponsesNodeInputV1;
+} | {
+    id: NodeId$1;
+    type: typeof WorkflowNodeTypesV1.RouteSwitch;
+    input: LLMResponsesNodeInputV1;
+} | {
+    id: NodeId$1;
+    type: typeof WorkflowNodeTypesV1.JoinAll;
+    input?: Record<string, unknown>;
+} | {
+    id: NodeId$1;
+    type: typeof WorkflowNodeTypesV1.JoinAny;
+    input?: JoinAnyNodeInputV1;
+} | {
+    id: NodeId$1;
+    type: typeof WorkflowNodeTypesV1.JoinCollect;
+    input: JoinCollectNodeInputV1;
+} | {
+    id: NodeId$1;
+    type: typeof WorkflowNodeTypesV1.TransformJSON;
+    input: TransformJSONNodeInputV1;
+} | {
+    id: NodeId$1;
+    type: typeof WorkflowNodeTypesV1.MapFanout;
+    input: MapFanoutNodeInputV1;
+};
 type RunStatusV0 = "running" | "waiting" | "succeeded" | "failed" | "canceled";
-type PayloadInfoV0 = {
+type PayloadInfoV0$1 = {
     bytes: number;
     sha256: string;
     included: boolean;
 };
 type RunEventTypeV0 = "run_compiled" | "run_started" | "run_completed" | "run_failed" | "run_canceled" | "node_llm_call" | "node_tool_call" | "node_tool_result" | "node_waiting" | "node_started" | "node_succeeded" | "node_failed" | "node_output_delta" | "node_output";
-type NodeErrorV0 = {
+type NodeErrorV0$1 = {
     code?: string;
     message: string;
 };
 /**
  * Stream event kind from an LLM provider.
  */
-type StreamEventKind = string;
-type NodeOutputDeltaV0 = {
-    kind: StreamEventKind;
+type StreamEventKind$1 = string;
+type NodeOutputDeltaV0$1 = {
+    kind: StreamEventKind$1;
     text_delta?: string;
     response_id?: string;
     model?: string;
 };
-type TokenUsageV0 = {
+type TokenUsageV0$1 = {
     input_tokens?: number;
     output_tokens?: number;
     total_tokens?: number;
 };
-type NodeLLMCallV0 = {
+type NodeLLMCallV0$1 = {
     step: number;
     request_id: string;
     provider?: string;
     model?: string;
     response_id?: string;
     stop_reason?: string;
-    usage?: TokenUsageV0;
+    usage?: TokenUsageV0$1;
 };
-type FunctionToolCallV0 = {
+type FunctionToolCallV0$1 = {
     id: string;
     name: string;
     arguments: string;
 };
-type NodeToolCallV0 = {
+type NodeToolCallV0$1 = {
     step: number;
     request_id: string;
-    tool_call: FunctionToolCallV0;
+    tool_call: FunctionToolCallV0$1;
 };
-type NodeToolResultV0 = {
+type NodeToolResultV0$1 = {
     step: number;
     request_id: string;
     tool_call_id: string;
     name: string;
     output: string;
 };
-type PendingToolCallV0 = {
+type PendingToolCallV0$1 = {
     tool_call_id: string;
     name: string;
     arguments: string;
 };
-type NodeWaitingV0 = {
+type NodeWaitingV0$1 = {
     step: number;
     request_id: string;
-    pending_tool_calls: PendingToolCallV0[];
+    pending_tool_calls: PendingToolCallV0$1[];
     reason: string;
 };
 type RunEventBaseV0 = {
     envelope_version: "v0";
-    run_id: RunId;
+    run_id: RunId$1;
     seq: number;
     ts: string;
 };
 type RunEventRunCompiledV0 = RunEventBaseV0 & {
     type: "run_compiled";
-    plan_hash: PlanHash;
+    plan_hash: PlanHash$1;
 };
 type RunEventRunStartedV0 = RunEventBaseV0 & {
     type: "run_started";
-    plan_hash: PlanHash;
+    plan_hash: PlanHash$1;
 };
 type RunEventRunCompletedV0 = RunEventBaseV0 & {
     type: "run_completed";
-    plan_hash: PlanHash;
+    plan_hash: PlanHash$1;
     outputs_artifact_key: string;
-    outputs_info: PayloadInfoV0;
+    outputs_info: PayloadInfoV0$1;
 };
 type RunEventRunFailedV0 = RunEventBaseV0 & {
     type: "run_failed";
-    plan_hash: PlanHash;
-    error: NodeErrorV0;
+    plan_hash: PlanHash$1;
+    error: NodeErrorV0$1;
 };
 type RunEventRunCanceledV0 = RunEventBaseV0 & {
     type: "run_canceled";
-    plan_hash: PlanHash;
-    error: NodeErrorV0;
+    plan_hash: PlanHash$1;
+    error: NodeErrorV0$1;
 };
 type RunEventNodeStartedV0 = RunEventBaseV0 & {
     type: "node_started";
-    node_id: NodeId;
+    node_id: NodeId$1;
 };
 type RunEventNodeSucceededV0 = RunEventBaseV0 & {
     type: "node_succeeded";
-    node_id: NodeId;
+    node_id: NodeId$1;
 };
 type RunEventNodeFailedV0 = RunEventBaseV0 & {
     type: "node_failed";
-    node_id: NodeId;
-    error: NodeErrorV0;
+    node_id: NodeId$1;
+    error: NodeErrorV0$1;
 };
 type RunEventNodeLLMCallV0 = RunEventBaseV0 & {
     type: "node_llm_call";
-    node_id: NodeId;
-    llm_call: NodeLLMCallV0;
+    node_id: NodeId$1;
+    llm_call: NodeLLMCallV0$1;
 };
 type RunEventNodeToolCallV0 = RunEventBaseV0 & {
     type: "node_tool_call";
-    node_id: NodeId;
-    tool_call: NodeToolCallV0;
+    node_id: NodeId$1;
+    tool_call: NodeToolCallV0$1;
 };
 type RunEventNodeToolResultV0 = RunEventBaseV0 & {
     type: "node_tool_result";
-    node_id: NodeId;
-    tool_result: NodeToolResultV0;
+    node_id: NodeId$1;
+    tool_result: NodeToolResultV0$1;
 };
 type RunEventNodeWaitingV0 = RunEventBaseV0 & {
     type: "node_waiting";
-    node_id: NodeId;
-    waiting: NodeWaitingV0;
+    node_id: NodeId$1;
+    waiting: NodeWaitingV0$1;
 };
 type RunEventNodeOutputDeltaV0 = RunEventBaseV0 & {
     type: "node_output_delta";
-    node_id: NodeId;
-    delta: NodeOutputDeltaV0;
+    node_id: NodeId$1;
+    delta: NodeOutputDeltaV0$1;
 };
 type RunEventNodeOutputV0 = RunEventBaseV0 & {
     type: "node_output";
-    node_id: NodeId;
+    node_id: NodeId$1;
     artifact_key: string;
-    output_info: PayloadInfoV0;
+    output_info: PayloadInfoV0$1;
 };
 type RunEventV0 = RunEventRunCompiledV0 | RunEventRunStartedV0 | RunEventRunCompletedV0 | RunEventRunFailedV0 | RunEventRunCanceledV0 | RunEventNodeLLMCallV0 | RunEventNodeToolCallV0 | RunEventNodeToolResultV0 | RunEventNodeWaitingV0 | RunEventNodeStartedV0 | RunEventNodeSucceededV0 | RunEventNodeFailedV0 | RunEventNodeOutputDeltaV0 | RunEventNodeOutputV0;
 
 type NodeStatusV0 = "pending" | "running" | "waiting" | "succeeded" | "failed" | "canceled";
 type RunsToolResultsRequest = {
-    node_id: NodeId;
+    node_id: NodeId$1;
     step: number;
     request_id: string;
     results: Array<{
@@ -2016,9 +2257,9 @@ type RunsToolResultsResponse = {
     status: RunStatusV0;
 };
 type RunsPendingToolsResponse = {
-    run_id: RunId;
+    run_id: RunId$1;
     pending: Array<{
-        node_id: NodeId;
+        node_id: NodeId$1;
         step: number;
         request_id: string;
         tool_calls: Array<{
@@ -2029,14 +2270,14 @@ type RunsPendingToolsResponse = {
     }>;
 };
 type RunsCreateResponse = {
-    run_id: RunId;
+    run_id: RunId$1;
     status: RunStatusV0;
-    plan_hash: PlanHash;
+    plan_hash: PlanHash$1;
 };
 type RunsGetResponse = {
-    run_id: RunId;
+    run_id: RunId$1;
     status: RunStatusV0;
-    plan_hash: PlanHash;
+    plan_hash: PlanHash$1;
     cost_summary: RunCostSummaryV0;
     nodes?: NodeResultV0[];
     outputs?: Record<string, unknown>;
@@ -2054,7 +2295,7 @@ type RunCostLineItemV0 = {
     usd_cents: number;
 };
 type NodeResultV0 = {
-    id: NodeId;
+    id: NodeId$1;
     type: string;
     status: NodeStatusV0;
     started_at?: string;
@@ -2097,6 +2338,7 @@ declare class RunsEventStream implements AsyncIterable<RunEventV0> {
 
 type RunsCreateOptions = {
     customerId?: string;
+    sessionId?: string;
     idempotencyKey?: string;
     signal?: AbortSignal;
     headers?: Record<string, string>;
@@ -2177,11 +2419,11 @@ declare class RunsClient {
         metrics?: MetricsCallbacks;
         trace?: TraceCallbacks;
     }): Promise<unknown>;
-    get(runId: RunId, options?: RunsGetOptions): Promise<RunsGetResponse>;
-    events(runId: RunId, options?: RunsEventsOptions): Promise<RunsEventStream>;
-    listEvents(runId: RunId, options?: Omit<RunsEventsOptions, "wait">): Promise<RunEventV0[]>;
-    submitToolResults(runId: RunId, req: RunsToolResultsRequest, options?: RunsToolResultsOptions): Promise<RunsToolResultsResponse>;
-    pendingTools(runId: RunId, options?: RunsPendingToolsOptions): Promise<RunsPendingToolsResponse>;
+    get(runId: RunId$1, options?: RunsGetOptions): Promise<RunsGetResponse>;
+    events(runId: RunId$1, options?: RunsEventsOptions): Promise<RunsEventStream>;
+    listEvents(runId: RunId$1, options?: Omit<RunsEventsOptions, "wait">): Promise<RunEventV0[]>;
+    submitToolResults(runId: RunId$1, req: RunsToolResultsRequest, options?: RunsToolResultsOptions): Promise<RunsToolResultsResponse>;
+    pendingTools(runId: RunId$1, options?: RunsPendingToolsOptions): Promise<RunsPendingToolsResponse>;
 }
 
 /**
@@ -2253,8 +2495,8 @@ declare class StreamProtocolError extends TransportError {
         status: number;
     });
 }
-declare class StreamTimeoutError extends TransportError {
-    streamKind: StreamTimeoutKind;
+declare class StreamTimeoutError extends ModelRelayError {
+    kind: StreamTimeoutKind;
     timeoutMs: number;
     constructor(streamKind: StreamTimeoutKind, timeoutMs: number);
 }
@@ -2385,7 +2627,11 @@ type WorkflowsCompileOptions = {
 };
 type WorkflowsCompileResponseV0 = {
     plan_json: unknown;
-    plan_hash: PlanHash;
+    plan_hash: PlanHash$1;
+};
+type WorkflowsCompileResponseV1 = {
+    plan_json: unknown;
+    plan_hash: PlanHash$1;
 };
 type WorkflowsCompileV0Result = ({
     ok: true;
@@ -2401,6 +2647,20 @@ type WorkflowsCompileV0Result = ({
     code?: string;
     requestId?: string;
 };
+type WorkflowsCompileV1Result = ({
+    ok: true;
+} & WorkflowsCompileResponseV1) | {
+    ok: false;
+    error_type: "validation_error";
+    issues: ReadonlyArray<WorkflowValidationIssue>;
+} | {
+    ok: false;
+    error_type: "internal_error";
+    status: number;
+    message: string;
+    code?: string;
+    requestId?: string;
+};
 declare class WorkflowsClient {
     private readonly http;
     private readonly auth;
@@ -2411,6 +2671,7 @@ declare class WorkflowsClient {
         trace?: TraceCallbacks;
     });
     compileV0(spec: WorkflowSpecV0, options?: WorkflowsCompileOptions): Promise<WorkflowsCompileV0Result>;
+    compileV1(spec: WorkflowSpecV1, options?: WorkflowsCompileOptions): Promise<WorkflowsCompileV1Result>;
 }
 
 /**
@@ -2438,6 +2699,26 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/schemas/workflow_v1.schema.json": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get JSON Schema for workflow.v1
+         * @description Returns the canonical JSON Schema (draft-07) for `workflow.v1`.
+         */
+        get: operations["getWorkflowV1Schema"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/schemas/run_event_v0.schema.json": {
         parameters: {
             query?: never;
@@ -3004,7 +3285,10 @@ interface paths {
         };
         get?: never;
         put?: never;
-        /** Create a response via the provider-agnostic API */
+        /**
+         * Create a response via the provider-agnostic API
+         * @description Creates a model response. Auth accepts secret API keys or bearer tokens. Bearer tokens may be owner session tokens (dashboard/server) or end-user tokens; publishable keys are not allowed.
+         */
         post: operations["createResponse"];
         delete?: never;
         options?: never;
@@ -3049,6 +3333,56 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/images/{image_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Image ID */
+                image_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Get image details
+         * @description Retrieve information about a specific image, including its pinned status and URL.
+         */
+        get: operations["getImage"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/images/{image_id}/pin": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Image ID */
+                image_id: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Pin an image
+         * @description Pin an image to prevent it from expiring. Pinned images remain accessible permanently (subject to tier limits).
+         */
+        post: operations["pinImage"];
+        /**
+         * Unpin an image
+         * @description Unpin an image, setting it to expire after the default ephemeral period (7 days).
+         */
+        delete: operations["unpinImage"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/runs": {
         parameters: {
             query?: never;
@@ -3059,8 +3393,8 @@ interface paths {
         get?: never;
         put?: never;
         /**
-         * Start a workflow run (workflow.v0)
-         * @description Starts a run for a `workflow.v0` spec and returns a `run_id`. Auth matches `/responses` (API key or frontend bearer token). Session owner tokens from `/auth/login` are not accepted.
+         * Start a workflow run (workflow.v0 or workflow.v1)
+         * @description Starts a run for a `workflow.v0` or `workflow.v1` spec and returns a `run_id`. Auth matches `/responses` (API key or frontend bearer token). Session owner tokens from `/auth/login` are not accepted. Provide `session_id` to link the run to a session; when linked, assistant messages are appended to the session on completion.
          */
         post: operations["createRun"];
         delete?: never;
@@ -3167,6 +3501,136 @@ interface paths {
         delete: operations["deleteSession"];
         options?: never;
         head?: never;
+        /**
+         * Update session metadata
+         * @description Updates session metadata. Keys with null values are removed.
+         */
+        patch: operations["updateSession"];
+        trace?: never;
+    };
+    "/sessions/{session_id}/messages": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_id: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Append a session message
+         * @description Appends a message to an existing session.
+         */
+        post: operations["addSessionMessage"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/projects/{id}/tool-hooks": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["ProjectID"];
+            };
+            cookie?: never;
+        };
+        /** List project tool hooks */
+        get: operations["listProjectToolHooks"];
+        put?: never;
+        /** Create a project tool hook */
+        post: operations["createProjectToolHook"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/projects/{id}/tool-hooks/{hook_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["ProjectID"];
+                hook_id: components["parameters"]["ToolHookID"];
+            };
+            cookie?: never;
+        };
+        /** Get a project tool hook */
+        get: operations["getProjectToolHook"];
+        /** Update a project tool hook */
+        put: operations["updateProjectToolHook"];
+        post?: never;
+        /** Delete a project tool hook */
+        delete: operations["deleteProjectToolHook"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/projects/{id}/tool-hooks/{hook_id}/events": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["ProjectID"];
+                hook_id: components["parameters"]["ToolHookID"];
+            };
+            cookie?: never;
+        };
+        /** List tool hook delivery events */
+        get: operations["listProjectToolHookEvents"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/projects/{id}/tool-hooks/{hook_id}/test": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["ProjectID"];
+                hook_id: components["parameters"]["ToolHookID"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Test a tool hook */
+        post: operations["testProjectToolHook"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/sessions/{session_id}/clear": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_id: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Clear session messages
+         * @description Deletes all messages in the session and returns the updated session.
+         */
+        post: operations["clearSession"];
+        delete?: never;
+        options?: never;
+        head?: never;
         patch?: never;
         trace?: never;
     };
@@ -3244,15 +3708,15 @@ interface components {
             /** @description Whether the model is deprecated */
             deprecated: boolean;
             /**
-             * Format: uint64
-             * @description Input token price in cents per million (e.g., 300 = $3.00/1M tokens)
+             * Format: int64
+             * @description Provider input cost in cents per million tokens. Customer price is derived as cost * (1 + platformFeePercent/100).
              */
-            input_price_per_million_cents: number;
+            model_input_cost_cents: number;
             /**
-             * Format: uint64
-             * @description Output token price in cents per million (e.g., 1500 = $15.00/1M tokens)
+             * Format: int64
+             * @description Provider output cost in cents per million tokens. Customer price is derived as cost * (1 + platformFeePercent/100).
              */
-            output_price_per_million_cents: number;
+            model_output_cost_cents: number;
             /** @description Whether this is the default model for the tier */
             is_default: boolean;
             /** Format: date-time */
@@ -3260,12 +3724,9 @@ interface components {
             /** Format: date-time */
             updated_at: string;
         };
+        /** @description Model to add to a tier. Pricing is derived from the model_pricing table. */
         TierModelCreate: {
             model_id: components["schemas"]["ModelId"];
-            /** Format: uint64 */
-            input_price_per_million_cents: number;
-            /** Format: uint64 */
-            output_price_per_million_cents: number;
             /** @default false */
             is_default: boolean;
         };
@@ -3677,12 +4138,21 @@ interface components {
         WorkflowSpecV0: {
             [key: string]: unknown;
         };
+        /** @description A `workflow.v1` spec. The canonical JSON Schema is available at `/schemas/workflow_v1.schema.json`. */
+        WorkflowSpecV1: {
+            [key: string]: unknown;
+        };
         RunsCreateOptionsV0: {
             idempotency_key?: string;
         };
         RunsCreateRequest: {
-            spec: components["schemas"]["WorkflowSpecV0"];
-            /** @description Reserved for future use. */
+            spec: components["schemas"]["WorkflowSpecV0"] | components["schemas"]["WorkflowSpecV1"];
+            /**
+             * Format: uuid
+             * @description Optional session ID to link this run to a session.
+             */
+            session_id?: string;
+            /** @description Runtime inputs for the workflow. Required when the spec uses from_input references (e.g., map.fanout with items.from_input). Each key is the input name, and the value is the JSON data to provide. */
             input?: {
                 [key: string]: unknown;
             };
@@ -3936,7 +4406,7 @@ interface components {
          * @description Workflow-critical model capability identifier.
          * @enum {string}
          */
-        ModelCapability: "tools" | "vision" | "web_search" | "web_fetch" | "computer_use" | "code_execution";
+        ModelCapability: "text_generation" | "tools" | "vision" | "web_search" | "web_fetch" | "computer_use" | "code_execution" | "image_generation";
         Model: {
             model_id: components["schemas"]["ModelId"];
             provider: components["schemas"]["ProviderId"];
@@ -4058,7 +4528,7 @@ interface components {
          * @description Type of workflow node.
          * @enum {string}
          */
-        NodeTypeV0: "llm.responses" | "join.all" | "transform.json";
+        NodeTypeV0: "llm.responses" | "route.switch" | "join.all" | "join.any" | "join.collect" | "map.fanout" | "transform.json";
         /** @description Tier code identifier (e.g., free, pro, enterprise). */
         TierCode: string;
         /** @description Request to generate images from a text prompt. */
@@ -4067,6 +4537,11 @@ interface components {
             model?: string;
             /** @description Text description of the image to generate */
             prompt: string;
+            /**
+             * @description Number of images to generate (1-10, default 1)
+             * @default 1
+             */
+            n: number;
             response_format?: components["schemas"]["ImageResponseFormat"];
         };
         /**
@@ -4093,6 +4568,15 @@ interface components {
             b64_json?: string;
             /** @description MIME type of the image (e.g., 'image/png', 'image/webp') */
             mime_type?: string;
+            /** @description Unique identifier for the image (used for pinning) */
+            image_id?: string;
+            /**
+             * Format: date-time
+             * @description When the image URL expires (null if pinned)
+             */
+            expires_at?: string;
+            /** @description URL to pin this image for permanent storage */
+            pin_url?: string;
         };
         /** @description Usage statistics for image generation. */
         ImageUsage: {
@@ -4102,10 +4586,24 @@ interface components {
              */
             images: number;
         };
-        /** @description Request body for creating a session. */
-        SessionCreateRequest: {
+        /** @description Response from pin/unpin operations. */
+        ImagePinResponse: {
+            /** @description Image ID */
+            id: string;
+            /** @description Whether the image is currently pinned */
+            pinned: boolean;
             /**
-             * Format: uuid
+             * Format: date-time
+             * @description When the image expires (null if pinned)
+             */
+            expires_at?: string;
+            /** @description URL of the image */
+            url: string;
+        };
+        /** @description Request body for creating a session. */
+        SessionCreateRequest: {
+            /**
+             * Format: uuid
              * @description Optional end user ID to associate with the session
              */
             end_user_id?: string;
@@ -4192,11 +4690,107 @@ interface components {
             /** @description Cursor for fetching the next page (if more results exist) */
             next_cursor?: string;
         };
+        /** @description Request body for appending a message to a session. */
+        SessionMessageCreateRequest: {
+            /** @description Message role (user, assistant, tool) */
+            role: string;
+            /** @description Message content parts */
+            content: {
+                [key: string]: unknown;
+            }[];
+            /**
+             * Format: uuid
+             * @description Run ID that generated this message (for assistant messages)
+             */
+            run_id?: string;
+        };
+        ToolHookConfig: {
+            /** Format: uuid */
+            id?: string;
+            /** Format: uuid */
+            project_id?: string;
+            /** @enum {string} */
+            hook_type?: "pre_tool_use" | "post_tool_use" | "tool_execute";
+            /** Format: uri */
+            endpoint_url?: string;
+            enabled?: boolean;
+            /** Format: int32 */
+            timeout_ms?: number;
+            /** @enum {string} */
+            fail_behavior?: "fail_closed" | "fail_open";
+            tools_allowlist?: string[];
+            allow_mutation?: boolean;
+            /** Format: date-time */
+            created_at?: string;
+            /** Format: date-time */
+            updated_at?: string;
+        };
+        ToolHookConfigInput: {
+            /** @enum {string} */
+            hook_type: "pre_tool_use" | "post_tool_use" | "tool_execute";
+            /** Format: uri */
+            endpoint_url: string;
+            enabled?: boolean;
+            /** Format: int32 */
+            timeout_ms?: number;
+            /** @enum {string} */
+            fail_behavior?: "fail_closed" | "fail_open";
+            tools_allowlist?: string[];
+            allow_mutation?: boolean;
+        };
+        ToolHookConfigUpdate: {
+            /** Format: uri */
+            endpoint_url?: string;
+            enabled?: boolean;
+            /** Format: int32 */
+            timeout_ms?: number;
+            /** @enum {string} */
+            fail_behavior?: "fail_closed" | "fail_open";
+            tools_allowlist?: string[];
+            allow_mutation?: boolean;
+            rotate_secret?: boolean;
+        };
+        ToolHookEvent: {
+            /** Format: uuid */
+            id?: string;
+            /** Format: uuid */
+            hook_config_id?: string;
+            request_id?: string;
+            tool_call_id?: string;
+            /** @enum {string} */
+            status?: "success" | "blocked" | "timeout" | "error";
+            /** Format: int32 */
+            response_status?: number;
+            response_body?: string;
+            /** Format: int32 */
+            latency_ms?: number;
+            error?: string;
+            /** Format: date-time */
+            created_at?: string;
+        };
+        ToolHookTestResult: {
+            /** @enum {string} */
+            status?: "success" | "blocked" | "timeout" | "error";
+            /** Format: int32 */
+            response_status?: number;
+            response_body?: string;
+            /** Format: int32 */
+            latency_ms?: number;
+            error?: string;
+        };
+        /** @description Request body for updating session metadata. Null values remove keys. */
+        SessionUpdateRequest: {
+            /** @description Metadata fields to set or remove */
+            metadata: {
+                [key: string]: unknown;
+            };
+        };
     };
     responses: never;
     parameters: {
         ProjectID: string;
         WebhookID: string;
+        ToolHookID: string;
     };
     requestBodies: never;
     headers: never;
@@ -4224,6 +4818,26 @@ interface operations {
             };
         };
     };
+    getWorkflowV1Schema: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Schema document */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/schema+json": Record<string, never>;
+                };
+            };
+        };
+    };
     getRunEventV0Schema: {
         parameters: {
             query?: never;
@@ -5523,6 +6137,110 @@ interface operations {
             };
         };
     };
+    getImage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Image ID */
+                image_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Image details */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ImagePinResponse"];
+                };
+            };
+            /** @description Image not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    pinImage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Image ID */
+                image_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Image pinned successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ImagePinResponse"];
+                };
+            };
+            /** @description Quota exceeded */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Image not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Image has expired */
+            410: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    unpinImage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Image ID */
+                image_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Image unpinned successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ImagePinResponse"];
+                };
+            };
+            /** @description Image not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     createRun: {
         parameters: {
             query?: never;
@@ -5750,85 +6468,401 @@ interface operations {
             };
         };
     };
+    updateSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SessionUpdateRequest"];
+            };
+        };
+        responses: {
+            /** @description Session updated */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SessionResponse"];
+                };
+            };
+            /** @description Invalid request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description API key required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Session not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    addSessionMessage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SessionMessageCreateRequest"];
+            };
+        };
+        responses: {
+            /** @description Message appended */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SessionMessageResponse"];
+                };
+            };
+            /** @description Invalid request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description API key required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Session not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    listProjectToolHooks: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["ProjectID"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Tool hook list */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        hooks?: components["schemas"]["ToolHookConfig"][];
+                    };
+                };
+            };
+        };
+    };
+    createProjectToolHook: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["ProjectID"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ToolHookConfigInput"];
+            };
+        };
+        responses: {
+            /** @description Tool hook created */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        hook?: components["schemas"]["ToolHookConfig"];
+                        signing_secret?: string;
+                    };
+                };
+            };
+        };
+    };
+    getProjectToolHook: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["ProjectID"];
+                hook_id: components["parameters"]["ToolHookID"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Tool hook details */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        hook?: components["schemas"]["ToolHookConfig"];
+                    };
+                };
+            };
+        };
+    };
+    updateProjectToolHook: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["ProjectID"];
+                hook_id: components["parameters"]["ToolHookID"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ToolHookConfigUpdate"];
+            };
+        };
+        responses: {
+            /** @description Tool hook updated */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        hook?: components["schemas"]["ToolHookConfig"];
+                        signing_secret?: string;
+                    };
+                };
+            };
+        };
+    };
+    deleteProjectToolHook: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["ProjectID"];
+                hook_id: components["parameters"]["ToolHookID"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Tool hook deleted */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    listProjectToolHookEvents: {
+        parameters: {
+            query?: {
+                limit?: number;
+            };
+            header?: never;
+            path: {
+                id: components["parameters"]["ProjectID"];
+                hook_id: components["parameters"]["ToolHookID"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Tool hook events */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        events?: components["schemas"]["ToolHookEvent"][];
+                    };
+                };
+            };
+        };
+    };
+    testProjectToolHook: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["ProjectID"];
+                hook_id: components["parameters"]["ToolHookID"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Tool hook test result */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ToolHookTestResult"];
+                };
+            };
+            /** @description Tool hook test failed */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    clearSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Session cleared */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SessionResponse"];
+                };
+            };
+            /** @description API key required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Session not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+}
+
+/**
+ * Customer represents a customer in a ModelRelay project.
+ */
+interface Customer {
+    id: string;
+    project_id: string;
+    external_id: string;
+    email: string;
+    metadata?: CustomerMetadata;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Subscription represents billing state for a customer.
+ */
+interface Subscription {
+    id: string;
+    project_id: string;
+    customer_id: string;
+    tier_id: string;
+    tier_code?: TierCode;
+    billing_provider?: BillingProvider;
+    billing_customer_id?: string;
+    billing_subscription_id?: string;
+    subscription_status?: SubscriptionStatusKind;
+    current_period_start?: string;
+    current_period_end?: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * CustomerWithSubscription bundles customer identity with optional subscription state.
+ */
+interface CustomerWithSubscription {
+    customer: Customer;
+    subscription?: Subscription;
+}
+/**
+ * Request to create a customer.
+ */
+interface CustomerCreateRequest {
+    external_id: string;
+    email: string;
+    metadata?: CustomerMetadata;
+}
+/**
+ * Request to upsert a customer by external_id.
+ */
+interface CustomerUpsertRequest {
+    external_id: string;
+    email: string;
+    metadata?: CustomerMetadata;
+}
+/**
+ * Request to link a customer identity to a customer by email.
+ * Used when a customer subscribes via Stripe Checkout (email only) and later authenticates to the app.
+ */
+interface CustomerClaimRequest {
+    email: string;
+    provider: string;
+    subject: string;
+}
+/**
+ * Request to create a checkout session for a customer subscription.
+ */
+interface CustomerSubscribeRequest {
+    tier_id: string;
+    success_url: string;
+    cancel_url: string;
+}
+/**
+ * Checkout session response.
+ */
+interface CheckoutSession {
+    session_id: string;
+    url: string;
 }
-
-/**
- * Customer represents a customer in a ModelRelay project.
- */
-interface Customer {
-    id: string;
-    project_id: string;
-    external_id: string;
-    email: string;
-    metadata?: CustomerMetadata;
-    created_at: string;
-    updated_at: string;
-}
-/**
- * Subscription represents billing state for a customer.
- */
-interface Subscription {
-    id: string;
-    project_id: string;
-    customer_id: string;
-    tier_id: string;
-    tier_code?: TierCode;
-    billing_provider?: BillingProvider;
-    billing_customer_id?: string;
-    billing_subscription_id?: string;
-    subscription_status?: SubscriptionStatusKind;
-    current_period_start?: string;
-    current_period_end?: string;
-    created_at: string;
-    updated_at: string;
-}
-/**
- * CustomerWithSubscription bundles customer identity with optional subscription state.
- */
-interface CustomerWithSubscription {
-    customer: Customer;
-    subscription?: Subscription;
-}
-/**
- * Request to create a customer.
- */
-interface CustomerCreateRequest {
-    external_id: string;
-    email: string;
-    metadata?: CustomerMetadata;
-}
-/**
- * Request to upsert a customer by external_id.
- */
-interface CustomerUpsertRequest {
-    external_id: string;
-    email: string;
-    metadata?: CustomerMetadata;
-}
-/**
- * Request to link a customer identity to a customer by email.
- * Used when a customer subscribes via Stripe Checkout (email only) and later authenticates to the app.
- */
-interface CustomerClaimRequest {
-    email: string;
-    provider: string;
-    subject: string;
-}
-/**
- * Request to create a checkout session for a customer subscription.
- */
-interface CustomerSubscribeRequest {
-    tier_id: string;
-    success_url: string;
-    cancel_url: string;
-}
-/**
- * Checkout session response.
- */
-interface CheckoutSession {
-    session_id: string;
-    url: string;
-}
 interface CustomersClientConfig {
     apiKey?: ApiKey;
     accessToken?: string;
@@ -5920,7 +6954,8 @@ declare class CustomersClient {
  */
 type PriceInterval = "month" | "year";
 /**
- * TierModel represents a model with pricing in a tier.
+ * TierModel represents a model with cost information in a tier.
+ * Customer prices are derived from model costs: price = cost * (1 + platformFeePercent/100).
  */
 interface TierModel {
     id: string;
@@ -5932,8 +6967,10 @@ interface TierModel {
     context_window: number;
     max_output_tokens: number;
     deprecated: boolean;
-    input_price_per_million_cents: number;
-    output_price_per_million_cents: number;
+    /** Provider input cost in cents per million tokens */
+    model_input_cost_cents: number;
+    /** Provider output cost in cents per million tokens */
+    model_output_cost_cents: number;
     is_default: boolean;
     created_at: string;
     updated_at: string;
@@ -6055,6 +7092,10 @@ type ImageUsage = components["schemas"]["ImageUsage"];
  * - "b64_json": Returns base64-encoded data, for testing/development
  */
 type ImageResponseFormat = components["schemas"]["ImageResponseFormat"];
+/**
+ * Response from pin/unpin operations.
+ */
+type ImagePinResponse = components["schemas"]["ImagePinResponse"];
 /**
  * ImagesClient provides methods for generating images using AI models.
  *
@@ -6091,6 +7132,36 @@ declare class ImagesClient {
      * @throws {Error} If prompt is empty
      */
     generate(request: ImageRequest): Promise<ImageResponse>;
+    /**
+     * 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
+     */
+    get(imageId: string): Promise<ImagePinResponse>;
+    /**
+     * 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
+     */
+    pin(imageId: string): Promise<ImagePinResponse>;
+    /**
+     * 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
+     */
+    unpin(imageId: string): Promise<ImagePinResponse>;
 }
 
 /**
@@ -6131,7 +7202,7 @@ interface SessionMessage extends InputItem {
     /** When this message was added to the session. */
     readonly createdAt: Date;
     /** The run ID that produced this message (for assistant messages). */
-    readonly runId?: RunId;
+    readonly runId?: RunId$1;
 }
 /**
  * Artifacts produced during a session (files, code, etc.).
@@ -6145,6 +7216,14 @@ interface SessionRunOptions {
     model?: ModelId;
     /** Override the provider for this run. */
     provider?: ProviderId$1;
+    /** How to manage history when it approaches the model context window. */
+    contextManagement?: SessionContextManagement;
+    /** Max tokens allowed for history (derived from model if not set). */
+    maxHistoryTokens?: number;
+    /** Tokens to reserve for output (defaults to model metadata when available). */
+    reserveOutputTokens?: number;
+    /** Called when history is truncated to fit the context window. */
+    onContextTruncate?: (info: SessionContextTruncateInfo) => void;
     /** Additional tools for this run (merged with session defaults). */
     tools?: Tool[];
     /** Maximum number of LLM turns (for tool loops). */
@@ -6158,6 +7237,16 @@ interface SessionRunOptions {
  * Status of a session run.
  */
 type SessionRunStatus = "complete" | "waiting_for_tools" | "error" | "canceled";
+/** Context management strategy for session history. */
+type SessionContextManagement = "none" | "truncate" | "summarize";
+/** Metadata for context truncation callbacks. */
+interface SessionContextTruncateInfo {
+    readonly model: ModelId;
+    readonly originalMessages: number;
+    readonly keptMessages: number;
+    readonly maxHistoryTokens: number;
+    readonly reservedOutputTokens?: number;
+}
 /**
  * Pending tool call that needs client-side execution.
  */
@@ -6189,7 +7278,7 @@ interface SessionRunResult {
     /** Error message (when status is 'error'). */
     readonly error?: string;
     /** The run ID from the server. */
-    readonly runId: RunId;
+    readonly runId: RunId$1;
     /** Token and call usage. */
     readonly usage: SessionUsageSummary;
     /** All events from this run. */
@@ -6342,90 +7431,28 @@ interface SessionStore {
     /** Close the store and release resources. */
     close(): Promise<void>;
 }
-
-/**
- * Client-managed session implementation.
- *
- * LocalSession keeps conversation history on the client side with optional
- * persistence to memory, file, or SQLite. Use for:
- * - Local AI coding agents (Claude Code, Cursor)
- * - Privacy-sensitive workflows (history never leaves device)
- * - Offline-capable agents
- *
- * @module
- */
-
 /**
- * Client-managed session with optional persistence.
- *
- * @example
- * ```typescript
- * import { ModelRelay, LocalSession } from "modelrelay";
- *
- * const client = ModelRelay.fromSecretKey(process.env.MODELRELAY_SECRET_KEY!);
- * const session = LocalSession.create(client, {
- *   toolRegistry: createLocalFSTools({ root: process.cwd() }),
- *   persistence: "sqlite",
- * });
- *
- * const result1 = await session.run("Create a file called hello.txt with 'Hello World'");
- * const result2 = await session.run("Now read that file back to me");
- * ```
- */
-declare class LocalSession implements Session {
-    readonly type: "local";
-    readonly id: SessionId;
-    private readonly client;
-    private readonly store;
-    private readonly toolRegistry?;
-    private readonly defaultModel?;
-    private readonly defaultProvider?;
-    private readonly defaultTools?;
-    private readonly metadata;
-    private messages;
-    private artifacts;
-    private nextSeq;
-    private createdAt;
-    private updatedAt;
-    private currentRunId?;
-    private currentNodeId?;
-    private currentWaiting?;
-    private currentEvents;
-    private currentUsage;
-    private constructor();
-    /**
-     * Create a new local session.
-     *
-     * @param client - ModelRelay client
-     * @param options - Session configuration
-     * @returns A new LocalSession instance
-     */
-    static create(client: ModelRelay, options?: LocalSessionOptions): LocalSession;
-    /**
-     * Resume an existing session from storage.
-     *
-     * @param client - ModelRelay client
-     * @param sessionId - ID of the session to resume
-     * @param options - Session configuration (must match original persistence settings)
-     * @returns The resumed LocalSession, or null if not found
-     */
-    static resume(client: ModelRelay, sessionId: string | SessionId, options?: LocalSessionOptions): Promise<LocalSession | null>;
-    get history(): readonly SessionMessage[];
-    run(prompt: string, options?: SessionRunOptions): Promise<SessionRunResult>;
-    submitToolResults(results: ToolExecutionResult[]): Promise<SessionRunResult>;
-    getArtifacts(): SessionArtifacts;
-    close(): Promise<void>;
-    private addMessage;
-    private buildInput;
-    private processRunEvents;
-    private executeTools;
-    private persist;
+ * Options for syncing a local session to a remote session.
+ */
+interface SessionSyncOptions {
+    /**
+     * Called for each message synced. Useful for progress indicators.
+     * @param synced - Number of messages synced so far
+     * @param total - Total messages to sync
+     */
+    onProgress?: (synced: number, total: number) => void;
+    /** Abort signal for cancellation. */
+    signal?: AbortSignal;
 }
 /**
- * Create a new local session.
- * Convenience function for LocalSession.create().
+ * Result of syncing a local session to a remote session.
  */
-declare function createLocalSession(client: ModelRelay, options?: LocalSessionOptions): LocalSession;
+interface SessionSyncResult {
+    /** Number of messages synced. */
+    readonly messagesSynced: number;
+    /** The remote session ID messages were synced to. */
+    readonly remoteSessionId: SessionId;
+}
 
 /**
  * Server-managed session implementation.
@@ -6472,11 +7499,13 @@ declare class RemoteSession implements Session {
     private readonly defaultTools?;
     private metadata;
     private endUserId?;
+    private readonly resolveModelContext;
     private messages;
     private artifacts;
     private nextSeq;
     private createdAt;
     private updatedAt;
+    private pendingMessages;
     private currentRunId?;
     private currentNodeId?;
     private currentWaiting?;
@@ -6551,7 +7580,124 @@ declare class RemoteSession implements Session {
     private resetRunState;
     private processRunEvents;
     private executeToolsLocally;
+    private flushPendingMessages;
+    private appendMessageToServer;
+    private extractOutputText;
+    private extractTextFromOutputValue;
+    private extractTextFromOutputItems;
+    private extractTextFromContentParts;
+}
+
+/**
+ * Client-managed session implementation.
+ *
+ * LocalSession keeps conversation history on the client side with optional
+ * persistence to memory, file, or SQLite. Use for:
+ * - Local AI coding agents (Claude Code, Cursor)
+ * - Privacy-sensitive workflows (history never leaves device)
+ * - Offline-capable agents
+ *
+ * @module
+ */
+
+/**
+ * Client-managed session with optional persistence.
+ *
+ * @example
+ * ```typescript
+ * import { ModelRelay, LocalSession } from "modelrelay";
+ *
+ * const client = ModelRelay.fromSecretKey(process.env.MODELRELAY_SECRET_KEY!);
+ * const session = LocalSession.create(client, {
+ *   toolRegistry: createLocalFSTools({ root: process.cwd() }),
+ *   persistence: "sqlite",
+ * });
+ *
+ * const result1 = await session.run("Create a file called hello.txt with 'Hello World'");
+ * const result2 = await session.run("Now read that file back to me");
+ * ```
+ */
+declare class LocalSession implements Session {
+    readonly type: "local";
+    readonly id: SessionId;
+    private readonly client;
+    private readonly store;
+    private readonly toolRegistry?;
+    private readonly defaultModel?;
+    private readonly defaultProvider?;
+    private readonly defaultTools?;
+    private readonly metadata;
+    private readonly resolveModelContext;
+    private messages;
+    private artifacts;
+    private nextSeq;
+    private createdAt;
+    private updatedAt;
+    private currentRunId?;
+    private currentNodeId?;
+    private currentWaiting?;
+    private currentEvents;
+    private currentUsage;
+    private constructor();
+    /**
+     * Create a new local session.
+     *
+     * @param client - ModelRelay client
+     * @param options - Session configuration
+     * @returns A new LocalSession instance
+     */
+    static create(client: ModelRelay, options?: LocalSessionOptions): LocalSession;
+    /**
+     * Resume an existing session from storage.
+     *
+     * @param client - ModelRelay client
+     * @param sessionId - ID of the session to resume
+     * @param options - Session configuration (must match original persistence settings)
+     * @returns The resumed LocalSession, or null if not found
+     */
+    static resume(client: ModelRelay, sessionId: string | SessionId, options?: LocalSessionOptions): Promise<LocalSession | null>;
+    get history(): readonly SessionMessage[];
+    run(prompt: string, options?: SessionRunOptions): Promise<SessionRunResult>;
+    submitToolResults(results: ToolExecutionResult[]): Promise<SessionRunResult>;
+    getArtifacts(): SessionArtifacts;
+    close(): Promise<void>;
+    /**
+     * 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}`),
+     * });
+     * ```
+     */
+    syncTo(remoteSession: RemoteSession, options?: SessionSyncOptions): Promise<SessionSyncResult>;
+    private addMessage;
+    private buildInput;
+    private processRunEvents;
+    private executeTools;
+    private persist;
 }
+/**
+ * Create a new local session.
+ * Convenience function for LocalSession.create().
+ */
+declare function createLocalSession(client: ModelRelay, options?: LocalSessionOptions): LocalSession;
 
 /**
  * SessionsClient - Entry point for session management.
@@ -6800,6 +7946,21 @@ interface OAuthDeviceTokenPollRequest {
     fetch?: typeof fetch;
     signal?: AbortSignal;
 }
+type PollUntilResult<T> = {
+    done: true;
+    value: T;
+} | {
+    done: false;
+    retryAfterMs?: number;
+};
+interface PollUntilOptions<T> {
+    intervalMs: number;
+    deadline?: Date;
+    signal?: AbortSignal;
+    poll: (attempt: number) => Promise<PollUntilResult<T>>;
+    onTimeout?: () => Error;
+}
+declare function pollUntil<T>(opts: PollUntilOptions<T>): Promise<T>;
 declare function startOAuthDeviceAuthorization(req: OAuthDeviceAuthorizationRequest): Promise<OAuthDeviceAuthorization>;
 declare function pollOAuthDeviceToken(req: OAuthDeviceTokenPollRequest): Promise<OAuthDeviceToken>;
 declare function runOAuthDeviceFlowForIDToken(cfg: {
@@ -6816,52 +7977,784 @@ declare function runOAuthDeviceFlowForIDToken(cfg: {
     signal?: AbortSignal;
 }): Promise<string>;
 
+/** JSON pointer to extract text content from an LLM response output. */
+declare const LLM_TEXT_OUTPUT: string;
+/** JSON pointer to inject text into the user message of an LLM request.
+ * The pointer is relative to the request object (not the full node input). */
+declare const LLM_USER_MESSAGE_TEXT: string;
 type TransformJSONValueV0 = {
-    from: NodeId;
+    from: NodeId$1;
     pointer?: string;
 };
-declare function transformJSONValue(from: NodeId, pointer?: string): TransformJSONValueV0;
+declare function transformJSONValue(from: NodeId$1, pointer?: string): TransformJSONValueV0;
 declare function transformJSONObject(object: Record<string, TransformJSONValueV0>): {
     object: Record<string, TransformJSONValueV0>;
 };
-declare function transformJSONMerge(merge: ReadonlyArray<TransformJSONValueV0>): {
-    merge: Array<TransformJSONValueV0>;
+declare function transformJSONMerge(merge: ReadonlyArray<TransformJSONValueV0>): {
+    merge: Array<TransformJSONValueV0>;
+};
+type TransformJSONValueV1 = TransformJSONValueV0;
+declare const transformJSONValueV1: typeof transformJSONValue;
+declare const transformJSONObjectV1: typeof transformJSONObject;
+declare const transformJSONMergeV1: typeof transformJSONMerge;
+/**
+ * Error thrown when a binding targets a non-existent path in the request.
+ */
+declare class BindingTargetError extends Error {
+    readonly nodeId: NodeId$1;
+    readonly bindingIndex: number;
+    readonly pointer: string;
+    constructor(nodeId: NodeId$1, bindingIndex: number, pointer: string, message: string);
+}
+/**
+ * Error thrown when a map.fanout node input is invalid.
+ */
+declare class MapFanoutInputError extends Error {
+    readonly nodeId: NodeId$1;
+    constructor(nodeId: NodeId$1, message: string);
+}
+type WorkflowBuilderV0State = {
+    readonly name?: string;
+    readonly execution?: WorkflowSpecV0["execution"];
+    readonly nodes: ReadonlyArray<WorkflowNodeV0>;
+    readonly edges: ReadonlyArray<WorkflowEdgeV0>;
+    readonly outputs: ReadonlyArray<WorkflowOutputRefV0>;
+};
+declare class WorkflowBuilderV0 {
+    private readonly state;
+    constructor(state?: WorkflowBuilderV0State);
+    static new(): WorkflowBuilderV0;
+    private with;
+    name(name: string): WorkflowBuilderV0;
+    execution(execution: WorkflowSpecV0["execution"]): WorkflowBuilderV0;
+    node(node: WorkflowNodeV0): WorkflowBuilderV0;
+    llmResponses(id: NodeId$1, request: WireResponsesRequest | ResponsesRequest, options?: {
+        stream?: boolean;
+        toolExecution?: ToolExecutionModeV0$1;
+        toolLimits?: LLMResponsesToolLimitsV0;
+        bindings?: ReadonlyArray<LLMResponsesBindingV0>;
+    }): WorkflowBuilderV0;
+    joinAll(id: NodeId$1): WorkflowBuilderV0;
+    transformJSON(id: NodeId$1, input: Extract<WorkflowNodeV0, {
+        type: typeof WorkflowNodeTypes.TransformJSON;
+    }>["input"]): WorkflowBuilderV0;
+    edge(from: NodeId$1, to: NodeId$1): WorkflowBuilderV0;
+    output(name: OutputName$1, from: NodeId$1, pointer?: string): WorkflowBuilderV0;
+    build(): WorkflowSpecV0;
+}
+declare function workflowV0(): WorkflowBuilderV0;
+type WorkflowBuilderV1State = {
+    readonly name?: string;
+    readonly execution?: WorkflowSpecV1["execution"];
+    readonly nodes: ReadonlyArray<WorkflowNodeV1>;
+    readonly edges: ReadonlyArray<WorkflowEdgeV1>;
+    readonly outputs: ReadonlyArray<WorkflowOutputRefV1>;
+};
+declare class WorkflowBuilderV1 {
+    private readonly state;
+    constructor(state?: WorkflowBuilderV1State);
+    static new(): WorkflowBuilderV1;
+    private with;
+    name(name: string): WorkflowBuilderV1;
+    execution(execution: WorkflowSpecV1["execution"]): WorkflowBuilderV1;
+    node(node: WorkflowNodeV1): WorkflowBuilderV1;
+    llmResponses(id: NodeId$1, request: WireResponsesRequest | ResponsesRequest, options?: {
+        stream?: boolean;
+        toolExecution?: ToolExecutionModeV1$1;
+        toolLimits?: LLMResponsesToolLimitsV1;
+        bindings?: ReadonlyArray<LLMResponsesBindingV1>;
+    }): WorkflowBuilderV1;
+    routeSwitch(id: NodeId$1, request: WireResponsesRequest | ResponsesRequest, options?: {
+        stream?: boolean;
+        toolExecution?: ToolExecutionModeV1$1;
+        toolLimits?: LLMResponsesToolLimitsV1;
+        bindings?: ReadonlyArray<LLMResponsesBindingV1>;
+    }): WorkflowBuilderV1;
+    joinAll(id: NodeId$1): WorkflowBuilderV1;
+    joinAny(id: NodeId$1, input?: JoinAnyNodeInputV1): WorkflowBuilderV1;
+    joinCollect(id: NodeId$1, input: JoinCollectNodeInputV1): WorkflowBuilderV1;
+    transformJSON(id: NodeId$1, input: TransformJSONNodeInputV1): WorkflowBuilderV1;
+    mapFanout(id: NodeId$1, input: MapFanoutNodeInputV1): WorkflowBuilderV1;
+    edge(from: NodeId$1, to: NodeId$1, when?: ConditionV1$1): WorkflowBuilderV1;
+    output(name: OutputName$1, from: NodeId$1, pointer?: string): WorkflowBuilderV1;
+    build(): WorkflowSpecV1;
+}
+declare function workflowV1(): WorkflowBuilderV1;
+type PendingLLMNode = {
+    id: NodeId$1;
+    request: WireResponsesRequest;
+    stream?: boolean;
+    bindings: LLMResponsesBindingV0[];
+    toolExecution?: ToolExecutionModeV0$1;
+    toolLimits?: LLMResponsesToolLimitsV0;
+};
+/**
+ * Ergonomic workflow builder with auto-edge inference from bindings.
+ *
+ * @example
+ * ```typescript
+ * const spec = newWorkflow("tier_generation")
+ *   .addLLMNode("tier_generator", tierReq).stream(true)
+ *   .addLLMNode("business_summary", summaryReq)
+ *     .bindFrom("tier_generator", "/output/0/content/0/text")
+ *   .output("tiers", "tier_generator")
+ *   .output("summary", "business_summary")
+ *   .build();
+ * ```
+ */
+declare class Workflow {
+    private _name?;
+    private _execution?;
+    private readonly _nodes;
+    private readonly _edges;
+    private readonly _outputs;
+    private _pendingNode;
+    private constructor();
+    /**
+     * Create a new workflow builder with the given name.
+     */
+    static create(name?: string): Workflow;
+    /**
+     * Set the workflow execution configuration.
+     */
+    execution(exec: WorkflowSpecV0["execution"]): Workflow;
+    /**
+     * Add an LLM responses node and return a node builder for configuration.
+     */
+    addLLMNode(id: NodeId$1, request: WireResponsesRequest | ResponsesRequest): LLMNodeBuilder;
+    /**
+     * Add a join.all node that waits for all incoming edges.
+     */
+    addJoinAllNode(id: NodeId$1): Workflow;
+    /**
+     * Add a transform.json node and return a builder for configuration.
+     */
+    addTransformJSONNode(id: NodeId$1): TransformJSONNodeBuilder;
+    /**
+     * Add an output reference extracting the full node output.
+     */
+    output(name: OutputName$1, from: NodeId$1, pointer?: string): Workflow;
+    /**
+     * Add an output reference extracting text content from an LLM response.
+     * This is a convenience method that uses the LLM_TEXT_OUTPUT pointer.
+     */
+    outputText(name: OutputName$1, from: NodeId$1): Workflow;
+    /**
+     * Explicitly add an edge between nodes.
+     * Note: edges are automatically inferred from bindings, so this is rarely needed.
+     */
+    edge(from: NodeId$1, to: NodeId$1): Workflow;
+    /**
+     * Build the workflow specification.
+     */
+    build(): WorkflowSpecV0;
+    /** @internal */
+    _getPendingNode(): PendingLLMNode | null;
+    /** @internal */
+    _addEdge(from: NodeId$1, to: NodeId$1): void;
+    /** @internal */
+    _addNode(node: WorkflowNodeV0): void;
+    private flushPendingNode;
+}
+/**
+ * Builder for configuring an LLM responses node.
+ */
+declare class LLMNodeBuilder {
+    private readonly workflow;
+    constructor(workflow: Workflow);
+    /**
+     * Enable or disable streaming for this node.
+     */
+    stream(enabled: boolean): LLMNodeBuilder;
+    /**
+     * Add a binding from another LLM node's text output to this node's user message.
+     * This is the most common binding pattern: LLM text → user message with json_string encoding.
+     * The edge from the source node is automatically inferred.
+     */
+    bindTextFrom(from: NodeId$1): LLMNodeBuilder;
+    /**
+     * Add a binding from another node's output to this node's user message text.
+     * Use bindTextFrom for the common case of binding LLM text output.
+     * The edge from the source node is automatically inferred.
+     */
+    bindFrom(from: NodeId$1, pointer?: string): LLMNodeBuilder;
+    /**
+     * Add a full binding with explicit source/destination pointers and encoding.
+     * The edge from the source node is automatically inferred.
+     */
+    bindFromTo(from: NodeId$1, fromPointer: string | undefined, toPointer: string, encoding?: LLMResponsesBindingEncodingV0): LLMNodeBuilder;
+    /**
+     * 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: NodeId$1, fromPointer: string | undefined, placeholder: string): LLMNodeBuilder;
+    /**
+     * 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: NodeId$1, placeholder: string): LLMNodeBuilder;
+    /**
+     * Set the tool execution mode (server or client).
+     */
+    toolExecution(mode: ToolExecutionModeV0$1): LLMNodeBuilder;
+    /**
+     * Set the tool execution limits.
+     */
+    toolLimits(limits: LLMResponsesToolLimitsV0): LLMNodeBuilder;
+    addLLMNode(id: NodeId$1, request: WireResponsesRequest | ResponsesRequest): LLMNodeBuilder;
+    addJoinAllNode(id: NodeId$1): Workflow;
+    addTransformJSONNode(id: NodeId$1): TransformJSONNodeBuilder;
+    edge(from: NodeId$1, to: NodeId$1): Workflow;
+    output(name: OutputName$1, from: NodeId$1, pointer?: string): Workflow;
+    outputText(name: OutputName$1, from: NodeId$1): Workflow;
+    execution(exec: WorkflowSpecV0["execution"]): Workflow;
+    build(): WorkflowSpecV0;
+}
+/**
+ * Builder for configuring a transform.json node.
+ */
+declare class TransformJSONNodeBuilder {
+    private readonly workflow;
+    private readonly id;
+    private _object?;
+    private _merge?;
+    constructor(workflow: Workflow, id: NodeId$1);
+    /**
+     * Set the object transformation with field mappings.
+     */
+    object(fields: Record<string, TransformJSONValueV0>): TransformJSONNodeBuilder;
+    /**
+     * Set the merge transformation with source references.
+     */
+    merge(items: TransformJSONValueV0[]): TransformJSONNodeBuilder;
+    private finalize;
+    addLLMNode(id: NodeId$1, request: WireResponsesRequest | ResponsesRequest): LLMNodeBuilder;
+    addJoinAllNode(id: NodeId$1): Workflow;
+    edge(from: NodeId$1, to: NodeId$1): Workflow;
+    output(name: OutputName$1, from: NodeId$1, pointer?: string): Workflow;
+    execution(exec: WorkflowSpecV0["execution"]): Workflow;
+    build(): WorkflowSpecV0;
+}
+/**
+ * Create a new ergonomic workflow builder with the given name.
+ *
+ * @example
+ * ```typescript
+ * const spec = newWorkflow("my_workflow")
+ *   .addLLMNode("generator", request).stream(true)
+ *   .addLLMNode("summarizer", summaryReq)
+ *     .bindFrom("generator", "/output/0/content/0/text")
+ *   .output("result", "summarizer")
+ *   .build();
+ * ```
+ */
+declare function newWorkflow(name?: string): Workflow;
+
+/**
+ * Type-safe JSON pointer construction for LLM request/response paths.
+ *
+ * Use these builders instead of raw strings to get compile-time safety
+ * and IDE autocomplete for common LLM request/response paths.
+ *
+ * @example
+ * ```typescript
+ * // Instead of raw string:
+ * const pointer = "/output/0/content/0/text";
+ *
+ * // Use typed builder:
+ * const pointer = LLMOutput().content(0).text();
+ *
+ * // Or use pre-built paths:
+ * import { LLMOutputText } from "./json_path";
+ * ```
+ */
+/** JSON pointer string type for type safety */
+type JSONPointer = string;
+/**
+ * Path builder for LLM response output structures.
+ * The output structure is: output[index].content[index].{text|...}
+ */
+declare class LLMOutputPath {
+    private readonly path;
+    constructor(path?: string);
+    /** Select an output by index */
+    index(i: number): LLMOutputContentPath;
+    /** Shorthand for index(0).content(i) */
+    content(i: number): LLMOutputContentItemPath;
+}
+/** Path builder for output[i] level */
+declare class LLMOutputContentPath {
+    private readonly path;
+    constructor(path: string);
+    /** Select a content item by index */
+    content(i: number): LLMOutputContentItemPath;
+}
+/** Path builder for output[i].content[j] level */
+declare class LLMOutputContentItemPath {
+    private readonly path;
+    constructor(path: string);
+    /** Get the text field pointer */
+    text(): JSONPointer;
+    /** Get the type field pointer */
+    type(): JSONPointer;
+    /** Get the path as a string */
+    toString(): string;
+}
+/**
+ * Path builder for LLM request input structures.
+ * The input structure is: input[message_index].content[content_index].{text|...}
+ */
+declare class LLMInputPath {
+    private readonly path;
+    constructor(path?: string);
+    /**
+     * Select a message by index.
+     * Index 0 is typically the system message, index 1 is the first user message.
+     */
+    message(i: number): LLMInputMessagePath;
+    /** Shorthand for message(0) - the first message slot */
+    systemMessage(): LLMInputMessagePath;
+    /** Shorthand for message(1) - typically the user message after system */
+    userMessage(): LLMInputMessagePath;
+}
+/** Path builder for input[i] level */
+declare class LLMInputMessagePath {
+    private readonly path;
+    constructor(path: string);
+    /** Select a content item by index */
+    content(i: number): LLMInputContentItemPath;
+    /** Shorthand for content(0).text() */
+    text(): JSONPointer;
+}
+/** Path builder for input[i].content[j] level */
+declare class LLMInputContentItemPath {
+    private readonly path;
+    constructor(path: string);
+    /** Get the text field pointer */
+    text(): JSONPointer;
+    /** Get the type field pointer */
+    type(): JSONPointer;
+    /** Get the path as a string */
+    toString(): string;
+}
+/** Start building a path into an LLM response output */
+declare function LLMOutput(): LLMOutputPath;
+/** Start building a path into an LLM request input */
+declare function LLMInput(): LLMInputPath;
+/** Extracts text from the first content item of the first output */
+declare const LLMOutputText: JSONPointer;
+/** Targets the system message text (input[0].content[0].text) */
+declare const LLMInputSystemText: JSONPointer;
+/** Targets the user message text (input[1].content[0].text) */
+declare const LLMInputUserText: JSONPointer;
+/** Targets the first message text (input[0].content[0].text) */
+declare const LLMInputFirstMessageText: JSONPointer;
+/**
+ * Path builder for accessing outputs from a join.all node.
+ * A join.all node produces an object keyed by upstream node IDs.
+ *
+ * @example
+ * ```typescript
+ * // Access text from a specific node in the join output:
+ * const pointer = JoinOutput("cost_analyst").text();
+ * // Produces: "/cost_analyst/output/0/content/0/text"
+ * ```
+ */
+declare class JoinOutputPath {
+    private readonly path;
+    constructor(path: string);
+    /** Access the output array of the node */
+    output(): LLMOutputPath;
+    /**
+     * Shorthand for accessing the first text content from the node.
+     * Equivalent to: JoinOutput(nodeId).output().content(0).text()
+     */
+    text(): JSONPointer;
+    /** Get the path as a string */
+    toString(): string;
+}
+/**
+ * Start building a path to access a specific node's output from a join.all node.
+ * @param nodeId The ID of the upstream node
+ */
+declare function JoinOutput(nodeId: string): JoinOutputPath;
+
+var $id$1 = "https://modelrelay.ai/schemas/workflow_v0.schema.json";
+var $schema$1 = "http://json-schema.org/draft-07/schema#";
+var additionalProperties$1 = false;
+var definitions$1 = {
+	edge: {
+		additionalProperties: false,
+		properties: {
+			from: {
+				minLength: 1,
+				type: "string"
+			},
+			to: {
+				minLength: 1,
+				type: "string"
+			}
+		},
+		required: [
+			"from",
+			"to"
+		],
+		type: "object"
+	},
+	llmResponsesBinding: {
+		additionalProperties: false,
+		oneOf: [
+			{
+				required: [
+					"to"
+				]
+			},
+			{
+				required: [
+					"to_placeholder"
+				]
+			}
+		],
+		properties: {
+			encoding: {
+				"enum": [
+					"json",
+					"json_string"
+				],
+				type: "string"
+			},
+			from: {
+				minLength: 1,
+				type: "string"
+			},
+			pointer: {
+				pattern: "^(/.*)?$",
+				type: "string"
+			},
+			to: {
+				pattern: "^/.*$",
+				type: "string"
+			},
+			to_placeholder: {
+				minLength: 1,
+				type: "string"
+			}
+		},
+		required: [
+			"from"
+		],
+		type: "object"
+	},
+	node: {
+		additionalProperties: false,
+		oneOf: [
+			{
+				allOf: [
+					{
+						properties: {
+							input: {
+								properties: {
+									bindings: {
+										items: {
+											$ref: "#/definitions/llmResponsesBinding"
+										},
+										type: "array"
+									},
+									request: {
+										type: "object"
+									},
+									stream: {
+										type: "boolean"
+									},
+									tool_execution: {
+										additionalProperties: false,
+										properties: {
+											mode: {
+												"default": "server",
+												"enum": [
+													"server",
+													"client"
+												],
+												type: "string"
+											}
+										},
+										required: [
+											"mode"
+										],
+										type: "object"
+									},
+									tool_limits: {
+										additionalProperties: false,
+										properties: {
+											max_llm_calls: {
+												"default": 8,
+												maximum: 64,
+												minimum: 1,
+												type: "integer"
+											},
+											max_tool_calls_per_step: {
+												"default": 16,
+												maximum: 64,
+												minimum: 1,
+												type: "integer"
+											},
+											wait_ttl_ms: {
+												"default": 900000,
+												maximum: 86400000,
+												minimum: 1,
+												type: "integer"
+											}
+										},
+										type: "object"
+									}
+								},
+								required: [
+									"request"
+								],
+								type: "object"
+							}
+						}
+					}
+				],
+				properties: {
+					type: {
+						"const": "llm.responses"
+					}
+				},
+				required: [
+					"input"
+				]
+			},
+			{
+				properties: {
+					type: {
+						"const": "join.all"
+					}
+				}
+			},
+			{
+				allOf: [
+					{
+						properties: {
+							input: {
+								additionalProperties: false,
+								oneOf: [
+									{
+										not: {
+											required: [
+												"merge"
+											]
+										},
+										required: [
+											"object"
+										]
+									},
+									{
+										not: {
+											required: [
+												"object"
+											]
+										},
+										required: [
+											"merge"
+										]
+									}
+								],
+								properties: {
+									merge: {
+										items: {
+											$ref: "#/definitions/transformValue"
+										},
+										minItems: 1,
+										type: "array"
+									},
+									object: {
+										additionalProperties: {
+											$ref: "#/definitions/transformValue"
+										},
+										minProperties: 1,
+										type: "object"
+									}
+								},
+								type: "object"
+							}
+						}
+					}
+				],
+				properties: {
+					type: {
+						"const": "transform.json"
+					}
+				},
+				required: [
+					"input"
+				]
+			}
+		],
+		properties: {
+			id: {
+				minLength: 1,
+				type: "string"
+			},
+			input: {
+			},
+			type: {
+				"enum": [
+					"llm.responses",
+					"join.all",
+					"transform.json"
+				],
+				type: "string"
+			}
+		},
+		required: [
+			"id",
+			"type"
+		],
+		type: "object"
+	},
+	output: {
+		additionalProperties: false,
+		properties: {
+			from: {
+				minLength: 1,
+				type: "string"
+			},
+			name: {
+				minLength: 1,
+				type: "string"
+			},
+			pointer: {
+				pattern: "^(/.*)?$",
+				type: "string"
+			}
+		},
+		required: [
+			"name",
+			"from"
+		],
+		type: "object"
+	},
+	transformValue: {
+		additionalProperties: false,
+		properties: {
+			from: {
+				minLength: 1,
+				type: "string"
+			},
+			pointer: {
+				pattern: "^(/.*)?$",
+				type: "string"
+			}
+		},
+		required: [
+			"from"
+		],
+		type: "object"
+	}
+};
+var properties$1 = {
+	edges: {
+		items: {
+			$ref: "#/definitions/edge"
+		},
+		type: "array"
+	},
+	execution: {
+		additionalProperties: false,
+		properties: {
+			max_parallelism: {
+				minimum: 1,
+				type: "integer"
+			},
+			node_timeout_ms: {
+				minimum: 1,
+				type: "integer"
+			},
+			run_timeout_ms: {
+				minimum: 1,
+				type: "integer"
+			}
+		},
+		type: "object"
+	},
+	kind: {
+		"const": "workflow.v0",
+		type: "string"
+	},
+	name: {
+		type: "string"
+	},
+	nodes: {
+		items: {
+			$ref: "#/definitions/node"
+		},
+		minItems: 1,
+		type: "array"
+	},
+	outputs: {
+		items: {
+			$ref: "#/definitions/output"
+		},
+		minItems: 1,
+		type: "array"
+	}
 };
-type WorkflowBuilderV0State = {
-    readonly name?: string;
-    readonly execution?: WorkflowSpecV0["execution"];
-    readonly nodes: ReadonlyArray<WorkflowNodeV0>;
-    readonly edges: ReadonlyArray<WorkflowEdgeV0>;
-    readonly outputs: ReadonlyArray<WorkflowOutputRefV0>;
+var required$1 = [
+	"kind",
+	"nodes",
+	"outputs"
+];
+var title$1 = "ModelRelay workflow.v0";
+var type$1 = "object";
+var workflow_v0_schema = {
+	$id: $id$1,
+	$schema: $schema$1,
+	additionalProperties: additionalProperties$1,
+	definitions: definitions$1,
+	properties: properties$1,
+	required: required$1,
+	title: title$1,
+	type: type$1
 };
-declare class WorkflowBuilderV0 {
-    private readonly state;
-    constructor(state?: WorkflowBuilderV0State);
-    static new(): WorkflowBuilderV0;
-    private with;
-    name(name: string): WorkflowBuilderV0;
-    execution(execution: WorkflowSpecV0["execution"]): WorkflowBuilderV0;
-    node(node: WorkflowNodeV0): WorkflowBuilderV0;
-    llmResponses(id: NodeId, request: WireResponsesRequest | ResponsesRequest, options?: {
-        stream?: boolean;
-        toolExecution?: ToolExecutionModeV0;
-        toolLimits?: LLMResponsesToolLimitsV0;
-        bindings?: ReadonlyArray<LLMResponsesBindingV0>;
-    }): WorkflowBuilderV0;
-    joinAll(id: NodeId): WorkflowBuilderV0;
-    transformJSON(id: NodeId, input: Extract<WorkflowNodeV0, {
-        type: typeof WorkflowNodeTypes.TransformJSON;
-    }>["input"]): WorkflowBuilderV0;
-    edge(from: NodeId, to: NodeId): WorkflowBuilderV0;
-    output(name: OutputName, from: NodeId, pointer?: string): WorkflowBuilderV0;
-    build(): WorkflowSpecV0;
-}
-declare function workflowV0(): WorkflowBuilderV0;
 
-var $id = "https://modelrelay.ai/schemas/workflow_v0.schema.json";
+var $id = "https://modelrelay.ai/schemas/workflow_v1.schema.json";
 var $schema = "http://json-schema.org/draft-07/schema#";
 var additionalProperties = false;
 var 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: {
@@ -6872,6 +8765,9 @@ var definitions = {
 			to: {
 				minLength: 1,
 				type: "string"
+			},
+			when: {
+				$ref: "#/definitions/condition"
 			}
 		},
 		required: [
@@ -6880,38 +8776,271 @@ var definitions = {
 		],
 		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"
-			},
-			from: {
-				minLength: 1,
-				type: "string"
-			},
-			pointer: {
-				pattern: "^(/.*)?$",
-				type: "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": 900000,
+												maximum: 86400000,
+												minimum: 1,
+												type: "integer"
+											}
+										},
+										type: "object"
+									}
+								},
+								required: [
+									"request"
+								],
+								type: "object"
+							}
+						}
+					}
+				],
+				properties: {
+					type: {
+						"const": "llm.responses"
+					}
+				},
+				required: [
+					"input"
+				]
 			},
-			to: {
-				pattern: "^/.*$",
-				type: "string"
-			}
-		},
-		required: [
-			"from",
-			"to"
-		],
-		type: "object"
-	},
-	node: {
-		additionalProperties: false,
-		oneOf: [
 			{
 				allOf: [
 					{
@@ -6982,7 +9111,7 @@ var definitions = {
 				],
 				properties: {
 					type: {
-						"const": "llm.responses"
+						"const": "route.switch"
 					}
 				},
 				required: [
@@ -6996,6 +9125,61 @@ var definitions = {
 					}
 				}
 			},
+			{
+				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: [
 					{
@@ -7053,6 +9237,122 @@ var definitions = {
 				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: {
@@ -7065,8 +9365,13 @@ var definitions = {
 			type: {
 				"enum": [
 					"llm.responses",
+					"route.switch",
 					"join.all",
-					"transform.json"
+					"join.any",
+					"join.collect",
+					"transform.json",
+					"map.fanout",
+					"fragment"
 				],
 				type: "string"
 			}
@@ -7088,6 +9393,10 @@ var definitions = {
 				minLength: 1,
 				type: "string"
 			},
+			output: {
+				minLength: 1,
+				type: "string"
+			},
 			pointer: {
 				pattern: "^(/.*)?$",
 				type: "string"
@@ -7142,8 +9451,14 @@ var properties = {
 		},
 		type: "object"
 	},
+	fragments: {
+		additionalProperties: {
+			$ref: "#/definitions/fragmentDef"
+		},
+		type: "object"
+	},
 	kind: {
-		"const": "workflow.v0",
+		"const": "workflow.v1",
 		type: "string"
 	},
 	name: {
@@ -7164,26 +9479,325 @@ var properties = {
 		type: "array"
 	}
 };
-var required = [
-	"kind",
-	"nodes",
-	"outputs"
-];
-var title = "ModelRelay workflow.v0";
-var type = "object";
-var workflow_v0_schema = {
-	$id: $id,
-	$schema: $schema,
-	additionalProperties: additionalProperties,
-	definitions: definitions,
-	properties: properties,
-	required: required,
-	title: title,
-	type: type
+var required = [
+	"kind",
+	"nodes",
+	"outputs"
+];
+var title = "ModelRelay workflow.v1";
+var type = "object";
+var workflow_v1_schema = {
+	$id: $id,
+	$schema: $schema,
+	additionalProperties: additionalProperties,
+	definitions: definitions,
+	properties: properties,
+	required: required,
+	title: title,
+	type: type
+};
+
+declare const WORKFLOWS_COMPILE_PATH = "/workflows/compile";
+type WorkflowsCompileRequestV0 = WorkflowSpecV0;
+type WorkflowsCompileRequestV1 = WorkflowSpecV1;
+
+/**
+ * High-level workflow pattern helpers for common workflow structures.
+ *
+ * These helpers reduce boilerplate for common patterns like sequential chains,
+ * parallel execution with aggregation, and map-reduce processing.
+ *
+ * All builders are immutable - each method returns a new builder instance.
+ *
+ * @example
+ * ```typescript
+ * import { Chain, Parallel, MapReduce, LLMStep, MapItem } from 'modelrelay';
+ *
+ * // Chain pattern - sequential steps
+ * const chainSpec = Chain('summarize-translate', [
+ *   LLMStep('summarize', summarizeReq),
+ *   LLMStep('translate', translateReq).withStream(),
+ * ])
+ *   .outputLast('result')
+ *   .build();
+ *
+ * // Parallel pattern - concurrent steps with aggregation
+ * const parallelSpec = Parallel('multi-model', [
+ *   LLMStep('gpt4', gpt4Req),
+ *   LLMStep('claude', claudeReq),
+ * ])
+ *   .aggregate('synthesize', synthesizeReq)
+ *   .output('result', 'synthesize')
+ *   .build();
+ *
+ * // MapReduce pattern - parallel mappers with reducer
+ * const mapReduceSpec = MapReduce('process-docs', [
+ *   MapItem('doc1', doc1Req),
+ *   MapItem('doc2', doc2Req),
+ * ])
+ *   .reduce('combine', combineReq)
+ *   .output('result', 'combine')
+ *   .build();
+ * ```
+ */
+
+/**
+ * Configuration for an LLM step in a workflow pattern.
+ */
+type LLMStepConfig = {
+    readonly id: NodeId$1;
+    readonly request: WireResponsesRequest;
+    readonly stream: boolean;
+};
+/**
+ * Creates an LLM step configuration for use with Chain or Parallel patterns.
+ *
+ * @param id - Unique node identifier
+ * @param request - The LLM request configuration
+ * @returns A step configuration object with fluent methods
+ *
+ * @example
+ * ```typescript
+ * const step = LLMStep('summarize', {
+ *   model: 'claude-sonnet-4-20250514',
+ *   input: [{ type: 'message', role: 'user', content: [{ type: 'text', text: 'Summarize...' }] }],
+ * });
+ *
+ * // Enable streaming
+ * const streamingStep = step.withStream();
+ * ```
+ */
+declare function LLMStep(id: NodeId$1 | string, request: WireResponsesRequest | ResponsesRequest): LLMStepConfig & {
+    withStream(): LLMStepConfig;
+};
+/**
+ * Immutable builder for sequential workflow where each step's output feeds into the next.
+ */
+declare class ChainBuilder {
+    private readonly state;
+    private constructor();
+    static create(name: string, steps: readonly LLMStepConfig[]): ChainBuilder;
+    private with;
+    /**
+     * Sets the workflow execution configuration.
+     */
+    execution(exec: WorkflowSpecV0["execution"]): ChainBuilder;
+    /**
+     * Adds an output reference from a specific step.
+     */
+    output(name: OutputName$1 | string, from: NodeId$1 | string): ChainBuilder;
+    /**
+     * Adds an output reference from the last step.
+     */
+    outputLast(name: OutputName$1 | string): ChainBuilder;
+    /**
+     * Builds and returns the compiled workflow spec.
+     * @throws Error if no steps are provided
+     */
+    build(): WorkflowSpecV0;
+}
+/**
+ * Creates a workflow builder for sequential LLM steps.
+ * Each step after the first automatically binds its input from the previous step's text output.
+ *
+ * @param name - Workflow name
+ * @param steps - Array of LLMStep configurations
+ * @returns A ChainBuilder for further configuration
+ *
+ * @example
+ * ```typescript
+ * const spec = Chain('summarize-translate', [
+ *   LLMStep('summarize', summarizeReq),
+ *   LLMStep('translate', translateReq).withStream(),
+ *   LLMStep('format', formatReq),
+ * ])
+ *   .outputLast('result')
+ *   .build();
+ * ```
+ */
+declare function Chain(name: string, steps: readonly LLMStepConfig[]): ChainBuilder;
+/**
+ * Immutable builder for workflow where multiple LLM steps execute in parallel,
+ * with optional aggregation.
+ */
+declare class ParallelBuilder {
+    private readonly state;
+    private constructor();
+    static create(name: string, steps: readonly LLMStepConfig[]): ParallelBuilder;
+    private with;
+    /**
+     * Sets the workflow execution configuration.
+     */
+    execution(exec: WorkflowSpecV0["execution"]): ParallelBuilder;
+    /**
+     * Adds a join node that waits for all parallel steps,
+     * followed by an aggregator LLM node that receives the combined output.
+     * The join node ID is automatically generated as "<id>_join".
+     */
+    aggregate(id: NodeId$1 | string, request: WireResponsesRequest | ResponsesRequest): ParallelBuilder;
+    /**
+     * Like aggregate() but enables streaming on the aggregator node.
+     */
+    aggregateWithStream(id: NodeId$1 | string, request: WireResponsesRequest | ResponsesRequest): ParallelBuilder;
+    /**
+     * Adds an output reference from a specific step.
+     */
+    output(name: OutputName$1 | string, from: NodeId$1 | string): ParallelBuilder;
+    /**
+     * Builds and returns the compiled workflow spec.
+     * @throws Error if no steps are provided
+     */
+    build(): WorkflowSpecV0;
+}
+/**
+ * Creates a workflow builder for parallel LLM steps.
+ * All steps execute concurrently with no dependencies between them.
+ *
+ * @param name - Workflow name
+ * @param steps - Array of LLMStep configurations
+ * @returns A ParallelBuilder for further configuration
+ *
+ * @example
+ * ```typescript
+ * // Without aggregation - just parallel execution
+ * const spec = Parallel('multi-model', [
+ *   LLMStep('gpt4', gpt4Req),
+ *   LLMStep('claude', claudeReq),
+ * ])
+ *   .output('gpt4_result', 'gpt4')
+ *   .output('claude_result', 'claude')
+ *   .build();
+ *
+ * // With aggregation - parallel then combine
+ * const spec = Parallel('multi-model', [
+ *   LLMStep('gpt4', gpt4Req),
+ *   LLMStep('claude', claudeReq),
+ * ])
+ *   .aggregate('synthesize', synthesizeReq)
+ *   .output('result', 'synthesize')
+ *   .build();
+ * ```
+ */
+declare function Parallel(name: string, steps: readonly LLMStepConfig[]): ParallelBuilder;
+/**
+ * Configuration for a map item in MapReduce.
+ */
+type MapItemConfig = {
+    readonly id: string;
+    readonly request: WireResponsesRequest;
+    readonly stream: boolean;
+};
+/**
+ * Creates a map item configuration for use with MapReduce pattern.
+ * Each item becomes a separate mapper node that runs in parallel.
+ *
+ * @param id - Unique identifier for this item (becomes part of node ID: "map_<id>")
+ * @param request - The LLM request for processing this item
+ * @returns A map item configuration object with fluent methods
+ *
+ * @example
+ * ```typescript
+ * const item = MapItem('doc1', {
+ *   model: 'claude-sonnet-4-20250514',
+ *   input: [{ type: 'message', role: 'user', content: [{ type: 'text', text: 'Summarize doc1...' }] }],
+ * });
+ *
+ * // Enable streaming
+ * const streamingItem = item.withStream();
+ * ```
+ */
+declare function MapItem(id: string, request: WireResponsesRequest | ResponsesRequest): MapItemConfig & {
+    withStream(): MapItemConfig;
 };
+/**
+ * Immutable builder for workflow where items are processed in parallel by mapper nodes,
+ * then combined by a reducer node.
+ *
+ * The pattern creates:
+ * - N mapper nodes (one per item), running in parallel
+ * - A join.all node to collect all mapper outputs
+ * - A reducer LLM node that receives the combined outputs
+ *
+ * Note: Items must be known at workflow build time. For dynamic array
+ * processing at runtime, server-side support for dynamic node instantiation
+ * would be required.
+ */
+declare class MapReduceBuilder {
+    private readonly state;
+    private constructor();
+    static create(name: string, items: readonly MapItemConfig[]): MapReduceBuilder;
+    private with;
+    /**
+     * Adds a mapper item to the workflow.
+     * Each item becomes a separate LLM node that runs in parallel.
+     */
+    item(id: NodeId$1 | string, request: WireResponsesRequest | ResponsesRequest): MapReduceBuilder;
+    /**
+     * Adds a mapper item with streaming enabled.
+     */
+    itemWithStream(id: NodeId$1 | string, request: WireResponsesRequest | ResponsesRequest): MapReduceBuilder;
+    /**
+     * Sets the workflow execution configuration.
+     */
+    execution(exec: WorkflowSpecV0["execution"]): MapReduceBuilder;
+    /**
+     * Adds a reducer node that receives all mapper outputs.
+     * The reducer receives a JSON object mapping each mapper ID to its text output.
+     * The join node ID is automatically generated as "<id>_join".
+     */
+    reduce(id: NodeId$1 | string, request: WireResponsesRequest | ResponsesRequest): MapReduceBuilder;
+    /**
+     * Like reduce() but enables streaming on the reducer node.
+     */
+    reduceWithStream(id: NodeId$1 | string, request: WireResponsesRequest | ResponsesRequest): MapReduceBuilder;
+    /**
+     * Adds an output reference from a specific node.
+     * Typically used to output from the reducer node.
+     */
+    output(name: OutputName$1 | string, from: NodeId$1 | string): MapReduceBuilder;
+    /**
+     * Builds and returns the compiled workflow spec.
+     * @throws Error if no items are provided or no reducer is configured
+     */
+    build(): WorkflowSpecV0;
+}
+/**
+ * Creates a workflow builder for parallel map-reduce processing.
+ * Each item is processed by a separate mapper node, and results are combined
+ * by a reducer node.
+ *
+ * @param name - Workflow name
+ * @param items - Optional array of MapItem configurations (can also use .item() builder)
+ * @returns A MapReduceBuilder for further configuration
+ *
+ * @example
+ * ```typescript
+ * // Fluent builder pattern (preferred)
+ * const spec = mapReduce('summarize-docs')
+ *   .item('doc1', doc1Req)
+ *   .item('doc2', doc2Req)
+ *   .reduce('combine', combineReq)
+ *   .output(parseOutputName('result'), 'combine')
+ *   .build();
+ * ```
+ */
+declare function MapReduce(name: string, items?: readonly MapItemConfig[]): MapReduceBuilder;
 
-declare const WORKFLOWS_COMPILE_PATH = "/workflows/compile";
-type WorkflowsCompileRequestV0 = WorkflowSpecV0;
+type NDJSONDelayStep = {
+    delayMs: number;
+    line: string;
+};
+declare function buildNDJSONResponse(lines: string[], headers?: Record<string, string>, status?: number): Response;
+declare function buildDelayedNDJSONResponse(steps: NDJSONDelayStep[], headers?: Record<string, string>, status?: number): Response;
+type MockFetchCall = {
+    url: string;
+    init?: RequestInit;
+};
+type MockFetchResponder = Response | ((call: MockFetchCall, index: number) => Response | Promise<Response>);
+declare function createMockFetchQueue(responses: MockFetchResponder[]): {
+    fetch: typeof fetch;
+    calls: MockFetchCall[];
+};
 
 declare function parseApiKey(raw: string): ApiKey;
 declare function parsePublishableKey(raw: string): PublishableKey;
@@ -7554,13 +10168,13 @@ interface ToolRunnerOptions {
     /** Customer ID for attributed requests (optional). */
     customerId?: string;
     /** Called before executing each tool call (optional). */
-    onBeforeExecute?: (pending: PendingToolCallV0) => void | Promise<void>;
+    onBeforeExecute?: (pending: PendingToolCallV0$1) => void | Promise<void>;
     /** Called after each tool execution (optional). */
     onAfterExecute?: (result: ToolExecutionResult) => void | Promise<void>;
     /** Called when results are successfully submitted (optional). */
-    onSubmitted?: (runId: RunId, count: number, status: RunStatusV0) => void | Promise<void>;
+    onSubmitted?: (runId: RunId$1, count: number, status: RunStatusV0) => void | Promise<void>;
     /** Called when an error occurs during execution (optional). */
-    onError?: (error: Error, pending?: PendingToolCallV0) => void | Promise<void>;
+    onError?: (error: Error, pending?: PendingToolCallV0$1) => void | Promise<void>;
 }
 /** Response from handling a node_waiting event. */
 interface HandleWaitingResult {
@@ -7628,7 +10242,7 @@ declare class ToolRunner {
      * }
      * ```
      */
-    handleNodeWaiting(runId: RunId, nodeId: NodeId, waiting: NodeWaitingV0): Promise<HandleWaitingResult>;
+    handleNodeWaiting(runId: RunId$1, nodeId: NodeId$1, waiting: NodeWaitingV0$1): Promise<HandleWaitingResult>;
     /**
      * Processes a stream of run events, automatically handling node_waiting events.
      *
@@ -7659,7 +10273,7 @@ declare class ToolRunner {
      * }
      * ```
      */
-    processEvents(runId: RunId, events: AsyncIterable<RunEventV0>): AsyncGenerator<RunEventV0, void, undefined>;
+    processEvents(runId: RunId$1, events: AsyncIterable<RunEventV0>): AsyncGenerator<RunEventV0, void, undefined>;
     /**
      * Checks if a run event is a node_waiting event.
      * Utility for filtering events when not using processEvents().
@@ -7686,13 +10300,569 @@ declare class ToolRunner {
  */
 declare function createToolRunner(options: ToolRunnerOptions): ToolRunner;
 
-type index_$defs = $defs;
-type index_components = components;
-type index_operations = operations;
-type index_paths = paths;
-type index_webhooks = webhooks;
+type index$1_$defs = $defs;
+type index$1_components = components;
+type index$1_operations = operations;
+type index$1_paths = paths;
+type index$1_webhooks = webhooks;
+declare namespace index$1 {
+  export type { index$1_$defs as $defs, index$1_components as components, index$1_operations as operations, index$1_paths as paths, index$1_webhooks as webhooks };
+}
+
+/**
+ * Helper functions for constructing workflow.v1 conditions and bindings.
+ *
+ * These factory functions reduce boilerplate when building conditional edges
+ * and node bindings.
+ *
+ * @example
+ * ```typescript
+ * import { workflow, workflowV1 } from "@modelrelay/sdk";
+ * import { whenOutputEquals, bindToPlaceholder } from "@modelrelay/sdk/workflow";
+ *
+ * const spec = workflowV1()
+ *   .routeSwitch("router", request)
+ *   .llmResponses("billing", billingReq, {
+ *     bindings: [bindToPlaceholder("router", "route_data")]
+ *   })
+ *   .edge("router", "billing", whenOutputEquals("$.route", "billing"))
+ *   .build();
+ * ```
+ */
+
+/**
+ * Create a condition that matches when a node's output equals a specific value.
+ *
+ * @param path - JSONPath expression to extract the value (must start with $)
+ * @param value - The value to compare against
+ * @returns A condition for use in edge `when` clauses
+ *
+ * @example
+ * ```typescript
+ * builder.edge("router", "billing", whenOutputEquals("$.route", "billing"))
+ * ```
+ */
+declare function whenOutputEquals(path: string, value: unknown): ConditionV1$1;
+/**
+ * Create a condition that matches when a node's output matches a regex pattern.
+ *
+ * @param path - JSONPath expression to extract the value (must start with $)
+ * @param pattern - Regular expression pattern to match
+ * @returns A condition for use in edge `when` clauses
+ *
+ * @example
+ * ```typescript
+ * builder.edge("router", "handler", whenOutputMatches("$.category", "billing|support"))
+ * ```
+ */
+declare function whenOutputMatches(path: string, pattern: string): ConditionV1$1;
+/**
+ * Create a condition that matches when a path exists in the node's output.
+ *
+ * @param path - JSONPath expression to check for existence (must start with $)
+ * @returns A condition for use in edge `when` clauses
+ *
+ * @example
+ * ```typescript
+ * builder.edge("router", "handler", whenOutputExists("$.special_case"))
+ * ```
+ */
+declare function whenOutputExists(path: string): ConditionV1$1;
+/**
+ * Create a condition that matches when a node's status equals a specific value.
+ *
+ * @param path - JSONPath expression to extract the status value (must start with $)
+ * @param value - The status value to compare against
+ * @returns A condition for use in edge `when` clauses
+ *
+ * @example
+ * ```typescript
+ * builder.edge("node", "handler", whenStatusEquals("$.status", "succeeded"))
+ * ```
+ */
+declare function whenStatusEquals(path: string, value: unknown): ConditionV1$1;
+/**
+ * Create a condition that matches when a node's status matches a regex pattern.
+ *
+ * @param path - JSONPath expression to extract the status value (must start with $)
+ * @param pattern - Regular expression pattern to match
+ * @returns A condition for use in edge `when` clauses
+ */
+declare function whenStatusMatches(path: string, pattern: string): ConditionV1$1;
+/**
+ * Create a condition that matches when a path exists in the node's status.
+ *
+ * @param path - JSONPath expression to check for existence (must start with $)
+ * @returns A condition for use in edge `when` clauses
+ */
+declare function whenStatusExists(path: string): ConditionV1$1;
+/**
+ * Options for binding factory functions.
+ */
+interface BindingOptions {
+    /** JSON pointer to extract from the source node's output */
+    pointer?: string;
+    /** Encoding to use (defaults to "json_string") */
+    encoding?: LLMResponsesBindingEncodingV1;
+}
+/**
+ * Create a binding that injects a value into a {{placeholder}} in the prompt.
+ *
+ * @param from - Source node ID
+ * @param placeholder - Placeholder name (without the {{ }} delimiters)
+ * @param opts - Optional pointer and encoding settings
+ * @returns A binding for use in node input
+ *
+ * @example
+ * ```typescript
+ * builder.llmResponses("aggregate", request, {
+ *   bindings: [
+ *     bindToPlaceholder("join", "route_output"),
+ *     bindToPlaceholder("data", "user_data", { pointer: "/results" })
+ *   ]
+ * })
+ * ```
+ */
+declare function bindToPlaceholder(from: NodeId$1, placeholder: string, opts?: BindingOptions): LLMResponsesBindingV1;
+/**
+ * Create a binding that injects a value at a specific JSON pointer in the request.
+ *
+ * @param from - Source node ID
+ * @param to - JSON pointer in the request to inject the value
+ * @param opts - Optional pointer and encoding settings
+ * @returns A binding for use in node input
+ *
+ * @example
+ * ```typescript
+ * builder.llmResponses("processor", request, {
+ *   bindings: [
+ *     bindToPointer("source", "/input/0/content/0/text")
+ *   ]
+ * })
+ * ```
+ */
+declare function bindToPointer(from: NodeId$1, to: string, opts?: BindingOptions): LLMResponsesBindingV1;
+/**
+ * Create a binding from a source node with full control over all fields.
+ *
+ * @param from - Source node ID
+ * @returns A builder for fluent binding construction
+ *
+ * @example
+ * ```typescript
+ * const binding = bindFrom("source")
+ *   .pointer("/output/text")
+ *   .toPlaceholder("data")
+ *   .encoding("json")
+ *   .build();
+ * ```
+ */
+declare function bindFrom(from: NodeId$1): BindingBuilder;
+/**
+ * Fluent builder for constructing bindings.
+ */
+declare class BindingBuilder {
+    private _from;
+    private _pointer?;
+    private _to?;
+    private _toPlaceholder?;
+    private _encoding;
+    constructor(from: NodeId$1);
+    /**
+     * Set the source pointer to extract from the node's output.
+     */
+    pointer(ptr: string): BindingBuilder;
+    /**
+     * Set the destination JSON pointer in the request.
+     */
+    to(ptr: string): BindingBuilder;
+    /**
+     * Set the destination placeholder name.
+     */
+    toPlaceholder(name: string): BindingBuilder;
+    /**
+     * Set the encoding for the binding value.
+     */
+    encoding(enc: LLMResponsesBindingEncodingV1): BindingBuilder;
+    /**
+     * Build the binding object.
+     */
+    build(): LLMResponsesBindingV1;
+}
+
+/**
+ * High-level pattern builders for workflow.v1.
+ *
+ * These builders provide ergonomic construction of common workflow patterns
+ * like routing and fan-out/reduce, similar to the v0 Chain/Parallel/MapReduce patterns.
+ *
+ * @example
+ * ```typescript
+ * import { RouterV1, FanoutReduceV1 } from "@modelrelay/sdk/workflow";
+ *
+ * // Router pattern: classify input and route to specialized handlers
+ * const routerSpec = new RouterV1({
+ *   classifier: { model: "gpt-4o-mini", input: [...] },
+ *   routes: [
+ *     { value: "billing", handler: { model: "gpt-4o", input: [...] } },
+ *     { value: "support", handler: { model: "gpt-4o", input: [...] } },
+ *   ]
+ * }).build();
+ *
+ * // FanoutReduce pattern: generate items, process each, aggregate
+ * const fanoutSpec = new FanoutReduceV1({
+ *   generator: { model: "gpt-4o-mini", input: [...] },
+ *   itemsPath: "/questions",
+ *   mapperPlaceholder: "question",
+ *   mapper: { model: "gpt-4o", input: [...] },
+ *   reducer: { model: "gpt-4o", input: [...] },
+ * }).build();
+ * ```
+ */
+
+/**
+ * A route definition for the router pattern.
+ */
+interface RouterRouteV1 {
+    /** The value to match in the router output (at routePath) */
+    value: string;
+    /** The handler node ID (auto-generated if not provided) */
+    id?: NodeId$1;
+    /** The LLM request for this route's handler */
+    handler: WireResponsesRequest | ResponsesRequest;
+    /** Optional bindings for the handler */
+    bindings?: ReadonlyArray<LLMResponsesBindingV1>;
+}
+/**
+ * Configuration for the RouterV1 pattern builder.
+ */
+interface RouterConfigV1 {
+    /** Optional workflow name */
+    name?: string;
+    /** The classifier/router node configuration */
+    classifier: WireResponsesRequest | ResponsesRequest;
+    /** Optional classifier node ID (defaults to "router") */
+    classifierId?: NodeId$1;
+    /** JSONPath to extract the route value from classifier output (defaults to "$.route") */
+    routePath?: string;
+    /** Route definitions mapping values to handlers */
+    routes: RouterRouteV1[];
+    /** Optional aggregator node to combine results */
+    aggregator?: {
+        /** Aggregator node ID (defaults to "aggregate") */
+        id?: NodeId$1;
+        /** The LLM request for aggregation */
+        request: WireResponsesRequest | ResponsesRequest;
+        /** Placeholder name for injecting the routed result (defaults to "route_output") */
+        placeholder?: string;
+    };
+    /** Output name (defaults to "final") */
+    outputName?: OutputName$1;
+}
+/**
+ * Builder for the Router pattern in workflow.v1.
+ *
+ * The router pattern classifies input and routes to specialized handlers
+ * based on the classification result. A join.any node collects the first
+ * successful handler response.
+ *
+ * Topology:
+ * ```
+ * classifier --[when=billing]--> billing_handler --\
+ *            --[when=support]--> support_handler --> join.any --> [aggregator]
+ *            --[when=sales]--> sales_handler ----/
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const spec = new RouterV1({
+ *   classifier: {
+ *     model: "gpt-4o-mini",
+ *     input: [{ role: "user", content: "Classify: {{query}}" }]
+ *   },
+ *   routes: [
+ *     { value: "billing", handler: { model: "gpt-4o", input: [...] } },
+ *     { value: "support", handler: { model: "gpt-4o", input: [...] } },
+ *   ],
+ *   aggregator: {
+ *     request: { model: "gpt-4o", input: [...] },
+ *     placeholder: "route_output"
+ *   }
+ * }).build();
+ * ```
+ */
+declare class RouterV1 {
+    private readonly config;
+    constructor(config: RouterConfigV1);
+    /**
+     * Build the workflow specification.
+     */
+    build(): WorkflowSpecV1;
+}
+/**
+ * Configuration for the FanoutReduceV1 pattern builder.
+ */
+interface FanoutReduceConfigV1 {
+    /** Optional workflow name */
+    name?: string;
+    /** The generator node that produces items to process */
+    generator: WireResponsesRequest | ResponsesRequest;
+    /** Generator node ID (defaults to "generator") */
+    generatorId?: NodeId$1;
+    /** JSON Pointer to extract items array from generator output (defaults to "/items") */
+    itemsPath?: string;
+    /** The mapper subnode template (processes each item) */
+    mapper: WireResponsesRequest | ResponsesRequest;
+    /** Placeholder name for item injection in mapper (defaults to "item") */
+    mapperPlaceholder?: string;
+    /** Maximum parallel mapper executions (defaults to 4) */
+    maxParallelism?: number;
+    /** The reducer node that aggregates results */
+    reducer: WireResponsesRequest | ResponsesRequest;
+    /** Reducer node ID (defaults to "reducer") */
+    reducerId?: NodeId$1;
+    /** How to inject fanout results into reducer */
+    reducerBinding?: {
+        /** Pointer to extract from fanout output (defaults to "/results") */
+        pointer?: string;
+        /** Placeholder name for injection (uses to_placeholder if set) */
+        placeholder?: string;
+        /** JSON pointer for injection (uses to if set, defaults to user message text) */
+        to?: string;
+    };
+    /** Output name (defaults to "final") */
+    outputName?: OutputName$1;
+}
+/**
+ * Builder for the FanoutReduce pattern in workflow.v1.
+ *
+ * The fanout/reduce pattern generates a list of items, processes each item
+ * in parallel using a mapper node, then aggregates all results.
+ *
+ * Topology:
+ * ```
+ * generator --> map.fanout(mapper) --> reducer
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const spec = new FanoutReduceV1({
+ *   generator: {
+ *     model: "gpt-4o-mini",
+ *     input: [{ role: "user", content: "Generate 3 questions about {{topic}}" }]
+ *   },
+ *   itemsPath: "/questions",
+ *   mapperPlaceholder: "question",
+ *   mapper: {
+ *     model: "gpt-4o",
+ *     input: [{ role: "system", content: "Answer: {{question}}" }]
+ *   },
+ *   reducer: {
+ *     model: "gpt-4o",
+ *     input: [{ role: "system", content: "Combine answers: {{results}}" }]
+ *   },
+ *   reducerBinding: { placeholder: "results" },
+ *   maxParallelism: 4,
+ * }).build();
+ * ```
+ */
+declare class FanoutReduceV1 {
+    private readonly config;
+    constructor(config: FanoutReduceConfigV1);
+    /**
+     * Build the workflow specification.
+     */
+    build(): WorkflowSpecV1;
+}
+
+/**
+ * Workflow types with clean naming (no Workflow prefix).
+ *
+ * @example
+ * ```typescript
+ * import { workflow } from "@modelrelay/sdk";
+ *
+ * const spec: workflow.SpecV0 = {
+ *   kind: workflow.KindV0,
+ *   nodes: [{ id: "my_node", type: workflow.NodeTypes.LLMResponses, input: {...} }],
+ *   outputs: [],
+ * };
+ * ```
+ */
+
+type NodeId = NodeId$1;
+type OutputName = OutputName$1;
+type RunId = RunId$1;
+type PlanHash = PlanHash$1;
+
+type Kind = WorkflowKind;
+type SpecV0 = WorkflowSpecV0;
+type SpecV1 = WorkflowSpecV1;
+type NodeV0 = WorkflowNodeV0;
+type NodeV1 = WorkflowNodeV1;
+type EdgeV0 = WorkflowEdgeV0;
+type EdgeV1 = WorkflowEdgeV1;
+type OutputRefV0 = WorkflowOutputRefV0;
+type OutputRefV1 = WorkflowOutputRefV1;
+type BindingV0 = LLMResponsesBindingV0;
+type BindingV1 = LLMResponsesBindingV1;
+type BindingEncodingV0 = LLMResponsesBindingEncodingV0;
+type BindingEncodingV1 = LLMResponsesBindingEncodingV1;
+type ToolLimitsV0 = LLMResponsesToolLimitsV0;
+type ToolLimitsV1 = LLMResponsesToolLimitsV1;
+type ToolExecutionV0 = ToolExecutionV0$1;
+type ToolExecutionV1 = ToolExecutionV1$1;
+type ToolExecutionModeV0 = ToolExecutionModeV0$1;
+type ToolExecutionModeV1 = ToolExecutionModeV1$1;
+type ConditionV1 = ConditionV1$1;
+type ConditionOpV1 = ConditionOpV1$1;
+type ConditionSourceV1 = ConditionSourceV1$1;
+type StatusV0 = RunStatusV0;
+type EventTypeV0 = RunEventTypeV0;
+type EventV0 = RunEventV0;
+type EventBaseV0 = RunEventBaseV0;
+type EventRunCompiledV0 = RunEventRunCompiledV0;
+type EventRunStartedV0 = RunEventRunStartedV0;
+type EventRunCompletedV0 = RunEventRunCompletedV0;
+type EventRunFailedV0 = RunEventRunFailedV0;
+type EventRunCanceledV0 = RunEventRunCanceledV0;
+type EventNodeStartedV0 = RunEventNodeStartedV0;
+type EventNodeSucceededV0 = RunEventNodeSucceededV0;
+type EventNodeFailedV0 = RunEventNodeFailedV0;
+type EventNodeLLMCallV0 = RunEventNodeLLMCallV0;
+type EventNodeToolCallV0 = RunEventNodeToolCallV0;
+type EventNodeToolResultV0 = RunEventNodeToolResultV0;
+type EventNodeWaitingV0 = RunEventNodeWaitingV0;
+type EventNodeOutputDeltaV0 = RunEventNodeOutputDeltaV0;
+type EventNodeOutputV0 = RunEventNodeOutputV0;
+type NodeErrorV0 = NodeErrorV0$1;
+type NodeOutputDeltaV0 = NodeOutputDeltaV0$1;
+type NodeLLMCallV0 = NodeLLMCallV0$1;
+type NodeToolCallV0 = NodeToolCallV0$1;
+type NodeToolResultV0 = NodeToolResultV0$1;
+type NodeWaitingV0 = NodeWaitingV0$1;
+type PendingToolCallV0 = PendingToolCallV0$1;
+type FunctionToolCallV0 = FunctionToolCallV0$1;
+type TokenUsageV0 = TokenUsageV0$1;
+type PayloadInfoV0 = PayloadInfoV0$1;
+type StreamEventKind = StreamEventKind$1;
+declare const KindV0: "workflow.v0";
+declare const KindV1: "workflow.v1";
+declare const NodeTypes: {
+    readonly LLMResponses: "llm.responses";
+    readonly JoinAll: "join.all";
+    readonly TransformJSON: "transform.json";
+};
+type NodeType = (typeof NodeTypes)[keyof typeof NodeTypes];
+declare const NodeTypesV1: {
+    readonly LLMResponses: "llm.responses";
+    readonly RouteSwitch: "route.switch";
+    readonly JoinAll: "join.all";
+    readonly JoinAny: "join.any";
+    readonly JoinCollect: "join.collect";
+    readonly TransformJSON: "transform.json";
+    readonly MapFanout: "map.fanout";
+};
+type NodeTypeV1 = (typeof NodeTypesV1)[keyof typeof NodeTypesV1];
+declare const BindingEncodings: {
+    readonly JSON: "json";
+    readonly JSONString: "json_string";
+};
+declare const ToolExecutionModes: {
+    readonly Server: "server";
+    readonly Client: "client";
+};
+
+type index_BindingBuilder = BindingBuilder;
+declare const index_BindingBuilder: typeof BindingBuilder;
+type index_BindingEncodingV0 = BindingEncodingV0;
+type index_BindingEncodingV1 = BindingEncodingV1;
+declare const index_BindingEncodings: typeof BindingEncodings;
+type index_BindingOptions = BindingOptions;
+type index_BindingV0 = BindingV0;
+type index_BindingV1 = BindingV1;
+type index_ConditionOpV1 = ConditionOpV1;
+type index_ConditionSourceV1 = ConditionSourceV1;
+type index_ConditionV1 = ConditionV1;
+type index_EdgeV0 = EdgeV0;
+type index_EdgeV1 = EdgeV1;
+type index_EventBaseV0 = EventBaseV0;
+type index_EventNodeFailedV0 = EventNodeFailedV0;
+type index_EventNodeLLMCallV0 = EventNodeLLMCallV0;
+type index_EventNodeOutputDeltaV0 = EventNodeOutputDeltaV0;
+type index_EventNodeOutputV0 = EventNodeOutputV0;
+type index_EventNodeStartedV0 = EventNodeStartedV0;
+type index_EventNodeSucceededV0 = EventNodeSucceededV0;
+type index_EventNodeToolCallV0 = EventNodeToolCallV0;
+type index_EventNodeToolResultV0 = EventNodeToolResultV0;
+type index_EventNodeWaitingV0 = EventNodeWaitingV0;
+type index_EventRunCanceledV0 = EventRunCanceledV0;
+type index_EventRunCompiledV0 = EventRunCompiledV0;
+type index_EventRunCompletedV0 = EventRunCompletedV0;
+type index_EventRunFailedV0 = EventRunFailedV0;
+type index_EventRunStartedV0 = EventRunStartedV0;
+type index_EventTypeV0 = EventTypeV0;
+type index_EventV0 = EventV0;
+type index_FanoutReduceConfigV1 = FanoutReduceConfigV1;
+type index_FanoutReduceV1 = FanoutReduceV1;
+declare const index_FanoutReduceV1: typeof FanoutReduceV1;
+type index_FunctionToolCallV0 = FunctionToolCallV0;
+type index_Kind = Kind;
+declare const index_KindV0: typeof KindV0;
+declare const index_KindV1: typeof KindV1;
+declare const index_LLM_TEXT_OUTPUT: typeof LLM_TEXT_OUTPUT;
+declare const index_LLM_USER_MESSAGE_TEXT: typeof LLM_USER_MESSAGE_TEXT;
+type index_NodeErrorV0 = NodeErrorV0;
+type index_NodeId = NodeId;
+type index_NodeLLMCallV0 = NodeLLMCallV0;
+type index_NodeOutputDeltaV0 = NodeOutputDeltaV0;
+type index_NodeToolCallV0 = NodeToolCallV0;
+type index_NodeToolResultV0 = NodeToolResultV0;
+type index_NodeType = NodeType;
+type index_NodeTypeV1 = NodeTypeV1;
+declare const index_NodeTypes: typeof NodeTypes;
+declare const index_NodeTypesV1: typeof NodeTypesV1;
+type index_NodeV0 = NodeV0;
+type index_NodeV1 = NodeV1;
+type index_NodeWaitingV0 = NodeWaitingV0;
+type index_OutputName = OutputName;
+type index_OutputRefV0 = OutputRefV0;
+type index_OutputRefV1 = OutputRefV1;
+type index_PayloadInfoV0 = PayloadInfoV0;
+type index_PendingToolCallV0 = PendingToolCallV0;
+type index_PlanHash = PlanHash;
+type index_RouterConfigV1 = RouterConfigV1;
+type index_RouterRouteV1 = RouterRouteV1;
+type index_RouterV1 = RouterV1;
+declare const index_RouterV1: typeof RouterV1;
+type index_RunId = RunId;
+type index_SpecV0 = SpecV0;
+type index_SpecV1 = SpecV1;
+type index_StatusV0 = StatusV0;
+type index_StreamEventKind = StreamEventKind;
+type index_TokenUsageV0 = TokenUsageV0;
+type index_ToolExecutionModeV0 = ToolExecutionModeV0;
+type index_ToolExecutionModeV1 = ToolExecutionModeV1;
+declare const index_ToolExecutionModes: typeof ToolExecutionModes;
+type index_ToolExecutionV0 = ToolExecutionV0;
+type index_ToolExecutionV1 = ToolExecutionV1;
+type index_ToolLimitsV0 = ToolLimitsV0;
+type index_ToolLimitsV1 = ToolLimitsV1;
+declare const index_bindFrom: typeof bindFrom;
+declare const index_bindToPlaceholder: typeof bindToPlaceholder;
+declare const index_bindToPointer: typeof bindToPointer;
+declare const index_parseNodeId: typeof parseNodeId;
+declare const index_parseOutputName: typeof parseOutputName;
+declare const index_parsePlanHash: typeof parsePlanHash;
+declare const index_parseRunId: typeof parseRunId;
+declare const index_whenOutputEquals: typeof whenOutputEquals;
+declare const index_whenOutputExists: typeof whenOutputExists;
+declare const index_whenOutputMatches: typeof whenOutputMatches;
+declare const index_whenStatusEquals: typeof whenStatusEquals;
+declare const index_whenStatusExists: typeof whenStatusExists;
+declare const index_whenStatusMatches: typeof whenStatusMatches;
 declare namespace index {
-  export type { index_$defs as $defs, index_components as components, index_operations as operations, index_paths as paths, index_webhooks as webhooks };
+  export { index_BindingBuilder as BindingBuilder, type index_BindingEncodingV0 as BindingEncodingV0, type index_BindingEncodingV1 as BindingEncodingV1, index_BindingEncodings as BindingEncodings, type index_BindingOptions as BindingOptions, type index_BindingV0 as BindingV0, type index_BindingV1 as BindingV1, type index_ConditionOpV1 as ConditionOpV1, type index_ConditionSourceV1 as ConditionSourceV1, type index_ConditionV1 as ConditionV1, type index_EdgeV0 as EdgeV0, type index_EdgeV1 as EdgeV1, type index_EventBaseV0 as EventBaseV0, type index_EventNodeFailedV0 as EventNodeFailedV0, type index_EventNodeLLMCallV0 as EventNodeLLMCallV0, type index_EventNodeOutputDeltaV0 as EventNodeOutputDeltaV0, type index_EventNodeOutputV0 as EventNodeOutputV0, type index_EventNodeStartedV0 as EventNodeStartedV0, type index_EventNodeSucceededV0 as EventNodeSucceededV0, type index_EventNodeToolCallV0 as EventNodeToolCallV0, type index_EventNodeToolResultV0 as EventNodeToolResultV0, type index_EventNodeWaitingV0 as EventNodeWaitingV0, type index_EventRunCanceledV0 as EventRunCanceledV0, type index_EventRunCompiledV0 as EventRunCompiledV0, type index_EventRunCompletedV0 as EventRunCompletedV0, type index_EventRunFailedV0 as EventRunFailedV0, type index_EventRunStartedV0 as EventRunStartedV0, type index_EventTypeV0 as EventTypeV0, type index_EventV0 as EventV0, type index_FanoutReduceConfigV1 as FanoutReduceConfigV1, index_FanoutReduceV1 as FanoutReduceV1, type index_FunctionToolCallV0 as FunctionToolCallV0, type index_Kind as Kind, index_KindV0 as KindV0, index_KindV1 as KindV1, index_LLM_TEXT_OUTPUT as LLM_TEXT_OUTPUT, index_LLM_USER_MESSAGE_TEXT as LLM_USER_MESSAGE_TEXT, type index_NodeErrorV0 as NodeErrorV0, type index_NodeId as NodeId, type index_NodeLLMCallV0 as NodeLLMCallV0, type index_NodeOutputDeltaV0 as NodeOutputDeltaV0, type index_NodeToolCallV0 as NodeToolCallV0, type index_NodeToolResultV0 as NodeToolResultV0, type index_NodeType as NodeType, type index_NodeTypeV1 as NodeTypeV1, index_NodeTypes as NodeTypes, index_NodeTypesV1 as NodeTypesV1, type index_NodeV0 as NodeV0, type index_NodeV1 as NodeV1, type index_NodeWaitingV0 as NodeWaitingV0, type index_OutputName as OutputName, type index_OutputRefV0 as OutputRefV0, type index_OutputRefV1 as OutputRefV1, type index_PayloadInfoV0 as PayloadInfoV0, type index_PendingToolCallV0 as PendingToolCallV0, type index_PlanHash as PlanHash, type index_RouterConfigV1 as RouterConfigV1, type index_RouterRouteV1 as RouterRouteV1, index_RouterV1 as RouterV1, type index_RunId as RunId, type index_SpecV0 as SpecV0, type index_SpecV1 as SpecV1, type index_StatusV0 as StatusV0, type index_StreamEventKind as StreamEventKind, type index_TokenUsageV0 as TokenUsageV0, type index_ToolExecutionModeV0 as ToolExecutionModeV0, type index_ToolExecutionModeV1 as ToolExecutionModeV1, index_ToolExecutionModes as ToolExecutionModes, type index_ToolExecutionV0 as ToolExecutionV0, type index_ToolExecutionV1 as ToolExecutionV1, type index_ToolLimitsV0 as ToolLimitsV0, type index_ToolLimitsV1 as ToolLimitsV1, index_bindFrom as bindFrom, index_bindToPlaceholder as bindToPlaceholder, index_bindToPointer as bindToPointer, index_parseNodeId as parseNodeId, index_parseOutputName as parseOutputName, index_parsePlanHash as parsePlanHash, index_parseRunId as parseRunId, index_whenOutputEquals as whenOutputEquals, index_whenOutputExists as whenOutputExists, index_whenOutputMatches as whenOutputMatches, index_whenStatusEquals as whenStatusEquals, index_whenStatusExists as whenStatusExists, index_whenStatusMatches as whenStatusMatches };
 }
 
 /**
@@ -7740,6 +10910,8 @@ declare class ModelRelay {
     readonly models: ModelsClient;
     readonly sessions: SessionsClient;
     readonly baseUrl: string;
+    /** @internal HTTP client for internal use by session sync */
+    readonly http: HTTPClient;
     static fromSecretKey(secretKey: string, options?: Omit<ModelRelayKeyOptions, "key">): ModelRelay;
     static fromPublishableKey(publishableKey: string, options?: Omit<ModelRelayKeyOptions, "key">): ModelRelay;
     static fromApiKey(apiKey: string, options?: Omit<ModelRelayKeyOptions, "key">): ModelRelay;
@@ -7747,4 +10919,4 @@ declare class ModelRelay {
     forCustomer(customerId: string): CustomerScopedModelRelay;
 }
 
-export { type APICheckoutSession, type APICustomerRef, APIError, type APIFrontendToken, type APIKey, type APIResponsesResponse, type APIUsage, type ApiKey, type AttemptRecord, AuthClient, type AuthHeaders, type BillingProvider, BillingProviders, BrowserDefaults, BrowserToolNames, BrowserToolPack, type BrowserToolPackOptions, type CatalogModel, type CheckoutSession, type Citation, type CodeExecConfig, ConfigError, type ContentPart, type ContentPartType, ContentPartTypes, type Customer, type CustomerClaimRequest, type CustomerCreateRequest, type CustomerMetadata, CustomerResponsesClient, CustomerScopedModelRelay, type CustomerSubscribeRequest, type CustomerToken, CustomerTokenProvider, type CustomerTokenRequest, type CustomerUpsertRequest, type CustomerWithSubscription, CustomersClient, DEFAULT_BASE_URL, DEFAULT_CLIENT_HEADER, DEFAULT_CONNECT_TIMEOUT_MS, DEFAULT_IGNORE_DIRS, DEFAULT_REQUEST_TIMEOUT_MS, type DeepPartial, type DeviceStartRequest, type DeviceStartResponse, type DeviceTokenPending, type DeviceTokenResponse, type DeviceTokenResult, type ErrorCategory, type ErrorCode, ErrorCodes, FSDefaults, ToolNames as FSToolNames, type FieldError, type FrontendCustomer, type FrontendToken, type FrontendTokenAutoProvisionRequest, FrontendTokenProvider, type FrontendTokenRequest, type FunctionCall, type FunctionCallDelta, type FunctionTool, type HandleWaitingResult, type HttpRequestMetrics, type ImageData, type ImageRequest, type ImageResponse, type ImageResponseFormat, type ImageUsage, ImagesClient, type InputItem, type InputItemType, InputItemTypes, type JSONSchemaFormat, type JsonSchemaOptions, type KnownStopReason, type ListSessionsOptions, type ListSessionsResponse, LocalFSToolPack, type LocalFSToolPackOptions, LocalSession, type LocalSessionOptions, type LocalSessionPersistence, MemorySessionStore, type MessageDeltaData, type MessageRole, MessageRoles, type MessageStartData, type MessageStopData, type MetricsCallbacks, type ModelCapability, type ModelId, ModelRelay, type ModelRelayBaseOptions, ModelRelayError, type ModelRelayKeyOptions, type ModelRelayOptions, type ModelRelayTokenOptions, type ModelRelayTokenProviderOptions, ModelsClient, type NodeErrorV0, type NodeId, type NonEmptyArray, type OAuthDeviceAuthorization, type OAuthDeviceAuthorizationRequest, type OAuthDeviceToken, type OAuthDeviceTokenPollRequest, type OIDCExchangeRequest, OIDCExchangeTokenProvider, type OutputFormat, type OutputFormatType, OutputFormatTypes, type OutputItem, type OutputItemType, OutputItemTypes, type OutputName, PathEscapeError, type PayloadInfoV0, type PlanHash, type PriceInterval, type Project, type ProviderId, type PublishableKey, type RemoteSessionInfo, type RemoteSessionOptions, type RequestContext, type Response$1 as Response, type ResponseEvent, type ResponseEventType, ResponsesClient, ResponsesStream, type RetryConfig, type RetryHandler, type RetryMetadata, type RetryOptions, type RunEventTypeV0, type RunEventV0, type RunId, type RunStatusV0, RunsClient, RunsEventStream, SDK_VERSION, type Schema, type SecretKey, type Session, type SessionArtifacts, type SessionId, type SessionMessage, type SessionPendingToolCall, type SessionRunOptions, type SessionRunResult, type SessionRunStatus, type SessionState, type SessionStore, type SessionType, type SessionUsageSummary, SessionsClient, type StopReason, StopReasons, type StreamFirstTokenMetrics, StreamProtocolError, StreamTimeoutError, type StreamTimeoutKind, StructuredDecodeError, type StructuredErrorKind, StructuredExhaustedError, type StructuredJSONEvent, type StructuredJSONRecordType, StructuredJSONStream, type StructuredOptions, type StructuredResult, type Subscription, type SubscriptionStatusKind, SubscriptionStatuses, type Tier, type TierCheckoutRequest, type TierCheckoutSession, type TierCode, TiersClient, type TokenProvider, type TokenType, type TokenUsageMetrics, type Tool, ToolArgsError, ToolArgumentError, type ToolCall, ToolCallAccumulator, type ToolCallDelta, type ToolChoice, type ToolChoiceType, ToolChoiceTypes, type ToolExecutionResult, type ToolHandler, ToolRegistry, ToolRunner, type ToolRunnerOptions, type ToolType, ToolTypes, type TraceCallbacks, type TransformJSONValueV0, TransportError, type TransportErrorKind, type Usage, type UsageSummary, type ValidationIssue, WORKFLOWS_COMPILE_PATH, type WebSearchConfig, type WebToolMode, WebToolModes, WorkflowBuilderV0, type WorkflowBuilderV0State, type WorkflowEdgeV0, type WorkflowKind, WorkflowKinds, type WorkflowNodeType, WorkflowNodeTypes, type WorkflowNodeV0, type WorkflowOutputRefV0, type WorkflowSpecV0, WorkflowValidationError, type WorkflowValidationIssue, WorkflowsClient, type WorkflowsCompileOptions, type WorkflowsCompileRequestV0, type WorkflowsCompileResponseV0, type WorkflowsCompileV0Result, type XSearchConfig, type ZodLikeSchema, asModelId, asProviderId, asSessionId, asTierCode, assistantMessageWithToolCalls, createAccessTokenAuth, createApiKeyAuth, createAssistantMessage, createBrowserToolPack, createBrowserTools, createFunctionCall, createFunctionTool, createFunctionToolFromSchema, createLocalFSToolPack, createLocalFSTools, createLocalSession, createMemorySessionStore, createRetryMessages, createSystemMessage, createToolCall, createToolRunner, createUsage, createUserMessage, createWebTool, defaultRetryHandler, executeWithRetry, firstToolCall, formatToolErrorForModel, generateSessionId, index as generated, getRetryableErrors, hasRetryableErrors, hasToolCalls, isAutoProvisionDisabled, isAutoProvisionMisconfigured, isEmailRequired, isIdentityRequired, isProvisioningError, isPublishableKey, isSecretKey, mergeMetrics, mergeTrace, modelToString, normalizeModelId, normalizeStopReason, outputFormatFromZod, parseApiKey, parseErrorResponse, parseNodeId, parseOutputName, parsePlanHash, parsePublishableKey, parseRunId, parseSecretKey, parseToolArgs, parseToolArgsRaw, pollOAuthDeviceToken, respondToToolCall, runOAuthDeviceFlowForIDToken, startOAuthDeviceAuthorization, stopReasonToString, toolChoiceAuto, toolChoiceNone, toolChoiceRequired, toolResultMessage, transformJSONMerge, transformJSONObject, transformJSONValue, tryParseToolArgs, validateWithZod, workflowV0, workflow_v0_schema as workflowV0Schema, zodToJsonSchema };
+export { type APICheckoutSession, type APICustomerRef, APIError, type APIFrontendToken, type APIKey, type APIResponsesResponse, type APIUsage, type ApiKey, type AttemptRecord, AuthClient, type AuthHeaders, type BillingProvider, BillingProviders, BindingTargetError, BrowserDefaults, BrowserToolNames, BrowserToolPack, type BrowserToolPackOptions, type CatalogModel, Chain, ChainBuilder, type CheckoutSession, type Citation, type CodeExecConfig, ConfigError, type ContentPart, type ContentPartType, ContentPartTypes, type Customer, type CustomerClaimRequest, type CustomerCreateRequest, type CustomerMetadata, CustomerResponsesClient, CustomerScopedModelRelay, type CustomerSubscribeRequest, type CustomerToken, CustomerTokenProvider, type CustomerTokenRequest, type CustomerUpsertRequest, type CustomerWithSubscription, CustomersClient, DEFAULT_BASE_URL, DEFAULT_CLIENT_HEADER, DEFAULT_CONNECT_TIMEOUT_MS, DEFAULT_IGNORE_DIRS, DEFAULT_REQUEST_TIMEOUT_MS, type DeepPartial, type DeviceStartRequest, type DeviceStartResponse, type DeviceTokenPending, type DeviceTokenResponse, type DeviceTokenResult, type ErrorCategory, type ErrorCode, ErrorCodes, FSDefaults, ToolNames as FSToolNames, type FieldError, type FrontendCustomer, type FrontendToken, type FrontendTokenAutoProvisionRequest, FrontendTokenProvider, type FrontendTokenRequest, type FunctionCall, type FunctionCallDelta, type FunctionTool, type HandleWaitingResult, type HttpRequestMetrics, type ImageData, type ImagePinResponse, type ImageRequest, type ImageResponse, type ImageResponseFormat, type ImageUsage, ImagesClient, type InputItem, type InputItemType, InputItemTypes, type JSONPointer, type JSONSchemaFormat, JoinOutput, JoinOutputPath, type JsonSchemaOptions, type KnownStopReason, LLMInput, LLMInputContentItemPath, LLMInputFirstMessageText, LLMInputMessagePath, LLMInputPath, LLMInputSystemText, LLMInputUserText, LLMNodeBuilder, LLMOutput, LLMOutputContentItemPath, LLMOutputContentPath, LLMOutputPath, LLMOutputText, LLMStep, type LLMStepConfig, LLM_TEXT_OUTPUT, LLM_USER_MESSAGE_TEXT, type ListSessionsOptions, type ListSessionsResponse, LocalFSToolPack, type LocalFSToolPackOptions, LocalSession, type LocalSessionOptions, type LocalSessionPersistence, MapFanoutInputError, MapItem, type MapItemConfig, MapReduce, MapReduceBuilder, MemorySessionStore, type MessageDeltaData, type MessageRole, MessageRoles, type MessageStartData, type MessageStopData, type MetricsCallbacks, type MockFetchCall, type MockFetchResponder, type ModelCapability, type ModelId, ModelRelay, type ModelRelayBaseOptions, ModelRelayError, type ModelRelayKeyOptions, type ModelRelayOptions, type ModelRelayTokenOptions, type ModelRelayTokenProviderOptions, ModelsClient, type NDJSONDelayStep, type NodeErrorV0$1 as NodeErrorV0, type NodeId$1 as NodeId, type NonEmptyArray, type OAuthDeviceAuthorization, type OAuthDeviceAuthorizationRequest, type OAuthDeviceToken, type OAuthDeviceTokenPollRequest, type OIDCExchangeRequest, OIDCExchangeTokenProvider, type OutputFormat, type OutputFormatType, OutputFormatTypes, type OutputItem, type OutputItemType, OutputItemTypes, type OutputName$1 as OutputName, Parallel, ParallelBuilder, PathEscapeError, type PayloadInfoV0$1 as PayloadInfoV0, type PlanHash$1 as PlanHash, type PollUntilOptions, type PollUntilResult, type PriceInterval, type Project, type ProviderId, type PublishableKey, type RemoteSessionInfo, type RemoteSessionOptions, type RequestContext, type Response$1 as Response, type ResponseEvent, type ResponseEventType, ResponsesClient, ResponsesStream, type RetryConfig, type RetryHandler, type RetryMetadata, type RetryOptions, type RunEventTypeV0, type RunEventV0, type RunId$1 as RunId, type RunStatusV0, RunsClient, RunsEventStream, SDK_VERSION, type Schema, type SecretKey, type Session, type SessionArtifacts, type SessionContextManagement, type SessionContextTruncateInfo, type SessionId, type SessionMessage, type SessionPendingToolCall, type SessionRunOptions, type SessionRunResult, type SessionRunStatus, type SessionState, type SessionStore, type SessionSyncOptions, type SessionSyncResult, type SessionType, type SessionUsageSummary, SessionsClient, type StopReason, StopReasons, type StreamFirstTokenMetrics, StreamProtocolError, StreamTimeoutError, type StreamTimeoutKind, StructuredDecodeError, type StructuredErrorKind, StructuredExhaustedError, type StructuredJSONEvent, type StructuredJSONRecordType, StructuredJSONStream, type StructuredOptions, type StructuredResult, type Subscription, type SubscriptionStatusKind, SubscriptionStatuses, type Tier, type TierCheckoutRequest, type TierCheckoutSession, type TierCode, TiersClient, type TokenProvider, type TokenType, type TokenUsageMetrics, type Tool, ToolArgsError, ToolArgumentError, type ToolCall, ToolCallAccumulator, type ToolCallDelta, type ToolChoice, type ToolChoiceType, ToolChoiceTypes, type ToolExecutionResult, type ToolHandler, ToolRegistry, ToolRunner, type ToolRunnerOptions, type ToolType, ToolTypes, type TraceCallbacks, TransformJSONNodeBuilder, type TransformJSONValueV0, type TransformJSONValueV1, TransportError, type TransportErrorKind, type Usage, type UsageSummary, type ValidationIssue, WORKFLOWS_COMPILE_PATH, type WebSearchConfig, type WebToolMode, WebToolModes, Workflow, WorkflowBuilderV0, type WorkflowBuilderV0State, WorkflowBuilderV1, type WorkflowBuilderV1State, type WorkflowEdgeV0, type WorkflowKind, WorkflowKinds, type WorkflowNodeType, WorkflowNodeTypes, type WorkflowNodeV0, type WorkflowOutputRefV0, type WorkflowSpecV0, WorkflowValidationError, type WorkflowValidationIssue, WorkflowsClient, type WorkflowsCompileOptions, type WorkflowsCompileRequestV0, type WorkflowsCompileRequestV1, type WorkflowsCompileResponseV0, type WorkflowsCompileResponseV1, type WorkflowsCompileV0Result, type WorkflowsCompileV1Result, type XSearchConfig, type ZodLikeSchema, asModelId, asProviderId, asSessionId, asTierCode, assistantMessageWithToolCalls, buildDelayedNDJSONResponse, buildNDJSONResponse, createAccessTokenAuth, createApiKeyAuth, createAssistantMessage, createBrowserToolPack, createBrowserTools, createFunctionCall, createFunctionTool, createFunctionToolFromSchema, createLocalFSToolPack, createLocalFSTools, createLocalSession, createMemorySessionStore, createMockFetchQueue, createRetryMessages, createSystemMessage, createToolCall, createToolRunner, createUsage, createUserMessage, createWebTool, defaultRetryHandler, executeWithRetry, firstToolCall, formatToolErrorForModel, generateSessionId, index$1 as generated, getRetryableErrors, hasRetryableErrors, hasToolCalls, isAutoProvisionDisabled, isAutoProvisionMisconfigured, isEmailRequired, isIdentityRequired, isProvisioningError, isPublishableKey, isSecretKey, mergeMetrics, mergeTrace, modelToString, newWorkflow, normalizeModelId, normalizeStopReason, outputFormatFromZod, parseApiKey, parseErrorResponse, parseNodeId, parseOutputName, parsePlanHash, parsePublishableKey, parseRunId, parseSecretKey, parseToolArgs, parseToolArgsRaw, pollOAuthDeviceToken, pollUntil, respondToToolCall, runOAuthDeviceFlowForIDToken, startOAuthDeviceAuthorization, stopReasonToString, toolChoiceAuto, toolChoiceNone, toolChoiceRequired, toolResultMessage, transformJSONMerge, transformJSONMergeV1, transformJSONObject, transformJSONObjectV1, transformJSONValue, transformJSONValueV1, tryParseToolArgs, validateWithZod, index as workflow, workflowV0, workflow_v0_schema as workflowV0Schema, workflowV1, workflow_v1_schema as workflowV1Schema, zodToJsonSchema };