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

package/src/activities/agent-turn/tool-environment.ts

@@ -68,10 +68,8 @@ import {
   buildApiIntegrationMcpServers,
   resolveCatalogSettings,
   resolveWorkspaceModelSelection,
-  loadWorkspaceCodexModelAvailability,
   withFrozenPersonalConnectionDelegations,
-  resolveTurnToolPolicy,
-  scheduledTurnMcpServerIds,
+  resolveSessionToolPolicy,
   hasPermission,
 } from "@opengeni/core";
 import { loadWorkspaceEnvironmentForRunWithCredentials } from "../environment";
@@ -225,20 +223,32 @@ export async function prepareTurnToolPolicy(deps: PrepareTurnToolPolicyDeps) {
   // sessions follow the current configured MCP set,
   // while explicit, inherited-fixed, and legacy sessions remain narrowed
   // to their stored materialized allow-list.
-  const resolvedToolPolicy = resolveTurnToolPolicy({
+  const scheduledEffectiveMcpServerIds = (() => {
+    const value =
+      turn.metadata && typeof turn.metadata === "object" && !Array.isArray(turn.metadata)
+        ? (turn.metadata as Record<string, unknown>).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),
+    sessionTools: scheduledEffectiveMcpServerIds ? turn.tools : session.tools,
+    availableMcpServerIds: scheduledEffectiveMcpServerIds
+      ? scheduledEffectiveMcpServerIds.filter((id) => currentMcpServerIds.has(id))
+      : [...currentMcpServerIds],
     defaultMcpServerIds:
-      scheduledTurnMcpServerIds(turn) === null && session.toolPolicy.mode === "workspace_default"
+      scheduledEffectiveMcpServerIds ??
+      (session.toolPolicy.mode === "workspace_default"
         ? await workspaceSessionToolPolicyDefaultServerIds(
             db,
             input.workspaceId,
             capabilitySettings,
             fileAuthoritySubjectId ?? undefined,
           )
-        : [],
+        : []),
   });
   const mcpAvailabilityNote = unavailableMcpOperationalContext({
     droppedIds: resolvedToolPolicy.effectivePolicy.droppedIds,
@@ -898,7 +908,6 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
           organizationGatewayCustomModels,
           organizationOpenRouterConnectionActive,
           organizationOpenRouterCustomModels,
-          codexModelAvailability,
         ] = await Promise.all([
           getWorkspaceConnectionModelRestrictions(
             db,
@@ -944,11 +953,9 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
             workspaceId: input.workspaceId,
             providerKind: "openrouter",
           }),
-          loadWorkspaceCodexModelAvailability(db, currentSettings, input.workspaceId),
         ]);
         return {
           selections: resolveWorkspaceModelSelection({
-            observations: codexModelAvailability,
             connectionModelRestrictions,
             settings: currentSettings,
             policy,
@@ -1103,7 +1110,7 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
         sessionAttachedRemoteMcpTargets: selectedSessionRemoteMcpTargets(
           githubRestMcp.settings,
           session.mcpServers ?? [],
-          githubRestMcp.tools,
+          turn.tools ?? [],
           localMcpServers,
         ),
         ...(deps.runMcpCredentials ? { runMcpCredentials: deps.runMcpCredentials } : {}),

package/src/activities/agent-turn/turn-context.ts

@@ -48,7 +48,6 @@ export type TurnSettleFn = (input: {
   sessionStatus: SessionStatus;
   activeTurnId: string | null;
   suppressGoalContinuation?: boolean;
-  allowanceGoalPause?: ApplySessionTurnSettlementInput["allowanceGoalPause"];
   consumeRequestedCompactionFailure?: boolean;
   runState?: ApplySessionTurnSettlementInput["runState"];
 }) => Promise<boolean>;

package/src/activities/capabilities.ts

@@ -40,8 +40,6 @@ import {
   listWorkspaceProviderCustomModels,
   getWorkspaceProviderCustomModelForExecution,
   loadWorkspaceProviderApiKey,
-  loadClaudeSubscriptionUsageCredential,
-  assertModelConnectionAllowsTurn,
   type Database,
   type SessionMcpServerForRun,
 } from "@opengeni/db";
@@ -305,30 +303,12 @@ export async function settingsWithOrganizationProviderCredentials(
     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, {
-            accountId,
-            workspaceId,
-            providerKind: kind,
-          });
-    if (credential)
-      result = withClaudeConnectionCredential(
-        result,
-        kind,
-        credential,
-        "organization",
-        binding ?? undefined,
-      );
+    const credential = await loadOrganizationModelProviderApiKey(db, settings, {
+      accountId,
+      workspaceId,
+      providerKind: kind,
+    });
+    if (credential) result = withClaudeConnectionCredential(result, kind, credential);
     const workspaceModels = await listWorkspaceProviderCustomModels(db, {
       accountId,
       workspaceId,
@@ -353,33 +333,15 @@ export async function settingsWithOrganizationProviderCredentials(
       { [kind]: { models: workspaceModels } },
       "workspace",
     );
-    const workspaceBinding =
-      kind === "claude_subscription"
-        ? await loadClaudeSubscriptionUsageCredential(db, settings, {
-            accountId,
-            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);
+    const workspaceCredential = await loadWorkspaceProviderApiKey(
+      db,
+      settings,
+      workspaceId,
+      kind,
+      workspaceModelId,
+    );
     if (workspaceCredential)
-      result = withClaudeConnectionCredential(
-        result,
-        kind,
-        workspaceCredential,
-        "workspace",
-        workspaceBinding ?? undefined,
-      );
+      result = withClaudeConnectionCredential(result, kind, workspaceCredential, "workspace");
   }
   return result;
 }

package/src/activities/goals.ts

@@ -19,10 +19,14 @@ import {
 import { isCodexBilledModel } from "@opengeni/codex";
 import {
   enqueueSessionWorkflowWakeIfRunnable,
+  getBillingBalance,
   getWorkspaceModelPolicy,
   getSessionGoal,
+  isCodexBilledTurn,
   materializeGoalContinuation,
   requireSession,
+  sumUsageQuantity,
+  type Database,
 } from "@opengeni/db";
 import type {
   ControlActivityServices,
@@ -34,7 +38,6 @@ import {
   resolveCatalogSettings,
   resolveWorkspaceCatalogSettings,
 } from "@opengeni/core";
-import { agentRunAdmissionDenial } from "./agent-run-admission";
 
 export function createGoalActivities(services: () => Promise<ControlActivityServices>) {
   async function enqueueGoalRetryWake(input: MaybeContinueGoalInput): Promise<void> {
@@ -106,6 +109,30 @@ export function createGoalActivities(services: () => Promise<ControlActivityServ
     ) {
       modelPolicyBlocked = `session is locked to Codex remote compaction v2; model "${continuationModel}" is not a Codex subscription model`;
     }
+    // A codex-model goal continuation is paid by the user's ChatGPT/Codex plan,
+    // so it must not be budget-paused for zero OpenGeni credits. This file uses
+    // BASE settings (no codex overlay); the predicate does its own credential read.
+    const isCodexRun = await isCodexBilledTurn({
+      db,
+      settings,
+      workspaceId: input.workspaceId,
+      model: continuationModel,
+    });
+    const fundedWithoutCredits = goalContinuationFundedWithoutCredits(
+      settings,
+      continuationModel,
+      isCodexRun,
+    );
+    // Budget exhaustion pauses the goal visibly instead of failing the
+    // session. Computed up front and applied inside the locked decision so a
+    // limits pause never consumes continuation budget.
+    const budgetBlocked = await goalRunBudgetBlocked(
+      settings,
+      db,
+      input.accountId,
+      input.workspaceId,
+      fundedWithoutCredits,
+    );
     const turnExecutionPolicy = resolveTurnExecutionPolicyV1(settings, {
       modelId: continuationModel,
       requestedModelId: null,
@@ -130,25 +157,7 @@ export function createGoalActivities(services: () => Promise<ControlActivityServ
       // A model-policy block takes precedence: it is deterministic (a budget
       // pause can clear on its own; a policy pause needs a model/policy change)
       // and rides the same visible-pause channel.
-      admission: async (tx, causalTurn) => {
-        const budgetBlocked = modelPolicyBlocked
-          ? null
-          : await goalRunBudgetBlocked(
-              { ...service, settings, db: tx },
-              {
-                accountId: input.accountId,
-                workspaceId: input.workspaceId,
-                model: continuationModel,
-                initiatingHumanSubjectId: causalTurn?.initiatingHumanSubjectId ?? null,
-              },
-            );
-        return {
-          budgetBlocked: modelPolicyBlocked ?? budgetBlocked?.message ?? null,
-          budgetPausedReason: modelPolicyBlocked
-            ? "limits"
-            : (budgetBlocked?.pausedReason ?? "limits"),
-        };
-      },
+      budgetBlocked: modelPolicyBlocked ?? budgetBlocked,
       policy: {
         model: continuationModel,
         reasoningEffort: continuationReasoningEffort,
@@ -327,22 +336,55 @@ export function withFirstPartyTools(settings: Settings, tools: ToolRef[]): ToolR
 }
 
 /**
- * Goals share scheduled admission and pause visibly without synthesizing work.
+ * Non-throwing variant of the scheduled-run admission check: returns a human
+ * readable reason when balance or monthly caps block another agent run.
  */
-export async function goalRunBudgetBlocked(
-  services: Parameters<typeof agentRunAdmissionDenial>[0],
-  input: Omit<Parameters<typeof agentRunAdmissionDenial>[1], "requestedAgentRuns">,
-): Promise<{ pausedReason: "limits" | "allowance"; message: string } | null> {
-  const denial = await agentRunAdmissionDenial(services, { ...input, requestedAgentRuns: 1 });
-  if (denial === null) return null;
-  if (denial === "allowance_exhausted") {
-    return { pausedReason: "allowance", message: "OpenGeni usage allowance exhausted" };
+async function goalRunBudgetBlocked(
+  settings: Settings,
+  db: Database,
+  accountId: string,
+  workspaceId: string,
+  fundedWithoutCredits: boolean,
+): Promise<string | null> {
+  // Free, subscription, and workspace-funded continuations skip OpenGeni's
+  // credit-balance gate and monthly model-cost cap. The agent-run COUNT cap
+  // below is a volume quota (not a credit/cost gate) and remains enforced.
+  if (
+    !fundedWithoutCredits &&
+    (settings.billingMode === "stripe" || settings.usageLimitsMode === "managed")
+  ) {
+    const balance = await getBillingBalance(db, accountId);
+    if (balance.balanceMicros <= 0) {
+      return "insufficient OpenGeni credits";
+    }
   }
-  const limits = configuredStaticUsageLimits(services.settings);
-  const messages = {
-    insufficient_credits: "insufficient OpenGeni credits",
-    monthly_model_cost_limit: `monthly model cost limit reached (${limits.maxMonthlyCostMicrosPerAccount} micros)`,
-    monthly_agent_run_limit: `monthly agent run limit reached (${limits.maxMonthlyAgentRunsPerWorkspace})`,
-  };
-  return { pausedReason: "limits", message: messages[denial] };
+  if (settings.usageLimitsMode === "static" || settings.usageLimitsMode === "managed") {
+    const limits = configuredStaticUsageLimits(settings);
+    if (!fundedWithoutCredits && limits.maxMonthlyCostMicrosPerAccount) {
+      const used = await sumUsageQuantity(db, {
+        accountId,
+        eventType: "model.cost",
+        since: startOfUtcMonth(),
+      });
+      if (used >= limits.maxMonthlyCostMicrosPerAccount) {
+        return `monthly model cost limit reached (${limits.maxMonthlyCostMicrosPerAccount} micros)`;
+      }
+    }
+    if (limits.maxMonthlyAgentRunsPerWorkspace) {
+      const used = await sumUsageQuantity(db, {
+        workspaceId,
+        eventType: "agent_run.created",
+        since: startOfUtcMonth(),
+      });
+      if (used + 1 > limits.maxMonthlyAgentRunsPerWorkspace) {
+        return `monthly agent run limit reached (${limits.maxMonthlyAgentRunsPerWorkspace})`;
+      }
+    }
+  }
+  return null;
+}
+
+function startOfUtcMonth(): Date {
+  const now = new Date();
+  return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
 }

package/src/activities/knowledge-indexing.ts

@@ -4,10 +4,8 @@ import {
   applyCreditDebitAfterUse,
   appendKnowledgeIndexChunks,
   claimKnowledgeIndexJobs,
-  checkWorkspaceAllowance,
   completeKnowledgeIndexJob,
   continueKnowledgeIndexJob,
-  creditDebitAttributionMetadata,
   deferKnowledgeIndexJob,
   freezeKnowledgeIndexBillingMode,
   getBillingBalance,
@@ -200,16 +198,6 @@ export function createKnowledgeIndexingActivities(
                 return;
               }
               const paid = frozenPolicy.mode === "credits";
-              if (paid && claim.billingAttribution.kind === "unknown") {
-                // Unknown legacy/source-preparation causality is not service.
-                // Keep the checkpoint without making an uncountable paid call.
-                observability.warn("Paid Knowledge indexing awaits initiating attribution", {
-                  errorCode: "knowledge_index_attribution_unavailable",
-                });
-                await deferKnowledgeIndexJob(lockedDb, claim);
-                result.deferred++;
-                return;
-              }
               if (paid && current.nextIndex === 0) {
                 const balance = await getBillingBalance(lockedDb, claim.accountId);
                 if (balance.balanceMicros <= 0) {
@@ -218,22 +206,6 @@ export function createKnowledgeIndexingActivities(
                   return;
                 }
               }
-              if (paid) {
-                const refusal = await checkWorkspaceAllowance(lockedDb, {
-                  accountId: claim.accountId,
-                  workspaceId: current.billingWorkspaceId,
-                  subjectId:
-                    claim.billingAttribution.kind === "turn" ||
-                    claim.billingAttribution.kind === "human"
-                      ? claim.billingAttribution.initiatingHumanSubjectId
-                      : null,
-                });
-                if (refusal) {
-                  await deferKnowledgeIndexJob(lockedDb, claim);
-                  result.deferred++;
-                  return;
-                }
-              }
               if (settings.usageLimitsMode === "static" || settings.usageLimitsMode === "managed") {
                 const limit =
                   configuredStaticUsageLimits(settings).maxDocumentIndexedChunksPerWorkspace;
@@ -337,7 +309,6 @@ export function createKnowledgeIndexingActivities(
                     sourceId: claim.revisionId,
                     idempotencyKey: `knowledge.embedding:${claim.revisionId}:${claim.generation}:${current.nextIndex}`,
                     metadata: {
-                      ...creditDebitAttributionMetadata(claim.billingAttribution),
                       model: claim.model,
                       bytes,
                       chunks: chunks.length,

package/src/activities/run-credentials.ts

@@ -5,7 +5,6 @@ import type {
   RunCredentialsRequest,
   Session,
   SessionTurn,
-  ToolRef,
 } from "@opengeni/contracts";
 import type { Settings } from "@opengeni/config";
 import { getSessionRootId, type Database } from "@opengeni/db";
@@ -31,8 +30,6 @@ export type RunCredentialResolutionContext = {
   initiatingHumanSubjectId?: string | null;
   /** Installed in-process API routes must never enter a product callback. */
   localMcpServerIds?: readonly string[];
-  /** Exact execution selection, resolved once at the turn policy boundary. */
-  effectiveTools: readonly ToolRef[];
 };
 
 export type BoundRunCredentialResolver = {
@@ -45,7 +42,7 @@ export type BoundRunCredentialResolver = {
 export function buildRunCredentialsRequest(
   input: Omit<
     RunCredentialResolutionContext,
-    "db" | "connectionCredentials" | "settings" | "initiatingHumanSubjectId" | "effectiveTools"
+    "db" | "connectionCredentials" | "settings" | "initiatingHumanSubjectId"
   > & {
     rootSessionId: string;
     purpose: "provision" | "renewal";
@@ -128,7 +125,7 @@ export async function bindRunCredentialResolver(
           mcpServers: selectedSessionRemoteMcpTargets(
             input.settings,
             input.session.mcpServers ?? [],
-            input.effectiveTools,
+            input.turn.tools ?? [],
             (input.localMcpServerIds ?? []).map((id) => ({ id })),
           ),
         },
@@ -149,25 +146,22 @@ export async function bindRunCredentialResolver(
     workspaceId: input.workspaceId,
     sessionId: input.session.id,
   };
-  // A renewable resolver belongs to one admitted turn, even if its caller
-  // subsequently replaces or mutates an in-memory session/turn projection.
-  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);
     },
   };

package/src/activities/scheduled-tasks.ts

@@ -917,7 +917,6 @@ export function createScheduledTaskActivities(services: () => Promise<ControlAct
           workspaceId: task.workspaceId,
           model: targetSessionExecution?.model ?? model,
           requestedAgentRuns: input.agentRunUsageIdempotencyKey ? 0 : 1,
-          initiatingHumanSubjectId: causalHumanSubjectId,
         },
       );
       if (admissionDenial) {

package/src/activities/types.ts

@@ -458,7 +458,6 @@ export type DispatchScheduledTaskRunResult =
       refusal?: import("@opengeni/contracts").ScheduledTaskAdmissionRefusal;
       reason:
         | "insufficient_credits"
-        | "allowance_exhausted"
         | "monthly_model_cost_limit"
         | "monthly_agent_run_limit"
         | "malformed_manual_trigger"

package/src/activities/workspace-credential-provider.ts

@@ -78,8 +78,6 @@ export function credentialProviderRequestBody(
     mcpServers: [],
   },
 ): CredentialProviderRequest {
-  const via = input.initiatorContext.via;
-  const latestHop = Array.isArray(via) ? via.at(-1) : null;
   return {
     type: "credentials.request",
     lane: selection.lane,
@@ -94,16 +92,6 @@ export function credentialProviderRequestBody(
     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,

package/dist/activities/agent-turn/model-call-admission.d.ts

@@ -1,15 +0,0 @@
-import type { StreamEvent } from "@openai/agents";
-/** SDK producer/consumer rendezvous. Usage stays on the sole consumer writer. */
-export declare function createModelCallAdmission(input: {
-    signal: AbortSignal;
-    admit: () => Promise<void>;
-}): {
-    beforeModelRequest: () => Promise<void>;
-    onModelResponse: (event: StreamEvent) => Promise<void>;
-    settle: (event: {
-        type: string;
-        data?: unknown;
-    }) => void;
-    fail: (error: unknown) => void;
-    close: () => void;
-};