casedev 0.1.0 → 0.3.0

package/src/resources/vault/vault.ts

@@ -2,18 +2,21 @@
 
 import { APIResource } from '../../core/resource';
 import * as GraphragAPI from './graphrag';
-import { Graphrag } from './graphrag';
+import { Graphrag, GraphragGetStatsResponse, GraphragInitResponse } from './graphrag';
 import * as ObjectsAPI from './objects';
 import {
   ObjectCreatePresignedURLParams,
   ObjectCreatePresignedURLResponse,
   ObjectDownloadParams,
+  ObjectDownloadResponse,
   ObjectGetTextParams,
+  ObjectGetTextResponse,
+  ObjectListResponse,
   ObjectRetrieveParams,
+  ObjectRetrieveResponse,
   Objects,
 } from './objects';
 import { APIPromise } from '../../core/api-promise';
-import { buildHeaders } from '../../internal/headers';
 import { RequestOptions } from '../../internal/request-options';
 import { path } from '../../internal/utils/path';
 
@@ -24,8 +27,8 @@ export class Vault extends APIResource {
   /**
    * Creates a new secure vault with dedicated S3 storage and vector search
    * capabilities. Each vault provides isolated document storage with semantic
-   * search, OCR processing, and optional knowledge graph features for legal document
-   * analysis and discovery.
+   * search, OCR processing, and optional GraphRAG knowledge graph features for legal
+   * document analysis and discovery.
    *
    * @example
    * ```ts
@@ -45,19 +48,16 @@ export class Vault extends APIResource {
    *
    * @example
    * ```ts
-   * await client.vault.retrieve('vault_abc123');
+   * const vault = await client.vault.retrieve('vault_abc123');
    * ```
    */
-  retrieve(id: string, options?: RequestOptions): APIPromise<void> {
-    return this._client.get(path`/vault/${id}`, {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+  retrieve(id: string, options?: RequestOptions): APIPromise<VaultRetrieveResponse> {
+    return this._client.get(path`/vault/${id}`, options);
   }
 
   /**
    * List all vaults for the authenticated organization. Returns vault metadata
-   * including storage configuration and usage statistics.
+   * including name, description, storage configuration, and usage statistics.
    *
    * @example
    * ```ts
@@ -69,10 +69,12 @@ export class Vault extends APIResource {
   }
 
   /**
-   * Triggers OCR ingestion workflow for a vault object to extract text, generate
-   * chunks, and create embeddings. Processing happens asynchronously with GraphRAG
-   * support if enabled on the vault. Returns immediately with workflow tracking
-   * information.
+   * Triggers ingestion workflow for a vault object to extract text, generate chunks,
+   * and create embeddings. For supported file types (PDF, DOCX, TXT, RTF, XML,
+   * audio, video), processing happens asynchronously. For unsupported types (images,
+   * archives, etc.), the file is marked as completed immediately without text
+   * extraction. GraphRAG indexing must be triggered separately via POST
+   * /vault/:id/graphrag/:objectId.
    *
    * @example
    * ```ts
@@ -142,15 +144,20 @@ export interface VaultCreateResponse {
    */
   description?: string;
 
+  /**
+   * Whether vector indexing is enabled for this vault
+   */
+  enableIndexing?: boolean;
+
   /**
    * S3 bucket name for document storage
    */
   filesBucket?: string;
 
   /**
-   * Vector search index name
+   * Vector search index name. Null for storage-only vaults.
    */
-  indexName?: string;
+  indexName?: string | null;
 
   /**
    * Vault display name
@@ -163,9 +170,118 @@ export interface VaultCreateResponse {
   region?: string;
 
   /**
-   * S3 bucket name for vector embeddings
+   * S3 bucket name for vector embeddings. Null for storage-only vaults.
+   */
+  vectorBucket?: string | null;
+}
+
+export interface VaultRetrieveResponse {
+  /**
+   * Vault identifier
+   */
+  id: string;
+
+  /**
+   * Vault creation timestamp
+   */
+  createdAt: string;
+
+  /**
+   * S3 bucket for document storage
+   */
+  filesBucket: string;
+
+  /**
+   * Vault name
+   */
+  name: string;
+
+  /**
+   * AWS region
+   */
+  region: string;
+
+  /**
+   * Document chunking strategy configuration
+   */
+  chunkStrategy?: VaultRetrieveResponse.ChunkStrategy;
+
+  /**
+   * Vault description
+   */
+  description?: string;
+
+  /**
+   * Whether GraphRAG is enabled
+   */
+  enableGraph?: boolean;
+
+  /**
+   * Search index name
+   */
+  indexName?: string;
+
+  /**
+   * KMS key for encryption
    */
-  vectorBucket?: string;
+  kmsKeyId?: string;
+
+  /**
+   * Additional vault metadata
+   */
+  metadata?: unknown;
+
+  /**
+   * Total storage size in bytes
+   */
+  totalBytes?: number;
+
+  /**
+   * Number of stored documents
+   */
+  totalObjects?: number;
+
+  /**
+   * Number of vector embeddings
+   */
+  totalVectors?: number;
+
+  /**
+   * Last update timestamp
+   */
+  updatedAt?: string;
+
+  /**
+   * S3 bucket for vector embeddings
+   */
+  vectorBucket?: string | null;
+}
+
+export namespace VaultRetrieveResponse {
+  /**
+   * Document chunking strategy configuration
+   */
+  export interface ChunkStrategy {
+    /**
+     * Target size for each chunk in tokens
+     */
+    chunkSize?: number;
+
+    /**
+     * Chunking method (e.g., 'semantic', 'fixed')
+     */
+    method?: string;
+
+    /**
+     * Minimum chunk size in tokens
+     */
+    minChunkSize?: number;
+
+    /**
+     * Number of overlapping tokens between chunks
+     */
+    overlap?: number;
+  }
 }
 
 export interface VaultListResponse {
@@ -218,7 +334,8 @@ export namespace VaultListResponse {
 
 export interface VaultIngestResponse {
   /**
-   * Whether GraphRAG is enabled for this vault
+   * Always false - GraphRAG must be triggered separately via POST
+   * /vault/:id/graphrag/:objectId
    */
   enableGraphRAG: boolean;
 
@@ -233,19 +350,20 @@ export interface VaultIngestResponse {
   objectId: string;
 
   /**
-   * Current ingestion status
+   * Current ingestion status. 'stored' for file types without text extraction (no
+   * chunks/vectors created).
    */
-  status: 'processing';
+  status: 'processing' | 'stored';
 
   /**
-   * Workflow run ID for tracking progress
+   * Workflow run ID for tracking progress. Null for file types that skip processing.
    */
-  workflowId: string;
+  workflowId: string | null;
 }
 
 export interface VaultSearchResponse {
   /**
-   * Relevant text chunks with similarity scores
+   * Relevant text chunks with similarity scores and page locations
    */
   chunks?: Array<VaultSearchResponse.Chunk>;
 
@@ -274,11 +392,61 @@ export interface VaultSearchResponse {
 
 export namespace VaultSearchResponse {
   export interface Chunk {
+    /**
+     * Index of the chunk within the document (0-based)
+     */
+    chunk_index?: number;
+
+    /**
+     * Vector similarity distance (lower is more similar)
+     */
+    distance?: number;
+
+    /**
+     * ID of the source document
+     */
+    object_id?: string;
+
+    /**
+     * PDF page number where the chunk ends (1-indexed). Null for non-PDF documents or
+     * documents ingested before page tracking was added.
+     */
+    page_end?: number | null;
+
+    /**
+     * PDF page number where the chunk begins (1-indexed). Null for non-PDF documents
+     * or documents ingested before page tracking was added.
+     */
+    page_start?: number | null;
+
+    /**
+     * Relevance score (deprecated, use distance or hybridScore)
+     */
     score?: number;
 
+    /**
+     * Source identifier (deprecated, use object_id)
+     */
     source?: string;
 
+    /**
+     * Preview of the chunk text (up to 500 characters)
+     */
     text?: string;
+
+    /**
+     * Ending word index (0-based) in the OCR word list. Use with GET
+     * /vault/:id/objects/:objectId/ocr-words to retrieve bounding boxes for
+     * highlighting.
+     */
+    word_end_index?: number | null;
+
+    /**
+     * Starting word index (0-based) in the OCR word list. Use with GET
+     * /vault/:id/objects/:objectId/ocr-words to retrieve bounding boxes for
+     * highlighting.
+     */
+    word_start_index?: number | null;
   }
 
   export interface Source {
@@ -304,6 +472,11 @@ export interface VaultUploadResponse {
    */
   auto_index?: boolean;
 
+  /**
+   * Whether the vault supports indexing. False for storage-only vaults.
+   */
+  enableIndexing?: boolean;
+
   /**
    * URL expiration time in seconds
    */
@@ -321,6 +494,11 @@ export interface VaultUploadResponse {
    */
   objectId?: string;
 
+  /**
+   * Folder path for hierarchy if provided
+   */
+  path?: string | null;
+
   /**
    * S3 object key for the file
    */
@@ -354,9 +532,22 @@ export interface VaultCreateParams {
   description?: string;
 
   /**
-   * Enable knowledge graph for entity relationship mapping
+   * Enable knowledge graph for entity relationship mapping. Only applies when
+   * enableIndexing is true.
    */
   enableGraph?: boolean;
+
+  /**
+   * Enable vector indexing and search capabilities. Set to false for storage-only
+   * vaults.
+   */
+  enableIndexing?: boolean;
+
+  /**
+   * Optional metadata to attach to the vault (e.g., { containsPHI: true } for HIPAA
+   * compliance tracking)
+   */
+  metadata?: unknown;
 }
 
 export interface VaultIngestParams {
@@ -373,9 +564,9 @@ export interface VaultSearchParams {
   query: string;
 
   /**
-   * Additional filters to apply to search results
+   * Filters to narrow search results to specific documents
    */
-  filters?: { [key: string]: unknown };
+  filters?: VaultSearchParams.Filters;
 
   /**
    * Search method: 'global' for comprehensive questions, 'entity' for specific
@@ -389,6 +580,21 @@ export interface VaultSearchParams {
   topK?: number;
 }
 
+export namespace VaultSearchParams {
+  /**
+   * Filters to narrow search results to specific documents
+   */
+  export interface Filters {
+    /**
+     * Filter to specific document(s) by object ID. Accepts a single ID or array of
+     * IDs.
+     */
+    object_id?: string | Array<string>;
+
+    [k: string]: unknown;
+  }
+}
+
 export interface VaultUploadParams {
   /**
    * MIME type of the file (e.g., application/pdf, image/jpeg)
@@ -411,7 +617,15 @@ export interface VaultUploadParams {
   metadata?: unknown;
 
   /**
-   * Estimated file size in bytes for cost calculation
+   * Optional folder path for hierarchy preservation. Allows integrations to maintain
+   * source folder structure from systems like NetDocs, Clio, or Smokeball. Example:
+   * '/Discovery/Depositions/2024'
+   */
+  path?: string;
+
+  /**
+   * File size in bytes (optional, max 500MB). When provided, enforces exact file
+   * size at S3 level.
    */
   sizeBytes?: number;
 }
@@ -422,6 +636,7 @@ Vault.Objects = Objects;
 export declare namespace Vault {
   export {
     type VaultCreateResponse as VaultCreateResponse,
+    type VaultRetrieveResponse as VaultRetrieveResponse,
     type VaultListResponse as VaultListResponse,
     type VaultIngestResponse as VaultIngestResponse,
     type VaultSearchResponse as VaultSearchResponse,
@@ -432,11 +647,19 @@ export declare namespace Vault {
     type VaultUploadParams as VaultUploadParams,
   };
 
-  export { Graphrag as Graphrag };
+  export {
+    Graphrag as Graphrag,
+    type GraphragGetStatsResponse as GraphragGetStatsResponse,
+    type GraphragInitResponse as GraphragInitResponse,
+  };
 
   export {
     Objects as Objects,
+    type ObjectRetrieveResponse as ObjectRetrieveResponse,
+    type ObjectListResponse as ObjectListResponse,
     type ObjectCreatePresignedURLResponse as ObjectCreatePresignedURLResponse,
+    type ObjectDownloadResponse as ObjectDownloadResponse,
+    type ObjectGetTextResponse as ObjectGetTextResponse,
     type ObjectRetrieveParams as ObjectRetrieveParams,
     type ObjectCreatePresignedURLParams as ObjectCreatePresignedURLParams,
     type ObjectDownloadParams as ObjectDownloadParams,

package/src/resources/voice/index.ts

@@ -1,10 +1,11 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-export { Streaming } from './streaming';
+export { Streaming, type StreamingGetURLResponse } from './streaming';
 export {
   Transcription,
+  type TranscriptionCreateResponse,
   type TranscriptionRetrieveResponse,
   type TranscriptionCreateParams,
 } from './transcription';
-export { V1, type V1ListVoicesParams } from './v1/index';
+export { V1, type V1ListVoicesResponse, type V1ListVoicesParams } from './v1/index';
 export { Voice } from './voice';

package/src/resources/voice/streaming.ts

@@ -2,7 +2,6 @@
 
 import { APIResource } from '../../core/resource';
 import { APIPromise } from '../../core/api-promise';
-import { buildHeaders } from '../../internal/headers';
 import { RequestOptions } from '../../internal/request-options';
 
 export class Streaming extends APIResource {
@@ -17,17 +16,75 @@ export class Streaming extends APIResource {
    * - Encoding: PCM 16-bit little-endian
    * - Channels: Mono (1 channel)
    *
-   * **Pricing:** $0.30 per minute ($18.00 per hour)
+   * **Pricing:** $0.01 per minute ($0.60 per hour)
    *
    * @example
    * ```ts
-   * await client.voice.streaming.getURL();
+   * const response = await client.voice.streaming.getURL();
    * ```
    */
-  getURL(options?: RequestOptions): APIPromise<void> {
-    return this._client.get('/voice/streaming/url', {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+  getURL(options?: RequestOptions): APIPromise<StreamingGetURLResponse> {
+    return this._client.get('/voice/streaming/url', options);
   }
 }
+
+export interface StreamingGetURLResponse {
+  audio_format?: StreamingGetURLResponse.AudioFormat;
+
+  /**
+   * Complete WebSocket URL with authentication token
+   */
+  connect_url?: string;
+
+  pricing?: StreamingGetURLResponse.Pricing;
+
+  /**
+   * Connection protocol
+   */
+  protocol?: string;
+
+  /**
+   * Base WebSocket URL for streaming transcription
+   */
+  url?: string;
+}
+
+export namespace StreamingGetURLResponse {
+  export interface AudioFormat {
+    /**
+     * Number of audio channels
+     */
+    channels?: number;
+
+    /**
+     * Required audio encoding format
+     */
+    encoding?: string;
+
+    /**
+     * Required audio sample rate in Hz
+     */
+    sample_rate?: number;
+  }
+
+  export interface Pricing {
+    /**
+     * Currency for pricing
+     */
+    currency?: string;
+
+    /**
+     * Cost per hour of transcription
+     */
+    per_hour?: number;
+
+    /**
+     * Cost per minute of transcription
+     */
+    per_minute?: number;
+  }
+}
+
+export declare namespace Streaming {
+  export { type StreamingGetURLResponse as StreamingGetURLResponse };
+}