@indexnetwork/protocol 66.0.0-rc.610.1 → 66.0.0-rc.611.1

package/dist/capabilities/intents.d.ts

@@ -18,10 +18,10 @@ import type { EmbeddingGenerator } from "../platform/discovery/embedder.js";
 import type { IntentFollowUp } from "../platform/runtime/follow-up.js";
 import { ExplicitIntentInferrer } from "../internal/intents/intent.inferrer.js";
 import { SemanticVerifier } from "../internal/intents/intent.verifier.js";
-import type { AdmissionCheck, PrepareInput, PrepareResult, RecoveryField } from "../internal/intents/intent.preparer.js";
+import type { PrepareInput, PrepareResult } from "../internal/intents/intent.preparer.js";
 export type { IntentSemanticMetadata } from "../internal/intents/intent.admission.js";
 export type { PreparedIntent } from "../internal/intents/intent.preparer.js";
-export type { AdmissionCheck, PrepareAnswer, PrepareInput, PrepareResult, RecoveryField, RecoveryFieldKind, RecoveryFieldOption, } from "../internal/intents/intent.preparer.js";
+export type { PrepareAnswer, PrepareInput, PrepareResult, RecoveryField, RecoveryFieldKind, RecoveryFieldOption, } from "../internal/intents/intent.preparer.js";
 /**
  * Host capabilities the intent lifecycle needs.
  *
@@ -421,7 +421,7 @@ export declare class Intents {
                 status: "needs_revision";
                 payload: string;
                 feedback: string;
-                recovery: RecoveryField[];
+                recovery: import("../internal/intents/intent.preparer.js").RecoveryField[];
             };
             actions: never[];
             validationFailures: {
@@ -607,10 +607,6 @@ export declare class Intents {
      * @param input - The payload and any recovery answers gathered so far.
      */
     prepare(input: PrepareInput): Promise<PrepareResult>;
-    /** Jev's pass or the constraints still missing. Does not write questions. */
-    check(input: PrepareInput): Promise<AdmissionCheck>;
-    /** One recovery field per missing constraint. Does not run Jev. */
-    questions(input: PrepareInput, missing: readonly string[]): Promise<RecoveryField[]>;
     /**
      * Measure text without applying any admission filters.
      * @param content - The exact saved description.

package/dist/capabilities/intents.js

@@ -70,16 +70,6 @@ export class Intents {
         this.preparer ?? (this.preparer = new IntentPreparer(this.deps.agents?.verifier));
         return this.preparer.invoke(input);
     }
-    /** Jev's pass or the constraints still missing. Does not write questions. */
-    async check(input) {
-        this.preparer ?? (this.preparer = new IntentPreparer(this.deps.agents?.verifier));
-        return this.preparer.check(input);
-    }
-    /** One recovery field per missing constraint. Does not run Jev. */
-    async questions(input, missing) {
-        this.preparer ?? (this.preparer = new IntentPreparer(this.deps.agents?.verifier));
-        return this.preparer.questions(input, missing);
-    }
     /**
      * Measure text without applying any admission filters.
      * @param content - The exact saved description.

package/dist/index.d.ts

@@ -29,7 +29,7 @@ export type { NegotiationDatabase } from './platform/database/negotiation.js';
 export { Networks } from "./capabilities/networks.js";
 export type { NetworksDeps } from "./capabilities/networks.js";
 export { Intents } from "./capabilities/intents.js";
-export type { AdmissionCheck, PrepareAnswer, PrepareInput, PrepareResult, RecoveryField, RecoveryFieldKind, RecoveryFieldOption, IntentsDeps, IntentSemanticMetadata, PreparedIntent, } from "./capabilities/intents.js";
+export type { PrepareAnswer, PrepareInput, PrepareResult, RecoveryField, RecoveryFieldKind, RecoveryFieldOption, IntentsDeps, IntentSemanticMetadata, PreparedIntent, } from "./capabilities/intents.js";
 export { normalizeTelegramHandle } from './internal/shared/utils/telegram-handle.js';
 /**
  * opportunity — the capability's sole cross-capability surface.

package/dist/internal/intents/graph/intent.graph.reconcile.js

@@ -34,7 +34,7 @@ export async function verificationNode(state, deps) {
                 const verdict = await deps.verifier.invoke(description, state.userProfile);
                 agentTimingsAccum.push({ name: 'intent.verifier', durationMs: Date.now() - verifierStart });
                 _traceEmitterVerifier?.({ type: "agent_end", name: "intent-verifier", durationMs: Date.now() - verifierStart, summary: `Verified: ${verdict.classification}` });
-                const failure = admissionFailure(verdict, isExplicitUpdate);
+                const failure = admissionFailure(description, verdict, isExplicitUpdate);
                 if (failure)
                     return { failure };
                 // Calculate Score

package/dist/internal/intents/intent.admission.d.ts

@@ -1,27 +1,7 @@
 import type { SemanticVerifierOutput } from "./intent.verifier.js";
 import type { IntentValidationFailure } from "./graph/intent.graph.state.js";
-/** A noul at or above this is a yes the admission check acts on. */
-export declare const ADMISSION_NOUL = 0.8;
-export declare const ADMISSION_CONSTRAINTS: readonly ["role", "outcome", "location", "timeframe", "domain", "concrete_need"];
-export type AdmissionConstraint = (typeof ADMISSION_CONSTRAINTS)[number];
-type SpeechAct = "commissive" | "directive" | "declaration" | "other";
-/** One Jev admission call, already read into numbers. */
-export interface AdmissionDecision {
-    speechAct: SpeechAct;
-    tooVague: number;
-    tooBroad: number;
-    constraints: Record<AdmissionConstraint, number>;
-}
 /** The admission policy shared by preparation and explicit updates. */
-export declare function admissionFailure(verdict: SemanticVerifierOutput, isExplicitUpdate?: boolean): IntentValidationFailure | undefined;
-/**
- * The prepare-path admission check. Constraint nouls at or above {@link ADMISSION_NOUL}
- * are still missing; they do not fail admission on their own.
- */
-export declare function admissionFromDecision(decision: AdmissionDecision): {
-    failure?: IntentValidationFailure;
-    missing: AdmissionConstraint[];
-};
+export declare function admissionFailure(description: string, verdict: SemanticVerifierOutput, isExplicitUpdate?: boolean): IntentValidationFailure | undefined;
 /** Measurements of exactly one description, independent of admission. */
 export interface IntentSemanticMetadata {
     semanticEntropy: number;
@@ -34,4 +14,3 @@ export interface IntentSemanticMetadata {
 }
 /** Map even a negative verdict to measurements without applying admission. */
 export declare function semanticMetadata(verdict: SemanticVerifierOutput): IntentSemanticMetadata;
-export {};

package/dist/internal/intents/intent.admission.js

@@ -1,42 +1,21 @@
 const MAX_PERMISSIBLE_ENTROPY = 0.75;
 const MIN_CLEAR_INTENT_SCORE = 40;
-const NON_ACTIONABLE_MESSAGE = "Describe who you want to reach and what you want to do together.";
-const VAGUE_MESSAGE = "Make the goal more concrete: specify the role, outcome, or particular help you need.";
-const BROAD_MESSAGE = "This signal is broad and may produce many weak matches. Add a more concrete role, outcome, location, timeframe, domain, or specific need to get better recommendations.";
-/** A noul at or above this is a yes the admission check acts on. */
-export const ADMISSION_NOUL = 0.8;
-export const ADMISSION_CONSTRAINTS = ["role", "outcome", "location", "timeframe", "domain", "concrete_need"];
+// Match the whole request so qualified job searches use the verifier's verdict.
+const GENERIC_JOB_PHRASE = /^(?:(?:i(?:['’]m|\s+am)?\s+)?(?:want|need|seek(?:ing)?|looking\s+for)\s+)?(?:a|any|some)\s+job[.!?]*$/i;
+const DEFAULT_SPECIFICITY_WARNING = "This signal is broad and may produce many weak matches. Add a more concrete role, outcome, location, timeframe, domain, or specific need to get better recommendations.";
 /** The admission policy shared by preparation and explicit updates. */
-export function admissionFailure(verdict, isExplicitUpdate = false) {
+export function admissionFailure(description, verdict, isExplicitUpdate = false) {
     const details = { classification: verdict.classification, referentialBreadth: verdict.referential_breadth };
     if (!["COMMISSIVE", "DIRECTIVE", "DECLARATION"].includes(verdict.classification)) {
-        return { ...details, category: "non_actionable", message: NON_ACTIONABLE_MESSAGE };
+        return { ...details, category: "non_actionable", message: "Describe who you want to reach and what you want to do together." };
     }
-    if (verdict.semantic_entropy > MAX_PERMISSIBLE_ENTROPY || verdict.felicity_scores.clarity < MIN_CLEAR_INTENT_SCORE) {
-        return { ...details, category: "vague_or_invalid", message: VAGUE_MESSAGE };
+    if (GENERIC_JOB_PHRASE.test(description.trim()) || verdict.semantic_entropy > MAX_PERMISSIBLE_ENTROPY || verdict.felicity_scores.clarity < MIN_CLEAR_INTENT_SCORE) {
+        return { ...details, category: "vague_or_invalid", message: "Make the goal more concrete: specify the role, outcome, or particular help you need." };
     }
     if (!isExplicitUpdate && verdict.referential_breadth === "broad") {
-        return { ...details, category: "vague_or_invalid", message: verdict.specificity_warning?.trim() || BROAD_MESSAGE };
+        return { ...details, category: "vague_or_invalid", message: verdict.specificity_warning?.trim() || DEFAULT_SPECIFICITY_WARNING };
     }
 }
-/**
- * The prepare-path admission check. Constraint nouls at or above {@link ADMISSION_NOUL}
- * are still missing; they do not fail admission on their own.
- */
-export function admissionFromDecision(decision) {
-    const missing = ADMISSION_CONSTRAINTS.filter((name) => decision.constraints[name] >= ADMISSION_NOUL);
-    const classification = decision.speechAct === "other" ? "UNKNOWN" : decision.speechAct.toUpperCase();
-    if (decision.speechAct === "other") {
-        return { missing, failure: { category: "non_actionable", classification, message: NON_ACTIONABLE_MESSAGE } };
-    }
-    if (decision.tooVague >= ADMISSION_NOUL) {
-        return { missing, failure: { category: "vague_or_invalid", classification, message: VAGUE_MESSAGE } };
-    }
-    if (decision.tooBroad >= ADMISSION_NOUL) {
-        return { missing, failure: { category: "vague_or_invalid", classification, referentialBreadth: "broad", message: BROAD_MESSAGE } };
-    }
-    return { missing };
-}
 /** Map even a negative verdict to measurements without applying admission. */
 export function semanticMetadata(verdict) {
     return {

package/dist/internal/intents/intent.preparer.d.ts

@@ -1,5 +1,4 @@
-import { DecisionClient } from "../shared/agent/decision.client.js";
-import { type AdmissionConstraint, type IntentSemanticMetadata } from "./intent.admission.js";
+import { type IntentSemanticMetadata } from "./intent.admission.js";
 import { SemanticVerifier } from "./intent.verifier.js";
 /** One answer paired with the recovery field it fills. */
 export interface PrepareAnswer {
@@ -38,40 +37,16 @@ export type PrepareResult = {
     feedback: string;
     recovery: RecoveryField[];
 };
-/** Jev's read of the current rows. `passed` is the only state that may mint a receipt. */
-export interface AdmissionCheck {
-    passed: boolean;
-    missing: AdmissionConstraint[];
-    message: string;
-}
 /** Folds recovery answers into a draft, admits its final form, and returns a dynamic recovery form on failure. Model failures propagate for retry. */
 export declare class IntentPreparer {
     private readonly verifier;
-    private readonly decider;
-    constructor(verifier?: Pick<SemanticVerifier, "invoke">, decider?: Pick<DecisionClient, "decide">);
-    /**
-     * Ask Jev whether the current rows would pass. Does not fold text or write questions.
-     * @param input - Opening draft and the answers already on the page.
-     * @param profileContext - The speaker's profile, if supplied by the host.
-     * @throws When Jev fails; the caller keeps the rows and retries.
-     */
-    check(input: PrepareInput, profileContext?: string): Promise<AdmissionCheck>;
-    /**
-     * Write one recovery field per constraint id. Does not run Jev.
-     * @param input - Opening draft and the answers already on the page.
-     * @param missing - Constraint ids that still need a row.
-     */
-    questions(input: PrepareInput, missing: readonly string[]): Promise<RecoveryField[]>;
+    constructor(verifier?: Pick<SemanticVerifier, "invoke">);
     /**
-     * Fold answers, admit the draft, and return a recovery form when it still fails.
+     * Prepare one draft using the creation admission policy.
      * @param input - Current payload and pending recovery answers.
      * @param profileContext - The speaker's profile, if supplied by the host.
+     * @returns An admitted draft or admission feedback plus a recovery form.
      * @throws When rewriting, verification, or recovery generation fails; callers must retain the input for retry.
      */
     invoke(input: PrepareInput, profileContext?: string): Promise<PrepareResult>;
-    /** Today's recovery form, used only when the Jev call itself fails. */
-    private legacy;
-    /** One field per constraint still missing. None named means one text field from the admission message. */
-    private revise;
-    private fieldsFor;
 }

package/dist/internal/intents/intent.preparer.js

@@ -1,9 +1,8 @@
 import { HumanMessage, SystemMessage } from "@langchain/core/messages";
 import { z } from "zod";
-import { DecisionClient } from "../shared/agent/decision.client.js";
 import { createStructuredModel } from "../shared/agent/model.config.js";
 import { invokeWithAbortSignal } from "../shared/agent/model-signal.js";
-import { ADMISSION_CONSTRAINTS, admissionFailure, admissionFromDecision, semanticMetadata } from "./intent.admission.js";
+import { admissionFailure, semanticMetadata } from "./intent.admission.js";
 import { SemanticVerifier } from "./intent.verifier.js";
 const payloadSchema = z.object({ payload: z.string().trim().min(1).max(65536) });
 const recoveryOptionSchema = z.object({
@@ -18,107 +17,34 @@ const recoveryFieldSchema = z.object({
     placeholder: z.string().max(200).nullable().optional(),
 });
 const recoverySchema = z.object({
-    recovery: z.array(recoveryFieldSchema).min(1).max(6),
-});
-const legacyRecoverySchema = z.object({
     recovery: z.array(recoveryFieldSchema).min(2).max(6),
 });
-const noul = (instructions, yes, no) => ({
-    type: "noul",
-    instructions: `Read \`draft\` and \`answers\` together. ${instructions}`,
-    criteria: { true: yes, false: no },
-});
-/** The admission process: the same questions judge the opening draft and a draft after answers. */
-const ADMISSION_QUESTIONS = {
-    speech_act: {
-        type: "choice",
-        instructions: "Read `draft` and `answers` together. What speech act is `draft`?",
-        criteria: {
-            commissive: "The speaker commits to a future action.",
-            directive: "The speaker is looking for someone, or asking for something to happen with another person.",
-            declaration: "The speaker cancels, closes, or declares a state change.",
-            other: "A fact, opinion, feeling, or anything that is not a search, a commitment, or a declaration.",
-        },
-    },
-    too_vague: noul("Is `draft` still too unconstrained to match someone on? A bare request, such as wanting a job with no role or outcome, is too vague.", "The goal is too unconstrained to match on.", "The goal names a concrete role, outcome, or particular help."),
-    too_broad: noul("Could many people still satisfy `draft`, even if it names a topic?", "Many people could plausibly match.", "A concrete role, outcome, location, timeframe, or specific need narrows who fits."),
-    role: noul("Is a specific role still missing from `draft`?", "No specific role is stated.", "A specific role is stated."),
-    outcome: noul("Is a concrete outcome still missing from `draft`?", "No concrete outcome is stated.", "A concrete outcome is stated."),
-    location: noul("Is a location still missing from `draft` where one would change who fits?", "No location is stated and one would change who fits.", "A location is stated, or none is needed."),
-    timeframe: noul("Is a timeframe still missing from `draft` where one would change who fits?", "No timeframe is stated and one would change who fits.", "A timeframe is stated, or none is needed."),
-    domain: noul("Is a domain still missing from `draft`?", "No domain is stated.", "A domain is stated."),
-    concrete_need: noul("Is the particular help still missing from `draft`?", "The particular help is not stated.", "The particular help is stated."),
-};
-function parseRecoveryFields(fields) {
-    return fields.map((field) => {
+function parseRecoveryFields(result) {
+    return result.recovery.map((field) => {
         const placeholder = field.placeholder?.trim() || undefined;
         const options = field.options?.length ? field.options : undefined;
         if (field.kind === "text") {
-            if (!placeholder)
+            if (!placeholder) {
                 throw new Error("Text recovery fields require a placeholder.");
+            }
             return { id: field.id, label: field.label, kind: field.kind, placeholder };
         }
-        if (!options?.length)
+        if (!options?.length) {
             throw new Error("Single and multi recovery fields require options.");
+        }
         return { id: field.id, label: field.label, kind: field.kind, options };
     });
 }
-function readDecision(answers) {
-    const speech = answers.speech_act;
-    const speechAct = speech?.type === "choice" ? speech.choice : "";
-    if (speechAct !== "commissive" && speechAct !== "directive" && speechAct !== "declaration" && speechAct !== "other") {
-        throw new Error("Jev speech_act answer was unusable");
-    }
-    const probability = (key) => {
-        const answer = answers[key];
-        if (!answer || answer.type !== "noul")
-            throw new Error(`Jev ${key} answer was unusable`);
-        return answer.noul;
-    };
-    const constraints = Object.fromEntries(ADMISSION_CONSTRAINTS.map((name) => [name, probability(name)]));
-    return { speechAct, tooVague: probability("too_vague"), tooBroad: probability("too_broad"), constraints };
-}
-function textField(message) {
-    return { id: "detail", label: message, kind: "text", placeholder: "Add the missing detail" };
-}
-function isAbort(error) {
-    return error instanceof Error && error.name === "AbortError";
-}
 /** Folds recovery answers into a draft, admits its final form, and returns a dynamic recovery form on failure. Model failures propagate for retry. */
 export class IntentPreparer {
-    constructor(verifier = new SemanticVerifier(), decider = new DecisionClient()) {
+    constructor(verifier = new SemanticVerifier()) {
         this.verifier = verifier;
-        this.decider = decider;
     }
     /**
-     * Ask Jev whether the current rows would pass. Does not fold text or write questions.
-     * @param input - Opening draft and the answers already on the page.
-     * @param profileContext - The speaker's profile, if supplied by the host.
-     * @throws When Jev fails; the caller keeps the rows and retries.
-     */
-    async check(input, profileContext = "") {
-        const answers = (input.answers ?? []).filter((answer) => answer.answer.trim());
-        const judged = admissionFromDecision(readDecision(await this.decider.decide({ draft: input.payload, answers, profile: profileContext }, ADMISSION_QUESTIONS)));
-        if (!judged.failure)
-            return { passed: true, missing: [], message: "" };
-        return { passed: false, missing: judged.missing, message: judged.failure.message };
-    }
-    /**
-     * Write one recovery field per constraint id. Does not run Jev.
-     * @param input - Opening draft and the answers already on the page.
-     * @param missing - Constraint ids that still need a row.
-     */
-    async questions(input, missing) {
-        const answers = (input.answers ?? []).filter((answer) => answer.answer.trim());
-        const constraints = [...new Set(missing)].filter((id) => ADMISSION_CONSTRAINTS.includes(id));
-        if (!constraints.length)
-            return [];
-        return this.fieldsFor(input.payload, answers, "", constraints);
-    }
-    /**
-     * Fold answers, admit the draft, and return a recovery form when it still fails.
+     * Prepare one draft using the creation admission policy.
      * @param input - Current payload and pending recovery answers.
      * @param profileContext - The speaker's profile, if supplied by the host.
+     * @returns An admitted draft or admission feedback plus a recovery form.
      * @throws When rewriting, verification, or recovery generation fails; callers must retain the input for retry.
      */
     async invoke(input, profileContext = "") {
@@ -132,28 +58,11 @@ export class IntentPreparer {
             ]);
             payload = payloadSchema.parse(result).payload;
         }
-        let jevFailed = false;
-        try {
-            const judged = admissionFromDecision(readDecision(await this.decider.decide({ draft: payload, profile: profileContext }, ADMISSION_QUESTIONS)));
-            if (judged.failure)
-                return this.revise(payload, answers, judged.failure.message, judged.missing);
-        }
-        catch (error) {
-            if (isAbort(error))
-                throw error;
-            jevFailed = true;
-        }
         const verdict = await this.verifier.invoke(payload, profileContext);
-        const failure = admissionFailure(verdict);
+        const failure = admissionFailure(payload, verdict);
         if (!failure)
             return { status: "ready", payload, metadata: semanticMetadata(verdict) };
-        if (jevFailed)
-            return this.legacy(payload, answers, failure, verdict);
-        return this.revise(payload, answers, failure.message, verdict.missing_selectional_constraints);
-    }
-    /** Today's recovery form, used only when the Jev call itself fails. */
-    async legacy(payload, answers, failure, verdict) {
-        const model = createStructuredModel("intentClarifier", legacyRecoverySchema, { name: "intent_recovery" });
+        const model = createStructuredModel("intentClarifier", recoverySchema, { name: "intent_recovery" });
         const result = await invokeWithAbortSignal(model, [
             new SystemMessage("Build one recovery form that helps the person concretize their signal. Return 2-6 fields. Each field needs a draft-specific label, a kind (single, multi, or text), and for single/multi 2-5 concrete options anchored to the draft. Text fields need a placeholder. Never re-ask what the draft or answers already settle. Options must be matchable and specific. Do not expose scores, classifications, JSON, or internal vocabulary."),
             new HumanMessage(JSON.stringify({
@@ -168,27 +77,11 @@ export class IntentPreparer {
                 missingConstraints: verdict.missing_selectional_constraints,
             })),
         ]);
-        return { status: "needs_revision", payload, feedback: failure.message, recovery: parseRecoveryFields(legacyRecoverySchema.parse(result).recovery) };
-    }
-    /** One field per constraint still missing. None named means one text field from the admission message. */
-    async revise(payload, answers, feedback, missing) {
-        const constraints = [...new Set(missing)];
-        const recovery = constraints.length === 0
-            ? [textField(feedback)]
-            : await this.fieldsFor(payload, answers, feedback, constraints);
-        return { status: "needs_revision", payload, feedback, recovery };
-    }
-    async fieldsFor(payload, answers, feedback, constraints) {
-        const model = createStructuredModel("intentClarifier", recoverySchema, { name: "intent_recovery" });
-        const result = await invokeWithAbortSignal(model, [
-            new SystemMessage(`Write one recovery field for each missing constraint, in this order: ${constraints.join(", ")}. Set each field's id to that constraint name. Each field needs a draft-specific label, a kind (single, multi, or text), and for single/multi 2-5 concrete options anchored to the draft. Text fields need a placeholder. Do not add any other field. Never re-ask what the draft or answers already settle. Do not expose scores, classifications, JSON, or internal vocabulary.`),
-            new HumanMessage(JSON.stringify({ payload, answers, feedback, missingConstraints: constraints })),
-        ]);
-        const fields = parseRecoveryFields(recoverySchema.parse(result).recovery);
-        const byId = new Map(fields.map((field) => [field.id, field]));
-        const matched = constraints.map((id) => byId.get(id));
-        if (matched.some((field) => !field))
-            throw new Error("Recovery fields did not cover the missing constraints.");
-        return matched;
+        return {
+            status: "needs_revision",
+            payload,
+            feedback: failure.message,
+            recovery: parseRecoveryFields(recoverySchema.parse(result)),
+        };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indexnetwork/protocol",
-  "version": "66.0.0-rc.610.1",
+  "version": "66.0.0-rc.611.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/dist/internal/shared/agent/decision.client.d.ts

@@ -1,42 +0,0 @@
-export type DecisionQuestion = {
-    type: "noul";
-    instructions: string;
-    criteria?: {
-        true: string;
-        false: string;
-    };
-} | {
-    type: "choice";
-    instructions: string;
-    criteria: Record<string, string>;
-} | {
-    type: "score";
-    instructions: string;
-    criteria: string[];
-};
-export type DecisionAnswer = {
-    type: "noul";
-    noul: number;
-} | {
-    type: "choice";
-    choice: string;
-} | {
-    type: "score";
-    score: number;
-};
-/**
- * Jev, through OpenRouter's Decisions API. It returns typed answers, not text.
- * A missing key, a bad response, or a timeout throws. Callers keep their own fallback.
- */
-export declare class DecisionClient {
-    private readonly apiKey?;
-    private readonly timeout;
-    constructor(apiKey?: string | undefined, timeout?: number);
-    /**
-     * @param state - The draft and whatever else the questions refer to.
-     * @param questions - Named noul, choice, or score questions.
-     * @param signal - Cancels this call. A request-scoped signal is used when this is omitted.
-     * @returns One answer per question key.
-     */
-    decide(state: unknown, questions: Record<string, DecisionQuestion>, signal?: AbortSignal): Promise<Record<string, DecisionAnswer>>;
-}

package/dist/internal/shared/agent/decision.client.js

@@ -1,61 +0,0 @@
-import { getAbortSignalConfig } from "./model-signal.js";
-const DECISIONS_URL = "https://openrouter.ai/api/alpha/decisions";
-const JEV_MODEL = "typesafe/jev-1.13";
-const TIMEOUT_MS = 60000;
-/**
- * Jev, through OpenRouter's Decisions API. It returns typed answers, not text.
- * A missing key, a bad response, or a timeout throws. Callers keep their own fallback.
- */
-export class DecisionClient {
-    constructor(apiKey, timeout = TIMEOUT_MS) {
-        this.apiKey = apiKey;
-        this.timeout = timeout;
-    }
-    /**
-     * @param state - The draft and whatever else the questions refer to.
-     * @param questions - Named noul, choice, or score questions.
-     * @param signal - Cancels this call. A request-scoped signal is used when this is omitted.
-     * @returns One answer per question key.
-     */
-    async decide(state, questions, signal) {
-        const apiKey = this.apiKey ?? process.env.OPENROUTER_API_KEY;
-        if (!apiKey?.trim())
-            throw new Error("DecisionClient: OPENROUTER_API_KEY is required.");
-        const caller = signal ?? getAbortSignalConfig()?.signal;
-        const deadline = AbortSignal.timeout(this.timeout);
-        const stop = caller ? AbortSignal.any([caller, deadline]) : deadline;
-        const response = await fetch(DECISIONS_URL, {
-            method: "POST",
-            signal: stop,
-            headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
-            body: JSON.stringify({ model: JEV_MODEL, state, questions }),
-        });
-        const body = await response.text();
-        let data = {};
-        try {
-            data = JSON.parse(body);
-        }
-        catch {
-            if (response.ok)
-                throw new Error(`Jev returned a non-JSON response: ${body.slice(0, 500)}`);
-        }
-        if (!response.ok || data.error || !data.answers) {
-            throw new Error(`Jev request failed (${response.status}): ${(data.error?.message ?? body).slice(0, 500)}`);
-        }
-        return readAnswers(data.answers);
-    }
-}
-function readAnswers(raw) {
-    const answers = {};
-    for (const [key, answer] of Object.entries(raw)) {
-        if (answer?.type === "noul" && typeof answer.noul === "number")
-            answers[key] = { type: "noul", noul: answer.noul };
-        else if (answer?.type === "choice" && typeof answer.choice === "string")
-            answers[key] = { type: "choice", choice: answer.choice };
-        else if (answer?.type === "score" && typeof answer.score === "number")
-            answers[key] = { type: "score", score: answer.score };
-        else
-            throw new Error(`Jev answer "${key}" was unusable`);
-    }
-    return answers;
-}