@fayegram-ai/decision-bridge 0.1.1 → 0.1.3

package/src/bridge.mjs

@@ -9,6 +9,9 @@ import { assertCapabilities, commonSchemaVersion, providerCapabilities } from '.
 import { validateResultOptions } from './probabilities.mjs';
 
 const elapsed = start => Math.round((performance.now() - start) * 1000) / 1000;
+const inputField = request => Object.hasOwn(request, 'state') ? 'state'
+    : Object.hasOwn(request, 'conversation') ? 'conversation' : 'input';
+const inputMethod = request => ({ state: 'prepareState', input: 'prepareInput', conversation: 'prepareConversation' })[inputField(request)];
 
 /** Stable interface. Prepare context, evaluate, validate, then observe immutable results. */
 export function createBridge(options) {
@@ -26,11 +29,11 @@ export function createBridge(options) {
     'Bridge timeouts must be positive 32-bit integers.', 'CONFIGURATION_ERROR');
   check(Array.isArray(extensions), 'extensions must be an array.', 'CONFIGURATION_ERROR');
   const registered = Array.from(extensions, extension => {
-    optionsObject(extension, ['name', 'prepareState', 'prepareInput', 'onResult'], 'Extension');
+    optionsObject(extension, ['name', 'prepareState', 'prepareInput', 'prepareConversation', 'onResult'], 'Extension');
     check(isRecord(extension) && typeof extension.name === 'string' && extension.name.trim() &&
       extension.name.length <= 100 && !/[\x00-\x1f\x7f]/.test(extension.name),
     'Each extension requires a printable name up to 100 characters.', 'CONFIGURATION_ERROR');
-    for (const method of ['prepareState', 'prepareInput', 'onResult']) check(extension[method] === undefined || typeof extension[method] === 'function',
+    for (const method of ['prepareState', 'prepareInput', 'prepareConversation', 'onResult']) check(extension[method] === undefined || typeof extension[method] === 'function',
       'Extension handlers must be functions.', 'CONFIGURATION_ERROR');
     return { ...extension };
   });
@@ -39,9 +42,9 @@ export function createBridge(options) {
   function validate(input) {
     const request = validateRequest(input, backend.defaultModel ?? '');
     assertCapabilities(request, providerCapabilities(backend, request.model));
-    const method = Object.hasOwn(request, 'state') ? 'prepareState' : 'prepareInput';
+    const method = inputMethod(request);
     for (const extension of registered) {
-      check(!(extension.prepareState || extension.prepareInput) || typeof extension[method] === 'function',
+      check(!(extension.prepareState || extension.prepareInput || extension.prepareConversation) || typeof extension[method] === 'function',
         `Preparation extension ${extension.name} cannot handle this input form.`, 'UNSUPPORTED_CAPABILITY');
     }
     freezeJson(request);
@@ -80,8 +83,8 @@ export function createBridge(options) {
           questionIds: Object.freeze(Object.keys(request.questions)), signal: budget.signal });
         for (const extension of registered) {
           budget.throwIfAborted();
-          const field = Object.hasOwn(request, 'state') ? 'state' : 'input';
-          const method = field === 'state' ? 'prepareState' : 'prepareInput';
+          const field = inputField(request);
+          const method = inputMethod(request);
           if (!extension[method]) continue;
           let prepared;
           try {

package/src/capabilities.mjs

@@ -2,6 +2,7 @@ import { DecisionError, requireCondition as check } from './errors.mjs';
 import { cloneJson, freezeJson, isRecord } from './validation.mjs';
 import { CLOUDFLARE_MODELS } from './providers/cloudflare-profile.mjs';
 import { openaiModelProfile } from './providers/openai-profile.mjs';
+import { jevFeatures } from './providers/jev-profile.mjs';
 
 /** Conservative defaults preserve the pre-existing custom-provider contract. */
 export const LEGACY_CAPABILITIES = freezeJson({
@@ -9,20 +10,25 @@ export const LEGACY_CAPABILITIES = freezeJson({
     labeledScores: false, safetyIdentifier: false,
     maxImages: 0, maxChoiceOptions: 255, maxScoreLevels: 10,
     audio: false, videos: false, maxAudioClips: 0, maxVideos: 0,
+    boxes: false,
+    conversation: false, toolHistory: false, remoteImages: false, promptCaching: false,
 });
 
 const CLOUDFLARE_CAPABILITIES = freezeJson({
     supported: true, orderedInput: true, images: true, typedChoices: true,
-    labeledScores: true, safetyIdentifier: false, maxImages: 4, maxChoiceOptions: 255, maxScoreLevels: 10,
+    labeledScores: true, safetyIdentifier: false, maxImages: null, maxChoiceOptions: null, maxScoreLevels: null,
 });
 
-export function builtInCapabilities(type, model) {
+export function builtInCapabilities(type, model, options = {}) {
+    if (type === 'jev') return freezeJson({ ...LEGACY_CAPABILITIES,
+        ...jevFeatures(model, Object.hasOwn(options, 'dangerZone') ? options.dangerZone : undefined),
+        maxChoiceOptions: null, maxScoreLevels: null });
     if (type === 'cloudflare-decisions') {
         const key = typeof model === 'string' ? model.trim().replace(/^@cf\/cloudflare\//, '') : '';
         const profile = Object.hasOwn(CLOUDFLARE_MODELS, key) ? CLOUDFLARE_MODELS[key] : undefined;
         return freezeJson({ ...LEGACY_CAPABILITIES, ...CLOUDFLARE_CAPABILITIES, supported: !!profile,
             audio: profile?.omni ?? false, videos: profile?.omni ?? false,
-            maxAudioClips: profile?.omni ? 4 : 0, maxVideos: profile?.omni ? 2 : 0 });
+            maxAudioClips: profile?.omni ? null : 0, maxVideos: profile?.omni ? null : 0 });
     }
     if (type !== 'openai-decisions') return LEGACY_CAPABILITIES;
     const profile = openaiModelProfile(model);
@@ -45,7 +51,8 @@ export function providerCapabilities(provider, model) {
     check(isRecord(profile) && Object.keys(profile).every(key => Object.hasOwn(LEGACY_CAPABILITIES, key)),
         'Invalid capability profile.', 'CONFIGURATION_ERROR');
     const result = { ...LEGACY_CAPABILITIES, ...profile };
-    for (const key of ['supported', 'orderedInput', 'images', 'typedChoices', 'labeledScores', 'safetyIdentifier', 'audio', 'videos']) {
+    for (const key of ['supported', 'orderedInput', 'images', 'typedChoices', 'labeledScores', 'safetyIdentifier', 'audio', 'videos', 'boxes',
+        'conversation', 'toolHistory', 'remoteImages', 'promptCaching']) {
         check(typeof result[key] === 'boolean', 'Capability flags must be boolean.', 'CONFIGURATION_ERROR');
     }
     for (const key of ['maxImages', 'maxChoiceOptions', 'maxScoreLevels', 'maxAudioClips', 'maxVideos']) {
@@ -60,9 +67,27 @@ export function assertCapabilities(request, capabilities) {
     const requireFeature = (condition, feature) => check(condition,
         `Selected provider/model does not support ${feature}.`, 'UNSUPPORTED_CAPABILITY');
     requireFeature(capabilities.supported, 'this model');
+    if (Object.hasOwn(request, 'conversation')) {
+        requireFeature(capabilities.conversation, 'conversation input');
+        if (request.conversation.some(item => !Object.hasOwn(item, 'role'))) requireFeature(capabilities.toolHistory, 'tool history');
+        const parts = request.conversation.flatMap(item => Array.isArray(item.content) ? item.content
+            : Array.isArray(item.output) ? item.output : []);
+        const images = parts.filter(part => part.type === 'input_image');
+        if (images.length) requireFeature(capabilities.images, 'image input');
+        requireFeature(capabilities.maxImages === null || images.length <= capabilities.maxImages, 'this image count');
+        if (parts.some(part => part.type === 'input_image' && /^https?:/i.test(part.image_url))) {
+            requireFeature(capabilities.remoteImages, 'remote images');
+        }
+        if (parts.some(part => Object.hasOwn(part, 'prompt_cache_breakpoint'))) requireFeature(capabilities.promptCaching, 'prompt caching');
+    }
+    if (Object.hasOwn(request, 'promptCacheKey') || Object.hasOwn(request, 'promptCacheOptions') ||
+        request.input?.some(part => Object.hasOwn(part, 'promptCacheBreakpoint'))) requireFeature(capabilities.promptCaching, 'prompt caching');
     if (Object.hasOwn(request, 'input')) {
         requireFeature(capabilities.orderedInput, 'ordered input');
         const images = request.input.filter(part => part.type === 'image').length;
+        if (request.input.some(part => part.type === 'image' && Object.hasOwn(part, 'url'))) {
+            requireFeature(capabilities.remoteImages, 'remote images');
+        }
         if (images) requireFeature(capabilities.images, 'image input');
         requireFeature(capabilities.maxImages === null || images <= capabilities.maxImages, 'this image count');
         for (const [kind, flag, limit] of [['audio', 'audio', 'maxAudioClips'], ['video', 'videos', 'maxVideos']]) {
@@ -75,6 +100,7 @@ export function assertCapabilities(request, capabilities) {
     }
     if (Object.hasOwn(request, 'safetyIdentifier')) requireFeature(capabilities.safetyIdentifier, 'safetyIdentifier');
     for (const q of Object.values(request.questions)) {
+        if (q.type === 'box') requireFeature(capabilities.boxes, 'box questions');
         if (q.options) requireFeature(capabilities.typedChoices, 'typed choices');
         if (q.levels) requireFeature(capabilities.labeledScores, 'labelled scores');
         const choices = q.options?.length ?? (q.type === 'choice' ? Object.keys(q.criteria).length : 0);
@@ -86,6 +112,10 @@ export function assertCapabilities(request, capabilities) {
 }
 
 export function commonSchemaVersion(request) {
+    if (Object.hasOwn(request, 'conversation') || Object.hasOwn(request, 'promptCacheKey') ||
+        Object.hasOwn(request, 'promptCacheOptions') || request.input?.some(part =>
+        Object.hasOwn(part, 'url') || Object.hasOwn(part, 'promptCacheBreakpoint'))) return 5;
+    if (Object.values(request.questions).some(q => q.type === 'box')) return 4;
     if (request.input?.some(part => ['audio', 'video'].includes(part.type))) return 3;
     return Object.hasOwn(request, 'input') || Object.hasOwn(request, 'safetyIdentifier') ||
         Object.values(request.questions).some(q => q.options || q.levels) ? 2 : 1;

package/src/cli/config-validation.mjs

@@ -2,17 +2,18 @@ import { requireCondition as check } from '../errors.mjs';
 import { cloneJson, isRecord } from '../validation.mjs';
 import { cloudflareGateway, validateCloudflareLimits } from '../providers/cloudflare-profile.mjs';
 import { generationOptions } from '../custom/generative/shared.mjs';
+import { jevDangerZone, jevRequestLimit } from '../providers/jev-profile.mjs';
 
-export const PROVIDERS = ['jev', 'openai-decisions', 'cloudflare-decisions', 'custom-decision', 'custom-generative'];
+export const PROVIDERS = ['jev', 'openai-decisions', 'cloudflare-decisions', 'cloudflare-extraction', 'custom-decision', 'custom-generative'];
 export const PRESETS = ['openai-compatible', 'openrouter', 'anthropic'];
 export const TRANSPORT = ['baseURL', 'maxRetries', 'maxRequestBytes', 'maxResponseBytes'];
 export const GENERATION = ['maxTokens', 'responseFormat', 'tokenParameter', 'parameters', 'noAuth'];
 export const PROVIDER_FIELDS = [...TRANSPORT, ...GENERATION, 'apiKeyEnv', 'model', 'preset', 'module',
-    'options', 'accountId', 'rejectIfBusy', 'gateway'];
+    'options', 'accountId', 'rejectIfBusy', 'gateway', 'dangerZone'];
 const FIELDS = new Set(['$schema', 'schemaVersion', 'provider', 'timeoutMs', ...PROVIDER_FIELDS]);
 export const NUMERIC = new Set(['timeoutMs', 'maxRetries', 'maxRequestBytes', 'maxResponseBytes', 'maxTokens']);
 export const KEY_ENVS = { jev: 'TYPESAFE_API_KEY', 'openai-decisions': 'OPENAI_API_KEY',
-    'cloudflare-decisions': 'CLOUDFLARE_API_TOKEN', 'openai-compatible': 'OPENAI_API_KEY',
+    'cloudflare-decisions': 'CLOUDFLARE_API_TOKEN', 'cloudflare-extraction': 'CLOUDFLARE_API_TOKEN', 'openai-compatible': 'OPENAI_API_KEY',
     openrouter: 'OPENROUTER_API_KEY', anthropic: 'ANTHROPIC_API_KEY' };
 export const isModule = config => ['custom-decision', 'custom-generative'].includes(config.provider) && config.module !== undefined;
 
@@ -56,9 +57,16 @@ export function validateConfig(input, { complete = false } = {}) {
     check(config.module === undefined || ['custom-decision', 'custom-generative'].includes(config.provider),
         'module requires custom-decision or custom-generative.', 'CONFIGURATION_ERROR');
     check(config.options === undefined || isModule(config), 'options requires a custom provider module.', 'CONFIGURATION_ERROR');
+    // Validate nested shape even when a partial file omits its provider selector.
+    if (Object.hasOwn(config, 'dangerZone')) config.dangerZone = jevDangerZone(config.dangerZone);
     if (config.provider !== undefined) {
-        if (config.provider !== 'cloudflare-decisions') check(['accountId', 'rejectIfBusy', 'gateway'].every(key => config[key] === undefined),
-            'Cloudflare settings require cloudflare-decisions.', 'CONFIGURATION_ERROR');
+        if (config.provider !== 'jev') check(!Object.hasOwn(config, 'dangerZone'),
+            'dangerZone requires Jev.', 'CONFIGURATION_ERROR');
+        else {
+            jevRequestLimit(config.maxRequestBytes);
+        }
+        if (!['cloudflare-decisions', 'cloudflare-extraction'].includes(config.provider)) check(['accountId', 'rejectIfBusy', 'gateway'].every(key => config[key] === undefined),
+            'Cloudflare settings require a Cloudflare provider.', 'CONFIGURATION_ERROR');
         else {
             config.gateway = cloudflareGateway(config.gateway);
             if (config.gateway === undefined) delete config.gateway;

package/src/cli/config.mjs

@@ -4,6 +4,7 @@ import { parseEnv } from 'node:util';
 import { OPENAI_DEFAULT_MODEL } from '../providers/openai-profile.mjs';
 import { DecisionError, requireCondition as check } from '../errors.mjs';
 import { validateConfig, NUMERIC, PROVIDER_FIELDS } from './config-validation.mjs';
+import { jevDangerZone } from '../providers/jev-profile.mjs';
 export { validateConfig } from './config-validation.mjs';
 export { configuredProvider } from './provider-loader.mjs';
 
@@ -12,6 +13,7 @@ const ENV_FIELDS = {
     DECISION_API_KEY_ENV: 'apiKeyEnv', DECISION_TIMEOUT_MS: 'timeoutMs',
     DECISION_MAX_RETRIES: 'maxRetries', DECISION_RESPONSE_FORMAT: 'responseFormat',
     DECISION_ACCOUNT_ID: 'accountId', DECISION_REJECT_IF_BUSY: 'rejectIfBusy', DECISION_GATEWAY_ID: 'gateway',
+    DECISION_JEV_IMAGES: 'jevImages', DECISION_JEV_LONG_CONTEXT: 'jevLongContext',
 };
 
 async function boundedFile(path, maxBytes, label) {
@@ -28,7 +30,8 @@ async function boundedFile(path, maxBytes, label) {
 }
 
 /** Explicit file only. Flags > DECISION_* environment > file > defaults. */
-export async function loadConfig({ configPath, envFile, overrides = {}, cwd = process.cwd(), env = process.env, allowIncomplete = false } = {}) {
+export async function loadConfig({ configPath, envFile, overrides = {}, cwd = process.cwd(), env = process.env, allowIncomplete = false,
+  defaultProvider = 'jev' } = {}) {
   const effectiveEnv = { ...env };
   if (envFile) {
     const text = await boundedFile(resolve(cwd, envFile), 65536, 'environment file');
@@ -47,13 +50,17 @@ export async function loadConfig({ configPath, envFile, overrides = {}, cwd = pr
     fileConfig = validateConfig(fileConfig);
     moduleBase = dirname(path);
   }
-  const environment = {};
+  const environment = Object.create(null);
   for (const [key, field] of Object.entries(ENV_FIELDS)) {
     if (effectiveEnv[key] === undefined) continue;
     const value = effectiveEnv[key];
     if (NUMERIC.has(field)) check(typeof value === 'string' && /^\d+$/.test(value),
       'Numeric DECISION_* variables must contain decimal integers.', 'CONFIGURATION_ERROR');
-    if (field === 'rejectIfBusy') {
+    if (field === 'jevImages' || field === 'jevLongContext') {
+      check(value === 'true' || value === 'false', 'Jev DECISION_* flags must be true or false.', 'CONFIGURATION_ERROR');
+      environment.dangerZone = { ...(Object.hasOwn(environment, 'dangerZone') ? environment.dangerZone : {}),
+        [field === 'jevImages' ? 'images' : 'longContext']: value === 'true' };
+    } else if (field === 'rejectIfBusy') {
       check(value === 'true' || value === 'false', 'DECISION_REJECT_IF_BUSY must be true or false.', 'CONFIGURATION_ERROR');
       environment[field] = value === 'true';
     } else environment[field] = field === 'gateway' ? { id: value } : NUMERIC.has(field) ? Number(value) : value;
@@ -62,6 +69,10 @@ export async function loadConfig({ configPath, envFile, overrides = {}, cwd = pr
   // environment-selected provider must not inherit that provider's key/endpoint.
   function mergeProviderLayer(base, layer, layerModuleBase = moduleBase) {
     const next = { ...base };
+    const dangerZone = Object.hasOwn(layer, 'dangerZone') ? layer.dangerZone : undefined;
+    // Validate before spreading, without filling defaults that would erase a
+    // different opt-in from a lower layer.
+    if (dangerZone !== undefined) jevDangerZone(dangerZone);
     // File and flag paths have different bases. Equal path text can identify
     // different implementations; compare destinations before changing the base.
     const moduleChanged = layer.module !== undefined && (typeof layer.module !== 'string' ||
@@ -72,14 +83,18 @@ export async function loadConfig({ configPath, envFile, overrides = {}, cwd = pr
     if (changed) for (const key of PROVIDER_FIELDS) delete next[key];
     if (layer.module !== undefined) moduleBase = layerModuleBase;
     return { ...next, ...layer,
+      ...(dangerZone === undefined ? {} : { dangerZone: {
+        ...(Object.hasOwn(next, 'dangerZone') ? next.dangerZone : {}), ...dangerZone,
+      } }),
       ...(layer.gateway === undefined ? {} : { gateway: { ...next.gateway, ...layer.gateway } }) };
   }
   const config = validateConfig(mergeProviderLayer(mergeProviderLayer(
-    { schemaVersion: 1, provider: 'jev', ...fileConfig }, environment), overrides, cwd), { complete: !allowIncomplete });
+    { schemaVersion: 1, provider: defaultProvider, ...fileConfig }, environment), overrides, cwd), { complete: !allowIncomplete });
   if (config.provider === 'jev' && config.model === undefined && effectiveEnv.JEV_MODEL?.trim()) {
     config.model = effectiveEnv.JEV_MODEL.trim();
   }
   if (config.provider === 'openai-decisions' && config.model === undefined) config.model = OPENAI_DEFAULT_MODEL;
   if (config.provider === 'cloudflare-decisions' && config.model === undefined) config.model = 'clef';
+  if (config.provider === 'cloudflare-extraction' && config.model === undefined) config.model = 'clairic';
   return { config, env: effectiveEnv, moduleBase };
 }

package/src/cli/decisions.mjs

@@ -4,9 +4,17 @@ import { preflightCloudflareDecision, preflightCommonCloudflareDecision } from '
 import { encodeCloudflareDecision } from '../providers/cloudflare-codec.mjs';
 import { CLOUDFLARE_MAX_REQUEST_LIMIT } from '../providers/cloudflare-profile.mjs';
 import { resolveOpenAIModel } from '../providers/openai-profile.mjs';
+import { preflightCommonJevDecision, preflightJevDecision, encodeJevDecision } from '../providers/jev-preflight.mjs';
+import { JEV_REQUEST_LIMIT } from '../providers/jev-profile.mjs';
 
 /** Provider-specific native dispatch is shared by validation, initialization and calls. */
 export function decisionProfile(provider) {
+    if (provider === 'jev') return {
+        common: preflightCommonJevDecision, native: preflightJevDecision, encode: encodeJevDecision,
+        models: true, inputLimit: JEV_REQUEST_LIMIT,
+        options: config => ({ model: config.model, maxRequestBytes: config.maxRequestBytes,
+            dangerZone: Object.hasOwn(config, 'dangerZone') ? config.dangerZone : undefined }),
+    };
     if (provider === 'openai-decisions') return {
         common: preflightCommonDecision, native: preflightDecision, encode: encodeCommonDecision,
         resolveModel: resolveOpenAIModel,

package/src/cli/initialize.mjs

@@ -5,6 +5,7 @@ import { validateRequest } from '../validation.mjs';
 import { decisionProfile } from './decisions.mjs';
 import { validateConfig, KEY_ENVS } from './config-validation.mjs';
 import { OPENAI_DEFAULT_MODEL } from '../providers/openai-profile.mjs';
+import { validateExtractionRequest } from '../extraction/validation.mjs';
 
 /** Templates are honest edit points for an unknown protocol, never fake inference. */
 function providerTemplate(kind) {
@@ -42,15 +43,18 @@ export async function initialize(directory, config, native = false, moduleBase =
         ...(config.provider === 'openai-decisions' && config.model === undefined ? { model: OPENAI_DEFAULT_MODEL } : {}),
         ...(custom && config.model === undefined ? { model: 'YOUR_MODEL' } : {}),
     }, { complete: true });
-    const request = { state: "ModuleNotFoundError: No module named 'pytest'", questions: {
+    const request = config.provider === 'cloudflare-extraction' ? {
+        state: 'Invoice total: 1080 USD. Due date: 2026-11-01.',
+        fields: { total: { type: 'number', unit: 'USD' }, due_date: { type: 'date' } },
+    } : { state: "ModuleNotFoundError: No module named 'pytest'", questions: {
         category: { type: 'choice', instructions: 'Classify the failure using only the supplied evidence.',
             criteria: { dependency: 'A required package or module is unavailable.',
                 network: 'A network operation failed.', assertion: 'A test assertion failed.', unknown: 'Insufficient evidence.' } },
         missing_dependency: { type: 'noul', instructions: 'Does this indicate a missing Python package?' },
     } };
     const profile = decisionProfile(config.provider);
-    const sample = native ? profile.native(profile.encode(validateRequest(request, template.model)),
-        profile.options(template)) : request;
+    const sample = config.provider === 'cloudflare-extraction' ? validateExtractionRequest(request, { model: template.model })
+        : native ? profile.native(profile.encode(validateRequest(request, template.model)), profile.options(template)) : request;
     // OpenAI request files inherit selection from configuration, including after later edits.
     const generated = { ...sample };
     if (config.provider === 'openai-decisions') delete generated.model;
@@ -60,7 +64,7 @@ export async function initialize(directory, config, native = false, moduleBase =
         'decision.config.schema.json': schema,
         'request.json': JSON.stringify(generated, null, 2) + '\n',
         '.env.example': `${template.apiKeyEnv}=replace_with_your_api_key\n` +
-            (config.provider === 'cloudflare-decisions' ? 'CLOUDFLARE_ACCOUNT_ID=replace_with_your_account_id\n' : ''),
+            (['cloudflare-decisions', 'cloudflare-extraction'].includes(config.provider) ? 'CLOUDFLARE_ACCOUNT_ID=replace_with_your_account_id\n' : ''),
         '.gitignore': '.env\n.env.*\n!.env.example\nnode_modules/\n*.tmp\n',
         ...(generateModule ? { 'provider.mjs': providerTemplate(config.provider === 'custom-decision' ? 'decision' : 'generative') } : {}),
     };

package/src/cli/live.mjs

@@ -0,0 +1,63 @@
+import { DecisionError, requireCondition as check, publicError } from '../errors.mjs';
+import { validateLiveCommand, validateLiveConfiguration, validateLiveEvent } from '../live/validation.mjs';
+import { createLiveState } from '../live/state.mjs';
+import { assertDistinctFiles, createWriter, readJson, readJsonLines } from './io.mjs';
+
+/** Offline protocol tools deliberately do not load provider configuration or keys. */
+export async function runLiveCli(positionals, values, context) {
+    const [command, positional] = positionals;
+    check(['validate', 'replay'].includes(command) && positionals.length <= 2, 'Use live validate or live replay.', 'USAGE_ERROR');
+    check(Object.keys(values).every(key => ['input', 'output', 'force', 'pretty', 'compact', 'kind'].includes(key)),
+        'Unsupported option for offline Live tools.', 'USAGE_ERROR');
+    check(!(values.input && positional), 'Supply one Live input file.', 'USAGE_ERROR');
+    check(!(values.pretty && values.compact), 'Choose pretty or compact output.', 'USAGE_ERROR');
+    check(!values.force || (values.output && values.output !== '-'), '--force requires file output.', 'USAGE_ERROR');
+    const path = values.input ?? positional;
+    check(path, 'Live tools require an explicit input file or -.', 'USAGE_ERROR');
+    if (values.output && values.output !== '-' && path !== '-') await assertDistinctFiles(path, values.output, context.cwd);
+    const validators = { config: validateLiveConfiguration, command: validateLiveCommand, event: validateLiveEvent };
+    check(command !== 'validate' || Object.hasOwn(validators, values.kind ?? ''), 'Live validation requires --kind config, command or event.', 'USAGE_ERROR');
+    check(command !== 'replay' || values.kind === undefined, '--kind applies only to validation.', 'USAGE_ERROR');
+    const writer = await createWriter({ ...context, output: values.output, force: values.force });
+    try {
+        if (command === 'validate') {
+            const input = await readJson(path, context);
+            try { validators[values.kind](input); }
+            catch (error) {
+                // An offline event file is caller input, even though the SDK's
+                // event validator correctly describes malformed server responses.
+                if (values.kind === 'event' && error instanceof DecisionError && error.code === 'INVALID_RESPONSE') {
+                    throw new DecisionError(error.message, { ...error.toJSON(), code: 'VALIDATION_ERROR', source: 'client' });
+                }
+                throw error;
+            }
+            await writer.write(JSON.stringify({ valid: true, operation: 'live', kind: values.kind,
+                validationScope: 'structure' }, null, values.compact ? 0 : 2) + '\n');
+            await writer.finish();
+            return 0;
+        }
+        const state = createLiveState();
+        let failed = false;
+        for await (const row of readJsonLines(path, context)) {
+            let record;
+            try {
+                if (row.error) { failed = true; record = { line: row.line, ok: false, error: row.error }; }
+                else {
+                    const input = row.input;
+                    check(input && typeof input === 'object' && Object.keys(input).length === 2 &&
+                        Object.hasOwn(input, 'event') && ['client', 'server'].includes(input.direction), 'Replay requires direction and event.');
+                    let event;
+                    if (input.direction === 'client') {
+                        const command = validateLiveCommand(input.event);
+                        state.observeClient(command);
+                        event = { type: 'command', eventType: command.type, ...(command.event_id ? { eventId: command.event_id } : {}) };
+                    } else event = state.accept(validateLiveEvent(input.event)) ?? { type: 'ignored', eventType: input.event.type };
+                    record = { line: row.line, ok: true, event };
+                }
+            } catch (error) { failed = true; record = { line: row.line, ok: false, error: publicError(error) }; }
+            await writer.write(JSON.stringify(record) + '\n');
+        }
+        await writer.finish();
+        return failed ? 1 : 0;
+    } catch (error) { await writer.abort(); throw error; }
+}

package/src/cli/main.mjs

@@ -13,11 +13,14 @@ import { isModule } from './config-validation.mjs';
 import { loadConfig, configuredProvider } from './config.mjs';
 import { assertDistinctFiles, createWriter, readJson, readJsonLines } from './io.mjs';
 import { mapOrdered } from './ordered.mjs';
+import { validateExtractionRequest } from '../extraction/index.mjs';
+import { runLiveCli } from './live.mjs';
 
 const SAMPLE_PATH = fileURLToPath(new URL('../../examples/request.json', import.meta.url));
-const BOOLS = ['help', 'version', 'pretty', 'compact', 'no-auth', 'force', 'native', 'reject-if-busy', 'no-reject-if-busy'];
+const BOOLS = ['help', 'version', 'pretty', 'compact', 'no-auth', 'force', 'native', 'reject-if-busy', 'no-reject-if-busy',
+    'jev-images', 'no-jev-images', 'jev-long-context', 'no-jev-long-context'];
 const STRINGS = ['config', 'env-file', 'provider', 'preset', 'model', 'base-url', 'api-key-env', 'timeout-ms',
-  'retries', 'max-tokens', 'response-format', 'token-parameter', 'input', 'output', 'concurrency', 'provider-module', 'account-id', 'gateway-id'];
+  'retries', 'max-tokens', 'response-format', 'token-parameter', 'input', 'output', 'concurrency', 'provider-module', 'account-id', 'gateway-id', 'kind'];
 const FIELD_MAP = { preset: 'preset', provider: 'provider', model: 'model', 'base-url': 'baseURL', 'api-key-env': 'apiKeyEnv',
   'timeout-ms': 'timeoutMs', retries: 'maxRetries', 'max-tokens': 'maxTokens',
   'response-format': 'responseFormat', 'token-parameter': 'tokenParameter', 'provider-module': 'module', 'account-id': 'accountId' };
@@ -31,6 +34,10 @@ Usage:
   decision-bridge schema [request.json | -] [options]      (offline generative schema)
   decision-bridge models [options]
   decision-bridge batch requests.jsonl [--concurrency 4] [options]
+  decision-bridge extraction run|validate|batch request-file [options]
+  decision-bridge extraction init [directory] [options]
+  decision-bridge live validate FILE --kind config|command|event   (offline)
+  decision-bridge live replay FILE.jsonl                         (offline)
 
 Command aliases: decision, faye-decision
 
@@ -48,8 +55,12 @@ Options:
   --api-key-env NAME        Read credential from this environment variable
   --no-auth                 Local OpenAI-compatible endpoint only
   --timeout-ms N            End-to-end evaluation/provider deadline
-  --retries N               HTTP retries, 0–10; Decisions default 0, others 2
+  --retries N               HTTP retries, 0–10; OpenAI/Cloudflare default 0, Jev 2
   --native                  Selected decision provider native format (init/evaluate/validate/batch)
+  --jev-images              Enable experimental Jev images and box questions
+  --no-jev-images           Explicitly disable Jev images
+  --jev-long-context        Enable experimental Jev 262k context
+  --no-jev-long-context     Explicitly disable Jev long context
   --account-id ID           Cloudflare account (otherwise CLOUDFLARE_ACCOUNT_ID)
   --reject-if-busy          Unavailable for Clef REST; rejected before inference
   --no-reject-if-busy       Explicitly disable Cloudflare capacity rejection
@@ -65,7 +76,8 @@ Options:
   --pretty / --compact      JSON layout; default pretty (batch is always JSONL)
   --help, -h / --version, -v
 
-Without an input file, evaluate/validate/schema use the bundled sample.
+Without an input file, decision evaluate/validate/schema use the bundled sample.
+Extraction and Live operations require an explicit input file or stdin.
 No credentials, file reads, or network calls are needed for help/version.
 All API calls are explicit; evaluate/models/batch may access paid services.
 Exit codes: 0 success; 1 provider/partial-batch failure; 2 input/config/IO;
@@ -95,7 +107,7 @@ function argumentsFor(argv) {
 }
 
 function overridesFor(values) {
-  const overrides = {};
+  const overrides = Object.create(null);
   for (const [flag, field] of Object.entries(FIELD_MAP)) if (values[flag] !== undefined) {
     const value = values[flag];
     if (['timeoutMs', 'maxRetries', 'maxTokens'].includes(field)) {
@@ -107,12 +119,18 @@ function overridesFor(values) {
   check(!(values['reject-if-busy'] && values['no-reject-if-busy']), 'Choose one reject-if-busy flag.', 'USAGE_ERROR');
   if (values['reject-if-busy'] || values['no-reject-if-busy']) overrides.rejectIfBusy = !!values['reject-if-busy'];
   if (values['gateway-id'] !== undefined) overrides.gateway = { id: values['gateway-id'] };
+  for (const [flag, field] of [['jev-images', 'images'], ['jev-long-context', 'longContext']]) {
+    check(!(values[flag] && values['no-' + flag]), 'Choose one Jev feature flag for each setting.', 'USAGE_ERROR');
+    if (values[flag] || values['no-' + flag]) overrides.dangerZone = {
+      ...(Object.hasOwn(overrides, 'dangerZone') ? overrides.dangerZone : {}), [field]: !!values[flag],
+    };
+  }
   return overrides;
 }
 
 const INPUT_CODES = new Set(['USAGE_ERROR', 'CONFIGURATION_ERROR', 'VALIDATION_ERROR', 'UNSUPPORTED_CAPABILITY', 'IO_ERROR', 'INPUT_TOO_LARGE', 'REQUEST_TOO_LARGE']);
 export function exitCode(error) {
-  return error?.code === 'ABORTED' ? 130 : INPUT_CODES.has(error?.code) ? 2 : 1;
+  return error?.code === 'ABORTED' ? 130 : error?.source === 'provider' ? 1 : INPUT_CODES.has(error?.code) ? 2 : 1;
 }
 
 function scrub(value, env, explicitSecret) {
@@ -141,14 +159,21 @@ export async function runCli(argv, { stdin = process.stdin, stdout = process.std
   if (signal?.aborted) cancelled();
   signal?.addEventListener('abort', cancelled, { once: true });
   try {
-    const { values, positionals } = argumentsFor(argv);
+    const { values, positionals: originalPositionals } = argumentsFor(argv);
+    const namespace = ['extraction', 'live'].includes(originalPositionals[0]) ? originalPositionals[0] : undefined;
+    const positionals = namespace ? originalPositionals.slice(1) : originalPositionals;
     if (values.help || (positionals.length === 0 && !values.version)) { stdout.write(HELP); return 0; }
     if (values.version) { stdout.write(VERSION + '\n'); return 0; }
-    const aliases = { eval: 'evaluate', ask: 'evaluate' };
+    if (namespace === 'live') return await runLiveCli(positionals, values,
+      { stdin, stdout, cwd, signal: internal.signal });
+    const extracting = namespace === 'extraction';
+    const aliases = { eval: 'evaluate', ask: 'evaluate', ...(extracting ? { run: 'evaluate' } : {}) };
     const command = aliases[positionals[0]] ?? positionals[0];
     if (command === 'help') { stdout.write(HELP); return 0; }
     if (internal.signal.aborted) throw abortError();
     check(['evaluate', 'validate', 'schema', 'models', 'init', 'batch'].includes(command), 'Unknown command. Run --help.', 'USAGE_ERROR');
+    check(!extracting || ['evaluate', 'validate', 'init', 'batch'].includes(command), 'Unsupported extraction command.', 'USAGE_ERROR');
+    check(values.kind === undefined, '--kind applies only to live validation.', 'USAGE_ERROR');
     check(positionals.length <= (command === 'models' ? 1 : 2), 'Too many positional arguments.', 'USAGE_ERROR');
     check(!(values.input && positionals[1]), 'Supply either --input or a positional file, not both.', 'USAGE_ERROR');
     check(!(values.pretty && values.compact), 'Choose --pretty or --compact, not both.', 'USAGE_ERROR');
@@ -165,23 +190,30 @@ export async function runCli(argv, { stdin = process.stdin, stdout = process.std
         'concurrency must be from 1 to 64.', 'USAGE_ERROR');
     }
     const loaded = await loadConfig({ configPath: values.config, envFile: values['env-file'],
-      overrides: overridesFor(values), cwd, env, allowIncomplete: command === 'init' });
-    const profile = decisionProfile(loaded.config.provider);
+      overrides: overridesFor(values), cwd, env, allowIncomplete: command === 'init',
+      defaultProvider: extracting ? 'cloudflare-extraction' : 'jev' });
+    check(extracting === (loaded.config.provider === 'cloudflare-extraction'), 'Selected provider does not match the command operation.', 'CONFIGURATION_ERROR');
+    const profile = extracting ? { common: validateExtractionRequest, inputLimit: 64 * 1024 * 1024,
+      options: config => Object.fromEntries(['model', 'maxRequestBytes', 'maxRetries', 'rejectIfBusy', 'gateway']
+        .filter(key => config[key] !== undefined).map(key => [key, config[key]])) } : decisionProfile(loaded.config.provider);
+    check(!extracting || !values.native, 'Extraction already uses its native field schema.', 'USAGE_ERROR');
     check(!values.native || (profile && ['init', 'evaluate', 'validate', 'batch'].includes(command)),
       '--native requires a decision provider and init/evaluate/validate/batch.', 'USAGE_ERROR');
     check(!values.native || command === 'init' || values.input || positionals[1],
       '--native requires an explicit input file or -.', 'USAGE_ERROR');
-    check(command !== 'models' || !profile,
+    check(command !== 'models' || !profile || profile.models,
       'This decision provider does not implement model listing.', 'UNSUPPORTED_OPERATION');
     activeEnv = loaded.env;
     explicitSecret = loaded.config.apiKeyEnv ? activeEnv[loaded.config.apiKeyEnv] : undefined;
     const inputPath = values.input ?? positionals[1] ?? SAMPLE_PATH;
+    check(!extracting || command === 'init' || values.input || positionals[1], 'Extraction requires an explicit input file or -.', 'USAGE_ERROR');
     if (values.output && values.output !== '-' && inputPath !== '-') {
       await assertDistinctFiles(inputPath, values.output, cwd);
     }
     writer = await createWriter({ output: values.output, force: values.force, stdout, cwd, signal: internal.signal });
     const writeJson = value => writer.write(JSON.stringify(value, null, values.compact ? 0 : 2) + '\n');
-    const context = { stdin, cwd, signal: internal.signal, maxInputBytes: profile?.inputLimit };
+    const context = { stdin, cwd, signal: internal.signal,
+      maxInputBytes: Math.max(profile?.inputLimit ?? 8 * 1024 * 1024, loaded.config.maxRequestBytes ?? 0) };
     const withModel = input => {
       if (!input || typeof input !== 'object' || Array.isArray(input)) return input;
       // Apply the configured fallback independently of a custom factory's default.
@@ -189,7 +221,7 @@ export async function runCli(argv, { stdin = process.stdin, stdout = process.std
       const model = values.model ?? (isModule(loaded.config) && !Object.hasOwn(input, 'model')
         ? loaded.config.model : undefined);
       const request = model === undefined ? input : { ...input, model };
-      if (values.native && (values['reject-if-busy'] || values['no-reject-if-busy'])) {
+      if ((values.native || extracting) && (values['reject-if-busy'] || values['no-reject-if-busy'])) {
         check(request.options === undefined || (request.options !== null && typeof request.options === 'object' &&
           !Array.isArray(request.options)), 'Native execution options must be an object.');
         return { ...request, options: { ...request.options, rejectIfBusy: !!values['reject-if-busy'] } };
@@ -201,7 +233,7 @@ export async function runCli(argv, { stdin = process.stdin, stdout = process.std
       if (profile && command !== 'schema') return profile.common(raw, profile.options(loaded.config));
       const request = validateRequest(raw, raw?.model ?? loaded.config.model ?? 'validation-only');
       if (!isModule(loaded.config)) assertCapabilities(request,
-        builtInCapabilities(loaded.config.provider, request.model));
+        builtInCapabilities(loaded.config.provider, request.model, loaded.config));
       return request;
     };
     if (command === 'init') {
@@ -213,7 +245,8 @@ export async function runCli(argv, { stdin = process.stdin, stdout = process.std
       const buildResponseSchema = command === 'schema'
         ? (await import('../custom/generative/schema.mjs')).buildResponseSchema : undefined;
       await writeJson(command === 'schema' ? buildResponseSchema(request.questions)
-        : { valid: true, validationScope: isModule(loaded.config) ? 'structure' : 'provider', questionCount: Object.keys(request.questions).length, model: selectedModel,
+        : { valid: true, operation: extracting ? 'extraction' : 'decision', validationScope: isModule(loaded.config) ? 'structure' : 'provider',
+          ...(extracting ? { fieldCount: Object.keys(request.fields).length } : { questionCount: Object.keys(request.questions).length }), model: selectedModel,
           ...(profile?.resolveModel ? { resolvedModel: profile.resolveModel(request.model) } : {}),
           ...(values.native ? { native: true } : {}) });
     } else {
@@ -226,8 +259,9 @@ export async function runCli(argv, { stdin = process.stdin, stdout = process.std
         validateInput(request);
       }
       const provider = await configuredProvider(loaded, { signal: internal.signal });
-      const bridge = createBridge({ provider, timeoutMs: loaded.config.timeoutMs ?? 60000 });
+      const bridge = extracting ? undefined : createBridge({ provider, timeoutMs: loaded.config.timeoutMs ?? 60000 });
       async function evaluateInput(input) {
+        if (extracting) return provider.extract(input, { signal: internal.signal });
         if (!values.native) return bridge.evaluate(input, { signal: internal.signal });
         const budget = deadline(loaded.config.timeoutMs ?? 60000, internal.signal);
         try {

package/src/cli/provider-loader.mjs

@@ -4,6 +4,7 @@ import { DecisionError, requireCondition as check } from '../errors.mjs';
 import { deadline, withSignal, abortError } from '../async.mjs';
 import { providerContract } from '../provider-contract.mjs';
 import { createProvider } from '../providers/index.mjs';
+import { CloudflareExtractionProvider } from '../extraction/index.mjs';
 import { validateConfig, isModule, KEY_ENVS } from './config-validation.mjs';
 
 /** Executable modules are loaded only by explicit inference/model-list commands. */
@@ -52,7 +53,7 @@ export async function configuredProvider(loaded, { signal } = {}) {
         const { createGenerativeProvider } = await import('../custom/generative/index.mjs');
         return createGenerativeProvider({ type: config.preset, ...options });
     }
-    if (type === 'cloudflare-decisions') options.accountId = config.accountId ??
+    if (['cloudflare-decisions', 'cloudflare-extraction'].includes(type)) options.accountId = config.accountId ??
         (config.baseURL === undefined ? loaded.env.CLOUDFLARE_ACCOUNT_ID : undefined) ?? '';
-    return createProvider({ type, ...options });
+    return type === 'cloudflare-extraction' ? new CloudflareExtractionProvider(options) : createProvider({ type, ...options });
 }

package/src/cloudflare-decisions.d.mts

@@ -41,25 +41,32 @@ export interface CloudflareDecisionResponse {
     readonly usage: CloudflareDecisionUsage;
 }
 export interface CloudflareGatewayOptions {
-    /** Nonblank printable ASCII Gateway name, at most 64 characters. */
+    /** Nonblank printable ASCII Gateway name. */
     readonly id: string;
     readonly cacheKey?: string;
-    /** Integer seconds from 60 through 2,592,000 (30 days). */
+    /** Nonnegative integer seconds; the service validates its cache policy. */
     readonly cacheTtl?: number;
     readonly skipCache?: boolean;
     readonly collectLog?: boolean;
-    /** At most five JSON primitive entries; caller-supplied cf.* keys are reserved. */
+    /** JSON primitive entries; caller-supplied cf.* keys are reserved. */
     readonly metadata?: Readonly<Record<string, string | number | boolean | null>>;
     readonly requestTimeoutMs?: number;
-    readonly retries?: { readonly maxAttempts?: 1 | 2 | 3 | 4 | 5; readonly retryDelayMs?: number;
+    readonly retries?: { readonly maxAttempts?: number; readonly retryDelayMs?: number;
         readonly backoff?: 'constant' | 'linear' | 'exponential' };
 }
 export interface CloudflareAIBinding {
     run(model: '@cf/cloudflare/clef' | '@cf/cloudflare/clef-flash' | '@cf/cloudflare/clef-omni',
         input: Omit<CloudflareDecisionRequest, 'model' | 'options'> & { readonly model: 'clef' | 'clef-flash' | 'clef-omni' },
         options?: { readonly signal?: AbortSignal; readonly returnRawResponse?: boolean;
-            readonly rejectIfBusy?: boolean; readonly gateway?: CloudflareGatewayOptions }): Promise<unknown>;
+            readonly rejectIfBusy?: boolean; readonly gateway?: CloudflareBindingGatewayOptions }): Promise<unknown>;
 }
+
+/** Known Workers binding ABI. Provider configuration remains forwardable to the service. */
+export type CloudflareBindingGatewayOptions = Omit<CloudflareGatewayOptions, 'retries'> & {
+    readonly retries?: Omit<NonNullable<CloudflareGatewayOptions['retries']>, 'maxAttempts'> & {
+        readonly maxAttempts?: 1 | 2 | 3 | 4 | 5;
+    };
+};
 type CommonOptions = {
     model?: CloudflareDecisionModel;
     /** Defaults to false. Enabling it requires binding transport and no retries. */