@vtxmacro/cli 2026.9.36 → 2026.9.38

package/bin/vtx.js

@@ -59,7 +59,7 @@ var init_define_VTX_EXO_POLICY = __esm({
 var define_VTX_GROK_POLICY_default;
 var init_define_VTX_GROK_POLICY = __esm({
   "<define:__VTX_GROK_POLICY__>"() {
-    define_VTX_GROK_POLICY_default = { subscription_proxy_base_url: "https://cli-chat-proxy.grok.com/v1", maximum_transport_request_bytes: 8388608, maximum_transport_response_bytes: 8388608, effective_model_aliases: { "grok-4.5": ["grok-4.5-build"] } };
+    define_VTX_GROK_POLICY_default = { subscription_proxy_base_url: "https://cli-chat-proxy.grok.com/v1", maximum_transport_request_bytes: 8388608, maximum_transport_response_bytes: 8388608 };
   }
 });
 
@@ -77,7 +77,7 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.9.36",
+      package_version: "2026.9.38",
       codex_package_name: "@openai/codex",
       codex_version: "0.153.3",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -389,9 +389,9 @@ function floatSafeRemainder(val, step) {
   const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
   return valInt % stepInt / 10 ** decCount;
 }
-function defineLazy(object5, key, getter) {
+function defineLazy(object6, key, getter) {
   let value = void 0;
-  Object.defineProperty(object5, key, {
+  Object.defineProperty(object6, key, {
     get() {
       if (value === EVALUATING) {
         return void 0;
@@ -403,7 +403,7 @@ function defineLazy(object5, key, getter) {
       return value;
     },
     set(v) {
-      Object.defineProperty(object5, key, {
+      Object.defineProperty(object6, key, {
         value: v
         // configurable: true,
       });
@@ -18654,28 +18654,28 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
         return await cachedSystemBootIdentity;
       }
       const read = async () => {
-        let identity = null;
+        let identity2 = null;
         if (platform === "linux") {
           try {
-            identity = (await readFile("/proc/sys/kernel/random/boot_id", "utf8")).trim();
+            identity2 = (await readFile("/proc/sys/kernel/random/boot_id", "utf8")).trim();
           } catch {
-            identity = null;
+            identity2 = null;
           }
         } else if (platform === "win32") {
           const invocation = windowsBootIdentityInvocation();
-          identity = await runSmallIdentityCommand(
+          identity2 = await runSmallIdentityCommand(
             "powershell.exe",
             invocation.args,
             invocation.env,
             invocation.timeoutMs
           );
         } else if (platform === "darwin") {
-          identity = await runSmallIdentityCommand("sysctl", ["-n", "kern.boottime"], void 0);
+          identity2 = await runSmallIdentityCommand("sysctl", ["-n", "kern.boottime"], void 0);
         }
-        if (!identity || /[\r\n\0]/u.test(identity)) {
+        if (!identity2 || /[\r\n\0]/u.test(identity2)) {
           throw new Error("Inference host could not establish the current system boot identity.");
         }
-        return `${platform}:${identity}`;
+        return `${platform}:${identity2}`;
       };
       const pending2 = read();
       if (platform === process.platform) cachedSystemBootIdentity = pending2;
@@ -18693,9 +18693,9 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
       return null;
     };
     defaultCurrentProcessIdentity = async () => {
-      const identity = await defaultProcessIdentity(process.pid);
-      if (!identity) throw new Error("Inference host could not establish its process-start identity.");
-      return identity;
+      const identity2 = await defaultProcessIdentity(process.pid);
+      if (!identity2) throw new Error("Inference host could not establish its process-start identity.");
+      return identity2;
     };
     processLockObservationCache = /* @__PURE__ */ new Map();
     inferenceProcessIdentitiesMatch = (stored, observed) => stored === observed;
@@ -18829,19 +18829,19 @@ function validateInferenceHostCredential(value) {
     updated_at: updatedAt
   };
 }
-function inferenceCredentialAccountKey(identity) {
-  const issuer = canonicalUrl(identity.issuer, "Inference OAuth issuer");
-  if (!identity.clientId || identity.clientId.length > 512) {
+function inferenceCredentialAccountKey(identity2) {
+  const issuer = canonicalUrl(identity2.issuer, "Inference OAuth issuer");
+  if (!identity2.clientId || identity2.clientId.length > 512) {
     throw new Error("Inference OAuth client ID is invalid.");
   }
-  if (!SAFE_IDENTIFIER.test(identity.hostId)) {
+  if (!SAFE_IDENTIFIER.test(identity2.hostId)) {
     throw new Error("Inference host ID is invalid.");
   }
   return createHash("sha256").update(
     JSON.stringify({
       issuer,
-      client_id: identity.clientId,
-      host_id: identity.hostId
+      client_id: identity2.clientId,
+      host_id: identity2.hostId
     }),
     "utf8"
   ).digest("hex");
@@ -24222,7 +24222,7 @@ var init_codex_adapter = __esm({
       reasoningContent: external_exports.string().min(1).max(CODEX_REASONING_CONTENT_MAX_UTF8_BYTES).nullable().optional().transform((value) => value ?? null),
       reasoningSummary: external_exports.string().min(1).max(CODEX_REASONING_SUMMARY_MAX_UTF8_BYTES).nullable().optional().transform((value) => value ?? null),
       requestedModel: external_exports.string().regex(CODEX_MODEL_NAME_PATTERN),
-      effectiveModel: external_exports.string().regex(CODEX_MODEL_NAME_PATTERN),
+      effectiveModel: external_exports.string().min(1).max(256).refine((value) => value.trim().length > 0 && !/[\u0000-\u001f\u007f]/u.test(value)),
       requestedReasoningEffort: external_exports.string().regex(CODEX_REASONING_EFFORT_PATTERN),
       effectiveReasoningEffort: external_exports.string().regex(CODEX_REASONING_EFFORT_PATTERN),
       adapterRequestId: external_exports.string().min(1).max(512),
@@ -24232,7 +24232,7 @@ var init_codex_adapter = __esm({
       timeToFirstTokenMs: external_exports.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).nullable(),
       terminalStatus: external_exports.literal("completed")
     }).superRefine((value, context) => {
-      if (value.reasoningContent != null && utf8Bytes(value.reasoningContent) > CODEX_REASONING_CONTENT_MAX_UTF8_BYTES || value.reasoningSummary != null && utf8Bytes(value.reasoningSummary) > CODEX_REASONING_SUMMARY_MAX_UTF8_BYTES || value.usage.cachedInputTokens > value.usage.inputTokens || value.usage.reasoningOutputTokens > value.usage.outputTokens || value.usage.totalTokens !== value.usage.inputTokens + value.usage.outputTokens || value.effectiveModel !== value.requestedModel || value.effectiveReasoningEffort !== value.requestedReasoningEffort) {
+      if (value.reasoningContent != null && utf8Bytes(value.reasoningContent) > CODEX_REASONING_CONTENT_MAX_UTF8_BYTES || value.reasoningSummary != null && utf8Bytes(value.reasoningSummary) > CODEX_REASONING_SUMMARY_MAX_UTF8_BYTES || value.usage.cachedInputTokens > value.usage.inputTokens || value.usage.reasoningOutputTokens > value.usage.outputTokens || value.usage.totalTokens !== value.usage.inputTokens + value.usage.outputTokens || value.effectiveReasoningEffort !== value.requestedReasoningEffort) {
         context.addIssue({ code: "custom", message: "Invalid Codex recovery usage or identity." });
       }
     });
@@ -25232,7 +25232,7 @@ var init_codex_adapter = __esm({
           }
           if (prior.terminal?.kind === "completed") {
             const recovered = prior.terminal.result;
-            if (recovered.requestedModel !== input.requestedModel || recovered.effectiveModel !== input.requestedModel || recovered.requestedReasoningEffort !== input.requestedReasoningEffort || recovered.effectiveReasoningEffort !== input.requestedReasoningEffort || recovered.terminalStatus !== "completed") {
+            if (recovered.requestedModel !== input.requestedModel || typeof recovered.effectiveModel !== "string" || recovered.effectiveModel.trim().length === 0 || recovered.effectiveModel.length > 256 || /[\u0000-\u001f\u007f]/u.test(recovered.effectiveModel) || recovered.requestedReasoningEffort !== input.requestedReasoningEffort || recovered.effectiveReasoningEffort !== input.requestedReasoningEffort || recovered.terminalStatus !== "completed") {
               throw new CodexAppServerError({
                 message: "Codex completed recovery receipt changed immutable model identity.",
                 category: "adapter",
@@ -25849,7 +25849,7 @@ import {
   RuntimeConnection,
   defineTool
 } from "@github/copilot-sdk";
-var COPILOT_SDK_VERSION, MAX_RESULT_BYTES, resolveRuntimePackage, copilotRuntimePackageCandidates, resolvePinnedCopilotCliPath, createPrivateWorkspace, cleanCopilotEnvironment, defaultClient, modelCapabilities, requiredUsageInteger, optionalUsageInteger, copilotAgentToolDefinitions, CopilotSubscriptionAdapter;
+var COPILOT_SDK_VERSION, MAX_RESULT_BYTES, resolveRuntimePackage, copilotRuntimePackageCandidates, resolvePinnedCopilotCliPath, createPrivateWorkspace, cleanCopilotEnvironment, defaultClient, modelCapabilities, requiredUsageInteger, optionalUsageInteger, responseModelLabel, coherentResponseModel, copilotAgentToolDefinitions, CopilotSubscriptionAdapter;
 var init_copilot_adapter = __esm({
   "lib/inference-host/copilot-adapter.ts"() {
     "use strict";
@@ -25948,9 +25948,20 @@ var init_copilot_adapter = __esm({
       }
       return Number(value);
     };
-    copilotAgentToolDefinitions = (input, evidence) => {
+    responseModelLabel = (value) => {
+      if (typeof value !== "string" || value.trim().length === 0 || value.length > 256 || /[\u0000-\u001f\u007f]/u.test(value)) {
+        throw new Error("copilot_effective_model_invalid");
+      }
+      return value;
+    };
+    coherentResponseModel = (models) => {
+      if (models.size !== 1) throw new Error("copilot_effective_model_mismatch");
+      return [...models][0];
+    };
+    copilotAgentToolDefinitions = (input, evidence, beforeExecute) => {
       const execute = async (tool, argumentsValue) => {
         const argumentsRecord = argumentsValue && typeof argumentsValue === "object" && !Array.isArray(argumentsValue) ? argumentsValue : {};
+        await beforeExecute();
         const callId = randomUUID();
         const result2 = await input.executeTool({
           callId,
@@ -26149,7 +26160,7 @@ ${input.outputSchemaJson}`
           let providerCallId = null;
           for (const event of usageEvents) {
             if (event.type !== "assistant.usage") continue;
-            observedModels.add(event.data.model);
+            observedModels.add(responseModelLabel(event.data.model));
             if (event.data.reasoningEffort) observedEfforts.add(event.data.reasoningEffort);
             inputTokens += requiredUsageInteger(event.data.inputTokens, "input_tokens");
             cachedInputTokens += optionalUsageInteger(event.data.cacheReadTokens, "cache_read_tokens");
@@ -26170,10 +26181,8 @@ ${input.outputSchemaJson}`
           if (usageEvents.length === 0) {
             throw new Error("copilot_usage_receipt_missing");
           }
-          if (response.data.model) observedModels.add(response.data.model);
-          if (observedModels.size !== 1 || !observedModels.has(input.requestedModel)) {
-            throw new Error("copilot_effective_model_mismatch");
-          }
+          if (response.data.model !== void 0) observedModels.add(responseModelLabel(response.data.model));
+          const effectiveModel = coherentResponseModel(observedModels);
           const effectiveEffort = input.requestedReasoningEffort === "none" ? observedEfforts.size === 0 ? "none" : observedEfforts.size === 1 ? [...observedEfforts][0] : null : observedEfforts.size === 1 ? [...observedEfforts][0] : null;
           if (effectiveEffort !== input.requestedReasoningEffort) {
             throw new Error("copilot_effective_effort_mismatch");
@@ -26192,7 +26201,7 @@ ${input.outputSchemaJson}`
             reasoningContent: response.data.reasoningText ?? null,
             reasoningSummary: null,
             requestedModel: input.requestedModel,
-            effectiveModel: input.requestedModel,
+            effectiveModel,
             requestedReasoningEffort: input.requestedReasoningEffort,
             effectiveReasoningEffort: effectiveEffort,
             adapterRequestId: providerCallId ?? response.data.requestId ?? response.data.messageId,
@@ -26261,9 +26270,22 @@ ${input.outputSchemaJson}`
         let durableCheckpointed = input.durableThread !== null;
         let dispatchEntered = false;
         const toolEvidence = [];
+        const observedModels = /* @__PURE__ */ new Set();
+        let modelReceiptError = null;
+        let thread = null;
+        const checkpointObservedModel = async () => {
+          if (modelReceiptError) throw modelReceiptError;
+          if (observedModels.size === 0 || !thread) return;
+          const effectiveModel = coherentResponseModel(observedModels);
+          if (thread.effectiveModel !== effectiveModel) {
+            const updatedThread = { ...thread, effectiveModel };
+            await input.onThreadReady?.(updatedThread);
+            thread = updatedThread;
+          }
+        };
         try {
           await client.start();
-          const tools = copilotAgentToolDefinitions(input, toolEvidence);
+          const tools = copilotAgentToolDefinitions(input, toolEvidence, checkpointObservedModel);
           const sessionConfig = {
             clientName: "@vtxmacro/cli durable Copilot Agent host",
             model: input.requestedModel,
@@ -26289,7 +26311,7 @@ ${JSON.stringify(input.outputSchema)}`
             workspacePath,
             cleanup: ownedWorkspace?.cleanup ?? null
           };
-          const thread = {
+          thread = {
             threadId: session.sessionId,
             threadPath: workspacePath,
             effectiveModel: input.requestedModel,
@@ -26301,7 +26323,15 @@ ${JSON.stringify(input.outputSchema)}`
           }
           const usageEvents = [];
           session.on((event) => {
-            if (event.type === "assistant.usage" && !event.agentId) usageEvents.push(event);
+            if (event.type === "assistant.usage" && !event.agentId) {
+              usageEvents.push(event);
+              try {
+                observedModels.add(responseModelLabel(event.data.model));
+                coherentResponseModel(observedModels);
+              } catch (error48) {
+                modelReceiptError = error48;
+              }
+            }
           });
           const onAbort = () => {
             void session?.abort().catch(() => void 0);
@@ -26320,7 +26350,6 @@ ${JSON.stringify(input.outputSchema)}`
           if (!response?.data.content || Buffer.byteLength(response.data.content, "utf8") > MAX_RESULT_BYTES) {
             throw new Error("copilot_agent_invalid_result");
           }
-          const observedModels = /* @__PURE__ */ new Set();
           const observedEfforts = /* @__PURE__ */ new Set();
           let inputTokens = 0;
           let cachedInputTokens = 0;
@@ -26332,7 +26361,7 @@ ${JSON.stringify(input.outputSchema)}`
           let providerCallId = null;
           for (const event of usageEvents) {
             if (event.type !== "assistant.usage") continue;
-            observedModels.add(event.data.model);
+            observedModels.add(responseModelLabel(event.data.model));
             if (event.data.reasoningEffort) observedEfforts.add(event.data.reasoningEffort);
             inputTokens += requiredUsageInteger(event.data.inputTokens, "input_tokens");
             cachedInputTokens += optionalUsageInteger(event.data.cacheReadTokens, "cache_read_tokens");
@@ -26348,10 +26377,9 @@ ${JSON.stringify(input.outputSchema)}`
             providerCallId = event.data.providerCallId ?? event.data.apiCallId ?? providerCallId;
           }
           if (usageEvents.length === 0) throw new Error("copilot_agent_usage_receipt_missing");
-          if (response.data.model) observedModels.add(response.data.model);
-          if (observedModels.size !== 1 || !observedModels.has(input.requestedModel)) {
-            throw new Error("copilot_agent_effective_model_mismatch");
-          }
+          if (response.data.model !== void 0) observedModels.add(responseModelLabel(response.data.model));
+          const effectiveModel = coherentResponseModel(observedModels);
+          await checkpointObservedModel();
           const effectiveEffort = input.requestedReasoningEffort === "none" ? observedEfforts.size === 0 ? "none" : observedEfforts.size === 1 ? [...observedEfforts][0] : null : observedEfforts.size === 1 ? [...observedEfforts][0] : null;
           if (effectiveEffort !== input.requestedReasoningEffort) {
             throw new Error("copilot_agent_effective_effort_mismatch");
@@ -26372,7 +26400,7 @@ ${JSON.stringify(input.outputSchema)}`
               reasoningContent: response.data.reasoningText ?? null,
               reasoningSummary: null,
               requestedModel: input.requestedModel,
-              effectiveModel: input.requestedModel,
+              effectiveModel,
               requestedReasoningEffort: input.requestedReasoningEffort,
               effectiveReasoningEffort: effectiveEffort,
               adapterRequestId: providerCallId ?? response.data.requestId ?? response.data.messageId,
@@ -26482,6 +26510,7 @@ var init_deepseek_transport_proxy = __esm({
         this.upstreamRequestStartedValue = false;
         this.providerResponseObservedValue = false;
         this.unansweredUpstreamRequestsValue = 0;
+        this.latestReceiptValue = null;
       }
       get baseUrl() {
         if (!this.urlValue) throw new Error("deepseek_transport_proxy_not_started");
@@ -26490,6 +26519,9 @@ var init_deepseek_transport_proxy = __esm({
       get receipts() {
         return [...this.receiptsValue];
       }
+      get lastReceipt() {
+        return this.latestReceiptValue;
+      }
       get providerResponseObserved() {
         return this.providerResponseObservedValue;
       }
@@ -26528,6 +26560,7 @@ var init_deepseek_transport_proxy = __esm({
             const controller = new AbortController();
             this.controllers.add(controller);
             try {
+              this.latestReceiptValue = null;
               this.upstreamRequestStartedValue = true;
               this.unansweredUpstreamRequestsValue += 1;
               const upstream = await this.fetchImpl(
@@ -26571,6 +26604,7 @@ var init_deepseek_transport_proxy = __esm({
               const decoder2 = new TextDecoder();
               let pending2 = "";
               let observedId = "";
+              let observedModel = "";
               let terminalObserved = false;
               const forwardLine = (line) => {
                 if (!line.startsWith("data:")) {
@@ -26585,25 +26619,18 @@ var init_deepseek_transport_proxy = __esm({
                   return;
                 }
                 if (value === "[DONE]") {
-                  if (terminalObserved || !observedId) {
+                  if (terminalObserved || !observedId || !observedModel) {
                     throw new Error("deepseek_provider_receipt_missing_or_mismatched");
                   }
                   terminalObserved = true;
-                  this.receiptsValue.push({
-                    id: observedId,
-                    model: this.expectedModel,
-                    requestedModel,
-                    requestedReasoningEffort: requestedEffort
-                  });
-                  response.write(`${line}
-`);
                   return;
                 }
                 const event = JSON.parse(value);
                 const eventId = typeof event.id === "string" ? event.id.trim() : "";
-                const eventModel = typeof event.model === "string" ? event.model.trim() : "";
-                if (!eventId || eventModel !== this.expectedModel || observedId && eventId !== observedId) throw new Error("deepseek_provider_receipt_missing_or_mismatched");
+                const eventModel = typeof event.model === "string" ? event.model : "";
+                if (terminalObserved || !eventId || !eventModel.trim() || eventModel.length > 256 || /[\u0000-\u001f\u007f]/u.test(eventModel) || observedModel && eventModel !== observedModel || observedId && eventId !== observedId) throw new Error("deepseek_provider_receipt_missing_or_mismatched");
                 observedId = eventId;
+                observedModel = eventModel;
                 response.write(`${line}
 `);
               };
@@ -26620,6 +26647,10 @@ var init_deepseek_transport_proxy = __esm({
               if (!terminalObserved) {
                 throw new Error("deepseek_provider_receipt_missing_or_mismatched");
               }
+              const receipt = { id: observedId, model: observedModel, requestedModel, requestedReasoningEffort: requestedEffort };
+              this.receiptsValue.push(receipt);
+              this.latestReceiptValue = receipt;
+              response.write("data: [DONE]\n\n");
               response.end();
             } finally {
               this.controllers.delete(controller);
@@ -27145,6 +27176,12 @@ ${JSON.stringify(input.outputSchema)}`,
                 },
                 execute: async (argumentsValue) => {
                   const argumentsRecord = argumentsValue && typeof argumentsValue === "object" && !Array.isArray(argumentsValue) ? argumentsValue : {};
+                  const receipt = proxy.lastReceipt;
+                  if (!receipt) throw new Error("deepseek_harness_agent_receipt_missing");
+                  if (thread.effectiveModel !== receipt.model) {
+                    thread = { ...thread, effectiveModel: receipt.model };
+                    await input.onThreadReady?.(thread);
+                  }
                   const callId = randomUUID2();
                   const result2 = await input.executeTool({ callId, tool: definition.name, arguments: argumentsRecord });
                   evidence.push({ callId, tool: definition.name, arguments: argumentsRecord, success: result2.success });
@@ -27192,7 +27229,7 @@ ${JSON.stringify(input.outputSchema)}`,
               yield* next();
             })();
           });
-          const thread = {
+          let thread = {
             threadId: String(sessionId),
             threadPath: rootPath,
             effectiveModel: input.requestedModel,
@@ -27244,6 +27281,10 @@ ${JSON.stringify(input.outputSchema)}`,
           }
           const text = validateText(textFromBlocks(last.data.message.content, "text"), "deepseek_harness_agent_result_invalid");
           const receipts = proxy.receipts;
+          if (thread.effectiveModel !== receipts.at(-1).model) {
+            thread = { ...thread, effectiveModel: receipts.at(-1).model };
+            await input.onThreadReady?.(thread);
+          }
           await handle.dispose();
           return {
             thread,
@@ -33852,7 +33893,7 @@ var init_pi_transport = __esm({
         if (new Set(this.receipts.map((receipt) => receipt.id)).size !== this.receipts.length) throw new Error("pi_response_identity_reused");
         for (const receipt of this.receipts) {
           if (receipt.reasoningEffortChanged || (this.options.model.reasoning ? receipt.reasoningEffort !== this.options.expectedEffort.native : receipt.reasoningEffort !== null && receipt.reasoningEffort !== "none")) throw new Error("pi_native_effort_mismatch");
-          if (!receipt.id || receipt.model !== this.options.model.id || !receipt.terminal || receipt.input === null || receipt.output === null || receipt.cachedInput > receipt.input || receipt.input + receipt.output <= 0) {
+          if (!receipt.id || typeof receipt.model !== "string" || !receipt.model.trim() || receipt.model.length > 256 || /[\u0000-\u001f\u007f]/u.test(receipt.model) || !receipt.terminal || receipt.input === null || receipt.output === null || receipt.cachedInput > receipt.input || receipt.input + receipt.output <= 0) {
             throw new Error("pi_native_receipt_unqualified");
           }
         }
@@ -34080,7 +34121,7 @@ var init_pi_adapter = __esm({
             if (this.activeThreads.has(cwd)) throw fail("pi_thread_busy");
             this.activeThreads.add(cwd);
             ownedPath = cwd;
-            if (agent.durableThread && (agent.durableThread.effectiveModel !== input.requestedModel || agent.durableThread.effectiveReasoningEffort !== input.requestedReasoningEffort)) throw fail("pi_thread_binding_changed", "model");
+            if (agent.durableThread && agent.durableThread.effectiveReasoningEffort !== input.requestedReasoningEffort) throw fail("pi_thread_binding_changed", "model");
           }
           const settings = SettingsManager.inMemory({
             retry: { enabled: false, maxRetries: 0, provider: { maxRetries: 0 } },
@@ -34107,6 +34148,8 @@ var init_pi_adapter = __esm({
             if (!info.isFile() || info.isSymbolicLink()) throw fail("pi_session_not_owned");
             manager = SessionManager.open(sessionFile, cwd, cwd);
             if (manager.getSessionId() !== agent.durableThread.threadId || manager.getHeader()?.cwd !== cwd) throw fail("pi_session_binding_changed");
+            const selection = manager.buildSessionContext().model;
+            if (!selection || selection.provider !== model.provider || selection.modelId !== model.id) throw fail("pi_thread_binding_changed", "model");
           } else if (agent) {
             const initial = SessionManager.inMemory(cwd, { id: basename2(cwd).slice("agent-".length) });
             await writeAtomicInferencePrivateFile(sessionFile, `${JSON.stringify(initial.getHeader())}
@@ -34150,6 +34193,11 @@ var init_pi_adapter = __esm({
                 session?.agent.abort();
                 throw boundaryFailure;
               }
+              const effectiveModel2 = `${model.provider}/${transport.lastReceipt.model}`;
+              if (thread && thread.effectiveModel !== effectiveModel2) {
+                thread = { ...thread, effectiveModel: effectiveModel2 };
+                await agent.onThreadReady?.(thread);
+              }
               const tool = definition.name;
               const result2 = await agent.executeTool({ callId, tool, arguments: args });
               tools.push({ callId, tool, arguments: args, success: result2.success });
@@ -34248,7 +34296,7 @@ var init_pi_adapter = __esm({
           for (let i = 0; i < messages.length; i++) {
             const message = messages[i];
             const native = observer.receipts[i];
-            if (message.responseId !== native.id || message.provider !== model.provider || message.model !== model.id || message.usage.input + message.usage.cacheRead + message.usage.cacheWrite !== native.input || message.usage.output !== native.output || message.usage.cacheRead !== native.cachedInput) throw fail("pi_receipt_mismatch");
+            if (message.responseId !== native.id || message.provider !== model.provider || message.usage.input + message.usage.cacheRead + message.usage.cacheWrite !== native.input || message.usage.output !== native.output || message.usage.cacheRead !== native.cachedInput) throw fail("pi_receipt_mismatch");
           }
           if (!last) throw fail("pi_result_missing");
           if (last.stopReason !== "stop") throw fail("pi_terminal_incomplete");
@@ -34262,13 +34310,18 @@ var init_pi_adapter = __esm({
           }
           if (!validateOutput(output3)) throw fail("pi_output_schema_mismatch", "schema");
           const reasoning = last.content.flatMap((part) => part.type === "thinking" ? [part.thinking] : []).join("");
+          const effectiveModel = `${model.provider}/${observer.receipts.at(-1).model}`;
+          if (agent && thread && thread.effectiveModel !== effectiveModel) {
+            thread = { ...thread, effectiveModel };
+            await agent.onThreadReady?.(thread);
+          }
           if (!agent) input.onTerminalDispatchOutcome?.("confirmed_dispatched");
           return { thread, tools, turn: {
             text,
             reasoningContent: reasoning ? Buffer.from(reasoning).subarray(0, 32768).toString("utf8") : null,
             reasoningSummary: null,
             requestedModel: input.requestedModel,
-            effectiveModel: `${model.provider}/${observer.receipts.at(-1).model}`,
+            effectiveModel,
             requestedReasoningEffort: input.requestedReasoningEffort,
             effectiveReasoningEffort: observer.effectiveReasoningEffort(),
             adapterRequestId: observer.receipts[0].id,
@@ -34292,7 +34345,9 @@ var init_pi_adapter = __esm({
             };
             try {
               const effort2 = transport.effectiveReasoningEffort();
-              terminalEvidence = { ...terminalEvidence, effectiveModel: input.requestedModel, effectiveReasoningEffort: effort2 };
+              const provider = input.requestedModel.slice(0, input.requestedModel.indexOf("/"));
+              const actualModel = transport.lastReceipt?.model;
+              if (actualModel) terminalEvidence = { ...terminalEvidence, effectiveModel: `${provider}/${actualModel}`, effectiveReasoningEffort: effort2 };
             } catch {
             }
           }
@@ -34300,7 +34355,7 @@ var init_pi_adapter = __esm({
           try {
             const qualified = messages.filter((message, index) => {
               const receipt = transport?.receipts[index];
-              return receipt && receipt.terminal && receipt.id === message.responseId && `${message.provider}/${receipt.model}` === input.requestedModel && message.usage.input + message.usage.cacheRead + message.usage.cacheWrite === receipt.input && message.usage.output === receipt.output && message.usage.cacheRead === receipt.cachedInput && (receipt.input ?? 0) + (receipt.output ?? 0) > 0;
+              return receipt && receipt.terminal && receipt.id === message.responseId && message.provider === input.requestedModel.slice(0, input.requestedModel.indexOf("/")) && typeof receipt.model === "string" && Boolean(receipt.model.trim()) && receipt.model.length <= 256 && !/[\u0000-\u001f\u007f]/u.test(receipt.model) && message.usage.input + message.usage.cacheRead + message.usage.cacheWrite === receipt.input && message.usage.output === receipt.output && message.usage.cacheRead === receipt.cachedInput && (receipt.input ?? 0) + (receipt.output ?? 0) > 0;
             });
             if (qualified.length) usage = usageSum(qualified);
           } catch {
@@ -34484,7 +34539,7 @@ var init_grok_binary = __esm({
 import { readFile as readFile6 } from "node:fs/promises";
 import { dirname as dirname7, resolve as resolve5 } from "node:path";
 import { fileURLToPath } from "node:url";
-var validateGrokPolicy, grokAllowedEffectiveModels, loadGrokPolicy;
+var validateGrokPolicy, loadGrokPolicy;
 var init_grok_policy = __esm({
   "lib/inference-host/grok-policy.ts"() {
     "use strict";
@@ -34502,26 +34557,12 @@ var init_grok_policy = __esm({
           throw new Error("Grok transport bounds are missing or invalid.");
         }
       }
-      const aliases = policy.effective_model_aliases;
-      if (!aliases || typeof aliases !== "object" || Array.isArray(aliases) || ![Object.prototype, null].includes(Object.getPrototypeOf(aliases)) || Object.keys(aliases).length > 64) throw new Error("Grok effective model aliases are missing or invalid.");
-      const validModel = (model) => typeof model === "string" && model.length > 0 && model.length <= 256 && model.trim() === model && !/[\u0000-\u001f\u007f]/u.test(model);
-      const entries = Object.entries(aliases);
-      for (const [requested, effective] of entries) {
-        if (!validModel(requested) || !Array.isArray(effective) || effective.length < 1 || effective.length > 15 || !effective.every(validModel) || new Set(effective).size !== effective.length || effective.includes(requested)) {
-          throw new Error("Grok effective model aliases are missing or invalid.");
-        }
-      }
-      const effectiveModelAliases = Object.freeze(Object.fromEntries(
-        entries.map(([requested, effective]) => [requested, Object.freeze([...effective])])
-      ));
       return Object.freeze({
         subscription_proxy_base_url: url2.href,
         maximum_transport_request_bytes: Number(policy.maximum_transport_request_bytes),
-        maximum_transport_response_bytes: Number(policy.maximum_transport_response_bytes),
-        effective_model_aliases: effectiveModelAliases
+        maximum_transport_response_bytes: Number(policy.maximum_transport_response_bytes)
       });
     };
-    grokAllowedEffectiveModels = (policy, requested) => Object.freeze([requested, ...Object.hasOwn(policy.effective_model_aliases, requested) ? policy.effective_model_aliases[requested] : []]);
     loadGrokPolicy = async () => {
       if (typeof define_VTX_GROK_POLICY_default !== "undefined") return validateGrokPolicy(define_VTX_GROK_POLICY_default);
       const config2 = parse3(await readFile6(resolve5(dirname7(fileURLToPath(import.meta.url)), "../../../config.toml"), "utf8"));
@@ -34530,6 +34571,46 @@ var init_grok_policy = __esm({
   }
 });
 
+// lib/inference-host/grok-model-catalog.ts
+var object3, identity, parseGrokModelCatalog;
+var init_grok_model_catalog = __esm({
+  "lib/inference-host/grok-model-catalog.ts"() {
+    "use strict";
+    init_define_VTX_EXO_POLICY();
+    init_define_VTX_GROK_POLICY();
+    init_define_VTX_PI_MODEL_POLICY();
+    object3 = (value) => {
+      if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("grok_model_catalog_invalid");
+      return value;
+    };
+    identity = (value) => {
+      if (value == null) return void 0;
+      if (typeof value !== "string" || !value || value !== value.trim() || value.length > 256 || /[\u0000-\u001f\u007f]/u.test(value)) throw new Error("grok_model_catalog_identity_invalid");
+      return value;
+    };
+    parseGrokModelCatalog = (value) => {
+      const data4 = object3(value).data;
+      if (!Array.isArray(data4)) throw new Error("grok_model_catalog_invalid");
+      const result2 = /* @__PURE__ */ new Map();
+      for (const raw of data4) {
+        const row = object3(raw);
+        const meta3 = row._meta == null ? {} : object3(row._meta);
+        const id2 = identity(row.id);
+        const transportModel = identity(row.model) ?? identity(row.modelId) ?? id2 ?? identity(meta3.model) ?? identity(meta3.modelId);
+        if (!transportModel) throw new Error("grok_model_catalog_identity_missing");
+        const selector = id2 ?? transportModel;
+        if (result2.has(selector)) throw new Error("grok_model_catalog_identity_ambiguous");
+        result2.set(selector, Object.freeze({
+          selector,
+          transportModel,
+          allowedEffectiveModels: Object.freeze([.../* @__PURE__ */ new Set([selector, transportModel])])
+        }));
+      }
+      return result2;
+    };
+  }
+});
+
 // lib/inference-host/grok-transport-proxy.ts
 import { createServer as createServer3 } from "node:http";
 import { createHash as createHash6, randomBytes as randomBytes5 } from "node:crypto";
@@ -34541,6 +34622,7 @@ var init_grok_transport_proxy = __esm({
     init_define_VTX_EXO_POLICY();
     init_define_VTX_GROK_POLICY();
     init_define_VTX_PI_MODEL_POLICY();
+    init_grok_model_catalog();
     init_external_inference_contract();
     diagnosticNames = /* @__PURE__ */ new Set([
       "search_tool",
@@ -34574,6 +34656,8 @@ var init_grok_transport_proxy = __esm({
         this.requestFingerprints = /* @__PURE__ */ new Set();
         this.pending = false;
         this.closed = false;
+        this.catalogValue = null;
+        this.boundIdentity = null;
         this.observedModel = null;
         this.dispatched = false;
         this.responded = false;
@@ -34583,11 +34667,7 @@ var init_grok_transport_proxy = __esm({
         this.toolValidationFailure = null;
         this.responseIdentityFailure = null;
         const upstream = new URL(options.upstreamBaseUrl);
-        const models = options.allowedEffectiveModels ?? [options.requestedModel];
-        if (!models.includes(options.requestedModel) || models.length > 16 || new Set(models).size !== models.length || models.some((model) => typeof model !== "string" || !model.trim())) {
-          throw new Error("grok_proxy_invalid_configuration");
-        }
-        if (upstream.protocol !== "https:" || upstream.username || upstream.password || upstream.search || upstream.hash || !options.requestedModel || typeof options.expectedSystemPrompt !== "string" || !Number.isSafeInteger(options.deadlineAtMs) || options.providerDispatchNotAfterMs !== void 0 && !Number.isSafeInteger(options.providerDispatchNotAfterMs) || !Number.isSafeInteger(options.maxRequestBytes) || options.maxRequestBytes < 1 || !Number.isSafeInteger(options.maxResponseBytes) || options.maxResponseBytes < 1 || new Set(options.allowedToolNames).size !== options.allowedToolNames.length || options.allowedToolNames.some((name) => !name)) throw new Error("grok_proxy_invalid_configuration");
+        if (upstream.protocol !== "https:" || upstream.username || upstream.password || upstream.search || upstream.hash || !options.metadataOnly && !options.requestedModel || typeof options.expectedSystemPrompt !== "string" || !Number.isSafeInteger(options.deadlineAtMs) || options.providerDispatchNotAfterMs !== void 0 && !Number.isSafeInteger(options.providerDispatchNotAfterMs) || !Number.isSafeInteger(options.maxRequestBytes) || options.maxRequestBytes < 1 || !Number.isSafeInteger(options.maxResponseBytes) || options.maxResponseBytes < 1 || new Set(options.allowedToolNames).size !== options.allowedToolNames.length || options.allowedToolNames.some((name) => !name)) throw new Error("grok_proxy_invalid_configuration");
       }
       get baseUrl() {
         if (!this.urlValue) throw new Error("grok_proxy_not_started");
@@ -34602,6 +34682,18 @@ var init_grok_transport_proxy = __esm({
       get pendingRequest() {
         return this.pending;
       }
+      get modelCatalog() {
+        return this.catalogValue ? new Map(this.catalogValue) : null;
+      }
+      bindModelIdentity(selector, frozenProviderAllowance) {
+        if (this.options.metadataOnly || this.boundIdentity || this.pending || this.dispatched || this.closed || selector !== this.options.requestedModel) throw new Error("grok_model_identity_binding_invalid");
+        const identity2 = this.catalogValue?.get(selector);
+        if (!identity2) throw new Error("grok_model_catalog_identity_missing");
+        const allowed = identity2.allowedEffectiveModels.filter((model) => !frozenProviderAllowance || frozenProviderAllowance.includes(model));
+        if (!allowed.includes(identity2.transportModel)) throw new Error("grok_model_catalog_identity_changed");
+        this.boundIdentity = Object.freeze({ ...identity2, allowedEffectiveModels: Object.freeze(allowed) });
+        return this.boundIdentity;
+      }
       async start() {
         if (this.server) return;
         if (this.closed) throw new Error("grok_proxy_closed");
@@ -34651,7 +34743,8 @@ var init_grok_transport_proxy = __esm({
       }
       validatePayload(payload, route) {
         const requestedEffort = route === "/responses" ? record3(payload.reasoning).effort : payload.reasoning_effort;
-        if (payload.model !== this.options.requestedModel || effort(requestedEffort) !== effort(this.options.requestedReasoningEffort)) {
+        if (!this.boundIdentity) throw new Error("grok_model_identity_not_bound");
+        if (payload.model !== this.boundIdentity.transportModel || effort(requestedEffort) !== effort(this.options.requestedReasoningEffort)) {
           throw new Error("grok_outbound_model_or_effort_mismatch");
         }
         if (payload.stream !== true) throw new Error("grok_streaming_required");
@@ -34704,6 +34797,7 @@ var init_grok_transport_proxy = __esm({
           if (!authorization?.startsWith("Bearer ") || authorization.length <= 7) throw new Error("grok_proxy_auth_required");
           let body;
           if (inference) {
+            if (this.options.metadataOnly) throw new Error("grok_metadata_only");
             if (this.pending || this.failureCode || this.terminalFailure || this.rejectionStatus) {
               throw new Error("grok_redispatch_blocked");
             }
@@ -34754,7 +34848,7 @@ var init_grok_transport_proxy = __esm({
             if (typeof value === "string") headers.set(name, value);
           }
           if (inference) {
-            if (headers.has("x-grok-model-override") && headers.get("x-grok-model-override") !== this.options.requestedModel) {
+            if (headers.has("x-grok-model-override") && headers.get("x-grok-model-override") !== this.boundIdentity.transportModel) {
               throw new Error("grok_outbound_model_or_effort_mismatch");
             }
             this.checkDispatch();
@@ -34792,6 +34886,29 @@ var init_grok_transport_proxy = __esm({
             const value = upstream.headers.get(name);
             if (value) responseHeaders[name] = value;
           }
+          if (metadata && route === "/models") {
+            const chunks = [];
+            let bytes3 = 0;
+            const reader = upstream.body.getReader();
+            try {
+              for (; ; ) {
+                if (controller.signal.aborted) throw new Error("grok_proxy_cancelled");
+                const part = await reader.read();
+                if (part.done) break;
+                bytes3 += part.value.byteLength;
+                if (bytes3 > this.options.maxResponseBytes) throw new Error("grok_response_too_large");
+                chunks.push(part.value);
+              }
+            } finally {
+              await reader.cancel().catch(() => void 0);
+            }
+            const catalogBytes = Buffer.concat(chunks);
+            const catalog = parseGrokModelCatalog(JSON.parse(catalogBytes.toString("utf8")));
+            if (!this.boundIdentity) this.catalogValue = catalog;
+            response.writeHead(upstream.status, responseHeaders);
+            response.end(catalogBytes);
+            return;
+          }
           response.writeHead(upstream.status, responseHeaders);
           await this.forward(upstream, response, inference ? route : null, controller.signal);
           response.end();
@@ -34858,17 +34975,17 @@ var init_grok_transport_proxy = __esm({
           const event = record3(JSON.parse(data4));
           const native = route === "/responses" ? record3(event.response) : event;
           if (native.id !== void 0 || native.model !== void 0) {
-            if (typeof native.id !== "string" || !native.id || !(this.options.allowedEffectiveModels ?? [this.options.requestedModel]).includes(native.model) || id2 && native.id !== id2) {
+            if (typeof native.id !== "string" || !native.id || typeof native.model !== "string" || !native.model.trim() || native.model.length > 256 || /[\u0000-\u001f\u007f]/u.test(native.model) || id2 && native.id !== id2) {
               const idPresent = typeof native.id === "string" && native.id.length > 0;
               const modelPresent = typeof native.model === "string" && native.model.length > 0;
               const modelMatches = native.model === this.options.requestedModel;
-              if (idPresent && !modelMatches && id2 && native.id !== id2 && (this.options.allowedEffectiveModels ?? [this.options.requestedModel]).includes(native.model)) {
+              if (idPresent && !modelMatches && id2 && native.id !== id2) {
                 throw new Error("grok_provider_response_id_changed");
               }
               const eventType = route === "/responses" ? event.type : event.object;
               this.responseIdentityFailure = grokResponseIdentityDiagnosticSchema.parse({
                 schema_version: "external_inference_grok_response_identity_v1",
-                reason: !idPresent ? "invalid_id" : !modelMatches ? "model_mismatch" : "changed_id",
+                reason: !idPresent ? "invalid_id" : id2 && native.id !== id2 ? "changed_id" : "model_mismatch",
                 route,
                 response_event: ["response.created", "response.in_progress", "response.completed", "chat.completion.chunk"].includes(String(eventType)) ? eventType : "other",
                 id_present: idPresent,
@@ -35543,11 +35660,11 @@ var init_grok_adapter = __esm({
         isDefault: state.currentModelId === model.modelId
       }];
     });
-    grokPromptUsage = (value, expectedModel, allowedEffectiveModels = [expectedModel]) => {
+    grokPromptUsage = (value, expectedModel) => {
       const usage = grokObject(value);
       if (usage.usageIsIncomplete === true) throw new Error("grok_usage_incomplete");
       const models = Object.keys(grokObject(usage.modelUsage));
-      if (models.length !== 1 || !allowedEffectiveModels.includes(models[0])) throw new Error("grok_effective_model_mismatch");
+      if (models.length !== 1 || models[0] !== expectedModel) throw new Error("grok_effective_model_mismatch");
       const inputTokens = integer2(usage.inputTokens, "input_tokens");
       const outputTokens = integer2(usage.outputTokens, "output_tokens");
       const cachedInputTokens = integer2(usage.cachedReadTokens, "cached_input_tokens");
@@ -35641,29 +35758,49 @@ var init_grok_adapter = __esm({
         signal.throwIfAborted();
         const workspace = await createGrokOwnedWorkspace(this.stateOptions, "preflight");
         let session = null;
+        let proxy = null;
         try {
           signal.throwIfAborted();
-          session = new GrokAcpSession({ binaryPath: binary.path, grokHome: this.grokHome, cwd: workspace });
-          this.active.add(session);
           const deadline = Date.now() + 3e4;
+          const policy = this.options.policy ?? await loadGrokPolicy();
+          proxy = await createGrokTransportProxy({
+            upstreamBaseUrl: policy.subscription_proxy_base_url,
+            maxRequestBytes: policy.maximum_transport_request_bytes,
+            maxResponseBytes: policy.maximum_transport_response_bytes,
+            metadataOnly: true,
+            requestedModel: "",
+            requestedReasoningEffort: "none",
+            expectedSystemPrompt: "",
+            allowedToolNames: [],
+            deadlineAtMs: deadline,
+            signal,
+            fetchImpl: this.options.fetchImpl
+          });
+          session = new GrokAcpSession({
+            binaryPath: binary.path,
+            grokHome: this.grokHome,
+            cwd: workspace,
+            config: { endpoints: { cli_chat_proxy_base_url: proxy.baseUrl } }
+          });
+          this.active.add(session);
           await this.initialize(session, "VTX inference host capability discovery.", deadline, signal);
           const auth = unwrap(await session.request("_x.ai/auth/info", {}, deadline, signal));
           if (auth.methodId !== "cached_token" || auth.userBlockedReason || list(auth.teamBlockedReasons).length) {
             throw new Error("grok_subscription_auth_unavailable");
           }
           const state = unwrap(await session.request("_x.ai/models/list", {}, deadline, signal));
-          const policy = this.options.policy ?? await loadGrokPolicy();
-          const capabilities = grokModelCapabilities(state).map((capability) => ({
-            ...capability,
-            allowedEffectiveModels: grokAllowedEffectiveModels(policy, capability.model)
-          }));
+          const capabilities = grokModelCapabilities(state).map((capability) => {
+            const identity3 = proxy.modelCatalog?.get(capability.model);
+            if (!identity3) throw new Error("grok_model_catalog_identity_missing");
+            return { ...capability, allowedEffectiveModels: identity3.allowedEffectiveModels };
+          });
           if (!capabilities.length) throw new Error("grok_model_catalog_empty");
-          const identity = typeof auth.principalId === "string" && auth.principalId ? auth.principalId : typeof auth.email === "string" && auth.email ? auth.email.toLowerCase() : null;
-          if (!identity) throw new Error("grok_account_identity_required");
+          const identity2 = typeof auth.principalId === "string" && auth.principalId ? auth.principalId : typeof auth.email === "string" && auth.email ? auth.email.toLowerCase() : null;
+          if (!identity2) throw new Error("grok_account_identity_required");
           return {
             adapterId: "grok-build",
             runtimeVersion: binary.version,
-            authenticatedAccountIdentity: identity,
+            authenticatedAccountIdentity: identity2,
             authenticatedAccountEmail: typeof auth.email === "string" ? auth.email : null,
             authenticatedAccountPlan: null,
             modelCapabilities: capabilities,
@@ -35676,7 +35813,11 @@ var init_grok_adapter = __esm({
             await session?.close();
           } finally {
             if (session) this.active.delete(session);
-            await releaseGrokOwnedWorkspace(this.stateOptions, workspace);
+            try {
+              await proxy?.close();
+            } finally {
+              await releaseGrokOwnedWorkspace(this.stateOptions, workspace);
+            }
           }
         }
       }
@@ -35701,7 +35842,6 @@ var init_grok_adapter = __esm({
         const startedAt = Date.now();
         const binary = await this.binary();
         const policy = this.options.policy ?? await loadGrokPolicy();
-        const allowedEffectiveModels = grokAllowedEffectiveModels(policy, input.requestedModel);
         input.signal.throwIfAborted();
         const workspace = agent?.durableThread ? await validateGrokOwnedThread(this.stateOptions, agent.durableThread) : await createGrokOwnedWorkspace(this.stateOptions, agent ? "agent" : "attempt");
         let mcp = null;
@@ -35757,7 +35897,6 @@ var init_grok_adapter = __esm({
             expectedSystemPrompt: input.systemPrompt,
             requestedModel: input.requestedModel,
             requestedReasoningEffort: input.requestedReasoningEffort,
-            allowedEffectiveModels,
             allowedToolNames: agent ? ["search_tool", "use_tool"] : [],
             deadlineAtMs: input.deadlineAtMs,
             providerDispatchNotAfterMs: provider?.providerDispatchNotAfterMs,
@@ -35795,6 +35934,8 @@ var init_grok_adapter = __esm({
           const catalog = unwrap(await session.request("_x.ai/models/list", {}, input.deadlineAtMs, input.signal));
           const selectedCapability = grokModelCapabilities(catalog).find((entry) => entry.model === input.requestedModel);
           if (!selectedCapability?.supportedReasoningEfforts.includes(input.requestedReasoningEffort)) throw new Error("grok_model_selection_unavailable");
+          if (provider && !provider.allowedEffectiveModels) throw new Error("grok_model_identity_contract_missing");
+          const { transportModel } = proxy.bindModelIdentity(input.requestedModel, provider?.allowedEffectiveModels);
           const metadata = {
             systemPromptOverride: input.systemPrompt,
             agentProfile: agentProfile(Boolean(agent)),
@@ -35821,6 +35962,14 @@ var init_grok_adapter = __esm({
               _meta: metadata
             }, input.deadlineAtMs, input.signal);
           }
+          if (transportModel !== input.requestedModel) {
+            created = await session.request("session/load", {
+              sessionId,
+              cwd: workspace,
+              mcpServers: mcp ? [mcp.descriptor] : [],
+              _meta: metadata
+            }, input.deadlineAtMs, input.signal);
+          }
           assertSelection(created, input.requestedModel, input.requestedReasoningEffort);
           const thread = {
             threadId: sessionId,
@@ -35853,8 +36002,9 @@ var init_grok_adapter = __esm({
           if (meta3.structuredOutputError || meta3.structuredOutput === void 0) throw new Error("grok_structured_output_missing");
           const text = JSON.stringify(meta3.structuredOutput);
           if (Buffer.byteLength(text) > 3e5) throw new Error("grok_result_too_large");
-          const usage = grokPromptUsage(meta3.usage, input.requestedModel, allowedEffectiveModels);
-          const actualModel = Object.keys(grokObject(grokObject(meta3.usage).modelUsage))[0];
+          const actualModel = proxy.observedModel;
+          if (!actualModel) throw new Error("grok_transport_receipt_missing");
+          const usage = grokPromptUsage(meta3.usage, actualModel);
           if (!proxy.dispatched || !proxy.responded || proxy.terminalFailure) throw new Error(proxy.failureCode ?? "grok_transport_receipt_missing");
           const receipts = proxy.receipts;
           if (!receipts.length || proxy.pendingRequest || receipts.some((receipt) => receipt.model !== actualModel || receipt.requestedReasoningEffort !== input.requestedReasoningEffort || receipt.input === null || receipt.output === null || receipt.cachedInput === null) || receipts.reduce((sum, receipt) => sum + receipt.input, 0) !== usage.inputTokens || receipts.reduce((sum, receipt) => sum + receipt.output, 0) !== usage.outputTokens || receipts.reduce((sum, receipt) => sum + receipt.cachedInput, 0) !== usage.cachedInputTokens || integer2(grokObject(meta3.usage).modelCalls, "model_calls") !== receipts.length) {
@@ -36024,7 +36174,7 @@ import { createServer as createServer5 } from "node:http";
 import { access as access3, lstat as lstat8, readdir as readdir4, realpath as realpath7, rm as rm9 } from "node:fs/promises";
 import { basename as basename4, dirname as dirname9, join as join12, resolve as resolve7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-var import_ajv2, failure, object3, receiptUsage, assertOwnedRuntime, cleanupExoOwnedState, ExoForegroundAdapter;
+var import_ajv2, failure, object4, validModel, receiptUsage, assertOwnedRuntime, cleanupExoOwnedState, ExoForegroundAdapter;
 var init_exo_adapter = __esm({
   "lib/inference-host/exo-adapter.ts"() {
     "use strict";
@@ -36042,9 +36192,10 @@ var init_exo_adapter = __esm({
       retryable: false,
       dispatchOutcome: dispatched ? "outcome_unknown" : "not_dispatched"
     });
-    object3 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+    object4 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+    validModel = (value) => typeof value === "string" && Boolean(value.trim()) && value.length <= 256 && !/[\u0000-\u001f\u007f]/u.test(value);
     receiptUsage = (value) => {
-      const usage = object3(value);
+      const usage = object4(value);
       for (const key of ["inputTokens", "cachedInputTokens", "outputTokens", "reasoningOutputTokens", "totalTokens"]) {
         if (!Number.isSafeInteger(usage[key]) || Number(usage[key]) < 0) return null;
       }
@@ -36063,8 +36214,9 @@ var init_exo_adapter = __esm({
       const info = await lstat8(root);
       if (!info.isDirectory() || info.isSymbolicLink() || await realpath7(root) !== root) throw failure("exo_state_not_owned");
       const raw = await readInferencePrivateFile(join12(root, "vtx-owner.json"), "Exo state owner");
-      const owner2 = raw === null ? {} : object3(JSON.parse(raw));
+      const owner2 = raw === null ? {} : object4(JSON.parse(raw));
       if (owner2.adapter !== "exo" || owner2.id !== id2 || owner2.root !== root) throw failure("exo_state_not_owned");
+      return owner2;
     };
     cleanupExoOwnedState = async (stateRoot) => {
       try {
@@ -36203,8 +36355,10 @@ var init_exo_adapter = __esm({
         if (!credential || credential.provider !== provider) throw failure("exo_credential_required", false, "auth");
         const id2 = agent?.durableThread?.threadId ?? randomUUID6();
         const runtimeRoot = agent?.durableThread ? await this.ownedRoot(agent.durableThread) : join12(await realpath7(this.options.stateRoot), `${agent ? "agent" : "attempt"}-${id2}`);
-        const thread = { threadId: id2, threadPath: runtimeRoot, effectiveModel: input.requestedModel, effectiveReasoningEffort: input.requestedReasoningEffort };
-        if (agent?.durableThread && (agent.durableThread.effectiveModel !== thread.effectiveModel || agent.durableThread.effectiveReasoningEffort !== thread.effectiveReasoningEffort)) throw failure("exo_thread_selection_mismatch");
+        let thread = { threadId: id2, threadPath: runtimeRoot, effectiveModel: input.requestedModel, effectiveReasoningEffort: input.requestedReasoningEffort };
+        const owner2 = agent?.durableThread ? await assertOwnedRuntime(runtimeRoot, id2) : null;
+        const boundSelection = owner2?.requestedModel ?? agent?.durableThread?.effectiveModel;
+        if (agent?.durableThread && (boundSelection !== input.requestedModel || agent.durableThread.effectiveReasoningEffort !== thread.effectiveReasoningEffort)) throw failure("exo_thread_selection_mismatch");
         const schema = agent ? agent.outputSchema : JSON.parse(input.outputSchemaJson);
         const validate = new import_ajv2.default({ allErrors: true }).compile(schema);
         const started = Date.now();
@@ -36265,7 +36419,7 @@ var init_exo_adapter = __esm({
               raw += String(chunk);
               if (Buffer.byteLength(raw) > 2e6) throw failure("exo_bridge_input_too_large");
             }
-            const body = object3(JSON.parse(raw));
+            const body = object4(JSON.parse(raw));
             if (terminal || workerFailure) throw failure("exo_turn_already_finished");
             if (request.url === "/dispatch") {
               if (body.model !== providerModel || body.reasoningEffort !== input.requestedReasoningEffort) throw failure("exo_dispatch_identity_mismatch");
@@ -36279,11 +36433,15 @@ var init_exo_adapter = __esm({
               return;
             }
             if (request.url === "/tool") {
-              if (!agent || !dispatched || toolBusy || typeof body.callId !== "string" || toolIds.has(body.callId) || !CODEX_AGENT_DYNAMIC_TOOLS.includes(body.tool) || body.effectiveModel !== input.requestedModel || body.effectiveReasoningEffort !== input.requestedReasoningEffort) throw failure("exo_tool_not_authorized");
+              if (!agent || !dispatched || toolBusy || typeof body.callId !== "string" || toolIds.has(body.callId) || !CODEX_AGENT_DYNAMIC_TOOLS.includes(body.tool) || !validModel(body.effectiveModel) || body.effectiveReasoningEffort !== input.requestedReasoningEffort) throw failure("exo_tool_not_authorized");
               toolBusy = true;
               toolIds.add(body.callId);
-              const call = { callId: body.callId, tool: body.tool, arguments: object3(body.arguments) };
+              const call = { callId: body.callId, tool: body.tool, arguments: object4(body.arguments) };
               try {
+                if (thread.effectiveModel !== body.effectiveModel) {
+                  thread = { ...thread, effectiveModel: body.effectiveModel };
+                  await agent.onThreadReady?.(thread);
+                }
                 let result2;
                 try {
                   result2 = await agent.executeTool(call);
@@ -36317,7 +36475,10 @@ var init_exo_adapter = __esm({
         try {
           input.signal?.throwIfAborted();
           await ensureInferencePrivateDirectory(runtimeRoot);
-          if (!agent?.durableThread) await writeAtomicInferencePrivateFile(join12(runtimeRoot, "vtx-owner.json"), JSON.stringify({ adapter: "exo", id: id2, root: runtimeRoot }));
+          if (!owner2 || owner2.requestedModel === void 0) await writeAtomicInferencePrivateFile(
+            join12(runtimeRoot, "vtx-owner.json"),
+            JSON.stringify({ adapter: "exo", id: id2, root: runtimeRoot, requestedModel: input.requestedModel })
+          );
           await new Promise((done, reject) => {
             server.once("error", reject);
             server.listen(0, "127.0.0.1", done);
@@ -36338,7 +36499,7 @@ var init_exo_adapter = __esm({
           }
           const result2 = terminal;
           if (!result2 || workerFailure) throw failure("exo_terminal_receipt_missing", dispatched);
-          if (result2.providerModel !== providerModel || result2.reasoningEffort !== input.requestedReasoningEffort) throw failure("exo_effective_identity_mismatch", dispatched, "model");
+          if (!validModel(result2.providerModel) || result2.reasoningEffort !== input.requestedReasoningEffort) throw failure("exo_effective_identity_mismatch", dispatched, "model");
           const usage = receiptUsage(result2.usage);
           if (!usage) throw failure("exo_usage_invalid", dispatched);
           let validOutput = false;
@@ -36350,13 +36511,18 @@ var init_exo_adapter = __esm({
           }
           if (!validOutput || typeof result2.text !== "string") throw failure("exo_output_schema_invalid", dispatched, "schema");
           if (typeof result2.responseId !== "string" || !result2.responseId) throw failure("exo_response_id_missing", dispatched);
+          const effectiveModel = `${provider}/${result2.providerModel}`;
+          if (thread.effectiveModel !== effectiveModel) {
+            thread = { ...thread, effectiveModel };
+            await agent?.onThreadReady?.(thread);
+          }
           if (!agent) input.onTerminalDispatchOutcome?.("confirmed_dispatched");
           return { thread, tools, turn: {
             text: result2.text,
             reasoningContent: null,
             reasoningSummary: null,
             requestedModel: input.requestedModel,
-            effectiveModel: input.requestedModel,
+            effectiveModel,
             requestedReasoningEffort: input.requestedReasoningEffort,
             effectiveReasoningEffort: input.requestedReasoningEffort,
             adapterRequestId: id2,
@@ -36372,7 +36538,7 @@ var init_exo_adapter = __esm({
           const receipt = terminal;
           const completed = receipt !== null || knownFailure?.terminalKnown === true;
           const evidence = receipt ?? knownFailure;
-          const identityQualified = evidence?.providerModel === providerModel && evidence?.reasoningEffort === input.requestedReasoningEffort;
+          const identityQualified = validModel(evidence?.providerModel) && evidence?.reasoningEffort === input.requestedReasoningEffort;
           const outcome = !dispatched ? "not_dispatched" : completed ? "confirmed_dispatched" : "outcome_unknown";
           const knownCode = typeof knownFailure?.code === "string" && /^exo_[a-z_]+$/u.test(knownFailure.code) ? knownFailure.code : null;
           const observedCode = completed ? knownCode ?? (error48 instanceof CodexAppServerError ? error48.code : "exo_turn_failed") : abort.signal.aborted ? "exo_interrupted" : "exo_unconfirmed_result";
@@ -36388,7 +36554,7 @@ var init_exo_adapter = __esm({
             httpStatusCode: ["quota_exceeded", "provider_rate_limited"].includes(code) ? 429 : null,
             retryAtMs: completed && Number.isSafeInteger(evidence?.retryAtMs) && Number(evidence?.retryAtMs) > Date.now() ? Number(evidence?.retryAtMs) : null,
             terminalEvidence: completed ? {
-              effectiveModel: identityQualified ? input.requestedModel : null,
+              effectiveModel: identityQualified ? `${provider}/${evidence.providerModel}` : null,
               effectiveReasoningEffort: identityQualified ? input.requestedReasoningEffort : null,
               adapterRequestId: id2,
               adapterResponseId: typeof evidence?.responseId === "string" && evidence.responseId ? evidence.responseId : null
@@ -36500,11 +36666,11 @@ var init_exo_credential_store = __esm({
       }
       const provider = validateProvider(record4.provider);
       const apiKey = validateApiKey(record4.api_key);
-      const identity = credentialIdentity(provider, apiKey);
-      if (record4.schema_version !== 1 || record4.adapter !== "exo" || record4.identity !== identity || Object.keys(record4).sort().join(",") !== "adapter,api_key,identity,provider,schema_version") {
+      const identity2 = credentialIdentity(provider, apiKey);
+      if (record4.schema_version !== 1 || record4.adapter !== "exo" || record4.identity !== identity2 || Object.keys(record4).sort().join(",") !== "adapter,api_key,identity,provider,schema_version") {
         throw new Error("Stored Exo credential failed validation.");
       }
-      return { provider, apiKey, identity };
+      return { provider, apiKey, identity: identity2 };
     };
     serializeCredential = (provider, apiKey) => {
       const validated = validateApiKey(apiKey);
@@ -36698,11 +36864,11 @@ var init_pi_credential_store = __esm({
       const record4 = value;
       const provider = validateProvider2(String(record4.provider ?? ""));
       const apiKey = validateApiKey2(String(record4.api_key ?? ""));
-      const identity = credentialIdentity2(provider, apiKey);
-      if (record4.schema_version !== 1 || record4.adapter !== "pi" || record4.identity !== identity || Object.keys(record4).sort().join(",") !== "adapter,api_key,identity,provider,schema_version") {
+      const identity2 = credentialIdentity2(provider, apiKey);
+      if (record4.schema_version !== 1 || record4.adapter !== "pi" || record4.identity !== identity2 || Object.keys(record4).sort().join(",") !== "adapter,api_key,identity,provider,schema_version") {
         throw new Error("Stored Pi credential failed validation.");
       }
-      return { provider, apiKey, identity };
+      return { provider, apiKey, identity: identity2 };
     };
     serializeCredential2 = (provider, apiKey) => {
       const validated = validateApiKey2(apiKey);
@@ -36854,11 +37020,11 @@ var init_deepseek_credential_store = __esm({
       }
       const record4 = value;
       const apiKey = validateApiKey3(String(record4.api_key ?? ""));
-      const identity = credentialIdentity3(apiKey);
-      if (record4.schema_version !== 1 || record4.adapter !== "deepseek-harness" || record4.identity !== identity || Object.keys(record4).sort().join(",") !== "adapter,api_key,identity,schema_version") {
+      const identity2 = credentialIdentity3(apiKey);
+      if (record4.schema_version !== 1 || record4.adapter !== "deepseek-harness" || record4.identity !== identity2 || Object.keys(record4).sort().join(",") !== "adapter,api_key,identity,schema_version") {
         throw new Error("Stored DeepSeek Harness credential failed validation.");
       }
-      return { apiKey, identity };
+      return { apiKey, identity: identity2 };
     };
     serializeCredential3 = (apiKey) => {
       const validated = validateApiKey3(apiKey);
@@ -37112,8 +37278,8 @@ var init_crypto = __esm({
       cipher.setAAD(aad);
       return Buffer.concat([cipher.update(plaintext), cipher.final(), cipher.getAuthTag()]);
     };
-    assertIdentity = (aad, identity) => {
-      if (aad.job_id !== identity.job_id || aad.host_id !== identity.host_id || aad.host_generation !== identity.host_generation || aad.key_generation !== identity.key_generation || aad.claim_generation !== identity.claim_generation) {
+    assertIdentity = (aad, identity2) => {
+      if (aad.job_id !== identity2.job_id || aad.host_id !== identity2.host_id || aad.host_generation !== identity2.host_generation || aad.key_generation !== identity2.key_generation || aad.claim_generation !== identity2.claim_generation) {
         throw new ExternalInferenceEnvelopeError(
           "identity_mismatch",
           "External inference envelope identity is invalid."
@@ -37270,7 +37436,7 @@ var init_crypto = __esm({
           "External inference claim does not contain a job."
         );
       }
-      const identity = {
+      const identity2 = {
         job_id: claim.job_id,
         host_id: claim.host_id,
         host_generation: claim.host_generation,
@@ -37280,9 +37446,9 @@ var init_crypto = __esm({
       const jobKey = unwrapExternalInferenceJobKey(
         hostPrivateKey,
         claim.sealed_job_key,
-        identity
+        identity2
       );
-      const jobInput = decryptExternalInferenceJobInput(jobKey, claim.sealed_input, identity);
+      const jobInput = decryptExternalInferenceJobInput(jobKey, claim.sealed_input, identity2);
       if (jobInput.advertisement_generation !== claim.advertisement_generation || jobInput.controller_generation !== claim.controller_generation || jobInput.input_sha256 !== claim.input_sha256 || jobInput.requested_model !== claim.requested_model || jobInput.requested_reasoning_effort !== claim.requested_reasoning_effort || jobInput.response_mode !== claim.response_mode || jobInput.output_schema_version !== claim.output_schema_version) {
         throw new ExternalInferenceEnvelopeError(
           "identity_mismatch",
@@ -40295,6 +40461,9 @@ var init_runner = __esm({
             userPrompt: jobInput.user_prompt,
             outputSchemaJson: outputContract.adapterSchemaJson,
             requestedModel: jobInput.requested_model,
+            allowedEffectiveModels: jobInput.allowed_model_identities.find(
+              (mapping2) => mapping2.requested_model === jobInput.requested_model
+            )?.effective_models,
             requestedReasoningEffort: jobInput.requested_reasoning_effort,
             deadlineAtMs: Date.parse(jobInput.deadline_at),
             ...providerDispatchNotAfterMs === void 0 ? {} : { providerDispatchNotAfterMs },
@@ -40687,7 +40856,8 @@ var init_runner = __esm({
         const mapping2 = jobInput.allowed_model_identities.find(
           (candidate) => candidate.requested_model === jobInput.requested_model
         );
-        if (result2.requestedModel !== jobInput.requested_model || result2.requestedReasoningEffort !== jobInput.requested_reasoning_effort || !mapping2?.effective_models.includes(result2.effectiveModel) || !jobInput.allowed_effective_reasoning_efforts.includes(result2.effectiveReasoningEffort)) {
+        const effectiveModelMatches = mapping2 !== void 0 && jobInput.controller.adapter === (this.options.adapterId ?? "codex") && typeof result2.effectiveModel === "string" && result2.effectiveModel.trim().length > 0 && result2.effectiveModel.length <= 256 && !/[\u0000-\u001f\u007f]/u.test(result2.effectiveModel);
+        if (result2.requestedModel !== jobInput.requested_model || result2.requestedReasoningEffort !== jobInput.requested_reasoning_effort || !effectiveModelMatches || !jobInput.allowed_effective_reasoning_efforts.includes(result2.effectiveReasoningEffort)) {
           throw new InferenceHostRunnerError(
             "effective_model_mismatch",
             "The effective adapter model provenance did not match the immutable allowance."
@@ -42083,8 +42253,8 @@ WantedBy=default.target
         }
       }
       windowsTaskName() {
-        const identity = this.username.replaceAll(/[^A-Za-z0-9_.@-]+/gu, "_").slice(-80) || "current-user";
-        return `VTX Macro Inference Host (${identity})`;
+        const identity2 = this.username.replaceAll(/[^A-Za-z0-9_.@-]+/gu, "_").slice(-80) || "current-user";
+        return `VTX Macro Inference Host (${identity2})`;
       }
       windowsPowerShell(script) {
         return [
@@ -46307,16 +46477,16 @@ Waiting for approval...
     hasExplicitCredentialStoreConfiguration = (env) => Boolean(
       String(env.VTX_INFERENCE_HOST_CREDENTIAL_STORE || "").trim() || String(env.VTX_INFERENCE_HOST_CREDENTIAL_FILE || "").trim()
     );
-    credentialEnvironmentForIdentity = (identity) => {
-      if (identity.startsWith("file:")) {
-        const path = identity.slice("file:".length);
+    credentialEnvironmentForIdentity = (identity2) => {
+      if (identity2.startsWith("file:")) {
+        const path = identity2.slice("file:".length);
         if (!path) throw new Error("Inference host credential store identity is invalid.");
         return {
           VTX_INFERENCE_HOST_CREDENTIAL_STORE: "file",
           VTX_INFERENCE_HOST_CREDENTIAL_FILE: path
         };
       }
-      if (identity.startsWith("os:")) {
+      if (identity2.startsWith("os:")) {
         return {
           VTX_INFERENCE_HOST_CREDENTIAL_STORE: "os",
           VTX_INFERENCE_HOST_CREDENTIAL_FILE: void 0
@@ -54116,10 +54286,10 @@ function arrayifyInteger(value) {
   }
   return result2;
 }
-function _encode2(object5) {
-  if (Array.isArray(object5)) {
+function _encode2(object6) {
+  if (Array.isArray(object6)) {
     let payload = [];
-    object5.forEach(function(child) {
+    object6.forEach(function(child) {
       payload = payload.concat(_encode2(child));
     });
     if (payload.length <= 55) {
@@ -54130,7 +54300,7 @@ function _encode2(object5) {
     length2.unshift(247 + length2.length);
     return length2.concat(payload);
   }
-  const data4 = Array.prototype.slice.call(getBytes(object5, "object"));
+  const data4 = Array.prototype.slice.call(getBytes(object6, "object"));
   if (data4.length === 1 && data4[0] <= 127) {
     return data4;
   } else if (data4.length <= 55) {
@@ -54141,9 +54311,9 @@ function _encode2(object5) {
   length.unshift(183 + length.length);
   return length.concat(data4);
 }
-function encodeRlp(object5) {
+function encodeRlp(object6) {
   let result2 = "0x";
-  for (const v of _encode2(object5)) {
+  for (const v of _encode2(object6)) {
     result2 += nibbles[v >> 4];
     result2 += nibbles[v & 15];
   }
@@ -54291,15 +54461,15 @@ function toObject(names2, items, deep) {
 }
 function checkResultErrors(result2) {
   const errors = [];
-  const checkErrors = function(path, object5) {
-    if (!Array.isArray(object5)) {
+  const checkErrors = function(path, object6) {
+    if (!Array.isArray(object6)) {
       return;
     }
-    for (let key in object5) {
+    for (let key in object6) {
       const childPath = path.slice();
       childPath.push(key);
       try {
-        checkErrors(childPath, object5[key]);
+        checkErrors(childPath, object6[key]);
       } catch (error48) {
         errors.push({ path: childPath, error: error48 });
       }
@@ -56549,15 +56719,15 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
   };
   return genUntil;
 }
-function validateObject(object5, validators, optValidators = {}) {
+function validateObject(object6, validators, optValidators = {}) {
   const checkField = (fieldName, type, isOptional) => {
     const checkVal = validatorFns[type];
     if (typeof checkVal !== "function")
       throw new Error(`Invalid validator "${type}", expected function`);
-    const val = object5[fieldName];
+    const val = object6[fieldName];
     if (isOptional && val === void 0)
       return;
-    if (!checkVal(val, object5)) {
+    if (!checkVal(val, object6)) {
       throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
     }
   };
@@ -56565,7 +56735,7 @@ function validateObject(object5, validators, optValidators = {}) {
     checkField(fieldName, type, false);
   for (const [fieldName, type] of Object.entries(optValidators))
     checkField(fieldName, type, true);
-  return object5;
+  return object6;
 }
 var _0n2, _1n2, _2n2, u8a3, hexes, bitSet, bitMask, u8n, u8fr, validatorFns;
 var init_utils4 = __esm({
@@ -56592,7 +56762,7 @@ var init_utils4 = __esm({
       stringOrUint8Array: (val) => typeof val === "string" || val instanceof Uint8Array,
       isSafeInteger: (val) => Number.isSafeInteger(val),
       array: (val) => Array.isArray(val),
-      field: (val, object5) => object5.Fp.isValid(val),
+      field: (val, object6) => object6.Fp.isValid(val),
       hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
     };
   }
@@ -68330,7 +68500,7 @@ function arrayOf(format, allowNull2) {
     return array2.map((i) => format(i));
   });
 }
-function object4(format, altNames) {
+function object5(format, altNames) {
   return ((value) => {
     const result2 = {};
     for (const key in format) {
@@ -68398,7 +68568,7 @@ function formatTransactionResponse(value) {
   if (value.to && getBigInt(value.to) === BN_011) {
     value.to = "0x0000000000000000000000000000000000000000";
   }
-  const result2 = object4({
+  const result2 = object5({
     hash: formatHash,
     // Some nodes do not return this, usually test nodes (like Ganache)
     index: allowNull(getNumber, void 0),
@@ -68484,7 +68654,7 @@ var init_format = __esm({
     init_transaction2();
     init_utils();
     BN_011 = BigInt(0);
-    _formatLog = object4({
+    _formatLog = object5({
       address: getAddress,
       blockHash: formatHash,
       blockNumber: getNumber,
@@ -68497,7 +68667,7 @@ var init_format = __esm({
     }, {
       index: ["logIndex"]
     });
-    _formatBlock = object4({
+    _formatBlock = object5({
       hash: allowNull(formatHash),
       parentHash: formatHash,
       parentBeaconBlockRoot: allowNull(formatHash, null),
@@ -68518,7 +68688,7 @@ var init_format = __esm({
     }, {
       prevRandao: ["mixHash"]
     });
-    _formatReceiptLog = object4({
+    _formatReceiptLog = object5({
       transactionIndex: getNumber,
       blockNumber: getNumber,
       transactionHash: formatHash,
@@ -68530,7 +68700,7 @@ var init_format = __esm({
     }, {
       index: ["logIndex"]
     });
-    _formatTransactionReceipt = object4({
+    _formatTransactionReceipt = object5({
       to: allowNull(getAddress, null),
       from: allowNull(getAddress, null),
       contractAddress: allowNull(getAddress, null),
@@ -79336,13 +79506,13 @@ function getPassword(password) {
   }
   return getBytesCopy(password);
 }
-function spelunk(object5, _path) {
+function spelunk(object6, _path) {
   const match = _path.match(/^([a-z0-9$_.-]*)(:([a-z]+))?(!)?$/i);
   assertArgument(match != null, "invalid path", "path", _path);
   const path = match[1];
   const type = match[3];
   const reqd = match[4] === "!";
-  let cur = object5;
+  let cur = object6;
   for (const comp of path.toLowerCase().split(".")) {
     if (Array.isArray(cur)) {
       if (!comp.match(/^[0-9]+$/)) {