Skip to content
Source
Sign inSign up
pingdotgg/t3code
Open History to see the last commit

OpenRouterDecisionModel.ts

176 lines6.0 KB

1/**
2 * Decision models backed by OpenRouter's alpha Decisions API.
3 *
4 * @stability unstable
5 * @since 4.0.0
6 */
7import * as AiError from "effect/ai/AiError"
8import * as DecisionModel from "effect/ai/DecisionModel"
9import * as Model from "effect/ai/Model"
10import * as Context from "effect/Context"
11import * as Effect from "effect/Effect"
12import * as Layer from "effect/Layer"
13import { OpenRouterClient } from "./OpenRouterClient.ts"
14import type * as OpenRouterSchema from "./OpenRouterSchema.ts"
15​
16declare module "effect/ai/DecisionModel" {
17 /**
18 * OpenRouter metadata returned with a decision response.
19 *
20 * @stability unstable
21 * @category models
22 * @since 4.0.6
23 */
24 export interface DecideResponseMetadata {
25 readonly openrouter?: {
26 /**
27 * Credits charged for the request.
28 */
29 readonly cost?: number
30 /**
31 * Upstream provider that served the request.
32 */
33 readonly provider?: string
34 }
35 }
37​
38/**
39 * Request options that override model defaults at call time.
40 *
41 * @stability unstable
42 * @category services
43 * @since 4.0.0
44 */
45export class Config extends Context.Service<
46 Config,
47 Pick<
48 typeof OpenRouterSchema.DecisionsRequest.Encoded,
49 "provider" | "session_id" | "user" | "trace"
50 >
51>()("@effect/ai-openrouter/OpenRouterDecisionModel/Config") {}
52​
53/**
54 * Creates an OpenRouter model descriptor with decision support.
55 *
56 * @stability unstable
57 * @category constructors
58 * @since 4.0.0
59 */
60export const model = (
61 model: string,
62 config?: typeof Config.Service
63): Model.Model<"openrouter", DecisionModel.DecisionModel, OpenRouterClient> =>
64 Model.make("openrouter", model, layer({ model, config }))
65​
66/**
67 * Creates a decision service that validates full choice and score distributions.
68 * Missing distributions yield `"NoDistribution"` with `decideSettled` or
69 * `AiError.InvalidOutputError` with `decide`.
70 * Score indices map to criteria labels. Reported `cost` and the serving
71 * provider are returned under `metadata.openrouter`.
72 * Probabilities arrive rounded to two decimals, so small sum drift is rescaled.
73 *
74 * @stability unstable
75 * @category constructors
76 * @since 4.0.0
77 */
78export const make = Effect.fnUntraced(function*(options: {
79 readonly model: string
80 readonly config?: typeof Config.Service | undefined
81}): Effect.fn.Return<DecisionModel.DecisionModel, never, OpenRouterClient> {
82 const client = yield* OpenRouterClient
83 const config = Effect.contextWith((services: Context.Context<never>) =>
84 Effect.succeed({ ...options.config, ...Context.getOrUndefined(services, Config) })
85 )
86 return yield* DecisionModel.make({
87 probabilityPrecision: 2,
88 decide: Effect.fnUntraced(function*({ state, decisions }) {
89 if (state === null || typeof state === "number" || typeof state === "boolean") {
90 return yield* AiError.make({
91 module: "OpenRouterDecisionModel",
92 method: "decide",
93 reason: new AiError.InvalidUserInputError({
94 description: "OpenRouter decision state must be a string, object, or array"
95 })
96 })
97 }
98 const questions: Record<string, typeof OpenRouterSchema.DecisionsQuestion.Encoded> = Object.create(null)
99 for (const [key, decision] of Object.entries(decisions)) {
100 switch (decision._tag) {
101 case "Classify":
102 questions[key] = { type: "choice", instructions: decision.instructions, criteria: decision.criteria }
103 break
104 case "Rate":
105 questions[key] = {
106 type: "score",
107 instructions: decision.instructions,
108 criteria: decision.criteria.map((level) => level.description)
109 }
110 break
111 case "Probability":
112 questions[key] = { type: "noul", instructions: decision.instructions, criteria: decision.criteria }
113 break
114 }
115 }
116 const [response] = yield* client.createDecisions({ ...yield* config, model: options.model, state, questions })
117 const answers: Record<string, DecisionModel.ProviderAnswer> = Object.create(null)
118 for (const [key, answer] of Object.entries(response.answers)) {
119 if (answer.type === "noul") {
120 answers[key] = { _tag: "Probability", probability: answer.noul }
121 continue
122 }
123 if (answer.type === "choice") {
124 answers[key] = {
125 _tag: "Classify",
126 label: answer.choice,
127 probabilities: answer.probabilities,
128 confidence: answer.confidence
129 }
130 } else {
131 const decision = decisions[key]
132 const probabilities: Record<string, number> = Object.create(null)
133 if (decision?._tag === "Rate") {
134 for (const [index, { label }] of decision.criteria.entries()) {
135 const probability = answer.probabilities?.[String(index)]
136 if (probability !== undefined) {
137 probabilities[label] = probability
138 }
139 }
140 }
141 answers[key] = {
142 _tag: "Rate",
143 rating: answer.score,
144 probabilities: answer.probabilities === undefined ? undefined : probabilities,
145 confidence: answer.confidence
146 }
147 }
148 }
149 return {
150 answers,
151 usage: { inputTokens: response.usage.input_tokens, outputTokens: response.usage.output_tokens },
152 id: response.id,
153 modelId: response.model,
154 metadata: {
155 openrouter: {
156 ...(response.usage.cost === undefined ? undefined : { cost: response.usage.cost }),
157 ...(response.provider === undefined ? undefined : { provider: response.provider })
158 }
159 }
160 }
161 })
162 })
163})
164​
165/**
166 * Provides a decision model using the OpenRouter client service.
167 *
168 * @stability unstable
169 * @category layers
170 * @since 4.0.0
171 */
172export const layer = (options: {
173 readonly model: string
174 readonly config?: typeof Config.Service | undefined
175}): Layer.Layer<DecisionModel.DecisionModel, never, OpenRouterClient> =>
176 Layer.effect(DecisionModel.DecisionModel, make(options))