graphor 0.12.2 → 0.14.0

package/resources/sources.mjs

@@ -1,6 +1,7 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 import { APIResource } from "../core/resource.mjs";
 import { multipartFormRequestOptions } from "../internal/uploads.mjs";
+import { path } from "../internal/utils/path.mjs";
 export class Sources extends APIResource {
     /**
      * List all sources in the project's knowledge graph.
@@ -10,12 +11,17 @@ export class Sources extends APIResource {
      * type, origin) along with its current processing status and a human-readable
      * status message.
      *
+     * **Query parameters:**
+     *
+     * - **file_ids** (list, optional): If provided, only sources whose file_id is in
+     *   this list are returned. Repeat the param for multiple IDs (e.g.
+     *   ?file_ids=id1&file_ids=id2).
+     *
      * **Status messages returned per source:**
      *
      * - `"completed"` → _"Source processed successfully"_
      * - `"processing"` → _"Source is being processed"_
      * - `"failed"` → _"Source processing failed"_
-     * - `"new"` → _"Source uploaded, awaiting processing"_
      *
      * **Returns** a JSON array of `PublicSourceResponse` objects.
      *
@@ -28,8 +34,8 @@ export class Sources extends APIResource {
      * const publicSources = await client.sources.list();
      * ```
      */
-    list(options) {
-        return this._client.get('/sources', options);
+    list(query = {}, options) {
+        return this._client.get('/sources', { query, ...options });
     }
     /**
      * Delete a source from the project's knowledge graph and all associated data.
@@ -161,332 +167,290 @@ export class Sources extends APIResource {
         return this._client.post('/sources/run-extraction', { body, ...options });
     }
     /**
-     * Retrieve the parsed elements (chunks/partitions) of a specific source with
-     * pagination.
-     *
-     * Returns the individual document partitions (text chunks) that were generated
-     * during ingestion for a given source. This is useful for inspecting how a file
-     * was segmented, reviewing chunk content, or building custom retrieval logic on
-     * top of the raw partitions.
-     *
-     * **Parameters (JSON body):**
-     *
-     * - **file_id** (str, optional — preferred): The unique identifier of the source
-     *   whose elements to retrieve.
-     * - **file_name** (str, optional — deprecated): The display name of the source.
-     *   Use `file_id` when possible. At least one of `file_id` or `file_name` must be
-     *   provided.
-     * - **page** (int, optional): The 1-based page number for pagination.
-     * - **page_size** (int, optional): The number of elements per page. Both `page`
-     *   and `page_size` must be provided together to enable pagination.
-     * - **filter** (object, optional): An optional filter object with:
-     *   - `type` — filter by element type.
-     *   - `page_numbers` — restrict to specific source page numbers.
-     *   - `elementsToRemove` — list of element types to exclude.
-     *
-     * **Returns** a `PaginatedResponse[Document]` containing:
-     *
-     * - `items` — list of `Document` objects (LangChain format) with `page_content`
-     *   and `metadata`.
-     * - `total` — total number of matching elements.
-     * - `page`, `page_size`, `total_pages` — pagination metadata.
+     * Return the status and optional parsed elements for an async build identified by
+     * `build_id`.
+     *
+     * Use this endpoint to poll the result of an async ingestion or re-process
+     * request. The `build_id` is returned in the response of:
+     *
+     * - `POST /v2/sources/upload` (async file upload)
+     * - `POST /v2/sources/upload-url-source` (async URL ingestion)
+     * - `POST /v2/sources/upload-github-source` (async GitHub ingestion)
+     * - `POST /v2/sources/upload-youtube-source` (async YouTube ingestion)
+     * - `POST /v2/sources/process` (async re-process)
+     *
+     * **Path parameter:**
+     *
+     * - **build_id** (str, required): The build identifier returned when the job was
+     *   scheduled.
+     *
+     * **Query parameters:**
+     *
+     * - **suppress_elements** (bool, default `false`): When `true`, elements are
+     *   omitted from the response. When `false` (default), the response includes the
+     *   parsed elements (chunks/partitions) for the build if it completed
+     *   successfully. Same structure as `POST /sources/elements` (each element has
+     *   `page_content` and `metadata`). If `page` and `page_size` are not passed, all
+     *   elements are returned.
+     * - **suppress_img_base64** (bool, default `false`): When `true`, `img_base64` is
+     *   omitted from each element (useful to reduce payload size when images are not
+     *   needed).
+     * - **page** (int, optional): 1-based page number. Only used when
+     *   `suppress_elements=false` and pagination is used (pass either `page` or
+     *   `page_size` to enable pagination).
+     * - **page_size** (int, optional): Number of elements per page (max 100). Only
+     *   used when `suppress_elements=false` and pagination is used.
+     *
+     * **Response fields:**
+     *
+     * - **build_id**: The requested build identifier.
+     * - **status**: SourceNodeStatus value when history exists (e.g. Processed,
+     *   Processing, Processing failed). `not_found` when no history exists (build in
+     *   progress or invalid id).
+     * - **success**: `true` only when `status == "Completed"`
+     *   (SourceNodeStatus.COMPLETED).
+     * - **file_id**, **file_name**: Source identifiers; present when the build has
+     *   been persisted (history exists).
+     * - **error**: Error message from the pipeline when the build failed.
+     * - **method**, **total_partitions**, **total_pages**: Build metadata when history
+     *   exists.
+     * - **created_at**, **updated_at**: ISO8601 timestamps when history exists.
+     * - **message**: Human-readable message (e.g. when status is `not_found`).
+     * - **elements**: List of `{ page_content, metadata }` when
+     *   `suppress_elements=false` and the build completed successfully.
+     * - **total_elements**, **page**, **page_size**, **total_pages_elements**:
+     *   Pagination metadata for `elements` when `suppress_elements=false`.
      *
      * **Error responses:**
      *
-     * - `400` — Invalid input (e.g. neither identifier provided).
-     * - `404` — Source file not found.
      * - `500` — Unexpected internal error.
      *
      * @example
      * ```ts
-     * const response = await client.sources.loadElements();
+     * const response = await client.sources.getBuildStatus(
+     *   'build_id',
+     * );
      * ```
      */
-    loadElements(body, options) {
-        return this._client.post('/sources/elements', { body, ...options });
+    getBuildStatus(buildID, query = {}, options) {
+        return this._client.get(path `/sources/builds/${buildID}`, { query, ...options });
     }
     /**
-     * Re-process (re-parse) an existing source that has already been uploaded.
-     *
-     * Use this endpoint to re-run the data-ingestion pipeline on a source that is
-     * already present in the knowledge graph — for example, after changing the
-     * partitioning strategy. The endpoint locates the source node, sets its status to
-     * `PROCESSING`, applies the requested partition method, and executes the full
-     * ingestion pipeline synchronously (partitioning, chunking, embedding, and graph
-     * persistence).
-     *
-     * **Parameters (JSON body):**
-     *
-     * - **file_id** (str, optional — preferred): The unique identifier of the source
-     *   to re-process.
-     * - **file_name** (str, optional — deprecated): The display name of the source.
-     *   Use `file_id` instead when possible. At least one of `file_id` or `file_name`
-     *   must be provided.
-     * - **partition_method** (str, default `"basic"`): The partitioning strategy to
-     *   apply. One of: `basic` (Fast), `hi_res` (Balanced), `hi_res_ft` (Accurate),
-     *   `mai` (VLM), `graphorlm` (Agentic).
-     *
-     * **Returns** a `PublicSourceResponse` with the updated source metadata.
-     *
-     * **Error responses:**
-     *
-     * - `404` — Source node not found for the given identifier.
-     * - `500` — Processing or unexpected internal error.
+     * Retrieve the parsed elements (chunks/partitions) of a source in the same format
+     * as get_build_status.
+     *
+     * Returns elements with explicit fields: element_id, element_type, text, markdown,
+     * html, img_base64 (optional), position, page_number, bounding_box, page_layout,
+     * etc.
+     *
+     * **Query parameters:**
+     *
+     * - **file_id** (str, required): Unique identifier of the source.
+     * - **page** (int, optional): 1-based page number. Use with page_size to enable
+     *   pagination.
+     * - **page_size** (int, optional): Number of elements per page (max 100).
+     * - **suppress_img_base64** (bool, default false): When true, img_base64 is
+     *   omitted from each element.
+     * - **type** (str, optional): Filter by element type (e.g. NarrativeText, Title,
+     *   Table).
+     * - **page_numbers** (list, optional): Restrict to specific page numbers (repeat
+     *   param for multiple).
+     * - **elementsToRemove** (list, optional): Element types to exclude (repeat param
+     *   for multiple).
+     *
+     * **Returns** Paginated response with items as BuildStatusElement list (same shape
+     * as GET /builds/{build_id} elements).
      *
      * @example
      * ```ts
-     * const publicSource = await client.sources.parse();
+     * const response = await client.sources.getElements({
+     *   file_id: 'file_id',
+     * });
      * ```
      */
-    parse(body, options) {
-        return this._client.post('/sources/process', { body, ...options });
+    getElements(query, options) {
+        return this._client.get('/sources/get-elements', { query, ...options });
     }
     /**
-     * Retrieve relevant document chunks from the prebuilt RAG vector store.
+     * Upload a local file and schedule ingestion in the background.
      *
-     * Performs a semantic similarity search over the project's prebuilt RAG store
-     * using Google File Search with grounding. Returns the most relevant text chunks
-     * along with their source metadata (file name, page number, relevance score). This
-     * is a pure retrieval endpoint — it does **not** generate an answer; use
-     * `/ask-sources` for Q&A.
-     *
-     * **Parameters (JSON body):**
+     * Accepts **`multipart/form-data`** with the file. Validates size (max 100 MB) and
+     * extension, stores the file, then schedules the full data-ingestion pipeline in
+     * the background. Returns immediately with a `build_id` to poll for status.
      *
-     * - **query** (str, required): The natural-language search query used to find
-     *   relevant chunks.
-     * - **file_ids** (list[str], optional — preferred): Restrict retrieval to specific
-     *   source file IDs.
-     * - **file_names** (list[str], optional — deprecated): Restrict retrieval to
-     *   specific source file names. Use `file_ids` when possible.
-     *
-     * **Returns** a `PublicRetrieveResponse` containing:
-     *
-     * - `query` — the original search query.
-     * - `chunks` — a list of `PublicRetrieveChunk` objects, each with `text`,
-     *   `file_name`, `page_number`, `score`, and additional `metadata`.
-     * - `total` — the total number of chunks returned.
+     * **Parameters:**
      *
-     * **Error responses:**
+     * - **file** (`multipart/form-data`): The file to upload. Must include
+     *   `Content-Length` and have a supported extension (pdf, doc, docx, csv, txt, md,
+     *   etc.).
+     * - **method** (`form`, optional): Partitioning strategy. One of: `fast`,
+     *   `balanced`, `accurate`, `vlm`, `agentic`. Default when omitted.
      *
-     * - `500` — Unexpected internal error during retrieval.
+     * **Returns** `AsyncIngestResponse` with `build_id`. Use it to check processing
+     * status.
      *
      * @example
      * ```ts
-     * const response = await client.sources.retrieveChunks({
-     *   query: 'query',
+     * const response = await client.sources.ingestFile({
+     *   file: fs.createReadStream('path/to/file'),
      * });
      * ```
      */
-    retrieveChunks(body, options) {
-        return this._client.post('/sources/prebuilt-rag', { body, ...options });
+    ingestFile(body, options) {
+        return this._client.post('/sources/ingest-file', multipartFormRequestOptions({ body, ...options }, this._client));
     }
     /**
-     * Upload a local file and ingest it as a source into the project's knowledge
-     * graph.
-     *
-     * This endpoint accepts a **`multipart/form-data`** request containing the file to
-     * upload. It validates the file size (max 100 MB) and extension against the list
-     * of allowed types, stores the file, and then runs the full data-ingestion
-     * pipeline synchronously — including partitioning, chunking, embedding, and graph
-     * persistence.
-     *
-     * **Usage via SDK (AI agent / MCP context):**
-     *
-     * The SDK executes code in a **remote sandboxed container** that does **not** have
-     * access to the local filesystem. Because of this, `fs.createReadStream()` with a
-     * local file path will **not work** — the file does not exist inside the
-     * container.
-     *
-     * For **text-based files** (md, txt, csv, html, etc.), you can read the file
-     * content with a local tool (e.g. IDE file-read) and create a `File` object in
-     * memory:
-     *
-     * ```
-     * const content = `...file contents read locally...`;
-     * const file = new File([content], "my-document.md", { type: "text/markdown" });
-     * const result = await client.sources.upload({ file });
-     * ```
-     *
-     * For **binary files** (pdf, docx, images, video, audio, etc.), the in-memory
-     * approach is impractical. Instead, use **`curl`** or **`subprocess`** to call the
-     * upload endpoint directly from the local machine, where the file is accessible:
-     *
-     * ```
-     * import { execSync } from "child_process";
-     *
-     * const result = execSync(`
-     *   curl -s -X POST "{base_url}/source/upload" \
-     *     -H "Authorization: Bearer {access_key}" \
-     *     -F "file=@/local/path/to/document.pdf" \
-     *     -F "partition_method=graphorlm"
-     * `).toString();
-     * ```
+     * Ingest a GitHub repository as a source into the project's knowledge graph.
      *
-     * Or with Python `subprocess`:
+     * Schedules the ingestion in the background and returns immediately with a
+     * `build_id`. Use the returned `build_id` to poll for processing status.
      *
-     * ```
-     * import subprocess, json
-     *
-     * result = subprocess.run([
-     *     "curl", "-s", "-X", "POST", "{base_url}/source/upload",
-     *     "-H", "Authorization: Bearer {access_key}",
-     *     "-F", "file=@/local/path/to/document.pdf",
-     *     "-F", "partition_method=graphorlm",
-     * ], capture_output=True, text=True)
-     * response = json.loads(result.stdout)
-     * ```
+     * **Parameters (JSON body):**
      *
-     * **Important:** Do NOT use `fs.createReadStream("/local/path")` inside the SDK
-     * code — it will fail because the execution environment cannot access local paths.
-     * Always prefer `curl`/`requests` executed locally for binary uploads.
+     * - **url** (str, required): The GitHub repository URL to ingest (e.g.
+     *   `https://github.com/owner/repo`).
      *
-     * **Usage via curl:**
+     * **Returns** `AsyncIngestResponse` with `build_id`.
      *
+     * @example
+     * ```ts
+     * const response = await client.sources.ingestGitHub({
+     *   url: 'url',
+     * });
      * ```
-     * curl -X POST "{base_url}/source/upload" \
-     *   -H "Authorization: Bearer {access_key}" \
-     *   -F "file=@/path/to/document.pdf" \
-     *   -F "partition_method=graphorlm"
-     * ```
+     */
+    ingestGitHub(body, options) {
+        return this._client.post('/sources/ingest-github', { body, ...options });
+    }
+    /**
+     * Ingest a web page (or a set of crawled pages) as a source into the project's
+     * knowledge graph.
      *
-     * **Usage via Python `requests`:**
+     * Unlike the synchronous version, this endpoint schedules the ingestion in the
+     * background and returns immediately with a `processing` status. The source will
+     * be fully available once background processing completes.
      *
-     * ```
-     * import requests
-     *
-     * with open("document.pdf", "rb") as f:
-     *     response = requests.post(
-     *         "{base_url}/source/upload",
-     *         headers={"Authorization": "Bearer {access_key}"},
-     *         files={"file": ("document.pdf", f, "application/pdf")},
-     *         data={"partition_method": "graphorlm"},  # optional
-     *     )
-     * ```
+     * If the URL points directly to a downloadable file (detected via URL path
+     * extension or HTTP Content-Type), the file is first downloaded and uploaded to
+     * storage synchronously, then the partition/embedding pipeline runs in the
+     * background.
      *
-     * **Parameters:**
+     * **Parameters (JSON body):**
      *
-     * - **file** (`multipart/form-data`): The file to upload. Must include a
-     *   `Content-Length` header and have one of the supported extensions: pdf, doc,
-     *   docx, odt, ppt, pptx, csv, tsv, xls, xlsx, txt, text, md, html, htm, png, jpg,
-     *   jpeg, tiff, bmp, heic, mp4, mov, avi, mkv, webm, mp3, wav, m4a, ogg, flac.
-     * - **partition_method** (`form`, optional): The partitioning strategy to apply.
-     *   One of: `basic` (Fast), `hi_res` (Balanced), `hi_res_ft` (Accurate), `mai`
-     *   (VLM), `graphorlm` (Agentic). When omitted, the system default is used.
+     * - **url** (str, required): The web page URL to ingest.
+     * - **crawlUrls** (bool, optional, default `false`): When `true`, the system will
+     *   also follow and ingest links found on the page. Ignored when the URL resolves
+     *   to a file.
+     * - **method** (str, optional): The partitioning strategy to use. One of: `fast`,
+     *   `balanced`, `accurate`, `vlm`, `agentic`. When omitted the system default is
+     *   applied.
      *
-     * **Returns** a `PublicSourceResponse` with the resulting source metadata (file
-     * ID, name, size, type, source origin, partition method, and processing status).
+     * **Returns** a `PublicSourceResponse` with `status: "processing"` immediately.
+     * Poll the source status endpoint using the returned `file_id` to track
+     * completion.
      *
      * **Error responses:**
      *
-     * - `400` — Unsupported file type or missing file name.
-     * - `411` — Missing `Content-Length` header (file size cannot be determined).
-     * - `413` — File exceeds the 100 MB size limit.
-     * - `403` — Permission denied.
-     * - `404` — File not found during processing.
-     * - `500` — Unexpected internal error.
+     * - `400` — Unsupported file type detected from a file URL.
+     * - `500` — Unexpected internal error during URL processing.
      *
      * @example
      * ```ts
-     * const publicSource = await client.sources.upload({
-     *   file: fs.createReadStream('path/to/file'),
+     * const response = await client.sources.ingestURL({
+     *   url: 'url',
      * });
      * ```
      */
-    upload(body, options) {
-        return this._client.post('/sources/upload', multipartFormRequestOptions({ body, ...options }, this._client));
+    ingestURL(body, options) {
+        return this._client.post('/sources/ingest-url', { body, ...options });
     }
     /**
-     * Ingest a GitHub repository as a source into the project's knowledge graph.
+     * Ingest a YouTube video as a source into the project's knowledge graph.
      *
-     * The endpoint clones or fetches the repository at the given URL, extracts its
-     * text-based files, partitions them using the system default method, generates
-     * embeddings, and persists everything in the knowledge graph synchronously.
+     * Schedules the ingestion in the background and returns immediately with a
+     * `build_id`. The endpoint will download the transcript/captions and process them
+     * in the background. Use the returned `build_id` to poll for processing status.
      *
      * **Parameters (JSON body):**
      *
-     * - **url** (str, required): The GitHub repository URL to ingest (e.g.
-     *   `https://github.com/owner/repo`).
-     *
-     * **Returns** a `PublicSourceResponse` with the resulting source metadata (file
-     * ID, name, size, type, source origin, partition method, and processing status).
-     *
-     * **Error responses:**
+     * - **url** (str, required): The YouTube video URL to ingest (e.g.
+     *   `https://www.youtube.com/watch?v=...`).
      *
-     * - `500` — Unexpected internal error during GitHub source processing.
+     * **Returns** `AsyncIngestResponse` with `build_id`.
      *
      * @example
      * ```ts
-     * const publicSource = await client.sources.uploadGitHub({
+     * const response = await client.sources.ingestYoutube({
      *   url: 'url',
      * });
      * ```
      */
-    uploadGitHub(body, options) {
-        return this._client.post('/sources/upload-github-source', { body, ...options });
+    ingestYoutube(body, options) {
+        return this._client.post('/sources/ingest-youtube', { body, ...options });
     }
     /**
-     * Ingest a web page (or a set of crawled pages) as a source into the project's
-     * knowledge graph.
+     * Re-process (re-parse) an existing source in the background.
      *
-     * The endpoint fetches the content at the given URL, optionally crawls linked
-     * pages (when `crawlUrls` is `true`), partitions the resulting HTML/text,
-     * generates embeddings, and persists everything in the knowledge graph
-     * synchronously.
+     * Schedules the data-ingestion pipeline (partitioning, chunking, embedding) for an
+     * existing source and returns immediately with a `build_id`. Use it to poll for
+     * status.
      *
      * **Parameters (JSON body):**
      *
-     * - **url** (str, required): The web page URL to ingest.
-     * - **crawlUrls** (bool, optional, default `false`): When `true`, the system will
-     *   also follow and ingest links found on the page.
-     * - **partition_method** (str, optional): The partitioning strategy to use. One
-     *   of: `basic` (Fast), `hi_res` (Balanced), `hi_res_ft` (Accurate), `mai` (VLM),
-     *   `graphorlm` (Agentic). When omitted the system default is applied.
-     *
-     * **Returns** a `PublicSourceResponse` with the resulting source metadata (file
-     * ID, name, size, type, source origin, partition method, and processing status).
+     * - **file_id** (str, required): Unique identifier of the source to re-process.
+     * - **method** (str, default `"fast"`): Partitioning strategy. One of: `fast`,
+     *   `balanced`, `accurate`, `vlm`, `agentic`.
      *
-     * **Error responses:**
-     *
-     * - `500` — Unexpected internal error during URL processing.
+     * **Returns** `AsyncIngestResponse` with `build_id`.
      *
      * @example
      * ```ts
-     * const publicSource = await client.sources.uploadURL({
-     *   url: 'url',
+     * const response = await client.sources.reprocess({
+     *   file_id: 'file_id',
      * });
      * ```
      */
-    uploadURL(body, options) {
-        return this._client.post('/sources/upload-url-source', { body, ...options });
+    reprocess(body, options) {
+        return this._client.post('/sources/reprocess', { body, ...options });
     }
     /**
-     * Ingest a YouTube video as a source into the project's knowledge graph.
+     * Retrieve relevant document chunks from the prebuilt RAG vector store.
      *
-     * The endpoint downloads the transcript/captions of the given YouTube video,
-     * partitions the text using the system default method, generates embeddings, and
-     * persists everything in the knowledge graph synchronously.
+     * Performs a semantic similarity search over the project's prebuilt RAG store
+     * using Google File Search with grounding. Returns the most relevant text chunks
+     * along with their source metadata (file name, page number, relevance score). This
+     * is a pure retrieval endpoint — it does **not** generate an answer; use
+     * `/ask-sources` for Q&A.
      *
      * **Parameters (JSON body):**
      *
-     * - **url** (str, required): The YouTube video URL to ingest (e.g.
-     *   `https://www.youtube.com/watch?v=...`).
+     * - **query** (str, required): The natural-language search query used to find
+     *   relevant chunks.
+     * - **file_ids** (list[str], optional — preferred): Restrict retrieval to specific
+     *   source file IDs.
+     * - **file_names** (list[str], optional — deprecated): Restrict retrieval to
+     *   specific source file names. Use `file_ids` when possible.
      *
-     * **Returns** a `PublicSourceResponse` with the resulting source metadata (file
-     * ID, name, size, type, source origin, partition method, and processing status).
+     * **Returns** a `PublicRetrieveResponse` containing:
+     *
+     * - `query` — the original search query.
+     * - `chunks` — a list of `PublicRetrieveChunk` objects, each with `text`,
+     *   `file_name`, `page_number`, `score`, and additional `metadata`.
+     * - `total` — the total number of chunks returned.
      *
      * **Error responses:**
      *
-     * - `500` — Unexpected internal error during YouTube source processing.
+     * - `500` — Unexpected internal error during retrieval.
      *
      * @example
      * ```ts
-     * const publicSource = await client.sources.uploadYoutube({
-     *   url: 'url',
+     * const response = await client.sources.retrieveChunks({
+     *   query: 'query',
      * });
      * ```
      */
-    uploadYoutube(body, options) {
-        return this._client.post('/sources/upload-youtube-source', { body, ...options });
+    retrieveChunks(body, options) {
+        return this._client.post('/sources/prebuilt-rag', { body, ...options });
     }
 }
 //# sourceMappingURL=sources.mjs.map

package/resources/sources.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"sources.mjs","sourceRoot":"","sources":["../src/resources/sources.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"sources.mjs","sourceRoot":"","sources":["../src/resources/sources.ts"],"names":[],"mappings":"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"}