@modelrelay/sdk 1.10.3 → 1.14.0

package/dist/index.d.ts

@@ -1766,25 +1766,25 @@ 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";
@@ -1809,52 +1809,52 @@ 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;
     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;
@@ -1862,147 +1862,147 @@ type LLMResponsesToolLimitsV0 = {
     wait_ttl_ms?: number;
 };
 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 +2016,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 +2029,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 +2054,7 @@ type RunCostLineItemV0 = {
     usd_cents: number;
 };
 type NodeResultV0 = {
-    id: NodeId;
+    id: NodeId$1;
     type: string;
     status: NodeStatusV0;
     started_at?: string;
@@ -2177,11 +2177,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>;
 }
 
 /**
@@ -2385,7 +2385,7 @@ type WorkflowsCompileOptions = {
 };
 type WorkflowsCompileResponseV0 = {
     plan_json: unknown;
-    plan_hash: PlanHash;
+    plan_hash: PlanHash$1;
 };
 type WorkflowsCompileV0Result = ({
     ok: true;
@@ -3170,6 +3170,28 @@ interface paths {
         patch?: never;
         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;
+    };
 }
 type webhooks = Record<string, never>;
 interface components {
@@ -4067,6 +4089,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"];
         };
         /**
@@ -4192,6 +4219,20 @@ 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;
+        };
     };
     responses: never;
     parameters: {
@@ -5750,6 +5791,53 @@ interface operations {
             };
         };
     };
+    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;
+            };
+        };
+    };
 }
 
 /**
@@ -6131,7 +6219,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.).
@@ -6189,7 +6277,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. */
@@ -6477,6 +6565,7 @@ declare class RemoteSession implements Session {
     private nextSeq;
     private createdAt;
     private updatedAt;
+    private pendingMessages;
     private currentRunId?;
     private currentNodeId?;
     private currentWaiting?;
@@ -6551,6 +6640,8 @@ declare class RemoteSession implements Session {
     private resetRunState;
     private processRunEvents;
     private executeToolsLocally;
+    private flushPendingMessages;
+    private appendMessageToServer;
 }
 
 /**
@@ -6816,11 +6907,19 @@ declare function runOAuthDeviceFlowForIDToken(cfg: {
     signal?: AbortSignal;
 }): Promise<string>;
 
+/**
+ * Semantic JSON pointer constants for LLM responses nodes.
+ * These eliminate magic strings and make bindings self-documenting.
+ */
+/** JSON pointer to extract text content from an LLM response output. */
+declare const LLM_TEXT_OUTPUT$1: "/output/0/content/0/text";
+/** JSON pointer to inject text into the user message of an LLM request. */
+declare const LLM_USER_MESSAGE_TEXT$1: "/request/input/1/content/0/text";
 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>;
 };
@@ -6842,21 +6941,180 @@ declare class WorkflowBuilderV0 {
     name(name: string): WorkflowBuilderV0;
     execution(execution: WorkflowSpecV0["execution"]): WorkflowBuilderV0;
     node(node: WorkflowNodeV0): WorkflowBuilderV0;
-    llmResponses(id: NodeId, request: WireResponsesRequest | ResponsesRequest, options?: {
+    llmResponses(id: NodeId$1, request: WireResponsesRequest | ResponsesRequest, options?: {
         stream?: boolean;
-        toolExecution?: ToolExecutionModeV0;
+        toolExecution?: ToolExecutionModeV0$1;
         toolLimits?: LLMResponsesToolLimitsV0;
         bindings?: ReadonlyArray<LLMResponsesBindingV0>;
     }): WorkflowBuilderV0;
-    joinAll(id: NodeId): WorkflowBuilderV0;
-    transformJSON(id: NodeId, input: Extract<WorkflowNodeV0, {
+    joinAll(id: NodeId$1): WorkflowBuilderV0;
+    transformJSON(id: NodeId$1, input: Extract<WorkflowNodeV0, {
         type: typeof WorkflowNodeTypes.TransformJSON;
     }>["input"]): WorkflowBuilderV0;
-    edge(from: NodeId, to: NodeId): WorkflowBuilderV0;
-    output(name: OutputName, from: NodeId, pointer?: string): 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 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;
+    /**
+     * 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;
 
 var $id = "https://modelrelay.ai/schemas/workflow_v0.schema.json";
 var $schema = "http://json-schema.org/draft-07/schema#";
@@ -7185,6 +7443,288 @@ var workflow_v0_schema = {
 declare const WORKFLOWS_COMPILE_PATH = "/workflows/compile";
 type WorkflowsCompileRequestV0 = WorkflowSpecV0;
 
+/**
+ * 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 function parseApiKey(raw: string): ApiKey;
 declare function parsePublishableKey(raw: string): PublishableKey;
 declare function parseSecretKey(raw: string): SecretKey;
@@ -7554,13 +8094,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 +8168,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 +8199,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 +8226,150 @@ 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 };
+}
+
+/**
+ * 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 NodeV0 = WorkflowNodeV0;
+type EdgeV0 = WorkflowEdgeV0;
+type OutputRefV0 = WorkflowOutputRefV0;
+type BindingV0 = LLMResponsesBindingV0;
+type BindingEncodingV0 = LLMResponsesBindingEncodingV0;
+type ToolLimitsV0 = LLMResponsesToolLimitsV0;
+type ToolExecutionV0 = ToolExecutionV0$1;
+type ToolExecutionModeV0 = ToolExecutionModeV0$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 NodeTypes: {
+    readonly LLMResponses: "llm.responses";
+    readonly JoinAll: "join.all";
+    readonly TransformJSON: "transform.json";
+};
+type NodeType = (typeof NodeTypes)[keyof typeof NodeTypes];
+declare const BindingEncodings: {
+    readonly JSON: "json";
+    readonly JSONString: "json_string";
+};
+declare const ToolExecutionModes: {
+    readonly Server: "server";
+    readonly Client: "client";
+};
+/** JSON pointer to extract text content from an LLM response output. */
+declare const LLM_TEXT_OUTPUT = "/output/0/content/0/text";
+/** JSON pointer to inject text into the user message of an LLM request. */
+declare const LLM_USER_MESSAGE_TEXT = "/request/input/1/content/0/text";
+
+type index_BindingEncodingV0 = BindingEncodingV0;
+declare const index_BindingEncodings: typeof BindingEncodings;
+type index_BindingV0 = BindingV0;
+type index_EdgeV0 = EdgeV0;
+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_FunctionToolCallV0 = FunctionToolCallV0;
+type index_Kind = Kind;
+declare const index_KindV0: typeof KindV0;
+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;
+declare const index_NodeTypes: typeof NodeTypes;
+type index_NodeV0 = NodeV0;
+type index_NodeWaitingV0 = NodeWaitingV0;
+type index_OutputName = OutputName;
+type index_OutputRefV0 = OutputRefV0;
+type index_PayloadInfoV0 = PayloadInfoV0;
+type index_PendingToolCallV0 = PendingToolCallV0;
+type index_PlanHash = PlanHash;
+type index_RunId = RunId;
+type index_SpecV0 = SpecV0;
+type index_StatusV0 = StatusV0;
+type index_StreamEventKind = StreamEventKind;
+type index_TokenUsageV0 = TokenUsageV0;
+type index_ToolExecutionModeV0 = ToolExecutionModeV0;
+declare const index_ToolExecutionModes: typeof ToolExecutionModes;
+type index_ToolExecutionV0 = ToolExecutionV0;
+type index_ToolLimitsV0 = ToolLimitsV0;
+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 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 { type index_BindingEncodingV0 as BindingEncodingV0, index_BindingEncodings as BindingEncodings, type index_BindingV0 as BindingV0, type index_EdgeV0 as EdgeV0, 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_FunctionToolCallV0 as FunctionToolCallV0, type index_Kind as Kind, index_KindV0 as KindV0, 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, index_NodeTypes as NodeTypes, type index_NodeV0 as NodeV0, type index_NodeWaitingV0 as NodeWaitingV0, type index_OutputName as OutputName, type index_OutputRefV0 as OutputRefV0, type index_PayloadInfoV0 as PayloadInfoV0, type index_PendingToolCallV0 as PendingToolCallV0, type index_PlanHash as PlanHash, type index_RunId as RunId, type index_SpecV0 as SpecV0, type index_StatusV0 as StatusV0, type index_StreamEventKind as StreamEventKind, type index_TokenUsageV0 as TokenUsageV0, type index_ToolExecutionModeV0 as ToolExecutionModeV0, index_ToolExecutionModes as ToolExecutionModes, type index_ToolExecutionV0 as ToolExecutionV0, type index_ToolLimitsV0 as ToolLimitsV0, index_parseNodeId as parseNodeId, index_parseOutputName as parseOutputName, index_parsePlanHash as parsePlanHash, index_parseRunId as parseRunId };
 }
 
 /**
@@ -7747,4 +8424,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, 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 ImageRequest, type ImageResponse, type ImageResponseFormat, type ImageUsage, ImagesClient, type InputItem, type InputItemType, InputItemTypes, type JSONSchemaFormat, type JsonSchemaOptions, type KnownStopReason, LLMNodeBuilder, LLMStep, type LLMStepConfig, LLM_TEXT_OUTPUT$1 as LLM_TEXT_OUTPUT, LLM_USER_MESSAGE_TEXT$1 as LLM_USER_MESSAGE_TEXT, type ListSessionsOptions, type ListSessionsResponse, LocalFSToolPack, type LocalFSToolPackOptions, LocalSession, type LocalSessionOptions, type LocalSessionPersistence, MapItem, type MapItemConfig, MapReduce, MapReduceBuilder, 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$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 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 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, TransformJSONNodeBuilder, type TransformJSONValueV0, TransportError, type TransportErrorKind, type Usage, type UsageSummary, type ValidationIssue, WORKFLOWS_COMPILE_PATH, type WebSearchConfig, type WebToolMode, WebToolModes, Workflow, 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$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, respondToToolCall, runOAuthDeviceFlowForIDToken, startOAuthDeviceAuthorization, stopReasonToString, toolChoiceAuto, toolChoiceNone, toolChoiceRequired, toolResultMessage, transformJSONMerge, transformJSONObject, transformJSONValue, tryParseToolArgs, validateWithZod, index as workflow, workflowV0, workflow_v0_schema as workflowV0Schema, zodToJsonSchema };