@opengeni/worker-bundle 1.0.0-canary.0 → 1.0.0

package/src/activities/run-credentials.ts

@@ -5,12 +5,16 @@ import type {
   RunCredentialsRequest,
   Session,
   SessionTurn,
+  ToolRef,
 } from "@opengeni/contracts";
+import type { Settings } from "@opengeni/config";
 import { getSessionRootId, type Database } from "@opengeni/db";
 import {
   normalizeRunCredentialsResolution,
+  selectedSessionRemoteMcpTargets,
   type NormalizedRunCredentialMaterial,
 } from "@opengeni/runtime";
+import { workspaceCredentialProviderResolver } from "./workspace-credential-provider";
 
 export type RunCredentialResolutionContext = {
   db: Database;
@@ -18,10 +22,17 @@ export type RunCredentialResolutionContext = {
   accountId: string;
   workspaceId: string;
   session: Session;
-  turn: SessionTurn;
+  turn: SessionTurn & { initiatingHumanSubjectId?: string | null };
   attemptId: string;
   effectiveSandboxBackend: SandboxBackend;
   variableSet: { id: string; name: string } | null;
+  /** Enables the workspace's configured HTTP credential provider. */
+  settings?: Settings;
+  initiatingHumanSubjectId?: string | null;
+  /** Installed in-process API routes must never enter a product callback. */
+  localMcpServerIds?: readonly string[];
+  /** Exact execution selection, resolved once at the turn policy boundary. */
+  effectiveTools: readonly ToolRef[];
 };
 
 export type BoundRunCredentialResolver = {
@@ -32,7 +43,10 @@ export type BoundRunCredentialResolver = {
 };
 
 export function buildRunCredentialsRequest(
-  input: Omit<RunCredentialResolutionContext, "db" | "connectionCredentials"> & {
+  input: Omit<
+    RunCredentialResolutionContext,
+    "db" | "connectionCredentials" | "settings" | "initiatingHumanSubjectId" | "effectiveTools"
+  > & {
     rootSessionId: string;
     purpose: "provision" | "renewal";
     forceRefresh: boolean;
@@ -95,11 +109,36 @@ export function runCredentialModelNote(
  * Freeze the provider-neutral host credential request to this exact admitted
  * turn. The host selects connections and material; the worker never infers a
  * provider from repositories, environment names, or an OpenGeni variable set.
+ * A workspace that configured its own HTTP credential provider uses it in
+ * place of the deployment's injected port.
  */
 export async function bindRunCredentialResolver(
   input: RunCredentialResolutionContext,
 ): Promise<BoundRunCredentialResolver | null> {
-  const resolver = input.connectionCredentials?.runCredentials;
+  // Connected Machines own their credentials. Even provider lookup/callback
+  // must not be performed for a turn executing on the user's machine.
+  if (input.effectiveSandboxBackend === "selfhosted") return null;
+  const workspaceResolver = input.settings
+    ? await workspaceCredentialProviderResolver(
+        input.db,
+        input.settings,
+        { accountId: input.accountId, workspaceId: input.workspaceId },
+        input.turn.initiatingHumanSubjectId ?? null,
+        {
+          mcpServers: selectedSessionRemoteMcpTargets(
+            input.settings,
+            input.session.mcpServers ?? [],
+            input.effectiveTools,
+            (input.localMcpServerIds ?? []).map((id) => ({ id })),
+          ),
+        },
+      )
+    : null;
+  const resolver =
+    workspaceResolver ??
+    (input.effectiveSandboxBackend === "none"
+      ? undefined
+      : input.connectionCredentials?.runCredentials);
   if (!resolver) return null;
   const rootSessionId = await getSessionRootId(input.db, input.workspaceId, input.session.id);
   if (!rootSessionId) {
@@ -110,22 +149,25 @@ export async function bindRunCredentialResolver(
     workspaceId: input.workspaceId,
     sessionId: input.session.id,
   };
+  // A renewable resolver belongs to one admitted turn, even if its caller
+  // subsequently replaces or mutates an in-memory session/turn projection.
+  const frozenRequest = structuredClone(
+    buildRunCredentialsRequest({
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      session: input.session,
+      turn: input.turn,
+      attemptId: input.attemptId,
+      effectiveSandboxBackend: input.effectiveSandboxBackend,
+      variableSet: input.variableSet,
+      rootSessionId,
+      purpose: "provision",
+      forceRefresh: false,
+    }),
+  );
   return {
     resolve: async ({ purpose, forceRefresh }) => {
-      const resolution = await resolver(
-        buildRunCredentialsRequest({
-          accountId: input.accountId,
-          workspaceId: input.workspaceId,
-          session: input.session,
-          turn: input.turn,
-          attemptId: input.attemptId,
-          effectiveSandboxBackend: input.effectiveSandboxBackend,
-          variableSet: input.variableSet,
-          rootSessionId,
-          purpose,
-          forceRefresh,
-        }),
-      );
+      const resolution = await resolver({ ...frozenRequest, purpose, forceRefresh });
       return normalizeRunCredentialsResolution(resolution, scope);
     },
   };

package/src/activities/run-input.ts

@@ -304,19 +304,13 @@ function attachmentRefsFromItem(item: Record<string, unknown>): FileResourceRef[
   return refs;
 }
 
-function attachmentReceiptText(ref: FileResourceRef, file: FileAsset | undefined): string {
-  if (!file) {
-    return (
-      `[Earlier attachment: fileId=${ref.fileId}; mountDirectory=${resourceMountPath(ref)}. ` +
-      `Use the existing file there, or call files__files_get_download_url with this fileId and ` +
-      `download it with the shell.]`
-    );
-  }
-  const path = sandboxFilePath(ref, file);
+function attachmentReceiptText(ref: FileResourceRef): string {
+  // The durable reference is immutable; live metadata/authority must not rewrite
+  // old receipt text. Pixel delivery remains subject to current file authority.
   return (
-    `[Attachment: ${file.safeFilename}; fileId=${file.id}; type=${file.contentType}; ` +
-    `bytes=${file.sizeBytes}; path=${path}. If the local path is absent, call ` +
-    `files__files_get_download_url with this fileId and download it with the shell.]`
+    `[Attachment: fileId=${ref.fileId}; mountDirectory=${resourceMountPath(ref)}. ` +
+    `Use the existing file there, or call files__files_get_download_url with this fileId and ` +
+    `download it with the shell.]`
   );
 }
 
@@ -434,7 +428,7 @@ export function createModelHistoryAttachmentProjector(
         const attachment = currentFile ? contentById.get(ref.fileId) : undefined;
         const receipt = {
           type: "input_text",
-          text: attachmentReceiptText(ref, currentFile),
+          text: attachmentReceiptText(ref),
         };
         if (!attachment || attachment.kind !== "image") {
           return [receipt];
@@ -458,12 +452,21 @@ export function withCurrentUserAttachmentRefs(
   refs: FileResourceRef[],
 ): Array<Record<string, unknown>> {
   if (refs.length === 0) return historyItems;
+  // Compaction can put a catalog after the triggering user message. A ref
+  // already retained anywhere in canonical history must not be copied onto
+  // that older catalog (and then disappear when the next turn replays it).
+  const retainedIds = new Set(
+    historyItems.flatMap((item) => attachmentRefsFromItem(item).map((ref) => ref.fileId)),
+  );
+  const missing = refs.filter((ref) => !retainedIds.has(ref.fileId));
+  if (missing.length === 0) return historyItems;
   for (let index = historyItems.length - 1; index >= 0; index -= 1) {
     const item = historyItems[index]!;
+    if (item[MODEL_ATTACHMENT_CATALOG_MARKER] === true) continue;
     if (item.type !== "message" || item.role !== "user") continue;
     const existing = attachmentRefsFromItem(item);
     const existingIds = new Set(existing.map((ref) => ref.fileId));
-    const additions = refs.filter((ref) => !existingIds.has(ref.fileId));
+    const additions = missing.filter((ref) => !existingIds.has(ref.fileId));
     if (additions.length === 0) return historyItems;
     const projected = [...historyItems];
     projected[index] = { ...item, [MODEL_ATTACHMENT_REFS_FIELD]: [...existing, ...additions] };
@@ -552,8 +555,14 @@ export async function turnInput(
       options,
     );
   }
-  if (trigger.type === "system.update.delivered") {
-    if (updates.length === 0) {
+  // Maintenance has no user message or delivered-update batch. It still needs
+  // the ordinary history/projection path so SDK preparation can capture the
+  // same model request prefix before the queued compaction stops inference.
+  if (
+    trigger.type === "system.update.delivered" ||
+    trigger.type === "session.context.compaction.requested"
+  ) {
+    if (trigger.type === "system.update.delivered" && updates.length === 0) {
       throw new Error("Internal update inference has no delivered updates");
     }
     return await messageInput(

package/src/activities/sandbox-images.ts

@@ -1,7 +1,6 @@
 export {
   resolveRigProviderImageSelection,
   rigProviderImageSourceImage,
-  settingsWithPackSandboxImage,
   settingsWithRigImage,
   settingsWithRigProviderImage,
   type RigProviderImageSelectionReason,