casedev 0.53.1 → 0.55.0

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/index.ts

@@ -47,3 +47,4 @@ export {
   type VaultUploadParams,
 } from './vault/vault';
 export { Voice } from './voice/voice';
+export { Webhooks } from './webhooks/webhooks';

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/resources/webhooks/index.ts

@@ -0,0 +1,4 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { V1 } from './v1/index';
+export { Webhooks } from './webhooks';

package/src/resources/webhooks/v1/deliveries.ts

@@ -0,0 +1,74 @@
+// 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 { buildHeaders } from '../../../internal/headers';
+import { RequestOptions } from '../../../internal/request-options';
+import { path } from '../../../internal/utils/path';
+
+/**
+ * Webhook endpoint management
+ */
+export class Deliveries extends APIResource {
+  /**
+   * Get webhook delivery
+   */
+  retrieve(id: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.get(path`/webhooks/v1/deliveries/${id}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Returns delivery attempts for the organization, newest first. Filter by
+   * endpoint_id or status to narrow results.
+   */
+  list(query: DeliveryListParams | null | undefined = {}, options?: RequestOptions): APIPromise<void> {
+    return this._client.get('/webhooks/v1/deliveries', {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Re-sends the original event to its endpoint. The payload is reconstructed from
+   * the delivery record (same eventId, eventType, and occurred_at). The signature
+   * header includes `svix-delivery-attempt: replay` so receivers can distinguish
+   * replays from first-time deliveries. Uses the endpoint's current signing secret —
+   * not the one in force at the original delivery time.
+   */
+  replay(
+    id: string,
+    body: DeliveryReplayParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<void> {
+    return this._client.post(path`/webhooks/v1/deliveries/${id}/replay`, {
+      body,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export interface DeliveryListParams {
+  endpoint_id?: string;
+
+  limit?: number;
+
+  status?: 'pending' | 'delivered' | 'failed';
+}
+
+export interface DeliveryReplayParams {
+  /**
+   * Override payload to deliver. Must only be supplied when the delivery record
+   * lacks enough context to reconstruct the original event (rare). Defaults to an
+   * empty data envelope.
+   */
+  payload?: unknown;
+}
+
+export declare namespace Deliveries {
+  export { type DeliveryListParams as DeliveryListParams, type DeliveryReplayParams as DeliveryReplayParams };
+}

package/src/resources/webhooks/v1/endpoints.ts

@@ -0,0 +1,204 @@
+// 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 { buildHeaders } from '../../../internal/headers';
+import { RequestOptions } from '../../../internal/request-options';
+import { path } from '../../../internal/utils/path';
+
+/**
+ * Webhook endpoint management
+ */
+export class Endpoints extends APIResource {
+  /**
+   * Creates a webhook endpoint that receives platform events matching the supplied
+   * event-type filters. Returns the generated signing secret ONCE — the response is
+   * the only time it is shown in plaintext.
+   */
+  create(body: EndpointCreateParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.post('/webhooks/v1/endpoints', {
+      body,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Get webhook endpoint
+   */
+  retrieve(id: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.get(path`/webhooks/v1/endpoints/${id}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Partially updates a webhook endpoint. Any omitted field is left unchanged.
+   * Signing secrets are rotated via the separate /rotate_secret endpoint.
+   */
+  update(id: string, body: EndpointUpdateParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.patch(path`/webhooks/v1/endpoints/${id}`, {
+      body,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Returns the organization's webhook endpoints, newest first. Signing secrets are
+   * never included.
+   */
+  list(query: EndpointListParams | null | undefined = {}, options?: RequestOptions): APIPromise<void> {
+    return this._client.get('/webhooks/v1/endpoints', {
+      query,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Soft-deletes a webhook endpoint. Delivery stops immediately and the endpoint no
+   * longer appears in list results. Delivery history is preserved (and can be
+   * fetched via GET /deliveries with the endpoint_id filter) so audit trails and
+   * post-mortem debugging remain possible.
+   */
+  delete(id: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.delete(path`/webhooks/v1/endpoints/${id}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Generates a new signing secret for the endpoint. The previous secret remains
+   * valid until `previousSecretExpiresInSec` elapses (default 24h, max 30 days).
+   * During the grace window deliveries are signed with both secrets so receivers can
+   * migrate without downtime. Returns the new secret — this is the only time it is
+   * shown in plaintext.
+   */
+  rotateSecret(
+    id: string,
+    body: EndpointRotateSecretParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<void> {
+    return this._client.post(path`/webhooks/v1/endpoints/${id}/rotate_secret`, {
+      body,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Synchronously delivers a synthetic `webhook.test` event to the endpoint and
+   * returns the HTTP result. No retries. Useful for validating that a new endpoint
+   * is reachable and its signature verifier works. The delivery is not persisted in
+   * the delivery history.
+   */
+  test(
+    id: string,
+    body: EndpointTestParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<void> {
+    return this._client.post(path`/webhooks/v1/endpoints/${id}/test`, {
+      body,
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export interface EndpointCreateParams {
+  /**
+   * Glob patterns of event types to deliver (e.g. "vault._", "ocr.job.completed",
+   * "_")
+   */
+  eventTypeFilters: Array<string>;
+
+  /**
+   * HTTPS callback URL that will receive event deliveries
+   */
+  url: string;
+
+  /**
+   * Human-readable label for this endpoint
+   */
+  description?: string;
+
+  /**
+   * Optional per-resource allowlists. If vaultIds is set, only events for those
+   * vaults are delivered. Same for matterIds.
+   */
+  resourceScopes?: EndpointCreateParams.ResourceScopes;
+}
+
+export namespace EndpointCreateParams {
+  /**
+   * Optional per-resource allowlists. If vaultIds is set, only events for those
+   * vaults are delivered. Same for matterIds.
+   */
+  export interface ResourceScopes {
+    matterIds?: Array<string>;
+
+    vaultIds?: Array<string>;
+  }
+}
+
+export interface EndpointUpdateParams {
+  description?: string | null;
+
+  eventTypeFilters?: Array<string>;
+
+  resourceScopes?: EndpointUpdateParams.ResourceScopes | null;
+
+  status?: 'active' | 'disabled';
+
+  url?: string;
+}
+
+export namespace EndpointUpdateParams {
+  export interface ResourceScopes {
+    matterIds?: Array<string>;
+
+    vaultIds?: Array<string>;
+  }
+}
+
+export interface EndpointListParams {
+  limit?: number;
+
+  /**
+   * Filter by endpoint status
+   */
+  status?: 'active' | 'disabled' | 'auto_disabled';
+}
+
+export interface EndpointRotateSecretParams {
+  /**
+   * How long (seconds) the old secret continues to be accepted. 0 invalidates
+   * immediately. Default: 86400 (24h).
+   */
+  previousSecretExpiresInSec?: number;
+}
+
+export interface EndpointTestParams {
+  /**
+   * Event type to simulate. Defaults to "webhook.test".
+   */
+  eventType?: string;
+
+  /**
+   * Custom `data` payload. Defaults to a small placeholder.
+   */
+  payload?: unknown;
+}
+
+export declare namespace Endpoints {
+  export {
+    type EndpointCreateParams as EndpointCreateParams,
+    type EndpointUpdateParams as EndpointUpdateParams,
+    type EndpointListParams as EndpointListParams,
+    type EndpointRotateSecretParams as EndpointRotateSecretParams,
+    type EndpointTestParams as EndpointTestParams,
+  };
+}

package/src/resources/webhooks/v1/event-types.ts

@@ -0,0 +1,23 @@
+// 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 { buildHeaders } from '../../../internal/headers';
+import { RequestOptions } from '../../../internal/request-options';
+
+/**
+ * Webhook endpoint management
+ */
+export class EventTypes extends APIResource {
+  /**
+   * Returns the catalog of event types that can be subscribed to via webhook
+   * endpoints. Each entry lists the required service scope the API key must carry to
+   * subscribe, plus the stability level.
+   */
+  list(options?: RequestOptions): APIPromise<void> {
+    return this._client.get('/webhooks/v1/event_types', {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}

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

@@ -0,0 +1,13 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { Deliveries, type DeliveryListParams, type DeliveryReplayParams } from './deliveries';
+export {
+  Endpoints,
+  type EndpointCreateParams,
+  type EndpointUpdateParams,
+  type EndpointListParams,
+  type EndpointRotateSecretParams,
+  type EndpointTestParams,
+} from './endpoints';
+export { EventTypes } from './event-types';
+export { V1 } from './v1';