@opengeni/core 2.7.2-canary.0 → 2.7.5-canary.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/core",
-  "version": "2.7.2-canary.0",
+  "version": "2.7.5-canary.0",
   "description": "OpenGeni framework-agnostic core: the domain, access, and billing layers (neutral access, off-HTTP V2 surface). Behavior-preserving extraction from apps/api — keeps Hono's HTTPException for error throwing (typed-errors cleanup deferred).",
   "license": "Apache-2.0",
   "repository": {
@@ -54,15 +54,17 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@opengeni/codex": "^0.2.20-canary.2",
-    "@opengeni/config": "^0.23.2-canary.0",
-    "@opengeni/contracts": "^2.11.1-canary.0",
-    "@opengeni/db": "^3.8.2-canary.0",
-    "@opengeni/documents": "^0.8.17-canary.0",
-    "@opengeni/events": "^0.4.15-canary.0",
-    "@opengeni/observability": "^0.8.17-canary.0",
-    "@opengeni/runtime": "^2.1.2-canary.0",
-    "@opengeni/storage": "^0.2.118-canary.0",
+    "@opengeni/capabilities": "^0.3.2-canary.0",
+    "@opengeni/codex": "^0.2.21-canary.0",
+    "@opengeni/config": "^1.0.0-canary.0",
+    "@opengeni/contracts": "^2.13.0-canary.0",
+    "@opengeni/db": "^4.0.0-canary.0",
+    "@opengeni/documents": "^0.8.19-canary.0",
+    "@opengeni/events": "^0.4.17-canary.0",
+    "@opengeni/network": "^0.3.0-canary.0",
+    "@opengeni/observability": "^0.8.19-canary.0",
+    "@opengeni/runtime": "^2.3.0-canary.0",
+    "@opengeni/storage": "^0.2.120-canary.0",
     "hono": "^4.12.18",
     "zod": "^4.2.1"
   },

package/src/access/index.ts

@@ -243,6 +243,31 @@ export function requireAccountAdminAuthorizationStamp(
   });
 }
 
+/**
+ * Verify that an access authorization was minted by the canonical request
+ * resolver for this exact subject and workspace.
+ *
+ * This is the protocol-neutral boundary for request-local services that need
+ * the authenticated grant rather than a caller-supplied grant-shaped object.
+ * Object identity is intentional: matching fields alone are not proof that the
+ * request authenticated the named subject.
+ */
+export function requireResolvedAccessGrantAuthorization(
+  authorization: AccessGrantAuthorization,
+  workspaceId: string,
+): AccessGrant {
+  const { grant } = authorization;
+  if (
+    !resolvedAccessGrantAuthorizations.has(authorization) ||
+    !authorization.contextIntegrity ||
+    authorization.authenticatedSubjectId !== grant.subjectId ||
+    grant.workspaceId !== workspaceId
+  ) {
+    throw new HTTPException(403, { message: "workspace access authorization is invalid" });
+  }
+  return grant;
+}
+
 /**
  * Resolve the exact built-in single-user local administrator for an account.
  *

package/src/application/api-integration-servers.ts

@@ -0,0 +1,215 @@
+import {
+  createGraphqlMcpServer,
+  createOpenApiMcpServer,
+  createPinnedIntegrationTransport,
+  directIntegrationTransport,
+  IntegrationInvocationError,
+  type IntegrationCredentialResolver,
+  type IntegrationInvocationAuthority,
+  type IntegrationTransport,
+} from "@opengeni/capabilities";
+import type { Settings } from "@opengeni/config";
+import type { ToolAuthNeededPayload } from "@opengeni/contracts";
+import type {
+  ApiIntegrationRuntime,
+  ResolveConnectionCredentialInput,
+  ResolveConnectionCredentialResult,
+} from "@opengeni/db";
+import type { FetchLike } from "@opengeni/network";
+import type { LocalMcpServerRegistration } from "@opengeni/runtime";
+
+export type BuildApiIntegrationServersInput = {
+  settings: Settings;
+  integrations: readonly ApiIntegrationRuntime[];
+  authority: Omit<IntegrationInvocationAuthority, "connectionRef">;
+  resolveCredential: (
+    input: ResolveConnectionCredentialInput,
+  ) => Promise<ResolveConnectionCredentialResult>;
+  onAuthNeeded?: (payload: ToolAuthNeededPayload) => Promise<void> | void;
+  fetchImpl?: FetchLike;
+};
+
+/**
+ * Compile active persisted API facets into ordinary in-process MCP providers.
+ * The caller supplies its authority resolver, so agent attempts and current
+ * humans use the same provider assembly without sharing credentials or policy.
+ */
+export function buildApiIntegrationMcpServers(
+  input: BuildApiIntegrationServersInput,
+): LocalMcpServerRegistration[] {
+  const transport = createPinnedIntegrationTransport({
+    network: input.settings,
+    ...(input.fetchImpl ? { fetchImpl: input.fetchImpl } : {}),
+  });
+  return input.integrations.map((integration) => {
+    const authority: IntegrationInvocationAuthority = {
+      ...input.authority,
+      ...(integration.connectionRef?.connectionId
+        ? { connectionRef: integration.connectionRef.connectionId }
+        : {}),
+    };
+    const credentialResolver = integration.connectionRef
+      ? integrationCredentialResolver(input, integration, "execution")
+      : undefined;
+    const buildServer = (
+      serverTransport: IntegrationTransport,
+      serverCredentialResolver = credentialResolver,
+    ) =>
+      integration.revision.protocol === "openapi"
+        ? createOpenApiMcpServer({
+            revision: integration.revision,
+            transport: serverTransport,
+            authority,
+            ...(serverCredentialResolver ? { credentialResolver: serverCredentialResolver } : {}),
+          })
+        : createGraphqlMcpServer({
+            revision: integration.revision,
+            endpoint: integration.baseUrl,
+            transport: serverTransport,
+            authority,
+            ...(serverCredentialResolver ? { credentialResolver: serverCredentialResolver } : {}),
+          });
+    const server = buildServer(transport);
+    const preflightCredentialResolver = integration.connectionRef
+      ? integrationCredentialResolver(input, integration, "preflight")
+      : undefined;
+    const preflightServer = preflightCredentialResolver
+      ? buildServer(providerBlockingPreflightTransport, preflightCredentialResolver)
+      : null;
+    return {
+      id: integration.serverId,
+      server,
+      approvalAuthority: {
+        kind: "api_integration",
+        capabilityId: integration.capabilityId,
+        pluginKey: integration.pluginKey,
+        pluginInstallationId: integration.pluginInstallationId,
+        installationVersion: integration.installationVersion,
+        instanceId: integration.instanceId,
+        instanceKey: integration.instanceKey,
+        instanceVersion: integration.instanceVersion,
+        definitionId: integration.definitionId,
+        definitionProvenance: integration.definitionProvenance,
+        revisionId: integration.revision.id,
+        baseUrl: integration.baseUrl,
+        providerDomain: integration.providerDomain,
+        connectionRef: integration.connectionRef,
+        connectionAuthorityGeneration: integration.connectionAuthorityGeneration,
+      },
+      ...(integration.connectionRef?.connectionId
+        ? { resolvedConnectionId: integration.connectionRef.connectionId }
+        : {}),
+      ...(credentialResolver
+        ? {
+            preflightCall: async (
+              toolName: string,
+              args: Record<string, unknown>,
+              options?: { signal?: AbortSignal },
+            ) => await preflightApiIntegrationCall(preflightServer!, toolName, args, options),
+          }
+        : {}),
+    };
+  });
+}
+
+const providerBlockingPreflightTransport = directIntegrationTransport(async () => {
+  throw new Error("integration provider request blocked by preflight");
+});
+
+async function preflightApiIntegrationCall(
+  server: LocalMcpServerRegistration["server"],
+  toolName: string,
+  args: Record<string, unknown>,
+  options?: { signal?: AbortSignal },
+): Promise<void> {
+  try {
+    await server.callTool(toolName, args, null, options);
+  } catch (error) {
+    if (error instanceof IntegrationInvocationError && error.code === "request_failed") return;
+    throw error;
+  }
+  throw new Error("integration preflight unexpectedly crossed the provider request boundary");
+}
+
+function integrationCredentialResolver(
+  input: BuildApiIntegrationServersInput,
+  integration: ApiIntegrationRuntime,
+  credentialResolutionMode: "execution" | "preflight",
+): IntegrationCredentialResolver {
+  const connectionRef = integration.connectionRef;
+  if (!connectionRef) throw new Error("Integration credential resolver requires a connection");
+  const expectedAuthorityGeneration = integration.connectionAuthorityGeneration;
+  if (expectedAuthorityGeneration === null) {
+    throw new Error("Integration credential resolver requires a connection authority generation");
+  }
+  return {
+    resolve: async (request) => {
+      const result = await input.resolveCredential({
+        workspaceId: input.authority.workspaceId,
+        serverId: integration.serverId,
+        toolName: request.operationKey,
+        connectionRef,
+        destinationUrl: request.destinationUrl,
+        credentialTarget: "http_api",
+        forceRefresh: request.forceRefresh === true,
+        credentialResolutionMode,
+        expectedAuthorityGeneration,
+      });
+      if (result.status === "auth_needed") {
+        await publishAuthNeeded(
+          input,
+          integration.serverId,
+          request.operationKey,
+          result,
+          connectionRef,
+        );
+        return null;
+      }
+      const destination = new URL(request.destinationUrl);
+      return {
+        audience: { origin: destination.origin, pathPrefix: "/" },
+        placements:
+          result.placements ??
+          Object.entries(result.headers).map(([name, value]) => ({
+            carrier: "header" as const,
+            name,
+            value,
+          })),
+        ...(result.authorizeProviderRequest
+          ? { authorizeProviderRequest: result.authorizeProviderRequest }
+          : {}),
+        ...(result.expiresAt ? { expiresAt: result.expiresAt.toISOString() } : {}),
+        ...(connectionRef.scopes ? { scope: [...connectionRef.scopes] } : {}),
+      };
+    },
+  };
+}
+
+async function publishAuthNeeded(
+  input: BuildApiIntegrationServersInput,
+  serverId: string,
+  toolName: string,
+  result: Extract<ResolveConnectionCredentialResult, { status: "auth_needed" }>,
+  connectionRef: NonNullable<ApiIntegrationRuntime["connectionRef"]>,
+): Promise<void> {
+  try {
+    await input.onAuthNeeded?.({
+      serverId,
+      toolName,
+      providerDomain: result.providerDomain,
+      ...(result.provider ? { provider: result.provider } : {}),
+      reason: result.reason,
+      ...(result.connectionId ? { connectionId: result.connectionId } : {}),
+      ...(result.authoritySource === "host" || connectionRef.authoritySource === "host"
+        ? { authoritySource: "host" as const }
+        : {}),
+      ...(result.scopes ? { scopes: result.scopes } : {}),
+      ...(result.resource ? { resource: result.resource } : {}),
+      ...(result.selectedResources ? { selectedResources: result.selectedResources } : {}),
+      ...(result.authorizationUrl ? { authorizationUrl: result.authorizationUrl } : {}),
+    });
+  } catch {
+    // Authentication notices are advisory UI/audit signals. The local tool
+    // still returns the fixed connection-required result when publication fails.
+  }
+}

package/src/application/session-commands.ts

@@ -555,7 +555,7 @@ export async function controlAgentSessionWorkstream(
           wakeRevision: result.workflowWake.wakeRevision,
           shouldSignal: true,
           interruptionCount: result.interruptionCount,
-          controlRequested: true,
+          controlRequested: input.action === "pause",
         });
       },
     },
@@ -928,7 +928,7 @@ export async function controlHumanSessionWorkstreamWithOutcome(
           wakeRevision: result.workflowWake.wakeRevision,
           shouldSignal: true,
           interruptionCount: result.interruptionCount,
-          controlRequested: true,
+          controlRequested: input.action === "pause",
         });
       },
     },

package/src/index.ts

@@ -106,6 +106,7 @@ export * from "./application/composer-submit";
 export * from "./application/session-commands";
 export * from "./application/session-tenancy";
 export * from "./application/user-resource-grants";
+export * from "./application/api-integration-servers";
 
 // Durable editable-artifact live broker, ticket, ports, and projection types.
 export * from "./editable-artifact-live";

package/src/sandbox/routing.ts

@@ -29,7 +29,6 @@ import {
   type SandboxRetainedProcess,
   type SandboxWorkspaceMutationAdmission,
 } from "@opengeni/db";
-import { settleSessionBackgroundCommandForRetainedProcess } from "@opengeni/db/session-background-commands";
 import { appendAndPublishEvents, type EventBus } from "@opengeni/events";
 import {
   isProviderSandboxGoneDuringRoutedOperation,
@@ -449,14 +448,11 @@ export function wrapChannelABoxWithRouting(
           reason: proof.reason,
           idleGraceMs: settings.sandboxIdleGraceMs,
         });
-        const backgroundSettlement = retainedProcessBackgroundSettlement(settlement.process, proof);
-        await settleSessionBackgroundCommandForRetainedProcess(db, {
-          accountId: ids.accountId,
-          workspaceId: ids.workspaceId,
-          sessionId: ids.sessionId,
-          retainedProcessId: process.id,
-          ...backgroundSettlement,
-        });
+        if (settlement.backgroundCommandEvents.length > 0 && bus) {
+          await bus
+            .publish(ids.workspaceId, ids.sessionId, settlement.backgroundCommandEvents)
+            .catch(() => undefined);
+        }
       }
     : undefined;
   const resolver = makeActiveBackendResolver({
@@ -520,6 +516,7 @@ export function wrapChannelABoxWithRouting(
   });
 
   const proxy = new RoutingSandboxSession({
+    bindActiveRouteOnFirstResolve: true,
     defaultResolved: {
       session: established.session as RoutableBackendSession,
       sandboxId: null,