@dereekb/openrouter 14.7.0 → 14.8.0

package/src/lib/openrouter.decision.question.d.ts

@@ -0,0 +1,392 @@
+import { type Maybe } from '@dereekb/util';
+import { type OpenRouterModelConfigValidation } from './openrouter.config';
+/**
+ * Identifier a caller gives one question inside a decision.
+ *
+ * The id is NEVER sent to the model — it is only how the caller addresses the matching answer — so a
+ * self-explanatory key is no substitute for writing the complete question in `instructions`.
+ */
+export type OpenRouterDecisionQuestionId = string;
+/**
+ * Discriminator of the three System One question primitives.
+ */
+export type OpenRouterDecisionQuestionType = 'choice' | 'score' | 'noul';
+/**
+ * One piece of declaration guidance: a question's `instructions`, a Choice option, a Score level, or a
+ * side of a Noul.
+ *
+ * Every declaration surface accepts a string, an object, or an array, and the wire carries whichever was
+ * supplied VERBATIM. Start with strings — a short unambiguous criterion stays one. Structure is for
+ * guidance prose would blur, and for data that is already JSON (a taxonomy branch, a database row):
+ * serializing a row into a sentence so the model can read it back out is work the model does not need.
+ */
+export type OpenRouterDecisionEntry = string | Readonly<Record<string, unknown>> | ReadonlyArray<unknown>;
+/**
+ * Structured `instructions`, for a question with several parts.
+ *
+ * `inspect` and `compare` name parts of the state, in the same backticked dot-path convention prose
+ * instructions use.
+ */
+export interface OpenRouterDecisionStructuredInstructions {
+    readonly question: string;
+    readonly focus?: Maybe<string>;
+    readonly inspect?: Maybe<string | ReadonlyArray<string>>;
+    readonly compare?: Maybe<ReadonlyArray<string>>;
+}
+/**
+ * A structured Choice option.
+ *
+ * CONTRASTIVE by design: use the SAME keys on every option of a question so the model compares like
+ * with like. `not_for` is where an option's boundary against its neighbours goes.
+ */
+export interface OpenRouterDecisionStructuredCriterion {
+    readonly what: string;
+    readonly not_for?: Maybe<string>;
+    readonly examples?: Maybe<ReadonlyArray<string>>;
+}
+/**
+ * A structured Score level.
+ *
+ * `what` is a SITUATION, not a degree — "broken or degraded feature, but a workaround exists" gives the
+ * model something to match the state against, where "moderately severe" does not. Use the same keys on
+ * every level of a question.
+ */
+export interface OpenRouterDecisionStructuredLevel {
+    readonly what: string;
+    readonly signals?: Maybe<ReadonlyArray<string>>;
+    readonly examples?: Maybe<ReadonlyArray<string>>;
+}
+/**
+ * The declared options of a Choice, keyed by the option name the answer will quote.
+ *
+ * A `null` / absent description declares an UNDESCRIBED option, which is the right thing when the state
+ * already carries the option's own text.
+ */
+export type OpenRouterDecisionChoiceOptions<O extends string = string> = Readonly<Record<O, Maybe<OpenRouterDecisionEntry>>>;
+/**
+ * The two sides of a Noul, for a condition whose boundary is worth stating explicitly.
+ *
+ * Both sides or neither — a one-sided definition is not expressible, because a `true` with no matching
+ * `false` measurably degrades the answer.
+ */
+export interface OpenRouterDecisionNoulMeans {
+    readonly true: OpenRouterDecisionEntry;
+    readonly false: OpenRouterDecisionEntry;
+}
+/**
+ * "Which of these options?"
+ *
+ * A Choice is only ever RELATIVE: the probabilities are normalised over the options supplied, so
+ * something always wins even when nothing fits. When "nothing fits" is an outcome the caller acts on, a
+ * Noul rides beside the Choice — it is absolute, and may be low for every option.
+ */
+export interface OpenRouterDecisionChoiceQuestion<O extends string = string> {
+    readonly type: 'choice';
+    readonly instructions: OpenRouterDecisionEntry;
+    readonly options: OpenRouterDecisionChoiceOptions<O>;
+}
+/**
+ * The levels of a Score, lowest to highest, as accepted by {@link openRouterScoreQuestion}.
+ *
+ * A tuple rather than an array so the two-level minimum is a COMPILE error for a question written in
+ * code. The question interface itself holds a plain array, because a question read back out of storage
+ * is one.
+ */
+export type OpenRouterDecisionScoreLevels = readonly [OpenRouterDecisionEntry, OpenRouterDecisionEntry, ...OpenRouterDecisionEntry[]];
+/**
+ * "Which level on this rubric?"
+ *
+ * The answer may land BETWEEN two levels, so cross a THRESHOLD with a score and never try to recover a
+ * magnitude from one. Every level is evaluated separately and the model never sees a level's number or
+ * its neighbours, which is why numbers in the level descriptions do not help and situations do.
+ */
+export interface OpenRouterDecisionScoreQuestion {
+    readonly type: 'score';
+    readonly instructions: OpenRouterDecisionEntry;
+    readonly levels: ReadonlyArray<OpenRouterDecisionEntry>;
+}
+/**
+ * "Is this true?"
+ *
+ * The returned probability IS the uncertainty, so a Noul carries no separate confidence. Define the
+ * CONDITION: "states they used Python at work" is a Noul, while "strong in Python" is a Score.
+ */
+export interface OpenRouterDecisionNoulQuestion {
+    readonly type: 'noul';
+    readonly instructions: OpenRouterDecisionEntry;
+    readonly means?: Maybe<OpenRouterDecisionNoulMeans>;
+}
+/**
+ * Any one declared question.
+ */
+export type OpenRouterDecisionQuestion<O extends string = string> = OpenRouterDecisionChoiceQuestion<O> | OpenRouterDecisionScoreQuestion | OpenRouterDecisionNoulQuestion;
+/**
+ * The questions one decision declares, keyed by {@link OpenRouterDecisionQuestionId}.
+ *
+ * Declare every question one state could need in ONE call: each is evaluated independently against the
+ * same state, so the map is both the batching unit and the cost unit. The state is sent (and billed)
+ * once, and a speculative question the caller may discard costs only its own tokens.
+ */
+export type OpenRouterDecisionQuestions = Readonly<Record<OpenRouterDecisionQuestionId, OpenRouterDecisionQuestion>>;
+/**
+ * The content to judge.
+ *
+ * Prefer an object so each part has a NAME a question can point at. Filtering belongs in code first:
+ * accuracy falls as a state grows with material unrelated to the decision, so a wide state is not a
+ * free hedge.
+ */
+export type OpenRouterDecisionState = string | Readonly<Record<string, unknown>> | ReadonlyArray<unknown>;
+/**
+ * A decision state in the form durable storage can hold: an object or an array, never a bare string.
+ *
+ * The narrowing is not a storage workaround dressed up as doctrine — it IS the doctrine. A state should
+ * be an object anyway, so each part has a name a question can point at with the backticked dot-path
+ * convention; a bare string leaves every question describing the state again in prose. A caller whose
+ * state really is one value names it (`{ phrase: '…' }`) and gets a question that can say `` `phrase` ``.
+ *
+ * (It also happens to be what a JSON-string Firestore field can carry, which is why the queued arm of
+ * the execution system takes this rather than {@link OpenRouterDecisionState}.)
+ */
+export type OpenRouterStorableDecisionState = Exclude<OpenRouterDecisionState, string>;
+/**
+ * The answer to a Choice.
+ *
+ * `choice` is GUARANTEED to be one of the declared options — that is the transport's contract, checked
+ * by `readOpenRouterDecisionAnswers` — and `probabilities` covers every declared option, summing to 1.
+ * Both `probabilities` and `confidence` are optional: an absent one is a real reply, not a fault.
+ */
+export interface OpenRouterDecisionChoiceAnswer<O extends string = string> {
+    readonly type: 'choice';
+    readonly choice: O;
+    readonly probabilities?: Maybe<Readonly<Record<O, number>>>;
+    readonly confidence?: Maybe<number>;
+}
+/**
+ * The answer to a Score.
+ *
+ * `legend` echoes the declared levels back, keyed by their index as a string.
+ */
+export interface OpenRouterDecisionScoreAnswer {
+    readonly type: 'score';
+    readonly score: number;
+    readonly legend?: Maybe<Readonly<Record<string, OpenRouterDecisionEntry>>>;
+    readonly probabilities?: Maybe<Readonly<Record<string, number>>>;
+    readonly confidence?: Maybe<number>;
+}
+/**
+ * The answer to a Noul: the probability the condition holds, 0..1.
+ */
+export interface OpenRouterDecisionNoulAnswer {
+    readonly type: 'noul';
+    readonly noul: number;
+}
+/**
+ * Any one answer.
+ */
+export type OpenRouterDecisionAnswer<O extends string = string> = OpenRouterDecisionChoiceAnswer<O> | OpenRouterDecisionScoreAnswer | OpenRouterDecisionNoulAnswer;
+/**
+ * The answer type a given declared question produces.
+ */
+export type OpenRouterDecisionAnswerFor<Q extends OpenRouterDecisionQuestion> = Q extends OpenRouterDecisionNoulQuestion ? OpenRouterDecisionNoulAnswer : Q extends OpenRouterDecisionScoreQuestion ? OpenRouterDecisionScoreAnswer : Q extends OpenRouterDecisionChoiceQuestion<infer O> ? OpenRouterDecisionChoiceAnswer<O> : never;
+/**
+ * The answers a declared question map produces.
+ *
+ * DERIVED from the questions rather than declared beside them, so a caller reads `answers.urgency.score`
+ * with no cast and a renamed question is a compile error at every reader.
+ */
+export type OpenRouterDecisionAnswers<Q extends OpenRouterDecisionQuestions = OpenRouterDecisionQuestions> = {
+    readonly [K in keyof Q]: OpenRouterDecisionAnswerFor<Q[K]>;
+};
+/**
+ * A coarse reading of a Choice or Score `confidence`.
+ */
+export type OpenRouterDecisionConfidenceBand = 'high' | 'medium' | 'low';
+/**
+ * Confidence at or above which {@link asOpenRouterDecisionConfidenceBand} reads `high`.
+ *
+ * A documented STARTING POINT, not a tuned threshold. Note also that a Noul probability and a Choice
+ * confidence answer different questions and are not comparable, so a threshold calibrated for one may
+ * not be carried over to the other.
+ */
+export declare const OPENROUTER_DECISION_CONFIDENCE_HIGH = 0.75;
+/**
+ * Confidence at or above which {@link asOpenRouterDecisionConfidenceBand} reads `medium`.
+ *
+ * See the note on {@link OPENROUTER_DECISION_CONFIDENCE_HIGH}.
+ */
+export declare const OPENROUTER_DECISION_CONFIDENCE_MEDIUM = 0.5;
+/**
+ * Most options a single Choice may declare.
+ *
+ * A hard transport limit, not a guideline. Past it, narrow in two stages — ask a first Choice that picks
+ * the branch, then a second over that branch's members — rather than truncating the set, because an
+ * option that was truncated away is one the model can never pick and nothing reports that it was missing.
+ */
+export declare const OPENROUTER_DECISION_CHOICE_OPTIONS_MAX = 255;
+/**
+ * Fewest levels a Score may declare.
+ */
+export declare const OPENROUTER_DECISION_SCORE_LEVELS_MIN = 2;
+/**
+ * Most levels a Score may declare.
+ *
+ * The trap this guards: a 0..8 band is NINE levels and legal, while a 0..10 scale is eleven and is
+ * rejected at the wire. Past the ceiling, MERGE the levels that cannot be told apart — never truncate
+ * the top, which silently removes the extreme the threshold usually cares about.
+ */
+export declare const OPENROUTER_DECISION_SCORE_LEVELS_MAX = 10;
+/**
+ * Whether a declaration entry says nothing at all.
+ *
+ * A blank string, an empty array, and a keyless object all ask nothing, and all three reach the wire as
+ * a question the model cannot answer.
+ *
+ * @param entry - The entry to test.
+ * @returns True when the entry carries no guidance.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function isBlankOpenRouterDecisionEntry(entry: Maybe<OpenRouterDecisionEntry>): boolean;
+/**
+ * The option names a Choice declared — what the model was SHOWN.
+ *
+ * @param question - The choice question.
+ * @returns The declared option names, in declaration order.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function openRouterDecisionChoiceOptionNames<O extends string = string>(question: OpenRouterDecisionChoiceQuestion<O>): O[];
+/**
+ * Reads a confidence as a band.
+ *
+ * An ABSENT confidence reads `low` rather than throwing: the model is not required to report one, and a
+ * caller that branches on the band should treat "did not say" the same as "not sure".
+ *
+ * @param confidence - The reported confidence, if any.
+ * @returns The band.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function asOpenRouterDecisionConfidenceBand(confidence: Maybe<number>): OpenRouterDecisionConfidenceBand;
+/**
+ * One row of a Choice's distribution.
+ */
+export interface OpenRouterDecisionChoiceRankingRow<O extends string = string> {
+    readonly option: O;
+    readonly probability: number;
+}
+/**
+ * Reads a Choice's distribution as a ranking, most probable first.
+ *
+ * The distribution is a FREE full ranking — the model reports every option, not just the winner — so a
+ * caller wanting a shortlist should read this rather than paying for a second question.
+ *
+ * Returns an empty array when the answer carried no distribution, which is a real reply rather than an
+ * error. The sort is stable, so tied options keep declaration order.
+ *
+ * @param answer - The choice answer.
+ * @returns The ranking rows.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function openRouterDecisionChoiceRanking<O extends string = string>(answer: OpenRouterDecisionChoiceAnswer<O>): OpenRouterDecisionChoiceRankingRow<O>[];
+/**
+ * Config for {@link mapOpenRouterDecisionChoiceRows}.
+ */
+export interface MapOpenRouterDecisionChoiceRowsConfig<Q extends OpenRouterDecisionQuestions, K extends keyof Q & string, R> {
+    /**
+     * The answers the decision returned.
+     */
+    readonly answers: OpenRouterDecisionAnswers<Q>;
+    /**
+     * Which question's distribution to read.
+     */
+    readonly question: K;
+    /**
+     * Resolves one declared option name back to the caller's own row. Return null to drop it.
+     */
+    readonly rowOf: (option: string) => Maybe<R>;
+}
+/**
+ * One of the caller's own rows, with the probability the model gave it.
+ */
+export interface OpenRouterDecisionChoiceRow<R> {
+    readonly row: R;
+    readonly probability: number;
+}
+/**
+ * Reads a Choice's distribution back as the caller's OWN rows, most probable first.
+ *
+ * The seam exists because a Choice's options are usually derived from rows the caller already holds, and
+ * walking the distribution back to them by hand at every call site is where the option-name convention
+ * quietly drifts.
+ *
+ * @param config - The answers, the question to read, and how to resolve an option to a row.
+ * @returns The resolved rows, most probable first. Options that resolve to nothing are dropped.
+ */
+export declare function mapOpenRouterDecisionChoiceRows<Q extends OpenRouterDecisionQuestions, K extends keyof Q & string, R>(config: MapOpenRouterDecisionChoiceRowsConfig<Q, K, R>): OpenRouterDecisionChoiceRow<R>[];
+/**
+ * Reads back the state paths a declaration entry names.
+ *
+ * The convention is to name a part of the state as a dot-and-index path IN BACKTICKS — `` `phrase` ``,
+ * `` `ticket.sender.email` ``, `` `messages[0].text` `` — so a question points at something the state
+ * actually carries rather than describing it again in prose.
+ *
+ * Documented and inspectable, deliberately NOT enforced: backticks also legitimately quote an option key
+ * or a literal, so a spec may pin that a declaration points at keys its state has, while the transport
+ * never refuses one that does not.
+ *
+ * @param entry - The entry to read. Objects and arrays are walked.
+ * @returns The paths, deduplicated, in the order they first appear.
+ */
+export declare function openRouterDecisionStatePaths(entry: Maybe<OpenRouterDecisionEntry>): string[];
+/**
+ * Declares a Choice question.
+ *
+ * Supply the FULL option set, plus an explicit `other` / `none of the above` when the set may not cover
+ * the input — the distribution is normalised over what was supplied, so a Choice always names a winner
+ * whether or not one fits.
+ *
+ * @param instructions - The complete question, as the model will read it.
+ * @param options - The options, keyed by the name the answer will quote.
+ * @returns The declared question.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function openRouterChoiceQuestion<O extends string = string>(instructions: OpenRouterDecisionEntry, options: OpenRouterDecisionChoiceOptions<O>): OpenRouterDecisionChoiceQuestion<O>;
+/**
+ * Declares a Score question.
+ *
+ * Use as many levels as can be described DISTINCTLY, lowest to highest — three is fine, and a rare
+ * extreme deserves its own level. One dimension per question.
+ *
+ * @param instructions - The complete question, as the model will read it.
+ * @param levels - The levels, lowest first. At least two.
+ * @returns The declared question.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function openRouterScoreQuestion(instructions: OpenRouterDecisionEntry, levels: OpenRouterDecisionScoreLevels): OpenRouterDecisionScoreQuestion;
+/**
+ * Declares a Noul question.
+ *
+ * @param instructions - The complete question, as the model will read it.
+ * @param means - Optional explicit definitions of the true and false sides.
+ * @returns The declared question.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function openRouterNoulQuestion(instructions: OpenRouterDecisionEntry, means?: Maybe<OpenRouterDecisionNoulMeans>): OpenRouterDecisionNoulQuestion;
+/**
+ * Validates a declared question map.
+ *
+ * Every problem here fails AT THE DECLARATION, naming the question, rather than as a 4xx about a request
+ * body — which is the difference between a publish that is refused and a run that dies in a sweep at 2am.
+ *
+ * Returns the package's standard validation result so a caller can report question problems and config
+ * problems through one surface.
+ *
+ * @param questions - The declared questions.
+ * @returns The validation result.
+ */
+export declare function validateOpenRouterDecisionQuestions(questions: Maybe<OpenRouterDecisionQuestions>): OpenRouterModelConfigValidation;

package/src/lib/openrouter.prompt.d.ts

@@ -1,5 +1,6 @@
 import { type Maybe } from '@dereekb/util';
 import { type OpenRouterModelConfig } from './openrouter.config';
+import { type OpenRouterDecisionQuestions } from './openrouter.decision.question';
 import { type OpenRouterInputRole } from './openrouter.input';
 import { type OpenRouterPromptKey, type OpenRouterPromptVersionNumber } from './openrouter.type';
 /**
@@ -46,6 +47,18 @@ export interface OpenRouterResolvedPrompt {
      * The version's model config.
      */
     readonly config: OpenRouterModelConfig;
+    /**
+     * The questions this prompt declares, when it is a DECISION prompt.
+     *
+     * Present makes a prompt a decision: a version carrying questions is asked through
+     * `openRouterDecision` rather than `callModelForOpenRouterRequest`, and its config names a System One
+     * model rather than a chat one. The two are mutually exclusive by construction — a decision has no
+     * prose output for `instructions` and `messages` to shape.
+     *
+     * These are the STATIC half of a decision's answer space, the counterpart of `messages`. A caller may
+     * declare further questions per call; they merge over these by id. See `openRouterDecisionRequest`.
+     */
+    readonly questions?: Maybe<OpenRouterDecisionQuestions>;
 }
 /**
  * Which half of a prompt resolution served it: the stored version, or the code definition standing in
@@ -87,4 +100,16 @@ export interface OpenRouterPromptDefinition extends OpenRouterResolvedPrompt {
      * What this prompt is for, used when this definition is published to Firestore.
      */
     readonly description?: Maybe<string>;
+    /**
+     * Whether the prompt this definition creates is locked to the store from the moment it exists.
+     *
+     * Takes effect ONLY on create — it is the initial value of the prompt's own `storeLocked` flag, not a
+     * standing instruction. A definition cannot lock a prompt it did not create, because doing so would
+     * let code silently seize a prompt an operator is already maintaining.
+     *
+     * Declare it for a prompt whose content is EXPECTED to be tuned at runtime — a decision's questions
+     * being the motivating case — so a fresh environment is seeded once and then left alone, with no
+     * per-environment manual step to remember.
+     */
+    readonly storeLocked?: Maybe<boolean>;
 }

package/src/lib/openrouter.sdk.d.ts

@@ -13,6 +13,13 @@
  * (`execute: false`) plus `ConversationState.pendingToolCalls` / `unsentToolResults` already provide that
  * mechanism. See `openrouter.tool.ts`.
  *
+ * `systemOneCreate` is the System One (decisions) operation, and is the ONE place that route is reached.
+ * Its path is resolved under the client root (`pathToFunc('/systemone')`), so the same `serverURL` that
+ * governs `/responses` governs it — there is no second base-url concept to configure or get wrong. It
+ * requires `@openrouter/sdk@^1.3.8`: the operation does not exist below that, and the alpha route it
+ * replaced (`/api/alpha/decisions`) was a SIBLING of `/api/v1` that older SDKs resolved relative to the
+ * client's own server, producing `…/api/v1/api/alpha/decisions` and a 404 on every call.
+ *
  * `responsesSend` / `ModelResult` / `convertToolsToAPIFormat` are what make hosted (server-executed) tools
  * deliverable: `callModel` owns the `tools` key and converts every entry as a client function tool, so
  * taking its transport and its tool loop directly is what lets `openrouter.call.ts` put an
@@ -22,6 +29,7 @@ export { callModel } from '@openrouter/sdk/funcs/call-model';
 export { responsesSend } from '@openrouter/sdk/funcs/responsesSend';
 export { unsentResultsToAPIFormat } from '@openrouter/sdk/lib/conversation-state';
 export { embeddingsGenerate } from '@openrouter/sdk/funcs/embeddingsGenerate';
+export { systemOneCreate } from '@openrouter/sdk/funcs/systemOneCreate';
 export { generationsGetGeneration } from '@openrouter/sdk/funcs/generationsGetGeneration';
 export { generationsListGenerationContent } from '@openrouter/sdk/funcs/generationsListGenerationContent';
 export { ModelResult } from '@openrouter/sdk/lib/model-result';
@@ -33,5 +41,5 @@ export type { OpenRouterCore } from '@openrouter/sdk/core';
 export type { CallModelInput } from '@openrouter/sdk/lib/async-params';
 export type { RequestOptions } from '@openrouter/sdk/lib/sdks';
 export type { ConversationState, ConversationStatus, ParsedToolCall, StateAccessor, StopWhen, Tool, UnsentToolResult } from '@openrouter/sdk/lib/tool-types';
-export type { FunctionCallOutputItem, GenerationContentData, GenerationResponseData, InputsUnion, OpenResponsesResult, ResponsesRequest, Usage } from '@openrouter/sdk/models';
-export type { CreateEmbeddingsRequest, CreateEmbeddingsResponseBody, CreateResponsesResponse } from '@openrouter/sdk/models/operations';
+export type { DecisionsChoiceAnswer, DecisionsChoiceQuestion, DecisionsNoulAnswer, DecisionsNoulQuestion, DecisionsRequest, DecisionsResponse, DecisionsScoreAnswer, DecisionsScoreQuestion, FunctionCallOutputItem, GenerationContentData, GenerationResponseData, InputsUnion, OpenResponsesResult, ResponsesRequest, Usage } from '@openrouter/sdk/models';
+export type { CreateEmbeddingsRequest, CreateEmbeddingsResponseBody, CreateResponsesResponse, CreateSystemoneRequest } from '@openrouter/sdk/models/operations';

package/src/lib/openrouter.type.d.ts

@@ -8,6 +8,57 @@ import { type Maybe } from '@dereekb/util';
  * `@dereekb/nestjs/openrouter`. They are plain string aliases, so values cross the boundary freely.
  */
 export type OpenRouterModelId = string;
+/**
+ * A model slug naming a SYSTEM ONE model — OpenRouter's second inference surface, served by
+ * `POST /systemone` rather than `/responses`.
+ *
+ * A System One model does not take messages and does not answer with prose. The caller declares the
+ * answer space up front as typed questions and the model returns a position inside it plus a calibrated
+ * distribution. See `openrouter.decision.ts`.
+ */
+export type OpenRouterSystemOneModelId = OpenRouterModelId;
+/**
+ * The namespace every System One model slug lives under.
+ */
+export declare const OPENROUTER_SYSTEM_ONE_MODEL_NAMESPACE = "typesafe";
+/**
+ * Jev 1.13, the System One model this package pins by default.
+ *
+ * A VERSIONED slug rather than one of the moving aliases (`jev-latest`, `jev-preview`), for the same
+ * reason {@link OpenRouterPromptVersionNumber} exists: a decision's answer is only reproducible against
+ * the exact model that produced it, and an alias silently moves out from under a stored prompt. Point a
+ * prompt at an alias deliberately, never by default.
+ */
+export declare const OPENROUTER_JEV_1_13_MODEL_ID: OpenRouterSystemOneModelId;
+/**
+ * The newest STABLE Jev. A moving alias — see {@link OPENROUTER_JEV_1_13_MODEL_ID}.
+ */
+export declare const OPENROUTER_JEV_LATEST_MODEL_ID: OpenRouterSystemOneModelId;
+/**
+ * The newest Jev, stable or not. A moving alias — see {@link OPENROUTER_JEV_1_13_MODEL_ID}.
+ */
+export declare const OPENROUTER_JEV_PREVIEW_MODEL_ID: OpenRouterSystemOneModelId;
+/**
+ * The System One model a decision uses when its config names none.
+ */
+export declare const DEFAULT_OPENROUTER_SYSTEM_ONE_MODEL_ID: OpenRouterSystemOneModelId;
+/**
+ * Whether a model slug names a System One model.
+ *
+ * This is the ONLY discriminator available, and it is the reason this function exists rather than a
+ * lookup: System One models are NOT listed by `GET /models`, so nothing can be learned about one from
+ * the catalog. A caller that guessed wrong does not get an error it can read — a Jev slug sent to
+ * `/responses` fails at the provider, and a chat slug sent to `/systemone` is refused by the route.
+ *
+ * Both forms are recognised: the namespaced slug (`typesafe/jev-1.13`) and the bare one (`jev-1.13`,
+ * `jev-latest`), which the SDK documents itself as mapping onto the `typesafe/` namespace.
+ *
+ * @param model - The model slug to test.
+ * @returns True when the slug names a System One model.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function isOpenRouterSystemOneModelId(model: Maybe<OpenRouterModelId>): boolean;
 /**
  * A generation id returned by OpenRouter for a completed request.
  *