@opengeni/core 1.0.2 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/core",
-  "version": "1.0.2",
+  "version": "1.1.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": {
@@ -50,17 +50,17 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@opengeni/capabilities": "1.0.2",
-    "@opengeni/codex": "1.0.2",
-    "@opengeni/config": "1.0.2",
-    "@opengeni/contracts": "1.0.2",
-    "@opengeni/db": "1.0.2",
-    "@opengeni/documents": "1.0.2",
-    "@opengeni/events": "1.0.2",
-    "@opengeni/network": "1.0.2",
-    "@opengeni/observability": "1.0.2",
-    "@opengeni/runtime": "1.0.2",
-    "@opengeni/storage": "1.0.2",
+    "@opengeni/capabilities": "1.1.0",
+    "@opengeni/codex": "1.1.0",
+    "@opengeni/config": "1.1.0",
+    "@opengeni/contracts": "1.1.0",
+    "@opengeni/db": "1.1.0",
+    "@opengeni/documents": "1.1.0",
+    "@opengeni/events": "1.1.0",
+    "@opengeni/network": "1.1.0",
+    "@opengeni/observability": "1.1.0",
+    "@opengeni/runtime": "1.1.0",
+    "@opengeni/storage": "1.1.0",
     "hono": "^4.12.18",
     "zod": "^4.2.1"
   },

package/src/application/session-tenancy.ts

@@ -19,10 +19,8 @@ import {
   isRetryableDatabaseTransportFailure,
   nestedPostgresSqlState,
   replayAppliedSessionFork,
-  sessionTenancyProductActivated,
   SessionTenancyAccessError,
   SessionTenancyInvalidRequestError,
-  SessionTenancyNotActivatedError,
   transitionSessionVisibility,
   type Database,
   type ForkSessionContentResult,
@@ -101,9 +99,10 @@ export async function getManagedHumanSessionCreateCapabilities(
     }
     throw error;
   }
-  // Mirror the database create fence exactly: a managed human's own Personal
-  // workspace needs only the operator readiness receipt, while a shared
-  // organization workspace additionally needs the owner/admin product setting.
+  // Mirror the database create fence exactly: every organization is
+  // session-tenancy activated (migration 0611), so a member's own Personal
+  // workspace is always private-capable, while a shared organization workspace
+  // additionally needs the owner/admin Only-me product setting.
   let activated = false;
   try {
     const policy = await getPrivateSessionCreatePolicy(deps.db, {
@@ -153,9 +152,6 @@ async function requireSessionTenancyMutationGate(
   // missing, shared, or another owner's private session.
   requireVerifiedOwningUser(authorization, workspaceId);
   for (const permission of permissions) requirePermission(authorization.grant, permission);
-  if (!(await sessionTenancyProductActivated(deps.db, workspaceId))) {
-    throw new SessionTenancyNotActivatedError();
-  }
 }
 
 async function publishExactCommittedEvent(

package/src/application/user-resource-grants.ts

@@ -8,8 +8,6 @@ import {
   issueSelfUserResourceGrant,
   listSelfUserResourceAuthorities,
   revokeSelfUserResourceGrant,
-  sessionTenancyProductActivated,
-  SessionTenancyNotActivatedError,
 } from "@opengeni/db";
 import { requirePermission, type AccessGrantAuthorization } from "../access";
 import type { AppDependencies } from "../dependencies";
@@ -46,9 +44,6 @@ async function requireOwnerProductGate(
   // Target-free gates must run before an optional target-session lookup or host
   // callback so rejected principals cannot use grant management as an oracle.
   requireOwnerAuthority(authorization, workspaceId, permissions);
-  if (!(await sessionTenancyProductActivated(deps.db, workspaceId))) {
-    throw new SessionTenancyNotActivatedError();
-  }
 }
 
 function requireOwnerAuthority(
@@ -75,14 +70,6 @@ export async function listManagedHumanUserResourceAuthorities(
   input: { resourceKind: UserResourceKind; cursor?: string | undefined; limit: number },
 ) {
   requireOwnerAuthority(authorization, workspaceId, LIST_PERMISSIONS[input.resourceKind]);
-  // Before activation there cannot be usable personal-resource authority in
-  // this organization. Discovery therefore has an exact empty answer; only
-  // issue/revoke and runtime use remain behind the forward-only product gate.
-  // This keeps ordinary workspace-owned Rig/Variable Set selection independent
-  // from an optional personal-resource product that is not enabled.
-  if (!(await sessionTenancyProductActivated(deps.db, workspaceId))) {
-    return { authorities: [], nextCursor: null };
-  }
   return await listSelfUserResourceAuthorities(deps.db, {
     accountId: authorization.grant.accountId,
     workspaceId,

package/src/billing/agent-run-admission.ts

@@ -0,0 +1,99 @@
+import { configuredStaticUsageLimits, type Settings } from "@opengeni/config";
+import type { EntitlementsPort } from "@opengeni/contracts";
+import { modelFundingForAdmission } from "./limits";
+import {
+  checkWorkspaceAllowance,
+  getBillingBalance,
+  isCodexBilledTurn,
+  sumUsageQuantity,
+  type Database,
+} from "@opengeni/db";
+
+export type AgentRunAdmissionDenial =
+  | "insufficient_credits"
+  | "allowance_exhausted"
+  | "monthly_model_cost_limit"
+  | "monthly_agent_run_limit";
+
+/** Read-only admission shared by service-authored runs and goal Resume. */
+export async function agentRunAdmissionDenial(
+  services: { db: Database; settings: Settings; entitlements?: EntitlementsPort | null },
+  input: {
+    accountId: string;
+    workspaceId: string;
+    model: string;
+    requestedAgentRuns: number;
+    /** The accepted work's causal human, not the scheduler/service caller. */
+    initiatingHumanSubjectId?: string | null;
+  },
+): Promise<AgentRunAdmissionDenial | null> {
+  const codexBilled = await isCodexBilledTurn({
+    db: services.db,
+    settings: services.settings,
+    workspaceId: input.workspaceId,
+    model: input.model,
+  });
+  const externallyBilled = modelFundingForAdmission(
+    services.settings,
+    input.model,
+    codexBilled,
+  ).fundedWithoutCredits;
+  if (
+    !externallyBilled &&
+    (services.settings.billingMode === "stripe" || services.settings.usageLimitsMode === "managed")
+  ) {
+    if (services.entitlements) {
+      const decision = await services.entitlements.admitRun({
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        action: "agent_run:create",
+        quantity: input.requestedAgentRuns,
+      });
+      if (!decision.allowed) return "insufficient_credits";
+    } else {
+      const balance = await getBillingBalance(services.db, input.accountId);
+      if (balance.balanceMicros <= 0) return "insufficient_credits";
+    }
+  }
+  if (!externallyBilled) {
+    const refusal = await checkWorkspaceAllowance(services.db, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      subjectId: input.initiatingHumanSubjectId ?? null,
+    });
+    if (refusal) return refusal.code;
+  }
+  if (
+    services.settings.usageLimitsMode !== "static" &&
+    services.settings.usageLimitsMode !== "managed"
+  ) {
+    return null;
+  }
+  const limits = configuredStaticUsageLimits(services.settings);
+  if (!externallyBilled && limits.maxMonthlyCostMicrosPerAccount) {
+    const used = await sumUsageQuantity(services.db, {
+      accountId: input.accountId,
+      eventType: "model.cost",
+      since: startOfUtcMonth(),
+    });
+    if (used >= limits.maxMonthlyCostMicrosPerAccount) {
+      return "monthly_model_cost_limit";
+    }
+  }
+  if (limits.maxMonthlyAgentRunsPerWorkspace) {
+    const used = await sumUsageQuantity(services.db, {
+      workspaceId: input.workspaceId,
+      eventType: "agent_run.created",
+      since: startOfUtcMonth(),
+    });
+    if (used + input.requestedAgentRuns > limits.maxMonthlyAgentRunsPerWorkspace) {
+      return "monthly_agent_run_limit";
+    }
+  }
+  return null;
+}
+
+function startOfUtcMonth(): Date {
+  const now = new Date();
+  return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
+}

package/src/dependencies.ts

@@ -3,6 +3,7 @@ import type {
   ConnectionCredentialsPort,
   Document,
   DocumentAuthorityKind,
+  EntitlementsPort,
   GitHubAppApiPort,
   ScheduledTask,
   ScheduledTaskTriggerType,
@@ -155,6 +156,8 @@ export type AppDependencies = {
    */
   catalogSourceSettings?: Settings;
   db: Database;
+  /** Read-only host funding admission; unset uses the standalone billing ledger. */
+  entitlements?: EntitlementsPort | null;
   /**
    * Host-composed editable artifact engine. Standalone startup binds the same
    * native kernel/DB/object-store implementation; embedded hosts may inject an

package/src/domain/session-tool-policy.ts

@@ -8,6 +8,7 @@ import {
 import {
   AGENT_SKILL_MANAGE_TOOL_NAMES,
   AUTOMATIC_SESSION_TITLE_FALLBACK,
+  bundledSkillSelectionForAgentConfig,
   DEFAULT_FIRST_PARTY_MCP_PERMISSIONS,
   FIRST_PARTY_IN_PROCESS_TOOL_NAMES,
   type FirstPartyMcpToolName,
@@ -395,14 +396,19 @@ export async function workspaceSessionEffectiveToolsContext(
 
 function sessionHasSkills(session: Session, context: SessionEffectiveToolsContext): boolean {
   if (context.hasWorkspaceSkills || session.skills.length > 0) return true;
-  // Undefined is the worker's bundled default. Explicit [] means no bundles.
-  if (session.bundledSkillIds === undefined) return true;
+  // Undefined is the worker's bundled default. Explicit [] means no bundles,
+  // and a "none" agent without an explicit list has none (as in the worker).
+  const bundledSkillIds = bundledSkillSelectionForAgentConfig(
+    session.bundledSkillIds,
+    session.agent,
+  );
+  if (bundledSkillIds === undefined) return true;
   const tools = new Set(
     resolveAgentToolFamilies(session.agent).firstPartyTools(
       allowedFirstPartyMcpToolsForSession(context.settings, session.firstPartyMcpTools),
     ),
   );
-  return session.bundledSkillIds.some((id) => {
+  return bundledSkillIds.some((id) => {
     if (
       [
         "builtin:opengeni-documents",
@@ -479,7 +485,7 @@ export function sessionEffectiveToolProjectionInput(
     (!session.title?.trim() || session.title.trim() === AUTOMATIC_SESSION_TITLE_FALLBACK);
   const firstPartyMcpTools =
     context && toolRefs.some((ref) => ref.id === "opengeni")
-      ? resolveAgentToolFamilies(session.agent)
+      ? resolveAgentToolFamilies(session.agent, { sandboxAttached: sandboxAvailable })
           .firstPartyTools(
             allowedFirstPartyMcpToolsForSession(context.settings, session.firstPartyMcpTools),
           )
@@ -512,7 +518,9 @@ export function sessionEffectiveToolProjectionInput(
         firstPartyModelNames.set(name, `interaction__${name}`);
         if (
           !firstPartyMcpTools.includes(name) &&
-          resolveAgentToolFamilies(session.agent).allowsFirstPartyTool(name) &&
+          resolveAgentToolFamilies(session.agent, {
+            sandboxAttached: sandboxAvailable,
+          }).allowsFirstPartyTool(name) &&
           session.firstPartyMcpTools.includes(name)
         )
           firstPartyMcpTools.push(name);
@@ -561,6 +569,7 @@ export function sessionEffectiveToolProjectionInput(
     routerInHistory:
       context?.routerInHistory === true ||
       context?.routerHistorySessionIds?.has(session.id) === true,
+    ...(context ? { sandboxAttached: sandboxAvailable } : {}),
   };
   const families = resolveAgentToolFamilies(session.agent, environment);
   environment.hasDeferredTools =

package/src/domain/sessions.ts

@@ -72,6 +72,7 @@ import {
   OPENGENI_SLACK_BOT_SESSION_METADATA_KEY,
   SessionSkills,
   resolveBundledSkillSelection,
+  bundledSkillSelectionForAgentConfig,
   SessionSpawnDenial,
   ServiceTurnInitiator,
   ServiceTurnInitiatorContext,
@@ -182,7 +183,6 @@ import {
   SessionToolPolicyVersionConflictError,
   SessionCreateIdempotencyConflictError,
   PersonalResourceAttachmentAcceptanceError,
-  sessionTenancyProductActivated,
   workspaceControlRequestLockTimeoutMs,
   WorkspaceControlBusyError,
   type SessionCommandActor,
@@ -327,11 +327,6 @@ async function requireAtomicPersonalResourceAttachment(
       cause: error,
     });
   }
-  if (!(await sessionTenancyProductActivated(deps.db, workspaceId))) {
-    throw new HTTPException(409, {
-      message: "Session tenancy is not activated for this organization.",
-    });
-  }
   if (existingSession && intent.expectedAuthorityEpoch === undefined) {
     throw new HTTPException(422, {
       message: "Personal-resource attachment requires expectedAuthorityEpoch.",
@@ -1051,6 +1046,13 @@ export async function createAndStartSessionWithOutcome(input: {
   allowNestedAgentDepthIncrease?: boolean;
   subjectId?: string | null;
 }): Promise<CreateSessionOutcome> {
+  const frozenBundledSkillIds = bundledSkillSelectionForAgentConfig(
+    input.bundledSkillIds,
+    input.agentConfig,
+  );
+  if (frozenBundledSkillIds !== input.bundledSkillIds) {
+    input = { ...input, bundledSkillIds: frozenBundledSkillIds };
+  }
   const sessionMetadata = metadataWithTurnExecutionPolicyV1(
     {
       ...input.metadata,
@@ -2545,6 +2547,9 @@ async function createSessionForRequestInFileScope(
   if (agentResolution.instructions !== undefined) {
     payload.instructions = agentResolution.instructions;
   }
+  // Freeze what the agent configuration implies before keyed replay compares
+  // it: a `"none"` agent omits the bundled guides unless the request lists them.
+  bundledSkillIds = bundledSkillSelectionForAgentConfig(bundledSkillIds, agentConfig);
   const parentCallingTurn =
     parentSession && creationInitiator.actor
       ? await getSessionTurnForAttempt(

package/src/goal-admission.ts

@@ -0,0 +1,187 @@
+import {
+  isModelAvailableForNewSelection,
+  policyProviderIdForModel,
+  resolveModelProvider,
+  runnableLatencyModesForModel,
+  withCodexCatalogProvider,
+  withXaiSubscriptionCatalogProvider,
+  type Settings,
+} from "@opengeni/config";
+import {
+  evaluateWorkspaceModelPolicy,
+  type GoalAdmissionPausedReason,
+  type Session,
+} from "@opengeni/contracts";
+import { isCodexBilledModel } from "@opengeni/codex";
+import { getWorkspaceModelPolicy, type Database } from "@opengeni/db";
+import { resolveWorkspaceCatalogSettings } from "./model-catalog";
+import { agentRunAdmissionDenial } from "./billing/agent-run-admission";
+
+export type GoalAdmissionBlock = { pausedReason: GoalAdmissionPausedReason; message: string };
+
+/** Catalog membership never grants access to a connection or changes the selected model. */
+export function goalContinuationModelDecision(input: {
+  settings: Settings;
+  workspaceModelPolicy: Awaited<ReturnType<typeof getWorkspaceModelPolicy>>;
+  inheritedModel: string;
+  codexCompactionMode?: Session["codexCompactionMode"];
+  latencyMode?: Session["latencyMode"];
+}): { model: string; blocked: string | null; pausedReason?: GoalAdmissionPausedReason } {
+  const catalogSettings = input.settings.supergrokSubscriptionEnabled
+    ? withXaiSubscriptionCatalogProvider(
+        input.settings.codexSubscriptionEnabled
+          ? withCodexCatalogProvider(input.settings)
+          : input.settings,
+      )
+    : input.settings.codexSubscriptionEnabled
+      ? withCodexCatalogProvider(input.settings)
+      : input.settings;
+  const model = input.inheritedModel;
+  if (!resolveModelProvider(catalogSettings, model)) {
+    return {
+      model,
+      blocked: "The selected model is unavailable. Choose an available model before resuming.",
+      pausedReason: "model_unavailable",
+    };
+  }
+  if (!isModelAvailableForNewSelection(catalogSettings, model)) {
+    return {
+      model,
+      blocked: "The selected model has been retired. Choose an available model before resuming.",
+      pausedReason: "model_unavailable",
+    };
+  }
+  if (
+    input.workspaceModelPolicy !== null &&
+    !evaluateWorkspaceModelPolicy(input.workspaceModelPolicy, {
+      providerId: policyProviderIdForModel(catalogSettings, model),
+      modelId: model,
+    }).allowed
+  ) {
+    return {
+      model,
+      blocked:
+        "Workspace policy blocks the selected model. Choose an allowed model before resuming.",
+      pausedReason: "model_policy",
+    };
+  }
+  if (input.codexCompactionMode === "remote_v2" && !isCodexBilledModel(model)) {
+    return {
+      model,
+      blocked: "This conversation requires a Codex model. Choose a Codex model before resuming.",
+      pausedReason: "model_policy",
+    };
+  }
+  if (
+    !runnableLatencyModesForModel(catalogSettings, model).includes(input.latencyMode ?? "standard")
+  ) {
+    return {
+      model,
+      blocked:
+        "The selected model does not support this conversation's latency mode. Choose a supported mode or model before resuming.",
+      pausedReason: "model_policy",
+    };
+  }
+  return { model, blocked: null };
+}
+
+/** The same scoped, secret-free catalog used at ordinary turn admission. */
+export async function resolveGoalModelAdmission(
+  db: Database,
+  settings: Settings,
+  input: {
+    accountId: string;
+    workspaceId: string;
+    model: string;
+    codexCompactionMode?: Session["codexCompactionMode"];
+    latencyMode?: Session["latencyMode"];
+  },
+) {
+  const catalog = await resolveWorkspaceCatalogSettings(db, settings, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    retainedProductModelId: input.model,
+  });
+  const workspaceModelPolicy = await getWorkspaceModelPolicy(db, input.workspaceId);
+  return {
+    settings: catalog.settings,
+    ...goalContinuationModelDecision({
+      settings: catalog.settings,
+      workspaceModelPolicy,
+      inheritedModel: input.model,
+      ...(input.codexCompactionMode ? { codexCompactionMode: input.codexCompactionMode } : {}),
+      ...(input.latencyMode ? { latencyMode: input.latencyMode } : {}),
+    }),
+  };
+}
+
+/** Shared with scheduled work; reasons describe the actual admission gate. */
+export async function goalRunBudgetBlocked(
+  services: Parameters<typeof agentRunAdmissionDenial>[0],
+  input: Omit<Parameters<typeof agentRunAdmissionDenial>[1], "requestedAgentRuns">,
+): Promise<GoalAdmissionBlock | null> {
+  const denial = await agentRunAdmissionDenial(services, { ...input, requestedAgentRuns: 1 });
+  if (denial === null) return null;
+  const blocks: Record<NonNullable<typeof denial>, GoalAdmissionBlock> = {
+    insufficient_credits: services.entitlements
+      ? {
+          pausedReason: "usage_policy",
+          message: "The application's usage policy blocks another run. Resume when it allows.",
+        }
+      : {
+          pausedReason: "credits",
+          message: "Insufficient Opengeni credits. Add credits before resuming.",
+        },
+    allowance_exhausted: {
+      pausedReason: "allowance",
+      message: "Opengeni usage allowance exhausted. Resume when your allowance is available.",
+    },
+    monthly_model_cost_limit: {
+      pausedReason: "budget",
+      message: "Monthly model spending limit reached. Resume when the spending limit allows.",
+    },
+    monthly_agent_run_limit: {
+      pausedReason: "usage_limit",
+      message: "Monthly agent run limit reached. Resume when the run limit allows.",
+    },
+  };
+  return blocks[denial];
+}
+
+export class GoalResumeBlockedError extends Error {
+  constructor(
+    readonly pausedReason: GoalAdmissionPausedReason,
+    message: string,
+  ) {
+    super(message);
+    this.name = "GoalResumeBlockedError";
+  }
+}
+
+/** Called under the goal transition's locks, before counters, events or wakes change. */
+export async function assertGoalResumeAllowed(
+  services: Parameters<typeof agentRunAdmissionDenial>[0] & { catalogSourceSettings?: Settings },
+  session: Pick<Session, "accountId" | "workspaceId" | "model" | "codexCompactionMode"> &
+    Partial<Pick<Session, "latencyMode">>,
+  causalTurn: { initiatingHumanSubjectId: string | null } | null,
+): Promise<void> {
+  const decision = await resolveGoalModelAdmission(
+    services.db,
+    services.catalogSourceSettings ?? services.settings,
+    session,
+  );
+  if (decision.blocked) {
+    throw new GoalResumeBlockedError(decision.pausedReason!, decision.blocked);
+  }
+  const block = await goalRunBudgetBlocked(
+    { ...services, settings: decision.settings },
+    {
+      accountId: session.accountId,
+      workspaceId: session.workspaceId,
+      model: decision.model,
+      // Resuming does not lend the clicking user's allowance or credentials.
+      initiatingHumanSubjectId: causalTurn?.initiatingHumanSubjectId ?? null,
+    },
+  );
+  if (block) throw new GoalResumeBlockedError(block.pausedReason, block.message);
+}

package/src/index.ts

@@ -63,6 +63,7 @@ export {
 } from "./managed-session";
 export * from "./transcription";
 export * from "./model-catalog";
+export * from "./goal-admission";
 export * from "./codex-model-availability";
 export * from "./default-session-model";
 
@@ -86,6 +87,7 @@ export * from "./session-authorization";
 
 // Billing / usage-limit admission (checkLimit / requireLimit / recordWorkspaceUsage).
 export * from "./billing/limits";
+export * from "./billing/agent-run-admission";
 
 // Domain layer — the off-HTTP V2 surface (createSessionForRequest,