notdiamond 1.1.3 → 2.0.0-rc1

package/src/internal/utils/values.ts

@@ -0,0 +1,105 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { NotDiamondError } from '../../core/error';
+
+// https://url.spec.whatwg.org/#url-scheme-string
+const startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i;
+
+export const isAbsoluteURL = (url: string): boolean => {
+  return startsWithSchemeRegexp.test(url);
+};
+
+export let isArray = (val: unknown): val is unknown[] => ((isArray = Array.isArray), isArray(val));
+export let isReadonlyArray = isArray as (val: unknown) => val is readonly unknown[];
+
+/** Returns an object if the given value isn't an object, otherwise returns as-is */
+export function maybeObj(x: unknown): object {
+  if (typeof x !== 'object') {
+    return {};
+  }
+
+  return x ?? {};
+}
+
+// https://stackoverflow.com/a/34491287
+export function isEmptyObj(obj: Object | null | undefined): boolean {
+  if (!obj) return true;
+  for (const _k in obj) return false;
+  return true;
+}
+
+// https://eslint.org/docs/latest/rules/no-prototype-builtins
+export function hasOwn<T extends object = object>(obj: T, key: PropertyKey): key is keyof T {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+export function isObj(obj: unknown): obj is Record<string, unknown> {
+  return obj != null && typeof obj === 'object' && !Array.isArray(obj);
+}
+
+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.`);
+  }
+
+  return value;
+};
+
+export const validatePositiveInteger = (name: string, n: unknown): number => {
+  if (typeof n !== 'number' || !Number.isInteger(n)) {
+    throw new NotDiamondError(`${name} must be an integer`);
+  }
+  if (n < 0) {
+    throw new NotDiamondError(`${name} must be a positive integer`);
+  }
+  return n;
+};
+
+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`);
+};
+
+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`);
+};
+
+export const coerceBoolean = (value: unknown): boolean => {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'string') return value === 'true';
+  return Boolean(value);
+};
+
+export const maybeCoerceInteger = (value: unknown): number | undefined => {
+  if (value == null) {
+    return undefined;
+  }
+  return coerceInteger(value);
+};
+
+export const maybeCoerceFloat = (value: unknown): number | undefined => {
+  if (value == null) {
+    return undefined;
+  }
+  return coerceFloat(value);
+};
+
+export const maybeCoerceBoolean = (value: unknown): boolean | undefined => {
+  if (value == null) {
+    return undefined;
+  }
+  return coerceBoolean(value);
+};
+
+export const safeJSON = (text: string) => {
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    return undefined;
+  }
+};

package/src/internal/utils.ts

@@ -0,0 +1,8 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './utils/values';
+export * from './utils/base64';
+export * from './utils/env';
+export * from './utils/log';
+export * from './utils/uuid';
+export * from './utils/sleep';

package/src/lib/.keep

@@ -0,0 +1,4 @@
+File generated from our OpenAPI spec by Stainless.
+
+This directory can be used to store custom files to expand the SDK.
+It is ignored by Stainless code generation and its content (other than this keep file) won't be touched.

package/src/resource.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/resource instead */
+export * from './core/resource';

package/src/resources/admin.ts

@@ -0,0 +1,5 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+
+export class Admin extends APIResource {}

package/src/resources/index.ts

@@ -0,0 +1,44 @@
+// 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 {
+  Preferences,
+  type PreferenceRetrieveResponse,
+  type PreferenceCreateUserPreferenceResponse,
+  type PreferenceDeleteUserPreferenceResponse,
+  type PreferenceUpdateUserPreferenceResponse,
+  type PreferenceRetrieveParams,
+  type PreferenceCreateUserPreferenceParams,
+  type PreferenceUpdateUserPreferenceParams,
+} from './preferences';
+export {
+  PromptAdaptation,
+  type AdaptationRunResults,
+  type JobStatus,
+  type PromptAdaptationAdaptResponse,
+  type PromptAdaptationGetAdaptRunsResponse,
+  type PromptAdaptationGetAdaptStatusResponse,
+  type PromptAdaptationRetrieveCostsResponse,
+  type PromptAdaptationAdaptParams,
+  type PromptAdaptationGetAdaptRunResultsParams,
+  type PromptAdaptationGetAdaptRunsParams,
+} 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';

package/src/resources/models.ts

@@ -0,0 +1,110 @@
+// 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 { RequestOptions } from '../internal/request-options';
+
+export class Models extends APIResource {
+  /**
+   * List all supported text generation models with optional filtering.
+   *
+   * including pricing, context length, latency, and OpenRouter availability.
+   *
+   * **Note:** Image generation models are excluded from this endpoint.
+   *
+   * **Examples:**
+   *
+   * - Get all models: `/v2/models`
+   * - OpenRouter only: `/v2/models?openrouter_only=true`
+   * - Specific provider: `/v2/models?provider=openai`
+   * - Multiple providers: `/v2/models?provider=openai&provider=anthropic`
+   *
+   * **Query Parameters:**
+   *
+   * - **provider**: Filter by provider name(s). Can specify multiple times for
+   *   multiple providers (e.g., `?provider=openai&provider=anthropic`)
+   * - **openrouter_only**: Return only models that have OpenRouter support (default:
+   *   false)
+   *
+   * **Returns:**
+   *
+   * - **models**: List of active text generation model objects with metadata
+   * - **total**: Total number of active models returned
+   * - **deprecated_models**: List of deprecated text generation model objects with
+   *   metadata (respects the same filters as active models)
+   *
+   * **Caching:**
+   *
+   * - Response is cacheable for 1 hour (model list rarely changes)
+   */
+  list(
+    query: ModelListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<ModelListResponse> {
+    return this._client.get('/v2/models', { query, ...options });
+  }
+}
+
+/**
+ * Response for models list endpoint.
+ */
+export interface ModelListResponse {
+  deprecated_models: Array<ModelListResponse.DeprecatedModel>;
+
+  models: Array<ModelListResponse.Model>;
+
+  total: number;
+}
+
+export namespace ModelListResponse {
+  /**
+   * Response model for a single LLM provider.
+   */
+  export interface DeprecatedModel {
+    context_length: number;
+
+    input_price: number;
+
+    model: string;
+
+    output_price: number;
+
+    provider: string;
+
+    openrouter_model?: string | null;
+  }
+
+  /**
+   * Response model for a single LLM provider.
+   */
+  export interface Model {
+    context_length: number;
+
+    input_price: number;
+
+    model: string;
+
+    output_price: number;
+
+    provider: string;
+
+    openrouter_model?: string | null;
+  }
+}
+
+export interface ModelListParams {
+  /**
+   * Return only OpenRouter-supported models
+   */
+  openrouter_only?: boolean;
+
+  /**
+   * Filter by provider name(s). Can specify multiple providers (e.g., 'openai',
+   * 'anthropic')
+   */
+  provider?: Array<string> | null;
+}
+
+export declare namespace Models {
+  export { type ModelListResponse as ModelListResponse, type ModelListParams as ModelListParams };
+}

package/src/resources/preferences.ts

@@ -0,0 +1,158 @@
+// 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 { buildHeaders } from '../internal/headers';
+import { RequestOptions } from '../internal/request-options';
+import { path } from '../internal/utils/path';
+
+export class Preferences extends APIResource {
+  /**
+   * Get User Preference By Id
+   *
+   * @example
+   * ```ts
+   * const preference = await client.preferences.retrieve(
+   *   'preference_id',
+   *   { user_id: 'user_id', 'x-token': 'x-token' },
+   * );
+   * ```
+   */
+  retrieve(
+    preferenceID: string,
+    params: PreferenceRetrieveParams,
+    options?: RequestOptions,
+  ): APIPromise<unknown> {
+    const { user_id, 'x-token': xToken } = params;
+    return this._client.get(path`/v2/preferences/${user_id}/${preferenceID}`, {
+      ...options,
+      headers: buildHeaders([{ 'x-token': xToken }, options?.headers]),
+    });
+  }
+
+  /**
+   * Create a new preference ID for personalized LLM routing.
+   *
+   * A preference ID enables personalized routing by tracking your feedback and
+   * learning your preferences over time. Once created, you can:
+   *
+   * 1. Use it in model_select() calls to get personalized routing decisions
+   * 2. Submit feedback via the feedback endpoint to improve routing quality
+   * 3. Train a custom router specific to your use case
+   *
+   * **Workflow:**
+   *
+   * 1. Create a preference ID (this endpoint)
+   * 2. Use the preference_id in POST /v2/modelRouter/modelSelect requests
+   * 3. Submit feedback on routing decisions via POST /v2/report/metrics/feedback
+   * 4. Optionally train a custom router via POST /v2/pzn/trainCustomRouter
+   *
+   * **Benefits:**
+   *
+   * - Personalized routing that learns from your feedback
+   * - Improved accuracy for your specific use case
+   * - Ability to train custom routers on your evaluation data
+   *
+   * **Note:** If you don't provide a preference_id in model_select() calls, the
+   * default router will be used.
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.preferences.createUserPreference();
+   * ```
+   */
+  createUserPreference(
+    body: PreferenceCreateUserPreferenceParams,
+    options?: RequestOptions,
+  ): APIPromise<PreferenceCreateUserPreferenceResponse> {
+    return this._client.post('/v2/preferences/userPreferenceCreate', { body, ...options });
+  }
+
+  /**
+   * Delete User Preference
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.preferences.deleteUserPreference(
+   *     'preference_id',
+   *   );
+   * ```
+   */
+  deleteUserPreference(preferenceID: string, options?: RequestOptions): APIPromise<unknown> {
+    return this._client.delete(path`/v2/preferences/userPreferenceDelete/${preferenceID}`, options);
+  }
+
+  /**
+   * Update User Preference
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.preferences.updateUserPreference({
+   *     preference_id: 'preference_id',
+   *   });
+   * ```
+   */
+  updateUserPreference(
+    body: PreferenceUpdateUserPreferenceParams,
+    options?: RequestOptions,
+  ): APIPromise<unknown> {
+    return this._client.put('/v2/preferences/userPreferenceUpdate', { body, ...options });
+  }
+}
+
+export type PreferenceRetrieveResponse = unknown;
+
+/**
+ * Response from preference creation endpoint.
+ */
+export interface PreferenceCreateUserPreferenceResponse {
+  /**
+   * The newly created preference ID. Use this in model_select() calls for
+   * personalized routing
+   */
+  preference_id: string;
+}
+
+export type PreferenceDeleteUserPreferenceResponse = unknown;
+
+export type PreferenceUpdateUserPreferenceResponse = unknown;
+
+export interface PreferenceRetrieveParams {
+  /**
+   * Path param:
+   */
+  user_id: string;
+
+  /**
+   * Header param:
+   */
+  'x-token': string;
+}
+
+export interface PreferenceCreateUserPreferenceParams {
+  /**
+   * Optional name for the preference
+   */
+  name?: string | null;
+}
+
+export interface PreferenceUpdateUserPreferenceParams {
+  preference_id: string;
+
+  name?: string | null;
+}
+
+export declare namespace Preferences {
+  export {
+    type PreferenceRetrieveResponse as PreferenceRetrieveResponse,
+    type PreferenceCreateUserPreferenceResponse as PreferenceCreateUserPreferenceResponse,
+    type PreferenceDeleteUserPreferenceResponse as PreferenceDeleteUserPreferenceResponse,
+    type PreferenceUpdateUserPreferenceResponse as PreferenceUpdateUserPreferenceResponse,
+    type PreferenceRetrieveParams as PreferenceRetrieveParams,
+    type PreferenceCreateUserPreferenceParams as PreferenceCreateUserPreferenceParams,
+    type PreferenceUpdateUserPreferenceParams as PreferenceUpdateUserPreferenceParams,
+  };
+}