@opengeni/worker-bundle 0.2.1 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -44,7 +44,7 @@ import {
44
44
  consumeSessionCompactionRequest,
45
45
  countSessionHistoryItems,
46
46
  getActiveSessionHistoryItems as getActiveSessionHistoryItems3,
47
- nextSessionHistoryPosition,
47
+ nextSessionHistoryPosition as nextSessionHistoryPosition2,
48
48
  requeuePreemptedTurn,
49
49
  saveRunState,
50
50
  upsertSandboxSessionEnvelope,
@@ -62,8 +62,10 @@ import {
62
62
  maxTurnsExceededRunState,
63
63
  modelResponseUsageFromSdkEvent,
64
64
  normalizeSdkEvent,
65
- sanitizeHistoryItemsForModel,
66
- summarizeForCompaction as summarizeForCompaction2
65
+ sanitizeHistoryItemsForModel as sanitizeHistoryItemsForModel2,
66
+ summarizeForCompaction as summarizeForCompaction2,
67
+ findCompactionNeededError,
68
+ SUMMARY_BUFFER_TOKENS as SUMMARY_BUFFER_TOKENS2
67
69
  } from "@opengeni/runtime";
68
70
  import { calculateModelUsageCostMicros, configuredModelPricing, configuredStaticUsageLimits as configuredStaticUsageLimits2, sandboxWarmRateMicrosPerSecond } from "@opengeni/config";
69
71
  import { CancelledFailure } from "@temporalio/activity";
@@ -83,12 +85,46 @@ import {
83
85
  import {
84
86
  decryptedCapabilityHeaders,
85
87
  listEnabledMcpCapabilityServers,
88
+ listSessionMcpServerMetadata,
89
+ listSessionMcpServersForRun,
86
90
  workspaceCodexSubscriptionActive
87
91
  } from "@opengeni/db";
88
92
  async function settingsWithEnabledCapabilityMcpServers(db, workspaceId, settings) {
89
93
  const enabled = await listEnabledMcpCapabilityServers(db, workspaceId);
90
94
  return settingsWithMcpCapabilityServers(settings, enabled);
91
95
  }
96
+ async function settingsWithSessionMcpServersForRun(db, workspaceId, sessionId, settings) {
97
+ const encryptionKey = environmentsEncryptionKeyBytes(settings);
98
+ if (!encryptionKey) {
99
+ const metadata = await listSessionMcpServerMetadata(db, workspaceId, sessionId);
100
+ if (metadata.length === 0) {
101
+ return settings;
102
+ }
103
+ throw new Error("session MCP server credentials require OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY");
104
+ }
105
+ return settingsWithSessionMcpServers(settings, await listSessionMcpServersForRun(db, workspaceId, sessionId, encryptionKey));
106
+ }
107
+ function settingsWithSessionMcpServers(settings, servers) {
108
+ if (servers.length === 0) {
109
+ return settings;
110
+ }
111
+ const sessionIds = new Set(servers.map((server) => server.id));
112
+ return {
113
+ ...settings,
114
+ mcpServers: [
115
+ ...settings.mcpServers.filter((server) => !sessionIds.has(server.id)),
116
+ ...servers.map((server) => ({
117
+ id: server.id,
118
+ ...server.name ? { name: server.name } : {},
119
+ url: server.url,
120
+ ...server.allowedTools ? { allowedTools: server.allowedTools } : {},
121
+ ...server.timeoutMs ? { timeoutMs: server.timeoutMs } : {},
122
+ cacheToolsList: server.cacheToolsList ?? false,
123
+ headers: server.headers
124
+ }))
125
+ ]
126
+ };
127
+ }
92
128
  async function settingsWithCodexCredential(db, workspaceId, settings, activeOverride) {
93
129
  const active = activeOverride ?? await workspaceCodexSubscriptionActive(db, settings, workspaceId);
94
130
  if (!active) {
@@ -324,19 +360,19 @@ function workflowIdForSession(sessionId) {
324
360
  // src/activities/context-compaction.ts
325
361
  import {
326
362
  applyContextCompaction,
327
- getActiveSessionHistoryItems
363
+ getActiveSessionHistoryItems,
364
+ nextSessionHistoryPosition
328
365
  } from "@opengeni/db";
329
366
  import {
330
- buildCompactionMessages,
331
- buildSummaryItem,
332
- planCompaction,
367
+ SUMMARY_BUFFER_TOKENS,
368
+ buildCompactionPromptInput,
369
+ buildCompactionReplacementHistory,
370
+ decideClientCompaction,
371
+ sanitizeHistoryItemsForModel,
333
372
  summarizeForCompaction
334
373
  } from "@opengeni/runtime";
335
- import {
336
- contextInputBudgetTokens,
337
- resolveContextCompactionMode
338
- } from "@opengeni/config";
339
- async function maybeCompactContext(db, settings, scope, lastInputTokens, summarize = (s, m) => summarizeForCompaction(s, m, { maxOutputTokens: s.contextSummaryMaxTokens }), options = {}) {
374
+ import { resolveContextCompactionMode } from "@opengeni/config";
375
+ async function maybeCompactContext(db, settings, scope, lastInputTokens, summarize = (s, m) => summarizeForCompaction(s, m, { maxOutputTokens: SUMMARY_BUFFER_TOKENS }), options = {}) {
340
376
  if (resolveContextCompactionMode(settings) !== "client") {
341
377
  return { compacted: false, reason: "mode_not_client" };
342
378
  }
@@ -344,48 +380,50 @@ async function maybeCompactContext(db, settings, scope, lastInputTokens, summari
344
380
  if (active.length === 0) {
345
381
  return { compacted: false, reason: "no_history" };
346
382
  }
347
- const items = active.map((row) => row.item);
348
- const plan = planCompaction({
383
+ const items = sanitizeHistoryItemsForModel(active.map((row) => row.item));
384
+ const decision = decideClientCompaction({
349
385
  items,
350
386
  lastInputTokens,
351
- inputBudgetTokens: contextInputBudgetTokens(settings),
352
- softFraction: settings.contextCompactSoftFraction,
353
- hardFraction: settings.contextCompactHardFraction,
354
- keepRecentTokens: settings.contextKeepRecentTokens,
387
+ contextWindowTokens: settings.contextWindowTokens,
388
+ contextReservedOutputTokens: settings.contextReservedOutputTokens,
355
389
  ...options.force ? { force: true } : {}
356
390
  });
357
- if (!plan.shouldCompact) {
358
- return { compacted: false, reason: plan.reason };
359
- }
360
- if (plan.hardForced) {
361
- console.warn(
362
- `context compaction HARD-FORCED for session ${scope.sessionId}: signal ${plan.signalTokens} tokens at/over hard ceiling`
363
- );
391
+ if (!decision.shouldCompact) {
392
+ return { compacted: false, reason: decision.reason };
364
393
  }
365
- const messages = buildCompactionMessages(plan);
366
- const summaryBody = await summarize(settings, messages);
394
+ const promptInput = buildCompactionPromptInput(items);
395
+ const summaryBody = await summarize(settings, promptInput);
367
396
  if (!summaryBody) {
368
397
  return { compacted: false, reason: "summarize_failed" };
369
398
  }
370
- const boundaryRow = active[plan.boundaryIndex];
371
- if (!boundaryRow) {
372
- return { compacted: false, reason: "boundary_out_of_range" };
399
+ const replacementHistory = buildCompactionReplacementHistory(items, summaryBody);
400
+ const summaryItem = replacementHistory.at(-1);
401
+ if (!summaryItem) {
402
+ return { compacted: false, reason: "empty_replacement_history" };
373
403
  }
374
- const boundaryPosition = boundaryRow.position;
375
- if (boundaryPosition <= 0) {
376
- return { compacted: false, reason: "boundary_at_origin" };
377
- }
378
- const summaryPosition = boundaryPosition - 0.5;
404
+ const nextPosition = await nextSessionHistoryPosition(db, scope.workspaceId, scope.sessionId);
405
+ const replacementItems = replacementHistory.slice(0, -1).map((item, index) => ({
406
+ position: nextPosition + index,
407
+ item
408
+ }));
409
+ const summaryPosition = nextPosition + replacementItems.length;
379
410
  await applyContextCompaction(db, {
380
411
  accountId: scope.accountId,
381
412
  workspaceId: scope.workspaceId,
382
413
  sessionId: scope.sessionId,
383
414
  turnId: scope.turnId ?? null,
384
- boundaryPosition,
415
+ boundaryPosition: nextPosition,
416
+ replacementItems,
385
417
  summaryPosition,
386
- summaryItem: buildSummaryItem(summaryBody)
418
+ summaryItem
387
419
  });
388
- return { compacted: true, supersededFrom: boundaryPosition, summaryPosition, hardForced: plan.hardForced };
420
+ return {
421
+ compacted: true,
422
+ supersededFrom: nextPosition,
423
+ summaryPosition,
424
+ signalTokens: decision.signalTokens,
425
+ thresholdTokens: decision.thresholdTokens
426
+ };
389
427
  }
390
428
 
391
429
  // src/activities/environment.ts
@@ -886,7 +924,7 @@ function isPlainObject(value) {
886
924
  }
887
925
 
888
926
  // src/activities/run-input.ts
889
- import { contextInputBudgetTokens as contextInputBudgetTokens2, resolveContextCompactionMode as resolveContextCompactionMode2 } from "@opengeni/config";
927
+ import { contextInputBudgetTokens, resolveContextCompactionMode as resolveContextCompactionMode2 } from "@opengeni/config";
890
928
  import {
891
929
  getActiveSessionHistoryItems as getActiveSessionHistoryItems2,
892
930
  getLatestRunState,
@@ -1030,7 +1068,7 @@ function readPathBudgetTokens(settings) {
1030
1068
  if (!settings || resolveContextCompactionMode2(settings) !== "client") {
1031
1069
  return void 0;
1032
1070
  }
1033
- const budget = contextInputBudgetTokens2(settings);
1071
+ const budget = contextInputBudgetTokens(settings);
1034
1072
  return budget > 0 ? budget : void 0;
1035
1073
  }
1036
1074
  async function userMessageTextWithAttachments(db, workspaceId, text, resources) {
@@ -1635,6 +1673,10 @@ function selectCodexCredentialForTurn(args) {
1635
1673
  }
1636
1674
  return null;
1637
1675
  }
1676
+ var CONTEXT_OVERFLOW_RESUME_TEXT = [
1677
+ "[TURN RESUMED AFTER CONTEXT COMPACTION] The conversation approached or exceeded the model's context window mid-turn; older history above was compacted into a summary.",
1678
+ "Continue the original task from where it left off. Before repeating any action with side effects, check whether it already happened."
1679
+ ].join("\n");
1638
1680
  var WORKER_SHUTDOWN_RESUME_TEXT = [
1639
1681
  "[TURN RESUMED AFTER WORKER RESTART] The platform worker running this turn restarted (deploy/rollout) before the turn finished.",
1640
1682
  "Your conversation history above, including this turn's earlier work, is preserved up to the last checkpoint; at most the single in-flight model step after it was lost.",
@@ -1648,6 +1690,47 @@ var WORKER_DEATH_RESUME_TEXT = [
1648
1690
  function isWorkerShutdownCancellation(error) {
1649
1691
  return error instanceof CancelledFailure && error.message === "WORKER_SHUTDOWN";
1650
1692
  }
1693
+ var CONTEXT_WINDOW_OVERFLOW_RECOVERY_MESSAGE = "The conversation reached the model context compaction threshold; it has been compacted. Send a message to continue.";
1694
+ function classifyContextWindowOverflowError(error) {
1695
+ const fields = collectErrorStrings(error);
1696
+ const matched = fields.find(
1697
+ (value) => /context[_\s-]*length[_\s-]*exceeded/i.test(value) || /exceeds?\s+(?:the\s+)?context\s+window/i.test(value) || /maximum\s+context\s+length/i.test(value) || /context\s+window[^.]*exceed/i.test(value)
1698
+ );
1699
+ if (!matched) {
1700
+ return null;
1701
+ }
1702
+ const message = error instanceof Error ? error.message : String(error);
1703
+ const code = fields.find((value) => /context[_\s-]*length[_\s-]*exceeded/i.test(value));
1704
+ return {
1705
+ message,
1706
+ ...code ? { code } : {},
1707
+ ...matched && matched !== message ? { detail: matched } : {}
1708
+ };
1709
+ }
1710
+ function collectErrorStrings(value, seen = /* @__PURE__ */ new WeakSet()) {
1711
+ if (typeof value === "string") {
1712
+ return [value];
1713
+ }
1714
+ if (!value || typeof value !== "object") {
1715
+ return [];
1716
+ }
1717
+ if (seen.has(value)) {
1718
+ return [];
1719
+ }
1720
+ seen.add(value);
1721
+ const out = [];
1722
+ const record = value;
1723
+ for (const key of ["message", "code", "type", "name", "param"]) {
1724
+ const field = record[key];
1725
+ if (typeof field === "string" && field.length > 0) {
1726
+ out.push(field);
1727
+ }
1728
+ }
1729
+ for (const key of ["error", "cause", "response", "data"]) {
1730
+ out.push(...collectErrorStrings(record[key], seen));
1731
+ }
1732
+ return out;
1733
+ }
1651
1734
  function modelUsageSourceKey(input) {
1652
1735
  if (input.responseId) {
1653
1736
  return input.responseId;
@@ -1655,7 +1738,7 @@ function modelUsageSourceKey(input) {
1655
1738
  return input.dispatchId ? `${input.dispatchId}:${input.positionalKey}` : input.positionalKey;
1656
1739
  }
1657
1740
  function historyRowsToAppend(rawHistory, persistedHistoryCount, nextPosition = persistedHistoryCount) {
1658
- const sanitized = sanitizeHistoryItemsForModel(rawHistory);
1741
+ const sanitized = sanitizeHistoryItemsForModel2(rawHistory);
1659
1742
  if (sanitized.length <= persistedHistoryCount) {
1660
1743
  return { rows: [], nextWatermark: persistedHistoryCount, nextPosition };
1661
1744
  }
@@ -1665,8 +1748,20 @@ function historyRowsToAppend(rawHistory, persistedHistoryCount, nextPosition = p
1665
1748
  }));
1666
1749
  return { rows, nextWatermark: sanitized.length, nextPosition: nextPosition + rows.length };
1667
1750
  }
1751
+ function isModelOrToolProgressHistoryItem(item) {
1752
+ if (item.type === "message") {
1753
+ return item.role === "assistant";
1754
+ }
1755
+ if (item.type === "reasoning" || item.type === "compaction") {
1756
+ return true;
1757
+ }
1758
+ if (typeof item.type === "string") {
1759
+ return item.type !== "message";
1760
+ }
1761
+ return false;
1762
+ }
1668
1763
  function reconcileSeedCount(activeSeedRows, modelHistoryFromItems, current) {
1669
- return sanitizeHistoryItemsForModel(
1764
+ return sanitizeHistoryItemsForModel2(
1670
1765
  modelHistoryFromItems ? applyCodexHistoryStrip(activeSeedRows, current) : activeSeedRows.map((row) => row.item)
1671
1766
  ).length;
1672
1767
  }
@@ -1689,6 +1784,18 @@ async function resolveActiveSandboxBackend(routingOn, loadPointer, loadSandboxKi
1689
1784
  function shouldStartOnTurnRecording(params) {
1690
1785
  return params.recordingEnabled && params.desktopEnabled && desktopCapableBackend2(params.establishedBackendId) && params.effectiveBackend !== "selfhosted";
1691
1786
  }
1787
+ function computerToolModeForTurn(resolvedModel) {
1788
+ if (!resolvedModel) {
1789
+ return "hosted";
1790
+ }
1791
+ if (resolvedModel.provider.kind === "codex-subscription") {
1792
+ return "function-image";
1793
+ }
1794
+ if (resolvedModel.provider.api === "chat") {
1795
+ return "function-text";
1796
+ }
1797
+ return "hosted";
1798
+ }
1692
1799
  async function refreshCappedCodexUsageRows(db, settings, workspaceId, accounts) {
1693
1800
  const nearPct = settings.codexRotationNearExhaustionPct;
1694
1801
  const stale = accounts.filter(
@@ -1721,14 +1828,19 @@ function createRunAgentTurnActivity(services) {
1721
1828
  let activeRecording = null;
1722
1829
  let didComputerUse = false;
1723
1830
  let batcher = null;
1831
+ const flushRuntimeBatcher = async () => {
1832
+ const current = batcher;
1833
+ await current?.flush().catch(() => void 0);
1834
+ };
1724
1835
  let preparedTools = null;
1725
1836
  let publish = null;
1726
1837
  let turnStartedPublished = false;
1727
1838
  let stream;
1728
1839
  let persistedHistoryCount = 0;
1729
1840
  let historyCountAtTurnStart = 0;
1841
+ let modelOrToolProgressPersisted = false;
1730
1842
  let nextHistoryPosition = 0;
1731
- const reconcileConversationTruth = async () => {
1843
+ const reconcileConversationTruth = async (options = {}) => {
1732
1844
  if (!stream || !turnId) {
1733
1845
  return;
1734
1846
  }
@@ -1740,7 +1852,9 @@ function createRunAgentTurnActivity(services) {
1740
1852
  persistedHistoryCount,
1741
1853
  nextHistoryPosition
1742
1854
  );
1743
- if (rows.length > 0) {
1855
+ const hasModelOrToolProgress = rows.some((row) => isModelOrToolProgressHistoryItem(row.item));
1856
+ const shouldAppendRows = rows.length > 0 && (!options.skipInputOnlyRows || hasModelOrToolProgress);
1857
+ if (shouldAppendRows) {
1744
1858
  await appendSessionHistoryItems(db, {
1745
1859
  accountId: input.accountId,
1746
1860
  workspaceId: input.workspaceId,
@@ -1754,8 +1868,13 @@ function createRunAgentTurnActivity(services) {
1754
1868
  items: rows
1755
1869
  });
1756
1870
  }
1757
- persistedHistoryCount = nextWatermark;
1758
- nextHistoryPosition = nextPosition;
1871
+ if (shouldAppendRows || !options.skipInputOnlyRows) {
1872
+ persistedHistoryCount = nextWatermark;
1873
+ nextHistoryPosition = nextPosition;
1874
+ }
1875
+ if (hasModelOrToolProgress) {
1876
+ modelOrToolProgressPersisted = true;
1877
+ }
1759
1878
  }
1760
1879
  const envelope = sandboxStateEntryFromRunState(stream.state);
1761
1880
  if (envelope) {
@@ -1932,12 +2051,13 @@ function createRunAgentTurnActivity(services) {
1932
2051
  }
1933
2052
  const packRuntime = await resolveWorkspacePackRuntime(db, input.workspaceId);
1934
2053
  const workspaceAgentInstructions = await resolveWorkspaceAgentInstructions(db, input.workspaceId);
1935
- const runSettings = {
2054
+ const baseRunSettings = {
1936
2055
  ...settingsWithPackSandboxImage(capabilitySettings, packRuntime.sandboxImage),
1937
2056
  openaiModel: turn.model,
1938
2057
  openaiReasoningEffort: turn.reasoningEffort,
1939
2058
  sandboxBackend: turn.sandboxBackend
1940
2059
  };
2060
+ const runSettings = await settingsWithSessionMcpServersForRun(db, input.workspaceId, input.sessionId, baseRunSettings);
1941
2061
  const resolvedModel = runtime.resolveTurnModel(capabilitySettings, turn.model);
1942
2062
  const codexContext = resolvedModel?.provider.kind === "codex-subscription" ? (() => {
1943
2063
  const resolver = buildCodexTokenResolver(db, runSettings, input.workspaceId, effectiveCodexCredentialId ?? "");
@@ -2193,8 +2313,13 @@ function createRunAgentTurnActivity(services) {
2193
2313
  // (built-in OpenAI/Azure = real hosted support; registry "chat"
2194
2314
  // providers = the SDK's own ChatCompletions detection) keeps the SDK
2195
2315
  // default.
2196
- structuredToolTransport: resolvedModel.provider.kind !== "codex-subscription"
2197
- } : {},
2316
+ structuredToolTransport: resolvedModel.provider.kind !== "codex-subscription",
2317
+ // EXPLICIT computer-use tool transport, derived from the resolved provider's
2318
+ // authoritative wire identity (codex → function-image, chat → function-text,
2319
+ // responses → hosted) so the runtime never string-sniffs the model instance's
2320
+ // constructor name. See {@link computerToolModeForTurn}.
2321
+ computerToolMode: computerToolModeForTurn(resolvedModel)
2322
+ } : { computerToolMode: computerToolModeForTurn(null) },
2198
2323
  ...packRuntime.skills.length > 0 ? { packSkills: packRuntime.skills } : {},
2199
2324
  ...workspaceAgentInstructions ? { instructionsTemplate: workspaceAgentInstructions } : {},
2200
2325
  ...workspaceEnvironment ? {
@@ -2205,6 +2330,12 @@ function createRunAgentTurnActivity(services) {
2205
2330
  }
2206
2331
  } : {}
2207
2332
  });
2333
+ const compactSummarizer = resolvedModel ? (s, m) => withCodex(() => summarizeForCompaction2(s, m, {
2334
+ client: resolvedModel.client,
2335
+ api: resolvedModel.provider.api,
2336
+ model: resolvedModel.configured.id,
2337
+ maxOutputTokens: SUMMARY_BUFFER_TOKENS2
2338
+ })) : void 0;
2208
2339
  if (triggerType === "user.message" || triggerType === "goal.continuation") {
2209
2340
  try {
2210
2341
  const forced = await consumeSessionCompactionRequest(db, input.workspaceId, input.sessionId);
@@ -2217,199 +2348,335 @@ function createRunAgentTurnActivity(services) {
2217
2348
  // registry provider, summarize on THAT provider's client + wire API
2218
2349
  // (a chat provider can't summarize through OpenAI/Azure). Null
2219
2350
  // resolution keeps the default built-in Responses summarizer.
2220
- resolvedModel ? (s, m) => withCodex(() => summarizeForCompaction2(s, m, {
2221
- client: resolvedModel.client,
2222
- api: resolvedModel.provider.api,
2223
- model: resolvedModel.configured.id,
2224
- maxOutputTokens: s.contextSummaryMaxTokens
2225
- })) : void 0,
2351
+ compactSummarizer,
2226
2352
  forced ? { force: true } : {}
2227
2353
  );
2228
2354
  if (outcome.compacted) {
2229
- const trigger2 = forced ? "operator" : outcome.hardForced ? "hard" : void 0;
2355
+ const trigger2 = forced ? "operator" : void 0;
2230
2356
  await publish([{ type: "session.context.compacted", payload: { summaryPosition: outcome.summaryPosition, ...trigger2 ? { trigger: trigger2 } : {} } }]);
2231
2357
  }
2232
2358
  } catch (compactError) {
2233
2359
  console.error("context compaction failed (turn proceeds un-compacted)", compactError);
2234
2360
  }
2235
2361
  }
2236
- const { input: runInput, modelHistoryFromItems } = await turnInput(
2237
- db,
2238
- runtime,
2239
- agent,
2240
- trigger,
2241
- runSettings,
2242
- { currentCodexCredentialId: effectiveCodexCredentialId }
2243
- );
2244
- const activeSeedRows = await getActiveSessionHistoryItems3(db, input.workspaceId, input.sessionId);
2245
- persistedHistoryCount = reconcileSeedCount(
2246
- activeSeedRows,
2247
- modelHistoryFromItems,
2248
- { currentCodexCredentialId: effectiveCodexCredentialId }
2249
- );
2250
- historyCountAtTurnStart = persistedHistoryCount;
2251
- nextHistoryPosition = await nextSessionHistoryPosition(db, input.workspaceId, input.sessionId);
2252
- let responseUsageCount = 0;
2253
- let lastInputTokensObserved = null;
2254
- throwIfWorkerShuttingDown();
2255
- const runStreamOnce = () => runtime.runStream(agent, runInput, runSettings, {
2256
- sandboxEnvironment,
2257
- onRuntimeEvent: async (event) => {
2258
- await publish([{ type: event.type, payload: event.payload }], true);
2259
- },
2260
- // P1.2: inject the resumed box NON-OWNED (the SDK never reaps it — the
2261
- // keystone). Absent when the flag is off -> legacy build-and-discard.
2262
- ...resolvedSandbox ? {
2263
- ownedSandbox: {
2264
- client: resolvedSandbox.established.client,
2265
- session: resolvedSandbox.established.session,
2266
- sessionState: resolvedSandbox.established.sessionState,
2267
- // Pin platform setup (hooks + file materialization) to the un-proxied
2268
- // established box — never through the routing proxy, which would
2269
- // re-route those execs onto a machine swapped in mid-turn.
2270
- ...setupBoxSession ? { setupSession: setupBoxSession } : {}
2271
- }
2272
- } : {}
2273
- });
2274
- stream = await withCodex(runStreamOnce);
2275
- batcher = createRuntimeBatcher(async (events) => {
2276
- await publish(events);
2277
- });
2278
- const iterator = stream.toStream()[Symbol.asyncIterator]();
2279
- let streamDone = false;
2280
- try {
2281
- while (true) {
2282
- const next = await nextStreamEvent(iterator, activityContext);
2283
- if (next.done) {
2284
- streamDone = true;
2285
- break;
2286
- }
2287
- const responseUsage = modelResponseUsageFromSdkEvent(next.value);
2288
- if (responseUsage) {
2289
- responseUsageCount += 1;
2290
- const observed = responseUsage.usage?.inputTokens;
2291
- if (typeof observed === "number" && observed > 0) {
2292
- lastInputTokensObserved = observed;
2362
+ const activeTurnId = turnId;
2363
+ if (!activeTurnId) {
2364
+ throw new Error("Turn id was not initialized");
2365
+ }
2366
+ let runInput = null;
2367
+ const prepareRunAttemptInput = async () => {
2368
+ const prepared = await turnInput(
2369
+ db,
2370
+ runtime,
2371
+ agent,
2372
+ trigger,
2373
+ runSettings,
2374
+ { currentCodexCredentialId: effectiveCodexCredentialId }
2375
+ );
2376
+ runInput = prepared.input;
2377
+ const activeSeedRows = await getActiveSessionHistoryItems3(db, input.workspaceId, input.sessionId);
2378
+ persistedHistoryCount = reconcileSeedCount(
2379
+ activeSeedRows,
2380
+ prepared.modelHistoryFromItems,
2381
+ { currentCodexCredentialId: effectiveCodexCredentialId }
2382
+ );
2383
+ historyCountAtTurnStart = persistedHistoryCount;
2384
+ nextHistoryPosition = await nextSessionHistoryPosition2(db, input.workspaceId, input.sessionId);
2385
+ };
2386
+ const forceContextCompaction = async (triggerLabel) => {
2387
+ const clientCompactionSettings = { ...runSettings, contextCompactionMode: "client" };
2388
+ const outcome = await maybeCompactContext(
2389
+ db,
2390
+ clientCompactionSettings,
2391
+ { accountId: input.accountId, workspaceId: input.workspaceId, sessionId: input.sessionId, turnId: activeTurnId },
2392
+ session.lastInputTokens,
2393
+ compactSummarizer,
2394
+ { force: true }
2395
+ );
2396
+ if (outcome.compacted) {
2397
+ await publish([{ type: "session.context.compacted", payload: { summaryPosition: outcome.summaryPosition, trigger: triggerLabel } }]);
2398
+ }
2399
+ return outcome;
2400
+ };
2401
+ const runStreamAttempt = async () => {
2402
+ if (!runInput) {
2403
+ throw new Error("Run input was not prepared");
2404
+ }
2405
+ stream = void 0;
2406
+ batcher = null;
2407
+ let responseUsageCount = 0;
2408
+ let lastInputTokensObserved = null;
2409
+ throwIfWorkerShuttingDown();
2410
+ const runStreamOnce = () => runtime.runStream(agent, runInput, runSettings, {
2411
+ sandboxEnvironment,
2412
+ onRuntimeEvent: async (event) => {
2413
+ await publish([{ type: event.type, payload: event.payload }], true);
2414
+ },
2415
+ // P1.2: inject the resumed box NON-OWNED (the SDK never reaps it — the
2416
+ // keystone). Absent when the flag is off -> legacy build-and-discard.
2417
+ ...resolvedSandbox ? {
2418
+ ownedSandbox: {
2419
+ client: resolvedSandbox.established.client,
2420
+ session: resolvedSandbox.established.session,
2421
+ sessionState: resolvedSandbox.established.sessionState,
2422
+ // Pin platform setup (hooks + file materialization) to the un-proxied
2423
+ // established box — never through the routing proxy, which would
2424
+ // re-route those execs onto a machine swapped in mid-turn.
2425
+ ...setupBoxSession ? { setupSession: setupBoxSession } : {}
2293
2426
  }
2294
- await recordModelUsageAndDebitCredits(settings, db, {
2295
- accountId: input.accountId,
2296
- workspaceId: input.workspaceId,
2297
- sessionId: input.sessionId,
2298
- turnId,
2299
- model: turn.model,
2300
- isCodexTurn,
2301
- usage: responseUsage.usage,
2302
- sourceKey: modelUsageSourceKey({
2303
- responseId: responseUsage.responseId,
2304
- dispatchId,
2305
- positionalKey: `response-${responseUsageCount}`
2306
- })
2307
- });
2308
- await reconcileConversationTruth();
2309
- try {
2310
- await ensureRunAllowed(settings, db, input.accountId, input.workspaceId, isCodexTurn, entitlements);
2311
- } catch (limitError) {
2312
- let serializedRunState = null;
2427
+ } : {},
2428
+ contextCompactionSignalTokens: () => lastInputTokensObserved
2429
+ });
2430
+ stream = await withCodex(runStreamOnce);
2431
+ batcher = createRuntimeBatcher(async (events) => {
2432
+ await publish(events);
2433
+ });
2434
+ const iterator = stream.toStream()[Symbol.asyncIterator]();
2435
+ let streamDone = false;
2436
+ try {
2437
+ while (true) {
2438
+ const next = await nextStreamEvent(iterator, activityContext);
2439
+ if (next.done) {
2440
+ streamDone = true;
2441
+ break;
2442
+ }
2443
+ const responseUsage = modelResponseUsageFromSdkEvent(next.value);
2444
+ if (responseUsage) {
2445
+ responseUsageCount += 1;
2446
+ const observed = responseUsage.usage?.inputTokens;
2447
+ if (typeof observed === "number" && observed > 0) {
2448
+ lastInputTokensObserved = observed;
2449
+ await setSessionLastInputTokens(db, input.workspaceId, input.sessionId, observed).catch((error) => console.error("persist last_input_tokens failed (non-fatal)", error));
2450
+ }
2451
+ await recordModelUsageAndDebitCredits(settings, db, {
2452
+ accountId: input.accountId,
2453
+ workspaceId: input.workspaceId,
2454
+ sessionId: input.sessionId,
2455
+ turnId: activeTurnId,
2456
+ model: turn.model,
2457
+ isCodexTurn,
2458
+ usage: responseUsage.usage,
2459
+ sourceKey: modelUsageSourceKey({
2460
+ responseId: responseUsage.responseId,
2461
+ dispatchId,
2462
+ positionalKey: `response-${responseUsageCount}`
2463
+ })
2464
+ });
2465
+ await reconcileConversationTruth();
2313
2466
  try {
2314
- serializedRunState = stream.state.toString();
2315
- } catch {
2316
- serializedRunState = null;
2467
+ await ensureRunAllowed(settings, db, input.accountId, input.workspaceId, isCodexTurn, entitlements);
2468
+ } catch (limitError) {
2469
+ let serializedRunState = null;
2470
+ try {
2471
+ serializedRunState = stream.state.toString();
2472
+ } catch {
2473
+ serializedRunState = null;
2474
+ }
2475
+ throw new BudgetExhaustedError(
2476
+ limitError instanceof Error ? limitError.message : String(limitError),
2477
+ serializedRunState
2478
+ );
2317
2479
  }
2318
- throw new BudgetExhaustedError(
2319
- limitError instanceof Error ? limitError.message : String(limitError),
2320
- serializedRunState
2321
- );
2480
+ }
2481
+ if (activeRecording && !didComputerUse && isComputerCallStreamEvent(next.value)) {
2482
+ didComputerUse = true;
2483
+ }
2484
+ const normalized = normalizeSdkEvent(next.value);
2485
+ for (const event of normalized) {
2486
+ await batcher.push(event);
2322
2487
  }
2323
2488
  }
2324
- if (activeRecording && !didComputerUse && isComputerCallStreamEvent(next.value)) {
2325
- didComputerUse = true;
2489
+ } finally {
2490
+ if (!streamDone) {
2491
+ await iterator.return?.();
2326
2492
  }
2327
- const normalized = normalizeSdkEvent(next.value);
2328
- for (const event of normalized) {
2329
- await batcher.push(event);
2493
+ }
2494
+ await batcher.flush();
2495
+ await stream.completed.catch(() => void 0);
2496
+ if (responseUsageCount === 0) {
2497
+ const aggregateInput = stream.state.usage?.inputTokens;
2498
+ if (typeof aggregateInput === "number" && aggregateInput > 0) {
2499
+ lastInputTokensObserved = aggregateInput;
2330
2500
  }
2501
+ await recordModelUsageAndDebitCredits(settings, db, {
2502
+ accountId: input.accountId,
2503
+ workspaceId: input.workspaceId,
2504
+ sessionId: input.sessionId,
2505
+ turnId: activeTurnId,
2506
+ model: turn.model,
2507
+ isCodexTurn,
2508
+ usage: stream.state.usage,
2509
+ sourceKey: modelUsageSourceKey({ responseId: null, dispatchId, positionalKey: "aggregate" })
2510
+ });
2331
2511
  }
2332
- } finally {
2333
- if (!streamDone) {
2334
- await iterator.return?.();
2512
+ if (lastInputTokensObserved !== null) {
2513
+ await setSessionLastInputTokens(db, input.workspaceId, input.sessionId, lastInputTokensObserved).catch((error) => console.error("persist last_input_tokens failed (non-fatal)", error));
2335
2514
  }
2336
- }
2337
- await batcher.flush();
2338
- await stream.completed.catch(() => void 0);
2339
- if (responseUsageCount === 0) {
2340
- const aggregateInput = stream.state.usage?.inputTokens;
2341
- if (typeof aggregateInput === "number" && aggregateInput > 0) {
2342
- lastInputTokensObserved = aggregateInput;
2515
+ if (stream.interruptions.length > 0) {
2516
+ await reconcileConversationTruth();
2517
+ const approvals = runtime.serializeApprovals(stream.interruptions);
2518
+ await saveRunState(db, {
2519
+ accountId: input.accountId,
2520
+ workspaceId: input.workspaceId,
2521
+ sessionId: input.sessionId,
2522
+ turnId: activeTurnId,
2523
+ serializedRunState: stream.state.toString(),
2524
+ pendingApprovals: approvals,
2525
+ // Record the account freezing this state so a resume on a DIFFERENT
2526
+ // codex account strips its account-bound reasoning before replay (HOLE C).
2527
+ frozenCodexCredentialId: effectiveCodexCredentialId
2528
+ });
2529
+ await publish([
2530
+ { type: "session.requiresAction", payload: { approvals } },
2531
+ { type: "session.status.changed", payload: { status: "requires_action" } }
2532
+ ], true);
2533
+ await finishTurn(db, input.workspaceId, activeTurnId, "requires_action");
2534
+ await setSessionStatus(db, input.workspaceId, input.sessionId, "requires_action", activeTurnId);
2535
+ activityStatus = "requires_action";
2536
+ return { status: "requires_action" };
2343
2537
  }
2344
- await recordModelUsageAndDebitCredits(settings, db, {
2345
- accountId: input.accountId,
2346
- workspaceId: input.workspaceId,
2347
- sessionId: input.sessionId,
2348
- turnId,
2349
- model: turn.model,
2350
- isCodexTurn,
2351
- usage: stream.state.usage,
2352
- sourceKey: modelUsageSourceKey({ responseId: null, dispatchId, positionalKey: "aggregate" })
2353
- });
2354
- }
2355
- if (lastInputTokensObserved !== null) {
2356
- await setSessionLastInputTokens(db, input.workspaceId, input.sessionId, lastInputTokensObserved).catch((error) => console.error("persist last_input_tokens failed (non-fatal)", error));
2357
- }
2358
- if (stream.interruptions.length > 0) {
2538
+ const finalOutput = String(stream.finalOutput ?? "");
2359
2539
  await reconcileConversationTruth();
2360
- const approvals = runtime.serializeApprovals(stream.interruptions);
2361
- await saveRunState(db, {
2362
- accountId: input.accountId,
2363
- workspaceId: input.workspaceId,
2364
- sessionId: input.sessionId,
2365
- turnId,
2366
- serializedRunState: stream.state.toString(),
2367
- pendingApprovals: approvals,
2368
- // Record the account freezing this state so a resume on a DIFFERENT
2369
- // codex account strips its account-bound reasoning before replay (HOLE C).
2370
- frozenCodexCredentialId: effectiveCodexCredentialId
2371
- });
2540
+ if (settings.sessionHistorySource !== "items") {
2541
+ await saveRunState(db, {
2542
+ accountId: input.accountId,
2543
+ workspaceId: input.workspaceId,
2544
+ sessionId: input.sessionId,
2545
+ turnId: activeTurnId,
2546
+ serializedRunState: stream.state.toString(),
2547
+ pendingApprovals: [],
2548
+ frozenCodexCredentialId: effectiveCodexCredentialId
2549
+ });
2550
+ }
2372
2551
  await publish([
2373
- { type: "session.requiresAction", payload: { approvals } },
2374
- { type: "session.status.changed", payload: { status: "requires_action" } }
2552
+ { type: "agent.message.completed", payload: { text: finalOutput } },
2553
+ { type: "turn.completed", payload: { output: finalOutput } },
2554
+ { type: "session.status.changed", payload: { status: "idle" } }
2375
2555
  ], true);
2376
- await finishTurn(db, input.workspaceId, turnId, "requires_action");
2377
- await setSessionStatus(db, input.workspaceId, input.sessionId, "requires_action", turnId);
2378
- activityStatus = "requires_action";
2379
- return { status: "requires_action" };
2380
- }
2381
- const finalOutput = String(stream.finalOutput ?? "");
2382
- await reconcileConversationTruth();
2383
- if (settings.sessionHistorySource !== "items") {
2384
- await saveRunState(db, {
2556
+ await finishTurn(db, input.workspaceId, activeTurnId, "idle");
2557
+ await setSessionStatus(db, input.workspaceId, input.sessionId, "idle", null);
2558
+ await recordUsageEvent2(db, {
2385
2559
  accountId: input.accountId,
2386
2560
  workspaceId: input.workspaceId,
2387
- sessionId: input.sessionId,
2388
- turnId,
2389
- serializedRunState: stream.state.toString(),
2390
- pendingApprovals: [],
2391
- frozenCodexCredentialId: effectiveCodexCredentialId
2561
+ eventType: "agent_run.completed",
2562
+ quantity: 1,
2563
+ unit: "run",
2564
+ sourceResourceType: "session_turn",
2565
+ sourceResourceId: activeTurnId,
2566
+ idempotencyKey: `usage:agent_run.completed:${activeTurnId}`
2392
2567
  });
2568
+ activityStatus = "idle";
2569
+ return { status: "idle" };
2570
+ };
2571
+ await prepareRunAttemptInput();
2572
+ let compactionRecoveryAttempted = false;
2573
+ let retriedAfterCompaction = false;
2574
+ while (true) {
2575
+ try {
2576
+ const result = await runStreamAttempt();
2577
+ if (retriedAfterCompaction) {
2578
+ observability.info("context compaction recovery succeeded after in-activity retry", {
2579
+ sessionId: input.sessionId,
2580
+ turnId: activeTurnId
2581
+ });
2582
+ }
2583
+ return result;
2584
+ } catch (attemptError) {
2585
+ const overflow = classifyContextWindowOverflowError(attemptError);
2586
+ const compactionNeeded = findCompactionNeededError(attemptError);
2587
+ const recoveryKind = compactionNeeded ? "proactive" : overflow ? "overflow" : null;
2588
+ if (!recoveryKind || !publish || !turnStartedPublished || compactionRecoveryAttempted) {
2589
+ throw attemptError;
2590
+ }
2591
+ compactionRecoveryAttempted = true;
2592
+ await flushRuntimeBatcher();
2593
+ await reconcileConversationTruth({ skipInputOnlyRows: true });
2594
+ const progressPersisted = modelOrToolProgressPersisted;
2595
+ observability.warn("context compaction recovery attempted", {
2596
+ sessionId: input.sessionId,
2597
+ turnId: activeTurnId,
2598
+ reason: recoveryKind,
2599
+ progressPersisted,
2600
+ code: overflow?.code,
2601
+ error: overflow?.message ?? compactionNeeded?.message,
2602
+ signalTokens: compactionNeeded?.signalTokens,
2603
+ thresholdTokens: compactionNeeded?.thresholdTokens
2604
+ });
2605
+ let compacted = false;
2606
+ try {
2607
+ const outcome = await forceContextCompaction(recoveryKind);
2608
+ compacted = outcome.compacted;
2609
+ } catch (compactError) {
2610
+ observability.warn("context compaction recovery compaction failed", {
2611
+ sessionId: input.sessionId,
2612
+ turnId: activeTurnId,
2613
+ error: compactError instanceof Error ? compactError.message : String(compactError)
2614
+ });
2615
+ }
2616
+ if (progressPersisted) {
2617
+ const triggerPayload = trigger.payload && typeof trigger.payload === "object" && !Array.isArray(trigger.payload) ? trigger.payload : {};
2618
+ const compactionResumedTurn = triggerType === "turn.preempted" && (triggerPayload.reason === "context_compacted" || triggerPayload.reason === "context_overflow_compacted");
2619
+ const canAutoContinue = compacted && !compactionResumedTurn && settings.sessionHistorySource === "items" && activeTurnId != null;
2620
+ if (canAutoContinue) {
2621
+ const [preemptedEvent] = await appendAndPublishEvents2(db, bus, input.workspaceId, input.sessionId, [
2622
+ {
2623
+ turnId: activeTurnId,
2624
+ type: "turn.preempted",
2625
+ payload: {
2626
+ triggerEventId: input.triggerEventId,
2627
+ reason: "context_compacted",
2628
+ resumeWithNotice: true,
2629
+ text: CONTEXT_OVERFLOW_RESUME_TEXT
2630
+ }
2631
+ },
2632
+ { turnId: activeTurnId, type: "session.status.changed", payload: { status: "queued" } }
2633
+ ]);
2634
+ await requeuePreemptedTurn(db, input.workspaceId, activeTurnId, preemptedEvent ? preemptedEvent.id : input.triggerEventId);
2635
+ await setSessionStatus(db, input.workspaceId, input.sessionId, "queued", null).catch(() => void 0);
2636
+ activityStatus = "preempted";
2637
+ observability.info("context compaction recovery succeeded by compacting and auto-continuing", {
2638
+ sessionId: input.sessionId,
2639
+ turnId: activeTurnId,
2640
+ reason: recoveryKind,
2641
+ compacted
2642
+ });
2643
+ return { status: "preempted" };
2644
+ }
2645
+ await publish([
2646
+ {
2647
+ type: "turn.failed",
2648
+ payload: {
2649
+ error: CONTEXT_WINDOW_OVERFLOW_RECOVERY_MESSAGE,
2650
+ code: recoveryKind === "overflow" ? "context_window_overflow_compacted" : "context_compacted",
2651
+ retryable: false,
2652
+ recovery: "user_message",
2653
+ compacted
2654
+ }
2655
+ },
2656
+ { type: "session.status.changed", payload: { status: "idle" } }
2657
+ ], true);
2658
+ await finishTurn(db, input.workspaceId, activeTurnId, "failed");
2659
+ await setSessionStatus(db, input.workspaceId, input.sessionId, "idle", null);
2660
+ activityStatus = "idle";
2661
+ activityError = attemptError;
2662
+ observability.info("context compaction recovery succeeded by compacting and idling", {
2663
+ sessionId: input.sessionId,
2664
+ turnId: activeTurnId,
2665
+ reason: recoveryKind,
2666
+ compacted
2667
+ });
2668
+ return { status: "idle" };
2669
+ }
2670
+ retriedAfterCompaction = true;
2671
+ observability.info("context compaction recovery retrying turn after compaction", {
2672
+ sessionId: input.sessionId,
2673
+ turnId: activeTurnId,
2674
+ reason: recoveryKind,
2675
+ compacted
2676
+ });
2677
+ await prepareRunAttemptInput();
2678
+ }
2393
2679
  }
2394
- await publish([
2395
- { type: "agent.message.completed", payload: { text: finalOutput } },
2396
- { type: "turn.completed", payload: { output: finalOutput } },
2397
- { type: "session.status.changed", payload: { status: "idle" } }
2398
- ], true);
2399
- await finishTurn(db, input.workspaceId, turnId, "idle");
2400
- await setSessionStatus(db, input.workspaceId, input.sessionId, "idle", null);
2401
- await recordUsageEvent2(db, {
2402
- accountId: input.accountId,
2403
- workspaceId: input.workspaceId,
2404
- eventType: "agent_run.completed",
2405
- quantity: 1,
2406
- unit: "run",
2407
- sourceResourceType: "session_turn",
2408
- sourceResourceId: turnId,
2409
- idempotencyKey: `usage:agent_run.completed:${turnId}`
2410
- });
2411
- activityStatus = "idle";
2412
- return { status: "idle" };
2413
2680
  } catch (error) {
2414
2681
  const preemptTurnId = turnId ?? input.turnId;
2415
2682
  if (error instanceof SandboxLeaseSupersededError2 && preemptTurnId) {
@@ -2424,7 +2691,7 @@ function createRunAgentTurnActivity(services) {
2424
2691
  }
2425
2692
  if (isWorkerShutdownCancellation(error) && preemptTurnId) {
2426
2693
  try {
2427
- await batcher?.flush().catch(() => void 0);
2694
+ await flushRuntimeBatcher();
2428
2695
  await reconcileConversationTruth();
2429
2696
  const approvalRerun = triggerType === "user.approvalDecision";
2430
2697
  let resumeWithNotice = !approvalRerun && settings.sessionHistorySource === "items" && persistedHistoryCount > historyCountAtTurnStart;
@@ -2472,7 +2739,7 @@ function createRunAgentTurnActivity(services) {
2472
2739
  if (error instanceof CancelledFailure) {
2473
2740
  activityStatus = "cancelled";
2474
2741
  activityError = error;
2475
- await batcher?.flush().catch(() => void 0);
2742
+ await flushRuntimeBatcher();
2476
2743
  if (preemptTurnId) {
2477
2744
  await finishTurn(db, input.workspaceId, preemptTurnId, "cancelled").catch(() => void 0);
2478
2745
  }
@@ -2480,7 +2747,7 @@ function createRunAgentTurnActivity(services) {
2480
2747
  }
2481
2748
  const maxTurns = maxTurnsExceededRunState(error);
2482
2749
  if (maxTurns && publish && turnId && turnStartedPublished) {
2483
- await batcher?.flush().catch(() => void 0);
2750
+ await flushRuntimeBatcher();
2484
2751
  await reconcileConversationTruth();
2485
2752
  const runStateSaved = Boolean(maxTurns.serializedRunState) && settings.sessionHistorySource !== "items";
2486
2753
  if (maxTurns.serializedRunState && settings.sessionHistorySource !== "items") {
@@ -2517,7 +2784,7 @@ function createRunAgentTurnActivity(services) {
2517
2784
  if (usageLimit && publish && turnId && turnStartedPublished) {
2518
2785
  const goal = await getSessionGoal3(db, input.workspaceId, input.sessionId).catch(() => null);
2519
2786
  const goalActive = Boolean(goal && goal.status === "active");
2520
- await batcher?.flush().catch(() => void 0);
2787
+ await flushRuntimeBatcher();
2521
2788
  await reconcileConversationTruth();
2522
2789
  const serializedRunState = agentsErrorRunState(error);
2523
2790
  const runStateSaved = Boolean(serializedRunState) && settings.sessionHistorySource !== "items";
@@ -2601,7 +2868,7 @@ function createRunAgentTurnActivity(services) {
2601
2868
  return { status: "idle" };
2602
2869
  }
2603
2870
  if (error instanceof BudgetExhaustedError && publish && turnId && turnStartedPublished) {
2604
- await batcher?.flush().catch(() => void 0);
2871
+ await flushRuntimeBatcher();
2605
2872
  await reconcileConversationTruth();
2606
2873
  const runStateSaved = Boolean(error.serializedRunState) && settings.sessionHistorySource !== "items";
2607
2874
  if (error.serializedRunState && settings.sessionHistorySource !== "items") {
@@ -2638,7 +2905,7 @@ function createRunAgentTurnActivity(services) {
2638
2905
  if (failure.retryable && publish && turnId && turnStartedPublished) {
2639
2906
  const goal = await getSessionGoal3(db, input.workspaceId, input.sessionId).catch(() => null);
2640
2907
  const goalActive = Boolean(goal && goal.status === "active");
2641
- await batcher?.flush().catch(() => void 0);
2908
+ await flushRuntimeBatcher();
2642
2909
  await reconcileConversationTruth();
2643
2910
  const serializedRunState = agentsErrorRunState(error);
2644
2911
  const runStateSaved = Boolean(serializedRunState) && settings.sessionHistorySource !== "items";
@@ -3853,7 +4120,7 @@ async function createOpenGeniWorker(options = {}) {
3853
4120
  connection,
3854
4121
  namespace: settings.temporalNamespace,
3855
4122
  taskQueue: settings.temporalTaskQueue,
3856
- workflowsPath: new URL("../src/workflows.ts", import.meta.url).pathname,
4123
+ workflowsPath: options.workflowsPath ?? new URL("../src/workflows.ts", import.meta.url).pathname,
3857
4124
  activities
3858
4125
  });
3859
4126
  return { worker, connection };