@mixedbread/sdk 0.1.0-alpha.10

package/src/resources/files.ts

@@ -0,0 +1,181 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../resource';
+import { isRequestOptions } from '../core';
+import * as Core from '../core';
+import { LimitOffset, type LimitOffsetParams } from '../pagination';
+import { type Response } from '../_shims/index';
+
+export class Files extends APIResource {
+  /**
+   * Upload a new file.
+   *
+   * Args: file: The file to upload.
+   *
+   * Returns: FileResponse: The response containing the details of the uploaded file.
+   */
+  create(body: FileCreateParams, options?: Core.RequestOptions): Core.APIPromise<FileObject> {
+    return this._client.post('/v1/files', Core.multipartFormRequestOptions({ body, ...options }));
+  }
+
+  /**
+   * Retrieve details of a specific file by its ID.
+   *
+   * Args: file_id: The ID of the file to retrieve.
+   *
+   * Returns: FileResponse: The response containing the file details.
+   */
+  retrieve(fileId: string, options?: Core.RequestOptions): Core.APIPromise<FileObject> {
+    return this._client.get(`/v1/files/${fileId}`, options);
+  }
+
+  /**
+   * Update the details of a specific file.
+   *
+   * Args: file_id: The ID of the file to update. file: The new details for the file.
+   *
+   * Returns: FileObject: The updated file details.
+   */
+  update(fileId: string, body: FileUpdateParams, options?: Core.RequestOptions): Core.APIPromise<FileObject> {
+    return this._client.post(`/v1/files/${fileId}`, Core.multipartFormRequestOptions({ body, ...options }));
+  }
+
+  /**
+   * List all files for the authenticated user.
+   *
+   * Args: pagination: The pagination options
+   *
+   * Returns: A list of files belonging to the user.
+   */
+  list(
+    query?: FileListParams,
+    options?: Core.RequestOptions,
+  ): Core.PagePromise<FileObjectsLimitOffset, FileObject>;
+  list(options?: Core.RequestOptions): Core.PagePromise<FileObjectsLimitOffset, FileObject>;
+  list(
+    query: FileListParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.PagePromise<FileObjectsLimitOffset, FileObject> {
+    if (isRequestOptions(query)) {
+      return this.list({}, query);
+    }
+    return this._client.getAPIList('/v1/files', FileObjectsLimitOffset, { query, ...options });
+  }
+
+  /**
+   * Delete a specific file by its ID.
+   *
+   * Args: file_id: The ID of the file to delete.
+   *
+   * Returns: FileDeleted: The response containing the details of the deleted file.
+   */
+  delete(fileId: string, options?: Core.RequestOptions): Core.APIPromise<FileDeleteResponse> {
+    return this._client.delete(`/v1/files/${fileId}`, options);
+  }
+
+  /**
+   * Download a specific file by its ID.
+   *
+   * Args: file_id: The ID of the file to download.
+   *
+   * Returns: FileStreamResponse: The response containing the file to be downloaded.
+   */
+  content(fileId: string, options?: Core.RequestOptions): Core.APIPromise<Response> {
+    return this._client.get(`/v1/files/${fileId}/content`, {
+      ...options,
+      headers: { Accept: 'application/octet-stream', ...options?.headers },
+      __binaryResponse: true,
+    });
+  }
+}
+
+export class FileObjectsLimitOffset extends LimitOffset<FileObject> {}
+
+/**
+ * A model representing a file object in the system.
+ *
+ * This model contains metadata about files stored in the system, including
+ * identifiers, size information, and timestamps.
+ */
+export interface FileObject {
+  /**
+   * Unique identifier for the file
+   */
+  id: string;
+
+  /**
+   * Name of the file including extension
+   */
+  filename: string;
+
+  /**
+   * Size of the file in bytes
+   */
+  bytes: number;
+
+  /**
+   * MIME type of the file
+   */
+  mime_type: string;
+
+  /**
+   * Version of the file
+   */
+  version: number;
+
+  /**
+   * Timestamp when the file was created
+   */
+  created_at: string;
+
+  /**
+   * Timestamp when the file was last updated
+   */
+  updated_at: string;
+}
+
+export interface FileDeleteResponse {
+  /**
+   * The ID of the deleted file
+   */
+  id: string;
+
+  /**
+   * Whether the file was deleted
+   */
+  deleted?: boolean;
+
+  /**
+   * The type of the deleted object
+   */
+  object?: 'file';
+}
+
+export interface FileCreateParams {
+  /**
+   * The file to upload
+   */
+  file: Core.Uploadable;
+}
+
+export interface FileUpdateParams {
+  /**
+   * The file to update
+   */
+  file: Core.Uploadable;
+}
+
+export interface FileListParams extends LimitOffsetParams {}
+
+Files.FileObjectsLimitOffset = FileObjectsLimitOffset;
+
+export declare namespace Files {
+  export {
+    type FileObject as FileObject,
+    type FileDeleteResponse as FileDeleteResponse,
+    FileObjectsLimitOffset as FileObjectsLimitOffset,
+    type FileCreateParams as FileCreateParams,
+    type FileUpdateParams as FileUpdateParams,
+    type FileListParams as FileListParams,
+  };
+}

package/src/resources/index.ts

@@ -0,0 +1,39 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './shared';
+export {
+  Embeddings,
+  type Embedding,
+  type EmbeddingCreateResponse,
+  type EmbeddingCreateParams,
+} from './embeddings';
+export { Extractions } from './extractions/extractions';
+export {
+  FileObjectsLimitOffset,
+  Files,
+  type FileObject,
+  type FileDeleteResponse,
+  type FileCreateParams,
+  type FileUpdateParams,
+  type FileListParams,
+} from './files';
+export { Parsing } from './parsing/parsing';
+export {
+  VectorStoresLimitOffset,
+  VectorStores,
+  type ExpiresAfter,
+  type FileCounts,
+  type ScoredVectorStoreChunk,
+  type VectorStore,
+  type VectorStoreChunkSearchOptions,
+  type VectorStoreFileSearchOptions,
+  type VectorStoreDeleteResponse,
+  type VectorStoreQuestionAnsweringResponse,
+  type VectorStoreSearchResponse,
+  type VectorStoreCreateParams,
+  type VectorStoreUpdateParams,
+  type VectorStoreListParams,
+  type VectorStoreQuestionAnsweringParams,
+  type VectorStoreSearchParams,
+} from './vector-stores/vector-stores';
+export { type InfoResponse, type RerankResponse, type EmbedParams, type RerankParams } from './top-level';

package/src/resources/parsing/index.ts

@@ -0,0 +1,12 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  JobListResponsesLimitOffset,
+  Jobs,
+  type ParsingJob,
+  type JobListResponse,
+  type JobDeleteResponse,
+  type JobCreateParams,
+  type JobListParams,
+} from './jobs';
+export { Parsing } from './parsing';

package/src/resources/parsing/jobs.ts

@@ -0,0 +1,453 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../resource';
+import { isRequestOptions } from '../../core';
+import * as Core from '../../core';
+import { LimitOffset, type LimitOffsetParams } from '../../pagination';
+import * as polling from '../../lib/polling';
+import { Uploadable } from '../../uploads';
+
+export class Jobs extends APIResource {
+  /**
+   * Start a parse job for the provided file.
+   *
+   * Args: params: The parameters for creating a parse job.
+   *
+   * Returns: The created parsing job.
+   */
+  create(body: JobCreateParams, options?: Core.RequestOptions): Core.APIPromise<ParsingJob> {
+    return this._client.post('/v1/parsing/jobs', { body, ...options });
+  }
+
+  /**
+   * Get detailed information about a specific parse job.
+   *
+   * Args: job_id: The ID of the parse job.
+   *
+   * Returns: Detailed information about the parse job.
+   */
+  retrieve(jobId: string, options?: Core.RequestOptions): Core.APIPromise<ParsingJob> {
+    return this._client.get(`/v1/parsing/jobs/${jobId}`, options);
+  }
+
+  /**
+   * List parsing jobs with pagination.
+   *
+   * Args: limit: The number of items to return. offset: The number of items to skip.
+   *
+   * Returns: List of parsing jobs with pagination.
+   */
+  list(
+    query?: JobListParams,
+    options?: Core.RequestOptions,
+  ): Core.PagePromise<JobListResponsesLimitOffset, JobListResponse>;
+  list(options?: Core.RequestOptions): Core.PagePromise<JobListResponsesLimitOffset, JobListResponse>;
+  list(
+    query: JobListParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.PagePromise<JobListResponsesLimitOffset, JobListResponse> {
+    if (isRequestOptions(query)) {
+      return this.list({}, query);
+    }
+    return this._client.getAPIList('/v1/parsing/jobs', JobListResponsesLimitOffset, { query, ...options });
+  }
+
+  /**
+   * Delete a specific parse job.
+   *
+   * Args: job_id: The ID of the parse job to delete.
+   *
+   * Returns: The deleted parsing job.
+   */
+  delete(jobId: string, options?: Core.RequestOptions): Core.APIPromise<JobDeleteResponse> {
+    return this._client.delete(`/v1/parsing/jobs/${jobId}`, options);
+  }
+
+  /**
+   * Cancel a specific parse job.
+   *
+   * Args: job_id: The ID of the parse job to cancel.
+   *
+   * Returns: The cancelled parsing job.
+   */
+  cancel(jobId: string, options?: Core.RequestOptions): Core.APIPromise<ParsingJob> {
+    return this._client.patch(`/v1/parsing/jobs/${jobId}`, options);
+  }
+
+  /**
+   * Poll for a job's status until it reaches a terminal state.
+   *
+   * @param jobId - The ID of the job to poll
+   * @param pollIntervalMs - The interval between polls in milliseconds (default: 500)
+   * @param pollTimeoutMs - The maximum time to poll for in milliseconds (default: no timeout)
+   * @param options - Additional request options
+   * @returns The job object once it reaches a terminal state
+   */
+  async poll(
+    jobId: string,
+    pollIntervalMs?: number,
+    pollTimeoutMs?: number,
+    options?: Core.RequestOptions,
+  ): Promise<ParsingJob> {
+    const pollingIntervalMs = pollIntervalMs || 500;
+    const pollingTimeoutMs = pollTimeoutMs;
+
+    return polling.poll({
+      fn: () => this.retrieve(jobId, options),
+      condition: (result) =>
+        result.status === 'completed' || result.status === 'failed' || result.status === 'cancelled',
+      intervalSeconds: pollingIntervalMs / 1000,
+      ...(pollingTimeoutMs && { timeoutSeconds: pollingTimeoutMs / 1000 }),
+    });
+  }
+
+  /**
+   * Create a parsing job and wait for it to complete.
+   *
+   * @param body - Parameters for creating a parse job
+   * @param pollIntervalMs - The interval between polls in milliseconds (default: 500)
+   * @param pollTimeoutMs - The maximum time to poll for in milliseconds (default: no timeout)
+   * @param options - Additional request options
+   * @returns The job object once it reaches a terminal state
+   */
+  async createAndPoll(
+    body: JobCreateParams,
+    pollIntervalMs?: number,
+    pollTimeoutMs?: number,
+    options?: Core.RequestOptions,
+  ): Promise<ParsingJob> {
+    const job = await this.create(body, options);
+    return this.poll(job.id, pollIntervalMs, pollTimeoutMs, options);
+  }
+
+  /**
+   * Upload a file to the files API and then create a parsing job for it.
+   * Note the job will be asynchronously processed.
+   *
+   * @param file - The file to upload
+   * @param body - Additional parameters for creating a parse job
+   * @param options - Additional request options
+   * @returns The created parsing job
+   */
+  async upload(
+    file: Uploadable,
+    body?: Omit<JobCreateParams, 'file_id'>,
+    options?: Core.RequestOptions,
+  ): Promise<ParsingJob> {
+    const fileUploadResponse = await this._client.files.create({ file }, options);
+
+    return this.create(
+      {
+        file_id: fileUploadResponse.id,
+        ...body,
+      },
+      options,
+    );
+  }
+
+  /**
+   * Upload a file and create a parsing job, then poll until processing is complete.
+   *
+   * @param file - The file to upload
+   * @param body - Additional parameters for creating a parse job
+   * @param pollIntervalMs - The interval between polls in milliseconds (default: 500)
+   * @param pollTimeoutMs - The maximum time to poll for in milliseconds (default: no timeout)
+   * @param options - Additional request options
+   * @returns The job object once it reaches a terminal state
+   */
+  async uploadAndPoll(
+    file: Uploadable,
+    body?: Omit<JobCreateParams, 'file_id'>,
+    pollIntervalMs?: number,
+    pollTimeoutMs?: number,
+    options?: Core.RequestOptions,
+  ): Promise<ParsingJob> {
+    const job = await this.upload(file, body, options);
+    return this.poll(job.id, pollIntervalMs, pollTimeoutMs, options);
+  }
+}
+
+export class JobListResponsesLimitOffset extends LimitOffset<JobListResponse> {}
+
+/**
+ * A job for parsing documents with its current state and result.
+ */
+export interface ParsingJob {
+  /**
+   * The ID of the job
+   */
+  id: string;
+
+  /**
+   * The ID of the file to parse
+   */
+  file_id: string;
+
+  /**
+   * The status of the job
+   */
+  status: 'pending' | 'in_progress' | 'cancelled' | 'completed' | 'failed';
+
+  /**
+   * The error of the job
+   */
+  error?: unknown;
+
+  /**
+   * Result of document parsing operation.
+   */
+  result?: ParsingJob.Result | null;
+
+  /**
+   * The started time of the job
+   */
+  started_at?: string | null;
+
+  /**
+   * The finished time of the job
+   */
+  finished_at?: string | null;
+
+  /**
+   * The creation time of the job
+   */
+  created_at?: string;
+
+  /**
+   * The updated time of the job
+   */
+  updated_at?: string | null;
+
+  /**
+   * The type of the object
+   */
+  object?: 'parsing_job';
+}
+
+export namespace ParsingJob {
+  /**
+   * Result of document parsing operation.
+   */
+  export interface Result {
+    /**
+     * The strategy used for chunking the document
+     */
+    chunking_strategy: 'page';
+
+    /**
+     * The format of the returned content
+     */
+    return_format: 'html' | 'markdown' | 'plain';
+
+    /**
+     * The types of elements extracted
+     */
+    element_types: Array<
+      | 'caption'
+      | 'footnote'
+      | 'formula'
+      | 'list-item'
+      | 'page-footer'
+      | 'page-header'
+      | 'picture'
+      | 'section-header'
+      | 'table'
+      | 'text'
+      | 'title'
+    >;
+
+    /**
+     * List of extracted chunks from the document
+     */
+    chunks: Array<Result.Chunk>;
+
+    /**
+     * List of (width, height) tuples for each page
+     */
+    page_sizes?: Array<Array<unknown>>;
+  }
+
+  export namespace Result {
+    /**
+     * A chunk of text extracted from a document page.
+     */
+    export interface Chunk {
+      /**
+       * The full content of the chunk
+       */
+      content: string;
+
+      /**
+       * The content to be used for embedding
+       */
+      content_to_embed: string;
+
+      /**
+       * List of elements contained in this chunk
+       */
+      elements: Array<Chunk.Element>;
+    }
+
+    export namespace Chunk {
+      /**
+       * Represents an extracted element from a document with its content and metadata.
+       */
+      export interface Element {
+        /**
+         * The type of the extracted element
+         */
+        type:
+          | 'caption'
+          | 'footnote'
+          | 'formula'
+          | 'list-item'
+          | 'page-footer'
+          | 'page-header'
+          | 'picture'
+          | 'section-header'
+          | 'table'
+          | 'text'
+          | 'title';
+
+        /**
+         * The confidence score of the extraction
+         */
+        confidence: number;
+
+        /**
+         * The bounding box coordinates [x1, y1, x2, y2]
+         */
+        bbox: Array<unknown>;
+
+        /**
+         * The page number where the element was found
+         */
+        page: number;
+
+        /**
+         * The full content of the extracted element
+         */
+        content: string;
+
+        /**
+         * A brief summary of the element's content
+         */
+        summary?: string | null;
+      }
+    }
+  }
+}
+
+/**
+ * A parsing job item for list responses, omitting result and error fields.
+ */
+export interface JobListResponse {
+  /**
+   * The ID of the job
+   */
+  id: string;
+
+  /**
+   * The ID of the file to parse
+   */
+  file_id: string;
+
+  /**
+   * The status of the job
+   */
+  status: 'pending' | 'in_progress' | 'cancelled' | 'completed' | 'failed';
+
+  /**
+   * The started time of the job
+   */
+  started_at?: string | null;
+
+  /**
+   * The finished time of the job
+   */
+  finished_at?: string | null;
+
+  /**
+   * The creation time of the job
+   */
+  created_at?: string;
+
+  /**
+   * The updated time of the job
+   */
+  updated_at?: string | null;
+
+  /**
+   * The type of the object
+   */
+  object?: 'parsing_job';
+}
+
+/**
+ * A deleted parsing job.
+ */
+export interface JobDeleteResponse {
+  /**
+   * The ID of the deleted job
+   */
+  id: string;
+
+  /**
+   * Whether the job was deleted
+   */
+  deleted?: boolean;
+
+  /**
+   * The type of the object
+   */
+  object?: 'parsing_job';
+}
+
+export interface JobCreateParams {
+  /**
+   * The ID of the file to parse
+   */
+  file_id: string;
+
+  /**
+   * The elements to extract from the document
+   */
+  element_types?: Array<
+    | 'caption'
+    | 'footnote'
+    | 'formula'
+    | 'list-item'
+    | 'page-footer'
+    | 'page-header'
+    | 'picture'
+    | 'section-header'
+    | 'table'
+    | 'text'
+    | 'title'
+  > | null;
+
+  /**
+   * The strategy to use for chunking the content
+   */
+  chunking_strategy?: 'page';
+
+  /**
+   * The format of the returned content
+   */
+  return_format?: 'html' | 'markdown' | 'plain';
+}
+
+export interface JobListParams extends LimitOffsetParams {}
+
+Jobs.JobListResponsesLimitOffset = JobListResponsesLimitOffset;
+
+export declare namespace Jobs {
+  export {
+    type ParsingJob as ParsingJob,
+    type JobListResponse as JobListResponse,
+    type JobDeleteResponse as JobDeleteResponse,
+    JobListResponsesLimitOffset as JobListResponsesLimitOffset,
+    type JobCreateParams as JobCreateParams,
+    type JobListParams as JobListParams,
+  };
+}

package/src/resources/parsing/parsing.ts

@@ -0,0 +1,32 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../resource';
+import * as JobsAPI from './jobs';
+import {
+  JobCreateParams,
+  JobDeleteResponse,
+  JobListParams,
+  JobListResponse,
+  JobListResponsesLimitOffset,
+  Jobs,
+  ParsingJob,
+} from './jobs';
+
+export class Parsing extends APIResource {
+  jobs: JobsAPI.Jobs = new JobsAPI.Jobs(this._client);
+}
+
+Parsing.Jobs = Jobs;
+Parsing.JobListResponsesLimitOffset = JobListResponsesLimitOffset;
+
+export declare namespace Parsing {
+  export {
+    Jobs as Jobs,
+    type ParsingJob as ParsingJob,
+    type JobListResponse as JobListResponse,
+    type JobDeleteResponse as JobDeleteResponse,
+    JobListResponsesLimitOffset as JobListResponsesLimitOffset,
+    type JobCreateParams as JobCreateParams,
+    type JobListParams as JobListParams,
+  };
+}