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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/core",
-  "version": "2.7.2-canary.0",
+  "version": "2.7.5-canary.1",
   "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.1",
+    "@opengeni/codex": "^0.2.21-canary.1",
+    "@opengeni/config": "^1.0.0-canary.1",
+    "@opengeni/contracts": "^2.13.0-canary.1",
+    "@opengeni/db": "^4.0.0-canary.1",
+    "@opengeni/documents": "^0.8.19-canary.1",
+    "@opengeni/events": "^0.4.17-canary.1",
+    "@opengeni/network": "^0.3.0-canary.1",
+    "@opengeni/observability": "^0.8.19-canary.1",
+    "@opengeni/runtime": "^2.3.0-canary.1",
+    "@opengeni/storage": "^0.2.120-canary.1",
     "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/new-session-drafts.ts

@@ -11,6 +11,7 @@ import {
   getSandbox,
   getVariableSet,
   NewSessionDraftAccessError,
+  newSessionDraftSelectedProjectChannelId,
   newSessionDraftToolsProvided,
   newSessionSelectionHistory,
   publicNewSessionDraftOptions,
@@ -41,6 +42,7 @@ function mapNewSessionDraft(
   row: Awaited<ReturnType<typeof getNewSessionDraftInTransaction>>,
 ): NewSessionDraftValue | null {
   if (!row) return null;
+  const selectedProjectChannelId = newSessionDraftSelectedProjectChannelId(row);
   return NewSessionDraft.parse({
     revision: row.revision,
     text: row.text,
@@ -50,6 +52,7 @@ function mapNewSessionDraft(
     model: row.model,
     reasoningEffort: row.reasoningEffort,
     latencyMode: row.latencyMode,
+    ...(selectedProjectChannelId !== undefined ? { selectedProjectChannelId } : {}),
     options: publicNewSessionDraftOptions(row),
     selectionHistory: newSessionSelectionHistory(row),
     updatedAt: row.updatedAt.toISOString(),
@@ -264,6 +267,9 @@ export async function saveActorNewSessionDraft(
           model: input.model,
           reasoningEffort: input.reasoningEffort,
           latencyMode: input.latencyMode,
+          ...(input.selectedProjectChannelId !== undefined
+            ? { selectedProjectChannelId: input.selectedProjectChannelId }
+            : {}),
           options: input.options,
           // Only managed people are removed through removeWorkspaceMember().
           // API keys and delegated service actors (for example the first-party

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/domain/github-action-policies.ts

@@ -0,0 +1,169 @@
+import type {
+  GitHubActionPolicyActor,
+  GitHubActionPolicyActorState,
+  GitHubActionPolicyDecision,
+  GitHubActionPolicyEffectiveDecision,
+  GitHubActionPolicyGroup,
+} from "@opengeni/contracts";
+import {
+  listConnectorActionPolicies,
+  resolveConnectorActionPolicy,
+  upsertConnectorActionPolicies,
+  type ConnectorActionPolicySnapshotEntry,
+  type Database,
+} from "@opengeni/db";
+import {
+  GITHUB_REST_MCP_APP_SERVER_ID,
+  GITHUB_REST_MCP_PERSONAL_SERVER_ID,
+  GITHUB_REST_WRITE_TOOL_NAMES,
+} from "@opengeni/runtime/github-rest-mcp";
+
+export const GITHUB_ACTION_POLICY_GROUP_TOOL_NAMES = {
+  routine: GITHUB_REST_WRITE_TOOL_NAMES.filter(
+    (toolName) => toolName !== "pull_request_review_submit" && toolName !== "pull_request_merge",
+  ),
+  review: ["pull_request_review_submit"],
+  merge: ["pull_request_merge"],
+} as const satisfies Record<GitHubActionPolicyGroup, readonly string[]>;
+
+const groupedToolNames = Object.values(GITHUB_ACTION_POLICY_GROUP_TOOL_NAMES).flat();
+if (
+  groupedToolNames.length !== new Set(groupedToolNames).size ||
+  GITHUB_REST_WRITE_TOOL_NAMES.some((toolName) => !groupedToolNames.includes(toolName))
+) {
+  throw new Error("GitHub action policy groups must cover every write tool exactly once");
+}
+
+export type GitHubActionPolicyActorBinding = {
+  actor: GitHubActionPolicyActor;
+  label: string;
+  connectionId: string;
+  serverId: typeof GITHUB_REST_MCP_APP_SERVER_ID | typeof GITHUB_REST_MCP_PERSONAL_SERVER_ID;
+};
+
+function effectiveToolDecision(
+  policies: readonly ConnectorActionPolicySnapshotEntry[],
+  actor: GitHubActionPolicyActorBinding,
+  toolName: string,
+): GitHubActionPolicyDecision {
+  const resolved = resolveConnectorActionPolicy(policies, {
+    connectionId: actor.connectionId,
+    serverId: actor.serverId,
+    toolName,
+    actionName: toolName,
+  });
+  // Match connector_write admission: absent policy inherits repository capability.
+  // This is a policy projection, not a grant of repository or provider access.
+  if (!resolved.managed) return "allow";
+  if (resolved.entry) return resolved.entry.policy;
+  return resolved.decision;
+}
+
+function effectiveGroupDecision(
+  policies: readonly ConnectorActionPolicySnapshotEntry[],
+  actor: GitHubActionPolicyActorBinding,
+  group: GitHubActionPolicyGroup,
+): GitHubActionPolicyEffectiveDecision {
+  const decisions = new Set(
+    GITHUB_ACTION_POLICY_GROUP_TOOL_NAMES[group].map((toolName) =>
+      effectiveToolDecision(policies, actor, toolName),
+    ),
+  );
+  return decisions.size === 1 ? decisions.values().next().value! : "mixed";
+}
+
+export function projectGitHubActionPolicyActor(
+  policies: readonly ConnectorActionPolicySnapshotEntry[],
+  binding: GitHubActionPolicyActorBinding,
+): GitHubActionPolicyActorState {
+  const groups = {
+    routine: effectiveGroupDecision(policies, binding, "routine"),
+    review: effectiveGroupDecision(policies, binding, "review"),
+    merge: effectiveGroupDecision(policies, binding, "merge"),
+  };
+  return binding.actor.kind === "workspace_app"
+    ? {
+        kind: "workspace_app",
+        installationId: binding.actor.installationId,
+        label: binding.label,
+        groups,
+      }
+    : {
+        kind: "personal",
+        connectionId: binding.actor.connectionId,
+        label: binding.label,
+        groups,
+      };
+}
+
+export async function listGitHubActionPolicyActors(
+  db: Database,
+  input: {
+    accountId: string;
+    workspaceId: string;
+    actors: readonly GitHubActionPolicyActorBinding[];
+  },
+): Promise<GitHubActionPolicyActorState[]> {
+  const policies = await listConnectorActionPolicies(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    connectionIds: input.actors.map((actor) => actor.connectionId),
+  });
+  return input.actors.map((actor) => projectGitHubActionPolicyActor(policies, actor));
+}
+
+export async function updateGitHubActionPolicyGroup(
+  db: Database,
+  input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    actor: GitHubActionPolicyActorBinding;
+    group: GitHubActionPolicyGroup;
+    decision: GitHubActionPolicyDecision;
+  },
+): Promise<GitHubActionPolicyActorState> {
+  await upsertConnectorActionPolicies(
+    db,
+    GITHUB_ACTION_POLICY_GROUP_TOOL_NAMES[input.group].map((toolName) => ({
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      subjectId: input.subjectId,
+      connectionId: input.actor.connectionId,
+      serverId: input.actor.serverId,
+      toolName,
+      actionName: toolName,
+      policy: input.decision,
+    })),
+  );
+  const policies = await listConnectorActionPolicies(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    connectionIds: [input.actor.connectionId],
+  });
+  return projectGitHubActionPolicyActor(policies, input.actor);
+}
+
+export function githubAppActionPolicyActor(input: {
+  installationId: number;
+  accountLogin: string | null;
+}): GitHubActionPolicyActorBinding {
+  return {
+    actor: { kind: "workspace_app", installationId: input.installationId },
+    label: input.accountLogin ? `OpenGeni bot on ${input.accountLogin}` : "OpenGeni bot",
+    connectionId: `github-app:${input.installationId}`,
+    serverId: GITHUB_REST_MCP_APP_SERVER_ID,
+  };
+}
+
+export function personalGitHubActionPolicyActor(input: {
+  connectionId: string;
+  githubLogin: string;
+}): GitHubActionPolicyActorBinding {
+  return {
+    actor: { kind: "personal", connectionId: input.connectionId },
+    label: `@${input.githubLogin}`,
+    connectionId: input.connectionId,
+    serverId: GITHUB_REST_MCP_PERSONAL_SERVER_ID,
+  };
+}

package/src/index.ts

@@ -80,6 +80,7 @@ export * from "./domain/product-integration-pack";
 export * from "./domain/personal-connection-delegations";
 export * from "./domain/resources";
 export * from "./domain/github-repository-bindings";
+export * from "./domain/github-action-policies";
 export * from "./domain/session-tool-policy";
 export * from "./domain/scheduled-tasks";
 export * from "./domain/sessions";
@@ -106,6 +107,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,