@probelabs/probe 0.6.0-rc334 → 0.6.0-rc336

package/build/agent/ProbeAgent.js

@@ -2503,7 +2503,10 @@ export class ProbeAgent {
         }
         return this.engine;
       } catch (error) {
-        if (this.governedCodexProfile) throw error;
+        if (this.governedCodexProfile) {
+          throw normalizeGovernedAnswerFailure(error, 'provider_engine', null, null, null,
+            null, null, 'acquire');
+        }
         console.warn('[WARNING] Failed to load Codex CLI engine:', error.message);
         console.warn('[WARNING] Falling back to Vercel AI SDK');
         this.clientApiProvider = null;
@@ -3530,8 +3533,11 @@ Follow these instructions carefully:
     let engine, answerFailure = null;
     try {
       try { engine = await this.getEngine(); }
-      catch { throw governedAnswerFailure('provider_engine'); }
-      if (!engine?.query) throw governedAnswerFailure('provider_engine');
+      catch (error) {
+        throw normalizeGovernedAnswerFailure(error, 'provider_engine', null, null, null,
+          null, null, 'acquire');
+      }
+      if (!engine?.query) throw governedAnswerFailure('internal_contract');
       const candidateChunks = [];
       let runtimeAttestation;
       let attestationCount = 0;
@@ -3540,31 +3546,47 @@ Follow these instructions carefully:
       const queryOptions = hasInvocationDigest
         ? { abortSignal: this._abortController.signal, invocationDigest: invocationDigest }
         : { abortSignal: this._abortController.signal };
-      for await (const chunk of engine.query(prompt, queryOptions)) {
-        if (chunk.type === 'text' && chunk.content) candidateChunks.push(chunk.content);
-        else if (chunk.type === 'metadata' && chunk.data?.attestation) {
-          runtimeAttestation = chunk.data.attestation;
-          attestationCount++;
-        } else if (chunk.type === 'toolBatch') {
-          nativeToolBatch = chunk;
-          nativeToolBatchCount++;
-        } else if (chunk.type === 'error') throw normalizeGovernedAnswerFailure(chunk.error, 'unknown');
+      try {
+        for await (const chunk of engine.query(prompt, queryOptions)) {
+          if (chunk.type === 'text' && chunk.content) candidateChunks.push(chunk.content);
+          else if (chunk.type === 'metadata' && chunk.data?.attestation) {
+            runtimeAttestation = chunk.data.attestation;
+            attestationCount++;
+          } else if (chunk.type === 'toolBatch') {
+            nativeToolBatch = chunk;
+            nativeToolBatchCount++;
+          } else if (chunk.type === 'error') {
+            throw normalizeGovernedAnswerFailure(chunk.error, 'provider_engine', null, null, null,
+              null, null, 'query');
+          }
+        }
+      } catch (error) {
+        throw normalizeGovernedAnswerFailure(error, 'provider_engine', null, null, null,
+          null, null, 'query');
       }
       if (hasInvocationDigest) {
         const expectedAttestation = this.governedCodexProfile?.version === 'probe.governed-codex-profile/v2'
           ? 'probe.governed-codex-attestation/v3' : 'probe.governed-codex-attestation/v2';
         if (attestationCount !== 1 || runtimeAttestation?.version !== expectedAttestation || runtimeAttestation?.executionContext?.source !== 'caller' || runtimeAttestation?.executionContext?.invocationDigest !== invocationDigest) {
-          throw new Error('Expected exactly one matching governed invocation attestation');
+          throw governedAnswerFailure('native_event_grammar', 'live_envelope_session', 'attestation', null,
+            'invocation_attestation');
         }
-      } else if (attestationCount !== 1) throw new Error(`Expected exactly one governed runtime attestation; received ${attestationCount}`);
+      } else if (attestationCount !== 1) {
+        throw governedAnswerFailure('native_event_grammar', 'live_envelope_session', 'attestation', null,
+          'invocation_attestation');
+      }
       if (this.governedCodexProfile?.version === 'probe.governed-codex-profile/v2') {
         if (nativeToolBatchCount !== 1 || !Number.isSafeInteger(nativeToolBatch?.total) ||
           !Array.isArray(nativeToolBatch?.tools) || nativeToolBatch.total !== runtimeAttestation?.observed?.nativeTools?.total ||
           JSON.stringify(nativeToolBatch.tools) !== JSON.stringify(runtimeAttestation?.observed?.nativeTools?.tools)) {
-          throw new Error('Expected exactly one matching governed native capability aggregate');
+          throw governedAnswerFailure('native_event_grammar', 'live_envelope_session', 'attestation', null,
+            'native_capability_aggregate');
         }
         for (const toolEvent of nativeToolBatch.tools) this.events.emit('toolCall', toolEvent);
-      } else if (nativeToolBatchCount !== 0) throw new Error('Unexpected governed native capability aggregate');
+      } else if (nativeToolBatchCount !== 0) {
+        throw governedAnswerFailure('native_event_grammar', 'live_envelope_session', 'attestation', null,
+          'native_capability_aggregate');
+      }
       const validation = validateJsonResponse(candidateChunks.join(''), {debug:this.debug,schema});
       if (!validation.isValid) throw governedSchemaResultValidationFailure(validation);
       if (hasResultIdentity) {
@@ -3577,12 +3599,15 @@ Follow these instructions carefully:
       }
       return { data: validation.parsed, runtimeAttestation };
     } catch (error) {
-      answerFailure = normalizeGovernedAnswerFailure(error, 'unknown');
+      answerFailure = normalizeGovernedAnswerFailure(error, 'internal_contract');
       throw answerFailure;
     } finally {
       if (engine) {
         try { await engine.close(); }
-        catch { if (!answerFailure) throw governedAnswerFailure('unknown'); }
+        catch (error) {
+          if (!answerFailure) throw normalizeGovernedAnswerFailure(error, 'provider_engine', null, null, null,
+            null, null, 'close');
+        }
       }
     }
   }

package/build/agent/engines/codex.js

@@ -461,7 +461,11 @@ export async function createCodexEngine(options = {}) {
           try { collector.observe(event); } catch (error) { evidenceFailure ??= normalizeGovernedAnswerFailure(error, 'native_event_grammar'); }
         });
         if (opts.abortSignal) {
-          if (opts.abortSignal.aborted) throw new Error('Codex query cancelled');
+          if (opts.abortSignal.aborted) {
+            throw governedProfile
+              ? governedAnswerFailure('provider_engine', null, null, null, null, null, null, 'query')
+              : new Error('Codex query cancelled');
+          }
           abortHandler = () => { void cleanup(new Error('Codex query cancelled')).catch(() => {}); };
           opts.abortSignal.addEventListener('abort', abortHandler, { once: true });
         }
@@ -501,7 +505,8 @@ export async function createCodexEngine(options = {}) {
         try { result = await resultPromise; }
         catch (error) {
           throw governedProfile
-            ? governedAnswerFailure(evidenceFailure ? 'unknown' : 'provider_engine')
+            ? evidenceFailure || normalizeGovernedAnswerFailure(error, 'provider_engine', null, null, null,
+              null, null, 'query')
             : error;
         }
 
@@ -521,20 +526,31 @@ export async function createCodexEngine(options = {}) {
             internal = attestGovernedCodexSession({ profile: governedProfile,
               events: governedProfile.version === 'probe.governed-codex-profile/v2'
                 ? [collected.sessionEvent, collected.capabilities.nativeTools] : [collected.sessionEvent] });
+          } catch (error) {
+            throw normalizeGovernedAnswerFailure(error, 'native_event_grammar', 'live_envelope_session',
+              'attestation');
+          }
+          try {
             probeMcpCallCount = governedProfile.version === 'probe.governed-codex-profile/v2'
               ? governedProbeMcpCallCount(mcpServer?.getGovernedCallEvidence()) : 0;
           } catch (error) {
-            throw normalizeGovernedAnswerFailure(error, 'native_event_grammar', 'live_envelope_session', 'attestation');
+            throw normalizeGovernedAnswerFailure(error, 'native_event_grammar', 'live_envelope_session',
+              'attestation', null, null, null, null, 'native_capability_aggregate');
+          }
+          try {
+            attestation = hasInvocationDigest
+              ? externalBoundReceipt(internal, dispatch, invocationDigest, {
+                nativeCallCount: collected.capabilities.nativeTools.total,
+                probeMcpCallCount,
+              })
+              : externalReceipt(internal, {
+                nativeCallCount: collected.capabilities.nativeTools.total,
+                probeMcpCallCount,
+              });
+          } catch (error) {
+            throw normalizeGovernedAnswerFailure(error, 'native_event_grammar', 'live_envelope_session',
+              'attestation', null, null, null, null, 'invocation_attestation');
           }
-          attestation = hasInvocationDigest
-            ? externalBoundReceipt(internal, dispatch, invocationDigest, {
-              nativeCallCount: collected.capabilities.nativeTools.total,
-              probeMcpCallCount,
-            })
-            : externalReceipt(internal, {
-              nativeCallCount: collected.capabilities.nativeTools.total,
-              probeMcpCallCount,
-            });
           session.setConversationId(collected.sessionEvent.params.msg.session_id);
         }
 
@@ -576,7 +592,7 @@ export async function createCodexEngine(options = {}) {
         };
 
       } catch (error) {
-        if (governedProfile) error = normalizeGovernedAnswerFailure(error, 'unknown');
+        if (governedProfile) error = normalizeGovernedAnswerFailure(error, 'internal_contract');
         queryError = error;
         if (debug) {
           console.error('[DEBUG] Codex query error:', error);
@@ -589,7 +605,10 @@ export async function createCodexEngine(options = {}) {
         if (opts.abortSignal && abortHandler) opts.abortSignal.removeEventListener('abort', abortHandler);
         if (governedProfile) {
           try { await cleanup(); }
-          catch (cleanupError) { if (!queryError) throw cleanupError; }
+          catch (cleanupError) {
+            if (!queryError) throw normalizeGovernedAnswerFailure(cleanupError, 'provider_engine', null, null,
+              null, null, null, 'close');
+          }
         }
       }
     },

package/build/agent/engines/governed-answer-failure.js

@@ -1,6 +1,7 @@
 const GOVERNED_ANSWER_FAILURE_STAGES = new Set([
-  'native_event_grammar', 'provider_engine', 'schema_result_validation', 'unknown',
+  'native_event_grammar', 'provider_engine', 'schema_result_validation', 'internal_contract', 'unknown',
 ]);
+const GOVERNED_PROVIDER_ENGINE_FAILURE_BOUNDARIES = new Set(['acquire', 'query', 'close']);
 const GOVERNED_NATIVE_EVENT_FAILURE_BOUNDARIES = new Set([
   'raw_item_predicate', 'live_envelope_session',
 ]);
@@ -17,6 +18,7 @@ const GOVERNED_NATIVE_EVENT_FAILURE_ATTESTATION_PREDICATES = new Set([
   'network',
   'filesystem_shape', 'filesystem_type', 'entries', 'entry', 'access', 'path_shape',
   'path_type', 'value_shape', 'kind', 'native_tool_evidence', 'internal_contract',
+  'invocation_attestation', 'native_capability_aggregate',
 ]);
 const GOVERNED_SCHEMA_RESULT_VALIDATION_SUBREASONS = new Set([
   'response_json', 'schema_definition', 'schema_mismatch', 'result_identity',
@@ -73,7 +75,8 @@ function governedAttestationPredicate(error) {
 export class GovernedAnswerFailure extends Error {
   constructor(stage, nativeEventFailureBoundary = null, nativeEventFailureSubreason = null,
     nativeEventFailureCorrelationOperand = null, nativeEventFailureAttestationPredicate = null,
-    schemaResultValidationSubreason = null, schemaResultValidationKeyword = null) {
+    schemaResultValidationSubreason = null, schemaResultValidationKeyword = null,
+    providerEngineFailureBoundary = null) {
     super();
     delete this.stack;
     const answerFailureStage = GOVERNED_ANSWER_FAILURE_STAGES.has(stage) ? stage : 'unknown';
@@ -82,6 +85,11 @@ export class GovernedAnswerFailure extends Error {
       value: answerFailureStage,
       enumerable: true,
     });
+    if (answerFailureStage === 'provider_engine') Object.defineProperty(this, 'providerEngineFailureBoundary', {
+      value: GOVERNED_PROVIDER_ENGINE_FAILURE_BOUNDARIES.has(providerEngineFailureBoundary)
+        ? providerEngineFailureBoundary : null,
+      enumerable: true,
+    });
     if (answerFailureStage === 'native_event_grammar') Object.defineProperty(this, 'nativeEventFailureBoundary', {
       value: GOVERNED_NATIVE_EVENT_FAILURE_BOUNDARIES.has(nativeEventFailureBoundary)
         ? nativeEventFailureBoundary : null,
@@ -134,19 +142,22 @@ export class GovernedAnswerFailure extends Error {
 
 export function governedAnswerFailure(stage, nativeEventFailureBoundary = null, nativeEventFailureSubreason = null,
   nativeEventFailureCorrelationOperand = null, nativeEventFailureAttestationPredicate = null,
-  schemaResultValidationSubreason = null, schemaResultValidationKeyword = null) {
+  schemaResultValidationSubreason = null, schemaResultValidationKeyword = null,
+  providerEngineFailureBoundary = null) {
   return new GovernedAnswerFailure(stage, nativeEventFailureBoundary, nativeEventFailureSubreason,
     nativeEventFailureCorrelationOperand, nativeEventFailureAttestationPredicate,
-    schemaResultValidationSubreason, schemaResultValidationKeyword);
+    schemaResultValidationSubreason, schemaResultValidationKeyword, providerEngineFailureBoundary);
 }
 
 export function normalizeGovernedAnswerFailure(error, fallback = 'unknown', nativeEventFailureBoundary = null,
   nativeEventFailureSubreason = null, nativeEventFailureCorrelationOperand = null,
-  schemaResultValidationSubreason = null, schemaResultValidationKeyword = null) {
+  schemaResultValidationSubreason = null, schemaResultValidationKeyword = null,
+  providerEngineFailureBoundary = null, nativeEventFailureAttestationPredicate = null) {
   return error instanceof GovernedAnswerFailure ? error
     : governedAnswerFailure(fallback, nativeEventFailureBoundary, nativeEventFailureSubreason,
       nativeEventFailureCorrelationOperand,
       fallback === 'native_event_grammar' && nativeEventFailureBoundary === 'live_envelope_session' &&
-        nativeEventFailureSubreason === 'attestation' ? governedAttestationPredicate(error) : null,
-      schemaResultValidationSubreason, schemaResultValidationKeyword);
+        nativeEventFailureSubreason === 'attestation'
+        ? nativeEventFailureAttestationPredicate ?? governedAttestationPredicate(error) : null,
+      schemaResultValidationSubreason, schemaResultValidationKeyword, providerEngineFailureBoundary);
 }

package/build/utils/provider.js

@@ -7,6 +7,7 @@
 
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { createOpenAI } from '@ai-sdk/openai';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
 import { createGoogleGenerativeAI } from '@ai-sdk/google';
 import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
 
@@ -31,10 +32,19 @@ export function createProviderInstance(config) {
 			});
 
 		case 'openai': {
+			if (config.baseURL) {
+				// Non-OpenAI endpoints (Fireworks, etc.) — use openai-compatible provider
+				// which correctly handles reasoning_content in streaming deltas
+				const provider = createOpenAICompatible({
+					name: 'openai-compatible',
+					baseURL: config.baseURL,
+					apiKey: config.apiKey,
+				});
+				return provider;
+			}
 			const openai = createOpenAI({
 				compatibility: 'strict',
 				apiKey: config.apiKey,
-				...(config.baseURL && { baseURL: config.baseURL })
 			});
 			const chatProvider = (modelId, settings) => openai.chat(modelId, settings);
 			chatProvider.chat = openai.chat.bind(openai);