@scenario-labs/sdk 2.2.1 → 2.4.0-alpha.1

package/src/lib/generate.ts

@@ -29,35 +29,35 @@ export class EnhancedGenerate extends Generate {
     params: GenerateCaptionParams,
     options?: RequestOptions,
   ): APIPromise<WithJob<GenerateCaptionResponse>> {
-    return enhanceJob(this._client, super.caption(params, options));
+    return enhanceJob(this._client, super.caption(params, options), options);
   }
 
   override describeStyle(
     params: GenerateDescribeStyleParams,
     options?: RequestOptions,
   ): APIPromise<WithJob<GenerateDescribeStyleResponse>> {
-    return enhanceJob(this._client, super.describeStyle(params, options));
+    return enhanceJob(this._client, super.describeStyle(params, options), options);
   }
 
   override detect(
     params: GenerateDetectParams,
     options?: RequestOptions,
   ): APIPromise<WithJob<GenerateDetectResponse>> {
-    return enhanceJob(this._client, super.detect(params, options));
+    return enhanceJob(this._client, super.detect(params, options), options);
   }
 
   override embed(
     params: GenerateEmbedParams,
     options?: RequestOptions,
   ): APIPromise<WithJob<GenerateEmbedResponse>> {
-    return enhanceJob(this._client, super.embed(params, options));
+    return enhanceJob(this._client, super.embed(params, options), options);
   }
 
   override patch(
     params: GeneratePatchParams,
     options?: RequestOptions,
   ): APIPromise<WithJob<GeneratePatchResponse>> {
-    return enhanceJob(this._client, super.patch(params, options));
+    return enhanceJob(this._client, super.patch(params, options), options);
   }
 
   override runModel(
@@ -65,13 +65,13 @@ export class EnhancedGenerate extends Generate {
     params: GenerateRunModelParams,
     options?: RequestOptions,
   ): APIPromise<WithJob<GenerateRunModelResponse>> {
-    return enhanceJob(this._client, super.runModel(modelID, params, options));
+    return enhanceJob(this._client, super.runModel(modelID, params, options), options);
   }
 
   override translate(
     params: GenerateTranslateParams,
     options?: RequestOptions,
   ): APIPromise<WithJob<GenerateTranslateResponse>> {
-    return enhanceJob(this._client, super.translate(params, options));
+    return enhanceJob(this._client, super.translate(params, options), options);
   }
 }

package/src/lib/job.ts

@@ -7,12 +7,19 @@ import {
   type JobTriggerActionParams,
   type JobTriggerActionResponse,
 } from '../resources/jobs';
+import { type Scope, clientProjectId, effectiveScope, withScope } from './scope';
 
 export interface WaitOptions {
   /** Polling interval in milliseconds. Default: 3000 */
   intervalMs?: number;
   /** Maximum wait time in milliseconds. Default: 120000 */
   timeoutMs?: number;
+  /**
+   * Override the project scope used for the polling requests. Defaults to
+   * the scope captured on the job (per-call override on the originating
+   * call, else the client's default project).
+   */
+  projectId?: string;
 }
 
 type JobStatus = JobRetrieveResponse.Job['status'];
@@ -22,6 +29,8 @@ const TERMINAL_STATUSES: Set<JobStatus> = new Set(['success', 'failure', 'cancel
 /** Job methods added on top of the original job fields. */
 export class JobMethods {
   /** @internal */ declare readonly _client: Scenario;
+  /** @internal scope captured from the originating call — replayed on every `.wait()` poll. */
+  declare readonly _scope?: Scope;
 
   /**
    * Poll until the job reaches a terminal status (success, failure, or canceled).
@@ -36,13 +45,14 @@ export class JobMethods {
   async wait(this: Job, options?: WaitOptions): Promise<Job> {
     const intervalMs = options?.intervalMs ?? 3_000;
     const timeoutMs = options?.timeoutMs ?? 120_000;
+    const scope = waitOverrideScope(options) ?? this._scope;
     let elapsed = 0;
 
     while (elapsed < timeoutMs) {
-      const response = await this._client.jobs.retrieve(this.jobId);
+      const response = await this._client.jobs.retrieve(this.jobId, withScope(scope));
 
       if (TERMINAL_STATUSES.has(response.job.status)) {
-        return Job.from(this._client, response.job);
+        return Job.from(this._client, response.job, scope);
       }
 
       await new Promise((resolve) => setTimeout(resolve, intervalMs));
@@ -52,10 +62,11 @@ export class JobMethods {
     throw new Error(`Job ${this.jobId} did not complete within ${timeoutMs / 1_000}s`);
   }
 
-  /** @internal Create a Job from raw job data. */
-  static from(client: Scenario, data: JobRetrieveResponse['job']): Job {
+  /** @internal Create a Job from raw job data, optionally remembering the originating scope. */
+  static from(client: Scenario, data: JobRetrieveResponse['job'], scope?: Scope): Job {
     const job = Object.assign(Object.create(JobMethods.prototype), data) as Job;
     Object.defineProperty(job, '_client', { value: client, enumerable: false });
+    if (scope) Object.defineProperty(job, '_scope', { value: scope, enumerable: false });
     return job;
   }
 }
@@ -72,14 +83,19 @@ export type WithJob<T extends { job: unknown }> = T & { job: JobMethods };
 
 /**
  * @internal Wrap `_thenUnwrap` to replace `response.job` with an enhanced Job.
+ * Captures the effective scope (per-call override or client default) so
+ * `.wait()` can replay it on every poll — keeping follow-up calls in sync
+ * with the project the job was originally created in.
  */
 export function enhanceJob<T extends { job: { jobId: string; status: string } }>(
   client: Scenario,
   promise: APIPromise<T>,
+  options?: RequestOptions,
 ): APIPromise<WithJob<T>> {
+  const scope = effectiveScope(options, clientProjectId(client));
   return promise._thenUnwrap((data) => ({
     ...data,
-    job: Job.from(client, data.job as JobRetrieveResponse['job']),
+    job: Job.from(client, data.job as JobRetrieveResponse['job'], scope),
   }));
 }
 
@@ -92,7 +108,7 @@ export function enhanceJob<T extends { job: { jobId: string; status: string } }>
  */
 export class EnhancedJobs extends Jobs {
   override retrieve(jobID: string, options?: RequestOptions): APIPromise<WithJob<JobRetrieveResponse>> {
-    return enhanceJob(this._client, super.retrieve(jobID, options));
+    return enhanceJob(this._client, super.retrieve(jobID, options), options);
   }
 
   override triggerAction(
@@ -100,6 +116,12 @@ export class EnhancedJobs extends Jobs {
     params: JobTriggerActionParams,
     options?: RequestOptions,
   ): APIPromise<WithJob<JobTriggerActionResponse>> {
-    return enhanceJob(this._client, super.triggerAction(jobID, params, options));
+    return enhanceJob(this._client, super.triggerAction(jobID, params, options), options);
   }
 }
+
+/** Resolve the scope override carried by a `WaitOptions`, if any. */
+function waitOverrideScope(options?: WaitOptions): Scope | undefined {
+  if (!options?.projectId) return undefined;
+  return { projectId: options.projectId };
+}

package/src/lib/models.ts

@@ -4,6 +4,7 @@ import type { GenerateRunModelParams, GenerateRunModelResponse } from '../resour
 import { Models, type ModelRetrieveParams, type ModelRetrieveResponse } from '../resources/models/models';
 import { Train, type TrainTriggerParams, type TrainTriggerResponse } from '../resources/models/train';
 import { type WithJob, enhanceJob } from './job';
+import { type Scope, effectiveScope, withScope } from './scope';
 // Type-only import to break the circular `scenario.ts` ↔ `models.ts` graph at runtime.
 import type { Scenario } from './scenario';
 
@@ -20,28 +21,35 @@ import type { Scenario } from './scenario';
  */
 export class ModelEntity {
   /** @internal */ declare readonly _client: Scenario;
+  /** @internal scope captured from the retrieve call — replayed when `.run()` is invoked without an explicit query override. */
+  declare readonly _scope?: Scope;
 
   /**
    * Generate with this model. Shortcut for
    * `client.generate.runModel(this.id, params)`.
    *
    * Returns an enhanced response where `response.job` has `.wait()`.
+   * If the model was fetched with a `projectId` scope (per-call override or
+   * client default), that scope is reused unless overridden by
+   * `options.query`.
    */
   run(
     this: ModelEntity & ModelRetrieveResponse.Model,
     params: GenerateRunModelParams,
     options?: RequestOptions,
   ): APIPromise<WithJob<GenerateRunModelResponse>> {
-    return this._client.generate.runModel(this.id, params, options);
+    return this._client.generate.runModel(this.id, params, withScope(this._scope, options));
   }
 
-  /** @internal Create a ModelEntity wrapping raw model data. */
+  /** @internal Create a ModelEntity wrapping raw model data, optionally remembering the originating scope. */
   static from(
     client: Scenario,
     data: ModelRetrieveResponse.Model,
+    scope?: Scope,
   ): ModelRetrieveResponse.Model & ModelEntity {
     const entity = Object.assign(Object.create(ModelEntity.prototype), data);
     Object.defineProperty(entity, '_client', { value: client, enumerable: false });
+    if (scope) Object.defineProperty(entity, '_scope', { value: scope, enumerable: false });
     return entity;
   }
 }
@@ -61,7 +69,7 @@ export class EnhancedTrain extends Train {
     params: TrainTriggerParams,
     options?: RequestOptions,
   ): APIPromise<WithJob<TrainTriggerResponse>> {
-    return enhanceJob(this._client, super.trigger(modelID, params, options));
+    return enhanceJob(this._client, super.trigger(modelID, params, options), options);
   }
 }
 
@@ -79,9 +87,11 @@ export class EnhancedModels extends Models {
     query: ModelRetrieveParams | null | undefined = {},
     options?: RequestOptions,
   ): APIPromise<EnhancedModelRetrieveResponse> {
+    const client = this._client as Scenario;
+    const scope = effectiveScope(options, client.projectId);
     return super.retrieve(modelID, query, options)._thenUnwrap((data) => ({
       ...data,
-      model: ModelEntity.from(this._client as Scenario, data.model),
+      model: ModelEntity.from(client, data.model, scope),
     }));
   }
 }

package/src/lib/scenario.ts

@@ -1,4 +1,4 @@
-import { Scenario as BaseScenario } from '../client';
+import { Scenario as BaseScenario, type ClientOptions as BaseClientOptions } from '../client';
 import { EnhancedAssets } from './asset';
 import { EnhancedGenerate } from './generate';
 import { EnhancedJobs } from './job';
@@ -6,6 +6,23 @@ import { EnhancedModels } from './models';
 import { EnhancedUploads } from './upload';
 import { EnhancedWorkflows } from './workflow';
 
+export interface ClientOptions extends BaseClientOptions {
+  /**
+   * Default project to scope every request to (sent as `?projectId=...`).
+   *
+   * Useful with `bearerAuth` when the user belongs to multiple projects —
+   * the server derives the team from the project, so `teamId` doesn't need
+   * to be configured at construction time. With `apiKey` auth, the project
+   * is already implied by the key and this option is unnecessary.
+   *
+   * Per-call `options.query.projectId` overrides this default for a single
+   * request. SDK helpers (`.wait()`, `model.run()`, ...) reuse the scope
+   * effective on the originating call, so an action created in project A
+   * keeps polling in project A even if the client default changes later.
+   */
+  projectId?: string | null | undefined;
+}
+
 /**
  * Enhanced Scenario client.
  *
@@ -17,23 +34,19 @@ import { EnhancedWorkflows } from './workflow';
  * ```ts
  * import Scenario from '@scenario-labs/sdk';
  *
- * const client = new Scenario({ apiKey: '...' });
+ * // With API key — project is implied by the key.
+ * const client = new Scenario({ apiKey: '...', apiSecret: '...' });
+ *
+ * // With bearer JWT — pin a default project for all requests.
+ * const client = new Scenario({ bearerAuth: jwt, projectId: 'proj_abc' });
  *
- * // All generated methods work as-is
- * const list = await client.assets.list({});
+ * // Per-call override (one request only):
+ * await client.uploads.uploadFile(params, { query: { projectId: 'proj_other' } });
  *
- * // Enhanced: response.job.wait()
+ * // Enhanced: response.job.wait() — auto-reuses the scope of the call that produced the job
  * const run = await client.workflows.run(workflowId, { body });
  * const completed = await run.job.wait();
  *
- * // Enhanced: response.workflow.findNode()
- * const wf = await client.workflows.retrieve(workflowId);
- * wf.workflow.findNode('final_image');
- *
- * // Enhanced: generate job.wait()
- * const gen = await client.generate.runModel(modelId, { body });
- * const done = await gen.job.wait();
- *
  * // Enhanced: upload.wait()
  * const res = await client.uploads.retrieve(uploadId);
  * const imported = await res.upload.wait();
@@ -50,4 +63,29 @@ export class Scenario extends BaseScenario {
   override uploads: EnhancedUploads = new EnhancedUploads(this);
   override assets: EnhancedAssets = new EnhancedAssets(this);
   override jobs: EnhancedJobs = new EnhancedJobs(this);
+
+  /** The default project this client scopes every request to, or `null` if unset. */
+  readonly projectId: string | null;
+
+  constructor(options: ClientOptions = {}) {
+    const { projectId, defaultQuery, ...rest } = options;
+    // Strip any stale projectId from defaultQuery so the typed field is the
+    // single source of truth (matters when `withOptions` reconstructs the client).
+    const cleanedDefaultQuery = stripKey(defaultQuery, 'projectId');
+    super({
+      ...rest,
+      // Pass projectId through so it lands in `_options` and survives a
+      // `withOptions()` round-trip. The base ClientOptions doesn't declare
+      // this field, hence the cast.
+      projectId,
+      defaultQuery: projectId ? { ...cleanedDefaultQuery, projectId } : cleanedDefaultQuery,
+    } as BaseClientOptions);
+    this.projectId = projectId ?? null;
+  }
+}
+
+function stripKey<T extends object>(obj: T | undefined, key: string): Partial<T> | undefined {
+  if (!obj || !(key in obj)) return obj;
+  const { [key]: _omit, ...rest } = obj as Record<string, unknown>;
+  return rest as Partial<T>;
 }

package/src/lib/scope.ts

@@ -0,0 +1,68 @@
+import type { RequestOptions } from '../internal/request-options';
+
+/**
+ * Per-request project scope.
+ *
+ * With API-key auth, the server resolves the project from the key. With
+ * bearer (JWT) auth a user can belong to multiple projects, so callers must
+ * specify which one to act on by passing `projectId` as a query param
+ * (the server derives `teamId` from it — no need to send it explicitly).
+ *
+ * SDK helpers like `Job.wait()` and `Upload.wait()` make follow-up calls
+ * internally — they capture the scope effective on the originating call and
+ * forward it on each retry, so an action created in project A always polls
+ * in project A even if the client default changes between calls.
+ */
+export interface Scope {
+  projectId?: string;
+}
+
+/** Extract `projectId` from a `RequestOptions.query`. Returns `undefined` if absent. */
+export function extractScope(options?: RequestOptions): Scope | undefined {
+  const query = options?.query as Record<string, unknown> | undefined;
+  if (!query) return undefined;
+  const projectId = typeof query['projectId'] === 'string' ? query['projectId'] : undefined;
+  if (!projectId) return undefined;
+  return { projectId };
+}
+
+/**
+ * Resolve the effective scope for an outgoing call:
+ *   1. If the per-call options carry a `projectId` query — use that (the explicit override wins).
+ *   2. Otherwise, fall back to the client's default `projectId`.
+ *   3. If neither is set (e.g. API-key auth with implicit scope), return `undefined`.
+ *
+ * Returns the snapshot we want to *capture on an enhanced entity* so that
+ * follow-up helper calls (`.wait()`, `entity.run()`, ...) reuse the same
+ * scope and stay in sync with the call that produced them.
+ */
+export function effectiveScope(
+  options: RequestOptions | undefined,
+  fallbackProjectId: string | null | undefined,
+): Scope | undefined {
+  const override = extractScope(options);
+  if (override) return override;
+  if (fallbackProjectId) return { projectId: fallbackProjectId };
+  return undefined;
+}
+
+/**
+ * Read the client's default `projectId` without repeating the structural
+ * cast at every call site. The base generated `Scenario` type doesn't
+ * declare `projectId` — only the enhanced one in `./scenario` does — so
+ * `lib/` modules that import `Scenario` from `'../client'` use this helper
+ * instead of duplicating the same cast inline.
+ */
+export function clientProjectId(client: unknown): string | null | undefined {
+  return (client as { projectId?: string | null }).projectId;
+}
+
+/** Build a `RequestOptions` that adds the scope as a query param, merging into any existing query. */
+export function withScope(scope: Scope | undefined, options?: RequestOptions): RequestOptions | undefined {
+  if (!scope?.projectId) return options;
+  const existingQuery = (options?.query as Record<string, unknown> | undefined) ?? {};
+  return {
+    ...options,
+    query: { ...existingQuery, projectId: scope.projectId },
+  };
+}

package/src/lib/upload.ts

@@ -11,6 +11,7 @@ import {
 } from '../resources/uploads';
 import type { AssetRetrieveResponse } from '../resources/assets/assets';
 import type { ModelRetrieveResponse } from '../resources/models/models';
+import { type Scope, clientProjectId, effectiveScope, withScope } from './scope';
 
 type UploadKind = NonNullable<UploadCreateParams['kind']>;
 
@@ -81,11 +82,19 @@ export interface UploadWaitOptions {
   intervalMs?: number;
   /** Maximum wait time in milliseconds. Default: 300000 */
   timeoutMs?: number;
+  /**
+   * Override the project scope used for the polling requests. Defaults to
+   * the scope captured on the upload (per-call override on the originating
+   * call, else the client's default project).
+   */
+  projectId?: string;
 }
 
 /** Upload methods added on top of the original upload fields. */
 export class UploadMethods {
   /** @internal */ declare readonly _client: Scenario;
+  /** @internal scope captured from the originating call — replayed on every `.wait()` poll. */
+  declare readonly _scope?: Scope;
 
   /**
    * Poll until the upload has been processed into an entity (asset or model),
@@ -102,18 +111,20 @@ 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),
+      () => this._client.uploads.retrieve(this.id, withScope(scope)),
       options?.intervalMs ?? 2_000,
       options?.timeoutMs ?? 300_000,
     );
-    return UploadMethods.from(this._client, final.upload);
+    return UploadMethods.from(this._client, final.upload, scope);
   }
 
-  /** @internal Create an Upload from raw upload data. */
-  static from(client: Scenario, data: UploadRetrieveResponse['upload']): Upload {
+  /** @internal Create an Upload from raw upload data, optionally remembering the originating scope. */
+  static from(client: Scenario, data: UploadRetrieveResponse['upload'], scope?: Scope): Upload {
     const upload = Object.assign(Object.create(UploadMethods.prototype), data) as Upload;
     Object.defineProperty(upload, '_client', { value: client, enumerable: false });
+    if (scope) Object.defineProperty(upload, '_scope', { value: scope, enumerable: false });
     return upload;
   }
 }
@@ -130,14 +141,19 @@ export type WithUpload<T extends { upload: unknown }> = T & { upload: UploadMeth
 
 /**
  * @internal Wrap `_thenUnwrap` to replace `response.upload` with an enhanced Upload.
+ * Captures the effective scope (per-call override or client default) so
+ * `.wait()` can replay it on every poll — keeping follow-up calls in sync
+ * with the project the upload was originally created in.
  */
 export function enhanceUpload<T extends { upload: { id: string; status: string } }>(
   client: Scenario,
   promise: APIPromise<T>,
+  options?: RequestOptions,
 ): APIPromise<WithUpload<T>> {
+  const scope = effectiveScope(options, clientProjectId(client));
   return promise._thenUnwrap((data) => ({
     ...data,
-    upload: Upload.from(client, data.upload as UploadRetrieveResponse['upload']),
+    upload: Upload.from(client, data.upload as UploadRetrieveResponse['upload'], scope),
   }));
 }
 
@@ -153,14 +169,14 @@ export class EnhancedUploads extends Uploads {
     body: UploadCreateParams,
     options?: RequestOptions,
   ): APIPromise<WithUpload<UploadCreateResponse>> {
-    return enhanceUpload(this._client, super.create(body, options));
+    return enhanceUpload(this._client, super.create(body, options), options);
   }
 
   override retrieve(
     uploadID: string,
     options?: RequestOptions,
   ): APIPromise<WithUpload<UploadRetrieveResponse>> {
-    return enhanceUpload(this._client, super.retrieve(uploadID, options));
+    return enhanceUpload(this._client, super.retrieve(uploadID, options), options);
   }
 
   override triggerAction(
@@ -168,7 +184,7 @@ export class EnhancedUploads extends Uploads {
     body: UploadTriggerActionParams,
     options?: RequestOptions,
   ): APIPromise<WithUpload<UploadTriggerActionResponse>> {
-    return enhanceUpload(this._client, super.triggerAction(uploadID, body, options));
+    return enhanceUpload(this._client, super.triggerAction(uploadID, body, options), options);
   }
 
   /**
@@ -266,16 +282,25 @@ export class EnhancedUploads extends Uploads {
       throw new Error(`Upload ${uploadId} reached status "${final.upload.status}" but has no entityId`);
     }
 
-    // Fetch and return the resolved entity (narrowed by kind).
+    // Fetch and return the resolved entity (narrowed by kind). Forward the
+    // original options so any per-call `projectId` query is passed through
+    // to the final retrieve (necessary under bearer auth with per-call
+    // scope overrides).
     if (params.kind === 'model') {
-      const model = await this._client.models.retrieve(entityId);
+      const model = await this._client.models.retrieve(entityId, undefined, options);
       return model as UploadResult<K>;
     }
-    const asset = await this._client.assets.retrieve(entityId);
+    const asset = await this._client.assets.retrieve(entityId, undefined, options);
     return asset as UploadResult<K>;
   }
 }
 
+/** Resolve the scope override carried by an `UploadWaitOptions`, if any. */
+function waitOverrideScope(options?: UploadWaitOptions): Scope | undefined {
+  if (!options?.projectId) return undefined;
+  return { projectId: options.projectId };
+}
+
 // ─────────────────────── helpers ───────────────────────
 
 async function normalizeToBytes(input: UploadFileInput): Promise<Uint8Array> {

package/src/lib/workflow.ts

@@ -9,6 +9,7 @@ import {
   type WorkflowRunResponse,
 } from '../resources/workflows';
 import { type WithJob, enhanceJob } from './job';
+import { type Scope, effectiveScope, withScope } from './scope';
 import { validateWorkflowFlow } from './workflow_validator';
 // Type-only import to break the circular `scenario.ts` ↔ `workflow.ts` graph at runtime.
 import type { Scenario } from './scenario';
@@ -32,6 +33,8 @@ type NodeType = DefinitionFlow['type'];
  */
 export class WorkflowEntity {
   /** @internal */ declare readonly _client: Scenario;
+  /** @internal scope captured from the retrieve call — replayed when `.run()` is invoked without an explicit query override. */
+  declare readonly _scope?: Scope;
 
   /** Find a node in the workflow definition by ID. */
   findNode(
@@ -59,22 +62,27 @@ export class WorkflowEntity {
    * `client.workflows.run(this.id, params)`.
    *
    * Returns an enhanced response where `response.job` has `.wait()`.
+   * If the workflow was fetched with a `projectId` scope (per-call override
+   * or client default), that scope is reused unless overridden by
+   * `options.query`.
    */
   run(
     this: WorkflowEntity & WorkflowRetrieveResponse.Workflow,
     params: WorkflowRunParams,
     options?: RequestOptions,
   ): APIPromise<WithJob<WorkflowRunResponse>> {
-    return this._client.workflows.run(this.id, params, options);
+    return this._client.workflows.run(this.id, params, withScope(this._scope, options));
   }
 
-  /** @internal Create a WorkflowEntity from raw workflow data. */
+  /** @internal Create a WorkflowEntity from raw workflow data, optionally remembering the originating scope. */
   static from(
     client: Scenario,
     data: WorkflowRetrieveResponse.Workflow,
+    scope?: Scope,
   ): WorkflowRetrieveResponse.Workflow & WorkflowEntity {
     const entity = Object.assign(Object.create(WorkflowEntity.prototype), data);
     Object.defineProperty(entity, '_client', { value: client, enumerable: false });
+    if (scope) Object.defineProperty(entity, '_scope', { value: scope, enumerable: false });
     return entity;
   }
 }
@@ -98,9 +106,11 @@ export class EnhancedWorkflows extends Workflows {
     workflowID: string,
     options?: RequestOptions,
   ): APIPromise<EnhancedWorkflowRetrieveResponse> {
+    const client = this._client as Scenario;
+    const scope = effectiveScope(options, client.projectId);
     return super.retrieve(workflowID, options)._thenUnwrap((data) => ({
       ...data,
-      workflow: WorkflowEntity.from(this._client as Scenario, data.workflow),
+      workflow: WorkflowEntity.from(client, data.workflow, scope),
     }));
   }
 
@@ -110,7 +120,7 @@ export class EnhancedWorkflows extends Workflows {
     params: WorkflowRunParams,
     options?: RequestOptions,
   ): APIPromise<WithJob<WorkflowRunResponse>> {
-    return enhanceJob(this._client, super.run(workflowID, params, options));
+    return enhanceJob(this._client, super.run(workflowID, params, options), options);
   }
 
   /** Approve a user approval node. Returns an enhanced response where `job` has `.wait()`. */
@@ -119,6 +129,6 @@ export class EnhancedWorkflows extends Workflows {
     body: WorkflowApproveUserParams,
     options?: RequestOptions,
   ): APIPromise<WithJob<WorkflowUserApprovalResponse>> {
-    return enhanceJob(this._client, super.userApproval(workflowID, body, options));
+    return enhanceJob(this._client, super.userApproval(workflowID, body, options), options);
   }
 }