notdiamond
Version:
The official TypeScript library for the Notdiamond API
194 lines • 6.83 kB
text/typescript
import { APIResource } from "../core/resource.mjs";
import * as PromptOptimizationAPI from "./prompt-optimization.mjs";
import { APIPromise } from "../core/api-promise.mjs";
import { RequestOptions } from "../internal/request-options.mjs";
export declare 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 models. 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
*
* **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 to use a custom router that you've trained
* 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/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>;
}
/**
* 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 declare 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.
*/
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<PromptOptimizationAPI.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 declare 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
*/
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, };
}
//# sourceMappingURL=model-router.d.mts.map