@opengeni/decisions 0.0.0-stage → 4.3.3-canary.39685962091001

package/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Cloudgeni-ai
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,55 @@
-# Temporary Holding Version
+# `@opengeni/decisions`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A decision model is a fast typed judge, not a conversational agent. It evaluates
+shared input against named questions and returns predicate probabilities, a choice,
+or a score. Consumers own the rubric and thresholds; adapters own the provider wire
+protocol, cancellation, answer validation and usage receipt.
+
+```ts
+import { createHttpDecisionModel, predicate } from "@opengeni/decisions";
+
+const model = createHttpDecisionModel({
+  provider: "openrouter",
+  model: "typesafe/jev-1.13",
+  apiKey, // explicitly supplied by the application
+});
+const result = await model.decide(
+  { message: "The checkout page is blank" },
+  {
+    defect: predicate("Does this describe broken behavior?"),
+    team: { type: "choice", instructions: "Which team owns it?", criteria: { ui: "Rendering", billing: "Payments" } },
+    urgency: { type: "score", instructions: "How urgent?", criteria: ["Cosmetic", "Blocking"] },
+  },
+  { signal, onUsage: recordUsage },
+);
+if (result.answers.defect.type === "predicate") {
+  console.log(result.answers.defect.probability);
+}
+```
+
+`DecisionModel.decide(input, questions, options?)` returns `{answers, usage}`.
+Answers may be typed refusals. Choice values must be declared keys; a score ranges
+from zero through `criteria.length - 1` and may be fractional. Probabilities are
+finite values in `[0,1]`, not a claim of calibration. The complete named answer set
+is validated; consumers must explicitly handle refusals. Neither tool discovery
+nor code search treats a refusal as a valid score.
+
+The OpenAI adapter calls `/v1/decisions`; OpenRouter calls
+`/api/alpha/decisions`. They are distinct typed protocols, not chat-completions
+requests. There is no prose fallback, credential discovery, retry policy or new
+timeout. The optional `endpoint` is a full URL; caller cancellation is forwarded.
+The existing `@opengeni/jev` package exports `createJevDecisionModel(client)` and
+retains its established chunking/retry policy. The dependency points from Jev to
+this package, not both ways.
+
+Usage includes actual model/provider identity when returned, successful request
+chunks, nullable token counts and nullable USD cost. `costSource` distinguishes
+provider-reported charges, explicit estimates and unknown cost. HTTP adapters call
+`onUsage` before answer validation; an invalid answer can still have a charge.
+Missing usage is never invented. The legacy Jev client supplies its existing
+input-cost estimate and may fail before an aggregate receipt exists; unknown
+failed-call charges are not proof of zero spend. The hook is application-owned
+accounting, not a built-in customer debit.
+
+See [deployment configuration and verified backend boundaries](../../docs/decision-models.md)
+and [tool-discovery evaluation](../../scripts/tool-discovery-eval/README.md).

package/dist/http.d.ts

@@ -0,0 +1,66 @@
+import { type DecisionModel, type DecisionQuestion } from "./types.js";
+export type HttpDecisionModelOptions = {
+    provider: "openai" | "openrouter";
+    model: string;
+    apiKey: string;
+    /** Full typed endpoint; never a chat-completions fallback. */
+    endpoint?: string;
+    fetch?: typeof fetch;
+    /** Optional deployment rate, explicitly an estimate, not a billed receipt. */
+    inputUsdPerMillion?: number;
+};
+export declare const OPENAI_DECISIONS_ENDPOINT = "https://api.openai.com/v1/decisions";
+export declare const OPENROUTER_DECISIONS_ENDPOINT = "https://openrouter.ai/api/alpha/decisions";
+export declare function openAiDecisionRequest(model: string, input: unknown, questions: Record<string, DecisionQuestion>): {
+    model: string;
+    input: string;
+    questions: ({
+        name: string;
+        type: "predicate";
+        instructions: string;
+        choices?: never;
+        levels?: never;
+    } | {
+        name: string;
+        type: "choice";
+        instructions: string;
+        choices: {
+            value: string;
+            description: string;
+        }[];
+        levels?: never;
+    } | {
+        choices?: never;
+        name: string;
+        type: "score";
+        instructions: string;
+        levels: {
+            label: string;
+            description: string;
+        }[];
+    })[];
+};
+export declare function openRouterDecisionRequest(model: string, input: unknown, questions: Record<string, DecisionQuestion>): {
+    model: string;
+    state: unknown;
+    questions: {
+        [k: string]: {
+            instructions: import("./types.js").DecisionInstructions;
+            criteria: Record<string, import("./types.js").DecisionInstructions | null>;
+            type: string;
+        } | {
+            instructions: import("./types.js").DecisionInstructions;
+            criteria?: {
+                true?: import("./types.js").DecisionInstructions;
+                false?: import("./types.js").DecisionInstructions;
+            };
+            type: string;
+        } | {
+            instructions: import("./types.js").DecisionInstructions;
+            criteria: import("./types.js").DecisionInstructions[];
+            type: string;
+        };
+    };
+};
+/** Real typed endpoints only. Caller cancellation is forwarded; no new timeout/retry policy. */
+export declare function createHttpDecisionModel(config: HttpDecisionModelOptions): DecisionModel;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./http.js";

package/dist/index.js

@@ -0,0 +1,213 @@
+// src/types.ts
+function predicate(instructions, criteria) {
+  return criteria ? { type: "predicate", instructions, criteria } : { type: "predicate", instructions };
+}
+var DecisionError = class extends Error {
+  status;
+  code;
+  constructor(message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = new.target.name;
+    this.status = options.status;
+    this.code = options.code;
+  }
+};
+var DecisionUnavailableError = class extends DecisionError {
+};
+var DecisionRequestError = class extends DecisionError {
+};
+var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var probability = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+function validateDecisionAnswers(questions, answers) {
+  const invalid = () => {
+    throw new DecisionUnavailableError("Decision model returned invalid typed answers");
+  };
+  if (!isRecord(answers)) return invalid();
+  const names = Object.keys(questions);
+  if (Object.keys(answers).length !== names.length) return invalid();
+  for (const name of names) {
+    const answer = answers[name];
+    const question = questions[name];
+    if (!isRecord(answer)) return invalid();
+    if (answer.type === "refusal") {
+      if (answer.reason !== void 0 && typeof answer.reason !== "string") return invalid();
+      continue;
+    }
+    if (answer.type !== question.type) return invalid();
+    if (question.type === "predicate" && !probability(answer.probability)) return invalid();
+    if (question.type === "choice" && (typeof answer.choice !== "string" || !Object.hasOwn(question.criteria, answer.choice)))
+      return invalid();
+    if (question.type === "score" && (typeof answer.score !== "number" || !Number.isFinite(answer.score) || answer.score < 0 || answer.score > question.criteria.length - 1))
+      return invalid();
+    if (answer.confidence !== void 0 && !probability(answer.confidence)) return invalid();
+    if (answer.probabilities !== void 0) {
+      if (!isRecord(answer.probabilities) || Object.values(answer.probabilities).some((p) => !probability(p)))
+        return invalid();
+      const allowed = question.type === "choice" ? Object.keys(question.criteria) : question.type === "score" ? question.criteria.map((_, i) => String(i)) : [];
+      if (Object.keys(answer.probabilities).some((key) => !allowed.includes(key))) return invalid();
+    }
+  }
+  return answers;
+}
+
+// src/http.ts
+var OPENAI_DECISIONS_ENDPOINT = "https://api.openai.com/v1/decisions";
+var OPENROUTER_DECISIONS_ENDPOINT = "https://openrouter.ai/api/alpha/decisions";
+var text = (value) => typeof value === "string" ? value : JSON.stringify(value);
+var count = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+function openAiDecisionRequest(model, input, questions) {
+  return {
+    model,
+    input: text(input),
+    questions: Object.entries(questions).map(([name, question]) => {
+      if (question.type === "predicate")
+        return {
+          name,
+          type: question.type,
+          instructions: question.criteria ? text({ instructions: question.instructions, criteria: question.criteria }) : text(question.instructions)
+        };
+      if (question.type === "choice")
+        return {
+          name,
+          type: question.type,
+          instructions: text(question.instructions),
+          choices: Object.entries(question.criteria).map(([value, description]) => ({
+            value,
+            description: description === null ? value : text(description)
+          }))
+        };
+      return {
+        name,
+        type: question.type,
+        instructions: text(question.instructions),
+        levels: question.criteria.map((description, index) => ({
+          label: String(index),
+          description: text(description)
+        }))
+      };
+    })
+  };
+}
+function openRouterDecisionRequest(model, input, questions) {
+  return {
+    model,
+    state: input,
+    questions: Object.fromEntries(
+      Object.entries(questions).map(([name, question]) => [
+        name,
+        { ...question, type: question.type === "predicate" ? "noul" : question.type }
+      ])
+    )
+  };
+}
+function normalizeAnswers(raw, provider) {
+  if (provider === "openrouter") {
+    if (!isRecord(raw))
+      throw new DecisionUnavailableError("Decision response has no named answers");
+    return Object.fromEntries(
+      Object.entries(raw).map(([name, answer]) => [
+        name,
+        isRecord(answer) && answer.type === "noul" ? { type: "predicate", probability: answer.noul } : answer
+      ])
+    );
+  }
+  if (!Array.isArray(raw))
+    throw new DecisionUnavailableError("Decision response has no answer array");
+  const answers = /* @__PURE__ */ Object.create(null);
+  for (const value of raw) {
+    if (!isRecord(value) || typeof value.name !== "string" || Object.hasOwn(answers, value.name))
+      throw new DecisionUnavailableError("Decision response has invalid or duplicate answer names");
+    const { name, probabilities, ...answer } = value;
+    if (probabilities !== void 0) {
+      if (!Array.isArray(probabilities))
+        throw new DecisionUnavailableError("Decision response has invalid probabilities");
+      const mapped = /* @__PURE__ */ Object.create(null);
+      for (const entry of probabilities) {
+        if (!isRecord(entry) || typeof entry.value !== "string" && typeof entry.value !== "number" || Object.hasOwn(mapped, String(entry.value)))
+          throw new DecisionUnavailableError("Decision response has invalid probability labels");
+        mapped[String(entry.value)] = entry.probability;
+      }
+      answer.probabilities = mapped;
+    }
+    answers[name] = answer;
+  }
+  return answers;
+}
+function createHttpDecisionModel(config) {
+  if (!config.apiKey || !config.model)
+    throw new DecisionRequestError("Decision model and credential must be configured");
+  const endpoint = config.endpoint ?? (config.provider === "openai" ? OPENAI_DECISIONS_ENDPOINT : OPENROUTER_DECISIONS_ENDPOINT);
+  return {
+    async decide(input, questions, options = {}) {
+      options.signal?.throwIfAborted();
+      if (!Object.keys(questions).length)
+        throw new DecisionRequestError("A decision request needs named questions");
+      const request = config.provider === "openai" ? openAiDecisionRequest(config.model, input, questions) : openRouterDecisionRequest(config.model, input, questions);
+      let response;
+      try {
+        response = await (config.fetch ?? fetch)(endpoint, {
+          method: "POST",
+          headers: { Authorization: `Bearer ${config.apiKey}`, "Content-Type": "application/json" },
+          body: JSON.stringify(request),
+          ...options.signal ? { signal: options.signal } : {}
+        });
+      } catch (cause) {
+        options.signal?.throwIfAborted();
+        throw new DecisionUnavailableError("Decision provider request failed", { cause });
+      }
+      if (!response.ok) {
+        await response.body?.cancel();
+        const ErrorType = [401, 402, 403, 408, 429].includes(response.status) || response.status >= 500 ? DecisionUnavailableError : DecisionRequestError;
+        throw new ErrorType(`Decision provider returned HTTP ${response.status}`, {
+          status: response.status
+        });
+      }
+      let result;
+      try {
+        result = await response.json();
+      } catch (cause) {
+        options.signal?.throwIfAborted();
+        throw new DecisionUnavailableError("Decision provider returned invalid JSON", { cause });
+      }
+      if (!isRecord(result))
+        throw new DecisionUnavailableError("Decision provider returned an invalid response");
+      const rawUsage = isRecord(result.usage) ? result.usage : {};
+      const inputTokens = count(rawUsage.input_tokens);
+      const reportedCost = typeof rawUsage.cost === "number" && Number.isFinite(rawUsage.cost) && rawUsage.cost >= 0 ? rawUsage.cost : null;
+      const estimatedCost = inputTokens !== null && config.inputUsdPerMillion !== void 0 ? inputTokens * config.inputUsdPerMillion / 1e6 : null;
+      const usage = {
+        model: typeof result.model === "string" ? result.model : config.model,
+        provider: typeof result.provider === "string" ? result.provider : config.provider,
+        ...typeof result.id === "string" ? { requestId: result.id } : {},
+        requests: 1,
+        inputTokens,
+        outputTokens: count(rawUsage.output_tokens),
+        costUsd: reportedCost ?? estimatedCost,
+        costSource: reportedCost !== null ? "provider-reported" : estimatedCost !== null ? "estimate" : "unknown"
+      };
+      await options.onUsage?.(usage);
+      options.signal?.throwIfAborted();
+      return {
+        usage,
+        answers: validateDecisionAnswers(
+          questions,
+          normalizeAnswers(result.answers, config.provider)
+        )
+      };
+    }
+  };
+}
+export {
+  DecisionError,
+  DecisionRequestError,
+  DecisionUnavailableError,
+  OPENAI_DECISIONS_ENDPOINT,
+  OPENROUTER_DECISIONS_ENDPOINT,
+  createHttpDecisionModel,
+  isRecord,
+  openAiDecisionRequest,
+  openRouterDecisionRequest,
+  predicate,
+  validateDecisionAnswers
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts","../src/http.ts"],"sourcesContent":["/** Shared typed judgments. Consumers own rubrics and thresholds; providers own inference. */\nexport type DecisionInstructions = string | Record<string, unknown> | unknown[];\nexport type DecisionPredicateQuestion = {\n  type: \"predicate\";\n  instructions: DecisionInstructions;\n  criteria?: { true?: DecisionInstructions; false?: DecisionInstructions };\n};\nexport type DecisionChoiceQuestion = {\n  type: \"choice\";\n  instructions: DecisionInstructions;\n  criteria: Record<string, DecisionInstructions | null>;\n};\nexport type DecisionScoreQuestion = {\n  type: \"score\";\n  instructions: DecisionInstructions;\n  criteria: DecisionInstructions[];\n};\nexport type DecisionQuestion =\n  | DecisionPredicateQuestion\n  | DecisionChoiceQuestion\n  | DecisionScoreQuestion;\nexport type DecisionRefusal = { type: \"refusal\"; reason?: string };\nexport type DecisionPredicateAnswer = { type: \"predicate\"; probability: number };\nexport type DecisionChoiceAnswer = {\n  type: \"choice\";\n  choice: string;\n  probabilities?: Record<string, number>;\n  confidence?: number;\n};\nexport type DecisionScoreAnswer = {\n  type: \"score\";\n  score: number;\n  probabilities?: Record<string, number>;\n  confidence?: number;\n};\nexport type DecisionAnswer =\n  | DecisionPredicateAnswer\n  | DecisionChoiceAnswer\n  | DecisionScoreAnswer\n  | DecisionRefusal;\nexport type DecisionAnswerFor<Q> =\n  | DecisionRefusal\n  | (Q extends DecisionPredicateQuestion\n      ? DecisionPredicateAnswer\n      : Q extends DecisionChoiceQuestion\n        ? DecisionChoiceAnswer\n        : DecisionScoreAnswer);\n\nexport type DecisionUsage = {\n  model: string;\n  provider: string;\n  requestId?: string;\n  inputTokens: number | null;\n  outputTokens: number | null;\n  /** Successful chunks, not retry attempts. */\n  requests: number;\n  costUsd: number | null;\n  costSource: \"provider-reported\" | \"estimate\" | \"unknown\";\n};\nexport type DecisionOptions = {\n  signal?: AbortSignal;\n  tag?: string;\n  /** Called even when a received answer is invalid. Never reconstructed on history replay. */\n  onUsage?: (usage: DecisionUsage) => void | Promise<void>;\n};\nexport type DecisionResult<\n  Q extends Record<string, DecisionQuestion> = Record<string, DecisionQuestion>,\n> = {\n  answers: { [K in keyof Q]: DecisionAnswerFor<Q[K]> };\n  usage: DecisionUsage;\n};\nexport interface DecisionModel {\n  decide<Q extends Record<string, DecisionQuestion>>(\n    input: unknown,\n    questions: Q,\n    options?: DecisionOptions,\n  ): Promise<DecisionResult<Q>>;\n  /** Optional provider preparation; existing code-search behavior, not required by callers. */\n  warmUp?(connections: number): void;\n}\n\nexport function predicate(\n  instructions: DecisionInstructions,\n  criteria?: DecisionPredicateQuestion[\"criteria\"],\n): DecisionPredicateQuestion {\n  return criteria\n    ? { type: \"predicate\", instructions, criteria }\n    : { type: \"predicate\", instructions };\n}\n\nexport class DecisionError extends Error {\n  readonly status: number | undefined;\n  readonly code: string | undefined;\n  constructor(message: string, options: { status?: number; code?: string; cause?: unknown } = {}) {\n    super(message, options.cause === undefined ? undefined : { cause: options.cause });\n    this.name = new.target.name;\n    this.status = options.status;\n    this.code = options.code;\n  }\n}\nexport class DecisionUnavailableError extends DecisionError {}\nexport class DecisionRequestError extends DecisionError {}\n\nexport const isRecord = (value: unknown): value is Record<string, unknown> =>\n  value !== null && typeof value === \"object\" && !Array.isArray(value);\nconst probability = (value: unknown): value is number =>\n  typeof value === \"number\" && Number.isFinite(value) && value >= 0 && value <= 1;\n\n/** Validate the complete named answer set, not a convenient partial selection. */\nexport function validateDecisionAnswers<Q extends Record<string, DecisionQuestion>>(\n  questions: Q,\n  answers: unknown,\n): DecisionResult<Q>[\"answers\"] {\n  const invalid = () => {\n    throw new DecisionUnavailableError(\"Decision model returned invalid typed answers\");\n  };\n  if (!isRecord(answers)) return invalid();\n  const names = Object.keys(questions);\n  if (Object.keys(answers).length !== names.length) return invalid();\n  for (const name of names) {\n    const answer = answers[name];\n    const question = questions[name]!;\n    if (!isRecord(answer)) return invalid();\n    if (answer.type === \"refusal\") {\n      if (answer.reason !== undefined && typeof answer.reason !== \"string\") return invalid();\n      continue;\n    }\n    if (answer.type !== question.type) return invalid();\n    if (question.type === \"predicate\" && !probability(answer.probability)) return invalid();\n    if (\n      question.type === \"choice\" &&\n      (typeof answer.choice !== \"string\" || !Object.hasOwn(question.criteria, answer.choice))\n    )\n      return invalid();\n    if (\n      question.type === \"score\" &&\n      (typeof answer.score !== \"number\" ||\n        !Number.isFinite(answer.score) ||\n        answer.score < 0 ||\n        answer.score > question.criteria.length - 1)\n    )\n      return invalid();\n    if (answer.confidence !== undefined && !probability(answer.confidence)) return invalid();\n    if (answer.probabilities !== undefined) {\n      if (\n        !isRecord(answer.probabilities) ||\n        Object.values(answer.probabilities).some((p) => !probability(p))\n      )\n        return invalid();\n      const allowed =\n        question.type === \"choice\"\n          ? Object.keys(question.criteria)\n          : question.type === \"score\"\n            ? question.criteria.map((_, i) => String(i))\n            : [];\n      if (Object.keys(answer.probabilities).some((key) => !allowed.includes(key))) return invalid();\n    }\n  }\n  return answers as DecisionResult<Q>[\"answers\"];\n}\n","import {\n  DecisionRequestError,\n  DecisionUnavailableError,\n  isRecord,\n  validateDecisionAnswers,\n  type DecisionModel,\n  type DecisionQuestion,\n  type DecisionUsage,\n} from \"./types\";\n\nexport type HttpDecisionModelOptions = {\n  provider: \"openai\" | \"openrouter\";\n  model: string;\n  apiKey: string;\n  /** Full typed endpoint; never a chat-completions fallback. */\n  endpoint?: string;\n  fetch?: typeof fetch;\n  /** Optional deployment rate, explicitly an estimate, not a billed receipt. */\n  inputUsdPerMillion?: number;\n};\nexport const OPENAI_DECISIONS_ENDPOINT = \"https://api.openai.com/v1/decisions\";\nexport const OPENROUTER_DECISIONS_ENDPOINT = \"https://openrouter.ai/api/alpha/decisions\";\nconst text = (value: unknown) => (typeof value === \"string\" ? value : JSON.stringify(value));\nconst count = (value: unknown) =>\n  typeof value === \"number\" && Number.isSafeInteger(value) && value >= 0 ? value : null;\n\nexport function openAiDecisionRequest(\n  model: string,\n  input: unknown,\n  questions: Record<string, DecisionQuestion>,\n) {\n  return {\n    model,\n    input: text(input),\n    questions: Object.entries(questions).map(([name, question]) => {\n      if (question.type === \"predicate\")\n        return {\n          name,\n          type: question.type,\n          instructions: question.criteria\n            ? text({ instructions: question.instructions, criteria: question.criteria })\n            : text(question.instructions),\n        };\n      if (question.type === \"choice\")\n        return {\n          name,\n          type: question.type,\n          instructions: text(question.instructions),\n          choices: Object.entries(question.criteria).map(([value, description]) => ({\n            value,\n            description: description === null ? value : text(description),\n          })),\n        };\n      return {\n        name,\n        type: question.type,\n        instructions: text(question.instructions),\n        levels: question.criteria.map((description, index) => ({\n          label: String(index),\n          description: text(description),\n        })),\n      };\n    }),\n  };\n}\nexport function openRouterDecisionRequest(\n  model: string,\n  input: unknown,\n  questions: Record<string, DecisionQuestion>,\n) {\n  return {\n    model,\n    state: input,\n    questions: Object.fromEntries(\n      Object.entries(questions).map(([name, question]) => [\n        name,\n        { ...question, type: question.type === \"predicate\" ? \"noul\" : question.type },\n      ]),\n    ),\n  };\n}\n\nfunction normalizeAnswers(raw: unknown, provider: HttpDecisionModelOptions[\"provider\"]) {\n  if (provider === \"openrouter\") {\n    if (!isRecord(raw))\n      throw new DecisionUnavailableError(\"Decision response has no named answers\");\n    return Object.fromEntries(\n      Object.entries(raw).map(([name, answer]) => [\n        name,\n        isRecord(answer) && answer.type === \"noul\"\n          ? { type: \"predicate\", probability: answer.noul }\n          : answer,\n      ]),\n    );\n  }\n  if (!Array.isArray(raw))\n    throw new DecisionUnavailableError(\"Decision response has no answer array\");\n  const answers = Object.create(null) as Record<string, unknown>;\n  for (const value of raw) {\n    if (!isRecord(value) || typeof value.name !== \"string\" || Object.hasOwn(answers, value.name))\n      throw new DecisionUnavailableError(\"Decision response has invalid or duplicate answer names\");\n    const { name, probabilities, ...answer } = value;\n    if (probabilities !== undefined) {\n      if (!Array.isArray(probabilities))\n        throw new DecisionUnavailableError(\"Decision response has invalid probabilities\");\n      const mapped = Object.create(null) as Record<string, unknown>;\n      for (const entry of probabilities) {\n        if (\n          !isRecord(entry) ||\n          (typeof entry.value !== \"string\" && typeof entry.value !== \"number\") ||\n          Object.hasOwn(mapped, String(entry.value))\n        )\n          throw new DecisionUnavailableError(\"Decision response has invalid probability labels\");\n        mapped[String(entry.value)] = entry.probability;\n      }\n      answer.probabilities = mapped;\n    }\n    answers[name] = answer;\n  }\n  return answers;\n}\n\n/** Real typed endpoints only. Caller cancellation is forwarded; no new timeout/retry policy. */\nexport function createHttpDecisionModel(config: HttpDecisionModelOptions): DecisionModel {\n  if (!config.apiKey || !config.model)\n    throw new DecisionRequestError(\"Decision model and credential must be configured\");\n  const endpoint =\n    config.endpoint ??\n    (config.provider === \"openai\" ? OPENAI_DECISIONS_ENDPOINT : OPENROUTER_DECISIONS_ENDPOINT);\n  return {\n    async decide(input, questions, options = {}) {\n      options.signal?.throwIfAborted();\n      if (!Object.keys(questions).length)\n        throw new DecisionRequestError(\"A decision request needs named questions\");\n      const request =\n        config.provider === \"openai\"\n          ? openAiDecisionRequest(config.model, input, questions)\n          : openRouterDecisionRequest(config.model, input, questions);\n      let response: Response;\n      try {\n        response = await (config.fetch ?? fetch)(endpoint, {\n          method: \"POST\",\n          headers: { Authorization: `Bearer ${config.apiKey}`, \"Content-Type\": \"application/json\" },\n          body: JSON.stringify(request),\n          ...(options.signal ? { signal: options.signal } : {}),\n        });\n      } catch (cause) {\n        options.signal?.throwIfAborted();\n        throw new DecisionUnavailableError(\"Decision provider request failed\", { cause });\n      }\n      if (!response.ok) {\n        await response.body?.cancel();\n        const ErrorType =\n          [401, 402, 403, 408, 429].includes(response.status) || response.status >= 500\n            ? DecisionUnavailableError\n            : DecisionRequestError;\n        throw new ErrorType(`Decision provider returned HTTP ${response.status}`, {\n          status: response.status,\n        });\n      }\n      let result: unknown;\n      try {\n        result = await response.json();\n      } catch (cause) {\n        options.signal?.throwIfAborted();\n        throw new DecisionUnavailableError(\"Decision provider returned invalid JSON\", { cause });\n      }\n      if (!isRecord(result))\n        throw new DecisionUnavailableError(\"Decision provider returned an invalid response\");\n      const rawUsage = isRecord(result.usage) ? result.usage : {};\n      const inputTokens = count(rawUsage.input_tokens);\n      const reportedCost =\n        typeof rawUsage.cost === \"number\" && Number.isFinite(rawUsage.cost) && rawUsage.cost >= 0\n          ? rawUsage.cost\n          : null;\n      const estimatedCost =\n        inputTokens !== null && config.inputUsdPerMillion !== undefined\n          ? (inputTokens * config.inputUsdPerMillion) / 1_000_000\n          : null;\n      const usage: DecisionUsage = {\n        model: typeof result.model === \"string\" ? result.model : config.model,\n        provider: typeof result.provider === \"string\" ? result.provider : config.provider,\n        ...(typeof result.id === \"string\" ? { requestId: result.id } : {}),\n        requests: 1,\n        inputTokens,\n        outputTokens: count(rawUsage.output_tokens),\n        costUsd: reportedCost ?? estimatedCost,\n        costSource:\n          reportedCost !== null\n            ? \"provider-reported\"\n            : estimatedCost !== null\n              ? \"estimate\"\n              : \"unknown\",\n      };\n      await options.onUsage?.(usage);\n      options.signal?.throwIfAborted();\n      return {\n        usage,\n        answers: validateDecisionAnswers(\n          questions,\n          normalizeAnswers(result.answers, config.provider),\n        ),\n      };\n    },\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/types.d.ts

@@ -0,0 +1,88 @@
+/** Shared typed judgments. Consumers own rubrics and thresholds; providers own inference. */
+export type DecisionInstructions = string | Record<string, unknown> | unknown[];
+export type DecisionPredicateQuestion = {
+    type: "predicate";
+    instructions: DecisionInstructions;
+    criteria?: {
+        true?: DecisionInstructions;
+        false?: DecisionInstructions;
+    };
+};
+export type DecisionChoiceQuestion = {
+    type: "choice";
+    instructions: DecisionInstructions;
+    criteria: Record<string, DecisionInstructions | null>;
+};
+export type DecisionScoreQuestion = {
+    type: "score";
+    instructions: DecisionInstructions;
+    criteria: DecisionInstructions[];
+};
+export type DecisionQuestion = DecisionPredicateQuestion | DecisionChoiceQuestion | DecisionScoreQuestion;
+export type DecisionRefusal = {
+    type: "refusal";
+    reason?: string;
+};
+export type DecisionPredicateAnswer = {
+    type: "predicate";
+    probability: number;
+};
+export type DecisionChoiceAnswer = {
+    type: "choice";
+    choice: string;
+    probabilities?: Record<string, number>;
+    confidence?: number;
+};
+export type DecisionScoreAnswer = {
+    type: "score";
+    score: number;
+    probabilities?: Record<string, number>;
+    confidence?: number;
+};
+export type DecisionAnswer = DecisionPredicateAnswer | DecisionChoiceAnswer | DecisionScoreAnswer | DecisionRefusal;
+export type DecisionAnswerFor<Q> = DecisionRefusal | (Q extends DecisionPredicateQuestion ? DecisionPredicateAnswer : Q extends DecisionChoiceQuestion ? DecisionChoiceAnswer : DecisionScoreAnswer);
+export type DecisionUsage = {
+    model: string;
+    provider: string;
+    requestId?: string;
+    inputTokens: number | null;
+    outputTokens: number | null;
+    /** Successful chunks, not retry attempts. */
+    requests: number;
+    costUsd: number | null;
+    costSource: "provider-reported" | "estimate" | "unknown";
+};
+export type DecisionOptions = {
+    signal?: AbortSignal;
+    tag?: string;
+    /** Called even when a received answer is invalid. Never reconstructed on history replay. */
+    onUsage?: (usage: DecisionUsage) => void | Promise<void>;
+};
+export type DecisionResult<Q extends Record<string, DecisionQuestion> = Record<string, DecisionQuestion>> = {
+    answers: {
+        [K in keyof Q]: DecisionAnswerFor<Q[K]>;
+    };
+    usage: DecisionUsage;
+};
+export interface DecisionModel {
+    decide<Q extends Record<string, DecisionQuestion>>(input: unknown, questions: Q, options?: DecisionOptions): Promise<DecisionResult<Q>>;
+    /** Optional provider preparation; existing code-search behavior, not required by callers. */
+    warmUp?(connections: number): void;
+}
+export declare function predicate(instructions: DecisionInstructions, criteria?: DecisionPredicateQuestion["criteria"]): DecisionPredicateQuestion;
+export declare class DecisionError extends Error {
+    readonly status: number | undefined;
+    readonly code: string | undefined;
+    constructor(message: string, options?: {
+        status?: number;
+        code?: string;
+        cause?: unknown;
+    });
+}
+export declare class DecisionUnavailableError extends DecisionError {
+}
+export declare class DecisionRequestError extends DecisionError {
+}
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+/** Validate the complete named answer set, not a convenient partial selection. */
+export declare function validateDecisionAnswers<Q extends Record<string, DecisionQuestion>>(questions: Q, answers: unknown): DecisionResult<Q>["answers"];

package/package.json

@@ -1,6 +1,39 @@
 {
   "name": "@opengeni/decisions",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "4.3.3-canary.39685962091001",
+  "description": "Provider-neutral typed decision models for application judgments, not prose generation.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Cloudgeni-ai/opengeni.git",
+    "directory": "packages/decisions"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "bun ../../scripts/build-typescript-package.ts",
+    "typecheck": "tsrs --noEmit",
+    "prepublishOnly": "bash ../../scripts/prepublish-guard"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/http.ts

@@ -0,0 +1,206 @@
+import {
+  DecisionRequestError,
+  DecisionUnavailableError,
+  isRecord,
+  validateDecisionAnswers,
+  type DecisionModel,
+  type DecisionQuestion,
+  type DecisionUsage,
+} from "./types";
+
+export type HttpDecisionModelOptions = {
+  provider: "openai" | "openrouter";
+  model: string;
+  apiKey: string;
+  /** Full typed endpoint; never a chat-completions fallback. */
+  endpoint?: string;
+  fetch?: typeof fetch;
+  /** Optional deployment rate, explicitly an estimate, not a billed receipt. */
+  inputUsdPerMillion?: number;
+};
+export const OPENAI_DECISIONS_ENDPOINT = "https://api.openai.com/v1/decisions";
+export const OPENROUTER_DECISIONS_ENDPOINT = "https://openrouter.ai/api/alpha/decisions";
+const text = (value: unknown) => (typeof value === "string" ? value : JSON.stringify(value));
+const count = (value: unknown) =>
+  typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+
+export function openAiDecisionRequest(
+  model: string,
+  input: unknown,
+  questions: Record<string, DecisionQuestion>,
+) {
+  return {
+    model,
+    input: text(input),
+    questions: Object.entries(questions).map(([name, question]) => {
+      if (question.type === "predicate")
+        return {
+          name,
+          type: question.type,
+          instructions: question.criteria
+            ? text({ instructions: question.instructions, criteria: question.criteria })
+            : text(question.instructions),
+        };
+      if (question.type === "choice")
+        return {
+          name,
+          type: question.type,
+          instructions: text(question.instructions),
+          choices: Object.entries(question.criteria).map(([value, description]) => ({
+            value,
+            description: description === null ? value : text(description),
+          })),
+        };
+      return {
+        name,
+        type: question.type,
+        instructions: text(question.instructions),
+        levels: question.criteria.map((description, index) => ({
+          label: String(index),
+          description: text(description),
+        })),
+      };
+    }),
+  };
+}
+export function openRouterDecisionRequest(
+  model: string,
+  input: unknown,
+  questions: Record<string, DecisionQuestion>,
+) {
+  return {
+    model,
+    state: input,
+    questions: Object.fromEntries(
+      Object.entries(questions).map(([name, question]) => [
+        name,
+        { ...question, type: question.type === "predicate" ? "noul" : question.type },
+      ]),
+    ),
+  };
+}
+
+function normalizeAnswers(raw: unknown, provider: HttpDecisionModelOptions["provider"]) {
+  if (provider === "openrouter") {
+    if (!isRecord(raw))
+      throw new DecisionUnavailableError("Decision response has no named answers");
+    return Object.fromEntries(
+      Object.entries(raw).map(([name, answer]) => [
+        name,
+        isRecord(answer) && answer.type === "noul"
+          ? { type: "predicate", probability: answer.noul }
+          : answer,
+      ]),
+    );
+  }
+  if (!Array.isArray(raw))
+    throw new DecisionUnavailableError("Decision response has no answer array");
+  const answers = Object.create(null) as Record<string, unknown>;
+  for (const value of raw) {
+    if (!isRecord(value) || typeof value.name !== "string" || Object.hasOwn(answers, value.name))
+      throw new DecisionUnavailableError("Decision response has invalid or duplicate answer names");
+    const { name, probabilities, ...answer } = value;
+    if (probabilities !== undefined) {
+      if (!Array.isArray(probabilities))
+        throw new DecisionUnavailableError("Decision response has invalid probabilities");
+      const mapped = Object.create(null) as Record<string, unknown>;
+      for (const entry of probabilities) {
+        if (
+          !isRecord(entry) ||
+          (typeof entry.value !== "string" && typeof entry.value !== "number") ||
+          Object.hasOwn(mapped, String(entry.value))
+        )
+          throw new DecisionUnavailableError("Decision response has invalid probability labels");
+        mapped[String(entry.value)] = entry.probability;
+      }
+      answer.probabilities = mapped;
+    }
+    answers[name] = answer;
+  }
+  return answers;
+}
+
+/** Real typed endpoints only. Caller cancellation is forwarded; no new timeout/retry policy. */
+export function createHttpDecisionModel(config: HttpDecisionModelOptions): DecisionModel {
+  if (!config.apiKey || !config.model)
+    throw new DecisionRequestError("Decision model and credential must be configured");
+  const endpoint =
+    config.endpoint ??
+    (config.provider === "openai" ? OPENAI_DECISIONS_ENDPOINT : OPENROUTER_DECISIONS_ENDPOINT);
+  return {
+    async decide(input, questions, options = {}) {
+      options.signal?.throwIfAborted();
+      if (!Object.keys(questions).length)
+        throw new DecisionRequestError("A decision request needs named questions");
+      const request =
+        config.provider === "openai"
+          ? openAiDecisionRequest(config.model, input, questions)
+          : openRouterDecisionRequest(config.model, input, questions);
+      let response: Response;
+      try {
+        response = await (config.fetch ?? fetch)(endpoint, {
+          method: "POST",
+          headers: { Authorization: `Bearer ${config.apiKey}`, "Content-Type": "application/json" },
+          body: JSON.stringify(request),
+          ...(options.signal ? { signal: options.signal } : {}),
+        });
+      } catch (cause) {
+        options.signal?.throwIfAborted();
+        throw new DecisionUnavailableError("Decision provider request failed", { cause });
+      }
+      if (!response.ok) {
+        await response.body?.cancel();
+        const ErrorType =
+          [401, 402, 403, 408, 429].includes(response.status) || response.status >= 500
+            ? DecisionUnavailableError
+            : DecisionRequestError;
+        throw new ErrorType(`Decision provider returned HTTP ${response.status}`, {
+          status: response.status,
+        });
+      }
+      let result: unknown;
+      try {
+        result = await response.json();
+      } catch (cause) {
+        options.signal?.throwIfAborted();
+        throw new DecisionUnavailableError("Decision provider returned invalid JSON", { cause });
+      }
+      if (!isRecord(result))
+        throw new DecisionUnavailableError("Decision provider returned an invalid response");
+      const rawUsage = isRecord(result.usage) ? result.usage : {};
+      const inputTokens = count(rawUsage.input_tokens);
+      const reportedCost =
+        typeof rawUsage.cost === "number" && Number.isFinite(rawUsage.cost) && rawUsage.cost >= 0
+          ? rawUsage.cost
+          : null;
+      const estimatedCost =
+        inputTokens !== null && config.inputUsdPerMillion !== undefined
+          ? (inputTokens * config.inputUsdPerMillion) / 1_000_000
+          : null;
+      const usage: DecisionUsage = {
+        model: typeof result.model === "string" ? result.model : config.model,
+        provider: typeof result.provider === "string" ? result.provider : config.provider,
+        ...(typeof result.id === "string" ? { requestId: result.id } : {}),
+        requests: 1,
+        inputTokens,
+        outputTokens: count(rawUsage.output_tokens),
+        costUsd: reportedCost ?? estimatedCost,
+        costSource:
+          reportedCost !== null
+            ? "provider-reported"
+            : estimatedCost !== null
+              ? "estimate"
+              : "unknown",
+      };
+      await options.onUsage?.(usage);
+      options.signal?.throwIfAborted();
+      return {
+        usage,
+        answers: validateDecisionAnswers(
+          questions,
+          normalizeAnswers(result.answers, config.provider),
+        ),
+      };
+    },
+  };
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./http";

package/src/types.ts

@@ -0,0 +1,160 @@
+/** Shared typed judgments. Consumers own rubrics and thresholds; providers own inference. */
+export type DecisionInstructions = string | Record<string, unknown> | unknown[];
+export type DecisionPredicateQuestion = {
+  type: "predicate";
+  instructions: DecisionInstructions;
+  criteria?: { true?: DecisionInstructions; false?: DecisionInstructions };
+};
+export type DecisionChoiceQuestion = {
+  type: "choice";
+  instructions: DecisionInstructions;
+  criteria: Record<string, DecisionInstructions | null>;
+};
+export type DecisionScoreQuestion = {
+  type: "score";
+  instructions: DecisionInstructions;
+  criteria: DecisionInstructions[];
+};
+export type DecisionQuestion =
+  | DecisionPredicateQuestion
+  | DecisionChoiceQuestion
+  | DecisionScoreQuestion;
+export type DecisionRefusal = { type: "refusal"; reason?: string };
+export type DecisionPredicateAnswer = { type: "predicate"; probability: number };
+export type DecisionChoiceAnswer = {
+  type: "choice";
+  choice: string;
+  probabilities?: Record<string, number>;
+  confidence?: number;
+};
+export type DecisionScoreAnswer = {
+  type: "score";
+  score: number;
+  probabilities?: Record<string, number>;
+  confidence?: number;
+};
+export type DecisionAnswer =
+  | DecisionPredicateAnswer
+  | DecisionChoiceAnswer
+  | DecisionScoreAnswer
+  | DecisionRefusal;
+export type DecisionAnswerFor<Q> =
+  | DecisionRefusal
+  | (Q extends DecisionPredicateQuestion
+      ? DecisionPredicateAnswer
+      : Q extends DecisionChoiceQuestion
+        ? DecisionChoiceAnswer
+        : DecisionScoreAnswer);
+
+export type DecisionUsage = {
+  model: string;
+  provider: string;
+  requestId?: string;
+  inputTokens: number | null;
+  outputTokens: number | null;
+  /** Successful chunks, not retry attempts. */
+  requests: number;
+  costUsd: number | null;
+  costSource: "provider-reported" | "estimate" | "unknown";
+};
+export type DecisionOptions = {
+  signal?: AbortSignal;
+  tag?: string;
+  /** Called even when a received answer is invalid. Never reconstructed on history replay. */
+  onUsage?: (usage: DecisionUsage) => void | Promise<void>;
+};
+export type DecisionResult<
+  Q extends Record<string, DecisionQuestion> = Record<string, DecisionQuestion>,
+> = {
+  answers: { [K in keyof Q]: DecisionAnswerFor<Q[K]> };
+  usage: DecisionUsage;
+};
+export interface DecisionModel {
+  decide<Q extends Record<string, DecisionQuestion>>(
+    input: unknown,
+    questions: Q,
+    options?: DecisionOptions,
+  ): Promise<DecisionResult<Q>>;
+  /** Optional provider preparation; existing code-search behavior, not required by callers. */
+  warmUp?(connections: number): void;
+}
+
+export function predicate(
+  instructions: DecisionInstructions,
+  criteria?: DecisionPredicateQuestion["criteria"],
+): DecisionPredicateQuestion {
+  return criteria
+    ? { type: "predicate", instructions, criteria }
+    : { type: "predicate", instructions };
+}
+
+export class DecisionError extends Error {
+  readonly status: number | undefined;
+  readonly code: string | undefined;
+  constructor(message: string, options: { status?: number; code?: string; cause?: unknown } = {}) {
+    super(message, options.cause === undefined ? undefined : { cause: options.cause });
+    this.name = new.target.name;
+    this.status = options.status;
+    this.code = options.code;
+  }
+}
+export class DecisionUnavailableError extends DecisionError {}
+export class DecisionRequestError extends DecisionError {}
+
+export const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === "object" && !Array.isArray(value);
+const probability = (value: unknown): value is number =>
+  typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+
+/** Validate the complete named answer set, not a convenient partial selection. */
+export function validateDecisionAnswers<Q extends Record<string, DecisionQuestion>>(
+  questions: Q,
+  answers: unknown,
+): DecisionResult<Q>["answers"] {
+  const invalid = () => {
+    throw new DecisionUnavailableError("Decision model returned invalid typed answers");
+  };
+  if (!isRecord(answers)) return invalid();
+  const names = Object.keys(questions);
+  if (Object.keys(answers).length !== names.length) return invalid();
+  for (const name of names) {
+    const answer = answers[name];
+    const question = questions[name]!;
+    if (!isRecord(answer)) return invalid();
+    if (answer.type === "refusal") {
+      if (answer.reason !== undefined && typeof answer.reason !== "string") return invalid();
+      continue;
+    }
+    if (answer.type !== question.type) return invalid();
+    if (question.type === "predicate" && !probability(answer.probability)) return invalid();
+    if (
+      question.type === "choice" &&
+      (typeof answer.choice !== "string" || !Object.hasOwn(question.criteria, answer.choice))
+    )
+      return invalid();
+    if (
+      question.type === "score" &&
+      (typeof answer.score !== "number" ||
+        !Number.isFinite(answer.score) ||
+        answer.score < 0 ||
+        answer.score > question.criteria.length - 1)
+    )
+      return invalid();
+    if (answer.confidence !== undefined && !probability(answer.confidence)) return invalid();
+    if (answer.probabilities !== undefined) {
+      if (
+        !isRecord(answer.probabilities) ||
+        Object.values(answer.probabilities).some((p) => !probability(p))
+      )
+        return invalid();
+      const allowed =
+        question.type === "choice"
+          ? Object.keys(question.criteria)
+          : question.type === "score"
+            ? question.criteria.map((_, i) => String(i))
+            : [];
+      if (Object.keys(answer.probabilities).some((key) => !allowed.includes(key))) return invalid();
+    }
+  }
+  return answers as DecisionResult<Q>["answers"];
+}