@opengeni/worker-bundle 0.27.0-canary.0 → 0.27.2-canary.0

package/src/activities/agent-turn/tool-environment.ts

@@ -1,6 +1,8 @@
 import { getWorkspaceConnectionModelRestrictions } from "@opengeni/db";
 import {
   beginConnectorActionExecution,
+  getWorkspaceVideoGenerationPolicy,
+  listSkillDescriptors,
   completeConnectorActionExecution,
   getScheduledVariableSetExpectedGenerationForAttempt,
   getWorkspaceModelPolicy,
@@ -86,6 +88,10 @@ import {
 } from "./session-title";
 import { resolveTurnSandboxAccess } from "./turn-sandbox-access";
 import { createListModelsAttemptToolDefinition } from "./list-models";
+import { createWorkspaceSkillTools } from "./skill-tools";
+import { loadConfiguredBundledSkills } from "./skill-selection";
+import { guardSkillFilesystem } from "./skill-transfer";
+import type { RuntimeSkillActivation } from "@opengeni/runtime";
 
 export type PrepareTurnToolPolicyDeps = {
   input: RunAgentTurnInput;
@@ -102,6 +108,7 @@ export type PrepareTurnToolPolicyDeps = {
 };
 
 export type PrepareTurnToolRuntimeDeps = {
+  selectedSkillActivations: readonly RuntimeSkillActivation[];
   input: RunAgentTurnInput;
   catalogSourceSettings: Settings;
   db: ActivityServices["db"];
@@ -555,7 +562,88 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
         outcome,
       }),
   };
+  const skillConfiguration = await getWorkspaceVideoGenerationPolicy(db, input.workspaceId);
+  const bundledSkills = loadConfiguredBundledSkills({
+    bundledSkillIds: session.bundledSkillIds,
+    firstPartyTools: selectedFirstPartyMcpTools,
+    videoGenerationEnabled:
+      skillConfiguration.defaultModelId !== null && skillConfiguration.enabledModelIds.length > 0,
+  });
+  const selectedSkills = [
+    ...bundledSkills,
+    ...deps.selectedSkillActivations.map((entry) => ({ id: entry.id, artifact: entry.artifact })),
+    ...session.skills.map((skill) => ({
+      id: `session:${session.id}:${skill.name}`,
+      artifact: skill,
+    })),
+  ];
+  const sharedSkillDescriptors = await listSkillDescriptors(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    ...(deps.fileAuthoritySubjectId ? { subjectId: deps.fileAuthoritySubjectId } : {}),
+  });
+  const skillCatalog = [
+    ...sharedSkillDescriptors
+      .filter((entry) => entry.activationMode === "workspace_managed")
+      .map((entry) => ({
+        id: entry.id,
+        name: entry.title,
+        description: entry.description,
+      })),
+    ...selectedSkills.map((entry) => ({
+      id: entry.id,
+      name: entry.artifact.name,
+      description: entry.artifact.description || entry.artifact.name,
+    })),
+  ];
+  const skillTools = createWorkspaceSkillTools({
+    db,
+    settings: runSettings,
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    ...(deps.fileAuthoritySubjectId ? { subjectId: deps.fileAuthoritySubjectId } : {}),
+    actor: {
+      kind: "agent",
+      sessionId: input.sessionId,
+      turnId: turn.id,
+      attemptId: input.attemptId,
+      executionGeneration: attempt.executionGeneration,
+    },
+    selected: selectedSkills,
+    filesystem: async () => {
+      throwIfWorkerShuttingDown();
+      throwIfTurnCancelled();
+      const access = await resolveTurnSandboxAccess(
+        sandboxState,
+        media.sdkOwnedSandboxSession,
+        "Skill checkout/publish requires a sandbox or Connected Machine.",
+      );
+      const machineRoot = sandboxState.machinePrimarySession?.workspaceRoot;
+      const runAs = sandboxRunAs(runSettings);
+      const channel = new SandboxChannelAService({
+        session: access.session,
+        workspaceRoot: machineRoot ?? "/workspace",
+        ...(machineRoot ? { providerPathMode: "workspace-relative" as const } : {}),
+        leaseEpoch: access.leaseEpoch,
+        emit: async (events) => {
+          await eventing.publish?.(events, true);
+        },
+        ...(runAs ? { runAs } : {}),
+      });
+      return guardSkillFilesystem(channel, {
+        assertActive: () => {
+          throwIfWorkerShuttingDown();
+          throwIfTurnCancelled();
+        },
+        runMutation: async (mutation) =>
+          access.sandbox && !routingOn
+            ? runWorkspaceMutationForSandbox(access.sandbox, "skillCheckout", mutation)
+            : mutation(),
+      });
+    },
+  });
   const attemptToolDefinitions = [
+    ...skillTools,
     createListModelsAttemptToolDefinition({
       currentModelId: turnExecutionPolicy.productModelId,
       load: async () => {
@@ -881,7 +969,11 @@ export async function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps) {
     connectorActionPolicy,
     generateSessionTitleInParallel: titleToolPlan.generateTitleInParallel,
     postToolPreparationStartedAt,
-    preparationIndependentToolNames: titleToolPlan.preparationIndependentToolNames,
+    preparationIndependentToolNames: [
+      ...titleToolPlan.preparationIndependentToolNames,
+      "skill_read",
+    ],
+    skillCatalog,
   };
 }
 

package/src/activities/automations.ts

@@ -17,6 +17,7 @@ import {
   claimAutomationRun,
   settleAutomationRun,
 } from "@opengeni/db";
+import { SessionSkills } from "@opengeni/contracts";
 import { agentRunAdmissionDenial } from "./agent-run-admission";
 import type {
   ControlActivityServices,
@@ -189,7 +190,8 @@ export function createAutomationActivities(
           workspaceId: input.workspaceId,
           initialMessage: accepted.initialMessage,
           resources: template.resources,
-          skills: template.skills,
+          skills: SessionSkills.parse(template.skills),
+          bundledSkillIds: template.bundledSkillIds,
           tools: template.tools,
           toolPolicy: { mode: "explicit", inheritedFromSessionId: null },
           model,

package/src/activities/context-compaction.ts

@@ -362,7 +362,12 @@ async function compactContextRemoteV2(
     rewrittenToolOutputs = retry.rewrittenToolOutputs;
     compactionItem = await options.requestRemoteCompactionV2(settings, retry.input);
   }
-  const replacementHistory = buildRemoteV2ReplacementHistory(canonicalItems, compactionItem);
+  const retainedTokens = await retentionTokenCounts(canonicalItems, projectForWire);
+  const replacementHistory = buildRemoteV2ReplacementHistory(
+    canonicalItems,
+    compactionItem,
+    (item) => retainedTokens.get(item) ?? estimateTokens([item]),
+  );
   const estimatedTokensAfter = estimateTokens(await projectForWire(replacementHistory));
   const replacementFingerprint = compactionReplacementFingerprint(replacementHistory);
   const tailItem = replacementHistory.at(-1);
@@ -433,7 +438,12 @@ async function compactContextPortable(
   const estimatedTokensBefore = estimateTokens(items);
   const summarized = await summarizeWithCodexOverflowTrimming(summarize, settings, items);
   const summaryBody = summarized.summaryBody;
-  const replacementHistory = buildCompactionReplacementHistory(canonicalItems, summaryBody);
+  const retainedTokens = await retentionTokenCounts(canonicalItems, projectForWire);
+  const replacementHistory = buildCompactionReplacementHistory(
+    canonicalItems,
+    summaryBody,
+    (item) => retainedTokens.get(item) ?? estimateTokens([item]),
+  );
   const estimatedTokensAfter = estimateTokens(await projectForWire(replacementHistory));
   const replacementFingerprint = compactionReplacementFingerprint(replacementHistory);
   const previousReplacementFingerprint = latestCompactionReplacementFingerprint(canonicalItems);
@@ -579,3 +589,17 @@ export function isExactContextLengthExceeded(
     isExactContextLengthExceeded(record.diagnostics, seen)
   );
 }
+
+/** Charge retained uploads by their projected image context, not reference text. */
+async function retentionTokenCounts(
+  items: CompactionItem[],
+  project: (items: CompactionItem[]) => Promise<CompactionItem[]>,
+): Promise<Map<CompactionItem, number>> {
+  const counts = new Map<CompactionItem, number>();
+  for (const item of items) {
+    if (item.role === "user" || item.role === "developer") {
+      counts.set(item, estimateTokens(await project([item])));
+    }
+  }
+  return counts;
+}

package/src/activities/parent-wake.ts

@@ -331,17 +331,50 @@ export async function reconcileAutomaticSessionTitleFanout(
   return { claimed: rows.length, delivered, failed };
 }
 
+export type WorkflowWakeReconciliationResult = {
+  claimed: number;
+  /** Transport acceptance is not durable admission. */
+  signaled: number;
+  /** Revisions acknowledged by the durable admission guard. */
+  delivered: number;
+  pendingAdmission: number;
+  /** Legacy/embedding signalers may not return an acknowledgment receipt. */
+  unconfirmed: number;
+  failed: number;
+  pendingAdmissionBlockers: Partial<
+    Record<
+      Extract<
+        import("@opengeni/db").SessionWorkflowWakeDeliveryResult,
+        { action: "pending_admission" }
+      >["blocker"],
+      number
+    >
+  >;
+};
+
 export async function reconcilePendingSessionWorkflowWakes(
   svc: NotifyServices,
   limit = 1_000,
   overrides: ReconcileSessionWorkflowWakeOverrides = {},
-): Promise<{ claimed: number; delivered: number; failed: number }> {
+): Promise<WorkflowWakeReconciliationResult> {
   const claimPendingSessionWorkflowWakesFn =
     overrides.claimPendingSessionWorkflowWakes ?? claimPendingSessionWorkflowWakes;
   if (!svc.wakeSessionWorkflow) {
-    return { claimed: 0, delivered: 0, failed: 0 };
+    return {
+      claimed: 0,
+      signaled: 0,
+      delivered: 0,
+      pendingAdmission: 0,
+      unconfirmed: 0,
+      failed: 0,
+      pendingAdmissionBlockers: {},
+    };
   }
   const repairs = await claimPendingSessionWorkflowWakesFn(svc.db, limit);
+  let signaled = 0;
+  let pendingAdmission = 0;
+  let unconfirmed = 0;
+  const pendingAdmissionBlockers: WorkflowWakeReconciliationResult["pendingAdmissionBlockers"] = {};
   let delivered = 0;
   let failed = 0;
   const queue = [...repairs];
@@ -349,16 +382,36 @@ export async function reconcilePendingSessionWorkflowWakes(
     for (;;) {
       const repair = queue.shift();
       if (!repair) return;
+      let signalAccepted = false;
+      const onSignalAccepted = () => {
+        if (signalAccepted) return;
+        signalAccepted = true;
+        signaled += 1;
+      };
       try {
-        await svc.wakeSessionWorkflow!({
+        const receipt = await svc.wakeSessionWorkflow!({
           accountId: repair.accountId,
           workspaceId: repair.workspaceId,
           sessionId: repair.sessionId,
           workflowId: repair.temporalWorkflowId,
           wakeRevision: repair.wakeRevision,
           ...(repair.interruptionRequested ? { interruptionRequested: true } : {}),
+          onSignalAccepted,
         });
-        delivered += 1;
+        // Older embeddings do not invoke the optional transport observer.
+        // Their successful return still proves a signal call, never an ACK.
+        onSignalAccepted();
+        if (receipt?.action === "acknowledged") {
+          delivered += 1;
+        } else if (receipt?.action === "pending_admission") {
+          pendingAdmission += 1;
+          pendingAdmissionBlockers[receipt.blocker] =
+            (pendingAdmissionBlockers[receipt.blocker] ?? 0) + 1;
+        } else {
+          // A successful legacy signal is not proof of acknowledgment. The
+          // committed outbox obligation remains owned by the existing guard.
+          unconfirmed += 1;
+        }
       } catch (error) {
         failed += 1;
         await markSessionWorkflowWakeFailed(
@@ -370,7 +423,15 @@ export async function reconcilePendingSessionWorkflowWakes(
     }
   });
   await Promise.all(workers);
-  return { claimed: repairs.length, delivered, failed };
+  return {
+    claimed: repairs.length,
+    signaled,
+    delivered,
+    pendingAdmission,
+    unconfirmed,
+    failed,
+    pendingAdmissionBlockers,
+  };
 }
 
 function childCompletionPayload(

package/src/activities/run-input.ts

@@ -1,5 +1,6 @@
 import {
   MODEL_ATTACHMENT_REFS_FIELD,
+  MODEL_ATTACHMENT_CATALOG_MARKER,
   FileResourceRef,
   resourceMountPath,
   type FileAsset,
@@ -134,6 +135,20 @@ async function measureHistoryPreparationPhase<T>(
 }
 
 export const MAX_INLINE_MODEL_ATTACHMENT_BYTES = 20 * 1024 * 1024;
+// Raw-byte allowance; base64 and request serialization add memory overhead.
+// This is transport admission, never an instruction to rewrite old messages.
+export const MAX_RETAINED_MODEL_ATTACHMENT_BYTES = 64 * 1024 * 1024;
+
+export class RetainedAttachmentTransportLimitError extends Error {
+  constructor() {
+    super(
+      "Active uploaded images exceed the 64 MiB inline transport limit. " +
+        "History was preserved and no new image bytes were downloaded. " +
+        "Start a smaller conversation or fork before the image-heavy messages.",
+    );
+    this.name = "RetainedAttachmentTransportLimitError";
+  }
+}
 
 export type ModelAttachmentContent = {
   kind: "image" | "file";
@@ -202,13 +217,16 @@ function modelAttachmentDescriptor(
 export async function modelAttachmentContentForFiles(
   files: FileAsset[],
   readFileBytes: (file: FileAsset) => Promise<Uint8Array>,
+  options: { retainAll?: boolean } = {},
 ): Promise<ModelAttachmentContent[]> {
   const selected: Array<{
     file: FileAsset;
     descriptor: Pick<ModelAttachmentContent, "kind" | "contentType">;
     checksum: string;
   }> = [];
-  let remainingBytes = MAX_INLINE_MODEL_ATTACHMENT_BYTES;
+  let remainingBytes = options.retainAll
+    ? Number.POSITIVE_INFINITY
+    : MAX_INLINE_MODEL_ATTACHMENT_BYTES;
   for (const file of files) {
     const descriptor = modelAttachmentDescriptor(file.contentType);
     const checksum = file.sha256?.trim().toLowerCase() ?? "";
@@ -216,6 +234,7 @@ export async function modelAttachmentContentForFiles(
       file.status !== "ready" ||
       !descriptor ||
       descriptor.kind !== "image" ||
+      file.sizeBytes > MAX_INLINE_MODEL_ATTACHMENT_BYTES ||
       file.sizeBytes > remainingBytes ||
       !/^[a-f0-9]{64}$/.test(checksum)
     ) {
@@ -301,19 +320,26 @@ function attachmentReceiptText(ref: FileResourceRef, file: FileAsset | undefined
 }
 
 /**
- * Build one turn-scoped durable-attachment projector. Current attachment
- * metadata arrives already authorized; bytes are memoized for same-turn retry.
- * Historical projection has no database or object-storage path.
+ * Build one turn-scoped durable-attachment projector. Resolve active refs under
+ * current file authority and memoize metadata/bytes for retries and compaction.
+ * A turn boundary never changes an authorized attachment's representation.
  */
 export function createModelHistoryAttachmentProjector(
   policy: ModelAttachmentInputPolicy,
   readFileBytes?: (file: FileAsset) => Promise<Uint8Array>,
+  loadAuthorizedFiles?: (fileIds: readonly string[]) => Promise<readonly FileAsset[]>,
 ): ModelHistoryAttachmentProjector {
   const contentById = new Map<string, ModelAttachmentContent>();
   const attemptedContentIds = new Set<string>();
+  const fileById = new Map<string, FileAsset>();
+  const resolvedFileIds = new Set<string>();
+  const retainedByteSizes = new Map<string, number>();
 
   return async (items, options = {}) => {
-    const currentFileById = new Map((options.inlineFiles ?? []).map((file) => [file.id, file]));
+    for (const file of options.inlineFiles ?? []) {
+      fileById.set(file.id, file);
+      resolvedFileIds.add(file.id);
+    }
     const refsByIndex = new Map<number, FileResourceRef[]>();
     const orderedFileIds: string[] = [];
     const seenFileIds = new Set<string>();
@@ -322,27 +348,76 @@ export function createModelHistoryAttachmentProjector(
       if (refs.length === 0) continue;
       refsByIndex.set(index, refs);
       for (const ref of refs) {
-        if (seenFileIds.has(ref.fileId)) continue;
+        if (items[index]![MODEL_ATTACHMENT_CATALOG_MARKER] === true || seenFileIds.has(ref.fileId))
+          continue;
         seenFileIds.add(ref.fileId);
         orderedFileIds.push(ref.fileId);
       }
     }
     if (refsByIndex.size === 0) return items;
+    const unresolved = orderedFileIds.filter((id) => !resolvedFileIds.has(id));
+    if (loadAuthorizedFiles && unresolved.length > 0) {
+      const files = await loadAuthorizedFiles(unresolved);
+      for (const file of files) fileById.set(file.id, file);
+      for (const id of unresolved) resolvedFileIds.add(id);
+    }
 
     if (readFileBytes) {
-      // Only the triggering message's attachments cross the provider byte
-      // boundary. Historical messages retain compact durable receipts and can
-      // recover bytes explicitly through the existing Files MCP + shell path.
+      const admitted = new Map(retainedByteSizes);
+      let requestImageBytes = 0;
+      for (const [index, refs] of refsByIndex) {
+        if (items[index]![MODEL_ATTACHMENT_CATALOG_MARKER] === true) continue;
+        for (const ref of refs) {
+          const file = fileById.get(ref.fileId);
+          if (
+            !file ||
+            !policy.supportsImageInput ||
+            file.status !== "ready" ||
+            file.sizeBytes > MAX_INLINE_MODEL_ATTACHMENT_BYTES ||
+            modelAttachmentDescriptor(file.contentType)?.kind !== "image" ||
+            !/^[a-f0-9]{64}$/i.test(file.sha256?.trim() ?? "")
+          )
+            continue;
+          // Repeated references share cached bytes but repeat in the wire body.
+          requestImageBytes += file.sizeBytes;
+          admitted.set(file.id, file.sizeBytes);
+        }
+      }
+      const turnImageBytes = [...admitted.values()].reduce((sum, bytes) => sum + bytes, 0);
+      if (
+        requestImageBytes > MAX_RETAINED_MODEL_ATTACHMENT_BYTES ||
+        turnImageBytes > MAX_RETAINED_MODEL_ATTACHMENT_BYTES
+      ) {
+        throw new RetainedAttachmentTransportLimitError();
+      }
+      for (const [id, bytes] of admitted) retainedByteSizes.set(id, bytes);
+      // Every active attachment uses the same authorized projection. Metadata
+      // and bytes are resolved once per turn, including compaction and retries.
       const readable = [...orderedFileIds]
         .reverse()
-        .map((id) => currentFileById.get(id))
+        .map((id) => fileById.get(id))
         .filter((file): file is FileAsset => {
           if (!file || attemptedContentIds.has(file.id)) return false;
           const descriptor = modelAttachmentDescriptor(file.contentType);
           return Boolean(descriptor && descriptor.kind === "image" && policy.supportsImageInput);
         });
       for (const file of readable) attemptedContentIds.add(file.id);
-      const content = await modelAttachmentContentForFiles(readable, readFileBytes);
+      const content = await modelAttachmentContentForFiles(readable, readFileBytes, {
+        retainAll: true,
+      });
+      const loadedIds = new Set(content.map((entry) => entry.fileId));
+      for (const file of readable) {
+        if (
+          file.status === "ready" &&
+          file.sizeBytes <= MAX_INLINE_MODEL_ATTACHMENT_BYTES &&
+          /^[a-f0-9]{64}$/i.test(file.sha256 ?? "") &&
+          !loadedIds.has(file.id)
+        ) {
+          // Do not let a retry silently proceed with pixels removed.
+          for (const candidate of readable) attemptedContentIds.delete(candidate.id);
+          throw new Error(`Retained attachment bytes unavailable or invalid: ${file.id}`);
+        }
+      }
       for (const attachment of content) contentById.set(attachment.fileId, attachment);
     }
 
@@ -353,7 +428,8 @@ export function createModelHistoryAttachmentProjector(
         ? [...original.content]
         : [{ type: "input_text", text: String(original.content ?? "") }];
       const attachmentParts = refs.flatMap((ref) => {
-        const currentFile = currentFileById.get(ref.fileId);
+        const currentFile =
+          original[MODEL_ATTACHMENT_CATALOG_MARKER] === true ? undefined : fileById.get(ref.fileId);
         const attachment = currentFile ? contentById.get(ref.fileId) : undefined;
         const receipt = {
           type: "input_text",