@fayegram-ai/decision-bridge 0.1.2 → 0.1.3

package/schemas/decision.config.schema.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://json-schema.org/draft/2020-12/schema",
     "title": "Decision Bridge configuration",
-    "description": "Explicit schemaVersion 1 configuration. Runtime preflight also enforces URL, credential and provider limits.",
+    "description": "Explicit schemaVersion 1 configuration. Runtime validation checks adapter structure and client resource budgets; service limits remain authoritative upstream.",
     "oneOf": [
         {
             "type": "object",
@@ -31,7 +31,7 @@
                 "maxRequestBytes": {
                     "type": "integer",
                     "minimum": 1,
-                    "maximum": 33554432
+                    "maximum": 67108864
                 },
                 "maxResponseBytes": {
                     "$ref": "#/$defs/bytes"
@@ -407,6 +407,89 @@
                 "provider",
                 "module"
             ]
+        },
+        {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "$schema": {
+                    "$ref": "#/$defs/text"
+                },
+                "schemaVersion": {
+                    "const": 1
+                },
+                "model": {
+                    "enum": [
+                        "clairic",
+                        "@cf/cloudflare/clairic"
+                    ]
+                },
+                "apiKeyEnv": {
+                    "$ref": "#/$defs/keyEnv"
+                },
+                "timeoutMs": {
+                    "$ref": "#/$defs/timeout"
+                },
+                "baseURL": {
+                    "$ref": "#/$defs/text"
+                },
+                "maxRetries": {
+                    "$ref": "#/$defs/retries"
+                },
+                "maxRequestBytes": {
+                    "$ref": "#/$defs/bytes"
+                },
+                "maxResponseBytes": {
+                    "$ref": "#/$defs/bytes"
+                },
+                "provider": {
+                    "const": "cloudflare-extraction"
+                },
+                "accountId": {
+                    "$ref": "#/$defs/text"
+                },
+                "rejectIfBusy": {
+                    "$ref": "#/$defs/boolean"
+                },
+                "gateway": {
+                    "$ref": "#/$defs/gateway"
+                }
+            },
+            "required": [
+                "provider"
+            ],
+            "allOf": [
+                {
+                    "if": {
+                        "properties": {
+                            "rejectIfBusy": {
+                                "const": true
+                            }
+                        },
+                        "required": [
+                            "rejectIfBusy"
+                        ]
+                    },
+                    "then": {
+                        "properties": {
+                            "maxRetries": {
+                                "const": 0
+                            },
+                            "gateway": {
+                                "properties": {
+                                    "retries": {
+                                        "properties": {
+                                            "maxAttempts": {
+                                                "const": 1
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            ]
         }
     ],
     "$defs": {
@@ -496,19 +579,16 @@
                 "id": {
                     "type": "string",
                     "minLength": 1,
-                    "maxLength": 64,
                     "pattern": "^[\\x20-\\x7e]*\\S[\\x20-\\x7e]*$"
                 },
                 "cacheKey": {
                     "type": "string",
                     "minLength": 1,
-                    "maxLength": 200,
                     "pattern": "^[\\x20-\\x7e]*\\S[\\x20-\\x7e]*$"
                 },
                 "cacheTtl": {
                     "type": "integer",
-                    "minimum": 60,
-                    "maximum": 2592000
+                    "minimum": 0
                 },
                 "skipCache": {
                     "type": "boolean"
@@ -523,7 +603,6 @@
                 },
                 "metadata": {
                     "type": "object",
-                    "maxProperties": 5,
                     "propertyNames": {
                         "not": {
                             "pattern": "^cf\\."
@@ -544,13 +623,11 @@
                     "properties": {
                         "maxAttempts": {
                             "type": "integer",
-                            "minimum": 1,
-                            "maximum": 5
+                            "minimum": 1
                         },
                         "retryDelayMs": {
                             "type": "integer",
-                            "minimum": 0,
-                            "maximum": 60000
+                            "minimum": 0
                         },
                         "backoff": {
                             "enum": [

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

@@ -11,22 +11,24 @@ export const LEGACY_CAPABILITIES = freezeJson({
     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, options = {}) {
     if (type === 'jev') return freezeJson({ ...LEGACY_CAPABILITIES,
-        ...jevFeatures(model, Object.hasOwn(options, 'dangerZone') ? options.dangerZone : undefined) });
+        ...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);
@@ -49,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', 'boxes']) {
+    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']) {
@@ -64,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']]) {
@@ -91,6 +112,9 @@ 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') ||

package/src/cli/config-validation.mjs

@@ -4,7 +4,7 @@ import { cloudflareGateway, validateCloudflareLimits } from '../providers/cloudf
 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'];
@@ -13,7 +13,7 @@ export const PROVIDER_FIELDS = [...TRANSPORT, ...GENERATION, 'apiKeyEnv', 'model
 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;
 
@@ -65,8 +65,8 @@ export function validateConfig(input, { complete = false } = {}) {
         else {
             jevRequestLimit(config.maxRequestBytes);
         }
-        if (config.provider !== 'cloudflare-decisions') check(['accountId', 'rejectIfBusy', 'gateway'].every(key => config[key] === undefined),
-            'Cloudflare settings require cloudflare-decisions.', 'CONFIGURATION_ERROR');
+        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

@@ -30,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');
@@ -88,11 +89,12 @@ export async function loadConfig({ configPath, envFile, overrides = {}, cwd = pr
       ...(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/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,12 +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',
     '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' };
@@ -32,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
 
@@ -49,7 +55,7 @@ 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
@@ -70,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;
@@ -123,7 +130,7 @@ function overridesFor(values) {
 
 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) {
@@ -152,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');
@@ -176,8 +190,13 @@ 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],
@@ -187,12 +206,14 @@ export async function runCli(argv, { stdin = process.stdin, stdout = process.std
     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.
@@ -200,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'] } };
@@ -224,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 {
@@ -237,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. */