casedev 0.53.0 → 0.54.0

package/src/resources/compute/v1/index.ts

@@ -9,6 +9,15 @@ export {
   type EnvironmentSetDefaultResponse,
   type EnvironmentCreateParams,
 } from './environments';
+export { InstanceTypes, type InstanceTypeListResponse } from './instance-types';
+export {
+  Instances,
+  type InstanceCreateResponse,
+  type InstanceRetrieveResponse,
+  type InstanceListResponse,
+  type InstanceDeleteResponse,
+  type InstanceCreateParams,
+} from './instances';
 export {
   Secrets,
   type SecretCreateResponse,

package/src/resources/compute/v1/instance-types.ts

@@ -0,0 +1,89 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+import { APIPromise } from '../../../core/api-promise';
+import { RequestOptions } from '../../../internal/request-options';
+
+/**
+ * Serverless GPU and CPU infrastructure
+ */
+export class InstanceTypes extends APIResource {
+  /**
+   * Retrieves all available GPU instance types with pricing, specifications, and
+   * regional availability. Includes T4, A10, A100, H100, and H200 GPUs powered by
+   * Lambda Labs. Perfect for AI model training, inference workloads, and legal
+   * document OCR processing at scale.
+   *
+   * @example
+   * ```ts
+   * const instanceTypes =
+   *   await client.compute.v1.instanceTypes.list();
+   * ```
+   */
+  list(options?: RequestOptions): APIPromise<InstanceTypeListResponse> {
+    return this._client.get('/compute/v1/instance-types', options);
+  }
+}
+
+export interface InstanceTypeListResponse {
+  /**
+   * Total number of instance types
+   */
+  count: number;
+
+  instanceTypes: Array<InstanceTypeListResponse.InstanceType>;
+}
+
+export namespace InstanceTypeListResponse {
+  export interface InstanceType {
+    /**
+     * Instance description
+     */
+    description?: string;
+
+    /**
+     * GPU model and count
+     */
+    gpu?: string;
+
+    /**
+     * Instance type identifier
+     */
+    name?: string;
+
+    /**
+     * Price per hour (e.g. '$1.20')
+     */
+    pricePerHour?: string;
+
+    /**
+     * Available regions
+     */
+    regionsAvailable?: Array<string>;
+
+    specs?: InstanceType.Specs;
+  }
+
+  export namespace InstanceType {
+    export interface Specs {
+      /**
+       * RAM in GiB
+       */
+      memoryGib?: number;
+
+      /**
+       * Storage in GiB
+       */
+      storageGib?: number;
+
+      /**
+       * Number of vCPUs
+       */
+      vcpus?: number;
+    }
+  }
+}
+
+export declare namespace InstanceTypes {
+  export { type InstanceTypeListResponse as InstanceTypeListResponse };
+}

package/src/resources/compute/v1/instances.ts

@@ -0,0 +1,240 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+import { APIPromise } from '../../../core/api-promise';
+import { RequestOptions } from '../../../internal/request-options';
+import { path } from '../../../internal/utils/path';
+
+/**
+ * Serverless GPU and CPU infrastructure
+ */
+export class Instances extends APIResource {
+  /**
+   * Launches a new GPU compute instance with automatic SSH key generation. Supports
+   * mounting Case.dev Vaults as filesystems and configurable auto-shutdown. Instance
+   * boots in ~2-5 minutes. Perfect for batch OCR processing, AI model training, and
+   * intensive document analysis workloads.
+   *
+   * @example
+   * ```ts
+   * const instance = await client.compute.v1.instances.create({
+   *   instanceType: 'gpu_1x_a10',
+   *   name: 'ocr-batch-job',
+   *   region: 'us-west-1',
+   *   autoShutdownMinutes: 120,
+   *   vaultIds: ['vault_abc123'],
+   * });
+   * ```
+   */
+  create(body: InstanceCreateParams, options?: RequestOptions): APIPromise<InstanceCreateResponse> {
+    return this._client.post('/compute/v1/instances', { body, ...options });
+  }
+
+  /**
+   * Retrieves detailed information about a GPU instance including SSH connection
+   * details, vault mount scripts, real-time cost tracking, and current status. SSH
+   * private key included for secure access.
+   *
+   * @example
+   * ```ts
+   * const instance = await client.compute.v1.instances.retrieve(
+   *   'id',
+   * );
+   * ```
+   */
+  retrieve(id: string, options?: RequestOptions): APIPromise<InstanceRetrieveResponse> {
+    return this._client.get(path`/compute/v1/instances/${id}`, options);
+  }
+
+  /**
+   * Retrieves all GPU compute instances for your organization with real-time status
+   * updates from Lambda Labs. Includes pricing, runtime metrics, and auto-shutdown
+   * configuration. Perfect for monitoring AI workloads, document processing jobs,
+   * and cost tracking.
+   *
+   * @example
+   * ```ts
+   * const instances = await client.compute.v1.instances.list();
+   * ```
+   */
+  list(options?: RequestOptions): APIPromise<InstanceListResponse> {
+    return this._client.get('/compute/v1/instances', options);
+  }
+
+  /**
+   * Terminates a running GPU instance, calculates final cost, and cleans up SSH
+   * keys. This action is permanent and cannot be undone. All data on the instance
+   * will be lost.
+   *
+   * @example
+   * ```ts
+   * const instance = await client.compute.v1.instances.delete(
+   *   'id',
+   * );
+   * ```
+   */
+  delete(id: string, options?: RequestOptions): APIPromise<InstanceDeleteResponse> {
+    return this._client.delete(path`/compute/v1/instances/${id}`, options);
+  }
+}
+
+export interface InstanceCreateResponse {
+  id?: string;
+
+  autoShutdownMinutes?: number | null;
+
+  createdAt?: string;
+
+  gpu?: string;
+
+  instanceType?: string;
+
+  message?: string;
+
+  name?: string;
+
+  pricePerHour?: string;
+
+  region?: string;
+
+  specs?: unknown;
+
+  status?: string;
+
+  vaults?: Array<unknown>;
+}
+
+export interface InstanceRetrieveResponse {
+  id?: string;
+
+  autoShutdownMinutes?: number | null;
+
+  createdAt?: string;
+
+  currentCost?: string;
+
+  currentRuntimeSeconds?: number;
+
+  gpu?: string;
+
+  instanceType?: string;
+
+  ip?: string | null;
+
+  name?: string;
+
+  pricePerHour?: string;
+
+  region?: string;
+
+  specs?: unknown;
+
+  ssh?: InstanceRetrieveResponse.SSH | null;
+
+  startedAt?: string | null;
+
+  status?: string;
+
+  vaultMounts?: unknown | null;
+}
+
+export namespace InstanceRetrieveResponse {
+  export interface SSH {
+    command?: string;
+
+    host?: string;
+
+    instructions?: Array<unknown>;
+
+    privateKey?: string;
+
+    user?: string;
+  }
+}
+
+export interface InstanceListResponse {
+  count?: number;
+
+  instances?: Array<InstanceListResponse.Instance>;
+}
+
+export namespace InstanceListResponse {
+  export interface Instance {
+    id?: string;
+
+    autoShutdownMinutes?: number | null;
+
+    createdAt?: string;
+
+    gpu?: string;
+
+    instanceType?: string;
+
+    ip?: string | null;
+
+    name?: string;
+
+    pricePerHour?: string;
+
+    region?: string;
+
+    startedAt?: string | null;
+
+    status?: 'booting' | 'running' | 'stopping' | 'stopped' | 'terminated' | 'failed';
+
+    totalCost?: string;
+
+    totalRuntimeSeconds?: number;
+  }
+}
+
+export interface InstanceDeleteResponse {
+  id?: string;
+
+  message?: string;
+
+  name?: string;
+
+  status?: string;
+
+  totalCost?: string;
+
+  totalRuntimeSeconds?: number;
+}
+
+export interface InstanceCreateParams {
+  /**
+   * GPU type (e.g., 'gpu_1x_h100_sxm5')
+   */
+  instanceType: string;
+
+  /**
+   * Instance name
+   */
+  name: string;
+
+  /**
+   * Region (e.g., 'us-west-1')
+   */
+  region: string;
+
+  /**
+   * Auto-shutdown timer (null = never)
+   */
+  autoShutdownMinutes?: number | null;
+
+  /**
+   * Vault IDs to mount
+   */
+  vaultIds?: Array<string>;
+}
+
+export declare namespace Instances {
+  export {
+    type InstanceCreateResponse as InstanceCreateResponse,
+    type InstanceRetrieveResponse as InstanceRetrieveResponse,
+    type InstanceListResponse as InstanceListResponse,
+    type InstanceDeleteResponse as InstanceDeleteResponse,
+    type InstanceCreateParams as InstanceCreateParams,
+  };
+}

package/src/resources/compute/v1/v1.ts

@@ -11,6 +11,17 @@ import {
   EnvironmentSetDefaultResponse,
   Environments,
 } from './environments';
+import * as InstanceTypesAPI from './instance-types';
+import { InstanceTypeListResponse, InstanceTypes } from './instance-types';
+import * as InstancesAPI from './instances';
+import {
+  InstanceCreateParams,
+  InstanceCreateResponse,
+  InstanceDeleteResponse,
+  InstanceListResponse,
+  InstanceRetrieveResponse,
+  Instances,
+} from './instances';
 import * as SecretsAPI from './secrets';
 import {
   SecretCreateParams,
@@ -26,6 +37,7 @@ import {
   Secrets,
 } from './secrets';
 import { APIPromise } from '../../../core/api-promise';
+import { buildHeaders } from '../../../internal/headers';
 import { RequestOptions } from '../../../internal/request-options';
 
 /**
@@ -33,8 +45,27 @@ import { RequestOptions } from '../../../internal/request-options';
  */
 export class V1 extends APIResource {
   environments: EnvironmentsAPI.Environments = new EnvironmentsAPI.Environments(this._client);
+  instanceTypes: InstanceTypesAPI.InstanceTypes = new InstanceTypesAPI.InstanceTypes(this._client);
+  instances: InstancesAPI.Instances = new InstancesAPI.Instances(this._client);
   secrets: SecretsAPI.Secrets = new SecretsAPI.Secrets(this._client);
 
+  /**
+   * Returns current pricing for GPU instances. Prices are fetched in real-time and
+   * include a 20% platform fee. For detailed instance types and availability, use
+   * GET /compute/v1/instance-types.
+   *
+   * @example
+   * ```ts
+   * await client.compute.v1.getPricing();
+   * ```
+   */
+  getPricing(options?: RequestOptions): APIPromise<void> {
+    return this._client.get('/compute/v1/pricing', {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
   /**
    * Returns detailed compute usage statistics and billing information for your
    * organization. Includes GPU and CPU hours, total runs, costs, and breakdowns by
@@ -110,6 +141,8 @@ export interface V1GetUsageParams {
 }
 
 V1.Environments = Environments;
+V1.InstanceTypes = InstanceTypes;
+V1.Instances = Instances;
 V1.Secrets = Secrets;
 
 export declare namespace V1 {
@@ -125,6 +158,17 @@ export declare namespace V1 {
     type EnvironmentCreateParams as EnvironmentCreateParams,
   };
 
+  export { InstanceTypes as InstanceTypes, type InstanceTypeListResponse as InstanceTypeListResponse };
+
+  export {
+    Instances as Instances,
+    type InstanceCreateResponse as InstanceCreateResponse,
+    type InstanceRetrieveResponse as InstanceRetrieveResponse,
+    type InstanceListResponse as InstanceListResponse,
+    type InstanceDeleteResponse as InstanceDeleteResponse,
+    type InstanceCreateParams as InstanceCreateParams,
+  };
+
   export {
     Secrets as Secrets,
     type SecretCreateResponse as SecretCreateResponse,

package/src/resources/vault/vault.ts

@@ -176,11 +176,12 @@ export class Vault extends APIResource {
   /**
    * Triggers ingestion workflow for a vault object to extract text, generate chunks,
    * and create embeddings. For supported file types (PDF, DOCX, PPTX, TXT, RTF, XML,
-   * ZIP, audio, video), processing happens asynchronously. ZIP archives are unpacked
-   * recursively up to 5 levels, and each extracted file is created as an independent
-   * vault object and ingested via the normal pipeline. For unsupported types
-   * (images, etc.), the file is marked as completed immediately without text
-   * extraction. GraphRAG indexing must be triggered separately via POST
+   * HTML, Markdown, CSV/TSV, JSON/YAML/TOML, common source code files, ZIP, audio,
+   * video), processing happens asynchronously. ZIP archives are unpacked recursively
+   * up to 5 levels, and each extracted file is created as an independent vault
+   * object and ingested via the normal pipeline. For unsupported types (images,
+   * etc.), the file is marked as completed immediately without text extraction.
+   * GraphRAG indexing must be triggered separately via POST
    * /vault/:id/graphrag/:objectId.
    *
    * @example

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.53.0'; // x-release-please-version
+export const VERSION = '0.54.0'; // x-release-please-version

package/version.d.mts

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

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.53.0";
+export declare const VERSION = "0.54.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 = '0.53.0'; // x-release-please-version
+exports.VERSION = '0.54.0'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

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