graphor 0.6.0 → 0.8.0

package/resources/sources.mjs

@@ -3,79 +3,408 @@ import { APIResource } from "../core/resource.mjs";
 import { multipartFormRequestOptions } from "../internal/uploads.mjs";
 export class Sources extends APIResource {
     /**
-     * Get the source nodes of the knowledge graph for public access.
+     * List all sources in the project's knowledge graph.
+     *
+     * Returns every source node currently stored in the knowledge graph for the
+     * authenticated project. Each item includes the file metadata (ID, name, size,
+     * type, origin) along with its current processing status and a human-readable
+     * status message.
+     *
+     * **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.
+     *
+     * **Error responses:**
+     *
+     * - `500` — Unexpected internal error while retrieving sources.
+     *
+     * @example
+     * ```ts
+     * const publicSources = await client.sources.list();
+     * ```
      */
     list(options) {
         return this._client.get('/sources', options);
     }
     /**
-     * Delete a source from the project for public access.
+     * Delete a source from the project's knowledge graph and all associated data.
+     *
+     * Removes the source node, its partitions/chunks, embeddings, and any stored files
+     * from the knowledge graph and object storage. The operation is irreversible.
+     *
+     * **Parameters (JSON body):**
+     *
+     * - **file_id** (str, optional — preferred): The unique identifier of the source
+     *   to delete.
+     * - **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.
      *
-     * Accepts either file_id (preferred) or file_name (deprecated) as identifier.
+     * **Returns** a `PublicDeleteSourceResponse` with the deletion status, file ID,
+     * file name, project ID, and project name.
+     *
+     * **Error responses:**
+     *
+     * - `400` — Invalid input (e.g. neither identifier provided).
+     * - `403` — Permission denied.
+     * - `404` — Source not found.
+     * - `500` — Unexpected internal error.
+     *
+     * @example
+     * ```ts
+     * const source = await client.sources.delete();
+     * ```
      */
     delete(body, options) {
         return this._client.delete('/sources/delete', { body, ...options });
     }
     /**
-     * Public endpoint to ask questions about the sources.
+     * Ask a natural-language question grounded on the project's ingested sources.
+     *
+     * This is the primary Q&A endpoint. It sends the question through the GenAI File
+     * Search pipeline, which retrieves relevant chunks from the knowledge graph,
+     * grounds the answer in the source documents, and returns a natural-language
+     * response. Optionally, you can request a structured JSON output by supplying an
+     * `output_schema`.
+     *
+     * Conversation memory is supported: pass a `conversation_id` to continue an
+     * existing conversation, or set `reset` to `true` to start fresh.
+     *
+     * **Parameters (JSON body):**
+     *
+     * - **question** (str, required): The question to ask about the sources.
+     * - **conversation_id** (str, optional): An existing conversation identifier to
+     *   maintain context across multiple turns.
+     * - **reset** (bool, optional, default `false`): When `true`, starts a new
+     *   conversation discarding any previous history.
+     * - **file_ids** (list[str], optional — preferred): Restrict the search scope to
+     *   specific source file IDs.
+     * - **file_names** (list[str], optional — deprecated): Restrict the search scope
+     *   to specific source file names. Use `file_ids` when possible.
+     * - **output_schema** (dict, optional): A JSON Schema for requesting structured
+     *   output. When provided, the response includes a `structured_output` field
+     *   validated against this schema and the `raw_json` produced by the model.
+     * - **thinking_level** (str, optional, default `"accurate"`): Controls the
+     *   model/thinking budget — one of `"fast"`, `"balanced"`, or `"accurate"`.
+     *
+     * **Returns** a `PublicAskSourcesResponse` containing:
+     *
+     * - `answer` — the natural-language answer (or a status message when
+     *   `output_schema` is provided).
+     * - `structured_output` — the validated structured object (when `output_schema` is
+     *   provided).
+     * - `raw_json` — the raw JSON text before validation (when `output_schema` is
+     *   provided).
+     * - `conversation_id` — the conversation identifier for follow-up questions.
+     *
+     * **Error responses:**
+     *
+     * - `500` — Unexpected internal error while asking sources.
+     *
+     * @example
+     * ```ts
+     * const response = await client.sources.ask({
+     *   question: 'question',
+     * });
+     * ```
      */
     ask(body, options) {
         return this._client.post('/sources/ask-sources', { body, ...options });
     }
     /**
-     * Run a one-off public extraction for files using the provided output schema.
+     * Run a one-off structured data extraction against one or more sources.
+     *
+     * This endpoint uses the GenAI File Search pipeline to read the specified sources,
+     * apply the user-provided instruction, and return structured JSON output
+     * conforming to the supplied `output_schema`. Internally it builds a grounded
+     * prompt, queries the model, and validates/corrects the raw JSON against the
+     * schema.
+     *
+     * **Parameters (JSON body):**
+     *
+     * - **file_ids** (list[str], optional — preferred): List of source file IDs to
+     *   extract from.
+     * - **file_names** (list[str], optional — deprecated): List of source file names
+     *   to extract from. Use `file_ids` when possible. At least one of the two lists
+     *   must be provided and non-empty.
+     * - **user_instruction** (str, required): A natural-language instruction that
+     *   guides what information to extract from the documents.
+     * - **output_schema** (dict, required): A JSON Schema object describing the
+     *   desired structured output shape. The model will produce data conforming to
+     *   this schema.
+     * - **thinking_level** (str, optional, default `"accurate"`): Controls the
+     *   model/thinking budget — one of `"fast"`, `"balanced"`, or `"accurate"`.
+     *
+     * **Returns** a `PublicRunExtractionResultResponse` containing:
+     *
+     * - `structured_output` — the validated structured object.
+     * - `raw_json` — the raw JSON text produced by the model before validation.
+     *
+     * **Error responses:**
+     *
+     * - `500` — Unexpected internal error during extraction.
+     *
+     * @example
+     * ```ts
+     * const response = await client.sources.extract({
+     *   output_schema: { foo: 'bar' },
+     *   user_instruction: 'user_instruction',
+     * });
+     * ```
      */
     extract(body, options) {
         return this._client.post('/sources/run-extraction', { body, ...options });
     }
     /**
-     * Loads elements from a file with optional pagination for public access.
+     * Retrieve the parsed elements (chunks/partitions) of a specific source with
+     * pagination.
      *
-     * Accepts either file_id (preferred) or file_name (deprecated) as identifier.
+     * 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.
+     *
+     * **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();
+     * ```
      */
     loadElements(body, options) {
         return this._client.post('/sources/elements', { body, ...options });
     }
     /**
-     * Process/parse an existing source.
+     * 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):**
      *
-     * Accepts either file_id (preferred) or file_name (deprecated) as identifier.
+     * - **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 (e.g. `"basic"`, `"hi_res"`, `"fast"`).
+     *
+     * **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.
+     *
+     * @example
+     * ```ts
+     * const publicSource = await client.sources.parse();
+     * ```
      */
     parse(body, options) {
         return this._client.post('/sources/process', { body, ...options });
     }
     /**
-     * Public endpoint to retrieve relevant chunks from the prebuild RAG store. Uses
-     * Google File Search with grounding to find relevant document chunks.
+     * Retrieve relevant document chunks from the prebuilt RAG vector store.
+     *
+     * 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):**
+     *
+     * - **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.
+     *
+     * **Error responses:**
      *
-     * Accepts either file_ids (preferred) or file_names (deprecated) as identifier.
+     * - `500` — Unexpected internal error during retrieval.
+     *
+     * @example
+     * ```ts
+     * const response = await client.sources.retrieveChunks({
+     *   query: 'query',
+     * });
+     * ```
      */
     retrieveChunks(body, options) {
         return this._client.post('/sources/prebuilt-rag', { body, ...options });
     }
     /**
-     * Upload
+     * Upload a local file and ingest it as a source into the project's knowledge
+     * graph.
+     *
+     * This endpoint accepts a multipart file upload, validates the file size (max 100
+     * MB) and extension against the list of allowed ingestion types, stores the file,
+     * and then runs the full data-ingestion pipeline synchronously — including
+     * partitioning, chunking, embedding, and graph persistence.
+     *
+     * **Parameters:**
+     *
+     * - **file** (multipart): The file to upload. Must include a `Content-Length`
+     *   header and have a supported extension (e.g. pdf, docx, txt, csv, etc.).
+     * - **partition_method** (form, optional): The partitioning strategy to apply to
+     *   the document. When omitted the system default is used.
+     *
+     * **Returns** a `PublicSourceResponse` with the resulting source metadata (file
+     * ID, name, size, type, source origin, partition method, and processing status).
+     *
+     * **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.
+     *
+     * @example
+     * ```ts
+     * const publicSource = await client.sources.upload({
+     *   file: fs.createReadStream('path/to/file'),
+     * });
+     * ```
      */
     upload(body, options) {
         return this._client.post('/sources/upload', multipartFormRequestOptions({ body, ...options }, this._client));
     }
     /**
-     * Public endpoint to process a source from a GitHub repository using synchronous
-     * ingestion.
+     * Ingest a GitHub repository 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.
+     *
+     * **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:**
+     *
+     * - `500` — Unexpected internal error during GitHub source processing.
+     *
+     * @example
+     * ```ts
+     * const publicSource = await client.sources.uploadGitHub({
+     *   url: 'url',
+     * });
+     * ```
      */
     uploadGitHub(body, options) {
         return this._client.post('/sources/upload-github-source', { body, ...options });
     }
     /**
-     * Public endpoint to upload and process a source from a URL. Triggers background
-     * ingestion and returns immediately.
+     * Ingest a web page (or a set of crawled pages) as a source into the project's
+     * knowledge graph.
+     *
+     * 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.
+     *
+     * **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. 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).
+     *
+     * **Error responses:**
+     *
+     * - `500` — Unexpected internal error during URL processing.
+     *
+     * @example
+     * ```ts
+     * const publicSource = await client.sources.uploadURL({
+     *   url: 'url',
+     * });
+     * ```
      */
     uploadURL(body, options) {
         return this._client.post('/sources/upload-url-source', { body, ...options });
     }
     /**
-     * Public endpoint to process a source from a YouTube video using synchronous
-     * ingestion.
+     * Ingest a YouTube video as a source into the project's knowledge graph.
+     *
+     * 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.
+     *
+     * **Parameters (JSON body):**
+     *
+     * - **url** (str, required): The YouTube video URL to ingest (e.g.
+     *   `https://www.youtube.com/watch?v=...`).
+     *
+     * **Returns** a `PublicSourceResponse` with the resulting source metadata (file
+     * ID, name, size, type, source origin, partition method, and processing status).
+     *
+     * **Error responses:**
+     *
+     * - `500` — Unexpected internal error during YouTube source processing.
+     *
+     * @example
+     * ```ts
+     * const publicSource = await client.sources.uploadYoutube({
+     *   url: 'url',
+     * });
+     * ```
      */
     uploadYoutube(body, options) {
         return this._client.post('/sources/upload-youtube-source', { body, ...options });

package/resources/sources.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"sources.mjs","sourceRoot":"","sources":["../src/resources/sources.ts"],"names":[],"mappings":"AAAA,sFAAsF;OAE/E,EAAE,WAAW,EAAE;OAIf,EAAE,2BAA2B,EAAE;AAEtC,MAAM,OAAO,OAAQ,SAAQ,WAAW;IACtC;;OAEG;IACH,IAAI,CAAC,OAAwB;QAC3B,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IAC/C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,IAAwB,EAAE,OAAwB;QACvD,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,iBAAiB,EAAE,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IACtE,CAAC;IAED;;OAEG;IACH,GAAG,CAAC,IAAqB,EAAE,OAAwB;QACjD,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,sBAAsB,EAAE,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IACzE,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,IAAyB,EAAE,OAAwB;QACzD,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,yBAAyB,EAAE,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IAC5E,CAAC;IAED;;;;OAIG;IACH,YAAY,CACV,IAA8B,EAC9B,OAAwB;QAExB,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,mBAAmB,EAAE,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IACtE,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,IAAuB,EAAE,OAAwB;QACrD,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,kBAAkB,EAAE,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IACrE,CAAC;IAED;;;;;OAKG;IACH,cAAc,CACZ,IAAgC,EAChC,OAAwB;QAExB,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,uBAAuB,EAAE,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IAC1E,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,IAAwB,EAAE,OAAwB;QACvD,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CACtB,iBAAiB,EACjB,2BAA2B,CAAC,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,CAChE,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,YAAY,CAAC,IAA8B,EAAE,OAAwB;QACnE,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,+BAA+B,EAAE,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IAClF,CAAC;IAED;;;OAGG;IACH,SAAS,CAAC,IAA2B,EAAE,OAAwB;QAC7D,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,4BAA4B,EAAE,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IAC/E,CAAC;IAED;;;OAGG;IACH,aAAa,CAAC,IAA+B,EAAE,OAAwB;QACrE,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,gCAAgC,EAAE,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IACnF,CAAC;CACF"}
+{"version":3,"file":"sources.mjs","sourceRoot":"","sources":["../src/resources/sources.ts"],"names":[],"mappings":"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"}

package/src/client.ts

@@ -59,7 +59,7 @@ export interface ClientOptions {
   /**
    * Override the default base URL for the API, e.g., "https://api.example.com/v2/"
    *
-   * Defaults to process.env['GRAPHOR_PRD_BASE_URL'].
+   * Defaults to process.env['GRAPHOR_BASE_URL'].
    */
   baseURL?: string | null | undefined;
 
@@ -113,7 +113,7 @@ export interface ClientOptions {
   /**
    * Set the log level.
    *
-   * Defaults to process.env['GRAPHOR_PRD_LOG'] or 'warn' if it isn't set.
+   * Defaults to process.env['GRAPHOR_LOG'] or 'warn' if it isn't set.
    */
   logLevel?: LogLevel | undefined;
 
@@ -126,9 +126,9 @@ export interface ClientOptions {
 }
 
 /**
- * API Client for interfacing with the Graphor Prd API.
+ * API Client for interfacing with the Graphor API.
  */
-export class GraphorPrd {
+export class Graphor {
   apiKey: string;
 
   baseURL: string;
@@ -144,10 +144,10 @@ export class GraphorPrd {
   private _options: ClientOptions;
 
   /**
-   * API Client for interfacing with the Graphor Prd API.
+   * API Client for interfacing with the Graphor API.
    *
    * @param {string | undefined} [opts.apiKey=process.env['GRAPHOR_API_KEY'] ?? undefined]
-   * @param {string} [opts.baseURL=process.env['GRAPHOR_PRD_BASE_URL'] ?? https://api.graphorlm.com/api/public/v1] - Override the default base URL for the API.
+   * @param {string} [opts.baseURL=process.env['GRAPHOR_BASE_URL'] ?? https://api.graphorlm.com/api/public/v1] - Override the default base URL for the API.
    * @param {number} [opts.timeout=10 minutes] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
    * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls.
    * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
@@ -156,13 +156,13 @@ export class GraphorPrd {
    * @param {Record<string, string | undefined>} opts.defaultQuery - Default query parameters to include with every request to the API.
    */
   constructor({
-    baseURL = readEnv('GRAPHOR_PRD_BASE_URL'),
+    baseURL = readEnv('GRAPHOR_BASE_URL'),
     apiKey = readEnv('GRAPHOR_API_KEY'),
     ...opts
   }: ClientOptions = {}) {
     if (apiKey === undefined) {
-      throw new Errors.GraphorPrdError(
-        "The GRAPHOR_API_KEY environment variable is missing or empty; either provide it, or instantiate the GraphorPrd client with an apiKey option, like new GraphorPrd({ apiKey: 'My API Key' }).",
+      throw new Errors.GraphorError(
+        "The GRAPHOR_API_KEY environment variable is missing or empty; either provide it, or instantiate the Graphor client with an apiKey option, like new Graphor({ apiKey: 'My API Key' }).",
       );
     }
 
@@ -173,14 +173,14 @@ export class GraphorPrd {
     };
 
     this.baseURL = options.baseURL!;
-    this.timeout = options.timeout ?? GraphorPrd.DEFAULT_TIMEOUT /* 10 minutes */;
+    this.timeout = options.timeout ?? Graphor.DEFAULT_TIMEOUT /* 10 minutes */;
     this.logger = options.logger ?? console;
     const defaultLogLevel = 'warn';
     // Set default logLevel early so that we can log a warning in parseLogLevel.
     this.logLevel = defaultLogLevel;
     this.logLevel =
       parseLogLevel(options.logLevel, 'ClientOptions.logLevel', this) ??
-      parseLogLevel(readEnv('GRAPHOR_PRD_LOG'), "process.env['GRAPHOR_PRD_LOG']", this) ??
+      parseLogLevel(readEnv('GRAPHOR_LOG'), "process.env['GRAPHOR_LOG']", this) ??
       defaultLogLevel;
     this.fetchOptions = options.fetchOptions;
     this.maxRetries = options.maxRetries ?? 0;
@@ -243,7 +243,7 @@ export class GraphorPrd {
         if (value === null) {
           return `${encodeURIComponent(key)}=`;
         }
-        throw new Errors.GraphorPrdError(
+        throw new Errors.GraphorError(
           `Cannot stringify type ${typeof value}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`,
         );
       })
@@ -722,10 +722,10 @@ export class GraphorPrd {
     }
   }
 
-  static GraphorPrd = this;
+  static Graphor = this;
   static DEFAULT_TIMEOUT = 600000; // 10 minutes
 
-  static GraphorPrdError = Errors.GraphorPrdError;
+  static GraphorError = Errors.GraphorError;
   static APIError = Errors.APIError;
   static APIConnectionError = Errors.APIConnectionError;
   static APIConnectionTimeoutError = Errors.APIConnectionTimeoutError;
@@ -744,9 +744,9 @@ export class GraphorPrd {
   sources: API.Sources = new API.Sources(this);
 }
 
-GraphorPrd.Sources = Sources;
+Graphor.Sources = Sources;
 
-export declare namespace GraphorPrd {
+export declare namespace Graphor {
   export type RequestOptions = Opts.RequestOptions;
 
   export {

package/src/core/api-promise.ts

@@ -1,6 +1,6 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { type GraphorPrd } from '../client';
+import { type Graphor } from '../client';
 
 import { type PromiseOrValue } from '../internal/types';
 import { APIResponseProps, defaultParseResponse } from '../internal/parse';
@@ -11,13 +11,13 @@ import { APIResponseProps, defaultParseResponse } from '../internal/parse';
  */
 export class APIPromise<T> extends Promise<T> {
   private parsedPromise: Promise<T> | undefined;
-  #client: GraphorPrd;
+  #client: Graphor;
 
   constructor(
-    client: GraphorPrd,
+    client: Graphor,
     private responsePromise: Promise<APIResponseProps>,
     private parseResponse: (
-      client: GraphorPrd,
+      client: Graphor,
       props: APIResponseProps,
     ) => PromiseOrValue<T> = defaultParseResponse,
   ) {

package/src/core/error.ts

@@ -2,13 +2,13 @@
 
 import { castToError } from '../internal/errors';
 
-export class GraphorPrdError extends Error {}
+export class GraphorError extends Error {}
 
 export class APIError<
   TStatus extends number | undefined = number | undefined,
   THeaders extends Headers | undefined = Headers | undefined,
   TError extends Object | undefined = Object | undefined,
-> extends GraphorPrdError {
+> extends GraphorError {
   /** HTTP status for the response that caused the error */
   readonly status: TStatus;
   /** HTTP headers for the response that caused the error */

package/src/core/resource.ts

@@ -1,11 +1,11 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import type { GraphorPrd } from '../client';
+import type { Graphor } from '../client';
 
 export abstract class APIResource {
-  protected _client: GraphorPrd;
+  protected _client: Graphor;
 
-  constructor(client: GraphorPrd) {
+  constructor(client: Graphor) {
     this._client = client;
   }
 }

package/src/index.ts

@@ -1,12 +1,12 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-export { GraphorPrd as default } from './client';
+export { Graphor as default } from './client';
 
 export { type Uploadable, toFile } from './core/uploads';
 export { APIPromise } from './core/api-promise';
-export { GraphorPrd, type ClientOptions } from './client';
+export { Graphor, type ClientOptions } from './client';
 export {
-  GraphorPrdError,
+  GraphorError,
   APIError,
   APIConnectionError,
   APIConnectionTimeoutError,

package/src/internal/parse.ts

@@ -1,7 +1,7 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import type { FinalRequestOptions } from './request-options';
-import { type GraphorPrd } from '../client';
+import { type Graphor } from '../client';
 import { formatRequestDetails, loggerFor } from './utils/log';
 
 export type APIResponseProps = {
@@ -13,7 +13,7 @@ export type APIResponseProps = {
   startTime: number;
 };
 
-export async function defaultParseResponse<T>(client: GraphorPrd, props: APIResponseProps): Promise<T> {
+export async function defaultParseResponse<T>(client: Graphor, props: APIResponseProps): Promise<T> {
   const { response, requestLogID, retryOfRequestLogID, startTime } = props;
   const body = await (async () => {
     // fetch refuses to read the body when the status code is 204.

package/src/internal/shims.ts

@@ -16,7 +16,7 @@ export function getDefaultFetch(): Fetch {
   }
 
   throw new Error(
-    '`fetch` is not defined as a global; Either pass `fetch` to the client, `new GraphorPrd({ fetch })` or polyfill the global, `globalThis.fetch = fetch`',
+    '`fetch` is not defined as a global; Either pass `fetch` to the client, `new Graphor({ fetch })` or polyfill the global, `globalThis.fetch = fetch`',
   );
 }