@modelrelay/sdk 4.0.0 → 5.3.0

package/dist/index.js

@@ -64,7 +64,7 @@ import {
   toolResultMessage,
   tryParseToolArgs,
   zodToJsonSchema
-} from "./chunk-5O4NJXLJ.js";
+} from "./chunk-LZDGY24E.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";
@@ -1804,11 +1804,10 @@ function parseOutputName(raw) {
 
 // src/runs_types.ts
 var WorkflowKinds = {
-  WorkflowV1: "workflow.v1"
+  WorkflowIntent: "workflow"
 };
-var WorkflowNodeTypesV1 = {
-  LLMResponses: "llm.responses",
-  RouteSwitch: "route.switch",
+var WorkflowNodeTypesLite = {
+  LLM: "llm",
   JoinAll: "join.all",
   JoinAny: "join.any",
   JoinCollect: "join.collect",
@@ -2179,6 +2178,9 @@ var RunsClient = class {
     if (options.idempotencyKey?.trim()) {
       payload.options = { idempotency_key: options.idempotencyKey.trim() };
     }
+    if (options.input) {
+      payload.input = options.input;
+    }
     const out = await this.http.json(RUNS_PATH, {
       method: "POST",
       headers,
@@ -2369,7 +2371,7 @@ var WorkflowsClient = class {
     this.metrics = cfg.metrics;
     this.trace = cfg.trace;
   }
-  async compileV1(spec, options = {}) {
+  async compile(spec, options = {}) {
     const metrics = mergeMetrics(this.metrics, options.metrics);
     const trace = mergeTrace(this.trace, options.trace);
     const authHeaders = await this.auth.authForResponses();
@@ -2874,21 +2876,16 @@ var LocalSession = class _LocalSession {
       const input = await this.buildInput(options);
       const tools = mergeTools(this.defaultTools, options.tools);
       const spec = {
-        kind: "workflow.v1",
+        kind: "workflow",
         name: `session-${this.id}-turn-${this.nextSeq}`,
+        model: options.model || this.defaultModel,
         nodes: [
           {
             id: "main",
-            type: "llm.responses",
-            input: {
-              request: {
-                provider: options.provider || this.defaultProvider,
-                model: options.model || this.defaultModel,
-                input,
-                tools
-              },
-              tool_execution: this.toolRegistry ? { mode: "client" } : void 0
-            }
+            type: "llm",
+            input,
+            tools,
+            tool_execution: this.toolRegistry ? { mode: "client" } : void 0
           }
         ],
         outputs: [{ name: "result", from: "main" }]
@@ -3369,21 +3366,16 @@ var RemoteSession = class _RemoteSession {
       const input = await this.buildInput(options);
       const tools = mergeTools2(this.defaultTools, options.tools);
       const spec = {
-        kind: "workflow.v1",
+        kind: "workflow",
         name: `session-${this.id}-turn-${this.nextSeq}`,
+        model: options.model || this.defaultModel,
         nodes: [
           {
             id: "main",
-            type: "llm.responses",
-            input: {
-              request: {
-                provider: options.provider || this.defaultProvider,
-                model: options.model || this.defaultModel,
-                input,
-                tools
-              },
-              tool_execution: this.toolRegistry ? { mode: "client" } : void 0
-            }
+            type: "llm",
+            input,
+            tools,
+            tool_execution: this.toolRegistry ? { mode: "client" } : void 0
           }
         ],
         outputs: [{ name: "result", from: "main" }]
@@ -4539,253 +4531,185 @@ function JoinOutput(nodeId) {
 // src/workflow_builder.ts
 var LLM_TEXT_OUTPUT = LLMOutputText;
 var LLM_USER_MESSAGE_TEXT = LLMInputUserText;
-function transformJSONValue(from, pointer) {
-  return pointer ? { from, pointer } : { from };
-}
-function transformJSONObject(object) {
-  return { object };
-}
-function transformJSONMerge(merge) {
-  return { merge: merge.slice() };
-}
-function wireRequest(req) {
-  const raw = req;
-  if (raw && typeof raw === "object") {
-    if ("input" in raw) {
-      return req;
-    }
-    if ("body" in raw) {
-      return raw.body ?? {};
-    }
-  }
-  return asInternal(req).body;
-}
-var INPUT_POINTER_PATTERN = /^\/input\/(\d+)(?:\/content\/(\d+))?/;
-var BindingTargetError = class extends Error {
-  constructor(nodeId, bindingIndex, pointer, message) {
-    super(`node "${nodeId}" binding ${bindingIndex}: ${message}`);
-    this.name = "BindingTargetError";
-    this.nodeId = nodeId;
-    this.bindingIndex = bindingIndex;
-    this.pointer = pointer;
-  }
-};
-var MapFanoutInputError = class extends Error {
-  constructor(nodeId, message) {
-    super(`node "${nodeId}": ${message}`);
-    this.name = "MapFanoutInputError";
-    this.nodeId = nodeId;
-  }
-};
-function validateBindingTargets(nodeId, input, bindings) {
-  for (let i = 0; i < bindings.length; i++) {
-    const binding = bindings[i];
-    if (!binding.to) continue;
-    const error = validateInputPointer(binding.to, input);
-    if (error) {
-      throw new BindingTargetError(nodeId, i, binding.to, error);
-    }
-  }
-}
-function validateInputPointer(pointer, input) {
-  if (!pointer.startsWith("/input/")) {
-    return void 0;
-  }
-  const match = pointer.match(INPUT_POINTER_PATTERN);
-  if (!match) {
-    return void 0;
-  }
-  const msgIndex = parseInt(match[1], 10);
-  if (msgIndex >= input.length) {
-    return `targets ${pointer} but request only has ${input.length} messages (indices 0-${input.length - 1}); add placeholder messages or adjust binding target`;
-  }
-  if (match[2] !== void 0) {
-    const contentIndex = parseInt(match[2], 10);
-    const msg = input[msgIndex];
-    if (contentIndex >= msg.content.length) {
-      return `targets ${pointer} but message ${msgIndex} only has ${msg.content.length} content blocks (indices 0-${msg.content.length - 1})`;
-    }
-  }
-  return void 0;
-}
-function validateMapFanoutInput(nodeId, input) {
-  const subnode = input.subnode;
-  if ((subnode.type === WorkflowNodeTypesV1.LLMResponses || subnode.type === WorkflowNodeTypesV1.RouteSwitch) && subnode.input.bindings && subnode.input.bindings.length > 0) {
-    throw new MapFanoutInputError(nodeId, "map.fanout subnode bindings are not allowed");
-  }
-  if (subnode.type !== WorkflowNodeTypesV1.TransformJSON) {
-    return;
-  }
-  if (input.item_bindings && input.item_bindings.length > 0) {
-    throw new MapFanoutInputError(
-      nodeId,
-      "map.fanout transform.json subnode cannot use item_bindings"
-    );
-  }
-  const hasObject = !!subnode.input.object && Object.keys(subnode.input.object).length > 0;
-  const hasMerge = !!subnode.input.merge && subnode.input.merge.length > 0;
-  if (hasObject === hasMerge) {
-    throw new MapFanoutInputError(
-      nodeId,
-      "map.fanout transform.json must provide exactly one of object or merge"
-    );
-  }
-  if (hasObject) {
-    for (const [key, value] of Object.entries(subnode.input.object ?? {})) {
-      if (!key.trim()) continue;
-      if (String(value.from) !== "item") {
-        throw new MapFanoutInputError(
-          nodeId,
-          `map.fanout transform.json object.${key}.from must be "item"`
-        );
-      }
-    }
-  }
-  if (hasMerge) {
-    for (const [index, value] of (subnode.input.merge ?? []).entries()) {
-      if (String(value.from) !== "item") {
-        throw new MapFanoutInputError(
-          nodeId,
-          `map.fanout transform.json merge[${index}].from must be "item"`
-        );
-      }
-    }
-  }
-}
-var WorkflowBuilderV1 = class _WorkflowBuilderV1 {
+var WorkflowIntentBuilder = class _WorkflowIntentBuilder {
   constructor(state = { nodes: [], edges: [], outputs: [] }) {
     this.state = state;
   }
-  static new() {
-    return new _WorkflowBuilderV1();
-  }
   with(patch) {
-    return new _WorkflowBuilderV1({
+    return new _WorkflowIntentBuilder({
       ...this.state,
-      ...patch
+      ...patch,
+      nodes: patch.nodes ?? this.state.nodes,
+      edges: patch.edges ?? this.state.edges,
+      outputs: patch.outputs ?? this.state.outputs
     });
   }
   name(name) {
-    return this.with({ name: name.trim() || void 0 });
+    return this.with({ name: name.trim() });
   }
-  execution(execution) {
-    return this.with({ execution });
+  model(model) {
+    return this.with({ model: model.trim() });
   }
   node(node) {
     return this.with({ nodes: [...this.state.nodes, node] });
   }
-  llmResponses(id, request, options = {}) {
-    const wiredRequest = wireRequest(request);
-    if (options.bindings) {
-      validateBindingTargets(id, wiredRequest.input, options.bindings);
-    }
-    const input = {
-      request: wiredRequest,
-      ...options.stream === void 0 ? {} : { stream: options.stream },
-      ...options.toolExecution === void 0 ? {} : { tool_execution: { mode: options.toolExecution } },
-      ...options.toolLimits === void 0 ? {} : { tool_limits: { ...options.toolLimits } },
-      ...options.bindings === void 0 ? {} : { bindings: options.bindings.slice() }
-    };
+  llm(id, configure) {
+    const builder = new LLMNodeBuilder(id);
+    const configured = configure ? configure(builder) : builder;
+    return this.node(configured.build());
+  }
+  joinAll(id) {
+    return this.node({ id, type: WorkflowNodeTypesLite.JoinAll });
+  }
+  joinAny(id, predicate) {
+    return this.node({ id, type: WorkflowNodeTypesLite.JoinAny, predicate });
+  }
+  joinCollect(id, options) {
     return this.node({
       id,
-      type: WorkflowNodeTypesV1.LLMResponses,
-      input
+      type: WorkflowNodeTypesLite.JoinCollect,
+      limit: options.limit,
+      timeout_ms: options.timeoutMs,
+      predicate: options.predicate
     });
   }
-  routeSwitch(id, request, options = {}) {
-    const wiredRequest = wireRequest(request);
-    if (options.bindings) {
-      validateBindingTargets(id, wiredRequest.input, options.bindings);
-    }
-    const input = {
-      request: wiredRequest,
-      ...options.stream === void 0 ? {} : { stream: options.stream },
-      ...options.toolExecution === void 0 ? {} : { tool_execution: { mode: options.toolExecution } },
-      ...options.toolLimits === void 0 ? {} : { tool_limits: { ...options.toolLimits } },
-      ...options.bindings === void 0 ? {} : { bindings: options.bindings.slice() }
-    };
+  transformJSON(id, object, merge) {
     return this.node({
       id,
-      type: WorkflowNodeTypesV1.RouteSwitch,
-      input
+      type: WorkflowNodeTypesLite.TransformJSON,
+      object,
+      merge
     });
   }
-  joinAll(id) {
-    return this.node({ id, type: WorkflowNodeTypesV1.JoinAll });
-  }
-  joinAny(id, input) {
+  mapFanout(id, options) {
     return this.node({
       id,
-      type: WorkflowNodeTypesV1.JoinAny,
-      ...input ? { input } : {}
+      type: WorkflowNodeTypesLite.MapFanout,
+      items_from: options.itemsFrom,
+      items_from_input: options.itemsFromInput,
+      items_path: options.itemsPath,
+      subnode: options.subnode,
+      max_parallelism: options.maxParallelism
     });
   }
-  joinCollect(id, input) {
-    return this.node({ id, type: WorkflowNodeTypesV1.JoinCollect, input });
-  }
-  transformJSON(id, input) {
-    return this.node({ id, type: WorkflowNodeTypesV1.TransformJSON, input });
-  }
-  mapFanout(id, input) {
-    validateMapFanoutInput(id, input);
-    return this.node({ id, type: WorkflowNodeTypesV1.MapFanout, input });
-  }
-  edge(from, to, when) {
-    return this.with({
-      edges: [...this.state.edges, { from, to, ...when ? { when } : {} }]
-    });
+  edge(from, to) {
+    return this.with({ edges: [...this.state.edges, { from, to }] });
   }
   output(name, from, pointer) {
     return this.with({
-      outputs: [
-        ...this.state.outputs,
-        { name, from, ...pointer ? { pointer } : {} }
-      ]
+      outputs: [...this.state.outputs, { name, from, pointer }]
     });
   }
   build() {
-    const edges = this.state.edges.slice().sort((a, b) => {
-      const af = String(a.from);
-      const bf = String(b.from);
-      if (af < bf) return -1;
-      if (af > bf) return 1;
-      const at = String(a.to);
-      const bt = String(b.to);
-      if (at < bt) return -1;
-      if (at > bt) return 1;
-      const aw = a.when ? JSON.stringify(a.when) : "";
-      const bw = b.when ? JSON.stringify(b.when) : "";
-      if (aw < bw) return -1;
-      if (aw > bw) return 1;
-      return 0;
-    });
-    const outputs = this.state.outputs.slice().sort((a, b) => {
-      const an = String(a.name);
-      const bn = String(b.name);
-      if (an < bn) return -1;
-      if (an > bn) return 1;
-      const af = String(a.from);
-      const bf = String(b.from);
-      if (af < bf) return -1;
-      if (af > bf) return 1;
-      const ap = a.pointer ?? "";
-      const bp = b.pointer ?? "";
-      if (ap < bp) return -1;
-      if (ap > bp) return 1;
-      return 0;
-    });
+    const nodes = this.state.nodes.map((node) => ({
+      ...node,
+      depends_on: node.depends_on ? [...node.depends_on] : void 0
+    }));
+    const byId = /* @__PURE__ */ new Map();
+    for (let idx = 0; idx < nodes.length; idx++) {
+      const id = nodes[idx].id;
+      if (byId.has(id)) {
+        throw new Error(`duplicate node id "${id}"`);
+      }
+      byId.set(id, idx);
+    }
+    for (const edge of this.state.edges) {
+      const idx = byId.get(edge.to);
+      if (idx === void 0) {
+        throw new Error(`edge to unknown node ${edge.to}`);
+      }
+      const existing = nodes[idx].depends_on ?? [];
+      if (!existing.includes(edge.from)) {
+        existing.push(edge.from);
+      }
+      nodes[idx].depends_on = existing;
+    }
     return {
-      kind: WorkflowKinds.WorkflowV1,
-      ...this.state.name ? { name: this.state.name } : {},
-      ...this.state.execution ? { execution: this.state.execution } : {},
-      nodes: this.state.nodes.slice(),
-      ...edges.length ? { edges } : {},
-      outputs
+      kind: WorkflowKinds.WorkflowIntent,
+      name: this.state.name,
+      model: this.state.model,
+      nodes,
+      outputs: [...this.state.outputs]
     };
   }
 };
-function workflowV1() {
-  return WorkflowBuilderV1.new();
+var LLMNodeBuilder = class {
+  constructor(id) {
+    this.node = { id, type: WorkflowNodeTypesLite.LLM };
+  }
+  system(text) {
+    this.node.system = text;
+    return this;
+  }
+  user(text) {
+    this.node.user = text;
+    return this;
+  }
+  input(items) {
+    this.node.input = items;
+    return this;
+  }
+  model(model) {
+    this.node.model = model;
+    return this;
+  }
+  stream(enabled) {
+    this.node.stream = enabled;
+    return this;
+  }
+  toolExecution(mode) {
+    this.node.tool_execution = { mode };
+    return this;
+  }
+  tools(tools) {
+    this.node.tools = tools;
+    return this;
+  }
+  build() {
+    return { ...this.node };
+  }
+};
+function workflowIntent() {
+  return new WorkflowIntentBuilder();
+}
+function llm(id, configure) {
+  const builder = new LLMNodeBuilder(parseNodeId(id));
+  const configured = configure ? configure(builder) : builder;
+  return configured.build();
+}
+function chain(steps, options) {
+  let builder = new WorkflowIntentBuilder();
+  if (options?.name) {
+    builder = builder.name(options.name);
+  }
+  if (options?.model) {
+    builder = builder.model(options.model);
+  }
+  for (const step of steps) {
+    builder = builder.node(step);
+  }
+  for (let i = 1; i < steps.length; i++) {
+    builder = builder.edge(steps[i - 1].id, steps[i].id);
+  }
+  return builder;
+}
+function parallel(steps, options) {
+  let builder = new WorkflowIntentBuilder();
+  const joinId = parseNodeId(options?.joinId ?? "join");
+  if (options?.name) {
+    builder = builder.name(options.name);
+  }
+  if (options?.model) {
+    builder = builder.model(options.model);
+  }
+  for (const step of steps) {
+    builder = builder.node(step);
+  }
+  builder = builder.joinAll(joinId);
+  for (const step of steps) {
+    builder = builder.edge(step.id, joinId);
+  }
+  return builder;
 }
 
 // src/testing.ts
@@ -5008,260 +4932,26 @@ var generated_exports = {};
 // src/workflow/index.ts
 var workflow_exports = {};
 __export(workflow_exports, {
-  BindingBuilder: () => BindingBuilder,
-  BindingEncodings: () => BindingEncodings,
-  FanoutReduceV1: () => FanoutReduceV1,
-  KindV1: () => KindV1,
+  KindIntent: () => KindIntent,
+  LLMNodeBuilder: () => LLMNodeBuilder,
   LLM_TEXT_OUTPUT: () => LLM_TEXT_OUTPUT,
   LLM_USER_MESSAGE_TEXT: () => LLM_USER_MESSAGE_TEXT,
-  NodeTypesV1: () => NodeTypesV1,
-  RouterV1: () => RouterV1,
-  ToolExecutionModes: () => ToolExecutionModes,
-  WorkflowBuilderV1: () => WorkflowBuilderV1,
-  bindFrom: () => bindFrom,
-  bindToPlaceholder: () => bindToPlaceholder,
-  bindToPointer: () => bindToPointer,
+  NodeTypesLite: () => NodeTypesLite,
+  WorkflowIntentBuilder: () => WorkflowIntentBuilder,
   parseNodeId: () => parseNodeId,
   parseOutputName: () => parseOutputName,
   parsePlanHash: () => parsePlanHash,
   parseRunId: () => parseRunId,
-  whenOutputEquals: () => whenOutputEquals,
-  whenOutputExists: () => whenOutputExists,
-  whenOutputMatches: () => whenOutputMatches,
-  whenStatusEquals: () => whenStatusEquals,
-  whenStatusExists: () => whenStatusExists,
-  whenStatusMatches: () => whenStatusMatches,
-  workflowV1: () => workflowV1
+  workflowIntent: () => workflowIntent
 });
-
-// src/workflow/helpers_v1.ts
-function whenOutputEquals(path, value) {
-  return { source: "node_output", op: "equals", path, value };
-}
-function whenOutputMatches(path, pattern) {
-  return { source: "node_output", op: "matches", path, value: pattern };
-}
-function whenOutputExists(path) {
-  return { source: "node_output", op: "exists", path };
-}
-function whenStatusEquals(path, value) {
-  return { source: "node_status", op: "equals", path, value };
-}
-function whenStatusMatches(path, pattern) {
-  return { source: "node_status", op: "matches", path, value: pattern };
-}
-function whenStatusExists(path) {
-  return { source: "node_status", op: "exists", path };
-}
-function bindToPlaceholder(from, placeholder, opts) {
-  return {
-    from,
-    ...opts?.pointer ? { pointer: opts.pointer } : {},
-    to_placeholder: placeholder,
-    encoding: opts?.encoding ?? "json_string"
-  };
-}
-function bindToPointer(from, to, opts) {
-  return {
-    from,
-    ...opts?.pointer ? { pointer: opts.pointer } : {},
-    to,
-    encoding: opts?.encoding ?? "json_string"
-  };
-}
-function bindFrom(from) {
-  return new BindingBuilder(from);
-}
-var BindingBuilder = class {
-  constructor(from) {
-    this._encoding = "json_string";
-    this._from = from;
-  }
-  /**
-   * Set the source pointer to extract from the node's output.
-   */
-  pointer(ptr) {
-    this._pointer = ptr;
-    return this;
-  }
-  /**
-   * Set the destination JSON pointer in the request.
-   */
-  to(ptr) {
-    this._to = ptr;
-    this._toPlaceholder = void 0;
-    return this;
-  }
-  /**
-   * Set the destination placeholder name.
-   */
-  toPlaceholder(name) {
-    this._toPlaceholder = name;
-    this._to = void 0;
-    return this;
-  }
-  /**
-   * Set the encoding for the binding value.
-   */
-  encoding(enc) {
-    this._encoding = enc;
-    return this;
-  }
-  /**
-   * Build the binding object.
-   */
-  build() {
-    const binding = {
-      from: this._from,
-      encoding: this._encoding
-    };
-    if (this._pointer) binding.pointer = this._pointer;
-    if (this._to) binding.to = this._to;
-    if (this._toPlaceholder) binding.to_placeholder = this._toPlaceholder;
-    return binding;
-  }
-};
-
-// src/workflow/patterns_v1.ts
-function wireRequest2(req) {
-  const raw = req;
-  if (raw && typeof raw === "object") {
-    if ("input" in raw) {
-      return req;
-    }
-    if ("body" in raw) {
-      return raw.body ?? {};
-    }
-  }
-  return asInternal(req).body;
-}
-var RouterV1 = class {
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Build the workflow specification.
-   */
-  build() {
-    const {
-      name,
-      classifier,
-      classifierId = "router",
-      routePath = "$.route",
-      routes,
-      aggregator,
-      outputName = "final"
-    } = this.config;
-    let builder = new WorkflowBuilderV1();
-    if (name) {
-      builder = builder.name(name);
-    }
-    builder = builder.routeSwitch(classifierId, classifier);
-    const joinId = "__router_join";
-    builder = builder.joinAny(joinId);
-    for (let i = 0; i < routes.length; i++) {
-      const route = routes[i];
-      const handlerId = route.id ?? `handler_${i}`;
-      builder = builder.llmResponses(handlerId, route.handler, {
-        bindings: route.bindings
-      });
-      builder = builder.edge(classifierId, handlerId, whenOutputEquals(routePath, route.value));
-      builder = builder.edge(handlerId, joinId);
-    }
-    if (aggregator) {
-      const aggId = aggregator.id ?? "aggregate";
-      const placeholder = aggregator.placeholder ?? "route_output";
-      builder = builder.llmResponses(aggId, aggregator.request, {
-        bindings: [bindToPlaceholder(joinId, placeholder)]
-      });
-      builder = builder.edge(joinId, aggId);
-      builder = builder.output(outputName, aggId);
-    } else {
-      builder = builder.output(outputName, joinId);
-    }
-    return builder.build();
-  }
-};
-var FanoutReduceV1 = class {
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Build the workflow specification.
-   */
-  build() {
-    const {
-      name,
-      generator,
-      generatorId = "generator",
-      itemsPath = "/items",
-      mapper,
-      mapperPlaceholder = "item",
-      maxParallelism = 4,
-      reducer,
-      reducerId = "reducer",
-      reducerBinding,
-      outputName = "final"
-    } = this.config;
-    let builder = new WorkflowBuilderV1();
-    if (name) {
-      builder = builder.name(name);
-    }
-    builder = builder.llmResponses(generatorId, generator);
-    const fanoutId = "__fanout";
-    const itemBindings = [
-      {
-        path: "$",
-        to_placeholder: mapperPlaceholder,
-        encoding: "json_string"
-      }
-    ];
-    const mapperRequest = wireRequest2(mapper);
-    builder = builder.mapFanout(fanoutId, {
-      items: { from: generatorId, path: itemsPath },
-      item_bindings: itemBindings,
-      subnode: {
-        id: "__mapper",
-        type: "llm.responses",
-        input: { request: mapperRequest }
-      },
-      max_parallelism: maxParallelism
-    });
-    builder = builder.edge(generatorId, fanoutId);
-    const pointer = reducerBinding?.pointer ?? "/results";
-    const binding = reducerBinding?.placeholder ? bindToPlaceholder(fanoutId, reducerBinding.placeholder, { pointer }) : {
-      from: fanoutId,
-      pointer,
-      to: reducerBinding?.to ?? "/input/0/content/0/text",
-      encoding: "json_string"
-    };
-    builder = builder.llmResponses(reducerId, reducer, {
-      bindings: [binding]
-    });
-    builder = builder.edge(fanoutId, reducerId);
-    builder = builder.output(outputName, reducerId);
-    return builder.build();
-  }
-};
-
-// src/workflow/index.ts
-var KindV1 = WorkflowKinds.WorkflowV1;
-var NodeTypesV1 = {
-  LLMResponses: WorkflowNodeTypesV1.LLMResponses,
-  RouteSwitch: WorkflowNodeTypesV1.RouteSwitch,
-  JoinAll: WorkflowNodeTypesV1.JoinAll,
-  JoinAny: WorkflowNodeTypesV1.JoinAny,
-  JoinCollect: WorkflowNodeTypesV1.JoinCollect,
-  TransformJSON: WorkflowNodeTypesV1.TransformJSON,
-  MapFanout: WorkflowNodeTypesV1.MapFanout
-};
-var BindingEncodings = {
-  JSON: "json",
-  JSONString: "json_string"
-};
-var ToolExecutionModes = {
-  Server: "server",
-  Client: "client"
+var KindIntent = WorkflowKinds.WorkflowIntent;
+var NodeTypesLite = {
+  LLM: WorkflowNodeTypesLite.LLM,
+  JoinAll: WorkflowNodeTypesLite.JoinAll,
+  JoinAny: WorkflowNodeTypesLite.JoinAny,
+  JoinCollect: WorkflowNodeTypesLite.JoinCollect,
+  TransformJSON: WorkflowNodeTypesLite.TransformJSON,
+  MapFanout: WorkflowNodeTypesLite.MapFanout
 };
 
 // src/index.ts
@@ -5328,7 +5018,6 @@ export {
   APIError,
   AuthClient,
   BillingProviders,
-  BindingTargetError,
   ConfigError,
   ContentPartTypes,
   CustomerResponsesClient,
@@ -5350,6 +5039,7 @@ export {
   LLMInputPath,
   LLMInputSystemText,
   LLMInputUserText,
+  LLMNodeBuilder,
   LLMOutput,
   LLMOutputContentItemPath,
   LLMOutputContentPath,
@@ -5358,7 +5048,6 @@ export {
   LLM_TEXT_OUTPUT,
   LLM_USER_MESSAGE_TEXT,
   LocalSession,
-  MapFanoutInputError,
   MemorySessionStore,
   MessageRoles,
   ModelRelay,
@@ -5390,10 +5079,10 @@ export {
   TransportError,
   WORKFLOWS_COMPILE_PATH,
   WebToolIntents,
-  WorkflowBuilderV1,
+  WorkflowIntentBuilder,
   WorkflowKinds,
-  WorkflowNodeTypesV1 as WorkflowNodeTypes,
-  WorkflowNodeTypesV1,
+  WorkflowNodeTypesLite as WorkflowNodeTypes,
+  WorkflowNodeTypesLite,
   WorkflowValidationError,
   WorkflowsClient,
   asModelId,
@@ -5403,6 +5092,7 @@ export {
   assistantMessageWithToolCalls,
   buildDelayedNDJSONResponse,
   buildNDJSONResponse,
+  chain,
   createAccessTokenAuth,
   createApiKeyAuth,
   createAssistantMessage,
@@ -5430,12 +5120,14 @@ export {
   hasRetryableErrors,
   hasToolCalls,
   isSecretKey,
+  llm,
   mergeMetrics,
   mergeTrace,
   modelToString,
   normalizeModelId,
   normalizeStopReason,
   outputFormatFromZod,
+  parallel,
   parseApiKey,
   parseErrorResponse,
   parseNodeId,
@@ -5451,12 +5143,9 @@ export {
   toolChoiceNone,
   toolChoiceRequired,
   toolResultMessage,
-  transformJSONMerge,
-  transformJSONObject,
-  transformJSONValue,
   tryParseToolArgs,
   validateWithZod,
   workflow_exports as workflow,
-  workflowV1,
+  workflowIntent,
   zodToJsonSchema
 };