notdiamond 2.0.0-rc1 → 2.0.0-rc11

package/src/internal/uploads.ts

@@ -1,6 +1,6 @@
 import { type RequestOptions } from './request-options';
 import type { FilePropertyBag, Fetch } from './builtin-types';
-import type { NotDiamond } from '../client';
+import type { Notdiamond } from '../client';
 import { ReadableStreamFrom } from './shims';
 
 export type BlobPart = string | ArrayBuffer | ArrayBufferView | Blob | DataView;
@@ -74,7 +74,7 @@ export const isAsyncIterable = (value: any): value is AsyncIterable<any> =>
  */
 export const maybeMultipartFormRequestOptions = async (
   opts: RequestOptions,
-  fetch: NotDiamond | Fetch,
+  fetch: Notdiamond | Fetch,
 ): Promise<RequestOptions> => {
   if (!hasUploadableValue(opts.body)) return opts;
 
@@ -85,7 +85,7 @@ type MultipartFormRequestOptions = Omit<RequestOptions, 'body'> & { body: unknow
 
 export const multipartFormRequestOptions = async (
   opts: MultipartFormRequestOptions,
-  fetch: NotDiamond | Fetch,
+  fetch: Notdiamond | Fetch,
 ): Promise<RequestOptions> => {
   return { ...opts, body: await createForm(opts.body, fetch) };
 };
@@ -98,7 +98,7 @@ const supportsFormDataMap = /* @__PURE__ */ new WeakMap<Fetch, Promise<boolean>>
  * This function detects if the fetch function provided supports the global FormData object to avoid
  * confusing error messages later on.
  */
-function supportsFormData(fetchObject: NotDiamond | Fetch): Promise<boolean> {
+function supportsFormData(fetchObject: Notdiamond | Fetch): Promise<boolean> {
   const fetch: Fetch = typeof fetchObject === 'function' ? fetchObject : (fetchObject as any).fetch;
   const cached = supportsFormDataMap.get(fetch);
   if (cached) return cached;
@@ -124,7 +124,7 @@ function supportsFormData(fetchObject: NotDiamond | Fetch): Promise<boolean> {
 
 export const createForm = async <T = Record<string, unknown>>(
   body: T | undefined,
-  fetch: NotDiamond | Fetch,
+  fetch: Notdiamond | Fetch,
 ): Promise<FormData> => {
   if (!(await supportsFormData(fetch))) {
     throw new TypeError(

package/src/internal/utils/base64.ts

@@ -1,6 +1,6 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { NotDiamondError } from '../../core/error';
+import { NotdiamondError } from '../../core/error';
 import { encodeUTF8 } from './bytes';
 
 export const toBase64 = (data: string | Uint8Array | null | undefined): string => {
@@ -18,7 +18,7 @@ export const toBase64 = (data: string | Uint8Array | null | undefined): string =
     return btoa(String.fromCharCode.apply(null, data as any));
   }
 
-  throw new NotDiamondError('Cannot generate base64 string; Expected `Buffer` or `btoa` to be defined');
+  throw new NotdiamondError('Cannot generate base64 string; Expected `Buffer` or `btoa` to be defined');
 };
 
 export const fromBase64 = (str: string): Uint8Array => {
@@ -36,5 +36,5 @@ export const fromBase64 = (str: string): Uint8Array => {
     return buf;
   }
 
-  throw new NotDiamondError('Cannot decode base64 string; Expected `Buffer` or `atob` to be defined');
+  throw new NotdiamondError('Cannot decode base64 string; Expected `Buffer` or `atob` to be defined');
 };

package/src/internal/utils/env.ts

@@ -9,10 +9,12 @@
  */
 export const readEnv = (env: string): string | undefined => {
   if (typeof (globalThis as any).process !== 'undefined') {
-    return (globalThis as any).process.env?.[env]?.trim() ?? undefined;
+    const value = (globalThis as any).process.env?.[env]?.trim() ?? undefined;
+    return value === '' ? undefined : value;
   }
   if (typeof (globalThis as any).Deno !== 'undefined') {
-    return (globalThis as any).Deno.env?.get?.(env)?.trim();
+    const value = (globalThis as any).Deno.env?.get?.(env)?.trim();
+    return value === '' ? undefined : value;
   }
   return undefined;
 };

package/src/internal/utils/log.ts

@@ -1,7 +1,7 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { hasOwn } from './values';
-import { type NotDiamond } from '../../client';
+import { type Notdiamond } from '../../client';
 import { RequestOptions } from '../request-options';
 
 type LogFn = (message: string, ...rest: unknown[]) => void;
@@ -24,7 +24,7 @@ const levelNumbers = {
 export const parseLogLevel = (
   maybeLevel: string | undefined,
   sourceName: string,
-  client: NotDiamond,
+  client: Notdiamond,
 ): LogLevel | undefined => {
   if (!maybeLevel) {
     return undefined;
@@ -60,7 +60,7 @@ const noopLogger = {
 
 let cachedLoggers = /* @__PURE__ */ new WeakMap<Logger, [LogLevel, Logger]>();
 
-export function loggerFor(client: NotDiamond): Logger {
+export function loggerFor(client: Notdiamond): Logger {
   const logger = client.logger;
   const logLevel = client.logLevel ?? 'off';
   if (!logger) {

package/src/internal/utils/path.ts

@@ -1,4 +1,4 @@
-import { NotDiamondError } from '../../core/error';
+import { NotdiamondError } from '../../core/error';
 
 /**
  * Percent-encode everything that isn't safe to have in a path without encoding safe chars.
@@ -72,7 +72,7 @@ export const createPathTagFunction = (pathEncoder = encodeURIPath) =>
         return acc + spaces + arrows;
       }, '');
 
-      throw new NotDiamondError(
+      throw new NotdiamondError(
         `Path parameters result in path with invalid segments:\n${invalidSegments
           .map((e) => e.error)
           .join('\n')}\n${path}\n${underline}`,

package/src/internal/utils/values.ts

@@ -1,6 +1,6 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { NotDiamondError } from '../../core/error';
+import { NotdiamondError } from '../../core/error';
 
 // https://url.spec.whatwg.org/#url-scheme-string
 const startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i;
@@ -39,7 +39,7 @@ export function isObj(obj: unknown): obj is Record<string, unknown> {
 
 export const ensurePresent = <T>(value: T | null | undefined): T => {
   if (value == null) {
-    throw new NotDiamondError(`Expected a value to be given but received ${value} instead.`);
+    throw new NotdiamondError(`Expected a value to be given but received ${value} instead.`);
   }
 
   return value;
@@ -47,10 +47,10 @@ export const ensurePresent = <T>(value: T | null | undefined): T => {
 
 export const validatePositiveInteger = (name: string, n: unknown): number => {
   if (typeof n !== 'number' || !Number.isInteger(n)) {
-    throw new NotDiamondError(`${name} must be an integer`);
+    throw new NotdiamondError(`${name} must be an integer`);
   }
   if (n < 0) {
-    throw new NotDiamondError(`${name} must be a positive integer`);
+    throw new NotdiamondError(`${name} must be a positive integer`);
   }
   return n;
 };
@@ -59,14 +59,14 @@ export const coerceInteger = (value: unknown): number => {
   if (typeof value === 'number') return Math.round(value);
   if (typeof value === 'string') return parseInt(value, 10);
 
-  throw new NotDiamondError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+  throw new NotdiamondError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
 };
 
 export const coerceFloat = (value: unknown): number => {
   if (typeof value === 'number') return value;
   if (typeof value === 'string') return parseFloat(value);
 
-  throw new NotDiamondError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+  throw new NotdiamondError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
 };
 
 export const coerceBoolean = (value: unknown): boolean => {

package/src/resources/custom-router.ts

@@ -0,0 +1,168 @@
+// 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 { type Uploadable } from '../core/uploads';
+import { RequestOptions } from '../internal/request-options';
+import { multipartFormRequestOptions } from '../internal/uploads';
+
+export class CustomRouter extends APIResource {
+  /**
+   * Train a custom router on your evaluation data to optimize routing for your
+   * specific use case.
+   *
+   * This endpoint allows you to train a domain-specific router that learns which
+   * models perform best for different types of queries in your application. The
+   * router analyzes your evaluation dataset, clusters similar queries, and learns
+   * model performance patterns.
+   *
+   * **Training Process:**
+   *
+   * 1. Upload a CSV file with your evaluation data
+   * 2. Specify which models to route between
+   * 3. Define the evaluation metric (score column)
+   * 4. The system trains asynchronously and returns a preference_id
+   * 5. Use the preference_id in model_select() calls once training completes
+   *
+   * **Dataset Requirements:**
+   *
+   * - Format: CSV file
+   * - Minimum samples: 25 (more is better for accuracy)
+   * - Required columns:
+   *   - Prompt column (specified in prompt_column parameter)
+   *   - For each model: `{provider}/{model}/score` and `{provider}/{model}/response`
+   *
+   * **Example CSV structure:**
+   *
+   * ```
+   * prompt,openai/gpt-4o/score,openai/gpt-4o/response,anthropic/claude-sonnet-4-5-20250929/score,anthropic/claude-sonnet-4-5-20250929/response
+   * "Explain quantum computing",0.95,"Quantum computing uses...",0.87,"Quantum computers leverage..."
+   * "Write a Python function",0.82,"def my_function()...",0.91,"Here's a Python function..."
+   * ```
+   *
+   * **Model Selection:**
+   *
+   * - Specify standard models: `{"provider": "openai", "model": "gpt-4o"}`
+   * - Or custom models with pricing:
+   *   `{"provider": "custom", "model": "my-model", "is_custom": true, "input_price": 10.0, "output_price": 30.0, "context_length": 8192, "latency": 1.5}`
+   *
+   * **Training Time:**
+   *
+   * - Training is asynchronous and typically takes 5-15 minutes
+   * - Larger datasets or more models take longer
+   * - You'll receive a preference_id immediately
+   * - Check training status by attempting to use the preference_id in model_select()
+   *
+   * **Best Practices:**
+   *
+   * 1. Use diverse, representative examples from your production workload
+   * 2. Include at least 50-100 samples for best results
+   * 3. Ensure consistent evaluation metrics across all models
+   * 4. Use the same models you plan to route between in production
+   *
+   * **Related Documentation:** See
+   * https://docs.notdiamond.ai/docs/adapting-prompts-to-new-models for detailed
+   * guide.
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.customRouter.trainCustomRouter({
+   *     dataset_file: fs.createReadStream('path/to/file'),
+   *     language: 'english',
+   *     llm_providers:
+   *       '[{"provider": "openai", "model": "gpt-4o"}, {"provider": "anthropic", "model": "claude-sonnet-4-5-20250929"}]',
+   *     maximize: true,
+   *     prompt_column: 'prompt',
+   *   });
+   * ```
+   */
+  trainCustomRouter(
+    body: CustomRouterTrainCustomRouterParams,
+    options?: RequestOptions,
+  ): APIPromise<CustomRouterTrainCustomRouterResponse> {
+    return this._client.post(
+      '/v2/pzn/trainCustomRouter',
+      multipartFormRequestOptions({ body, ...options }, this._client),
+    );
+  }
+}
+
+/**
+ * Response model for POST /v2/pzn/trainCustomRouter endpoint.
+ *
+ * Returned immediately after submitting a custom router training request. The
+ * training process runs asynchronously (typically 5-15 minutes), so use the
+ * returned preference_id to make routing calls once training completes.
+ *
+ * **Next steps:**
+ *
+ * 1. Store the preference_id
+ * 2. Wait for training to complete (typically 5-15 minutes)
+ * 3. Use this preference_id in POST /v2/modelRouter/modelSelect requests
+ * 4. The router will use your custom-trained model to make routing decisions
+ *
+ * **How to use the preference_id:**
+ *
+ * - Include it in the 'preference_id' field of model_select() calls
+ * - The system automatically uses your custom router once training is complete
+ * - No need to poll status - you can start using it immediately (will use default
+ *   until ready)
+ */
+export interface CustomRouterTrainCustomRouterResponse {
+  /**
+   * Unique identifier for the custom router. Use this in model_select() calls to
+   * enable routing with your custom-trained router
+   */
+  preference_id: string;
+}
+
+export interface CustomRouterTrainCustomRouterParams {
+  /**
+   * CSV file containing evaluation data with prompt column and score/response
+   * columns for each model
+   */
+  dataset_file: Uploadable;
+
+  /**
+   * Language of the evaluation data. Use 'english' for English-only data or
+   * 'multilingual' for multi-language support
+   */
+  language: string;
+
+  /**
+   * JSON string array of LLM providers to train the router on. Format:
+   * '[{"provider": "openai", "model": "gpt-4o"}, {"provider": "anthropic", "model":
+   * "claude-sonnet-4-5-20250929"}]'
+   */
+  llm_providers: string;
+
+  /**
+   * Whether higher scores are better. Set to true if higher scores indicate better
+   * performance, false otherwise
+   */
+  maximize: boolean;
+
+  /**
+   * Name of the column in the CSV file that contains the prompts
+   */
+  prompt_column: string;
+
+  /**
+   * Whether to override an existing custom router for this preference_id
+   */
+  override?: boolean | null;
+
+  /**
+   * Optional preference ID to update an existing router. If not provided, a new
+   * preference will be created
+   */
+  preference_id?: string | null;
+}
+
+export declare namespace CustomRouter {
+  export {
+    type CustomRouterTrainCustomRouterResponse as CustomRouterTrainCustomRouterResponse,
+    type CustomRouterTrainCustomRouterParams as CustomRouterTrainCustomRouterParams,
+  };
+}

package/src/resources/index.ts

@@ -1,44 +1,33 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-export { Admin } from './admin';
-export { Models, type ModelListResponse, type ModelListParams } from './models';
+export {
+  CustomRouter,
+  type CustomRouterTrainCustomRouterResponse,
+  type CustomRouterTrainCustomRouterParams,
+} from './custom-router';
+export {
+  ModelRouter,
+  type ModelRouterSelectModelResponse,
+  type ModelRouterSelectModelParams,
+} from './model-router';
+export { Models, type Model, type ModelListResponse, type ModelListParams } from './models';
 export {
   Preferences,
-  type PreferenceRetrieveResponse,
-  type PreferenceCreateUserPreferenceResponse,
-  type PreferenceDeleteUserPreferenceResponse,
-  type PreferenceUpdateUserPreferenceResponse,
-  type PreferenceRetrieveParams,
-  type PreferenceCreateUserPreferenceParams,
-  type PreferenceUpdateUserPreferenceParams,
+  type PreferenceCreateResponse,
+  type PreferenceUpdateResponse,
+  type PreferenceDeleteResponse,
+  type PreferenceCreateParams,
+  type PreferenceUpdateParams,
 } from './preferences';
 export {
   PromptAdaptation,
-  type AdaptationRunResults,
+  type GoldenRecord,
   type JobStatus,
-  type PromptAdaptationAdaptResponse,
-  type PromptAdaptationGetAdaptRunsResponse,
+  type RequestProvider,
+  type PromptAdaptationCreateResponse,
+  type PromptAdaptationGetAdaptResultsResponse,
   type PromptAdaptationGetAdaptStatusResponse,
-  type PromptAdaptationRetrieveCostsResponse,
-  type PromptAdaptationAdaptParams,
-  type PromptAdaptationGetAdaptRunResultsParams,
-  type PromptAdaptationGetAdaptRunsParams,
+  type PromptAdaptationGetCostsResponse,
+  type PromptAdaptationCreateParams,
 } from './prompt-adaptation';
-export {
-  Report,
-  type ReportEvaluateHallucinationResponse,
-  type ReportLatencyResponse,
-  type ReportSubmitFeedbackResponse,
-  type ReportEvaluateHallucinationParams,
-  type ReportLatencyParams,
-  type ReportSubmitFeedbackParams,
-} from './report';
-export {
-  Routing,
-  type RoutingCreateSurveyResponseResponse,
-  type RoutingSelectModelResponse,
-  type RoutingTrainCustomRouterResponse,
-  type RoutingCreateSurveyResponseParams,
-  type RoutingSelectModelParams,
-  type RoutingTrainCustomRouterParams,
-} from './routing';
+export { Report } from './report/report';

package/src/resources/model-router.ts

@@ -0,0 +1,224 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import * as PromptAdaptationAPI from './prompt-adaptation';
+import { APIPromise } from '../core/api-promise';
+import { RequestOptions } from '../internal/request-options';
+
+export class ModelRouter extends APIResource {
+  /**
+   * Select the optimal LLM to handle your query based on Not Diamond's routing
+   * algorithm.
+   *
+   * This endpoint analyzes your messages and returns the best-suited model from your
+   * specified providers. The router considers factors like query complexity, model
+   * capabilities, cost, and latency based on your preferences.
+   *
+   * **Key Features:**
+   *
+   * - Intelligent routing across multiple LLM providers
+   * - Support for custom routers trained on your evaluation data
+   * - Optional cost/latency optimization
+   * - Function calling support for compatible models
+   * - Privacy-preserving content hashing
+   *
+   * **Usage:**
+   *
+   * 1. Pass your messages in OpenAI format (array of objects with 'role' and
+   *    'content')
+   * 2. Specify which LLM providers you want to route between
+   * 3. Optionally provide a preference_id for personalized routing
+   * 4. Receive a recommended model and session_id
+   * 5. Use the session_id to submit feedback and improve routing
+   *
+   * **Related Endpoints:**
+   *
+   * - `POST /v2/preferences/userPreferenceCreate` - Create a preference ID for
+   *   personalized routing
+   * - `POST /v2/report/metrics/feedback` - Submit feedback on routing decisions
+   * - `POST /v2/pzn/trainCustomRouter` - Train a custom router on your evaluation
+   *   data
+   *
+   * @example
+   * ```ts
+   * const response = await client.modelRouter.selectModel({
+   *   llm_providers: [
+   *     { provider: 'openai', model: 'gpt-4o' },
+   *     {
+   *       provider: 'anthropic',
+   *       model: 'claude-sonnet-4-5-20250929',
+   *     },
+   *     { provider: 'google', model: 'gemini-2.5-flash' },
+   *   ],
+   *   messages: [
+   *     {
+   *       role: 'system',
+   *       content: 'You are a helpful assistant.',
+   *     },
+   *     {
+   *       role: 'user',
+   *       content: 'Explain quantum computing in simple terms',
+   *     },
+   *   ],
+   * });
+   * ```
+   */
+  selectModel(
+    params: ModelRouterSelectModelParams,
+    options?: RequestOptions,
+  ): APIPromise<ModelRouterSelectModelResponse> {
+    const { type, ...body } = params;
+    return this._client.post('/v2/modelRouter/modelSelect', { query: { type }, body, ...options });
+  }
+}
+
+/**
+ * Response from model selection endpoint.
+ */
+export interface ModelRouterSelectModelResponse {
+  /**
+   * List containing the selected provider
+   */
+  providers: Array<ModelRouterSelectModelResponse.Provider>;
+
+  /**
+   * Unique session ID for this routing decision
+   */
+  session_id: string;
+}
+
+export namespace ModelRouterSelectModelResponse {
+  /**
+   * Selected LLM provider information from model selection endpoints.
+   *
+   * Part of ModelSelectResponse. Contains the provider and model that Not Diamond's
+   * routing algorithm selected as optimal for your query. Use these values to make
+   * your LLM API call to the recommended model.
+   */
+  export interface Provider {
+    /**
+     * Model identifier for the selected model (e.g., 'gpt-4o',
+     * 'claude-3-opus-20240229')
+     */
+    model: string;
+
+    /**
+     * Provider name for the selected model (e.g., 'openai', 'anthropic', 'google')
+     */
+    provider: string;
+  }
+}
+
+export interface ModelRouterSelectModelParams {
+  /**
+   * Body param: List of LLM providers to route between. Specify at least one
+   * provider in format {provider, model}
+   */
+  llm_providers: Array<PromptAdaptationAPI.RequestProvider | ModelRouterSelectModelParams.OpenRouterProvider>;
+
+  /**
+   * Body param: Array of message objects in OpenAI format (with 'role' and 'content'
+   * keys)
+   */
+  messages: Array<{ [key: string]: string | Array<unknown> }> | string;
+
+  /**
+   * Query param: Optional format type. Use 'openrouter' to accept and return
+   * OpenRouter-format model identifiers
+   */
+  type?: string | null;
+
+  /**
+   * Body param: Whether to hash message content for privacy
+   */
+  hash_content?: boolean;
+
+  /**
+   * Body param: Maximum number of models to consider for routing. If not specified,
+   * considers all provided models
+   */
+  max_model_depth?: number | null;
+
+  /**
+   * Body param: Optimization metric for model selection
+   */
+  metric?: string;
+
+  /**
+   * Body param: Preference ID for personalized routing. Create one via POST
+   * /v2/preferences/userPreferenceCreate
+   */
+  preference_id?: string | null;
+
+  /**
+   * Body param: Previous session ID to link related requests
+   */
+  previous_session?: string | null;
+
+  /**
+   * Body param: OpenAI-format function calling tools
+   */
+  tools?: Array<{ [key: string]: unknown }> | null;
+
+  /**
+   * Body param: Optimization tradeoff strategy. Use 'cost' to prioritize cost
+   * savings or 'latency' to prioritize speed
+   */
+  tradeoff?: string | null;
+}
+
+export namespace ModelRouterSelectModelParams {
+  /**
+   * Model for specifying an LLM provider using OpenRouter format.
+   *
+   * Used in model routing requests when you want to specify providers using the
+   * OpenRouter naming convention (combined 'provider/model' format). This is an
+   * alternative to the standard RequestProvider which uses separate provider and
+   * model fields.
+   *
+   * **When to use:**
+   *
+   * - When working with OpenRouter-compatible systems
+   * - When you prefer the unified 'provider/model' format
+   * - For models accessed via OpenRouter proxy
+   */
+  export interface OpenRouterProvider {
+    /**
+     * OpenRouter model identifier in 'provider/model' format (e.g., 'openai/gpt-4o',
+     * 'anthropic/claude-sonnet-4-5-20250929')
+     */
+    model: string;
+
+    /**
+     * Maximum context length for the model (required for custom models)
+     */
+    context_length?: number | null;
+
+    /**
+     * Input token price per million tokens in USD (required for custom models)
+     */
+    input_price?: number | null;
+
+    /**
+     * Whether this is a custom model not in Not Diamond's supported model list
+     */
+    is_custom?: boolean;
+
+    /**
+     * Average latency in seconds (required for custom models)
+     */
+    latency?: number | null;
+
+    /**
+     * Output token price per million tokens in USD (required for custom models)
+     */
+    output_price?: number | null;
+  }
+}
+
+export declare namespace ModelRouter {
+  export {
+    type ModelRouterSelectModelResponse as ModelRouterSelectModelResponse,
+    type ModelRouterSelectModelParams as ModelRouterSelectModelParams,
+  };
+}