@scenario-labs/sdk 1.0.0 → 1.2.0

package/src/client.ts

@@ -49,6 +49,8 @@ import {
   GenerateEmbedResponse,
   GeneratePatchParams,
   GeneratePatchResponse,
+  GeneratePromptParams,
+  GeneratePromptResponse,
   GenerateRunModelParams,
   GenerateRunModelResponse,
   GenerateTranslateParams,
@@ -85,7 +87,6 @@ import {
 import { UsageListParams, UsageListResponse, Usages } from './resources/usages';
 import {
   WorkflowApproveUserParams,
-  WorkflowApproveUserResponse,
   WorkflowCreateParams,
   WorkflowCreateResponse,
   WorkflowDeleteResponse,
@@ -99,6 +100,8 @@ import {
   WorkflowRunResponse,
   WorkflowUpdateParams,
   WorkflowUpdateResponse,
+  WorkflowUserApprovalParams,
+  WorkflowUserApprovalResponse,
   Workflows,
 } from './resources/workflows';
 import {
@@ -165,6 +168,7 @@ import {
   ModelUpdateTagsResponse,
   Models,
 } from './resources/models/models';
+import { Pricing } from './resources/pricing/pricing';
 import { type Fetch } from './internal/builtin-types';
 import { HeadersLike, NullableHeaders, buildHeaders } from './internal/headers';
 import { FinalRequestOptions, RequestOptions } from './internal/request-options';
@@ -328,6 +332,18 @@ export class Scenario {
     this.fetch = options.fetch ?? Shims.getDefaultFetch();
     this.#encoder = Opts.FallbackEncoder;
 
+    const customHeadersEnv = readEnv('SCENARIO_CUSTOM_HEADERS');
+    if (customHeadersEnv) {
+      const parsed: Record<string, string> = {};
+      for (const line of customHeadersEnv.split('\n')) {
+        const colon = line.indexOf(':');
+        if (colon >= 0) {
+          parsed[line.substring(0, colon).trim()] = line.substring(colon + 1).trim();
+        }
+      }
+      options.defaultHeaders = { ...parsed, ...options.defaultHeaders };
+    }
+
     this._options = options;
 
     this.apiKey = apiKey;
@@ -387,14 +403,8 @@ export class Scenario {
     );
   }
 
-  protected async authHeaders(
-    opts: FinalRequestOptions,
-    schemes: { scBasicAuth?: boolean; scBearerAuth?: boolean },
-  ): Promise<NullableHeaders | undefined> {
-    return buildHeaders([
-      schemes.scBasicAuth ? await this.scBasicAuth(opts) : null,
-      schemes.scBearerAuth ? await this.scBearerAuth(opts) : null,
-    ]);
+  protected async authHeaders(opts: FinalRequestOptions): Promise<NullableHeaders | undefined> {
+    return buildHeaders([await this.scBasicAuth(opts), await this.scBearerAuth(opts)]);
   }
 
   protected async scBasicAuth(opts: FinalRequestOptions): Promise<NullableHeaders | undefined> {
@@ -865,7 +875,7 @@ export class Scenario {
         ...(options.timeout ? { 'X-Stainless-Timeout': String(Math.trunc(options.timeout / 1000)) } : {}),
         ...getPlatformHeaders(),
       },
-      await this.authHeaders(options, options.__security ?? { scBasicAuth: true, scBearerAuth: true }),
+      await this.authHeaders(options),
       this._options.defaultHeaders,
       bodyHeaders,
       options.headers,
@@ -951,6 +961,7 @@ export class Scenario {
   generate: API.Generate = new API.Generate(this);
   jobs: API.Jobs = new API.Jobs(this);
   models: API.Models = new API.Models(this);
+  pricing: API.Pricing = new API.Pricing(this);
   oscu: API.Oscu = new API.Oscu(this);
   search: API.Search = new API.Search(this);
   tags: API.Tags = new API.Tags(this);
@@ -964,6 +975,7 @@ Scenario.Collections = Collections;
 Scenario.Generate = Generate;
 Scenario.Jobs = Jobs;
 Scenario.Models = Models;
+Scenario.Pricing = Pricing;
 Scenario.Oscu = Oscu;
 Scenario.Search = Search;
 Scenario.Tags = Tags;
@@ -1058,6 +1070,7 @@ export declare namespace Scenario {
     type GenerateDetectResponse as GenerateDetectResponse,
     type GenerateEmbedResponse as GenerateEmbedResponse,
     type GeneratePatchResponse as GeneratePatchResponse,
+    type GeneratePromptResponse as GeneratePromptResponse,
     type GenerateRunModelResponse as GenerateRunModelResponse,
     type GenerateTranslateResponse as GenerateTranslateResponse,
     type GenerateCaptionParams as GenerateCaptionParams,
@@ -1065,6 +1078,7 @@ export declare namespace Scenario {
     type GenerateDetectParams as GenerateDetectParams,
     type GenerateEmbedParams as GenerateEmbedParams,
     type GeneratePatchParams as GeneratePatchParams,
+    type GeneratePromptParams as GeneratePromptParams,
     type GenerateRunModelParams as GenerateRunModelParams,
     type GenerateTranslateParams as GenerateTranslateParams,
   };
@@ -1105,6 +1119,8 @@ export declare namespace Scenario {
     type ModelUpdateTagsParams as ModelUpdateTagsParams,
   };
 
+  export { Pricing as Pricing };
+
   export { Oscu as Oscu, type OscuRetrievePricesResponse as OscuRetrievePricesResponse };
 
   export {
@@ -1146,9 +1162,9 @@ export declare namespace Scenario {
     type WorkflowUpdateResponse as WorkflowUpdateResponse,
     type WorkflowListResponse as WorkflowListResponse,
     type WorkflowDeleteResponse as WorkflowDeleteResponse,
-    type WorkflowApproveUserResponse as WorkflowApproveUserResponse,
     type WorkflowGetTagsResponse as WorkflowGetTagsResponse,
     type WorkflowRunResponse as WorkflowRunResponse,
+    type WorkflowUserApprovalResponse as WorkflowUserApprovalResponse,
     type WorkflowListResponsesWorkflowsCursor as WorkflowListResponsesWorkflowsCursor,
     type WorkflowCreateParams as WorkflowCreateParams,
     type WorkflowUpdateParams as WorkflowUpdateParams,
@@ -1156,5 +1172,6 @@ export declare namespace Scenario {
     type WorkflowApproveUserParams as WorkflowApproveUserParams,
     type WorkflowGetTagsParams as WorkflowGetTagsParams,
     type WorkflowRunParams as WorkflowRunParams,
+    type WorkflowUserApprovalParams as WorkflowUserApprovalParams,
   };
 }

package/src/index.ts

@@ -22,7 +22,7 @@ export {
   PermissionDeniedError,
   UnprocessableEntityError,
 } from './core/error';
-export { Job, type WaitOptions, type WithJob } from './lib/job';
+export { EnhancedJobs, Job, type WaitOptions, type WithJob } from './lib/job';
 export { EnhancedWorkflows, WorkflowEntity } from './lib/workflow';
 export { validateWorkflowFlow } from './lib/workflow_validator';
 export {
@@ -34,3 +34,5 @@ export {
 } from './lib/workflow_import_validator';
 export { EnhancedGenerate } from './lib/generate';
 export { EnhancedModels, EnhancedTrain } from './lib/models';
+export { EnhancedUploads, Upload, type UploadWaitOptions, type WithUpload } from './lib/upload';
+export { EnhancedAssets, Asset, type WithAsset } from './lib/asset';

package/src/internal/request-options.ts

@@ -75,8 +75,6 @@ export type RequestOptions = {
    */
   defaultBaseURL?: string | undefined;
 
-  __security?: { scBasicAuth?: boolean; scBearerAuth?: boolean };
-
   __binaryResponse?: boolean | undefined;
 };
 

package/src/lib/asset.ts

@@ -0,0 +1,85 @@
+import type { APIPromise } from '../core/api-promise';
+import type { RequestOptions } from '../internal/request-options';
+import {
+  Assets,
+  type AssetRetrieveParams,
+  type AssetRetrieveResponse,
+  type AssetUpdateParams,
+  type AssetUpdateResponse,
+} from '../resources/assets/assets';
+
+/** Asset methods added on top of the original asset fields. */
+export class AssetMethods {
+  /**
+   * Fetch the asset's content as bytes, using the signed `url` field on the
+   * asset. Works in Node ≥18 and in browsers with no extra setup.
+   *
+   * This is a thin wrapper around `fetch(asset.url)` — use `asset.url`
+   * directly if you need streaming or a Response object.
+   *
+   * @example
+   * ```ts
+   * const res = await client.assets.retrieve(assetId);
+   * const bytes = await res.asset.download();
+   * await fs.writeFile('out.png', bytes);
+   * ```
+   */
+  async download(this: Asset): Promise<Uint8Array> {
+    const res = await fetch(this.url);
+    if (!res.ok) {
+      throw new Error(`Failed to download asset ${this.id}: ${res.status} ${res.statusText}`);
+    }
+    return new Uint8Array(await res.arrayBuffer());
+  }
+
+  /** @internal Create an Asset from raw asset data. */
+  static from(data: AssetRetrieveResponse['asset']): Asset {
+    return Object.assign(Object.create(AssetMethods.prototype), data) as Asset;
+  }
+}
+
+/** An asset with all original fields plus `.download()`. */
+export type Asset = AssetRetrieveResponse.Asset & AssetMethods;
+export const Asset = AssetMethods;
+
+/**
+ * @internal Helper type: adds `.download()` to the `asset` field of a response.
+ * Uses intersection so the original response type is preserved — a `WithAsset<T>` is still assignable to `T`.
+ */
+export type WithAsset<T extends { asset: unknown }> = T & { asset: AssetMethods };
+
+/**
+ * @internal Wrap `_thenUnwrap` to replace `response.asset` with an enhanced Asset.
+ */
+export function enhanceAsset<T extends { asset: { id: string; url: string } }>(
+  promise: APIPromise<T>,
+): APIPromise<WithAsset<T>> {
+  return promise._thenUnwrap((data) => ({
+    ...data,
+    asset: Asset.from(data.asset as AssetRetrieveResponse['asset']),
+  }));
+}
+
+/**
+ * Enhanced Assets resource.
+ * All original methods (and subresources like `download`, `public`) are
+ * inherited. `retrieve` and `update` responses' `asset` field gains a
+ * `.download()` helper for fetching the asset's bytes.
+ */
+export class EnhancedAssets extends Assets {
+  override retrieve(
+    assetID: string,
+    query: AssetRetrieveParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<WithAsset<AssetRetrieveResponse>> {
+    return enhanceAsset(super.retrieve(assetID, query, options));
+  }
+
+  override update(
+    assetID: string,
+    params: AssetUpdateParams,
+    options?: RequestOptions,
+  ): APIPromise<WithAsset<AssetUpdateResponse>> {
+    return enhanceAsset(super.update(assetID, params, options));
+  }
+}

package/src/lib/job.ts

@@ -1,6 +1,12 @@
 import type { Scenario } from '../client';
 import type { APIPromise } from '../core/api-promise';
-import type { JobRetrieveResponse } from '../resources/jobs';
+import type { RequestOptions } from '../internal/request-options';
+import {
+  Jobs,
+  type JobRetrieveResponse,
+  type JobTriggerActionParams,
+  type JobTriggerActionResponse,
+} from '../resources/jobs';
 
 export interface WaitOptions {
   /** Polling interval in milliseconds. Default: 3000 */
@@ -76,3 +82,24 @@ export function enhanceJob<T extends { job: { jobId: string; status: string } }>
     job: Job.from(client, data.job as JobRetrieveResponse['job']),
   }));
 }
+
+/**
+ * Enhanced Jobs resource. `retrieve` and `triggerAction` responses' `job`
+ * field gains a `.wait()` helper — previously only job-creating endpoints
+ * (workflow.run, models.trigger, generate.*) had it. `list` is not enhanced:
+ * its items use a different (but structurally similar) type, and users
+ * 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));
+  }
+
+  override triggerAction(
+    jobID: string,
+    params: JobTriggerActionParams,
+    options?: RequestOptions,
+  ): APIPromise<WithJob<JobTriggerActionResponse>> {
+    return enhanceJob(this._client, super.triggerAction(jobID, params, options));
+  }
+}

package/src/lib/scenario.ts

@@ -1,5 +1,7 @@
 import { Scenario as BaseScenario } from '../client';
+import { EnhancedAssets } from './asset';
 import { EnhancedGenerate } from './generate';
+import { EnhancedJobs } from './job';
 import { EnhancedModels } from './models';
 import { EnhancedUploads } from './upload';
 import { EnhancedWorkflows } from './workflow';
@@ -31,6 +33,14 @@ import { EnhancedWorkflows } from './workflow';
  * // 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();
+ *
+ * // Enhanced: asset.download()
+ * const a = await client.assets.retrieve(assetId);
+ * const bytes = await a.asset.download();
  * ```
  */
 export class Scenario extends BaseScenario {
@@ -38,4 +48,6 @@ export class Scenario extends BaseScenario {
   override generate: EnhancedGenerate = new EnhancedGenerate(this);
   override models: EnhancedModels = new EnhancedModels(this);
   override uploads: EnhancedUploads = new EnhancedUploads(this);
+  override assets: EnhancedAssets = new EnhancedAssets(this);
+  override jobs: EnhancedJobs = new EnhancedJobs(this);
 }

package/src/lib/upload.ts

@@ -1,9 +1,13 @@
+import type { Scenario } from '../client';
+import type { APIPromise } from '../core/api-promise';
 import type { RequestOptions } from '../internal/request-options';
 import {
   Uploads,
   type UploadCreateParams,
   type UploadCreateResponse,
   type UploadRetrieveResponse,
+  type UploadTriggerActionParams,
+  type UploadTriggerActionResponse,
 } from '../resources/uploads';
 import type { AssetRetrieveResponse } from '../resources/assets/assets';
 import type { ModelRetrieveResponse } from '../resources/models/models';
@@ -64,19 +68,109 @@ const MAX_PART_SIZE = 5_368_709_120; // 5 GiB
 const MAX_PARTS = 10_000;
 const MAX_FILE_SIZE = 5_497_558_138_880; // 5 TiB
 
+type UploadStatus = UploadRetrieveResponse.Upload['status'];
+
 // `validated` is intermediate — the server has validated the upload but
 // hasn't created the asset/model yet, so `entityId` isn't populated.
 // Real terminals are `imported` (asset/model created), `complete`, and
 // `failed`. Everything else means "keep polling".
-const TERMINAL_STATUSES = new Set(['complete', 'failed', 'imported']);
+const TERMINAL_STATUSES: Set<UploadStatus> = new Set(['complete', 'failed', 'imported']);
+
+export interface UploadWaitOptions {
+  /** Polling interval in milliseconds. Default: 2000 */
+  intervalMs?: number;
+  /** Maximum wait time in milliseconds. Default: 300000 */
+  timeoutMs?: number;
+}
+
+/** Upload methods added on top of the original upload fields. */
+export class UploadMethods {
+  /** @internal */ declare readonly _client: Scenario;
+
+  /**
+   * Poll until the upload has been processed into an entity (asset or model),
+   * or reaches a terminal state (`imported`, `complete`, `failed`). Resolves
+   * with the latest upload data so you can read `entityId`, `status`, or
+   * `errorMessage` without a follow-up retrieve.
+   *
+   * @example
+   * ```ts
+   * const res = await client.uploads.retrieve(uploadId);
+   * const done = await res.upload.wait();
+   * if (done.status === 'failed') throw new Error(done.errorMessage);
+   * console.log(done.entityId);
+   * ```
+   */
+  async wait(this: Upload, options?: UploadWaitOptions): Promise<Upload> {
+    const final = await pollUntilImported(
+      () => this._client.uploads.retrieve(this.id),
+      options?.intervalMs ?? 2_000,
+      options?.timeoutMs ?? 300_000,
+    );
+    return UploadMethods.from(this._client, final.upload);
+  }
+
+  /** @internal Create an Upload from raw upload data. */
+  static from(client: Scenario, data: UploadRetrieveResponse['upload']): Upload {
+    const upload = Object.assign(Object.create(UploadMethods.prototype), data) as Upload;
+    Object.defineProperty(upload, '_client', { value: client, enumerable: false });
+    return upload;
+  }
+}
+
+/** An upload with all original fields plus `.wait()`. */
+export type Upload = UploadRetrieveResponse.Upload & UploadMethods;
+export const Upload = UploadMethods;
+
+/**
+ * @internal Helper type: adds `.wait()` to the `upload` field of a response.
+ * Uses intersection so the original response type is preserved — a `WithUpload<T>` is still assignable to `T`.
+ */
+export type WithUpload<T extends { upload: unknown }> = T & { upload: UploadMethods };
+
+/**
+ * @internal Wrap `_thenUnwrap` to replace `response.upload` with an enhanced Upload.
+ */
+export function enhanceUpload<T extends { upload: { id: string; status: string } }>(
+  client: Scenario,
+  promise: APIPromise<T>,
+): APIPromise<WithUpload<T>> {
+  return promise._thenUnwrap((data) => ({
+    ...data,
+    upload: Upload.from(client, data.upload as UploadRetrieveResponse['upload']),
+  }));
+}
 
 /**
  * Enhanced Uploads resource.
- * All original methods (`create`, `retrieve`, `triggerAction`) are inherited.
+ * All original methods (`create`, `retrieve`, `triggerAction`) are inherited,
+ * with each response's `upload` field enriched with a `.wait()` helper.
  * Adds `uploadFile()` — a one-call wrapper around the 4-step upload flow:
  * init → PUT parts to S3 → trigger complete → poll until imported.
  */
 export class EnhancedUploads extends Uploads {
+  override create(
+    body: UploadCreateParams,
+    options?: RequestOptions,
+  ): APIPromise<WithUpload<UploadCreateResponse>> {
+    return enhanceUpload(this._client, super.create(body, options));
+  }
+
+  override retrieve(
+    uploadID: string,
+    options?: RequestOptions,
+  ): APIPromise<WithUpload<UploadRetrieveResponse>> {
+    return enhanceUpload(this._client, super.retrieve(uploadID, options));
+  }
+
+  override triggerAction(
+    uploadID: string,
+    body: UploadTriggerActionParams,
+    options?: RequestOptions,
+  ): APIPromise<WithUpload<UploadTriggerActionResponse>> {
+    return enhanceUpload(this._client, super.triggerAction(uploadID, body, options));
+  }
+
   /**
    * Upload a file end-to-end. Computes an optimal part size (within AWS's
    * 5 MiB / 5 GiB / 10,000-part bounds), uploads all parts in parallel,

package/src/lib/workflow.ts

@@ -2,8 +2,8 @@ import type { APIPromise } from '../core/api-promise';
 import type { RequestOptions } from '../internal/request-options';
 import {
   Workflows,
+  WorkflowUserApprovalResponse,
   type WorkflowApproveUserParams,
-  type WorkflowApproveUserResponse,
   type WorkflowRetrieveResponse,
   type WorkflowRunParams,
   type WorkflowRunResponse,
@@ -114,11 +114,11 @@ export class EnhancedWorkflows extends Workflows {
   }
 
   /** Approve a user approval node. Returns an enhanced response where `job` has `.wait()`. */
-  override approveUser(
+  override userApproval(
     workflowID: string,
     body: WorkflowApproveUserParams,
     options?: RequestOptions,
-  ): APIPromise<WithJob<WorkflowApproveUserResponse>> {
-    return enhanceJob(this._client, super.approveUser(workflowID, body, options));
+  ): APIPromise<WithJob<WorkflowUserApprovalResponse>> {
+    return enhanceJob(this._client, super.userApproval(workflowID, body, options));
   }
 }