@opengeni/core 0.4.10 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/core",
-  "version": "0.4.10",
+  "version": "0.8.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": {
@@ -34,15 +34,15 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@opengeni/codex": "^0.2.3",
-    "@opengeni/config": "^0.5.1",
-    "@opengeni/contracts": "^0.10.0",
-    "@opengeni/db": "^0.7.3",
-    "@opengeni/documents": "^0.2.12",
-    "@opengeni/events": "^0.3.3",
+    "@opengeni/codex": "^0.2.5",
+    "@opengeni/config": "^0.6.2",
+    "@opengeni/contracts": "^0.15.0",
+    "@opengeni/db": "^0.9.3",
+    "@opengeni/documents": "^0.2.19",
+    "@opengeni/events": "^0.3.10",
     "@opengeni/observability": "^0.3.0",
-    "@opengeni/runtime": "^0.7.1",
-    "@opengeni/storage": "^0.2.10",
+    "@opengeni/runtime": "^0.11.0",
+    "@opengeni/storage": "^0.2.15",
     "hono": "^4.12.18"
   },
   "engines": {

package/src/access/index.ts

@@ -240,6 +240,10 @@ async function delegatedAccessContext(
             ? { executionGeneration: payload.executionGeneration }
             : {}),
         },
+        ...(payload.serviceInitiator ? { serviceInitiator: payload.serviceInitiator } : {}),
+        ...(payload.serviceInitiatorContext
+          ? { serviceInitiatorContext: payload.serviceInitiatorContext }
+          : {}),
       },
     ],
     defaultAccountId: payload.accountId,

package/src/application/session-commands.ts

@@ -4,6 +4,9 @@ import type {
   EditSessionQueueItemRequest,
   MoveSessionQueueItemRequest,
   SaveComposerDraftRequest,
+  AccessGrant,
+  SessionAuthorizationOperation,
+  SessionAuthorizationPort,
   SessionCommandReceipt,
   SessionControlRequest,
   SessionControlResponse,
@@ -24,6 +27,8 @@ import {
   moveQueuedTurnInTransaction,
   mutateSessionControlInTransaction,
   mutateWorkspaceControlInTransaction,
+  projectEffectiveControlForRelatedAccess,
+  runIdempotentPersistenceTransaction,
   saveComposerDraftInTransaction,
   sendAgentMessageInTransaction,
   serializeEffectiveSessionControl,
@@ -40,6 +45,10 @@ import {
   type EventBus,
 } from "@opengeni/events";
 import type { SessionWorkflowClient } from "../dependencies";
+import {
+  requireSessionAuthorization,
+  type ResolvedSessionAuthorization,
+} from "../session-authorization";
 
 export type HumanSessionCommandContext = {
   accountId: string;
@@ -51,12 +60,67 @@ export type HumanSessionCommandContext = {
 export type AgentSessionCommandContext = {
   accountId: string;
   workspaceId: string;
+  subjectId: string;
   callerSessionId: string;
   callerTurnId: string;
   callerAttemptId: string;
   callerExecutionGeneration: number;
 };
 
+type SessionAuthorizationCommandDeps = {
+  db: Database;
+  sessionAuthorization?: SessionAuthorizationPort | null;
+};
+
+function humanAccessGrant(context: HumanSessionCommandContext): AccessGrant {
+  return {
+    accountId: context.accountId,
+    workspaceId: context.workspaceId,
+    subjectId: context.subjectId,
+    permissions: [],
+  };
+}
+
+function agentAccessGrant(context: AgentSessionCommandContext): AccessGrant {
+  return {
+    accountId: context.accountId,
+    workspaceId: context.workspaceId,
+    subjectId: context.subjectId,
+    permissions: [],
+    metadata: {
+      sessionId: context.callerSessionId,
+      turnId: context.callerTurnId,
+      attemptId: context.callerAttemptId,
+      executionGeneration: context.callerExecutionGeneration,
+    },
+  };
+}
+
+async function authorizeHumanSessionCommand(
+  deps: SessionAuthorizationCommandDeps,
+  context: HumanSessionCommandContext,
+  operation: SessionAuthorizationOperation,
+): Promise<ResolvedSessionAuthorization | null> {
+  return await requireSessionAuthorization(deps, humanAccessGrant(context), {
+    sessionId: context.sessionId,
+    operation,
+    surface: "core",
+  });
+}
+
+async function authorizeAgentSessionCommand(
+  deps: SessionAuthorizationCommandDeps,
+  context: AgentSessionCommandContext,
+  targetSessionId: string,
+  operation: SessionAuthorizationOperation,
+): Promise<ResolvedSessionAuthorization | null> {
+  return await requireSessionAuthorization(deps, agentAccessGrant(context), {
+    sessionId: targetSessionId,
+    operation,
+    surface: "core",
+  });
+}
+
 function agentActor(context: AgentSessionCommandContext) {
   return {
     type: "agent_attempt" as const,
@@ -67,11 +131,39 @@ function agentActor(context: AgentSessionCommandContext) {
   };
 }
 
+/**
+ * Retry only one operation-keyed Agent command transaction. The caller keeps
+ * event publication and Temporal wake delivery after this returns, so a
+ * deadlock/serialization retry can never replay an external effect.
+ */
+async function runAgentCommandPersistenceTransaction<T>(
+  deps: { db: Database },
+  context: AgentSessionCommandContext,
+  input: {
+    stage: string;
+    eventTypes: string[];
+    transaction: (tx: Database) => Promise<T>;
+  },
+): Promise<T> {
+  return await runIdempotentPersistenceTransaction(
+    {
+      stage: input.stage,
+      eventTypes: input.eventTypes,
+      maxAttempts: 3,
+    },
+    async () =>
+      await withWorkspaceRls(deps.db, context.workspaceId, async (scoped) =>
+        scoped.transaction(async (tx) => await input.transaction(tx as unknown as Database)),
+      ),
+  );
+}
+
 async function publishAndWakeAgentCommand(
   deps: {
     db: Database;
     bus: EventBus;
     workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
+    sessionAuthorization?: SessionAuthorizationPort | null;
   },
   input: {
     accountId: string;
@@ -161,13 +253,17 @@ export async function sendAgentSessionMessage(
     db: Database;
     bus: EventBus;
     workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
+    sessionAuthorization?: SessionAuthorizationPort | null;
   },
   context: AgentSessionCommandContext,
   input: { targetSessionId: string; text: string; idempotencyKey: string },
 ) {
-  const result = await withWorkspaceRls(deps.db, context.workspaceId, (scoped) =>
-    scoped.transaction((tx) =>
-      sendAgentMessageInTransaction(tx as unknown as Database, {
+  await authorizeAgentSessionCommand(deps, context, input.targetSessionId, "session.append");
+  const result = await runAgentCommandPersistenceTransaction(deps, context, {
+    stage: "session_commands.agent_message",
+    eventTypes: ["system.update.pending"],
+    transaction: async (tx) =>
+      await sendAgentMessageInTransaction(tx, {
         accountId: context.accountId,
         workspaceId: context.workspaceId,
         targetSessionId: input.targetSessionId,
@@ -175,8 +271,7 @@ export async function sendAgentSessionMessage(
         operationKey: input.idempotencyKey,
         text: input.text,
       }),
-    ),
-  );
+  });
   await publishAndWakeAgentCommand(deps, {
     accountId: context.accountId,
     workspaceId: context.workspaceId,
@@ -196,13 +291,17 @@ export async function steerAgentSession(
     db: Database;
     bus: EventBus;
     workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
+    sessionAuthorization?: SessionAuthorizationPort | null;
   },
   context: AgentSessionCommandContext,
   input: { targetSessionId: string; instruction: string; idempotencyKey: string },
 ) {
-  const result = await withWorkspaceRls(deps.db, context.workspaceId, (scoped) =>
-    scoped.transaction((tx) =>
-      steerAgentSessionInTransaction(tx as unknown as Database, {
+  await authorizeAgentSessionCommand(deps, context, input.targetSessionId, "session.steer");
+  const result = await runAgentCommandPersistenceTransaction(deps, context, {
+    stage: "session_commands.agent_steer",
+    eventTypes: ["session.control.steer_requested", "system.update.pending", "turn.superseded"],
+    transaction: async (tx) =>
+      await steerAgentSessionInTransaction(tx, {
         accountId: context.accountId,
         workspaceId: context.workspaceId,
         targetSessionId: input.targetSessionId,
@@ -210,8 +309,7 @@ export async function steerAgentSession(
         operationKey: input.idempotencyKey,
         instruction: input.instruction,
       }),
-    ),
-  );
+  });
   await publishAndWakeAgentCommand(deps, {
     accountId: context.accountId,
     workspaceId: context.workspaceId,
@@ -231,6 +329,7 @@ export async function controlAgentSessionWorkstream(
     db: Database;
     bus: EventBus;
     workflowClient: Pick<SessionWorkflowClient, "requestSessionWorkflowWakeDispatch">;
+    sessionAuthorization?: SessionAuthorizationPort | null;
   },
   context: AgentSessionCommandContext,
   input: {
@@ -240,6 +339,7 @@ export async function controlAgentSessionWorkstream(
     reason?: string | null;
   },
 ) {
+  await authorizeAgentSessionCommand(deps, context, input.targetSessionId, "session.control");
   const result = await withWorkspaceRls(deps.db, context.workspaceId, (scoped) =>
     scoped.transaction((tx) =>
       mutateSessionControlInTransaction(tx as unknown as Database, {
@@ -293,18 +393,31 @@ function composerDraft(
   };
 }
 
-async function authoritativeQueue(db: Database, workspaceId: string, sessionId: string) {
+async function authoritativeQueue(
+  db: Database,
+  workspaceId: string,
+  sessionId: string,
+  relatedSessionAccess: "target" | "root",
+) {
   const snapshot = await getSessionQueueSnapshot(db, workspaceId, sessionId);
   if (!snapshot) throw new Error(`Session not found: ${sessionId}`);
-  return snapshot;
+  return {
+    ...snapshot,
+    effectiveControl: projectEffectiveControlForRelatedAccess(
+      snapshot.effectiveControl,
+      sessionId,
+      relatedSessionAccess,
+    ),
+  };
 }
 
 export async function moveHumanQueuePrompt(
-  deps: { db: Database; bus: EventBus },
+  deps: { db: Database; bus: EventBus; sessionAuthorization?: SessionAuthorizationPort | null },
   context: HumanSessionCommandContext,
   turnId: string,
   input: MoveSessionQueueItemRequest,
 ): Promise<SessionQueueMutationResponse> {
+  const authorization = await authorizeHumanSessionCommand(deps, context, "session.queue.control");
   const result = await withWorkspaceRls(deps.db, context.workspaceId, (scoped) =>
     scoped.transaction((tx) =>
       moveQueuedTurnInTransaction(tx as unknown as Database, {
@@ -319,18 +432,24 @@ export async function moveHumanQueuePrompt(
   );
   const response = {
     receipt: receipt(result.receipt),
-    snapshot: await authoritativeQueue(deps.db, context.workspaceId, context.sessionId),
+    snapshot: await authoritativeQueue(
+      deps.db,
+      context.workspaceId,
+      context.sessionId,
+      authorization?.relatedSessionAccess ?? "root",
+    ),
   };
   await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
   return response;
 }
 
 export async function deleteHumanQueuePrompt(
-  deps: { db: Database; bus: EventBus },
+  deps: { db: Database; bus: EventBus; sessionAuthorization?: SessionAuthorizationPort | null },
   context: HumanSessionCommandContext,
   turnId: string,
   input: DeleteSessionQueueItemRequest,
 ): Promise<SessionQueueMutationResponse> {
+  const authorization = await authorizeHumanSessionCommand(deps, context, "session.queue.control");
   const result = await withWorkspaceRls(deps.db, context.workspaceId, (scoped) =>
     scoped.transaction((tx) =>
       deleteSessionQueueItemInTransaction(tx as unknown as Database, {
@@ -345,18 +464,24 @@ export async function deleteHumanQueuePrompt(
   );
   const response = {
     receipt: receipt(result.receipt),
-    snapshot: await authoritativeQueue(deps.db, context.workspaceId, context.sessionId),
+    snapshot: await authoritativeQueue(
+      deps.db,
+      context.workspaceId,
+      context.sessionId,
+      authorization?.relatedSessionAccess ?? "root",
+    ),
   };
   await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
   return response;
 }
 
 export async function editHumanQueuePrompt(
-  deps: { db: Database; bus: EventBus },
+  deps: { db: Database; bus: EventBus; sessionAuthorization?: SessionAuthorizationPort | null },
   context: HumanSessionCommandContext,
   turnId: string,
   input: EditSessionQueueItemRequest,
 ): Promise<SessionQueueMutationResponse> {
+  const authorization = await authorizeHumanSessionCommand(deps, context, "session.queue.control");
   const result = await withWorkspaceSubjectRls(
     deps.db,
     context.workspaceId,
@@ -376,7 +501,12 @@ export async function editHumanQueuePrompt(
   );
   const response = {
     receipt: receipt(result.receipt),
-    snapshot: await authoritativeQueue(deps.db, context.workspaceId, context.sessionId),
+    snapshot: await authoritativeQueue(
+      deps.db,
+      context.workspaceId,
+      context.sessionId,
+      authorization?.relatedSessionAccess ?? "root",
+    ),
     draft: composerDraft(result.draft)!,
   };
   await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
@@ -384,11 +514,12 @@ export async function editHumanQueuePrompt(
 }
 
 export async function steerHumanQueuePrompt(
-  deps: { db: Database; bus: EventBus },
+  deps: { db: Database; bus: EventBus; sessionAuthorization?: SessionAuthorizationPort | null },
   context: HumanSessionCommandContext,
   turnId: string,
   input: SteerSessionQueueItemRequest,
 ): Promise<SessionQueueMutationResponse> {
+  const authorization = await authorizeHumanSessionCommand(deps, context, "session.queue.control");
   const result = await withWorkspaceRls(deps.db, context.workspaceId, (scoped) =>
     scoped.transaction((tx) =>
       steerQueuedTurnInTransaction(tx as unknown as Database, {
@@ -403,7 +534,12 @@ export async function steerHumanQueuePrompt(
   );
   const response = {
     receipt: receipt(result.receipt),
-    snapshot: await authoritativeQueue(deps.db, context.workspaceId, context.sessionId),
+    snapshot: await authoritativeQueue(
+      deps.db,
+      context.workspaceId,
+      context.sessionId,
+      authorization?.relatedSessionAccess ?? "root",
+    ),
   };
   await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
   await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
@@ -415,10 +551,12 @@ export async function controlHumanSessionWorkstream(
     db: Database;
     bus: EventBus;
     workflowClient: Pick<SessionWorkflowClient, "requestSessionWorkflowWakeDispatch">;
+    sessionAuthorization?: SessionAuthorizationPort | null;
   },
   context: HumanSessionCommandContext,
   input: SessionControlRequest,
 ): Promise<SessionControlResponse> {
+  const authorization = await authorizeHumanSessionCommand(deps, context, "session.control");
   const result = await withWorkspaceRls(deps.db, context.workspaceId, (scoped) =>
     scoped.transaction((tx) =>
       mutateSessionControlInTransaction(tx as unknown as Database, {
@@ -435,7 +573,11 @@ export async function controlHumanSessionWorkstream(
   );
   const response = {
     receipt: receipt(result.receipt),
-    effectiveControl: serializeEffectiveSessionControl(result.control),
+    effectiveControl: projectEffectiveControlForRelatedAccess(
+      serializeEffectiveSessionControl(result.control),
+      context.sessionId,
+      authorization?.relatedSessionAccess ?? "root",
+    ),
     interruptionCount: result.interruptionCount,
     wakeCount: result.wakeCount,
   };
@@ -482,19 +624,24 @@ export async function controlHumanWorkspace(
 }
 
 export async function getHumanComposerDraft(
-  db: Database,
+  deps: SessionAuthorizationCommandDeps,
   context: HumanSessionCommandContext,
 ): Promise<ComposerDraft> {
-  const row = await withWorkspaceSubjectRls(db, context.workspaceId, context.subjectId, (scoped) =>
-    getComposerDraftInTransaction(scoped, {
-      workspaceId: context.workspaceId,
-      sessionId: context.sessionId,
-      subjectId: context.subjectId,
-    }),
+  await authorizeHumanSessionCommand(deps, context, "session.composer.read");
+  const row = await withWorkspaceSubjectRls(
+    deps.db,
+    context.workspaceId,
+    context.subjectId,
+    (scoped) =>
+      getComposerDraftInTransaction(scoped, {
+        workspaceId: context.workspaceId,
+        sessionId: context.sessionId,
+        subjectId: context.subjectId,
+      }),
   );
   const mapped = composerDraft(row);
   if (mapped) return mapped;
-  const session = await getSession(db, context.workspaceId, context.sessionId);
+  const session = await getSession(deps.db, context.workspaceId, context.sessionId);
   if (!session) throw new Error(`Session not found: ${context.sessionId}`);
   return {
     revision: 0,
@@ -510,18 +657,23 @@ export async function getHumanComposerDraft(
 }
 
 export async function saveHumanComposerDraft(
-  db: Database,
+  deps: SessionAuthorizationCommandDeps,
   context: HumanSessionCommandContext,
   input: SaveComposerDraftRequest,
 ): Promise<ComposerDraft> {
-  const row = await withWorkspaceSubjectRls(db, context.workspaceId, context.subjectId, (scoped) =>
-    scoped.transaction((tx) =>
-      saveComposerDraftInTransaction(tx as unknown as Database, {
-        ...context,
-        ...input,
-        subjectId: context.subjectId,
-      }),
-    ),
+  await authorizeHumanSessionCommand(deps, context, "session.composer.write");
+  const row = await withWorkspaceSubjectRls(
+    deps.db,
+    context.workspaceId,
+    context.subjectId,
+    (scoped) =>
+      scoped.transaction((tx) =>
+        saveComposerDraftInTransaction(tx as unknown as Database, {
+          ...context,
+          ...input,
+          subjectId: context.subjectId,
+        }),
+      ),
   );
   return composerDraft(row)!;
 }

package/src/billing/limits.ts

@@ -1,5 +1,11 @@
 import { configuredStaticUsageLimits } from "@opengeni/config";
-import type { LimitAction, LimitDecision } from "@opengeni/contracts";
+import type {
+  LimitAction,
+  LimitDecision,
+  SessionTurnSource,
+  TurnInitiator,
+  TurnInitiatorContext,
+} from "@opengeni/contracts";
 import {
   countActiveApiKeysForWorkspace,
   countScheduledTasksForWorkspace,
@@ -213,6 +219,12 @@ export async function recordWorkspaceUsage(
     unit: string;
     sourceResourceType: string;
     sourceResourceId: string;
+    sessionId?: string | null;
+    turnId?: string | null;
+    turnAttemptId?: string | null;
+    initiator?: TurnInitiator | null;
+    initiatorContext?: TurnInitiatorContext;
+    origin?: SessionTurnSource | null;
     idempotencyKey: string;
   },
 ): Promise<void> {
@@ -225,6 +237,13 @@ export async function recordWorkspaceUsage(
     unit: input.unit,
     sourceResourceType: input.sourceResourceType,
     sourceResourceId: input.sourceResourceId,
+    sessionId: input.sessionId ?? null,
+    turnId: input.turnId ?? null,
+    turnAttemptId: input.turnAttemptId ?? null,
+    initiator:
+      input.initiator ?? (input.subjectId ? { kind: "subject", subjectId: input.subjectId } : null),
+    ...(input.initiatorContext ? { initiatorContext: input.initiatorContext } : {}),
+    origin: input.origin ?? null,
     idempotencyKey: input.idempotencyKey,
   });
 }

package/src/dependencies.ts

@@ -1,5 +1,11 @@
 import type { Settings } from "@opengeni/config";
-import type { Document, ScheduledTask } from "@opengeni/contracts";
+import type {
+  ConnectionCredentialsPort,
+  Document,
+  GitHubAppApiPort,
+  ScheduledTask,
+  SessionAuthorizationPort,
+} from "@opengeni/contracts";
 import type { Database } from "@opengeni/db";
 import type { DocumentServices } from "@opengeni/documents";
 import type { EventBus } from "@opengeni/events";
@@ -79,6 +85,24 @@ export type AppDependencies = {
   observability?: Observability;
   readinessChecks?: Partial<Record<"db" | "nats" | "temporal", () => Promise<void> | void>>;
   githubStateSecret?: string;
+  /**
+   * Optional host-provided GitHub App API seam. Embedded hosts can authorize
+   * users, inspect installations, and list repositories with their own GitHub
+   * App credentials; standalone deployments fall back to @opengeni/github.
+   */
+  githubAppApi?: GitHubAppApiPort;
+  /**
+   * Optional host-owned connection credential seam. API-side consumers use
+   * the MCP leg for Toolspace/Code Mode; worker consumers bind the same port
+   * for model MCP, Git, and sandbox-secret resolution.
+   */
+  connectionCredentials?: ConnectionCredentialsPort | null;
+  /**
+   * Optional embedding-host session ACL. Unset preserves standalone workspace
+   * authorization; once bound, every session-addressed surface fails closed on
+   * an unavailable or invalid host decision.
+   */
+  sessionAuthorization?: SessionAuthorizationPort | null;
   managedAuth?: ManagedAuth | null;
   // The API process's OWN agent-loop-free sandbox client (constructed from
   // settings via @opengeni/runtime/sandbox). Undefined when sandboxBackend=none.
@@ -118,7 +142,7 @@ export type ApiRouteDeps = AppDependencies & {
  */
 export type AcceptSessionUserMessageDependencies = Pick<
   AppDependencies,
-  "settings" | "db" | "bus"
+  "settings" | "db" | "bus" | "sessionAuthorization"
 > & {
   workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
   objectStorage: ObjectStorageDependency;