@scenario-labs/sdk 2.6.0 → 2.7.0

package/src/lib/workflow_converter.ts

@@ -501,7 +501,8 @@ function getSourceRef(
   }
 
   if (targetNode.type === 'ifElse') {
-    const handles = targetNode.data.outputHandles ?? [];
+    // Approval handles are UI-only and must not shift case/else indices.
+    const handles = (targetNode.data.outputHandles ?? []).filter((h) => h.type !== 'approval');
     const handleIndex = handles.findIndex((h) => h.id === edge.targetHandle);
     if (handleIndex !== -1) {
       const targetFlowId = nodeIdToFlowIdMap.get(targetNodeId);
@@ -572,6 +573,38 @@ function getIsSliceAssetsItemsSourceHandle(nodeId: string, sourceHandle: string
   return sourceHandle === `${nodeId}-source-items` || sourceHandle === `${nodeId}-source-assets`;
 }
 
+function getConcatListSourceDescriptor(
+  targetNode: WorkflowEditorNode,
+  outHandle: WorkflowEditorHandleOutput | undefined,
+  outHandleName: string,
+): { isArray: boolean; inputType: string } {
+  const isArray =
+    (targetNode.type === 'asset' && !!(targetNode.data as { isMultiple?: boolean }).isMultiple) ||
+    targetNode.type === 'groupItems' ||
+    targetNode.type === 'sliceAssets' ||
+    targetNode.type === 'splitText' ||
+    (targetNode.type === 'llm' && outHandleName === 'outputs') ||
+    !!outHandle?.isArray ||
+    outHandleName === 'allOutputs';
+
+  if (!isArray) {
+    return {
+      isArray: false,
+      inputType: outHandle?.type === 'text' ? 'string' : 'file',
+    };
+  }
+
+  const isTextList =
+    targetNode.type === 'splitText' ||
+    (targetNode.type === 'llm' && outHandleName === 'outputs') ||
+    outHandle?.type === 'text';
+
+  return {
+    isArray: true,
+    inputType: isTextList ? 'string_array' : 'file_array',
+  };
+}
+
 /**
  * Builds the concat variables and flow inputs for a list-concatenating node
  * (groupItems, sliceAssets in randomize mode) from its incoming edges.
@@ -595,18 +628,14 @@ function collectConcatVarsAndInputs(
     const outHandle = targetNode.data.outputHandles?.find((h) => h.id === edge.targetHandle);
     const outHandleName = outHandle?.name ?? 'output';
     const varName = getVarName(targetNode.id, outHandleName);
-    const isArr =
-      (targetNode.type === 'asset' && !!(targetNode.data as { isMultiple?: boolean }).isMultiple) ||
-      targetNode.type === 'groupItems' ||
-      targetNode.type === 'sliceAssets' ||
-      outHandleName === 'allOutputs';
+    const { isArray, inputType } = getConcatListSourceDescriptor(targetNode, outHandle, outHandleName);
     const isRequired =
       inputNodeIds.includes(targetNode.id) ?
         (targetNode.type === 'asset' && !!(targetNode.data as { isRequired?: boolean }).isRequired) ||
         ['firstFrame', 'lastFrame'].includes(outHandleName)
       : true;
-    variables.push({ name: varName, isArray: isArr, isRequired });
-    flowInputs.push({ name: varName, type: isArr ? 'file_array' : 'file', ref });
+    variables.push({ name: varName, isArray, isRequired });
+    flowInputs.push({ name: varName, type: inputType, ref });
   }
 
   return { variables, flowInputs };
@@ -842,6 +871,7 @@ function getForEachBodyEditorNodeIds(
   forEachId: string,
   forEachEndId: string,
   edges: WorkflowEditorEdge[],
+  nodes: WorkflowEditorNode[],
 ): Set<string> {
   const bodyNodeIds = new Set<string>();
   const queue: string[] = [];
@@ -861,9 +891,77 @@ function getForEachBodyEditorNodeIds(
       }
     }
   }
+
+  addRandomizeClosureToBody(bodyNodeIds, forEachEndId, edges, nodes);
+
   return bodyNodeIds;
 }
 
+/**
+ * The body traversal above only walks *downstream* from the loop's per-item
+ * outputs, so an unlocked randomize node sitting on a side branch that merely
+ * *feeds* the body (e.g. `randomSample(...) -> promptBuilder -> generator`) is
+ * left out — computed once and shared, so every iteration reuses the same draw
+ * (scenario-labs/phoenix#8498).
+ *
+ * A locked seed means the user wants reproducibility, so those stay shared. But
+ * for an UNLOCKED randomize node we mutate `bodyNodeIds` in place to also include
+ * that node plus the deterministic chain down to the body, so the runtime clones
+ * it per iteration and each iteration re-draws. We only pull it in when *every*
+ * path out of it lands in the body — if it also feeds a node outside the loop,
+ * cloning it would break that external consumer, so we leave it shared.
+ */
+function addRandomizeClosureToBody(
+  bodyNodeIds: Set<string>,
+  forEachEndId: string,
+  edges: WorkflowEditorEdge[],
+  nodes: WorkflowEditorNode[],
+): void {
+  const nodeById = new Map(nodes.map((n) => [n.id, n]));
+  const isUnlockedRandomize = (id: string): boolean => {
+    const data = nodeById.get(id)?.data as { isRandomize?: boolean; isSeedLocked?: boolean } | undefined;
+    return data?.isRandomize === true && data.isSeedLocked !== true;
+  };
+  // edge convention: `{ source: consumer, target: provider }` — an input handle
+  // on `source` reads an output handle on `target`.
+  const providersOf = (id: string): string[] => edges.filter((e) => e.source === id).map((e) => e.target);
+  const consumersOf = (id: string): string[] => edges.filter((e) => e.target === id).map((e) => e.source);
+
+  // Every node strictly upstream of the body (its transitive input providers).
+  const upstream = new Set<string>();
+  const upstreamQueue = [...bodyNodeIds];
+  while (upstreamQueue.length > 0) {
+    for (const provider of providersOf(upstreamQueue.pop()!)) {
+      if (provider !== forEachEndId && !bodyNodeIds.has(provider) && !upstream.has(provider)) {
+        upstream.add(provider);
+        upstreamQueue.push(provider);
+      }
+    }
+  }
+
+  for (const randomId of upstream) {
+    if (!isUnlockedRandomize(randomId)) continue;
+    // Walk downstream from the randomize node, stopping at the body frontier.
+    const chain = new Set<string>();
+    const chainQueue = [randomId];
+    let escapesLoop = false;
+    while (chainQueue.length > 0) {
+      const id = chainQueue.pop()!;
+      if (bodyNodeIds.has(id)) continue; // reached the loop body — a valid sink
+      chain.add(id);
+      const consumers = consumersOf(id);
+      if (consumers.length === 0) {
+        escapesLoop = true; // dead-end outside the loop → do not internalize
+        break;
+      }
+      for (const consumer of consumers) {
+        if (!bodyNodeIds.has(consumer)) chainQueue.push(consumer);
+      }
+    }
+    if (!escapesLoop) for (const id of chain) bodyNodeIds.add(id);
+  }
+}
+
 function sortNodesByInputKeys(nodes: WorkflowEditorNode[], inputKeys: string[]): WorkflowEditorNode[] {
   return [...nodes].sort((a, b) => {
     const ai = inputKeys.indexOf(a.id);
@@ -1145,7 +1243,7 @@ export function convertWorkflowEditorToFlow(
       (n) => n.type === 'forEachEnd' && (n.data as { parentNodeId?: string }).parentNodeId === node.id,
     );
     if (!endNode) continue;
-    forEachBodyEditorNodeIds.set(node.id, getForEachBodyEditorNodeIds(node.id, endNode.id, edges));
+    forEachBodyEditorNodeIds.set(node.id, getForEachBodyEditorNodeIds(node.id, endNode.id, edges, nodes));
     forEachLoopFlowIds.set(node.id, []);
   }
 
@@ -1331,21 +1429,16 @@ export function convertWorkflowEditorToFlow(
                 targetInputType = outHandle?.type === 'text' ? 'string' : 'file';
               } else {
                 targetNodeKey = getOutputHandleVarName(edge.target, targetOutputHandleName);
-                targetInputType =
-                  (
-                    (targetNode?.type === 'asset' &&
-                      !!(targetNode.data as { isMultiple?: boolean }).isMultiple) ||
-                    targetNode?.type === 'groupItems' ||
-                    targetNode?.type === 'sliceAssets' ||
-                    targetOutputHandleName === 'allOutputs'
-                  ) ?
-                    'file_array'
-                  : targetNode?.type === 'llm' && targetOutputHandleName === 'outputs' ? 'string_array'
-                  : targetNode?.type === 'asset' || targetNode?.type === 'model' ? 'file'
-                  : 'string';
+                if (!targetNode) continue;
+                const descriptor = getConcatListSourceDescriptor(
+                  targetNode,
+                  targetOutputHandle,
+                  targetOutputHandleName,
+                );
+                targetInputType = descriptor.inputType;
               }
 
-              const isArr = targetInputType === 'file_array';
+              const isArr = targetInputType === 'file_array' || targetInputType === 'string_array';
               const isRequired =
                 (targetNode?.type === 'asset' &&
                   !!(targetNode.data as { isRequired?: boolean }).isRequired) ||
@@ -1635,7 +1728,9 @@ export function convertWorkflowEditorToFlow(
           const ref = targetNode ? getSourceRef(assetsEdge, ctx) : undefined;
           if (targetNode && ref) {
             const outHandle = targetNode.data.outputHandles?.find((h) => h.id === assetsEdge.targetHandle);
-            const varName = getOutputHandleVarName(targetNode.id, outHandle?.name ?? 'output');
+            const outHandleName = outHandle?.name ?? 'output';
+            const varName = getOutputHandleVarName(targetNode.id, outHandleName);
+            const { inputType } = getConcatListSourceDescriptor(targetNode, outHandle, outHandleName);
             const from = parseInt(String(sliceData.from ?? ''), 10) || 0;
             const count = parseInt(String(sliceData.count ?? ''), 10) || 0;
             const transform =
@@ -1643,7 +1738,7 @@ export function convertWorkflowEditorToFlow(
                 `slice(${varName}, (${varName}).size() + ${from}, (${varName}).size() + ${from + count})`
               : `slice(${varName}, ${from}, ${from + count})`;
             const flowInputs: WorkflowEditorFlowInput[] = [
-              { name: varName, type: 'file_array', ref },
+              { name: varName, type: inputType, ref },
               ...collectConditionalConnectionInputs(incomingEdges, node.id, ctx),
             ];
             flow.push({

package/src/resources/models/examples.ts

@@ -5058,7 +5058,8 @@ export namespace ExampleListResponse {
 
 export interface ExampleUpdateParams {
   /**
-   * Body param: The list of asset ids to use as examples of the model
+   * Body param: The list of asset ids to use as examples of the model. Maximum of
+   * 150 asset ids.
    */
   assetIds: Array<string>;
 

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '2.6.0'; // x-release-please-version
+export const VERSION = '2.7.0'; // x-release-please-version

package/version.d.mts

@@ -1,2 +1,2 @@
-export declare const VERSION = "2.6.0";
+export declare const VERSION = "2.7.0";
 //# sourceMappingURL=version.d.mts.map

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "2.6.0";
+export declare const VERSION = "2.7.0";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '2.6.0'; // x-release-please-version
+exports.VERSION = '2.7.0'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

@@ -1,2 +1,2 @@
-export const VERSION = '2.6.0'; // x-release-please-version
+export const VERSION = '2.7.0'; // x-release-please-version
 //# sourceMappingURL=version.mjs.map