@opengeni/core 0.4.7 → 0.4.9

package/dist/index.js

@@ -1,3 +1,8 @@
+// src/workflow-wake-contract.ts
+var SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID = "opengeni-session-workflow-wake-dispatcher";
+var SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_TYPE = "sessionWorkflowWakeDispatcherWorkflow";
+var SESSION_WORKFLOW_WAKE_DISPATCHER_PERIOD_MS = 1e4;
+
 // src/sandbox/fleet.ts
 import {
   getEnrollment,
@@ -558,7 +563,9 @@ async function delegatedAccessContext(c, deps, mode, token = bearerToken(c)) {
           ...payload.sessionId ? { sessionId: payload.sessionId } : {},
           // Caller identity: the turn that minted this token. Tools classify the
           // CALLER from this instead of re-reading the live active pointer.
-          ...payload.turnId ? { turnId: payload.turnId } : {}
+          ...payload.turnId ? { turnId: payload.turnId } : {},
+          ...payload.attemptId ? { attemptId: payload.attemptId } : {},
+          ...payload.executionGeneration ? { executionGeneration: payload.executionGeneration } : {}
         }
       }
     ],
@@ -2596,7 +2603,6 @@ import {
 import {
   createSession,
   createSessionWithIdempotencyKey,
-  enqueueSessionMessageAtomically,
   encryptVariableSetValue as encryptVariableSetValue2,
   getAnySessionInGroup,
   getEnrollment as getEnrollment2,
@@ -2607,17 +2613,23 @@ import {
   getSandbox as getSandbox3,
   getSession,
   getSessionByCreateIdempotencyKey,
+  getSessionEvent,
+  getWorkspaceControlEvent,
   getSessionLineage,
   getSessionTurn,
   getWorkspaceModelPolicy,
   initializeSessionStartAtomically,
   requireSession as requireSession2,
+  submitHumanPromptInTransaction,
   updateSessionTitle as updateSessionTitleRow,
-  SessionQueueConflictError
+  withWorkspaceSubjectRls,
+  QueueCommandConflictError,
+  SessionControlConflictError
 } from "@opengeni/db";
 import {
   appendAndPublishEvents,
-  publishDurableSessionEvents
+  publishDurableSessionEvents,
+  publishDurableWorkspaceControlEvent
 } from "@opengeni/events";
 import { HTTPException as HTTPException9 } from "hono/http-exception";
 var reservedSessionMcpServerIds = /* @__PURE__ */ new Set(["opengeni", "files", "docs", "codex_apps"]);
@@ -2942,30 +2954,37 @@ async function postUserMessageTurn(input) {
   const requestedReasoningEffort = input.reasoningEffort ?? null;
   assertConfiguredModel(settings, requestedModel);
   await assertWorkspaceModelPolicyAllows(db, settings, workspaceId, requestedModel);
+  const operationKey = input.clientEventId ?? crypto.randomUUID();
   let result;
   try {
-    result = await enqueueSessionMessageAtomically(db, {
-      accountId,
+    result = await withWorkspaceSubjectRls(
+      db,
       workspaceId,
-      sessionId,
-      actor: input.actor ?? accountId,
-      origin: input.origin ?? "human",
-      text: input.text,
-      resources: input.resources,
-      tools: input.tools,
-      model: requestedModel,
-      reasoningEffort: requestedReasoningEffort,
-      clientEventId: input.clientEventId ?? null,
-      mcpCredentialUpdates: input.mcpCredentialUpdates ?? [],
-      delivery: input.delivery ?? "queue",
-      ...input.expectedControlGeneration !== void 0 ? { expectedControlGeneration: input.expectedControlGeneration } : {},
-      ...input.expectedWorkspaceInferenceGeneration !== void 0 ? {
-        expectedWorkspaceInferenceGeneration: input.expectedWorkspaceInferenceGeneration
-      } : {},
-      reasoningEffortFallback: settings.openaiReasoningEffort
-    });
+      input.actor ?? accountId,
+      (scoped) => scoped.transaction(
+        (tx) => submitHumanPromptInTransaction(tx, {
+          accountId,
+          workspaceId,
+          sessionId,
+          subjectId: input.actor ?? accountId,
+          actor: { type: "human", subjectId: input.actor ?? accountId },
+          operationKey,
+          delivery: input.delivery ?? "send",
+          controlEtag: input.controlEtag ?? null,
+          expectedDraftRevision: input.expectedDraftRevision ?? null,
+          text: input.text,
+          resources: input.resources,
+          tools: input.tools,
+          model: requestedModel,
+          reasoningEffort: requestedReasoningEffort,
+          reasoningEffortFallback: settings.openaiReasoningEffort,
+          source: input.origin === "operator" ? "api" : "user",
+          mcpCredentialUpdates: input.mcpCredentialUpdates ?? []
+        })
+      )
+    );
   } catch (error) {
-    if (error instanceof SessionQueueConflictError) {
+    if (error instanceof QueueCommandConflictError || error instanceof SessionControlConflictError) {
       throw new HTTPException9(409, { message: error.message });
     }
     if (error instanceof Error && error.message.includes("cancelled")) {
@@ -2976,35 +2995,51 @@ async function postUserMessageTurn(input) {
     }
     throw error;
   }
-  await bus.publish(workspaceId, sessionId, result.events);
-  if (result.shouldSignalControl && result.controlEvent) {
-    if (result.workflowWakeRevision === null) {
-      throw new Error("Steer control has no workflow wake revision");
-    }
-    await workflowClient.signalSessionControl({
-      accountId,
+  const events = await Promise.all(
+    result.eventIds.map((eventId) => getSessionEvent(db, workspaceId, eventId))
+  );
+  if (events.some((event) => event === null)) {
+    throw new Error("Committed prompt events could not be reloaded");
+  }
+  const turn = await getSessionTurn(db, workspaceId, result.turnId);
+  if (!turn) throw new Error("Committed prompt turn could not be reloaded");
+  const accepted = events.find((event) => event?.id === result.acceptedEventId);
+  if (!accepted) throw new Error("Committed user.message event could not be reloaded");
+  await publishDurableSessionEvents(
+    bus,
+    workspaceId,
+    sessionId,
+    events.filter((event) => event !== null)
+  );
+  if (result.workspaceControlEventId) {
+    const controlEvent = await getWorkspaceControlEvent(
+      db,
       workspaceId,
-      sessionId,
-      eventId: result.controlEvent.id,
-      workflowId: result.temporalWorkflowId,
-      workflowWakeRevision: result.workflowWakeRevision
-    });
-  } else if (result.shouldWake) {
-    if (result.workflowWakeRevision === null) {
-      throw new Error("Runnable prompt has no workflow wake revision");
+      result.workspaceControlEventId
+    );
+    if (!controlEvent) {
+      throw new Error(
+        `Committed workspace control event disappeared: ${result.workspaceControlEventId}`
+      );
     }
+    await publishDurableWorkspaceControlEvent(bus, workspaceId, controlEvent);
+  }
+  try {
     await workflowClient.wakeSessionWorkflow({
       accountId,
       workspaceId,
       sessionId,
-      workflowId: result.temporalWorkflowId,
-      wakeRevision: result.workflowWakeRevision
+      workflowId: turn.temporalWorkflowId,
+      wakeRevision: result.wakeRevision,
+      ...result.interruptionCount > 0 ? { interruptionRequested: true } : {}
     });
+  } catch (error) {
+    console.warn(
+      `[sessions] workflow wake failed for committed prompt ${workspaceId}/${sessionId}; durable outbox will retry`,
+      error
+    );
   }
-  return {
-    accepted: result.accepted,
-    turn: result.turn
-  };
+  return { accepted, turn };
 }
 async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
   const { settings, db, bus, workflowClient, objectStorage } = deps;
@@ -3290,13 +3325,11 @@ async function acceptSessionUserMessage(deps, grant, workspaceId, sessionId, inp
     model: input.model ?? null,
     reasoningEffort: input.reasoningEffort ?? null,
     mcpCredentialUpdates,
-    delivery: input.delivery ?? "queue",
+    delivery: input.delivery ?? "send",
     origin: input.origin ?? "human",
     actor: grant.subjectId,
-    ...input.expectedControlGeneration !== void 0 ? { expectedControlGeneration: input.expectedControlGeneration } : {},
-    ...input.expectedWorkspaceInferenceGeneration !== void 0 ? {
-      expectedWorkspaceInferenceGeneration: input.expectedWorkspaceInferenceGeneration
-    } : {},
+    ...input.controlEtag !== void 0 ? { controlEtag: input.controlEtag } : {},
+    ...input.expectedDraftRevision !== void 0 ? { expectedDraftRevision: input.expectedDraftRevision } : {},
     ...input.clientEventId ? { clientEventId: input.clientEventId } : {}
   });
   await recordWorkspaceUsage(deps, {
@@ -3611,6 +3644,394 @@ function assertWorkspaceDeletable(input) {
     });
   }
 }
+
+// src/application/session-commands.ts
+import { reasoningEffortForMetadata as reasoningEffortForMetadata2 } from "@opengeni/contracts";
+import {
+  deleteSessionQueueItemInTransaction,
+  editQueuedTurnInTransaction,
+  getComposerDraftInTransaction,
+  getSession as getSession2,
+  getSessionEvent as getSessionEvent2,
+  getWorkspaceControlEvent as getWorkspaceControlEvent2,
+  getSessionQueueSnapshot,
+  moveQueuedTurnInTransaction,
+  mutateSessionControlInTransaction,
+  mutateWorkspaceControlInTransaction,
+  saveComposerDraftInTransaction,
+  sendAgentMessageInTransaction,
+  serializeEffectiveSessionControl,
+  steerAgentSessionInTransaction,
+  steerQueuedTurnInTransaction,
+  withWorkspaceRls,
+  withWorkspaceSubjectRls as withWorkspaceSubjectRls2
+} from "@opengeni/db";
+import {
+  publishDurableSessionEvents as publishDurableSessionEvents2,
+  publishDurableWorkspaceControlEvent as publishDurableWorkspaceControlEvent2
+} from "@opengeni/events";
+function agentActor(context) {
+  return {
+    type: "agent_attempt",
+    sessionId: context.callerSessionId,
+    turnId: context.callerTurnId,
+    attemptId: context.callerAttemptId,
+    executionGeneration: context.callerExecutionGeneration
+  };
+}
+async function publishAndWakeAgentCommand(deps, input) {
+  await publishSessionEventIds(deps, input.workspaceId, input.sessionId, input.eventIds);
+  if (!input.shouldSignal || input.wakeRevision === null) return;
+  try {
+    await deps.workflowClient.wakeSessionWorkflow({
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId,
+      workflowId: input.workflowId,
+      wakeRevision: input.wakeRevision,
+      ...input.interruptionCount > 0 ? { interruptionRequested: true } : {}
+    });
+  } catch (error) {
+    console.warn(
+      `[session-commands] immediate Agent command wake failed for ${input.workspaceId}/${input.sessionId}; durable outbox will retry`,
+      error
+    );
+  }
+}
+async function requestControlWakeDispatch(deps, wakeCount) {
+  if (wakeCount === 0) return;
+  try {
+    await deps.workflowClient.requestSessionWorkflowWakeDispatch();
+  } catch (error) {
+    console.warn(
+      `[session-commands] immediate control wake dispatch failed for ${wakeCount} committed revisions; durable outbox will retry`,
+      error
+    );
+  }
+}
+async function publishSessionEventIds(deps, workspaceId, sessionId, eventIds) {
+  if (eventIds.length === 0) return;
+  const events = await Promise.all(
+    eventIds.map((eventId) => getSessionEvent2(deps.db, workspaceId, eventId))
+  );
+  await publishDurableSessionEvents2(
+    deps.bus,
+    workspaceId,
+    sessionId,
+    events.filter((event) => event !== null)
+  );
+}
+async function publishWorkspaceControlEvent(deps, workspaceId, eventId) {
+  if (!eventId) return;
+  const event = await getWorkspaceControlEvent2(deps.db, workspaceId, eventId);
+  if (!event) {
+    throw new Error(`Committed workspace control event disappeared: ${eventId}`);
+  }
+  await publishDurableWorkspaceControlEvent2(deps.bus, workspaceId, event);
+}
+async function sendAgentSessionMessage(deps, context, input) {
+  const result = await withWorkspaceRls(
+    deps.db,
+    context.workspaceId,
+    (scoped) => scoped.transaction(
+      (tx) => sendAgentMessageInTransaction(tx, {
+        accountId: context.accountId,
+        workspaceId: context.workspaceId,
+        targetSessionId: input.targetSessionId,
+        actor: agentActor(context),
+        operationKey: input.idempotencyKey,
+        text: input.text
+      })
+    )
+  );
+  await publishAndWakeAgentCommand(deps, {
+    accountId: context.accountId,
+    workspaceId: context.workspaceId,
+    sessionId: input.targetSessionId,
+    eventIds: result.eventIds,
+    workflowId: result.workflowId,
+    wakeRevision: result.wakeRevision,
+    shouldSignal: result.shouldSignal,
+    interruptionCount: 0
+  });
+  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
+  return result;
+}
+async function steerAgentSession(deps, context, input) {
+  const result = await withWorkspaceRls(
+    deps.db,
+    context.workspaceId,
+    (scoped) => scoped.transaction(
+      (tx) => steerAgentSessionInTransaction(tx, {
+        accountId: context.accountId,
+        workspaceId: context.workspaceId,
+        targetSessionId: input.targetSessionId,
+        actor: agentActor(context),
+        operationKey: input.idempotencyKey,
+        instruction: input.instruction
+      })
+    )
+  );
+  await publishAndWakeAgentCommand(deps, {
+    accountId: context.accountId,
+    workspaceId: context.workspaceId,
+    sessionId: input.targetSessionId,
+    eventIds: result.eventIds,
+    workflowId: result.workflowId,
+    wakeRevision: result.wakeRevision,
+    shouldSignal: result.shouldSignal,
+    interruptionCount: result.interruptionCount
+  });
+  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
+  return result;
+}
+async function controlAgentSessionWorkstream(deps, context, input) {
+  const result = await withWorkspaceRls(
+    deps.db,
+    context.workspaceId,
+    (scoped) => scoped.transaction(
+      (tx) => mutateSessionControlInTransaction(tx, {
+        accountId: context.accountId,
+        workspaceId: context.workspaceId,
+        sessionId: input.targetSessionId,
+        actor: agentActor(context),
+        operationKey: input.idempotencyKey,
+        action: input.action,
+        reason: input.reason ?? null
+      })
+    )
+  );
+  await publishSessionEventIds(deps, context.workspaceId, input.targetSessionId, [
+    result.sessionControlEventId
+  ]);
+  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
+  await requestControlWakeDispatch(deps, result.wakeCount);
+  return result;
+}
+function receipt(row) {
+  return {
+    id: row.id,
+    action: row.action,
+    operationKey: row.operationKey,
+    targetSessionId: row.targetSessionId,
+    targetTurnId: row.targetTurnId,
+    appliedControlRevision: row.appliedControlRevision,
+    appliedQueueVersion: row.appliedQueueVersion,
+    appliedTurnVersion: row.appliedTurnVersion,
+    appliedDraftRevision: row.appliedDraftRevision,
+    createdAt: row.createdAt.toISOString()
+  };
+}
+function composerDraft(row) {
+  if (!row) return null;
+  return {
+    revision: row.revision,
+    text: row.text,
+    resources: row.resources,
+    tools: row.tools,
+    model: row.model,
+    reasoningEffort: row.reasoningEffort,
+    sourceTurnId: row.sourceTurnId,
+    sourceTurnVersion: row.sourceTurnVersion,
+    updatedAt: row.updatedAt.toISOString()
+  };
+}
+async function authoritativeQueue(db, workspaceId, sessionId) {
+  const snapshot = await getSessionQueueSnapshot(db, workspaceId, sessionId);
+  if (!snapshot) throw new Error(`Session not found: ${sessionId}`);
+  return snapshot;
+}
+async function moveHumanQueuePrompt(deps, context, turnId, input) {
+  const result = await withWorkspaceRls(
+    deps.db,
+    context.workspaceId,
+    (scoped) => scoped.transaction(
+      (tx) => moveQueuedTurnInTransaction(tx, {
+        ...context,
+        turnId,
+        beforeTurnId: input.beforeTurnId,
+        expectedQueueVersion: input.expectedQueueVersion,
+        actor: { type: "human", subjectId: context.subjectId },
+        operationKey: input.clientEventId
+      })
+    )
+  );
+  const response = {
+    receipt: receipt(result.receipt),
+    snapshot: await authoritativeQueue(deps.db, context.workspaceId, context.sessionId)
+  };
+  await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
+  return response;
+}
+async function deleteHumanQueuePrompt(deps, context, turnId, input) {
+  const result = await withWorkspaceRls(
+    deps.db,
+    context.workspaceId,
+    (scoped) => scoped.transaction(
+      (tx) => deleteSessionQueueItemInTransaction(tx, {
+        ...context,
+        turnId,
+        expectedTurnVersion: input.expectedTurnVersion,
+        actor: { type: "human", subjectId: context.subjectId },
+        operationKey: input.clientEventId,
+        reason: input.reason ?? null
+      })
+    )
+  );
+  const response = {
+    receipt: receipt(result.receipt),
+    snapshot: await authoritativeQueue(deps.db, context.workspaceId, context.sessionId)
+  };
+  await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
+  return response;
+}
+async function editHumanQueuePrompt(deps, context, turnId, input) {
+  const result = await withWorkspaceSubjectRls2(
+    deps.db,
+    context.workspaceId,
+    context.subjectId,
+    (scoped) => scoped.transaction(
+      (tx) => editQueuedTurnInTransaction(tx, {
+        ...context,
+        turnId,
+        expectedTurnVersion: input.expectedTurnVersion,
+        expectedDraftRevision: input.expectedDraftRevision,
+        replaceDraft: input.replaceDraft,
+        actor: { type: "human", subjectId: context.subjectId },
+        operationKey: input.clientEventId
+      })
+    )
+  );
+  const response = {
+    receipt: receipt(result.receipt),
+    snapshot: await authoritativeQueue(deps.db, context.workspaceId, context.sessionId),
+    draft: composerDraft(result.draft)
+  };
+  await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
+  return response;
+}
+async function steerHumanQueuePrompt(deps, context, turnId, input) {
+  const result = await withWorkspaceRls(
+    deps.db,
+    context.workspaceId,
+    (scoped) => scoped.transaction(
+      (tx) => steerQueuedTurnInTransaction(tx, {
+        ...context,
+        turnId,
+        expectedTurnVersion: input.expectedTurnVersion,
+        controlEtag: input.controlEtag ?? null,
+        actor: { type: "human", subjectId: context.subjectId },
+        operationKey: input.clientEventId
+      })
+    )
+  );
+  const response = {
+    receipt: receipt(result.receipt),
+    snapshot: await authoritativeQueue(deps.db, context.workspaceId, context.sessionId)
+  };
+  await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
+  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
+  return response;
+}
+async function controlHumanSessionWorkstream(deps, context, input) {
+  const result = await withWorkspaceRls(
+    deps.db,
+    context.workspaceId,
+    (scoped) => scoped.transaction(
+      (tx) => mutateSessionControlInTransaction(tx, {
+        accountId: context.accountId,
+        workspaceId: context.workspaceId,
+        sessionId: context.sessionId,
+        actor: { type: "human", subjectId: context.subjectId },
+        operationKey: input.clientEventId,
+        action: input.action,
+        reason: input.reason ?? null,
+        expectedControlEtag: input.expectedControlEtag ?? null
+      })
+    )
+  );
+  const response = {
+    receipt: receipt(result.receipt),
+    effectiveControl: serializeEffectiveSessionControl(result.control),
+    interruptionCount: result.interruptionCount,
+    wakeCount: result.wakeCount
+  };
+  await publishSessionEventIds(deps, context.workspaceId, context.sessionId, [
+    result.sessionControlEventId
+  ]);
+  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
+  await requestControlWakeDispatch(deps, result.wakeCount);
+  return response;
+}
+async function controlHumanWorkspace(deps, context, input) {
+  const result = await withWorkspaceRls(
+    deps.db,
+    context.workspaceId,
+    (scoped) => scoped.transaction(
+      (tx) => mutateWorkspaceControlInTransaction(tx, {
+        accountId: context.accountId,
+        workspaceId: context.workspaceId,
+        actor: { type: "human", subjectId: context.subjectId },
+        operationKey: input.clientEventId,
+        action: input.action,
+        reason: input.reason ?? null,
+        expectedRevision: input.expectedRevision ?? null
+      })
+    )
+  );
+  const response = {
+    receipt: receipt(result.receipt),
+    state: result.workspaceState,
+    revision: result.revision,
+    interruptionCount: result.interruptionCount,
+    wakeCount: result.wakeCount
+  };
+  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
+  await requestControlWakeDispatch(deps, result.wakeCount);
+  return response;
+}
+async function getHumanComposerDraft(db, context) {
+  const row = await withWorkspaceSubjectRls2(
+    db,
+    context.workspaceId,
+    context.subjectId,
+    (scoped) => getComposerDraftInTransaction(scoped, {
+      workspaceId: context.workspaceId,
+      sessionId: context.sessionId,
+      subjectId: context.subjectId
+    })
+  );
+  const mapped = composerDraft(row);
+  if (mapped) return mapped;
+  const session = await getSession2(db, context.workspaceId, context.sessionId);
+  if (!session) throw new Error(`Session not found: ${context.sessionId}`);
+  return {
+    revision: 0,
+    text: "",
+    resources: [],
+    tools: [],
+    model: session.model,
+    reasoningEffort: reasoningEffortForMetadata2(session.metadata, "medium"),
+    sourceTurnId: null,
+    sourceTurnVersion: null,
+    updatedAt: null
+  };
+}
+async function saveHumanComposerDraft(db, context, input) {
+  const row = await withWorkspaceSubjectRls2(
+    db,
+    context.workspaceId,
+    context.subjectId,
+    (scoped) => scoped.transaction(
+      (tx) => saveComposerDraftInTransaction(tx, {
+        ...context,
+        ...input,
+        subjectId: context.subjectId
+      })
+    )
+  );
+  return composerDraft(row);
+}
 export {
   MARKETING_SOCIAL_PACK_ID,
   MAX_CHECKS_PER_RIG,
@@ -3619,6 +4040,9 @@ export {
   MAX_ENVIRONMENTS_PER_WORKSPACE,
   MAX_RIGS_PER_WORKSPACE,
   MAX_VARIABLES_PER_ENVIRONMENT,
+  SESSION_WORKFLOW_WAKE_DISPATCHER_PERIOD_MS,
+  SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID,
+  SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_TYPE,
   acceptSessionUserMessage,
   activateRigVersionForApi,
   appendRigSetupCommand,
@@ -3635,18 +4059,24 @@ export {
   buildMarketingDailyAnalysisAgentConfig,
   checkLimit,
   classifyRigVerificationOutcome,
+  controlAgentSessionWorkstream,
+  controlHumanSessionWorkstream,
+  controlHumanWorkspace,
   createAndStartSession,
   createCatalogItem,
   createRigForApi,
   createRigVersionForApi,
   createSessionForRequest,
   createValidatedScheduledTask,
+  deleteHumanQueuePrompt,
   deleteRigForApi,
   disableCapability,
   discoverMcpRegistryCapabilities,
+  editHumanQueuePrompt,
   enableCapability,
   enabledCapabilityMcpToolRefs,
   getCapabilityPack,
+  getHumanComposerDraft,
   hasPermission,
   isBuiltInCapabilityPack,
   isUserMember,
@@ -3660,6 +4090,7 @@ export {
   memberCanAdminister,
   mergeResourceRefs,
   mergeToolRefs,
+  moveHumanQueuePrompt,
   normalizeResources,
   officialMcpRegistryUrl,
   postUserMessageTurn,
@@ -3691,13 +4122,17 @@ export {
   rigActorForGrant,
   routingEnabled,
   runOnSandbox,
+  saveHumanComposerDraft,
   scheduledTaskTemporalScheduleId,
   scheduledTaskToolsProvided,
   scheduledTaskTriggerToken,
+  sendAgentSessionMessage,
   settingsWithEnabledCapabilityMcpServers,
   settingsWithMcpCapabilityServers,
   settingsWithSessionMcpServerMetadata,
   stableJson,
+  steerAgentSession,
+  steerHumanQueuePrompt,
   swapActiveSandbox,
   syncCreatedScheduledTask,
   syncUpdatedScheduledTask,