@opengeni/worker-bundle 2.2.0-canary.36844267522001 → 2.2.0

package/dist/{activities-turn-LSRAUGEK.js → activities-turn-FQ5OO2WW.js}

@@ -94,7 +94,7 @@ import {
   withFirstPartyTools,
   wrapLazyTurnBoxWithRouting,
   wrapTurnBoxWithRouting
-} from "./chunk-WADNTBZZ.js";
+} from "./chunk-RZAAGRFQ.js";
 import {
   StreamTimingMetrics,
   makeMachineOpObserver,
@@ -139,12 +139,10 @@ import {
   getSessionAuthorityProjection,
   readActiveSandbox as readActiveSandbox3,
   getWorkspaceCredentialProvider,
-  loadClaudeSubscriptionUsageCredential as loadClaudeSubscriptionUsageCredential2,
-  resolveClaudeSubscriptionCredential,
-  ClaudeSubscriptionReconnectRequired
+  loadClaudeSubscriptionUsageCredential
 } from "@opengeni/db";
 import {
-  assertModelConnectionAllowsTurn as assertModelConnectionAllowsTurn2,
+  assertModelConnectionAllowsTurn,
   freezeAgentLearningPolicy as freezeAgentLearningPolicy2,
   recoverLegacyKnowledgeConfirmations,
   withSessionRlsActorContext
@@ -163,7 +161,6 @@ import {
 import {
   REMOTE_COMPACTION_V2_BETA_FEATURE,
   REMOTE_COMPACTION_V2_IMPLEMENTATION as REMOTE_COMPACTION_V2_IMPLEMENTATION2,
-  awaitModelCallAdmission,
   materializeSandboxFileDownloads as materializeSandboxFileDownloads3,
   sandboxFileDownloadFailureNote
 } from "@opengeni/runtime";
@@ -194,17 +191,6 @@ async function createClaudeUsageObserver(providers, latest, readCredential) {
       (provider) => provider.kind === "claude-subscription-workspace" || provider.kind === "claude-subscription-organization"
     ).map(async (provider) => {
       const scope = provider.kind === "claude-subscription-workspace" ? "workspace" : "organization";
-      const binding = provider.anthropic?.credentialBinding;
-      if (binding && provider.apiKey)
-        return [
-          provider.id,
-          {
-            scope,
-            token: provider.apiKey,
-            expectedConnectionId: binding.connectionId,
-            expectedCredentialVersion: binding.credentialVersion
-          }
-        ];
       const credential = await readCredential(scope).catch(() => null);
       if (!credential || credential.token !== provider.apiKey) return null;
       return [
@@ -219,7 +205,7 @@ async function createClaudeUsageObserver(providers, latest, readCredential) {
     })
   );
   const captured = new Map(bindings.filter((binding) => binding !== null));
-  const observe2 = (providerId, response) => {
+  return (providerId, response) => {
     const binding = captured.get(providerId);
     if (!binding) return;
     const { scope, ...identity } = binding;
@@ -244,16 +230,6 @@ async function createClaudeUsageObserver(providers, latest, readCredential) {
         ...response.status === 401 ? { refresh: { status: "reconnect", checkedAt: (/* @__PURE__ */ new Date()).toISOString() } } : {}
       });
   };
-  return Object.assign(observe2, {
-    binding(providerId) {
-      return captured.get(providerId);
-    },
-    renew(providerId, credential) {
-      const binding = captured.get(providerId);
-      if (binding && binding.expectedConnectionId === credential.connectionId && binding.expectedCredentialVersion === credential.credentialVersion)
-        captured.set(providerId, { ...binding, token: credential.token });
-    }
-  });
 }
 
 // src/activities/agent-turn/run.ts
@@ -5280,7 +5256,7 @@ import {
 } from "@opengeni/codex";
 
 // src/activities/agent-turn/admission.ts
-import { checkWorkspaceAllowance, getBillingBalance, sumUsageQuantity } from "@opengeni/db";
+import { getBillingBalance, sumUsageQuantity } from "@opengeni/db";
 import {
   configuredStaticUsageLimits
 } from "@opengeni/config";
@@ -5925,48 +5901,13 @@ function stableInteractionInterventionUuid(namespace, sessionId, turnId, toolCal
   return `${value.slice(0, 8)}-${value.slice(8, 12)}-${value.slice(12, 16)}-${value.slice(16, 20)}-${value.slice(20)}`;
 }
 var BudgetExhaustedError = class extends Error {
-  constructor(message, serializedRunState, allowance = null) {
+  constructor(message, serializedRunState) {
     super(message);
     this.serializedRunState = serializedRunState;
-    this.allowance = allowance;
     this.name = "BudgetExhaustedError";
   }
 };
-var AllowanceExhaustedError = class extends Error {
-  constructor(refusal) {
-    super(refusal.message);
-    this.refusal = refusal;
-    this.name = "AllowanceExhaustedError";
-  }
-  code = "allowance_exhausted";
-};
-async function ensureRunAllowedBetweenModelCalls(input) {
-  try {
-    await ensureRunAllowed(
-      input.settings,
-      input.db,
-      input.accountId,
-      input.workspaceId,
-      input.isExternallyBilledTurn,
-      input.entitlements,
-      input.chargesOpenGeniCredits,
-      input.countsTowardTokenCap,
-      input.initiatingHumanSubjectId
-    );
-  } catch (limitError) {
-    let serializedRunState = null;
-    try {
-      serializedRunState = input.serializedRunState?.() ?? null;
-    } catch {
-    }
-    throw new BudgetExhaustedError(
-      limitError instanceof Error ? limitError.message : String(limitError),
-      serializedRunState,
-      limitError instanceof AllowanceExhaustedError ? limitError.refusal : null
-    );
-  }
-}
-async function ensureRunAllowed(settings, db, accountId, workspaceId, isExternallyBilledTurn, entitlements, chargesOpenGeniCredits = !isExternallyBilledTurn, countsTowardTokenCap = !isExternallyBilledTurn, initiatingHumanSubjectId = null) {
+async function ensureRunAllowed(settings, db, accountId, workspaceId, isExternallyBilledTurn, entitlements, chargesOpenGeniCredits = !isExternallyBilledTurn, countsTowardTokenCap = !isExternallyBilledTurn) {
   if (chargesOpenGeniCredits && entitlements && (settings.billingMode === "stripe" || settings.usageLimitsMode === "managed")) {
     const decision = await entitlements.admitRun({
       accountId,
@@ -5983,14 +5924,6 @@ async function ensureRunAllowed(settings, db, accountId, workspaceId, isExternal
       throw new Error("insufficient OpenGeni credits");
     }
   }
-  if (chargesOpenGeniCredits) {
-    const refusal = await checkWorkspaceAllowance(db, {
-      accountId,
-      workspaceId,
-      subjectId: initiatingHumanSubjectId
-    });
-    if (refusal) throw new AllowanceExhaustedError(refusal);
-  }
   if (settings.usageLimitsMode === "static" || settings.usageLimitsMode === "managed") {
     const limits = configuredStaticUsageLimits(settings);
     if (limits.maxMonthlyAgentRunsPerWorkspace) {
@@ -7065,22 +6998,19 @@ async function settleTurnFailure(deps) {
     await historySink.reconcileConversationTruth();
     if (!await eventing.settle({
       events: [
-        ...error51.allowance ? [{ type: "usage.exhausted", payload: error51.allowance }] : [],
         {
           type: "turn.completed",
           payload: {
             output: "",
             segmentLimit: "budget_exhausted",
-            detail: error51.message,
-            ...error51.allowance ?? {}
+            detail: error51.message
           }
         },
         { type: "session.status.changed", payload: { status: "idle" } }
       ],
       turnStatus: "completed",
       sessionStatus: "idle",
-      activeTurnId: null,
-      ...error51.allowance ? { allowanceGoalPause: { rationale: error51.allowance.message } } : {}
+      activeTurnId: null
     })) {
       return claimedResult({ status: "cancelled" });
     }
@@ -8042,81 +7972,6 @@ import {
   resolveWorkspaceAgentHumanInputEnabled
 } from "@opengeni/contracts";
 
-// src/activities/agent-turn/model-call-admission.ts
-function createModelCallAdmission(input) {
-  const receipts = /* @__PURE__ */ new WeakMap();
-  const responseReceipts = /* @__PURE__ */ new Map();
-  const pending = /* @__PURE__ */ new Set();
-  const responseId = (event) => {
-    const id = event?.response?.id;
-    return typeof id === "string" && id.length > 0 ? id : null;
-  };
-  let latest = Promise.resolve();
-  let failure2;
-  let failed = false;
-  let rejectHalted;
-  const halted = new Promise((_, reject) => {
-    rejectHalted = reject;
-  });
-  void halted.catch(() => void 0);
-  const fail = (error51) => {
-    if (failed) return;
-    failed = true;
-    failure2 = error51;
-    rejectHalted(error51);
-    for (const receipt of pending) receipt.reject(error51);
-    pending.clear();
-    responseReceipts.clear();
-  };
-  const abort = () => fail(input.signal.reason ?? new Error("Model stream cancelled"));
-  input.signal.addEventListener("abort", abort, { once: true });
-  if (input.signal.aborted) abort();
-  return {
-    beforeModelRequest: async () => {
-      await Promise.race([latest, halted]);
-      if (failed) throw failure2;
-      await Promise.race([input.admit(), halted]);
-      if (failed) throw failure2;
-    },
-    onModelResponse: (event) => {
-      if (failed) return Promise.reject(failure2);
-      const id = responseId(event);
-      const existing = receipts.get(event) ?? (id ? responseReceipts.get(id) : void 0) ?? (!id && pending.size === 1 ? pending.values().next().value : void 0);
-      if (existing) return existing.promise;
-      let resolve;
-      let reject;
-      const promise2 = new Promise((yes, no) => {
-        resolve = yes;
-        reject = no;
-      });
-      void promise2.catch(() => void 0);
-      const receipt = { promise: promise2, resolve, reject };
-      receipts.set(event, receipt);
-      if (id) responseReceipts.set(id, receipt);
-      pending.add(receipt);
-      latest = promise2;
-      return promise2;
-    },
-    settle: (event) => {
-      if (event.type !== "raw_model_stream_event" || !event.data || typeof event.data !== "object")
-        return;
-      if (event.data.type !== "response_done") return;
-      const id = responseId(event.data);
-      const receipt = receipts.get(event.data) ?? (id ? responseReceipts.get(id) : void 0) ?? (pending.size === 1 ? pending.values().next().value : void 0);
-      if (!receipt) return;
-      pending.delete(receipt);
-      if (id) responseReceipts.delete(id);
-      receipt.resolve();
-    },
-    fail,
-    close: () => {
-      input.signal.removeEventListener("abort", abort);
-      if (pending.size > 0) fail(new Error("Model stream closed before response settlement"));
-      responseReceipts.clear();
-    }
-  };
-}
-
 // src/activities/agent-turn/session-title.ts
 import { hasPermission } from "@opengeni/core";
 import { isManagedOpenRouterFreeRoute } from "@opengeni/config";
@@ -8712,31 +8567,12 @@ async function runTurnStreamAttempt(deps) {
   const modelResponseState = createModelResponseEventState(claimedModelUsageSourceKeys);
   let latestAssistantMessageText = null;
   let workerPreparationTotalRecorded = false;
-  const revalidateModelCallAdmission = async () => {
-    await historySink.reconcileConversationTruth({ requireDurable: true });
-    await ensureRunAllowedBetweenModelCalls({
-      settings,
-      db,
-      accountId: input.accountId,
-      workspaceId: input.workspaceId,
-      isExternallyBilledTurn: billingState.isExternallyBilledTurn,
-      entitlements,
-      chargesOpenGeniCredits: billingState.chargesOpenGeniCredits,
-      countsTowardTokenCap: billingState.countsTowardTokenCap,
-      initiatingHumanSubjectId: turn.initiatingHumanSubjectId
-    });
-  };
   const runStreamAttempt = async (options) => {
     if (!runInput) {
       throw new Error("Run input was not prepared");
     }
-    eventing.stream = void 0;
-    if (options.requireTerminalModelResponse) await revalidateModelCallAdmission();
-    const modelCallAdmission = createModelCallAdmission({
-      signal: runtimeCancellationSignal,
-      admit: revalidateModelCallAdmission
-    });
     const responseCountBeforeStream = modelResponseState.responseCount;
+    eventing.stream = void 0;
     eventing.batcher = null;
     let currentToolBatchCallIds = /* @__PURE__ */ new Set();
     let currentToolBatchCompletedCallIds = /* @__PURE__ */ new Set();
@@ -8904,8 +8740,6 @@ async function runTurnStreamAttempt(deps) {
         }
         attempt.modelRequestStarted = true;
         return await runtime.runStream(agent, runInput, eventing.modelRunSettings, {
-          beforeModelRequest: modelCallAdmission.beforeModelRequest,
-          onModelResponse: modelCallAdmission.onModelResponse,
           signal: runtimeCancellationSignal,
           sandboxEnvironment,
           onModelVisibleContext: async (snapshot) => {
@@ -9012,13 +8846,7 @@ async function runTurnStreamAttempt(deps) {
     if (leases.xai.lost) {
       throw new Error("xAI credential lease expired before the model run");
     }
-    try {
-      eventing.stream = await withProviderRequestContext(runStreamOnce);
-    } catch (error51) {
-      modelCallAdmission.fail(error51);
-      modelCallAdmission.close();
-      throw error51;
-    }
+    eventing.stream = await withProviderRequestContext(runStreamOnce);
     const streamTiming = new StreamTimingMetrics(observability, {
       provider: streamProvider
     });
@@ -9157,20 +8985,32 @@ async function runTurnStreamAttempt(deps) {
           await historySink.reconcileConversationTruth();
           turnLifecycleMetricsFor(observability).progress({ attemptId: input.attemptId });
           modelCheckpointMemoryCollector.schedule(observability);
-          await ensureRunAllowedBetweenModelCalls({
-            settings,
-            db,
-            accountId: input.accountId,
-            workspaceId: input.workspaceId,
-            isExternallyBilledTurn: billingState.isExternallyBilledTurn,
-            entitlements,
-            chargesOpenGeniCredits: billingState.chargesOpenGeniCredits,
-            countsTowardTokenCap: billingState.countsTowardTokenCap,
-            initiatingHumanSubjectId: turn.initiatingHumanSubjectId,
-            serializedRunState: () => media.compactMediaRunState(String(eventing.stream.state.toString()))
-          });
+          try {
+            await ensureRunAllowed(
+              settings,
+              db,
+              input.accountId,
+              input.workspaceId,
+              billingState.isExternallyBilledTurn,
+              entitlements,
+              billingState.chargesOpenGeniCredits,
+              billingState.countsTowardTokenCap
+            );
+          } catch (limitError) {
+            let serializedRunState = null;
+            try {
+              serializedRunState = media.compactMediaRunState(
+                String(eventing.stream.state.toString())
+              );
+            } catch {
+              serializedRunState = null;
+            }
+            throw new BudgetExhaustedError(
+              limitError instanceof Error ? limitError.message : String(limitError),
+              serializedRunState
+            );
+          }
         }
-        modelCallAdmission.settle(next.value);
         const durableSdkEvent = generatedImageReceipt ? compactGeneratedImageSdkEvent(next.value, generatedImageReceipt) : next.value;
         const pendingToolCall = pendingToolCallFromSdkEvent(durableSdkEvent);
         if (pendingToolCall) {
@@ -9385,7 +9225,6 @@ async function runTurnStreamAttempt(deps) {
         }
       }
     } catch (error51) {
-      modelCallAdmission.fail(error51);
       closeStreamWaitAdmission?.();
       if (fallbackProviderRequestLifecycleStartedAt !== null) {
         const durationMs = Math.max(
@@ -9435,7 +9274,6 @@ async function runTurnStreamAttempt(deps) {
       }
       throw error51;
     } finally {
-      modelCallAdmission.close();
       if (!streamDone) {
         void iterator.return?.().catch(() => void 0);
       }
@@ -9757,7 +9595,6 @@ async function runTurnStreamAttempt(deps) {
   })) {
     return claimedResult({ status: "cancelled" });
   }
-  await revalidateModelCallAdmission();
   if (turn.source !== "compaction" && generateSessionTitleInParallel && runtime.generateSessionTitle && !runtimeCancellationSignal.aborted) {
     const serviceTier = serviceTierForLatencyMode(
       turnExecutionPolicy.providerId,
@@ -10004,9 +9841,7 @@ import {
   loadOrganizationModelProviderApiKey,
   listWorkspaceProviderCustomModels,
   getWorkspaceProviderCustomModelForExecution,
-  loadWorkspaceProviderApiKey,
-  loadClaudeSubscriptionUsageCredential,
-  assertModelConnectionAllowsTurn
+  loadWorkspaceProviderApiKey
 } from "@opengeni/db";
 async function settingsWithSessionMcpServersForRun(db, workspaceId, sessionId, attemptId, settings, options) {
   const encryptionKey = environmentsEncryptionKeyBytes(settings);
@@ -10164,24 +9999,12 @@ async function settingsWithOrganizationProviderCredentials(db, accountId, worksp
     if (kind === "claude_subscription" && !settings.claudeSubscriptionEnabled) continue;
     const models = await buildModels(kind, claudeProviderId(kind) + "/");
     result = withClaudeConnectionCatalog(result, { [kind]: { models } });
-    const binding = kind === "claude_subscription" ? await loadClaudeSubscriptionUsageCredential(db, settings, {
-      accountId,
-      workspaceId,
-      scope: "organization"
-    }) : null;
-    const credential = kind === "claude_subscription" ? binding?.serializedCredential : await loadOrganizationModelProviderApiKey(db, settings, {
+    const credential = await loadOrganizationModelProviderApiKey(db, settings, {
       accountId,
       workspaceId,
       providerKind: kind
     });
-    if (credential)
-      result = withClaudeConnectionCredential(
-        result,
-        kind,
-        credential,
-        "organization",
-        binding ?? void 0
-      );
+    if (credential) result = withClaudeConnectionCredential(result, kind, credential);
     const workspaceModels = await listWorkspaceProviderCustomModels(db, {
       accountId,
       workspaceId,
@@ -10204,27 +10027,15 @@ async function settingsWithOrganizationProviderCredentials(db, accountId, worksp
       { [kind]: { models: workspaceModels } },
       "workspace"
     );
-    const workspaceBinding = kind === "claude_subscription" ? await loadClaudeSubscriptionUsageCredential(db, settings, {
-      accountId,
+    const workspaceCredential = await loadWorkspaceProviderApiKey(
+      db,
+      settings,
       workspaceId,
-      scope: "workspace"
-    }) : null;
-    if (workspaceBinding && workspaceModelId)
-      await assertModelConnectionAllowsTurn(db, {
-        workspaceId,
-        subjectId: "worker:model-access",
-        modelId: workspaceModelId,
-        workspaceProviderConnectionId: workspaceBinding.connectionId
-      });
-    const workspaceCredential = kind === "claude_subscription" ? workspaceBinding?.serializedCredential : await loadWorkspaceProviderApiKey(db, settings, workspaceId, kind, workspaceModelId);
+      kind,
+      workspaceModelId
+    );
     if (workspaceCredential)
-      result = withClaudeConnectionCredential(
-        result,
-        kind,
-        workspaceCredential,
-        "workspace",
-        workspaceBinding ?? void 0
-      );
+      result = withClaudeConnectionCredential(result, kind, workspaceCredential, "workspace");
   }
   return result;
 }
@@ -10442,27 +10253,20 @@ async function claimTurnAttempt(deps) {
     return attached.action === "claimed" && attached.turn.id === turn.id;
   };
   turnLifecycleMetricsFor(observability).start({ attemptId: input.attemptId });
-  let allowanceRefusal = null;
-  try {
-    await waitForTurnOperation(
-      ensureRunAllowed(
-        capabilitySettings,
-        db,
-        input.accountId,
-        input.workspaceId,
-        billingState.isExternallyBilledTurn,
-        entitlements,
-        billingState.chargesOpenGeniCredits,
-        billingState.countsTowardTokenCap,
-        turn.initiatingHumanSubjectId
-      ),
-      cancellationSignal,
-      void 0
-    );
-  } catch (error51) {
-    if (!(error51 instanceof AllowanceExhaustedError)) throw error51;
-    allowanceRefusal = error51.refusal;
-  }
+  await waitForTurnOperation(
+    ensureRunAllowed(
+      capabilitySettings,
+      db,
+      input.accountId,
+      input.workspaceId,
+      billingState.isExternallyBilledTurn,
+      entitlements,
+      billingState.chargesOpenGeniCredits,
+      billingState.countsTowardTokenCap
+    ),
+    cancellationSignal,
+    void 0
+  );
   const throwIfWorkerShuttingDown = () => {
     const reason = activityContext?.cancellationSignal.reason;
     if (isWorkerShutdownCancellation(reason)) {
@@ -10567,7 +10371,6 @@ async function claimTurnAttempt(deps) {
       sessionStatus: inputSettlement.sessionStatus,
       activeTurnId: inputSettlement.activeTurnId,
       ...inputSettlement.suppressGoalContinuation !== void 0 ? { suppressGoalContinuation: inputSettlement.suppressGoalContinuation } : {},
-      ...inputSettlement.allowanceGoalPause ? { allowanceGoalPause: inputSettlement.allowanceGoalPause } : {},
       events: inputs,
       ...runState ? { runState } : {},
       ...compactionRequestFailure ? { compactionRequestFailure } : {}
@@ -10615,31 +10418,6 @@ async function claimTurnAttempt(deps) {
     durationSeconds: (performance.now() - activityStarted) / 1e3
   });
   const turnStartSettlementStartedAt = performance.now();
-  if (allowanceRefusal) {
-    if (!await eventing.settle({
-      events: [
-        { type: "usage.exhausted", payload: allowanceRefusal },
-        {
-          type: "turn.completed",
-          payload: {
-            output: "",
-            segmentLimit: "budget_exhausted",
-            ...allowanceRefusal
-          }
-        },
-        { type: "session.status.changed", payload: { status: "idle" } }
-      ],
-      turnStatus: "completed",
-      sessionStatus: "idle",
-      activeTurnId: null,
-      allowanceGoalPause: { rationale: allowanceRefusal.message }
-    })) {
-      return { exit: claimedResult({ status: "cancelled" }) };
-    }
-    control.turnMetricOutcome = "completed";
-    control.activityStatus = "idle";
-    return { exit: claimedResult({ status: "idle" }) };
-  }
   if (!await eventing.settle({
     events: [
       { type: "session.status.changed", payload: { status: "running" } },
@@ -14564,100 +14342,6 @@ import {
 } from "@opengeni/runtime";
 import { codemodeWorkspaceUrl as codemodeWorkspaceUrl2 } from "@opengeni/config";
 
-// src/activities/mcp-account-routes.ts
-function accountRouteAuthNeededPayload(payload, bindings) {
-  const binding = bindings?.find((candidate) => candidate.serverId === payload.serverId);
-  return binding ? {
-    ...payload,
-    canonicalServerId: binding.canonicalServerId,
-    connectionSubjectScope: binding.subjectScope
-  } : payload;
-}
-function expandMcpAccountRoutes(input) {
-  if (input.bindings == null) {
-    return { settings: input.settings, tools: input.tools, accountLabels: /* @__PURE__ */ new Map() };
-  }
-  const configured = new Map(input.settings.mcpServers.map((server) => [server.id, server]));
-  const byCanonical = /* @__PURE__ */ new Map();
-  const routes = /* @__PURE__ */ new Set();
-  const accounts = /* @__PURE__ */ new Set();
-  for (const binding of input.bindings) {
-    const account = JSON.stringify([binding.canonicalServerId, binding.connectionId]);
-    if (routes.has(binding.serverId) || accounts.has(account) || configured.has(binding.serverId) || binding.subjectScope === "subject" !== (binding.ownerSubjectId !== null) || binding.connectionRef.authoritySource === "host" || binding.connectionRef.connectionId !== binding.connectionId || binding.connectionRef.subjectScope !== binding.subjectScope || binding.connectionRef.providerDomain !== binding.providerDomain || binding.connectionRef.kind !== binding.kind) {
-      throw new Error("Invalid accepted MCP account route");
-    }
-    routes.add(binding.serverId);
-    accounts.add(account);
-    const siblings = byCanonical.get(binding.canonicalServerId) ?? [];
-    siblings.push(binding);
-    byCanonical.set(binding.canonicalServerId, siblings);
-  }
-  const servers = [];
-  const tools = [];
-  const accountLabels = /* @__PURE__ */ new Map();
-  for (const tool of input.tools) {
-    const bindings = byCanonical.get(tool.id);
-    if (!bindings) {
-      if (!configured.get(tool.id)?.connectionRef) tools.push(tool);
-      continue;
-    }
-    const canonical = configured.get(tool.id);
-    if (!canonical?.connectionRef) {
-      throw new Error("Accepted MCP account route has no canonical connection configuration");
-    }
-    for (const binding of bindings) {
-      if (canonical.connectionRef.authoritySource === "host" || canonical.connectionRef.providerDomain !== binding.providerDomain || canonical.connectionRef.kind && canonical.connectionRef.kind !== binding.kind) {
-        throw new Error("Accepted MCP account route does not match canonical provider");
-      }
-      const { headers: _headers, ...config2 } = canonical;
-      const label = `${canonical.name ?? canonical.id} \u2014 ${binding.subjectScope === "subject" ? "Personal" : "Workspace"}: ${binding.accountLabel}`;
-      servers.push({
-        ...config2,
-        id: binding.serverId,
-        name: label,
-        connectionRef: structuredClone(binding.connectionRef)
-      });
-      tools.push({ ...tool, id: binding.serverId });
-      accountLabels.set(binding.serverId, label);
-    }
-  }
-  return {
-    settings: {
-      ...input.settings,
-      mcpServers: [
-        ...input.settings.mcpServers.filter((server) => !server.connectionRef),
-        ...servers
-      ]
-    },
-    tools,
-    accountLabels
-  };
-}
-function expandApiIntegrationAccountRoutes(input) {
-  const selected = new Set(input.tools.map((tool) => tool.id));
-  if (input.bindings == null)
-    return input.integrations.filter((item) => selected.has(item.serverId));
-  const acceptedBindings = input.bindings;
-  return input.integrations.flatMap((integration) => {
-    const bindings = acceptedBindings.filter(
-      (binding) => binding.canonicalServerId === integration.serverId
-    );
-    if (bindings.length === 0)
-      return !integration.connectionRef && selected.has(integration.serverId) ? [integration] : [];
-    return bindings.filter((binding) => selected.has(binding.serverId)).map((binding) => {
-      if (binding.connectionAuthorityGeneration === void 0) {
-        throw new Error("Accepted API integration account route has no authority generation");
-      }
-      return {
-        ...integration,
-        serverId: binding.serverId,
-        connectionRef: structuredClone(binding.connectionRef),
-        connectionAuthorityGeneration: binding.connectionAuthorityGeneration
-      };
-    });
-  });
-}
-
 // src/activities/git-credential-renewal.ts
 var GIT_CREDENTIAL_DEFAULT_REFRESH_MS = 30 * 6e4;
 var GIT_CREDENTIAL_EXPIRY_LEAD_MS = 5 * 6e4;
@@ -15016,8 +14700,6 @@ function credentialProviderRequestBody(input, initiatingHumanSubjectId, initiati
   lane: "workspace",
   mcpServers: []
 }) {
-  const via = input.initiatorContext.via;
-  const latestHop = Array.isArray(via) ? via.at(-1) : null;
   return {
     type: "credentials.request",
     lane: selection.lane,
@@ -15032,11 +14714,6 @@ function credentialProviderRequestBody(input, initiatingHumanSubjectId, initiati
     turnId: input.turnId,
     attemptId: input.attemptId,
     initiator: { kind: input.initiator.kind, subjectId: input.initiator.subjectId },
-    initiatorContext: {
-      kind: latestHop?.kind === "agent" ? "agent" : input.initiator.kind === "subject" ? "human" : "service",
-      initiator: input.initiator,
-      context: input.initiatorContext
-    },
     initiatingHumanSubjectId,
     initiatingHuman,
     sandboxBackend: input.effectiveSandboxBackend,
@@ -15228,7 +14905,7 @@ async function bindRunCredentialResolver(input) {
       mcpServers: selectedSessionRemoteMcpTargets(
         input.settings,
         input.session.mcpServers ?? [],
-        input.effectiveTools,
+        input.turn.tools ?? [],
         (input.localMcpServerIds ?? []).map((id) => ({ id }))
       )
     }
@@ -15244,23 +14921,22 @@ async function bindRunCredentialResolver(input) {
     workspaceId: input.workspaceId,
     sessionId: input.session.id
   };
-  const frozenRequest = structuredClone(
-    buildRunCredentialsRequest({
-      accountId: input.accountId,
-      workspaceId: input.workspaceId,
-      session: input.session,
-      turn: input.turn,
-      attemptId: input.attemptId,
-      effectiveSandboxBackend: input.effectiveSandboxBackend,
-      variableSet: input.variableSet,
-      rootSessionId,
-      purpose: "provision",
-      forceRefresh: false
-    })
-  );
   return {
     resolve: async ({ purpose, forceRefresh }) => {
-      const resolution = await resolver({ ...frozenRequest, purpose, forceRefresh });
+      const resolution = await resolver(
+        buildRunCredentialsRequest({
+          accountId: input.accountId,
+          workspaceId: input.workspaceId,
+          session: input.session,
+          turn: input.turn,
+          attemptId: input.attemptId,
+          effectiveSandboxBackend: input.effectiveSandboxBackend,
+          variableSet: input.variableSet,
+          rootSessionId,
+          purpose,
+          forceRefresh
+        })
+      );
       return normalizeRunCredentialsResolution(resolution, scope);
     }
   };
@@ -15305,19 +14981,13 @@ async function prepareRunCredentials(deps) {
   const platformGitResources = turnResources.filter(
     (resource) => resource.kind !== "repository" || repositoryHasExplicitGitConnection(resource)
   );
-  const accountRoutes = expandMcpAccountRoutes({
-    settings: runSettings,
-    tools: deps.turnTools,
-    bindings: turn.mcpAccountBindings
-  });
   const runCredentialResolver = effectiveRunCredentialBackend === "none" || effectiveRunCredentialBackend === "selfhosted" ? null : await waitForTurnOperation(
     bindRunCredentialResolver({
       db,
-      settings: accountRoutes.settings,
+      settings: runSettings,
       initiatingHumanSubjectId: turn.initiatingHumanSubjectId ?? null,
       connectionCredentials: connectionCredentials ?? null,
       localMcpServerIds: deps.localMcpServerIds ?? [],
-      effectiveTools: accountRoutes.tools,
       accountId: input.accountId,
       workspaceId: input.workspaceId,
       session,
@@ -15356,9 +15026,9 @@ async function prepareRunCredentials(deps) {
   ) : null;
   const runMcpCredentials = new RunMcpCredentials(
     selectedSessionRemoteMcpTargets2(
-      accountRoutes.settings,
+      runSettings,
       session.mcpServers ?? [],
-      accountRoutes.tools,
+      turn.tools ?? [],
       (deps.localMcpServerIds ?? []).map((id) => ({ id }))
     ),
     {
@@ -16740,6 +16410,100 @@ function isGitHubApiDestination(value) {
   }
 }
 
+// src/activities/mcp-account-routes.ts
+function accountRouteAuthNeededPayload(payload, bindings) {
+  const binding = bindings?.find((candidate) => candidate.serverId === payload.serverId);
+  return binding ? {
+    ...payload,
+    canonicalServerId: binding.canonicalServerId,
+    connectionSubjectScope: binding.subjectScope
+  } : payload;
+}
+function expandMcpAccountRoutes(input) {
+  if (input.bindings == null) {
+    return { settings: input.settings, tools: input.tools, accountLabels: /* @__PURE__ */ new Map() };
+  }
+  const configured = new Map(input.settings.mcpServers.map((server) => [server.id, server]));
+  const byCanonical = /* @__PURE__ */ new Map();
+  const routes = /* @__PURE__ */ new Set();
+  const accounts = /* @__PURE__ */ new Set();
+  for (const binding of input.bindings) {
+    const account = JSON.stringify([binding.canonicalServerId, binding.connectionId]);
+    if (routes.has(binding.serverId) || accounts.has(account) || configured.has(binding.serverId) || binding.subjectScope === "subject" !== (binding.ownerSubjectId !== null) || binding.connectionRef.authoritySource === "host" || binding.connectionRef.connectionId !== binding.connectionId || binding.connectionRef.subjectScope !== binding.subjectScope || binding.connectionRef.providerDomain !== binding.providerDomain || binding.connectionRef.kind !== binding.kind) {
+      throw new Error("Invalid accepted MCP account route");
+    }
+    routes.add(binding.serverId);
+    accounts.add(account);
+    const siblings = byCanonical.get(binding.canonicalServerId) ?? [];
+    siblings.push(binding);
+    byCanonical.set(binding.canonicalServerId, siblings);
+  }
+  const servers = [];
+  const tools = [];
+  const accountLabels = /* @__PURE__ */ new Map();
+  for (const tool of input.tools) {
+    const bindings = byCanonical.get(tool.id);
+    if (!bindings) {
+      if (!configured.get(tool.id)?.connectionRef) tools.push(tool);
+      continue;
+    }
+    const canonical = configured.get(tool.id);
+    if (!canonical?.connectionRef) {
+      throw new Error("Accepted MCP account route has no canonical connection configuration");
+    }
+    for (const binding of bindings) {
+      if (canonical.connectionRef.authoritySource === "host" || canonical.connectionRef.providerDomain !== binding.providerDomain || canonical.connectionRef.kind && canonical.connectionRef.kind !== binding.kind) {
+        throw new Error("Accepted MCP account route does not match canonical provider");
+      }
+      const { headers: _headers, ...config2 } = canonical;
+      const label = `${canonical.name ?? canonical.id} \u2014 ${binding.subjectScope === "subject" ? "Personal" : "Workspace"}: ${binding.accountLabel}`;
+      servers.push({
+        ...config2,
+        id: binding.serverId,
+        name: label,
+        connectionRef: structuredClone(binding.connectionRef)
+      });
+      tools.push({ ...tool, id: binding.serverId });
+      accountLabels.set(binding.serverId, label);
+    }
+  }
+  return {
+    settings: {
+      ...input.settings,
+      mcpServers: [
+        ...input.settings.mcpServers.filter((server) => !server.connectionRef),
+        ...servers
+      ]
+    },
+    tools,
+    accountLabels
+  };
+}
+function expandApiIntegrationAccountRoutes(input) {
+  const selected = new Set(input.tools.map((tool) => tool.id));
+  if (input.bindings == null)
+    return input.integrations.filter((item) => selected.has(item.serverId));
+  const acceptedBindings = input.bindings;
+  return input.integrations.flatMap((integration) => {
+    const bindings = acceptedBindings.filter(
+      (binding) => binding.canonicalServerId === integration.serverId
+    );
+    if (bindings.length === 0)
+      return !integration.connectionRef && selected.has(integration.serverId) ? [integration] : [];
+    return bindings.filter((binding) => selected.has(binding.serverId)).map((binding) => {
+      if (binding.connectionAuthorityGeneration === void 0) {
+        throw new Error("Accepted API integration account route has no authority generation");
+      }
+      return {
+        ...integration,
+        serverId: binding.serverId,
+        connectionRef: structuredClone(binding.connectionRef),
+        connectionAuthorityGeneration: binding.connectionAuthorityGeneration
+      };
+    });
+  });
+}
+
 // src/activities/agent-turn/tool-environment.ts
 import { createMcpOperationPersistence } from "@opengeni/db/mcp-operations";
 
@@ -32493,10 +32257,8 @@ import {
   buildApiIntegrationMcpServers,
   resolveCatalogSettings as resolveCatalogSettings2,
   resolveWorkspaceModelSelection,
-  loadWorkspaceCodexModelAvailability,
   withFrozenPersonalConnectionDelegations,
-  resolveTurnToolPolicy,
-  scheduledTurnMcpServerIds,
+  resolveSessionToolPolicy,
   hasPermission as hasPermission2
 } from "@opengeni/core";
 import { SandboxChannelAService as SandboxChannelAService3 } from "@opengeni/runtime/sandbox";
@@ -33941,17 +33703,21 @@ async function prepareTurnToolPolicy(deps) {
   } = deps;
   const turnResources = mergeResourceRefs(session.resources, turn.resources);
   const runtimeResources = runtimeResourcesForTurn(session.resources, turn.resources);
-  const resolvedToolPolicy = resolveTurnToolPolicy({
+  const scheduledEffectiveMcpServerIds = (() => {
+    const value = turn.metadata && typeof turn.metadata === "object" && !Array.isArray(turn.metadata) ? turn.metadata.scheduledEffectiveMcpServerIds : null;
+    return Array.isArray(value) && value.every((id) => typeof id === "string") ? [...new Set(value)].sort() : null;
+  })();
+  const currentMcpServerIds = new Set(runSettings.mcpServers.map((server) => server.id));
+  const resolvedToolPolicy = resolveSessionToolPolicy({
     toolPolicy: session.toolPolicy,
-    session,
-    turn,
-    availableMcpServerIds: runSettings.mcpServers.map((server) => server.id),
-    defaultMcpServerIds: scheduledTurnMcpServerIds(turn) === null && session.toolPolicy.mode === "workspace_default" ? await workspaceSessionToolPolicyDefaultServerIds(
+    sessionTools: scheduledEffectiveMcpServerIds ? turn.tools : session.tools,
+    availableMcpServerIds: scheduledEffectiveMcpServerIds ? scheduledEffectiveMcpServerIds.filter((id) => currentMcpServerIds.has(id)) : [...currentMcpServerIds],
+    defaultMcpServerIds: scheduledEffectiveMcpServerIds ?? (session.toolPolicy.mode === "workspace_default" ? await workspaceSessionToolPolicyDefaultServerIds(
       db,
       input.workspaceId,
       capabilitySettings,
       fileAuthoritySubjectId ?? void 0
-    ) : []
+    ) : [])
   });
   const mcpAvailabilityNote = unavailableMcpOperationalContext({
     droppedIds: resolvedToolPolicy.effectivePolicy.droppedIds,
@@ -34517,8 +34283,7 @@ async function prepareTurnToolRuntime(deps) {
           organizationGatewayConnectionActive,
           organizationGatewayCustomModels,
           organizationOpenRouterConnectionActive,
-          organizationOpenRouterCustomModels,
-          codexModelAvailability
+          organizationOpenRouterCustomModels
         ] = await Promise.all([
           getWorkspaceConnectionModelRestrictions(
             db,
@@ -34561,12 +34326,10 @@ async function prepareTurnToolRuntime(deps) {
             accountId: input.accountId,
             workspaceId: input.workspaceId,
             providerKind: "openrouter"
-          }),
-          loadWorkspaceCodexModelAvailability(db, currentSettings, input.workspaceId)
+          })
         ]);
         return {
           selections: resolveWorkspaceModelSelection({
-            observations: codexModelAvailability,
             connectionModelRestrictions,
             settings: currentSettings,
             policy,
@@ -34710,7 +34473,7 @@ async function prepareTurnToolRuntime(deps) {
         sessionAttachedRemoteMcpTargets: selectedSessionRemoteMcpTargets3(
           githubRestMcp.settings,
           session.mcpServers ?? [],
-          githubRestMcp.tools,
+          turn.tools ?? [],
           localMcpServers
         ),
         ...deps.runMcpCredentials ? { runMcpCredentials: deps.runMcpCredentials } : {},
@@ -37115,14 +36878,11 @@ function createRunAgentTurnActivity(services) {
       getModelRunSettings: () => eventing.modelRunSettings,
       getExecutionGeneration: () => attempt.executionGeneration
     });
-    const checkpointBeforeProviderDispatch = async () => {
-      await awaitModelCallAdmission();
-      await checkpointHistoryBeforeProviderDispatch(historySink, {
-        effectiveSandboxBackend: eventing.modelRunSettings.sandboxBackend,
-        routingEnabled: routingEnabled(settings),
-        readActiveSandbox: () => readActiveSandbox3(db, input.workspaceId, input.sessionId)
-      });
-    };
+    const checkpointBeforeProviderDispatch = () => checkpointHistoryBeforeProviderDispatch(historySink, {
+      effectiveSandboxBackend: eventing.modelRunSettings.sandboxBackend,
+      routingEnabled: routingEnabled(settings),
+      readActiveSandbox: () => readActiveSandbox3(db, input.workspaceId, input.sessionId)
+    });
     try {
       const claimed = await claimTurnAttempt({
         input,
@@ -37265,7 +37025,7 @@ function createRunAgentTurnActivity(services) {
             requiredGeneratedVideoFiles
           });
           if ("exit" in governance) return governance.exit;
-          await assertModelConnectionAllowsTurn2(db, {
+          await assertModelConnectionAllowsTurn(db, {
             workspaceId: input.workspaceId,
             subjectId: turn.initiatingHumanSubjectId ?? "worker:model-access",
             modelId: turnExecutionPolicy.productModelId,
@@ -37572,36 +37332,13 @@ function createRunAgentTurnActivity(services) {
           const claudeUsageObserver = await createClaudeUsageObserver(
             parseModelProvidersJson(runSettings.modelProvidersJson),
             providerTurn.latestClaudeUsage,
-            (scope) => loadClaudeSubscriptionUsageCredential2(db, settings, {
+            (scope) => loadClaudeSubscriptionUsageCredential(db, settings, {
               accountId: input.accountId,
               workspaceId: input.workspaceId,
               scope
             })
           );
-          const withClaudeUsage = (fn) => withClaudeUsageObserver(claudeUsageObserver, fn, async (providerId, headers) => {
-            const binding = claudeUsageObserver.binding(providerId);
-            if (!binding) return headers;
-            const credential = await resolveClaudeSubscriptionCredential(
-              db,
-              settings,
-              {
-                accountId: input.accountId,
-                workspaceId: input.workspaceId,
-                scope: binding.scope
-              },
-              {
-                expectedConnectionId: binding.expectedConnectionId,
-                expectedCredentialVersion: binding.expectedCredentialVersion
-              }
-            );
-            if (!credential) return headers;
-            if ("reconnectRequired" in credential)
-              throw new ClaudeSubscriptionReconnectRequired();
-            claudeUsageObserver.renew(providerId, credential);
-            headers.set("authorization", `Bearer ${credential.token}`);
-            headers.delete("x-api-key");
-            return headers;
-          });
+          const withClaudeUsage = (fn) => withClaudeUsageObserver(claudeUsageObserver, fn);
           const withCodex = (fn) => codexContext ? codexRequestStorage.run(codexContext, fn) : fn();
           const withProviderRequestContext = (fn) => withClaudeUsage(
             () => providerTurn.xaiRequestContext ? xaiSubscriptionRequestStorage.run(providerTurn.xaiRequestContext, fn) : withCodex(fn)
@@ -37805,7 +37542,6 @@ These are publication receipts for the human's earlier answer. Do not call the r
             void 0
           );
           const runCredentials = await prepareRunCredentials({
-            turnTools,
             localMcpServerIds: installedApiIntegrations.map((integration) => integration.serverId),
             input,
             settings,
@@ -39571,4 +39307,4 @@ export {
   createTurnActivities,
   createTurnActivitiesFromServices
 };
-//# sourceMappingURL=activities-turn-LSRAUGEK.js.map
+//# sourceMappingURL=activities-turn-FQ5OO2WW.js.map