@opengeni/core 3.0.1 → 3.1.2

package/src/index.ts

@@ -1,11 +1,20 @@
+export { readSessionAttachmentFiles } from "./domain/session-file-access";
+export { verifyDirectModelAccess } from "./domain/direct-model-provider";
 export * from "./domain/skills";
+export * from "./domain/mcp-account-bindings";
+export * from "./domain/mcp-account-routes";
+export * from "./domain/session-connection-accounts";
+export * from "./domain/organization-integration-catalog";
 export * from "./domain/knowledge";
 export * from "./domain/knowledge-search";
-// @opengeni/core — the framework-agnostic OpenGeni core.
+export * from "./domain/voice-input-billing";
+export * from "./domain/web-search-billing";
+export * from "./domain/realtime-voice-billing";
+// @opengeni/core — the framework-agnostic Opengeni core.
 //
-// WHAT THIS PACKAGE IS: the OpenGeni domain, access, and billing layers carved
+// WHAT THIS PACKAGE IS: the Opengeni domain, access, and billing layers carved
 // out of `apps/api` into an importable library, so a host (e.g. cloudgeni) can
-// call the OpenGeni core DIRECTLY, off-HTTP — e.g. `createSessionForRequest(
+// call the Opengeni core DIRECTLY, off-HTTP — e.g. `createSessionForRequest(
 // deps, grant, workspaceId, input)` — without standing up the Hono router.
 // `apps/api` (@opengeni/api-router) and `apps/worker` (@opengeni/worker-bundle)
 // remain the STANDALONE RUNNERS that consume this library; nothing about the
@@ -30,7 +39,11 @@ export * from "./domain/knowledge-search";
 // The central dependency type surface (AppDependencies, ApiRouteDeps,
 // SessionWorkflowClient, DocumentIndexClient, ObjectStorageDependency).
 export * from "./dependencies";
+export * from "./domain/vaults/provider-registry";
+export * from "./domain/vaults/provider-sync";
 export * from "./workflow-wake-contract";
+export * from "./user-presence";
+export * from "./product-usage-metrics";
 
 // Boundary type slots referenced by dependencies.ts. The IMPLEMENTATIONS that
 // construct these (the real sandbox client / Better Auth instance) stay in
@@ -44,6 +57,12 @@ export {
   getManagedAuthRequestActorEpoch,
   getManagedAuthRequestActorLeaseStamp,
   getManagedSession,
+  getNativeAppManagedSession,
+  NATIVE_APP_CREDENTIAL_PREFIX,
+  recordManagedAuthLoggedFailure,
+  withManagedAuthSessionLookup,
+  configureManagedUserAdmission,
+  assertManagedUserAdmission,
   ManagedAuthActorLeaseOutcomeUnknownError,
   markManagedAuthRequestActorTransitionApplied,
   releaseManagedAuthRequestActorLease,
@@ -53,6 +72,10 @@ export {
 } from "./managed-session";
 export * from "./transcription";
 export * from "./model-catalog";
+export * from "./model-provider-credentials";
+export * from "./goal-admission";
+export * from "./codex-model-availability";
+export * from "./default-session-model";
 
 // Sandbox fleet/routing service — the closure of `domain/sessions.ts`
 // (`swapActiveSandbox` + `FleetContext`). apps/api re-imports these for its MCP
@@ -65,40 +88,49 @@ export * from "./sandbox/runtime-settings";
 export * from "./access";
 export * from "./application/external-workspace-members";
 export * from "./application/external-identity-lifecycle";
-export * from "./application/host-mcp-resolvers";
 export * from "./application/external-continuation";
 export * from "./application/session-mcp-credential-rotation";
 export * from "./application/external-link-work-admission";
 export * from "./application/connect-authority";
-export * from "./application/host-mcp-owner";
 export * from "./application/connect-operation";
+export * from "./application/prepared-mcp-connection";
 export * from "./session-authorization";
 
 // Billing / usage-limit admission (checkLimit / requireLimit / recordWorkspaceUsage).
 export * from "./billing/limits";
+export * from "./billing/agent-run-admission";
+export * from "./billing/model-usage-settlement";
+export * from "./billing/model-call-admission";
+export * from "./model-call";
 
 // Domain layer — the off-HTTP V2 surface (createSessionForRequest,
-// postUserMessageTurn, createAndStartSession, capability/pack/environment/
+
 // scheduled-task/workspace-member logic, …).
 export * from "./domain/capabilities";
-export * from "./domain/host-mcp-authority-source-admission";
+export * from "./domain/native-mcp-connection-admission";
 export * from "./domain/skill-imports";
 export * from "./domain/skill-search";
 export * from "./domain/github-skill-source";
-export * from "./domain/environments";
+export * from "./domain/encryption-key";
+export * from "./domain/vaults";
 export * from "./rigs";
-export * from "./domain/packs";
 export * from "./domain/automations";
 export * from "./domain/pr-review";
-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/agent-config-resolution";
 export * from "./domain/scheduled-tasks";
+export * from "./domain/scheduled-task-access";
+export * from "./domain/scheduled-task-account-audit";
+export * from "./domain/scheduled-task-audience";
+export * from "./domain/site-audience";
 export * from "./domain/sessions";
 export * from "./domain/insights";
+export * from "./domain/insights-usage";
 export * from "./domain/memory-slack-publication";
 export * from "./domain/memory-slack-delivery";
 export * from "./domain/governed-learning-slack-publication";
@@ -115,7 +147,10 @@ export * from "./domain/organization-membership-lifecycle";
 export * from "./application/new-session-drafts";
 export * from "./application/composer-submit";
 export * from "./application/session-commands";
+export * from "./application/archived-session-imports";
 export * from "./application/session-tenancy";
+export * from "./application/organization-privacy";
+export * from "./application/sandbox-recovery";
 export * from "./application/user-resource-grants";
 export * from "./application/api-integration-servers";
 
@@ -124,10 +159,39 @@ export * from "./editable-artifact-live";
 
 // Transport-neutral editable-artifact domain service, ports, and contracts.
 export * from "./editable-artifacts";
-export { withSiteSessionOrigin } from "./site-session-origin";
+export {
+  currentSiteSessionOrigin,
+  siteOriginsMatch,
+  siteSessionOriginFromMetadata,
+  withSiteOriginMetadata,
+  withSiteSessionOrigin,
+  type SiteSessionOrigin,
+} from "./site-session-origin";
+export {
+  assertNotSiteClampedAgent,
+  assertSiteAgentMayChooseCompute,
+  SITE_AGENT_COMPUTE_MESSAGE,
+  siteAgentClamp,
+  siteAgentMayReachSession,
+  siteClampedAgentMessage,
+  siteSessionClamp,
+  type SiteAgentClamp,
+  type SiteClampedResource,
+} from "./site-agent-clamp";
+export {
+  currentHostSessionUsageLimit,
+  withHostSessionUsageLimit,
+  type HostSessionUsageLimit,
+} from "./host-session-usage-limit";
+export { resolveTurnSurface } from "./turn-surface";
 
 export { fileOwnerContextForAccess, fileOwnerContextForAgent } from "./domain/file-owner";
 
 export { prepareKnowledgeFile } from "./domain/knowledge-files";
+export { prepareKnowledgeSave } from "./domain/knowledge-preparation";
 
 export { retainKnowledgeMessage } from "./domain/knowledge-messages";
+
+export * from "./domain/connector-tool-permissions";
+export * from "./session-usage-limits";
+export * from "./session-usage-limit-metrics";

package/src/managed-session.ts

@@ -1,6 +1,14 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createHmac } from "node:crypto";
+import { managedUserEmailAllowed } from "@opengeni/config";
 import type { Context } from "hono";
 import type { ManagedAuth } from "./managed-auth-type";
-import type { Database } from "@opengeni/db";
+import {
+  DatabaseUnavailableError,
+  isDatabaseConnectionLoss,
+  isRetryableDatabaseTransportFailure,
+  type Database,
+} from "@opengeni/db";
 import {
   acquireManagedAuthActorMutationLease,
   getManagedAuthAdoptedSessionSnapshot,
@@ -22,6 +30,52 @@ import {
   type ManagedAuthSessionAdapter,
 } from "./managed-auth-session-sets";
 
+/**
+ * Better Auth's session endpoint replaces every non-API failure with a generic
+ * INTERNAL_SERVER_ERROR and passes the original only to its logger. A lookup run
+ * through `withManagedAuthSessionLookup` collects what the logger saw, so a lost
+ * database connection is reported as a retryable outage instead of an opaque 500.
+ */
+const managedAuthLookupFailures = new AsyncLocalStorage<{ errors: unknown[] }>();
+const MANAGED_AUTH_LOOKUP_FAILURE_LIMIT = 8;
+
+/** Better Auth `logger.log` sink; a no-op outside a managed-auth session lookup. */
+export function recordManagedAuthLoggedFailure(args: readonly unknown[]): void {
+  const store = managedAuthLookupFailures.getStore();
+  if (!store) return;
+  for (const value of args) {
+    if (store.errors.length >= MANAGED_AUTH_LOOKUP_FAILURE_LIMIT) return;
+    if (value && typeof value === "object") store.errors.push(value);
+  }
+}
+
+function isBetterAuthInternalServerError(error: unknown): boolean {
+  if (!error || typeof error !== "object") return false;
+  const candidate = error as { status?: unknown; statusCode?: unknown };
+  return candidate.status === "INTERNAL_SERVER_ERROR" || candidate.statusCode === 500;
+}
+
+export async function withManagedAuthSessionLookup<T>(lookup: () => Promise<T>): Promise<T> {
+  const store = { errors: [] as unknown[] };
+  try {
+    return await managedAuthLookupFailures.run(store, lookup);
+  } catch (error) {
+    // Better Auth's session endpoint only reads its database adapter, so a
+    // socket failure it logged is that adapter's connection, not another service.
+    if (
+      isBetterAuthInternalServerError(error) &&
+      store.errors.some(
+        (logged) => isDatabaseConnectionLoss(logged) || isRetryableDatabaseTransportFailure(logged),
+      )
+    ) {
+      throw new DatabaseUnavailableError("managed auth session store unavailable", {
+        cause: error,
+      });
+    }
+    throw error;
+  }
+}
+
 const ACTOR_MUTATION_LEASE_SECONDS = 15 * 60;
 const ACTOR_MUTATION_LEASE_REFRESH_MS = 5 * 60 * 1_000;
 const ACTOR_MUTATION_HANDLER_DEADLINE_MS = 10 * 60 * 1_000;
@@ -68,7 +122,82 @@ const managedActorAdmissionByRequest = new WeakMap<Request, ManagedAuthActorAdmi
  * Programmatic callers must explicitly request and forward the returned cookie
  * headers; the HTTP handler does this automatically, but direct API calls do not.
  */
-export async function getManagedSession(
+const managedUserAllowlists = new WeakMap<ManagedAuth, readonly string[]>();
+
+/** Bind admission to this auth instance, including all session-set modes. */
+export function configureManagedUserAdmission(
+  auth: ManagedAuth,
+  emails: readonly string[] | undefined,
+): void {
+  if (emails === undefined) managedUserAllowlists.delete(auth);
+  else managedUserAllowlists.set(auth, [...emails]);
+}
+
+export async function getManagedSession(...args: Parameters<typeof resolveManagedSession>) {
+  const session = await resolveManagedSession(...args);
+  assertManagedUserAdmission(args[1], session?.user);
+  return session;
+}
+
+/**
+ * Bearer prefix of a native app credential. The credential is a dedicated
+ * Better Auth session the person approved from a signed-in browser (see the
+ * native app sign-in route); the prefix only routes it to this resolver.
+ */
+export const NATIVE_APP_CREDENTIAL_PREFIX = "ogapp_";
+
+/**
+ * Resolve a native app credential exactly as the legacy managed cookie path
+ * resolves a browser session: Better Auth validates expiry and renews the
+ * durable session, then the canonical human session must still be valid. A
+ * native credential never reads or selects a browser session set; each app
+ * account holds its own independently revocable session.
+ */
+export async function getNativeAppManagedSession(
+  auth: ManagedAuth,
+  credential: string,
+  db: Database | undefined,
+) {
+  if (!credential.startsWith(NATIVE_APP_CREDENTIAL_PREFIX)) return null;
+  const token = credential.slice(NATIVE_APP_CREDENTIAL_PREFIX.length);
+  if (!/^[A-Za-z0-9]{16,128}$/u.test(token)) return null;
+  const context = await auth.$context;
+  const signed = encodeURIComponent(
+    `${token}.${createHmac("sha256", context.secret).update(token, "utf8").digest("base64")}`,
+  );
+  const session = await withManagedAuthSessionLookup(() =>
+    auth.api.getSession({
+      headers: new Headers({ cookie: `${context.authCookies.sessionToken.name}=${signed}` }),
+      // Never serve a cached cookie snapshot: the app's session row is authoritative.
+      query: { disableCookieCache: true },
+    }),
+  );
+  if (!session?.user) return null;
+  assertManagedUserAdmission(auth, session.user);
+  if (!db) return session;
+  const authSessionId = session.session?.id;
+  if (typeof authSessionId !== "string") return null;
+  const valid = await validateCanonicalHumanSession(db, {
+    authSessionId,
+    authUserId: session.user.id,
+  });
+  return valid ? session : null;
+}
+
+export function assertManagedUserAdmission(
+  auth: ManagedAuth,
+  user: { email: string; emailVerified: boolean } | null | undefined,
+): void {
+  const emails = managedUserAllowlists.get(auth);
+  if (
+    user &&
+    emails !== undefined &&
+    (!user.emailVerified || !managedUserEmailAllowed(emails, user.email))
+  )
+    throw new HTTPException(403, { message: "Account is not permitted on this deployment" });
+}
+
+async function resolveManagedSession(
   c: Context,
   auth: ManagedAuth,
   options?: {
@@ -229,10 +358,12 @@ export async function getManagedSession(
         throw error;
       }
   }
-  const result = await auth.api.getSession({
-    headers: c.req.raw.headers,
-    returnHeaders: true,
-  });
+  const result = await withManagedAuthSessionLookup(() =>
+    auth.api.getSession({
+      headers: c.req.raw.headers,
+      returnHeaders: true,
+    }),
+  );
 
   for (const cookie of setCookieHeaders(result.headers)) {
     c.header("set-cookie", cookie, { append: true });

package/src/model-call.ts

@@ -0,0 +1,79 @@
+import type { AccessGrant } from "@opengeni/contracts";
+import type { SingleModelCallRequest, SingleModelCallResult } from "@opengeni/runtime";
+
+/**
+ * Stateless single model calls: one request to one workspace model with no
+ * tools, no agent loop and no session. The public chat completions endpoint
+ * is the transport; agentic work uses sessions. The host-owned service picks
+ * the model, credential and subscription account exactly as a turn would,
+ * admits the call against the same funding rules and settles actual usage.
+ */
+
+export type ModelCallCaller = {
+  grant: AccessGrant;
+  accountId: string;
+  workspaceId: string;
+  /** The authenticated subject whose model and subscription authority apply. */
+  subjectId: string;
+};
+
+export type ModelCallInput = ModelCallCaller & {
+  /** Product model id or alias; null selects the workspace default model. */
+  model: string | null;
+  request: Omit<SingleModelCallRequest, "signal">;
+  /** Server-generated identity; the settlement idempotency key derives from it. */
+  requestId: string;
+  signal?: AbortSignal;
+  onTextDelta?: (delta: string) => void | Promise<void>;
+};
+
+export type ModelCallOutput = {
+  /** Canonical product model id that served the call. */
+  model: string;
+  result: SingleModelCallResult;
+};
+
+export type ModelCallModel = {
+  id: string;
+  label: string;
+  providerLabel: string;
+};
+
+export interface ModelCallService {
+  /** Models the caller may use for a single call, in catalog order. */
+  listModels(caller: ModelCallCaller): Promise<ModelCallModel[]>;
+  call(input: ModelCallInput): Promise<ModelCallOutput>;
+}
+
+export type ModelCallErrorType =
+  | "invalid_request_error"
+  | "not_found_error"
+  | "insufficient_quota"
+  | "rate_limit_error"
+  | "api_error"
+  | "service_unavailable";
+
+/**
+ * A refusal or failure with a public status and an OpenAI-style error type.
+ * Messages are safe to return to the caller.
+ */
+export class ModelCallError extends Error {
+  readonly status: number;
+  readonly type: ModelCallErrorType;
+  readonly code: string | null;
+  readonly param: string | null;
+  constructor(input: {
+    status: number;
+    type: ModelCallErrorType;
+    message: string;
+    code?: string | null;
+    param?: string | null;
+  }) {
+    super(input.message);
+    this.name = "ModelCallError";
+    this.status = input.status;
+    this.type = input.type;
+    this.code = input.code ?? null;
+    this.param = input.param ?? null;
+  }
+}