@scenario-labs/sdk 2.6.0 → 3.0.0

package/src/client.ts

@@ -60,6 +60,7 @@ import {
   JobListParams,
   JobListResponse,
   JobListResponsesJobsCursor,
+  JobRetrieveParams,
   JobRetrieveResponse,
   JobTriggerActionParams,
   JobTriggerActionResponse,
@@ -79,6 +80,7 @@ import { TagListParams, TagListResponse, TagListResponsesTagsCursor, Tags } from
 import {
   UploadCreateParams,
   UploadCreateResponse,
+  UploadRetrieveParams,
   UploadRetrieveResponse,
   UploadTriggerActionParams,
   UploadTriggerActionResponse,
@@ -89,12 +91,14 @@ import {
   WorkflowApproveUserParams,
   WorkflowCreateParams,
   WorkflowCreateResponse,
+  WorkflowDeleteParams,
   WorkflowDeleteResponse,
   WorkflowGetTagsParams,
   WorkflowGetTagsResponse,
   WorkflowListParams,
   WorkflowListResponse,
   WorkflowListResponsesWorkflowsCursor,
+  WorkflowRetrieveParams,
   WorkflowRetrieveResponse,
   WorkflowRunParams,
   WorkflowRunResponse,
@@ -134,10 +138,12 @@ import {
 import {
   CollectionCreateParams,
   CollectionCreateResponse,
+  CollectionDeleteParams,
   CollectionDeleteResponse,
   CollectionListParams,
   CollectionListResponse,
   CollectionListResponsesCollectionsCursor,
+  CollectionRetrieveParams,
   CollectionRetrieveResponse,
   CollectionUpdateParams,
   CollectionUpdateResponse,
@@ -150,6 +156,7 @@ import {
   ModelCreateResponse,
   ModelDeleteImagesParams,
   ModelDeleteImagesResponse,
+  ModelDeleteParams,
   ModelDeleteResponse,
   ModelDownloadParams,
   ModelDownloadResponse,
@@ -1067,8 +1074,10 @@ export declare namespace Scenario {
     type CollectionDeleteResponse as CollectionDeleteResponse,
     type CollectionListResponsesCollectionsCursor as CollectionListResponsesCollectionsCursor,
     type CollectionCreateParams as CollectionCreateParams,
+    type CollectionRetrieveParams as CollectionRetrieveParams,
     type CollectionUpdateParams as CollectionUpdateParams,
     type CollectionListParams as CollectionListParams,
+    type CollectionDeleteParams as CollectionDeleteParams,
   };
 
   export {
@@ -1097,6 +1106,7 @@ export declare namespace Scenario {
     type JobListResponse as JobListResponse,
     type JobTriggerActionResponse as JobTriggerActionResponse,
     type JobListResponsesJobsCursor as JobListResponsesJobsCursor,
+    type JobRetrieveParams as JobRetrieveParams,
     type JobListParams as JobListParams,
     type JobTriggerActionParams as JobTriggerActionParams,
   };
@@ -1119,6 +1129,7 @@ export declare namespace Scenario {
     type ModelRetrieveParams as ModelRetrieveParams,
     type ModelUpdateParams as ModelUpdateParams,
     type ModelListParams as ModelListParams,
+    type ModelDeleteParams as ModelDeleteParams,
     type ModelCopyParams as ModelCopyParams,
     type ModelDeleteImagesParams as ModelDeleteImagesParams,
     type ModelDownloadParams as ModelDownloadParams,
@@ -1154,6 +1165,7 @@ export declare namespace Scenario {
     type UploadRetrieveResponse as UploadRetrieveResponse,
     type UploadTriggerActionResponse as UploadTriggerActionResponse,
     type UploadCreateParams as UploadCreateParams,
+    type UploadRetrieveParams as UploadRetrieveParams,
     type UploadTriggerActionParams as UploadTriggerActionParams,
   };
 
@@ -1175,8 +1187,10 @@ export declare namespace Scenario {
     type WorkflowUserApprovalResponse as WorkflowUserApprovalResponse,
     type WorkflowListResponsesWorkflowsCursor as WorkflowListResponsesWorkflowsCursor,
     type WorkflowCreateParams as WorkflowCreateParams,
+    type WorkflowRetrieveParams as WorkflowRetrieveParams,
     type WorkflowUpdateParams as WorkflowUpdateParams,
     type WorkflowListParams as WorkflowListParams,
+    type WorkflowDeleteParams as WorkflowDeleteParams,
     type WorkflowGetTagsParams as WorkflowGetTagsParams,
     type WorkflowRunParams as WorkflowRunParams,
     type WorkflowUserApprovalParams as WorkflowUserApprovalParams,

package/src/lib/job.ts

@@ -3,6 +3,7 @@ import type { APIPromise } from '../core/api-promise';
 import type { RequestOptions } from '../internal/request-options';
 import {
   Jobs,
+  type JobRetrieveParams,
   type JobRetrieveResponse,
   type JobTriggerActionParams,
   type JobTriggerActionResponse,
@@ -49,7 +50,7 @@ export class JobMethods {
     let elapsed = 0;
 
     while (elapsed < timeoutMs) {
-      const response = await this._client.jobs.retrieve(this.jobId, withScope(scope));
+      const response = await this._client.jobs.retrieve(this.jobId, undefined, withScope(scope));
 
       if (TERMINAL_STATUSES.has(response.job.status)) {
         return Job.from(this._client, response.job, scope);
@@ -107,8 +108,12 @@ export function enhanceJob<T extends { job: { jobId: string; status: string } }>
  * typically fetch individual jobs via `retrieve` before acting on them.
  */
 export class EnhancedJobs extends Jobs {
-  override retrieve(jobID: string, options?: RequestOptions): APIPromise<WithJob<JobRetrieveResponse>> {
-    return enhanceJob(this._client, super.retrieve(jobID, options), options);
+  override retrieve(
+    jobID: string,
+    query: JobRetrieveParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<WithJob<JobRetrieveResponse>> {
+    return enhanceJob(this._client, super.retrieve(jobID, query, options), options);
   }
 
   override triggerAction(

package/src/lib/upload.ts

@@ -5,6 +5,7 @@ import {
   Uploads,
   type UploadCreateParams,
   type UploadCreateResponse,
+  type UploadRetrieveParams,
   type UploadRetrieveResponse,
   type UploadTriggerActionParams,
   type UploadTriggerActionResponse,
@@ -113,7 +114,7 @@ export class UploadMethods {
   async wait(this: Upload, options?: UploadWaitOptions): Promise<Upload> {
     const scope = waitOverrideScope(options) ?? this._scope;
     const final = await pollUntilImported(
-      () => this._client.uploads.retrieve(this.id, withScope(scope)),
+      () => this._client.uploads.retrieve(this.id, undefined, withScope(scope)),
       options?.intervalMs ?? 2_000,
       options?.timeoutMs ?? 300_000,
     );
@@ -174,9 +175,10 @@ export class EnhancedUploads extends Uploads {
 
   override retrieve(
     uploadID: string,
+    query: UploadRetrieveParams | null | undefined = {},
     options?: RequestOptions,
   ): APIPromise<WithUpload<UploadRetrieveResponse>> {
-    return enhanceUpload(this._client, super.retrieve(uploadID, options), options);
+    return enhanceUpload(this._client, super.retrieve(uploadID, query, options), options);
   }
 
   override triggerAction(
@@ -269,7 +271,7 @@ export class EnhancedUploads extends Uploads {
 
     // Step 4 — poll until the upload has been processed into an entity.
     const final = await pollUntilImported(
-      () => this.retrieve(uploadId, options),
+      () => this.retrieve(uploadId, undefined, options),
       params.pollIntervalMs ?? 2_000,
       params.pollTimeoutMs ?? 300_000,
     );

package/src/lib/workflow.ts

@@ -4,6 +4,7 @@ import {
   Workflows,
   WorkflowUserApprovalResponse,
   type WorkflowApproveUserParams,
+  type WorkflowRetrieveParams,
   type WorkflowRetrieveResponse,
   type WorkflowRunParams,
   type WorkflowRunResponse,
@@ -104,11 +105,12 @@ export class EnhancedWorkflows extends Workflows {
    */
   override retrieve(
     workflowID: string,
+    query: WorkflowRetrieveParams | null | undefined = {},
     options?: RequestOptions,
   ): APIPromise<EnhancedWorkflowRetrieveResponse> {
     const client = this._client as Scenario;
     const scope = effectiveScope(options, client.projectId);
-    return super.retrieve(workflowID, options)._thenUnwrap((data) => ({
+    return super.retrieve(workflowID, query, options)._thenUnwrap((data) => ({
       ...data,
       workflow: WorkflowEntity.from(client, data.workflow, scope),
     }));

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({