@fayegram-ai/decision-bridge 0.1.0 → 0.1.2

package/src/providers/jev.mjs

@@ -1,9 +1,11 @@
 import { optionsObject, TRANSPORT_FIELDS } from '../options.mjs';
 import { withResponseMeta, requireCondition as check } from '../errors.mjs';
-import { isRecord, validateRequest, validateResult } from '../validation.mjs';
+import { freezeJson, isRecord, validateResult } from '../validation.mjs';
 import { JsonTransport, parseBaseURL, validateApiKey } from '../transport.mjs';
 import { environmentValue } from '../runtime-env.mjs';
-import { assertCapabilities, LEGACY_CAPABILITIES } from '../capabilities.mjs';
+import { builtInCapabilities } from '../capabilities.mjs';
+import { jevDangerZone, jevHeaders, jevRequestLimit, JEV_RESULT_OPTIONS } from './jev-profile.mjs';
+import { prepareCommonJevDecision, prepareJevDecision } from './jev-preflight.mjs';
 
 /** Native TypeSafe HTTP provider: one shared-state request, no chat emulation. */
 export class JevProvider {
@@ -11,12 +13,13 @@ export class JevProvider {
   kind = 'decision';
   probabilitySource = 'native';
   #transport;
+  #options;
 
   constructor(options = {}) {
     const { apiKey,
     model = environmentValue('JEV_MODEL')?.trim() || 'jev-latest',
-    baseURL = 'https://api.typesafe.ai', ...transportOptions } = optionsObject(options,
-      ['apiKey', 'model', 'baseURL', ...TRANSPORT_FIELDS], 'Jev options');
+    baseURL = 'https://api.typesafe.ai', dangerZone, ...transportOptions } = Object.assign(Object.create(null), optionsObject(options,
+      ['apiKey', 'model', 'baseURL', 'dangerZone', ...TRANSPORT_FIELDS], 'Jev options'));
     const endpointInfo = parseBaseURL(baseURL, { originOnly: true });
     const supplied = apiKey === undefined && endpointInfo.origin === 'https://api.typesafe.ai'
       ? environmentValue('TYPESAFE_API_KEY') : apiKey;
@@ -24,20 +27,36 @@ export class JevProvider {
     check(typeof model === 'string' && model.trim(), 'model must be nonempty.', 'CONFIGURATION_ERROR');
     const endpoint = endpointInfo.baseURL;
     this.defaultModel = model.trim();
-    this.#transport = new JsonTransport({ ...transportOptions, baseURL: endpoint,
-      headers: { authorization: `Bearer ${key}` }, secrets: [key] });
+    this.#options = { model: this.defaultModel, dangerZone: jevDangerZone(dangerZone),
+        maxRequestBytes: jevRequestLimit(transportOptions.maxRequestBytes) };
+    this.#transport = new JsonTransport({ ...transportOptions, maxRequestBytes: this.#options.maxRequestBytes, baseURL: endpoint,
+      headers: { authorization: `Bearer ${key}`, ...jevHeaders(this.#options.dangerZone) }, secrets: [key] });
   }
 
   async evaluate(input, options = {}) {
-    const request = validateRequest(input, this.defaultModel);
-    assertCapabilities(request, this.getCapabilities(request.model));
-    const { data, meta } = await this.#transport.request('POST', '/v1/systemone', request, options);
-    const result = withResponseMeta(meta, () => validateResult(data, request.questions, { native: true }));
-    return { ...result, meta: { ...meta, provider: this.name, requestedModel: request.model,
-      probabilitySource: 'native', confidenceSource: 'native', modelSource: 'reported' } };
+    const prepared = prepareCommonJevDecision(input, this.#options);
+    const { decision, meta } = await this.#perform(prepared, options);
+    return freezeJson({ ...decision, meta: { ...meta, provider: this.name,
+      probabilitySource: 'native', confidenceSource: 'native', modelSource: 'reported' } });
   }
 
-  getCapabilities() { return LEGACY_CAPABILITIES; }
+  getCapabilities(model = this.defaultModel) { return builtInCapabilities('jev', model, this.#options); }
+
+  getResultValidationOptions() { return JEV_RESULT_OPTIONS; }
+
+  validateRequest(request) { prepareCommonJevDecision(request, this.#options); }
+
+  /** Native JSON assets allow images anywhere in state, instructions or criteria. */
+  async createDecision(input, options = {}) {
+    return this.#perform(prepareJevDecision(input, this.#options), options);
+  }
+
+  async #perform({ request, native }, options) {
+    const { data, meta: transport } = await this.#transport.request('POST', '/v1/systemone', native, options);
+    const meta = { ...transport, requestedModel: request.model };
+    const decision = withResponseMeta(meta, () => validateResult(data, request.questions, JEV_RESULT_OPTIONS));
+    return freezeJson({ decision, meta });
+  }
 
   async listModels(options = {}) {
     const { data, meta } = await this.#transport.request('GET', '/v1/models', undefined, options);

package/src/providers/openai-decisions.mjs

@@ -5,8 +5,9 @@ import { builtInCapabilities } from '../capabilities.mjs';
 import { JsonTransport, parseBaseURL, validateApiKey } from '../transport.mjs';
 import { environmentValue } from '../runtime-env.mjs';
 import { validateDecisionResponse } from './decisions-validation.mjs';
-import { encodeCommonDecision, decodeCommonDecision } from './decisions-codec.mjs';
-import { preflightCommonDecision, preflightDecision } from './decisions-preflight.mjs';
+import { decodeCommonDecision } from './decisions-codec.mjs';
+import { preflightCommonDecision, prepareCommonDecision, prepareDecision } from './decisions-preflight.mjs';
+import { OPENAI_DEFAULT_MODEL } from './openai-profile.mjs';
 
 /** Native Decisions transport. Common and dedicated access share a single codec. */
 export class OpenAIDecisionsProvider {
@@ -17,7 +18,7 @@ export class OpenAIDecisionsProvider {
     #maxRequestBytes;
 
     constructor(options = {}) {
-        const { apiKey, model = 'gpt-6-luna', baseURL = 'https://api.openai.com', maxRetries = 0, ...transportOptions } =
+        const { apiKey, model = OPENAI_DEFAULT_MODEL, baseURL = 'https://api.openai.com', maxRetries = 0, ...transportOptions } =
             optionsObject(options, ['apiKey', 'model', 'baseURL', ...TRANSPORT_FIELDS], 'OpenAI Decisions options');
         const endpoint = parseBaseURL(baseURL, { originOnly: true });
         const supplied = apiKey === undefined && endpoint.origin === 'https://api.openai.com'
@@ -36,16 +37,22 @@ export class OpenAIDecisionsProvider {
         preflightCommonDecision(request, { model: this.defaultModel, maxRequestBytes: this.#maxRequestBytes });
     }
 
-    async createDecision(input, options = {}) {
-        const request = preflightDecision(input, { model: this.defaultModel, maxRequestBytes: this.#maxRequestBytes });
-        const { data, meta } = await this.#transport.request('POST', '/v1/decisions', request, options);
-        const decision = withResponseMeta(meta, () => validateDecisionResponse(data, request));
+    /** Dispatch only prepared wire input; keep selection and reported identity independent. */
+    async #perform({ request, native }, options) {
+        const { data, meta: transport } = await this.#transport.request('POST', '/v1/decisions', native, options);
+        const meta = { ...transport, requestedModel: request.model, resolvedModel: native.model };
+        const decision = withResponseMeta(meta, () => validateDecisionResponse(data, native));
         return freezeJson({ decision, meta });
     }
 
+    async createDecision(input, options = {}) {
+        const prepared = prepareDecision(input, { model: this.defaultModel, maxRequestBytes: this.#maxRequestBytes });
+        return this.#perform(prepared, options);
+    }
+
     async evaluate(input, options = {}) {
-        const request = preflightCommonDecision(input, { model: this.defaultModel, maxRequestBytes: this.#maxRequestBytes });
-        const { decision, meta } = await this.createDecision(encodeCommonDecision(request), options);
-        return freezeJson(withResponseMeta(meta, () => decodeCommonDecision(decision, request, meta)));
+        const prepared = prepareCommonDecision(input, { model: this.defaultModel, maxRequestBytes: this.#maxRequestBytes });
+        const { decision, meta } = await this.#perform(prepared, options);
+        return freezeJson(withResponseMeta(meta, () => decodeCommonDecision(decision, prepared.request, meta)));
     }
 }

package/src/providers/openai-profile.mjs

@@ -0,0 +1,24 @@
+import { requireCondition as check } from '../errors.mjs';
+
+/** Release-owned selectors resolve locally; upstream responses never change this mapping. */
+export const OPENAI_DEFAULT_MODEL = 'default';
+const LUNA_MODEL = 'gpt-6-luna';
+const SELECTORS = Object.freeze({ default: LUNA_MODEL, luna: LUNA_MODEL, [LUNA_MODEL]: LUNA_MODEL });
+const PROFILES = Object.freeze({
+    [LUNA_MODEL]: Object.freeze({
+        supported: true, orderedInput: true, images: true, typedChoices: true,
+        labeledScores: true, safetyIdentifier: true,
+        maxImages: 128, maxChoiceOptions: 255, maxScoreLevels: null,
+    }),
+});
+
+/** Lookup does not throw for unsupported selections, matching capability-query semantics. */
+export function openaiModelProfile(selector) {
+    return typeof selector === 'string' && Object.hasOwn(SELECTORS, selector)
+        ? PROFILES[SELECTORS[selector]] : undefined;
+}
+
+export function resolveOpenAIModel(selector) {
+    check(openaiModelProfile(selector), 'Selected provider/model does not support this model.', 'UNSUPPORTED_CAPABILITY');
+    return SELECTORS[selector];
+}

package/src/questions.mjs

@@ -13,3 +13,5 @@ export const noul = (instructions, criteria) => build({
 });
 export const score = (instructions, criteria) => build({ type: 'score', instructions, criteria });
 export const scoreLevels = (instructions, levels) => build({ type: 'score', instructions, levels });
+/** One bounding box; use a separate noul to check whether the target is present. */
+export const box = instructions => build({ type: 'box', instructions });

package/src/validation.mjs

@@ -97,9 +97,9 @@ export function validateRequest(input, defaultModel) {
   for (const [id, q] of Object.entries(request.questions)) {
     check(nonempty(id), 'Question IDs must be nonempty.');
     check(isRecord(q), 'Every question must be an object.');
-    allowedKeys(q, q.type === 'choice' ? ['type', 'instructions', 'criteria', 'options'] :
+    allowedKeys(q, q.type === 'box' ? ['type', 'instructions'] : q.type === 'choice' ? ['type', 'instructions', 'criteria', 'options'] :
       q.type === 'score' ? ['type', 'instructions', 'criteria', 'levels'] : ['type', 'instructions', 'criteria'], 'question');
-    check(['choice', 'noul', 'score'].includes(q.type), 'Question type must be choice, noul, or score.');
+    check(['choice', 'noul', 'score', 'box'].includes(q.type), 'Question type must be choice, noul, score, or box.');
     check(own(q, 'instructions') && q.instructions !== null && isEntry(q.instructions),
       'instructions are required and must be text, a JSON object, or an array.');
     if (typeof q.instructions === 'string') check(nonempty(q.instructions), 'instructions must not be empty.');
@@ -158,7 +158,7 @@ function distribution(value, labels, decimalPlaces) {
 
 /** Validate, but do not invent, round, or normalize model results. */
 export function validateResult(input, questions, options = {}) {
-  const { native, probabilityDecimalPlaces } = validateResultOptions(options);
+  const { native, nullableUsage, probabilityDecimalPlaces } = validateResultOptions(options);
   const result = cloneJson(input, 'response', 'INVALID_RESPONSE');
   // Snapshot both sides so rubric comparison uses JSON values without executing accessors.
   const questionSnapshot = cloneJson(questions, 'questions');
@@ -168,7 +168,7 @@ export function validateResult(input, questions, options = {}) {
   check(nonempty(result.model), 'Response must include model.', 'INVALID_RESPONSE');
   exactKeys(result.answers, Object.keys(questionSnapshot), 'answers', 'INVALID_RESPONSE');
   for (const [id, q] of Object.entries(questionSnapshot)) {
-    check(isRecord(q) && ['noul', 'choice', 'score'].includes(q.type), 'A valid question type is required.');
+    check(isRecord(q) && ['noul', 'choice', 'score', 'box'].includes(q.type), 'A valid question type is required.');
     if (q.type === 'choice' && own(q, 'options')) check(Array.isArray(q.options) && q.options.length > 0 &&
       q.options.every(option => isRecord(option)), 'Typed choice requires nonempty option objects.');
     if (q.type === 'score' && own(q, 'levels')) check(Array.isArray(q.levels) && q.levels.length >= 2 &&
@@ -178,13 +178,20 @@ export function validateResult(input, questions, options = {}) {
     if (q.type === 'score' && !own(q, 'levels')) check(Array.isArray(q.criteria) && q.criteria.length >= 2 && q.criteria.length <= 10, 'score requires 2–10 levels.');
     const answer = result.answers[id];
     check(isRecord(answer) && answer.type === q.type, 'Answer type must match its question.', 'INVALID_RESPONSE');
-    allowedKeys(answer, q.type === 'noul' ? ['type', 'noul'] : q.type === 'choice'
+    allowedKeys(answer, q.type === 'box' ? ['type', 'box', 'confidence'] : q.type === 'noul' ? ['type', 'noul'] : q.type === 'choice'
       ? ['type', 'choice', 'probabilities', 'confidence'] : ['type', 'score', 'legend', 'probabilities', 'confidence'], 'answer', 'INVALID_RESPONSE');
     if (q.type === 'noul') {
       probability(answer.noul, 'noul');
       continue;
     }
     if (native || own(answer, 'confidence')) probability(answer.confidence, 'confidence');
+    if (q.type === 'box') {
+      exactKeys(answer.box, ['top', 'bottom', 'left', 'right'], 'box', 'INVALID_RESPONSE');
+      Object.values(answer.box).forEach(value => probability(value, 'box edge'));
+      check(answer.box.left < answer.box.right && answer.box.top < answer.box.bottom,
+        'Box edges must enclose a positive area.', 'INVALID_RESPONSE');
+      continue;
+    }
     if (q.type === 'choice' && q.options) {
       validateTypedChoice(answer, q.options, probabilityDecimalPlaces);
       continue;
@@ -215,7 +222,7 @@ export function validateResult(input, questions, options = {}) {
     if (own(result.usage, field)) check(Number.isSafeInteger(result.usage[field]) && result.usage[field] >= 0, 'Invalid cache token count.', 'INVALID_RESPONSE');
   }
   for (const field of ['input_tokens', 'output_tokens']) {
-    check((!native && result.usage[field] === null) ||
+    check(((!native || nullableUsage) && result.usage[field] === null) ||
       (Number.isSafeInteger(result.usage[field]) && result.usage[field] >= 0),
       'Token counts must be nonnegative safe integers.', 'INVALID_RESPONSE');
   }

package/src/version.mjs

@@ -1,2 +1,2 @@
 /** Keep in sync with package.json; scripts/check.mjs verifies the release version. */
-export const VERSION = '0.1.0';
+export const VERSION = '0.1.2';