@opengeni/api-router 2.5.0 → 2.6.4

package/dist/interaction-metrics.d.ts

@@ -1,9 +1,11 @@
 import type { AuthRunMutationResponse, BrowserActionReceipt, BrowserActionRequest, PublishBrowserRevisionResponse, BrowserSessionMutationResponse, ComputerActionReceipt, ComputerActionRequest, ComputerSessionMutationResponse, InteractionInterventionMutationResponse, ProtectedAuthFillResponse } from "@opengeni/contracts";
 import { type Observability } from "@opengeni/observability";
+import type { ComputerFrameEvidenceMismatchReason } from "@opengeni/runtime/sandbox";
 type InteractionLifecycleMutation = BrowserSessionMutationResponse | ComputerSessionMutationResponse;
 type AuthMutation = AuthRunMutationResponse | ProtectedAuthFillResponse;
 export declare function observeBrowserActionResult(observability: Observability | null | undefined, startedAtMs: number, request: BrowserActionRequest, receipt: BrowserActionReceipt): void;
 export declare function observeComputerActionResult(observability: Observability | null | undefined, startedAtMs: number, request: ComputerActionRequest, receipt: ComputerActionReceipt): void;
+export declare function observeComputerFrameEvidenceMismatch(observability: Observability | null | undefined, reason: ComputerFrameEvidenceMismatchReason): void;
 export declare function observeLifecycleResult(observability: Observability | null | undefined, startedAtMs: number, response: InteractionLifecycleMutation): void;
 export declare function observeBrowserRevisionPublication(observability: Observability | null | undefined, startedAtMs: number, response: PublishBrowserRevisionResponse): void;
 export declare function observeAuthMutation(observability: Observability | null | undefined, startedAtMs: number, response: AuthMutation): void;

package/dist/mcp/company-brain-governed-writes.d.ts

@@ -1,6 +1,6 @@
 import { type CompanyBrainGovernedWriteAttempt } from "@opengeni/contracts";
 import { createCompanyBrainLearningPolicyRouter } from "@opengeni/core";
-import type { Database } from "@opengeni/db";
+import { type Database } from "@opengeni/db";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 type JsonResult = (value: unknown) => {
     content: {

package/dist/mcp/company-profile-agent-admin.d.ts

@@ -33,12 +33,12 @@ export declare function deriveCompanyProfileStableKey(content: string): string;
  */
 export declare function resolveCompanyProfileEntries(input: readonly EntryInput[]): CompanyProfileEntry[];
 /**
- * Register the explicit owner-confirmed organization profile path. This is
- * administration, not derived learning: workspace learning mode is never
- * consulted, the initiating human must be the organization's active owner (the
- * same authority as the manual `account:admin` route), and the proposal cannot
- * become active without the exact bound human-input response returned by the
- * first call.
+ * Register the organization profile administration path. This is not derived
+ * workspace learning: the initiating human must be the organization's active
+ * owner (the same authority as the manual `account:admin` route). The separate
+ * organization policy either blocks the proposal, keeps the exact bound
+ * human-confirmation path, or permits immediate activation through the native
+ * company-profile lifecycle.
  */
 export declare function registerCompanyProfileAgentAdminTools(input: RegisterCompanyProfileAgentAdminToolsInput): void;
 export {};

package/dist/mcp/remember.d.ts

@@ -1,6 +1,6 @@
 import { type CompanyBrainGovernedWriteAttempt } from "@opengeni/contracts";
 import { createRememberRouter } from "@opengeni/core";
-import type { Database } from "@opengeni/db";
+import { type Database } from "@opengeni/db";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 type JsonResult = (value: unknown) => {
     content: {
@@ -19,7 +19,7 @@ export type RegisterRememberToolsInput = {
 /**
  * Explicit user-directed remember. Content becomes exact task-note evidence,
  * promotion runs through the frozen workspace learning policy, and activation
- * is either automatic (preference under Automatic mode) or requires exactly one
+ * is either automatic (Skill or instruction under Automatic mode) or requires exactly one
  * bound human confirmation through the built-in `request_human_input` tool.
  * Tool input cannot select scope beyond the workspace, active authority, or
  * another learning-policy source.

package/dist/mcp/server.d.ts

@@ -90,6 +90,7 @@ export declare function capSessionDiscoveryPage(page: Awaited<ReturnType<typeof
             pausedDescendants: number;
             failedDescendants: number;
             unreadDescendants?: number | undefined;
+            unreadFailedDescendants?: number | undefined;
             activelyWorkingDescendants?: number | undefined;
             attentionSince?: string | null | undefined;
             truncated: boolean;

package/dist/mcp/session-view.d.ts

@@ -121,6 +121,7 @@ export declare function boundSessionDetailMcp(session: Session, effectiveControl
         pausedDescendants: number;
         failedDescendants: number;
         unreadDescendants?: number | undefined;
+        unreadFailedDescendants?: number | undefined;
         activelyWorkingDescendants?: number | undefined;
         attentionSince?: string | null | undefined;
         truncated: boolean;

package/dist/mcp/session-wait.d.ts

@@ -40,6 +40,21 @@ export declare const SESSION_WAIT_EVENTS_PER_TARGET = 20;
  * noise never wake a waiter; `session_events` remains the drill-down for them.
  */
 export declare const SESSION_WAIT_EVENT_TYPES: readonly ["turn.started", "turn.completed", "turn.failed", "turn.cancelled", "turn.superseded", "turn.capacity_waiting", "agent.message.completed", "session.status.changed", "session.requiresAction", "session.humanInput.requested", "session.control.paused", "session.control.resumed", "tool.auth_needed", "credential.auth_needed", "rig.setup.failed", "goal.set", "goal.updated", "goal.progress", "goal.rewrite.proposed", "goal.rewrite.rejected", "goal.completed", "goal.paused", "goal.resumed", "goal.cleared", "goal.continuation"];
+/**
+ * Settlement and blocking events that make a child result usable.
+ * Goal facts are deliberately absent: an agent can complete its durable goal
+ * before it emits the final assistant message and settles the turn. Completed
+ * agent messages are also absent because commentary messages use the same
+ * event type; an ordinary result-bearing `turn.completed` carries the
+ * authoritative final output.
+ */
+export declare const SESSION_WAIT_COMPLETION_EVENT_TYPES: readonly ["turn.completed", "turn.failed", "turn.cancelled", "turn.superseded", "turn.capacity_waiting", "session.requiresAction", "session.humanInput.requested", "session.control.paused", "tool.auth_needed", "credential.auth_needed", "rig.setup.failed", "goal.paused"];
+/**
+ * A completed turn is result-bearing only when it carries the ordinary final
+ * output. Segment-limit and maintenance turns settle one execution segment
+ * while the session still has work to do, so they must not release a parent.
+ */
+export declare function sessionWaitCompletionEventMatches(event: SessionEvent): boolean;
 /** The self-session event that announces a newly pending machine input. */
 export declare const SESSION_WAIT_OWN_PENDING_EVENT_TYPE = "system.update.pending";
 /**
@@ -120,6 +135,10 @@ export type SessionWaitInput = {
     targets: readonly SessionWaitTarget[];
     ownSessionId: string | null;
     maxWaitMs: number;
+    /** Target events that end the wait. Defaults to the ordinary activity set. */
+    targetEventTypes?: readonly SessionEventType[] | undefined;
+    /** Optional payload-aware refinement applied after the event-type filter. */
+    targetEventMatches?: ((event: SessionEvent) => boolean) | undefined;
     source: SessionWaitSource;
     signal?: AbortSignal | undefined;
     now?: (() => number) | undefined;

package/dist/routes/api-keys.d.ts

@@ -1,3 +1,5 @@
+import { Permission } from "@opengeni/contracts";
 import type { Hono } from "hono";
 import type { ApiRouteDeps } from "@opengeni/core";
+export declare const organizationApiKeyPermissions: Permission[];
 export declare function registerApiKeyRoutes(app: Hono, deps: ApiRouteDeps): void;

package/dist/routes/browser-sessions.d.ts

@@ -5,6 +5,7 @@ export declare function registerBrowserSessionRoutes(app: Hono, deps: ApiRouteDe
 export declare function browserNeedsStandaloneDisplayStack(input: {
     headless: boolean;
     linkedComputer: boolean;
+    nativeBrowserControl: boolean;
 }): boolean;
 export declare function interactionActorForGrant(grant: AccessGrant): ReturnType<typeof InteractionActor.parse>;
 /** Resolve Drive authority from the same immutable session authorization that

package/dist/routes/computer-sessions.d.ts

@@ -1,6 +1,18 @@
 import { type ApiRouteDeps } from "@opengeni/core";
+import { type ComputerControlFrame, type ExpectedComputerFrameEvidence } from "@opengeni/runtime/sandbox";
 import type { Hono } from "hono";
+type ComputerFrameCaptureClient = {
+    capture(targetId: string, options: {
+        format?: "jpeg" | "png";
+        quality?: number;
+        maxWidth?: number;
+        maxHeight?: number;
+    }): Promise<ComputerControlFrame>;
+};
+export declare function validateComputerFrameForApi(frame: Pick<ComputerControlFrame, "data" | "mediaType" | "metadataHeader">, expected: ExpectedComputerFrameEvidence): ComputerControlFrame;
+export declare function captureModelComputerFrame(sessionClient: ComputerFrameCaptureClient, expected: ExpectedComputerFrameEvidence): Promise<ComputerControlFrame>;
 /** Public ComputerSession resource surface. Physical app/window authority stays
  * in the same placement controller used by BrowserSession; this route owns only
  * durable authorization, placement fencing, lifecycle receipts, and routing. */
 export declare function registerComputerSessionRoutes(app: Hono, deps: ApiRouteDeps): void;
+export {};

package/dist/routes/managed-auth-session-sets.d.ts

@@ -1,6 +1,12 @@
 import { type ApiRouteDeps } from "@opengeni/core";
 import type { Hono } from "hono";
 export declare function registerManagedAuthSessionSetRoutes(app: Hono, deps: ApiRouteDeps): void;
+export declare function validatedManagedAuthSocialAuthorizationUrl(input: {
+    provider: "google" | "github";
+    rawUrl: unknown;
+    expectedClientId: string;
+    expectedCallbackUrl: string;
+}): string;
 /**
  * Better Auth 1.6.26 provider lifecycle routes retained while session-set mode
  * owns all selected-session reads, enumeration, revocation, and user mutation.
@@ -11,6 +17,7 @@ export declare function requireManagedAuthProviderRouteAllowed(method: string, p
 /** Remove provider bearer/session material and enforce browser-auth cache/cookie policy. */
 export declare function scrubManagedAuthProviderResponse(response: Response, options?: {
     replacementCookies?: readonly string[] | undefined;
+    preserveCookieNames?: readonly string[] | undefined;
 }): Promise<Response>;
 export declare function parseSupportedDeepLink(path: string): {
     workspaceId: string | null;

package/dist/routes/workspaces.d.ts

@@ -16,7 +16,7 @@ export declare function workspaceMembersResponse(members: readonly WorkspaceMemb
         subjectId: string;
         subjectLabel: string | null;
         role: string;
-        permissions: ("account:admin" | "account:read" | "api_keys:manage" | "artifacts:publish" | "artifacts:read" | "billing:manage" | "billing:read" | "codemode:call" | "connections:read" | "connections:write" | "documents:manage" | "documents:search" | "enrollments:manage" | "enrollments:read" | "environments:manage" | "environments:use" | "files:read" | "files:upload" | "files:write" | "github:manage" | "github:use" | "goals:manage" | "mcp_servers:attach" | "members:manage" | "rigs:manage" | "rigs:use" | "scheduled_tasks:manage" | "scheduled_tasks:run" | "secrets:list" | "secrets:read" | "secrets:write" | "sessions:control" | "sessions:create" | "sessions:read" | "stream:acknowledge" | "stream:control" | "stream:view" | "terminal:attach" | "variable-sets:attach" | "variable-sets:list" | "variable-sets:manage" | "variable-sets:read" | "variable-sets:use" | "variable-sets:write" | "workspace:admin" | "workspace:create" | "workspace:read")[];
+        permissions: ("account:admin" | "account:read" | "api_keys:manage" | "artifacts:publish" | "artifacts:read" | "billing:manage" | "billing:read" | "capabilities:manage" | "codemode:call" | "connections:read" | "connections:write" | "documents:manage" | "documents:search" | "enrollments:manage" | "enrollments:read" | "environments:manage" | "environments:use" | "files:read" | "files:upload" | "files:write" | "github:manage" | "github:use" | "goals:manage" | "mcp_servers:attach" | "members:manage" | "rigs:manage" | "rigs:use" | "scheduled_tasks:manage" | "scheduled_tasks:run" | "secrets:list" | "secrets:read" | "secrets:write" | "sessions:control" | "sessions:create" | "sessions:read" | "stream:acknowledge" | "stream:control" | "stream:view" | "terminal:attach" | "variable-sets:attach" | "variable-sets:list" | "variable-sets:manage" | "variable-sets:read" | "variable-sets:use" | "variable-sets:write" | "workspace:admin" | "workspace:create" | "workspace:read")[];
         createdAt: string;
     }[];
 };

package/dist/sandbox/metrics-ingestion.d.ts

@@ -7,6 +7,22 @@ import { Hello, type AttachedBrowserInventorySnapshot as WireAttachedBrowserInve
 export declare const AGENT_EVENTS_SUBJECT = "agent.*.*.connection.*.events";
 /** The wildcard subject the agent publishes its connect Hello on. */
 export declare const AGENT_HELLO_SUBJECT = "agent.*.*.connection.*.hello";
+export type AgentEventIngestionScheduler = {
+    enqueue: (payload: Uint8Array, subject: string) => void;
+    whenIdle: () => Promise<void>;
+    close: () => void;
+};
+/**
+ * Drain agent events without making every Connected Machine wait behind one
+ * deployment-wide serial DB queue. Each exact process subject retains FIFO order;
+ * separate subjects drain concurrently. Consecutive pending heartbeats for one
+ * subject are latest-wins because they are point-in-time liveness/metrics samples,
+ * while GoingOffline and update-progress events remain ordered barriers.
+ */
+export declare function createAgentEventIngestionScheduler(handler: (payload: Uint8Array, subject: string) => void | Promise<void>, options?: {
+    maxConcurrentSubjects?: number;
+    onHeartbeatCoalesced?: () => void;
+}): AgentEventIngestionScheduler;
 /** Parse the exact process events subject (heartbeat plane). */
 export declare function parseAgentEventSubject(subject: string): {
     workspaceId: string;

package/dist/workspace-delete-observability.d.ts

@@ -0,0 +1,10 @@
+import type { WorkspaceDeleteObserver } from "@opengeni/db";
+import type { Observability } from "@opengeni/observability";
+/**
+ * Retain exact workspace deletion timing and inventory without putting tenant
+ * identifiers in metric labels. Observer failures never change deletion truth.
+ */
+export declare function workspaceDeleteObserver(observability: Observability | null | undefined, identity: {
+    accountId: string;
+    workspaceId: string;
+}): WorkspaceDeleteObserver | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/api-router",
-  "version": "2.5.0",
+  "version": "2.6.4",
   "description": "OpenGeni HTTP surface: the Hono adapter/router (createApp), routes, MCP HTTP transport, and HTTP access adapters over @opengeni/core. An engine-distribution surface — its runtime closure includes engine-internal packages.",
   "license": "Apache-2.0",
   "repository": {
@@ -41,24 +41,24 @@
     "@aws-sdk/client-s3": "^3.1044.0",
     "@aws-sdk/s3-request-presigner": "^3.1044.0",
     "@hono/zod-validator": "^0.7.6",
-    "@llamaindex/liteparse": "^1.5.3",
+    "@llamaindex/liteparse": "2.14.2",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@opengeni/agent-proto": "^0.5.1",
-    "@opengeni/artifact-tool": "^0.3.9",
+    "@opengeni/artifact-tool": "^0.3.14",
     "@opengeni/capabilities": "^0.3.1",
-    "@opengeni/codemode": "^0.4.17",
-    "@opengeni/codex": "^0.2.19",
-    "@opengeni/config": "^0.22.0",
-    "@opengeni/contracts": "^2.7.0",
-    "@opengeni/core": "^2.5.3",
-    "@opengeni/db": "^3.6.0",
-    "@opengeni/documents": "^0.8.6",
-    "@opengeni/events": "^0.4.4",
-    "@opengeni/github": "^0.6.1",
+    "@opengeni/codemode": "^0.4.22",
+    "@opengeni/codex": "^0.2.20",
+    "@opengeni/config": "^0.22.5",
+    "@opengeni/contracts": "^2.9.2",
+    "@opengeni/core": "^2.6.4",
+    "@opengeni/db": "^3.7.4",
+    "@opengeni/documents": "^0.8.14",
+    "@opengeni/events": "^0.4.12",
+    "@opengeni/github": "^0.6.7",
     "@opengeni/network": "^0.2.3",
-    "@opengeni/observability": "^0.8.9",
-    "@opengeni/runtime": "^1.4.2",
-    "@opengeni/storage": "^0.2.110",
+    "@opengeni/observability": "^0.8.14",
+    "@opengeni/runtime": "^2.0.1",
+    "@opengeni/storage": "^0.2.115",
     "@opengeni/xai-subscription": "^0.1.2",
     "@temporalio/client": "^1.17.0",
     "better-auth": "^1.6.14",

package/src/app.ts

@@ -44,6 +44,7 @@ import {
   withSessionRlsActorContext,
 } from "@opengeni/db";
 import { requireSessionEventDurableFanoutCapability } from "@opengeni/events";
+import { githubAppBotIdentityWarnings } from "@opengeni/github";
 import { createObservability } from "@opengeni/observability";
 import { createObjectStorage } from "@opengeni/storage";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
@@ -70,14 +71,28 @@ import {
   SessionAuthorizationDeniedError,
   SessionAuthorizationUnavailableError,
 } from "@opengeni/core";
-import { createManagedAuth } from "./auth/managed-auth";
 import {
+  createManagedAuth,
+  isolatedManagedAuthOAuthCallbackRequest,
+  managedAuthOAuthReturnMatches,
+  resolveManagedAuthOAuthAttempt,
+} from "./auth/managed-auth";
+import {
+  adoptManagedAuthSession,
   MANAGED_AUTH_SESSION_SET_COOKIE,
   ManagedAuthActorChangeError,
+  managedAuthCsrfHash,
+  managedAuthDerivedUuid,
+  managedAuthSecretRequestDigest,
   managedAuthSha256,
 } from "@opengeni/core/managed-auth-session-sets";
 import { createBetterAuthSessionAdapter } from "./auth/managed-auth-session-adapter";
-import { runManagedAuthDiscardedProviderSession } from "./auth/managed-auth-attempt-context";
+import {
+  currentManagedAuthCreatedSessionId,
+  runManagedAuthAttempt,
+  runManagedAuthDiscardedProviderSession,
+  runManagedAuthProvider,
+} from "./auth/managed-auth-attempt-context";
 import { createManagedEmailTransport } from "./auth/managed-email";
 import { assertManagedEmailTransportMetadata } from "./auth/organization-user-setup";
 import { createApiSandboxClient, makeResumeBoxById } from "./sandbox/access";
@@ -579,26 +594,111 @@ export function createAppComposition(deps: AppDependencies): {
   registerManagedAuthSessionSetRoutes(app, routeDeps);
   if (managedAuth) {
     app.on(["GET", "POST"], "/v1/auth/*", async (c) => {
+      const pathname = new URL(c.req.url).pathname;
+      const oauthCallbackProvider = managedAuthOAuthCallbackProvider(pathname);
       if (deps.settings.managedAuthSessionSetMode === "legacy") {
-        return await managedAuth.handler(c.req.raw);
+        return oauthCallbackProvider
+          ? await runManagedAuthProvider(
+              oauthCallbackProvider,
+              async () => await managedAuth.handler(c.req.raw),
+            )
+          : await managedAuth.handler(c.req.raw);
       }
-      requireManagedAuthProviderRouteAllowed(c.req.method, new URL(c.req.url).pathname);
+      requireManagedAuthProviderRouteAllowed(c.req.method, pathname);
       // Provider authentication/recovery is isolated from whichever actor the
       // browser currently renders. Selected-session capabilities are all
       // product-owned above this wildcard and generation/epoch fenced.
-      const headers = new Headers(c.req.raw.headers);
-      headers.delete("cookie");
-      headers.delete("authorization");
-      headers.delete("x-forwarded-user");
-      const providerRequest = new Request(c.req.raw, { headers });
       const authority = getCookie(c, MANAGED_AUTH_SESSION_SET_COOKIE);
-      const discardProviderSession =
-        deps.settings.managedAuthSessionSetMode === "broker" || authority !== undefined;
-      const providerResponse = discardProviderSession
-        ? await runManagedAuthDiscardedProviderSession(
-            async () => await managedAuth.handler(providerRequest),
+      let providerResponse: Response;
+      let preserveCookieNames: readonly string[] | undefined;
+      if (oauthCallbackProvider) {
+        const attempt = await resolveManagedAuthOAuthAttempt(
+          managedAuth,
+          c.req.raw,
+          oauthCallbackProvider,
+          deps.settings.publicBaseUrl!,
+        );
+        if (!attempt || !authority || attempt.authorityHash !== managedAuthSha256(authority)) {
+          throw new HTTPException(409, { message: "provider_route_blocked" });
+        }
+        const isolated = await isolatedManagedAuthOAuthCallbackRequest(managedAuth, c.req.raw);
+        preserveCookieNames = [isolated.stateCookieName];
+        const handled = await runManagedAuthAttempt(
+          attempt.transactionId,
+          oauthCallbackProvider,
+          async () => {
+            const response = await managedAuth.handler(isolated.request);
+            return {
+              response,
+              authSessionId: currentManagedAuthCreatedSessionId(),
+            };
+          },
+        );
+        providerResponse = handled.response;
+        if (
+          !handled.authSessionId &&
+          managedAuthOAuthReturnMatches(
+            providerResponse.headers.get("location") ?? "",
+            new URL(deps.settings.publicBaseUrl!).origin,
+            attempt.transactionId,
+            "complete",
           )
-        : await managedAuth.handler(providerRequest);
+        ) {
+          const location = new URL("/account-auth", deps.settings.publicBaseUrl!);
+          location.searchParams.set("transaction", attempt.transactionId);
+          location.searchParams.set("social", "error");
+          providerResponse = Response.redirect(location, 302);
+        } else if (handled.authSessionId) {
+          try {
+            await adoptManagedAuthSession({
+              db: deps.db,
+              adapter: managedAuthSessionAdapter!,
+              authority,
+              authorityHash: attempt.authorityHash,
+              csrfHash: managedAuthCsrfHash(authority),
+              operationId: managedAuthDerivedUuid(
+                "opengeni:managed-auth:social-completion",
+                `${attempt.transactionId}:${attempt.provider}`,
+              ),
+              requestDigest: managedAuthSecretRequestDigest(deps.settings.betterAuthSecret!, {
+                operation: "social_completion",
+                transactionId: attempt.transactionId,
+                provider: attempt.provider,
+                expectedGeneration: attempt.expectedGeneration,
+                expectedActorEpoch: attempt.expectedActorEpoch,
+              }),
+              expectedGeneration: attempt.expectedGeneration,
+              expectedActorEpoch: attempt.expectedActorEpoch,
+              transactionId: attempt.transactionId,
+              transactionSecretHash: attempt.transactionSecretHash,
+              authSessionId: handled.authSessionId,
+              mode: deps.settings.managedAuthSessionSetMode,
+            });
+          } catch {
+            // adoptManagedAuthSession revokes only when durable reconciliation
+            // proves that completion did not commit. An uncertain outcome may
+            // already point the selected slot at this session, so the callback
+            // must not independently revoke it.
+            const location = new URL("/account-auth", deps.settings.publicBaseUrl!);
+            location.searchParams.set("transaction", attempt.transactionId);
+            location.searchParams.set("social", "error");
+            providerResponse = Response.redirect(location, 302);
+          }
+        }
+      } else {
+        const headers = new Headers(c.req.raw.headers);
+        headers.delete("cookie");
+        headers.delete("authorization");
+        headers.delete("x-forwarded-user");
+        const providerRequest = new Request(c.req.raw, { headers });
+        const discardProviderSession =
+          deps.settings.managedAuthSessionSetMode === "broker" || authority !== undefined;
+        providerResponse = discardProviderSession
+          ? await runManagedAuthDiscardedProviderSession(
+              async () => await managedAuth.handler(providerRequest),
+            )
+          : await managedAuth.handler(providerRequest);
+      }
       let replacementCookies: readonly string[] | undefined;
       if (deps.settings.managedAuthSessionSetMode === "broker") {
         replacementCookies = await managedAuthSessionAdapter!.createLegacySelectedSessionCookies(
@@ -628,19 +728,24 @@ export function createAppComposition(deps: AppDependencies): {
           }
         }
       }
-      return await scrubManagedAuthProviderResponse(providerResponse, { replacementCookies });
+      return await scrubManagedAuthProviderResponse(providerResponse, {
+        replacementCookies,
+        preserveCookieNames,
+      });
     });
   }
 
-  app.get("/healthz", (c) =>
-    c.json({
+  app.get("/healthz", (c) => {
+    const warnings = githubAppBotIdentityWarnings(deps.settings);
+    return c.json({
       service: deps.settings.serviceName,
       environment: deps.settings.environment,
       deploymentRevision: deps.settings.deploymentRevision,
       ...(deps.settings.serverVersion ? { serverVersion: deps.settings.serverVersion } : {}),
+      ...(warnings.length > 0 ? { warnings } : {}),
       ok: true,
-    }),
-  );
+    });
+  });
 
   app.get("/readyz", async (c) => {
     const result = await runReadinessChecks(readinessChecks(deps), 2_000);
@@ -681,6 +786,7 @@ export function createAppComposition(deps: AppDependencies): {
         models: configuredModels(catalogSettings).map(projectClientModel),
         defaultReasoningEffort: deps.settings.openaiReasoningEffort,
         allowedReasoningEfforts: configuredAllowedReasoningEfforts(deps.settings),
+        defaultSandboxBackend: deps.settings.sandboxBackend,
         mcpServers: deps.settings.mcpServers.map((server) => ({
           id: server.id,
           name: server.name ?? server.id,
@@ -956,6 +1062,11 @@ export function createAppComposition(deps: AppDependencies): {
   return { app, routeDeps };
 }
 
+function managedAuthOAuthCallbackProvider(pathname: string): "google" | "github" | null {
+  const match = pathname.match(/^\/v1\/auth\/callback\/(google|github)$/u);
+  return match?.[1] === "google" || match?.[1] === "github" ? match[1] : null;
+}
+
 function mutationOutcomeUnknown(error: unknown, method: string): boolean {
   if (method === "GET" || method === "HEAD" || method === "OPTIONS") return false;
   const cause = error instanceof HTTPException ? error.cause : error;
@@ -1072,6 +1183,14 @@ function clientAuthConfig(settings: AppDependencies["settings"]) {
       mode: "managedSession" as const,
       session: "cookie" as const,
       emailVerificationRequired: settings.environment !== "local",
+      socialProviders: [
+        ...(settings.managedAuthGoogleClientId && settings.managedAuthGoogleClientSecret
+          ? (["google"] as const)
+          : []),
+        ...(settings.managedAuthGithubClientId && settings.managedAuthGithubClientSecret
+          ? (["github"] as const)
+          : []),
+      ],
     };
   }
   if (settings.productAccessMode === "configured") {
@@ -1354,6 +1473,22 @@ const routeLabelPatterns: Array<{
     pattern: /^\/v1\/workspaces\/[^/]+\/codex\/status$/,
     label: "/v1/workspaces/:workspaceId/codex/status",
   },
+  {
+    pattern: /^\/v1\/workspaces\/[^/]+\/codex\/source$/,
+    label: "/v1/workspaces/:workspaceId/codex/source",
+  },
+  {
+    pattern: /^\/v1\/organizations\/[^/]+\/codex\/(accounts|settings)$/,
+    label: (match) => `/v1/organizations/:organizationId/codex/${match[1]}`,
+  },
+  {
+    pattern: /^\/v1\/organizations\/[^/]+\/codex\/connect\/(start|poll)$/,
+    label: (match) => `/v1/organizations/:organizationId/codex/connect/${match[1]}`,
+  },
+  {
+    pattern: /^\/v1\/organizations\/[^/]+\/codex\/accounts\/[^/]+(?:\/activate)?$/,
+    label: "/v1/organizations/:organizationId/codex/accounts/:accountId",
+  },
   {
     pattern: /^\/v1\/workspaces\/[^/]+\/supergrok\/connect\/(start|poll)$/,
     label: (match) => `/v1/workspaces/:workspaceId/supergrok/connect/${match[1]}`,
@@ -1513,6 +1648,11 @@ const routeLabelPatterns: Array<{
     label:
       "/v1/workspaces/:workspaceId/computer-sessions/:computerSessionId/targets/:targetId/observation",
   },
+  {
+    pattern: /^\/v1\/workspaces\/[^/]+\/computer-sessions\/[^/]+\/targets\/[^/]+\/screenshot$/,
+    label:
+      "/v1/workspaces/:workspaceId/computer-sessions/:computerSessionId/targets/:targetId/screenshot",
+  },
   {
     pattern: /^\/v1\/workspaces\/[^/]+\/computer-sessions\/[^/]+\/operations\/[^/]+$/,
     label:
@@ -1689,6 +1829,18 @@ const routeLabelPatterns: Array<{
     pattern: /^\/v1\/workspaces\/[^/]+\/api-keys\/[^/]+$/,
     label: "/v1/workspaces/:workspaceId/api-keys/:id",
   },
+  {
+    pattern: /^\/v1\/organizations\/[^/]+\/api-keys$/,
+    label: "/v1/organizations/:organizationId/api-keys",
+  },
+  {
+    pattern: /^\/v1\/organizations\/[^/]+\/api-keys\/[^/]+$/,
+    label: "/v1/organizations/:organizationId/api-keys/:id",
+  },
+  {
+    pattern: /^\/v1\/workspaces\/external$/,
+    label: "/v1/workspaces/external",
+  },
   {
     pattern: /^\/v1\/workspaces\/[^/]+\/scheduled-tasks$/,
     label: "/v1/workspaces/:workspaceId/scheduled-tasks",

package/src/auth/managed-auth-attempt-context.ts

@@ -1,13 +1,33 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 
 type ManagedAuthAttemptContext =
-  | { kind: "isolated_transaction"; transactionId: string }
+  | {
+      kind: "isolated_transaction";
+      transactionId: string;
+      providerId: "credential" | "google" | "github";
+      createdAuthSessionId: string | null;
+    }
+  | { kind: "provider"; providerId: "credential" | "google" | "github" }
   | { kind: "discard_provider_session" };
 
 const managedAuthAttemptStorage = new AsyncLocalStorage<ManagedAuthAttemptContext>();
 
-export function runManagedAuthAttempt<T>(transactionId: string, action: () => T): T {
-  return managedAuthAttemptStorage.run({ kind: "isolated_transaction", transactionId }, action);
+export function runManagedAuthAttempt<T>(
+  transactionId: string,
+  providerId: "credential" | "google" | "github",
+  action: () => T,
+): T {
+  return managedAuthAttemptStorage.run(
+    { kind: "isolated_transaction", transactionId, providerId, createdAuthSessionId: null },
+    action,
+  );
+}
+
+export function runManagedAuthProvider<T>(
+  providerId: "credential" | "google" | "github",
+  action: () => T,
+): T {
+  return managedAuthAttemptStorage.run({ kind: "provider", providerId }, action);
 }
 
 export function runManagedAuthDiscardedProviderSession<T>(action: () => T): T {
@@ -19,6 +39,23 @@ export function currentManagedAuthAttemptId(): string | null {
   return context?.kind === "isolated_transaction" ? context.transactionId : null;
 }
 
+export function currentManagedAuthProviderId(): "credential" | "google" | "github" {
+  const context = managedAuthAttemptStorage.getStore();
+  return context?.kind === "isolated_transaction" || context?.kind === "provider"
+    ? context.providerId
+    : "credential";
+}
+
+export function recordCurrentManagedAuthSession(authSessionId: string): void {
+  const context = managedAuthAttemptStorage.getStore();
+  if (context?.kind === "isolated_transaction") context.createdAuthSessionId = authSessionId;
+}
+
+export function currentManagedAuthCreatedSessionId(): string | null {
+  const context = managedAuthAttemptStorage.getStore();
+  return context?.kind === "isolated_transaction" ? context.createdAuthSessionId : null;
+}
+
 export function shouldDiscardCurrentManagedAuthProviderSession(): boolean {
   return managedAuthAttemptStorage.getStore()?.kind === "discard_provider_session";
 }

package/src/auth/managed-auth-session-adapter.ts

@@ -19,6 +19,7 @@ export function createBetterAuthSessionAdapter(
       }
       const result = await runManagedAuthAttempt(
         input.transactionId,
+        "credential",
         async () =>
           await auth.api.signInEmail({
             body: {