@opengeni/worker-bundle 1.0.0-canary.1 → 1.0.0

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

@@ -83,6 +83,82 @@ export function structuredToolTransportForTurn(
   );
 }
 
+/**
+ * `text.verbosity: "low"` is the Codex CLI default for its GPT-5-family models
+ * and keeps final answers short. Send it only where the wire is known to accept
+ * it: the ChatGPT/Codex subscription backend, direct OpenAI Responses, and the
+ * Azure OpenAI Responses wire, where the parallel session-title request already
+ * sends the same field with the turn's model. Gateways, xAI, other
+ * OpenAI-compatible endpoints and chat wires keep their provider default. The
+ * result depends only on the route and model, so a session sends the same value
+ * on every request until its model changes, and a model change already starts a
+ * new prompt-cache prefix.
+ */
+export function textVerbosityForTurn(
+  resolvedModel: {
+    provider: {
+      id: string;
+      kind: ResolvedModelProvider["kind"];
+      api: ModelProviderApi;
+      wireProfile: "openai" | "azure-openai";
+      builtin: boolean;
+      baseUrl?: string | undefined;
+    };
+  } | null,
+  upstreamModelId: string,
+): "low" | undefined {
+  if (resolvedModel?.provider.api !== "responses") return undefined;
+  const provider = resolvedModel.provider;
+  const acceptsVerbosity =
+    provider.kind === "codex-subscription" ||
+    provider.wireProfile === "azure-openai" ||
+    (provider.builtin && provider.id === "openai" && isDirectOpenAiApiBaseUrl(provider.baseUrl));
+  return acceptsVerbosity && modelAcceptsTextVerbosity(upstreamModelId) ? "low" : undefined;
+}
+
+// GPT-5 and later accept low/medium/high. Earlier models and the -codex and
+// -chat variants accept only the default, so a non-default value is rejected.
+function modelAcceptsTextVerbosity(upstreamModelId: string): boolean {
+  return (
+    /^gpt-(?:[5-9]|[1-9]\d)(?:[.-]|$)/.test(upstreamModelId) &&
+    !/-(?:codex|chat)(?:-|$)/.test(upstreamModelId)
+  );
+}
+
+/**
+ * Ask supported reasoning Responses routes for their provider-selected summary
+ * format. This is public summary text, never private or encrypted reasoning.
+ * Codex and unverified compatible wires retain the existing detailed setting.
+ */
+export function reasoningSummaryForTurn(
+  resolvedModel: {
+    provider: {
+      id: string;
+      api: ModelProviderApi;
+      wireProfile: "openai" | "azure-openai";
+      builtin: boolean;
+      baseUrl?: string | undefined;
+    };
+    configured: {
+      upstreamModelId: string;
+      capabilities: { reasoning: { runnable: boolean } };
+    };
+  } | null,
+): "auto" | undefined {
+  if (
+    resolvedModel?.provider.api !== "responses" ||
+    !resolvedModel.configured.capabilities.reasoning.runnable ||
+    !modelAcceptsTextVerbosity(resolvedModel.configured.upstreamModelId)
+  ) {
+    return undefined;
+  }
+  const provider = resolvedModel.provider;
+  return provider.wireProfile === "azure-openai" ||
+    (provider.builtin && provider.id === "openai" && isDirectOpenAiApiBaseUrl(provider.baseUrl))
+    ? "auto"
+    : undefined;
+}
+
 /**
  * Progressive tool disclosure is universal for supported OpenGeni turns; only
  * its contained transport differs. Codex keeps its native path, built-in direct
@@ -218,7 +294,10 @@ export function modelAttachmentInputPolicyForTurn(
     };
   } | null,
 ): ModelAttachmentInputPolicy {
-  const typedTransport = resolvedModel === null || resolvedModel.provider.api === "responses";
+  const typedTransport =
+    resolvedModel === null ||
+    resolvedModel.provider.api === "responses" ||
+    resolvedModel.provider.api === "anthropic-messages";
   return {
     supportsImageInput: typedTransport && modelSupportsImageInputForTurn(resolvedModel),
     inputFileMediaTypes: [],

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

@@ -1,3 +1,4 @@
+import type { TurnHeartbeatDetails } from "../../op-journal";
 import type { Settings } from "@opengeni/config";
 import type { CodexUsageHeaderSnapshot } from "@opengeni/codex";
 import type { AppendEventInput, ApplySessionTurnSettlementInput } from "@opengeni/db";
@@ -25,6 +26,7 @@ import type { TurnOutcome } from "../../observability-metrics";
 import type { ResumedTurnSandbox, TurnSandboxLeaseHolderId } from "../../sandbox-resume";
 import type { TurnEventPublisher } from "./model-usage";
 import type { TurnSandboxProvisioner } from "./sandbox-provision";
+import { InitialModelWireDispatchClock } from "./model-wire-dispatch";
 
 /** Stamps the claimed turn/attempt ids onto a phase's own outcome. */
 export type ClaimedResult = (
@@ -47,6 +49,7 @@ export type TurnSettleFn = (input: {
   sessionStatus: SessionStatus;
   activeTurnId: string | null;
   suppressGoalContinuation?: boolean;
+  allowanceGoalPause?: ApplySessionTurnSettlementInput["allowanceGoalPause"];
   consumeRequestedCompactionFailure?: boolean;
   runState?: ApplySessionTurnSettlementInput["runState"];
 }) => Promise<boolean>;
@@ -65,6 +68,7 @@ export type AttemptIdentityState = {
   triggerEventId: string | undefined;
   executionGeneration: number;
   providerRecoveryCount: number;
+  claudeAuthRecovery?: { credentialId: string; credentialVersion: number } | undefined;
   modelRequestStarted: boolean;
   redispatchesAtDispatch: number;
   // Held for same-turn recovery: an approval-decision rerun must re-enter
@@ -75,6 +79,7 @@ export type AttemptIdentityState = {
 export type BillingState = {
   isCodexTurn: boolean;
   isXaiTurn: boolean;
+  isClaudeTurn: boolean;
   isExternallyBilledTurn: boolean;
   chargesOpenGeniCredits: boolean;
   countsTowardTokenCap: boolean;
@@ -112,10 +117,14 @@ export type SandboxRuntimeState = {
 };
 
 export type RenewalState = {
+  /** Secret-only local state; closed on every attempt finalization path. */
+  runMcpCredentials?: { close(): void };
   gitCredentialRenewals: GitCredentialRenewalController[];
   gitCredentialRenewalClosed: boolean;
   runCredentialRenewal: RunCredentialRenewalController | null;
   runCredentialRenewalClosed: boolean;
+  /** Outcome of the most recent renewal attempt, for on-demand refresh reporting. */
+  runCredentialRenewalOutcome: "completed" | "auth_needed" | "error" | null;
   runCredentialSession: RunCredentialCommandSession | null;
   codemodeTokenRenewal: CodemodeTokenRenewalController | null;
   codemodeTokenRenewalClosed: boolean;
@@ -123,6 +132,7 @@ export type RenewalState = {
 };
 
 export type EventingState = {
+  heartbeatDetails: TurnHeartbeatDetails | null;
   heartbeatTimer: ReturnType<typeof startActivityHeartbeat> | undefined;
   batcher: ReturnType<typeof createRuntimeBatcher> | null;
   preparedTools: Awaited<ReturnType<OpenGeniRuntime["prepareTools"]>> | null;
@@ -138,7 +148,10 @@ export type EventingState = {
   firstModelRequestPreparationStartedAt: number | null;
   firstModelRequestPreparationRecorded: boolean;
   firstModelRequestCheckpointAt: number | null;
+  initialModelWireDispatch: InitialModelWireDispatchClock;
   companyBrainContextContributions: readonly ModelContextContributionSummary[] | null;
+  /** Skill ids in this turn's frozen, model-visible Skill index; telemetry only. */
+  modelVisibleSkillIds: ReadonlySet<string> | null;
 };
 
 /** Rig telemetry (M3): set once the session loads; empty string for a rig-less
@@ -157,8 +170,18 @@ export type ProviderTurnState = {
   effectiveCodexCredentialVersion: number | null;
   /** Frozen alternate-account ceiling observed by the fenced allocator. */
   codexCredentialFailoverLimit: number;
+  /**
+   * Accepted product model id (`codex/<slug>`) the Codex allocator filtered
+   * for. Failure settlement scopes plan entitlement and failover to it.
+   */
+  codexProductModelId?: string | null;
   /** Accepted Codex allocator policy captured with the first durable lease. */
   codexPolicySnapshot: CodexCredentialPolicySnapshotV1 | null;
+  effectiveClaudeCredentialId: string | null;
+  effectiveClaudeCredentialVersion: number | null;
+  claudeUpstreamModelId: string | null;
+  claudeRotationEnabled: boolean;
+  claudeAuthoritySnapshot: XaiProviderAccountAuthoritySnapshotV1 | null;
   effectiveXaiCredentialId: string | null;
   xaiRotationEnabled: boolean;
   xaiAuthoritySnapshot: XaiProviderAccountAuthoritySnapshotV1 | null;
@@ -177,6 +200,7 @@ export type ProviderTurnState = {
   // scraped. Lives on the turn context so the finalizer sees it; the sink is
   // wired into codexContext.onUsageHeaders by the orchestrator.
   latestCodexUsage: CodexUsageHeaderSnapshot | null;
+  latestClaudeUsage: Map<string, import("./claude-usage-observer").CapturedClaudeUsage>;
   lastCodexRequestOpaqueArtifacts: readonly string[];
 };
 
@@ -216,6 +240,7 @@ export function createTurnContext(input: {
     billingState: {
       isCodexTurn: false,
       isXaiTurn: false,
+      isClaudeTurn: false,
       isExternallyBilledTurn: false,
       chargesOpenGeniCredits: true,
       countsTowardTokenCap: true,
@@ -247,6 +272,7 @@ export function createTurnContext(input: {
       gitCredentialRenewals: [],
       gitCredentialRenewalClosed: false,
       runCredentialRenewal: null,
+      runCredentialRenewalOutcome: null,
       runCredentialRenewalClosed: false,
       runCredentialSession: null,
       codemodeTokenRenewal: null,
@@ -254,6 +280,7 @@ export function createTurnContext(input: {
       publishedRunCredentialNotices: new Set(),
     },
     eventing: {
+      heartbeatDetails: null,
       heartbeatTimer: undefined,
       batcher: null,
       preparedTools: null,
@@ -269,7 +296,9 @@ export function createTurnContext(input: {
       firstModelRequestPreparationStartedAt: null,
       firstModelRequestPreparationRecorded: false,
       firstModelRequestCheckpointAt: null,
+      initialModelWireDispatch: new InitialModelWireDispatchClock(),
       companyBrainContextContributions: null,
+      modelVisibleSkillIds: null,
     },
     workspaceRefs: {
       variableSetId: "",
@@ -281,6 +310,11 @@ export function createTurnContext(input: {
       effectiveCodexCredentialVersion: null,
       codexCredentialFailoverLimit: 1,
       codexPolicySnapshot: null,
+      effectiveClaudeCredentialId: null,
+      effectiveClaudeCredentialVersion: null,
+      claudeUpstreamModelId: null,
+      claudeRotationEnabled: false,
+      claudeAuthoritySnapshot: null,
       effectiveXaiCredentialId: null,
       xaiRotationEnabled: false,
       xaiAuthoritySnapshot: null,
@@ -288,6 +322,7 @@ export function createTurnContext(input: {
       xaiCredentialQuarantined: false,
       priorSessionCodexCredentialId: null,
       latestCodexUsage: null,
+      latestClaudeUsage: new Map(),
       lastCodexRequestOpaqueArtifacts: [],
     },
   };

package/src/activities/agent-turn/turn-sandbox-access.ts

@@ -13,6 +13,12 @@ export type ResolvedTurnSandboxAccess = Readonly<{
   leaseEpoch: number;
 }>;
 
+/** The lazy wrapper remains the agent's owner even after provisioning fills
+ * resolvedSandbox with the raw provider handle for capture and release. */
+export function ownedTurnSandboxForAgent(sandboxState: TurnSandboxAccessState) {
+  return sandboxState.lazyOwnedSandbox ?? sandboxState.resolvedSandbox?.established;
+}
+
 /** Join the turn's canonical sandbox boundary and return its active routed session. */
 export async function resolveTurnSandboxAccess(
   sandboxState: TurnSandboxAccessState,
@@ -24,7 +30,7 @@ export async function resolveTurnSandboxAccess(
     sandbox = await sandboxState.turnSandboxProvisioner.get();
   }
 
-  const session = (sandboxState.lazyOwnedSandbox?.session ??
+  const session = (ownedTurnSandboxForAgent(sandboxState)?.session ??
     sandbox?.established.session ??
     sdkOwnedSandboxSession) as ChannelASession | null;
   if (!session) throw new Error(unavailableMessage);

package/src/activities/agent-turn/xai-capacity.ts

@@ -7,14 +7,21 @@ import {
   recordXaiSessionLastAccount,
   XAI_CREDENTIAL_LEASE_TTL_MS,
   armXaiCapacityWait,
+  acquireClaudeCredentialLease,
+  getClaudeSessionAccountPin,
+  setClaudeSessionAccountPin,
+  recordClaudeSessionLastAccount,
+  CLAUDE_CREDENTIAL_LEASE_TTL_MS,
+  armClaudeCapacityWait,
 } from "@opengeni/db";
 import { publishDurableSessionEvents } from "@opengeni/events";
 
 import type { CapacityPhaseDeps, CapacityPhaseOutcome } from "./codex-capacity";
 import { refreshExhaustedXaiQuota } from "../xai-quota";
 
-export async function selectXaiTurnCapacity(
+async function selectScopedSubscriptionTurnCapacity(
   deps: CapacityPhaseDeps,
+  provider: "xai" | "claude",
 ): Promise<CapacityPhaseOutcome> {
   const {
     input,
@@ -30,32 +37,50 @@ export async function selectXaiTurnCapacity(
     turn,
   } = deps;
 
-  if (billingState.isXaiTurn) {
-    const authoritySnapshot = turn.xaiProviderAccountAuthoritySnapshot;
-    providerTurn.xaiAuthoritySnapshot = authoritySnapshot;
+  const claude = provider === "claude";
+  const name = claude ? "Claude" : "SuperGrok";
+  const acquireLease = claude ? acquireClaudeCredentialLease : acquireXaiCredentialLease;
+  const getPin = claude ? getClaudeSessionAccountPin : getXaiSessionAccountPin;
+  const setPin = claude ? setClaudeSessionAccountPin : setXaiSessionAccountPin;
+  const recordLastAccount = claude ? recordClaudeSessionLastAccount : recordXaiSessionLastAccount;
+  const armWait = claude ? armClaudeCapacityWait : armXaiCapacityWait;
+  const lease = claude ? leases.claude : leases.xai;
+  const credentialKey = claude ? "effectiveClaudeCredentialId" : "effectiveXaiCredentialId";
+  const rotationKey = claude ? "claudeRotationEnabled" : "xaiRotationEnabled";
+  const authorityKey = claude ? "claudeAuthoritySnapshot" : "xaiAuthoritySnapshot";
+  if (claude ? billingState.isClaudeTurn : billingState.isXaiTurn) {
+    const authoritySnapshot = claude
+      ? turn.claudeProviderAccountAuthoritySnapshot
+      : turn.xaiProviderAccountAuthoritySnapshot;
+    providerTurn[authorityKey] = authoritySnapshot;
+    if (claude) providerTurn.claudeUpstreamModelId = deps.turnExecutionPolicy.upstreamModelId;
     const subjectId =
-      authoritySnapshot.scope === "user" ? turn.initiatingHumanSubjectId : "worker:xai-workspace";
+      authoritySnapshot.scope === "user"
+        ? turn.initiatingHumanSubjectId
+        : "worker:" + provider + "-workspace";
     if (!subjectId) {
-      throw new Error("User-scoped SuperGrok work has no frozen initiating human");
+      throw new Error("User-scoped " + name + " work has no frozen initiating human");
     }
-    const sessionPin = await getXaiSessionAccountPin(db, {
+    const sessionPin = await getPin(db, {
       workspaceId: input.workspaceId,
       subjectId,
       sessionId: input.sessionId,
       authoritySnapshot,
     });
+    if (!claude)
+      await refreshExhaustedXaiQuota({
+        db,
+        settings: deps.settings,
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        subjectId,
+        sessionId: input.sessionId,
+        turnId: turn.id,
+        authoritySnapshot,
+      });
     const leaseStartedAtMs = performance.now();
-    await refreshExhaustedXaiQuota({
-      db,
-      settings: deps.settings,
-      accountId: input.accountId,
-      workspaceId: input.workspaceId,
-      subjectId,
-      sessionId: input.sessionId,
-      turnId: turn.id,
-      authoritySnapshot,
-    });
-    const leased = await acquireXaiCredentialLease(db, {
+    const leased = await acquireLease(db, {
+      upstreamModelId: deps.turnExecutionPolicy.upstreamModelId,
       modelId: deps.turnExecutionPolicy.productModelId,
       accountId: input.accountId,
       workspaceId: input.workspaceId,
@@ -70,20 +95,20 @@ export async function selectXaiTurnCapacity(
           ? sessionPin.pinSource
           : null,
     });
-    providerTurn.effectiveXaiCredentialId = leased.credentialId;
-    providerTurn.xaiRotationEnabled = leased.rotationEnabled;
-    leases.xai.subjectId = subjectId;
-    leases.xai.holderId = leased.holderId;
-    leases.xai.generation = leased.generation;
-    leases.xai.confirmedUntilMs = leased.leasedUntil
-      ? leaseStartedAtMs + XAI_CREDENTIAL_LEASE_TTL_MS
+    providerTurn[credentialKey] = leased.credentialId;
+    providerTurn[rotationKey] = leased.rotationEnabled;
+    lease.subjectId = subjectId;
+    lease.holderId = leased.holderId;
+    lease.generation = leased.generation;
+    lease.confirmedUntilMs = leased.leasedUntil
+      ? leaseStartedAtMs + (claude ? CLAUDE_CREDENTIAL_LEASE_TTL_MS : XAI_CREDENTIAL_LEASE_TTL_MS)
       : null;
-    leases.xai.held =
-      providerTurn.effectiveXaiCredentialId !== null &&
+    lease.held =
+      providerTurn[credentialKey] !== null &&
       leased.holderId !== null &&
       leased.generation !== null &&
-      leases.xai.confirmedUntilMs !== null;
-    if (!providerTurn.effectiveXaiCredentialId) {
+      lease.confirmedUntilMs !== null;
+    if (!providerTurn[credentialKey]) {
       const relevant =
         sessionPin?.pinnedCredentialId && sessionPin.pinSource !== "policy"
           ? leased.accounts.filter((account) => account.id === sessionPin.pinnedCredentialId)
@@ -98,13 +123,13 @@ export async function selectXaiTurnCapacity(
             ),
         )
       )
-        throw new Error("This model is disabled for the selected SuperGrok subscription");
+        throw new Error("This model is disabled for the selected " + name + " subscription");
       const connected = leased.accounts.length;
       const allocatorEnabled = leased.accounts.filter((account) => account.allocatorEnabled).length;
       if (connected === 0) {
         throw Object.assign(
-          new Error("No SuperGrok subscription account is connected for this authority scope"),
-          { code: "xai_not_connected" },
+          new Error("No " + name + " subscription account is connected for this authority scope"),
+          { code: provider + "_not_connected" },
         );
       }
       if (turn.source === "compaction") {
@@ -115,7 +140,7 @@ export async function selectXaiTurnCapacity(
                 type: "turn.cancelled",
                 payload: {
                   maintenance: "context_compaction",
-                  reason: "xai_capacity_unavailable",
+                  reason: provider + "_capacity_unavailable",
                   requestPreserved: true,
                 },
               },
@@ -141,14 +166,16 @@ export async function selectXaiTurnCapacity(
       const futureResets = leased.accounts
         .map((account) => account.exhaustedUntil)
         .filter((date): date is Date => date !== null && date > now);
-      const earliestResetAt = futureResets.length
-        ? new Date(Math.min(...futureResets.map((date) => date.getTime())))
-        : null;
+      const earliestResetAt = claude
+        ? (leased.nextCheckAt ?? null)
+        : futureResets.length
+          ? new Date(Math.min(...futureResets.map((date) => date.getTime())))
+          : null;
       const error =
         allocatorEnabled === 0
-          ? "All connected SuperGrok subscription accounts are disabled for allocation"
-          : "All connected SuperGrok subscription accounts are temporarily unavailable";
-      const armed = await armXaiCapacityWait(db, {
+          ? "All connected " + name + " subscription accounts are disabled for allocation"
+          : "All connected " + name + " subscription accounts are temporarily unavailable";
+      const armed = await armWait(db, {
         accountId: input.accountId,
         workspaceId: input.workspaceId,
         subjectId,
@@ -162,7 +189,10 @@ export async function selectXaiTurnCapacity(
         earliestResetAt,
         failurePayload: {
           error,
-          code: allocatorEnabled === 0 ? "xai_allocator_disabled" : "xai_capacity_unavailable",
+          code:
+            allocatorEnabled === 0
+              ? provider + "_allocator_disabled"
+              : provider + "_capacity_unavailable",
           detail: "waiting for an eligible account, reconnect, pin change, or quota reset",
         },
       });
@@ -174,7 +204,7 @@ export async function selectXaiTurnCapacity(
           exit: claimedResult({
             status: "waiting_capacity",
             capacityWait: {
-              provider: "xai",
+              provider,
               waiterId: armed.waiter.id,
               generation: armed.waiter.generation,
               nextCheckAt: armed.waiter.nextCheckAt.toISOString(),
@@ -190,7 +220,7 @@ export async function selectXaiTurnCapacity(
               type: "turn.failed",
               payload: {
                 error,
-                code: "xai_capacity_wait_stale",
+                code: provider + "_capacity_wait_stale",
                 retryable: false,
                 recovery: "user_message",
               },
@@ -208,28 +238,32 @@ export async function selectXaiTurnCapacity(
       control.activityStatus = "idle";
       return { exit: claimedResult({ status: "idle" }) };
     }
-    if (leases.xai.held) leases.xai.startHeartbeat();
+    if (lease.held) lease.startHeartbeat();
     if (
       leased.rotationEnabled &&
       sessionPin?.pinSource !== "manual" &&
-      (sessionPin?.pinnedCredentialId !== providerTurn.effectiveXaiCredentialId ||
+      (sessionPin?.pinnedCredentialId !== providerTurn[credentialKey] ||
         sessionPin?.pinSource !== "policy")
     ) {
-      await setXaiSessionAccountPin(db, {
+      await setPin(db, {
         accountId: input.accountId,
         workspaceId: input.workspaceId,
         subjectId,
         sessionId: input.sessionId,
         authoritySnapshot,
-        credentialId: providerTurn.effectiveXaiCredentialId,
+        credentialId: providerTurn[credentialKey],
         pinSource: "policy",
         expectedVersion: sessionPin?.version ?? null,
       }).catch((error: unknown) => {
-        if (error instanceof Error && error.message === "xAI session pin changed") return;
+        if (
+          error instanceof Error &&
+          error.message === (claude ? "Claude" : "xAI") + " session pin changed"
+        )
+          return;
         throw error;
       });
     } else if (!leased.rotationEnabled && sessionPin?.pinSource === "policy") {
-      await setXaiSessionAccountPin(db, {
+      await setPin(db, {
         accountId: input.accountId,
         workspaceId: input.workspaceId,
         subjectId,
@@ -239,19 +273,28 @@ export async function selectXaiTurnCapacity(
         pinSource: null,
         expectedVersion: sessionPin.version,
       }).catch((error: unknown) => {
-        if (error instanceof Error && error.message === "xAI session pin changed") return;
+        if (
+          error instanceof Error &&
+          error.message === (claude ? "Claude" : "xAI") + " session pin changed"
+        )
+          return;
         throw error;
       });
     }
-    await recordXaiSessionLastAccount(db, {
+    await recordLastAccount(db, {
       accountId: input.accountId,
       workspaceId: input.workspaceId,
       subjectId,
       sessionId: input.sessionId,
       authoritySnapshot,
-      credentialId: providerTurn.effectiveXaiCredentialId,
+      credentialId: providerTurn[credentialKey],
     });
   }
 
   return { ok: true };
 }
+
+export const selectXaiTurnCapacity = (deps: CapacityPhaseDeps) =>
+  selectScopedSubscriptionTurnCapacity(deps, "xai");
+export const selectClaudeTurnCapacity = (deps: CapacityPhaseDeps) =>
+  selectScopedSubscriptionTurnCapacity(deps, "claude");