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

package/src/activities/agent-turn/governance-model.ts

@@ -20,10 +20,14 @@ import {
   renderWorkspaceGovernanceContext,
   type OpenGeniRuntime,
 } from "@opengeni/runtime";
-import { settingsWithResolvedModelContext, type Settings } from "@opengeni/config";
+import {
+  codeSearchDeploymentPolicy,
+  settingsWithResolvedModelContext,
+  type Settings,
+} from "@opengeni/config";
+import { projectReasoningConfigurations, supportsReasoningConfiguration } from "@opengeni/codex";
 import { settingsWithSessionMcpServersForRun } from "../capabilities";
-import { resolveRigProviderImageForRun } from "@opengeni/core";
-import { resolveWorkspacePackRuntime, settingsWithPackSandboxImage } from "../packs";
+import { resolveRigProviderImageForRun, settingsWithWorkspaceSandboxImage } from "@opengeni/core";
 import { createModelHistoryAttachmentProjector } from "../run-input";
 import type {
   TurnActivityServices as ActivityServices,
@@ -40,12 +44,15 @@ import {
 } from "../generated-images";
 import { createTurnMediaArtifacts } from "./media-artifacts";
 import { retryWhileMissing } from "@opengeni/storage";
+import { measureTurnStartupPhase } from "../../observability-metrics";
 import { WorkspaceModelPolicyBlockedError } from "@opengeni/runtime";
 import {
   evaluateWorkspaceModelPolicy,
   resolveWorkspaceAgentHumanInputEnabled,
+  resolveWorkspaceDefaultAgentIdentity,
   type MediaGenerationResult,
 } from "@opengeni/contracts";
+import { codeSearchEnabledForTurn } from "@opengeni/contracts/code-search";
 
 import { assertWorkspaceHumanInputAllowed } from "./admission";
 import {
@@ -60,6 +67,7 @@ import type { EventingState, WorkspaceRefState } from "./turn-context";
 export type GovernanceModelDeps = {
   input: RunAgentTurnInput;
   db: ActivityServices["db"];
+  observability: ActivityServices["observability"];
   runtime: ActivityServices["runtime"];
   objectStorage: ActivityServices["objectStorage"];
   eventing: EventingState;
@@ -84,13 +92,20 @@ export type GovernanceModelDeps = {
 
 export type GovernanceModelOk = {
   runtimePreparationStartedAt: number;
-  packRuntime: Awaited<ReturnType<typeof resolveWorkspacePackRuntime>>;
   rigVersion:
     | NonNullable<Awaited<ReturnType<typeof materializeRigVersionForAttempt>>>["version"]
     | null;
   rigName: string | null;
   agentHumanInputEnabled: boolean;
+  /** Deployment and workspace allow the Jev-backed code_search tool. */
+  codeSearchEnabled: boolean;
   workspaceAgentInstructions: string | null | undefined;
+  /**
+   * Modular composer identity tier: the explicit workspace default identity,
+   * else the frozen legacy persona without `{{core}}`. Never dropped by
+   * instruction policies (only read for sessions with an agent configuration).
+   */
+  workspaceAgentIdentity: string | null;
   workspaceGovernance: ReturnType<typeof renderWorkspaceGovernanceContext>;
   structuredWorkspacePolicyActive: boolean;
   workspaceMemory: string | null | undefined;
@@ -155,6 +170,7 @@ export async function prepareGovernanceAndModel(
   const {
     input,
     db,
+    observability,
     runtime,
     objectStorage,
     eventing,
@@ -189,17 +205,15 @@ export async function prepareGovernanceAndModel(
     attemptId: input.attemptId,
     executionGeneration: turn.executionGeneration,
   };
-  // Independent workspace reads after the personal-resource fence. Pack,
-  // installed skills, frozen rig, governance snapshots, and model policy do
+  // Independent workspace reads after the personal-resource fence. The
+  // frozen rig, governance snapshots, and model policy do
   // not depend on each other. Company-brain selection still waits on the
   // snapshots below so its receipt stays exact.
   const [
-    packRuntime,
     rigMaterialization,
     [workspace, companyProfileSnapshot, instructionPolicySnapshot, preferenceSnapshot],
     workspaceModelPolicy,
   ] = await Promise.all([
-    resolveWorkspacePackRuntime(db, input.workspaceId),
     session.rigId && session.rigVersionId
       ? (async () =>
           await materializeRigVersionForAttempt(db, {
@@ -233,8 +247,20 @@ export async function prepareGovernanceAndModel(
   workspaceRefs.rigVersionId = session.rigVersionId ?? "";
   if (!workspace) throw new Error(`Workspace not found: ${input.workspaceId}`);
   const agentHumanInputEnabled = resolveWorkspaceAgentHumanInputEnabled(workspace.settings);
+  // The session's decision was frozen when it was created, so only a
+  // deliberate switch-off (deployment or workspace Off), or undoing one,
+  // changes its tool list.
+  const codeSearchEnabled = codeSearchEnabledForTurn(
+    session.codeSearchEnabled,
+    workspace.settings,
+    codeSearchDeploymentPolicy(capabilitySettings),
+  );
   const contextSelection = await resolveCompanyBrainContextSelection(db, governanceClaims);
   const workspaceAgentInstructions = contextSelection.legacyWorkspaceInstructions;
+  const workspaceAgentIdentity = resolveWorkspaceDefaultAgentIdentity(
+    workspace.settings,
+    workspaceAgentInstructions,
+  ).identity;
   const memoryPromptMode = contextSelection.receipt.memoryPromptMode;
   assertWorkspaceHumanInputAllowed(agentHumanInputEnabled, "resume", humanInputResume !== null);
   const companyProfileIncluded = contextSelection.receipt.companyProfileIncluded;
@@ -279,15 +305,13 @@ export async function prepareGovernanceAndModel(
   } catch {
     // Contribution telemetry must never change model execution semantics.
   }
-  // A Rig is always a setup/check layer over the deployment platform sandbox.
-  // The pre-v2 Pack image path remains only for rig-less compatibility sessions.
-  const logicalSandboxSettings = rigVersion
-    ? capabilitySettings
-    : settingsWithPackSandboxImage(
-        capabilitySettings,
-        packRuntime.sandboxImage,
-        packRuntime.sandboxProviderImages,
-      );
+  // A Rig is always a setup/check layer over the deployment platform sandbox,
+  // or over the workspace's allowlisted selection of one.
+  const logicalSandboxSettings = settingsWithWorkspaceSandboxImage(
+    capabilitySettings,
+    workspace.settings,
+    turn.sandboxBackend,
+  );
   const providerImageSelection = await resolveRigProviderImageForRun(
     logicalSandboxSettings,
     rigVersion,
@@ -299,21 +323,29 @@ export async function prepareGovernanceAndModel(
       ? (providerImageSelection.imageId ?? undefined)
       : undefined;
   const baseRunSettings = {
-    // IMAGE PRECEDENCE: a Rig uses the deployment platform base; a rig-less
-    // pre-v2 Pack may retain its compatibility image. A matching verified
-    // provider-native ID is then applied only to fresh creation without
+    // A Rig uses the deployment platform base. A matching verified
+    // provider-native ID is applied only to fresh creation without
     // changing the logical lease image.
     ...providerImageSettings,
     openaiModel: turn.model,
     openaiReasoningEffort: turn.reasoningEffort,
     sandboxBackend: turn.sandboxBackend,
   };
-  const runSettings = await settingsWithSessionMcpServersForRun(
-    db,
-    input.workspaceId,
-    input.sessionId,
-    input.attemptId,
-    baseRunSettings,
+  const runSettings = await measureTurnStartupPhase(
+    observability,
+    {
+      phase: "session_mcp_settings",
+      provider: turnExecutionPolicy.providerId,
+      backend: turn.sandboxBackend,
+    },
+    () =>
+      settingsWithSessionMcpServersForRun(
+        db,
+        input.workspaceId,
+        input.sessionId,
+        input.attemptId,
+        baseRunSettings,
+      ),
   );
 
   // Multi-provider per-turn routing → the provider gating (compaction mode,
@@ -365,12 +397,20 @@ export async function prepareGovernanceAndModel(
         fileIds,
       }),
   );
+  const useReasoningUpdates =
+    runSettings.reasoningConfigurationUpdatesEnabled &&
+    providerApi === "responses" &&
+    (resolvedModel?.provider.id === "codex" || resolvedModel?.provider.id === "openai") &&
+    supportsReasoningConfiguration(turnExecutionPolicy.upstreamModelId, turn.reasoningEffort);
   const modelHistoryProjector = async (
     items: Array<Record<string, unknown>>,
     projectionOptions?: Parameters<typeof attachmentProjector>[1],
   ) =>
     projectModelInputForCapabilities(
-      await attachmentProjector(items, projectionOptions),
+      projectReasoningConfigurations(
+        await attachmentProjector(items, projectionOptions),
+        useReasoningUpdates,
+      ),
       modelInputPolicy,
     );
   const generatedImageHistoryProjector = async (
@@ -460,11 +500,12 @@ export async function prepareGovernanceAndModel(
   return {
     ok: {
       runtimePreparationStartedAt,
-      packRuntime,
       rigVersion,
       rigName,
       agentHumanInputEnabled,
+      codeSearchEnabled,
       workspaceAgentInstructions,
+      workspaceAgentIdentity,
       workspaceGovernance,
       structuredWorkspacePolicyActive,
       workspaceMemory,

package/src/activities/agent-turn/history-sink.ts

@@ -50,6 +50,7 @@ export type TurnHistorySinkDeps = {
  */
 export class TurnHistorySink {
   private readonly prefix = new HistoryPrefixGuard();
+  private checkpointTail: Promise<void> = Promise.resolve();
 
   seedHistory(input: string | readonly unknown[] | { readonly history: unknown[] }, count: number) {
     const items =
@@ -76,9 +77,22 @@ export class TurnHistorySink {
 
   constructor(private readonly deps: TurnHistorySinkDeps) {}
 
-  reconcileConversationTruth = async (
+  reconcileConversationTruth = (
     options: { skipInputOnlyRows?: boolean; requireDurable?: boolean } = {},
-  ) => {
+  ): Promise<void> => {
+    // The provider loop and the stream consumer checkpoint independently.
+    // Serialize the complete read/write/acknowledgment boundary, not just the
+    // database write: each caller must read history against the latest durable
+    // watermark. Keep each caller's durability policy and rejection intact.
+    const checkpoint = this.checkpointTail.then(() => this.reconcile(options));
+    this.checkpointTail = checkpoint.catch(() => {});
+    return checkpoint;
+  };
+
+  private reconcile = async (options: {
+    skipInputOnlyRows?: boolean;
+    requireDurable?: boolean;
+  }) => {
     const { media } = this.deps;
     const stream = this.deps.getStream();
     const turnId = this.deps.getTurnId();

package/src/activities/agent-turn/history.ts

@@ -1,5 +1,6 @@
 import {
   normalizeProtocolJsonValue,
+  TURN_OPERATIONAL_NOTICE_PREFIX,
   sanitizeHistoryItemsForModel,
   toolCallIdFromSdkItem,
 } from "@opengeni/runtime";
@@ -31,15 +32,20 @@ export function historyRowsToAppend(
   }
   // Canonical model-facing inputs (including machine-input batches) are
   // persisted before inference and therefore live inside the prefix represented
-  // by persistedHistoryCount. System messages synthesized only for this
-  // attempt—recovery diagnostics, credential notices, attachment materialization
-  // notes—must not accidentally become conversation memory during reconciliation.
-  // Advance the in-memory watermark past them, but only allocate durable
-  // positions to actual model/tool output.
+  // by persistedHistoryCount. Explicitly turn-scoped operational notices remain
+  // at their original positions: deleting them rewrites the model-visible prefix
+  // on the next turn and during compaction. Unscoped synthetic system messages
+  // still cannot silently become permanent conversation instructions.
   const rows: Array<{ position: number; item: Record<string, unknown> }> = [];
   for (const [offset, item] of modelReady.slice(persistedHistoryCount).entries()) {
     if (item.type === "message" && item.role === "system") {
-      continue;
+      const content =
+        typeof item.content === "string"
+          ? item.content
+          : Array.isArray(item.content)
+            ? item.content.map((part: { text?: string }) => part.text ?? "").join("")
+            : "";
+      if (!content.startsWith(TURN_OPERATIONAL_NOTICE_PREFIX)) continue;
     }
     rows.push({
       position: nextPosition + rows.length,
@@ -149,10 +155,18 @@ export function pendingToolCallFromSdkEvent(event: unknown): {
     return null;
   }
   const raw = item.rawItem as Record<string, unknown>;
-  // The hosted image call is a complete provider fact carried by one item; it
-  // never receives a separate function result and therefore must not enter the
-  // pending function-call ledger.
-  if (raw.type === "hosted_tool_call" && raw.name === "image_generation_call") return null;
+  // Provider-executed search/image calls carry their outcome in this item,
+  // not a later function result. Registering them as pending leaves an
+  // impossible receipt behind even after the turn completes. Hosted MCP
+  // approval requests are different: they still require a response.
+  const providerData = raw.providerData as Record<string, unknown> | undefined;
+  if (
+    raw.type === "hosted_tool_call" &&
+    raw.name !== "mcp_approval_request" &&
+    providerData?.type !== "mcp_approval_request" &&
+    (raw.status === "completed" || raw.name === "image_generation_call")
+  )
+    return null;
   const callId = toolCallIdFromSdkItem(raw) ?? raw.id;
   const callType = raw.type;
   if (typeof callId !== "string" || callId.length === 0 || typeof callType !== "string") {
@@ -172,7 +186,20 @@ export function toolCallProducesRetainableSessionImage(name: string | null): boo
   return (
     name === "computer_screenshot" ||
     name === "view_image" ||
-    name === "interaction__computer_observe"
+    name === "interaction__computer_observe" ||
+    retainableBrowserScreenshotToolCall(name)
+  );
+}
+
+/** Browser interactions can carry an image block, including opt-in observe frames. */
+export function retainableBrowserScreenshotToolCall(name: string | null): boolean {
+  return (
+    name === "browser_screenshot" ||
+    name === "interaction__browser_screenshot" ||
+    name === "browser_observe" ||
+    name === "interaction__browser_observe" ||
+    name === "browser_act" ||
+    name === "interaction__browser_act"
   );
 }
 

package/src/activities/agent-turn/input-wait-reply.ts

@@ -0,0 +1,103 @@
+import { listSessionEvents, type Database } from "@opengeni/db";
+import type { TurnInitiator, TurnInitiatorContext } from "@opengeni/contracts";
+
+type ReplyTurn = {
+  source?: string | undefined;
+  initiator: TurnInitiator;
+  initiatorContext: TurnInitiatorContext;
+};
+
+/**
+ * Provenance an agent adds when it creates a session or calls the API
+ * (`via`, `viaTruncated`), plus internal-update and legacy markers: the prompt
+ * came from an agent or a migration, not from a person.
+ */
+const DERIVED_PROVENANCE_KEYS = ["via", "viaTruncated", "provenanceError", "backfill"] as const;
+
+/**
+ * Worker-owned producers that create a session whose first turn (`source`
+ * `user`) is their task prompt: scheduled runs, automations and site-auth
+ * maintenance. An embedding host that asserts one of these service names only
+ * gives up the recorded reply; it grants nothing.
+ */
+function isWorkerTaskProducer(initiator: TurnInitiator): boolean {
+  if (initiator.kind !== "service") return false;
+  const subjectId = initiator.subjectId;
+  return (
+    subjectId === "scheduler" ||
+    subjectId === "site-auth-maintenance" ||
+    subjectId.startsWith("automation:")
+  );
+}
+
+/**
+ * Whether a turn answers a message a person sent, directly or through an API
+ * caller that relays one (an embedding host, a realtime delegation). The
+ * source alone is not enough: every session's first turn is `user`, including
+ * a child an agent spawned and a session a scheduled task created.
+ */
+function turnAnswersMessage(turn: ReplyTurn): boolean {
+  if (turn.source !== "user" && turn.source !== "api") return false;
+  if (
+    DERIVED_PROVENANCE_KEYS.some((key) =>
+      Object.prototype.hasOwnProperty.call(turn.initiatorContext, key),
+    )
+  ) {
+    return false;
+  }
+  return !isWorkerTaskProducer(turn.initiator);
+}
+
+/**
+ * The reply `turn.completed` records when a turn ends through `wait_for_input`
+ * (read back with `turnCompletedReply` in `@opengeni/contracts`).
+ *
+ * Such a turn settles with an empty `output`: the wait, not an answer, ended
+ * it. When the turn answers a person's message, its latest assistant message
+ * is still that message's answer, for example a status reply given before
+ * waiting again on work in flight. That message shares its model response with
+ * the wait call, so it streams as commentary, which is activity everywhere
+ * else. Recording it lets unread attention and Slack treat it as the answer
+ * without relabelling the provider's phase in stored history. Turns that
+ * machine input, an agent or a worker-owned producer started only narrate
+ * progress and record nothing.
+ *
+ * The message this activity completed last is the newest. An activity that
+ * resumed the turn (after an approval, a human-input answer or a recovery) and
+ * completed none reads the turn's latest durable message instead.
+ */
+export async function inputWaitReply(input: {
+  inputWaitYielded: boolean;
+  turn: ReplyTurn;
+  latestAssistantMessageText: string | null;
+  readLatestDurableTurnMessage: () => Promise<string | null>;
+}): Promise<string | null> {
+  if (!input.inputWaitYielded || !turnAnswersMessage(input.turn)) return null;
+  const text = input.latestAssistantMessageText ?? (await input.readLatestDurableTurnMessage());
+  return text !== null && text.trim().length > 0 ? text : null;
+}
+
+/** How far back to look past rejected-late or duplicate completions. */
+const DURABLE_MESSAGE_LOOKBACK = 16;
+
+/**
+ * Text of the newest current `agent.message.completed` this turn persisted,
+ * or null when the session's newest completion belongs to another turn.
+ */
+export async function latestDurableTurnMessageText(
+  db: Database,
+  input: { workspaceId: string; sessionId: string; turnId: string },
+): Promise<string | null> {
+  const events = await listSessionEvents(db, input.workspaceId, input.sessionId, {
+    direction: "before",
+    includeTypes: ["agent.message.completed"],
+    limit: DURABLE_MESSAGE_LOOKBACK,
+  });
+  for (const event of events.reverse()) {
+    if (event.duplicateOfEventId || (event.turnAssociation ?? "current") !== "current") continue;
+    if (event.turnId !== input.turnId) return null;
+    const text = (event.payload as { text?: unknown } | null)?.text;
+    return typeof text === "string" ? text : null;
+  }
+  return null;
+}

package/src/activities/agent-turn/knowledge-source-tools.ts

@@ -1,3 +1,4 @@
+import { isRetiredNativeAtlassianSource } from "@opengeni/contracts/atlassian-native-retirement";
 import type { AttemptToolDefinition } from "@opengeni/codemode";
 import {
   freezeAgentLearningPolicy,
@@ -24,6 +25,7 @@ export async function createKnowledgeSourceAttemptTools(input: {
   });
   const source = accepted?.task.agentConfig.knowledgeSource;
   if (!accepted || !source || accepted.task.action.kind !== "agent_turn") return [];
+  if (isRetiredNativeAtlassianSource(source)) return [];
   const actor = input.context.actor;
   const authorize = async () => {
     const current = await freezeAgentLearningPolicy(input.db, input.context);

package/src/activities/agent-turn/media-artifacts.ts

@@ -12,7 +12,7 @@ import {
   type TurnToolCancellationFence,
 } from "@opengeni/runtime";
 import type { Settings } from "@opengeni/config";
-import type { RetainedArtifactMetadata } from "@opengeni/contracts";
+import type { RetainedArtifactMetadata, RetainedSessionScreenshotKind } from "@opengeni/contracts";
 import type { ResumedTurnSandbox } from "../../sandbox-resume";
 import type { SharedActivityServices } from "../types";
 import {
@@ -79,6 +79,7 @@ export class TurnMediaArtifacts {
   sandboxFileDownloadBackend: Settings["sandboxBackend"];
   nativeImageGenerationRetention: NativeImageGenerationRetention | null = null;
   readonly retainedSessionImageCallIds = new Set<string>();
+  readonly retainedSessionImageKindsByCallId = new Map<string, RetainedSessionScreenshotKind>();
 
   constructor(private readonly deps: TurnMediaArtifactDeps) {
     this.sandboxFileDownloadBackend = deps.getModelRunSettings().sandboxBackend;

package/src/activities/agent-turn/model-call-admission.ts

@@ -0,0 +1,94 @@
+import type { StreamEvent } from "@openai/agents";
+
+/** SDK producer/consumer rendezvous. Usage stays on the sole consumer writer. */
+export function createModelCallAdmission(input: {
+  signal: AbortSignal;
+  admit: () => Promise<void>;
+}) {
+  type Receipt = {
+    promise: Promise<void>;
+    resolve: () => void;
+    reject: (error: unknown) => void;
+  };
+  const receipts = new WeakMap<object, Receipt>();
+  const responseReceipts = new Map<string, Receipt>();
+  const pending = new Set<Receipt>();
+  const responseId = (event: unknown): string | null => {
+    const id = (event as { response?: { id?: unknown } } | null)?.response?.id;
+    return typeof id === "string" && id.length > 0 ? id : null;
+  };
+  let latest: Promise<void> = Promise.resolve();
+  let failure: unknown;
+  let failed = false;
+  let rejectHalted!: (error: unknown) => void;
+  const halted = new Promise<never>((_, reject) => {
+    rejectHalted = reject;
+  });
+  void halted.catch(() => undefined);
+  const fail = (error: unknown) => {
+    if (failed) return;
+    failed = true;
+    failure = error;
+    rejectHalted(error);
+    for (const receipt of pending) receipt.reject(error);
+    pending.clear();
+    responseReceipts.clear();
+  };
+  const abort = () => fail(input.signal.reason ?? new Error("Model stream cancelled"));
+  input.signal.addEventListener("abort", abort, { once: true });
+  if (input.signal.aborted) abort();
+  return {
+    beforeModelRequest: async () => {
+      await Promise.race([latest, halted]);
+      if (failed) throw failure;
+      // Even a settled predecessor does not grant admission to the next call.
+      await Promise.race([input.admit(), halted]);
+      if (failed) throw failure;
+    },
+    onModelResponse: (event: StreamEvent): Promise<void> => {
+      if (failed) return Promise.reject(failure);
+      const id = responseId(event);
+      const existing =
+        receipts.get(event) ??
+        (id ? responseReceipts.get(id) : undefined) ??
+        (!id && pending.size === 1 ? pending.values().next().value : undefined);
+      if (existing) return existing.promise;
+      let resolve!: () => void;
+      let reject!: (error: unknown) => void;
+      const promise = new Promise<void>((yes, no) => {
+        resolve = yes;
+        reject = no;
+      });
+      // The next model entry awaits this receipt; rejection can happen sooner.
+      void promise.catch(() => undefined);
+      const receipt = { promise, resolve, reject };
+      receipts.set(event, receipt);
+      if (id) responseReceipts.set(id, receipt);
+      pending.add(receipt);
+      latest = promise;
+      return promise;
+    },
+    settle: (event: { type: string; data?: unknown }) => {
+      if (event.type !== "raw_model_stream_event" || !event.data || typeof event.data !== "object")
+        return;
+      if ((event.data as { type?: unknown }).type !== "response_done") return;
+      const id = responseId(event.data);
+      // Runner retry normalization copies response_done. It cannot create a
+      // second response before this receipt permits the next model entry.
+      const receipt =
+        receipts.get(event.data) ??
+        (id ? responseReceipts.get(id) : undefined) ??
+        (pending.size === 1 ? pending.values().next().value : undefined);
+      if (!receipt) return;
+      pending.delete(receipt);
+      if (id) responseReceipts.delete(id);
+      receipt.resolve();
+    },
+    fail,
+    close: () => {
+      input.signal.removeEventListener("abort", abort);
+      if (pending.size > 0) fail(new Error("Model stream closed before response settlement"));
+      responseReceipts.clear();
+    },
+  };
+}