@opengeni/core 4.0.0 → 4.0.1

package/dist/sandbox/fleet.d.ts

@@ -68,7 +68,7 @@ export type FleetSandboxEntry = {
     /** The sandbox id used as the attach/swap/run_on `target`. For the session's
      *  own group box this is the group id (a null active pointer == this box). */
     id: string;
-    kind: "modal" | "selfhosted" | "opensandbox";
+    kind: Exclude<SandboxBackend, "none">;
     name: string;
     liveness: FleetLiveness;
     /** True for the session's currently-active sandbox (the routing target). */

package/dist/sandbox/runtime-settings.d.ts

@@ -14,6 +14,13 @@ export type ManagedSessionGroupBackend = Exclude<SandboxBackend, "none" | "selfh
  * fallback to expose.
  */
 export declare function managedSessionGroupBackend(deploymentBackend: SandboxBackend, sessionBackend: SandboxBackend): ManagedSessionGroupBackend | null;
+/** Display name and kind for the session's own managed box. The kind is the
+ * real provider. Callers must not collapse local, Docker, or other providers
+ * into Modal. */
+export declare function sessionGroupMachinePresentation(backend: ManagedSessionGroupBackend): {
+    name: string;
+    kind: ManagedSessionGroupBackend;
+};
 /** A machine-home row carries the machine's host OS; its managed group uses the
  * platform's canonical managed-sandbox OS instead. Ordinary sessions preserve
  * their explicitly selected OS. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/core",
-  "version": "4.0.0",
+  "version": "4.0.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": {
@@ -51,16 +51,16 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@opengeni/capabilities": "^0.3.4",
-    "@opengeni/codex": "^0.2.24",
-    "@opengeni/config": "^2.0.0",
-    "@opengeni/contracts": "^5.0.0",
-    "@opengeni/db": "^6.0.0",
-    "@opengeni/documents": "^0.8.31",
-    "@opengeni/events": "^0.4.29",
+    "@opengeni/codex": "^0.2.25",
+    "@opengeni/config": "^2.1.0",
+    "@opengeni/contracts": "^5.1.0",
+    "@opengeni/db": "^6.0.1",
+    "@opengeni/documents": "^0.8.32",
+    "@opengeni/events": "^0.4.30",
     "@opengeni/network": "^0.3.1",
-    "@opengeni/observability": "^0.8.30",
-    "@opengeni/runtime": "^4.0.0",
-    "@opengeni/storage": "^0.2.131",
+    "@opengeni/observability": "^0.8.31",
+    "@opengeni/runtime": "^4.0.1",
+    "@opengeni/storage": "^0.2.132",
     "hono": "^4.12.18",
     "zod": "^4.2.1"
   },

package/src/application/new-session-drafts.ts

@@ -19,6 +19,7 @@ import {
   publicNewSessionDraftOptions,
   requireFileForSubject,
   saveNewSessionDraftInTransaction,
+  reusableNewSessionRepositoryResource,
   withWorkspaceSubjectRls,
 } from "@opengeni/db";
 import { HTTPException } from "hono/http-exception";
@@ -333,3 +334,44 @@ export async function saveActorNewSessionDraft(
     : { subjectId: grant.subjectId, privateFileOwnerSubjectId: null };
   return withSessionRlsActorContext(actor, () => saveActorNewSessionDraftInFileScope(...args));
 }
+
+/** Reuse the website's actor/workspace selections without consuming its draft. */
+export async function getActorNewSessionDefaults(
+  deps: Parameters<typeof getActorNewSessionDraft>[0],
+  grant: AccessGrant,
+  workspaceId: string,
+) {
+  const draft = await getActorNewSessionDraft(deps, grant, workspaceId);
+  const options = draft.options;
+  return {
+    // Revision zero is a synthetic empty form, not a user's model preference.
+    ...(draft.revision > 0
+      ? {
+          model: draft.model,
+          reasoningEffort: draft.reasoningEffort,
+          latencyMode: draft.latencyMode,
+        }
+      : {}),
+    resources: draft.resources.flatMap((resource) =>
+      resource.kind === "repository" ? [reusableNewSessionRepositoryResource(resource)] : [],
+    ),
+    ...(draft.toolsProvided
+      ? { tools: draft.tools }
+      : options.excludedMcpServerIds
+        ? { excludedMcpServerIds: options.excludedMcpServerIds }
+        : {}),
+    ...(options.firstPartyMcpTools ? { firstPartyMcpTools: options.firstPartyMcpTools } : {}),
+    ...(options.firstPartyMcpPermissions
+      ? { firstPartyMcpPermissions: options.firstPartyMcpPermissions }
+      : {}),
+    ...(options.variableSetIds ? { variableSetIds: options.variableSetIds } : {}),
+    ...(options.rigId ? { rigId: options.rigId } : {}),
+    ...(options.sandboxBackend ? { sandboxBackend: options.sandboxBackend } : {}),
+    ...(options.targetSandboxId
+      ? {
+          targetSandboxId: options.targetSandboxId,
+          ...(options.workingDir ? { workingDir: options.workingDir } : {}),
+        }
+      : {}),
+  };
+}

package/src/domain/github-skill-source.ts

@@ -4,6 +4,7 @@ import type { GitHubSkillSourceClient, GitHubSkillTreeEntry } from "./skill-impo
 import { pinnedFetch, readResponseJsonBounded, readResponseTextBounded } from "@opengeni/network";
 import {
   PORTABLE_SKILL_MAX_FILES,
+  PORTABLE_SKILL_MAX_FILE_BYTES,
   PORTABLE_SKILL_MAX_TOTAL_BYTES,
   type SkillLibraryFile,
 } from "@opengeni/runtime/skill-library";
@@ -11,7 +12,8 @@ import {
 const githubApiBase = "https://api.github.com";
 const githubRequestTimeoutMs = 15_000;
 const githubMetadataMaxBytes = 4 * 1024 * 1024;
-const githubBlobResponseMaxBytes = 512 * 1024;
+// GitHub blobs are base64-encoded JSON; allow framing and line wrapping.
+const githubBlobResponseMaxBytes = PORTABLE_SKILL_MAX_FILE_BYTES * 2;
 
 type GitHubJsonRequest = (path: string, maxBytes: number, label: string) => Promise<unknown>;
 

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

@@ -188,9 +188,25 @@ export async function workspaceSessionToolPolicyDefaultServerIds(
   const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(db, workspaceId, settings, {
     ...(subjectId ? { subjectId } : {}),
   });
-  const availableDefaults = defaultSessionMcpServerIds(runtimeSettings.mcpServers);
   const workspace = await requireWorkspace(db, workspaceId);
-  const configured = resolveWorkspaceSessionToolDefaults(workspace.settings);
+  return workspaceSessionToolPolicyDefaultServerIdsFor(
+    runtimeSettings.mcpServers,
+    workspace.settings,
+  );
+}
+
+/**
+ * The omitted-tools default for one resolved runtime registry and one
+ * workspace settings bag. Pure so a caller that already holds both never has
+ * to re-query the capability registry to agree with the worker and the
+ * composer on which connectors a `workspace_default` session executes with.
+ */
+export function workspaceSessionToolPolicyDefaultServerIdsFor(
+  runtimeMcpServers: Iterable<{ id: string }>,
+  workspaceSettings: unknown,
+): string[] {
+  const availableDefaults = defaultSessionMcpServerIds(runtimeMcpServers);
+  const configured = resolveWorkspaceSessionToolDefaults(workspaceSettings);
   if (!configured?.mcpServerIds) return availableDefaults;
   const available = new Set(availableDefaults);
   return sortedIds([

package/src/domain/sessions.ts

@@ -16,6 +16,7 @@ import { sessionCreationMetadata } from "../site-session-origin";
 import {
   canonicalizeConfiguredModelId,
   configuredAllowedModels,
+  withCodexCatalogProvider,
   ORGANIZATION_GATEWAY_MODEL_ID_PREFIX,
   ORGANIZATION_OPENROUTER_MODEL_ID_PREFIX,
   resolveFirstPartyMcpToolPolicy,
@@ -181,6 +182,10 @@ import {
   workspaceCustomModelReference,
 } from "../model-catalog";
 import { settingsWithEnabledCapabilityMcpServers } from "./capabilities";
+import {
+  resolveSessionToolPolicy,
+  workspaceSessionToolPolicyDefaultServerIdsFor,
+} from "./session-tool-policy";
 import { validateSubmittedTimelineAnnotations } from "./timeline-annotations";
 import { requireVariableSetEncryption, validateVariableSetAttachment } from "./environments";
 import {
@@ -1420,6 +1425,18 @@ export function canonicalConfiguredModel(
     return model;
   }
   const canonicalModel = canonicalizeConfiguredModelId(settings, model);
+  if (
+    canonicalModel.startsWith(CODEX_MODEL_ID_PREFIX) &&
+    settings.resolvedCodexModelsJson !== undefined
+  ) {
+    if (
+      settings.codexSubscriptionEnabled &&
+      configuredAllowedModels(withCodexCatalogProvider(settings)).includes(canonicalModel)
+    ) {
+      return canonicalModel;
+    }
+    throw new HTTPException(422, { message: `model is not available: ${model}` });
+  }
   if (configuredAllowedModels(settings).includes(canonicalModel)) {
     return canonicalModel;
   }
@@ -3724,25 +3741,39 @@ async function acceptSessionUserMessageInFileScope(
             connectionDelegationSource.turnId,
           )
         : null;
+    const capabilityRuntimeSettings = await settingsWithEnabledCapabilityMcpServers(
+      db,
+      workspaceId,
+      settings,
+      inheritedPersonalConnectionDelegations
+        ? {
+            personalConnectionDelegations: inheritedPersonalConnectionDelegations,
+          }
+        : { subjectId: grant.subjectId },
+    );
     const runtimeSettings = settingsWithSessionMcpServerMetadata(
-      await settingsWithEnabledCapabilityMcpServers(
-        db,
-        workspaceId,
-        settings,
-        inheritedPersonalConnectionDelegations
-          ? {
-              personalConnectionDelegations: inheritedPersonalConnectionDelegations,
-            }
-          : { subjectId: grant.subjectId },
-      ),
+      capabilityRuntimeSettings,
       existingSession.mcpServers,
     );
+    // A `workspace_default` session stores only its creation-time tool
+    // snapshot and resolves the current workspace defaults at run time, so the
+    // raw column is not the connector allow-list this follow-up executes with.
+    // Freeze accounts against the same resolved list the composer and the
+    // worker see.
+    const connectionAccountTools = sessionToolsForConnectionAccounts({
+      session: existingSession,
+      runtimeMcpServers: runtimeSettings.mcpServers,
+      defaultMcpServerIds: workspaceSessionToolPolicyDefaultServerIdsFor(
+        capabilityRuntimeSettings.mcpServers,
+        (await requireWorkspace(db, workspaceId)).settings,
+      ),
+    });
     const { personalConnectionDelegations, mcpAccountBindings } = await freezeConnectionAccounts({
       db,
       accountId: grant.accountId,
       workspaceId,
       settings: runtimeSettings,
-      tools: existingSession.tools,
+      tools: connectionAccountTools,
       resources: [...existingSession.resources, ...requestedResources],
       source: connectionDelegationSource,
       targetSessionId: sessionId,
@@ -4411,6 +4442,34 @@ function withFirstPartyTools(
   return mergeToolRefs(tools, [{ kind: "mcp", id: "opengeni" }]);
 }
 
+/**
+ * The executable MCP tool list a follow-up on an existing session freezes
+ * connector accounts against.
+ *
+ * A `workspace_default` session stores only the tool snapshot taken when it
+ * was created and expands the current workspace defaults at run time, so a
+ * connector enabled after creation never enters the stored column. The
+ * composer projects that same expansion and submits account selections for
+ * it, so freezing against the stored column rejected every such selection as
+ * unmatched and never froze its personal delegation. Resolve through the one
+ * ID-only policy resolver the API projection and the worker use, with the
+ * same omitted-tools default, so all three agree on the executable set.
+ */
+export function sessionToolsForConnectionAccounts(input: {
+  session: Pick<Session, "tools" | "toolPolicy">;
+  /** The resolved runtime registry, including session-local servers. */
+  runtimeMcpServers: Iterable<{ id: string }>;
+  /** The current omitted-tools default for this workspace. */
+  defaultMcpServerIds: Iterable<string>;
+}): ToolRef[] {
+  return resolveSessionToolPolicy({
+    toolPolicy: input.session.toolPolicy,
+    sessionTools: input.session.tools,
+    availableMcpServerIds: [...input.runtimeMcpServers].map((server) => server.id),
+    defaultMcpServerIds: input.defaultMcpServerIds,
+  }).toolRefs;
+}
+
 function hasOwnProperty(value: unknown, key: string): boolean {
   return Boolean(
     value && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, key),

package/src/model-catalog.ts

@@ -4,6 +4,7 @@ import {
   configuredGatewayWorkspaceProductModelIds,
   configuredGatewayOrganizationProductModelIds,
   configuredModels,
+  isModelAvailableForNewSelection,
   configuredModelNotes,
   configuredOpenRouterWorkspaceProductModelIds,
   configuredOpenRouterOrganizationProductModelIds,
@@ -708,38 +709,41 @@ export function resolveWorkspaceModelSelection(
       ? input.credentialReadinessMaxAgeMs
       : MODEL_CREDENTIAL_READINESS_OBSERVATION_MAX_AGE_MS;
 
-  return configuredModels(catalogSettings).map((model) => {
-    const provider = providers.get(model.providerId);
-    const policyAllowed =
-      evaluateWorkspaceModelPolicy(input.policy, {
-        providerId: model.providerId,
-        modelId: model.id,
-      }).allowed && modelAllowedByConnections(input.connectionModelRestrictions ?? {}, model.id);
-    const credentialReadiness = credentialReadinessFor({
-      model,
-      provider,
-      codexSubscriptionActive: input.codexSubscriptionActive,
-      xaiSubscriptionActive: input.xaiSubscriptionActive === true,
-      workspaceGatewayConnectionActive: input.workspaceGatewayConnectionActive === true,
-      workspaceOpenRouterConnectionActive: input.workspaceOpenRouterConnectionActive === true,
-      organizationGatewayConnectionActive: input.organizationGatewayConnectionActive === true,
-      organizationOpenRouterConnectionActive: input.organizationOpenRouterConnectionActive === true,
-      observation: input.credentialReadinessObservations?.[model.definitionVersion],
-      nowMs,
-      maxAgeMs,
-    });
-    return {
-      model,
-      credentialReadiness,
-      policyAllowed,
-      availability: availabilityFor({
+  return configuredModels(catalogSettings)
+    .filter((model) => isModelAvailableForNewSelection(catalogSettings, model.id))
+    .map((model) => {
+      const provider = providers.get(model.providerId);
+      const policyAllowed =
+        evaluateWorkspaceModelPolicy(input.policy, {
+          providerId: model.providerId,
+          modelId: model.id,
+        }).allowed && modelAllowedByConnections(input.connectionModelRestrictions ?? {}, model.id);
+      const credentialReadiness = credentialReadinessFor({
         model,
-        credentialReadiness,
-        policyAllowed,
-        observation: input.observations?.[model.definitionVersion],
+        provider,
+        codexSubscriptionActive: input.codexSubscriptionActive,
+        xaiSubscriptionActive: input.xaiSubscriptionActive === true,
+        workspaceGatewayConnectionActive: input.workspaceGatewayConnectionActive === true,
+        workspaceOpenRouterConnectionActive: input.workspaceOpenRouterConnectionActive === true,
+        organizationGatewayConnectionActive: input.organizationGatewayConnectionActive === true,
+        organizationOpenRouterConnectionActive:
+          input.organizationOpenRouterConnectionActive === true,
+        observation: input.credentialReadinessObservations?.[model.definitionVersion],
         nowMs,
         maxAgeMs,
-      }),
-    };
-  });
+      });
+      return {
+        model,
+        credentialReadiness,
+        policyAllowed,
+        availability: availabilityFor({
+          model,
+          credentialReadiness,
+          policyAllowed,
+          observation: input.observations?.[model.definitionVersion],
+          nowMs,
+          maxAgeMs,
+        }),
+      };
+    });
 }

package/src/sandbox/fleet.ts

@@ -46,7 +46,7 @@ import {
   type SelfhostedOperationResourcePolicy,
 } from "@opengeni/runtime/sandbox";
 import { relayConfigFromSettings } from "./routing";
-import { managedSessionGroupBackend } from "./runtime-settings";
+import { managedSessionGroupBackend, sessionGroupMachinePresentation } from "./runtime-settings";
 
 export type FleetServices = {
   db: Database;
@@ -130,7 +130,7 @@ export type FleetSandboxEntry = {
   /** The sandbox id used as the attach/swap/run_on `target`. For the session's
    *  own group box this is the group id (a null active pointer == this box). */
   id: string;
-  kind: "modal" | "selfhosted" | "opensandbox";
+  kind: Exclude<SandboxBackend, "none">;
   name: string;
   liveness: FleetLiveness;
   /** True for the session's currently-active sandbox (the routing target). */
@@ -325,10 +325,11 @@ export async function listFleet(
         : groupRecovering
           ? "recovering"
           : "wakeable";
+    const presentation = sessionGroupMachinePresentation(groupBackend);
     entries.push({
       id: ctx.sessionGroupId,
-      kind: groupBackend === "opensandbox" ? "opensandbox" : "modal",
-      name: "session sandbox",
+      kind: presentation.kind,
+      name: presentation.name,
       liveness: groupOnline ? "online" : groupRecovering ? "reconnecting" : "offline",
       active: groupActive,
       isSessionGroup: true,

package/src/sandbox/runtime-settings.ts

@@ -34,6 +34,29 @@ export function managedSessionGroupBackend(
   return backend === "none" || backend === "selfhosted" ? null : backend;
 }
 
+const SESSION_GROUP_MACHINE_NAMES: Record<ManagedSessionGroupBackend, string> = {
+  local: "this computer",
+  docker: "Docker",
+  modal: "Modal",
+  daytona: "Daytona",
+  runloop: "Runloop",
+  e2b: "E2B",
+  blaxel: "Blaxel",
+  cloudflare: "Cloudflare",
+  vercel: "Vercel",
+  opensandbox: "OpenSandbox",
+};
+
+/** Display name and kind for the session's own managed box. The kind is the
+ * real provider. Callers must not collapse local, Docker, or other providers
+ * into Modal. */
+export function sessionGroupMachinePresentation(backend: ManagedSessionGroupBackend): {
+  name: string;
+  kind: ManagedSessionGroupBackend;
+} {
+  return { name: SESSION_GROUP_MACHINE_NAMES[backend], kind: backend };
+}
+
 /** A machine-home row carries the machine's host OS; its managed group uses the
  * platform's canonical managed-sandbox OS instead. Ordinary sessions preserve
  * their explicitly selected OS. */