@opengeni/runtime 0.2.0

package/dist/index.js

@@ -0,0 +1,3663 @@
+import {
+  ActiveBackendUnresolvableError,
+  CAPABILITY_DESCRIPTORS,
+  ChannelAConflictError,
+  ChannelANotFoundError,
+  ChannelAUnsupportedError,
+  ChannelAValidationError,
+  DEFAULT_DESKTOP_GEOMETRY,
+  DESKTOP_STREAM_PORT,
+  DISPLAY_STACK_TIMEOUT_MS,
+  DisplayStackError,
+  DisplayStackUnsupportedError,
+  MockAgentResponder,
+  NatsControlRpc,
+  PROVIDER_REGISTRY,
+  RecordingError,
+  RecordingUnavailableError,
+  RoutingSandboxSession,
+  RoutingUnsupportedError,
+  SELFHOSTED_DEFAULT_TIMEOUT_MS,
+  SELFHOSTED_RECONNECT_WINDOW_MS,
+  SELFHOSTED_RELAY_STREAM_PATH,
+  STREAM_PORT,
+  STREAM_TOKEN_DEFAULT_TTL_SECONDS,
+  SandboxChannelAService,
+  SandboxConfigError,
+  SandboxProviderUnavailableError,
+  SelfhostedControlError,
+  SelfhostedSandboxClient,
+  SelfhostedSession,
+  StreamPortUnavailableError,
+  StreamTokenPayload,
+  TERMINAL_SERVER_TIMEOUT_MS,
+  TERMINAL_STREAM_PORT,
+  TerminalServerError,
+  TerminalServerUnsupportedError,
+  agentErrorToControlError,
+  assertDescriptorRegistryInvariants,
+  assertProviderRegistryInvariants,
+  assertSafeRelPath,
+  backendSupportsOs,
+  buildDisplayStackScript,
+  buildSelfhostedBackendSession,
+  buildStreamUrl,
+  buildTerminalServerScript,
+  collectSandboxEnvironment,
+  contentTypeForCodec,
+  createSandboxClient,
+  createSandboxClientForBackend,
+  decodeModalSnapshotId,
+  deletePriorPersistedSnapshot,
+  deleteRecordingArtifacts,
+  deserializeSandboxSessionStateEnvelope,
+  desktopCapableBackend,
+  ensureDisplayStack,
+  ensureTerminalServer,
+  establishSandboxSessionFromEnvelope,
+  exposeStreamPort,
+  extForCodec,
+  isExecSessionLostBanner,
+  isProviderSandboxNotFoundError,
+  isSelfhostedProviderNotFoundError,
+  isWorkspaceEscapeError,
+  makeActiveBackendResolver,
+  mintStreamToken,
+  negotiateCapabilities,
+  negotiateSelfhostedCapabilities,
+  offlineAgentError,
+  offlineControlResponse,
+  parseExecBannerSessionId,
+  parseExposedPorts,
+  parseNumstatZ,
+  parsePorcelainV2,
+  parseUnifiedPatch,
+  readRecordingBytes,
+  readWorkspaceArchiveFromEnvelopeSessionState,
+  recordingStorageKey,
+  restoredSandboxSessionStateFromEntry,
+  sandboxStateEntryFromRunState,
+  selectBackend,
+  selfhostedLiveness,
+  serializeEstablishedSandboxEnvelope,
+  setSelfhostedApplyDiff,
+  startRecording,
+  stopRecording,
+  stripExecBanner,
+  subjectFor,
+  tearDownDisplayStack,
+  tearDownTerminalServer,
+  timeoutAgentError,
+  timeoutControlResponse,
+  verifyStreamToken
+} from "./chunk-2PO56VAL.js";
+
+// src/index.ts
+import { AGENT_INSTRUCTIONS_CORE_PLACEHOLDER, collectSandboxEnvironment as collectSandboxEnvironment2, contextServerCompactThreshold, firstPartyMcpBaseUrl, resolveContextCompactionMode, resolveModelProvider, sandboxLifecycleHookIds } from "@opengeni/config";
+import { CAPABILITY_DESCRIPTORS as CAPABILITY_DESCRIPTORS2, isClearedRunStateBlob, signDelegatedAccessToken } from "@opengeni/contracts";
+import {
+  Agent,
+  AgentsError,
+  connectMcpServers,
+  OpenAIProvider,
+  setDefaultModelProvider,
+  MaxTurnsExceededError,
+  MCPServerStreamableHttp,
+  OpenAIChatCompletionsModel,
+  OpenAIResponsesModel,
+  RunState,
+  isOpenAIResponsesRawModelStreamEvent,
+  Runner,
+  setDefaultOpenAIClient,
+  setDefaultOpenAIKey,
+  setOpenAIResponsesTransport,
+  webSearchTool,
+  applyDiff
+} from "@openai/agents";
+import {
+  localDirLazySkillSource
+} from "@openai/agents/sandbox/local";
+import {
+  Manifest,
+  SandboxAgent,
+  StaticCompactionPolicy,
+  azureBlobMount,
+  compaction,
+  dir,
+  file,
+  filesystem,
+  gitRepo,
+  inContainerMountStrategy,
+  localDir,
+  s3Mount,
+  shell,
+  skills
+} from "@openai/agents/sandbox";
+import { ModalCloudBucketMountStrategy } from "@openai/agents-extensions/sandbox/modal";
+import OpenAI from "openai";
+import { CODEX_APPS_MCP_SERVER_ID, CODEX_MODEL_ID_PREFIX, CODEX_ORIGINATOR, codexAppsSanitizingFetch, codexRequestStorage, codexSubscriptionFetch } from "@opengeni/codex";
+import { cpSync, existsSync, mkdirSync, readdirSync, renameSync, rmSync } from "fs";
+import { dirname, isAbsolute, join, posix as posixPath, relative } from "path";
+import { fileURLToPath } from "url";
+
+// src/history-sanitizer.ts
+var RESULT_TYPE_BY_CALL_TYPE = {
+  function_call: "function_call_result",
+  computer_call: "computer_call_result",
+  shell_call: "shell_call_output",
+  apply_patch_call: "apply_patch_call_output",
+  // Progressive connector disclosure (codex tool_search): a replayed
+  // `tool_search_call` must be settled by its `tool_search_output` exactly like a
+  // function call — an unpaired one 400s the store:false replay. The SDK pairs
+  // these OUTSIDE its own TOOL_CALL_RESULT_TYPE_BY_CALL_TYPE (sessionPersistence's
+  // hasToolSearchCallId), so we mirror the semantics here; the correlation id can
+  // additionally ride providerData (see callIdOf).
+  tool_search_call: "tool_search_output"
+};
+var RESULT_TYPES = new Set(Object.values(RESULT_TYPE_BY_CALL_TYPE));
+function itemType(item) {
+  if (!item || typeof item !== "object") {
+    return void 0;
+  }
+  const type = item.type;
+  return typeof type === "string" ? type : void 0;
+}
+function callIdOf(item) {
+  if (!item || typeof item !== "object") {
+    return void 0;
+  }
+  const record = item;
+  if (typeof record.callId === "string" && record.callId.length > 0) {
+    return record.callId;
+  }
+  if (typeof record.call_id === "string" && record.call_id.length > 0) {
+    return record.call_id;
+  }
+  const provider = record.providerData;
+  if (provider && typeof provider === "object") {
+    if (typeof provider.call_id === "string" && provider.call_id.length > 0) {
+      return provider.call_id;
+    }
+    if (typeof provider.callId === "string" && provider.callId.length > 0) {
+      return provider.callId;
+    }
+  }
+  return void 0;
+}
+function sanitizeHistoryItemsForModel(items) {
+  if (items.length === 0) {
+    return [];
+  }
+  const dropped = /* @__PURE__ */ new Set();
+  const openCallIdsByResultType = /* @__PURE__ */ new Map();
+  items.forEach((item, index) => {
+    const type = itemType(item);
+    const callId = callIdOf(item);
+    if (!type || !callId) {
+      return;
+    }
+    const callResultType = RESULT_TYPE_BY_CALL_TYPE[type];
+    if (callResultType) {
+      const open = openCallIdsByResultType.get(callResultType) ?? /* @__PURE__ */ new Set();
+      open.add(callId);
+      openCallIdsByResultType.set(callResultType, open);
+      return;
+    }
+    if (RESULT_TYPES.has(type)) {
+      const open = openCallIdsByResultType.get(type);
+      if (open && open.has(callId)) {
+        open.delete(callId);
+      } else {
+        dropped.add(index);
+      }
+    }
+  });
+  const stillOpen = /* @__PURE__ */ new Map();
+  for (const [resultType, open] of openCallIdsByResultType) {
+    if (open.size > 0) {
+      stillOpen.set(resultType, new Set(open));
+    }
+  }
+  if (stillOpen.size > 0) {
+    for (let index = items.length - 1; index >= 0; index -= 1) {
+      const item = items[index];
+      const type = itemType(item);
+      const callId = callIdOf(item);
+      if (!type || !callId) {
+        continue;
+      }
+      const resultType = RESULT_TYPE_BY_CALL_TYPE[type];
+      if (!resultType) {
+        continue;
+      }
+      const open = stillOpen.get(resultType);
+      if (open && open.has(callId)) {
+        dropped.add(index);
+        open.delete(callId);
+      }
+    }
+  }
+  if (dropped.size > 0) {
+    for (let index = 0; index < items.length; index += 1) {
+      if (dropped.has(index) || itemType(items[index]) !== "reasoning") {
+        continue;
+      }
+      for (let next = index + 1; next < items.length; next += 1) {
+        if (itemType(items[next]) === "reasoning") {
+          continue;
+        }
+        if (dropped.has(next)) {
+          dropped.add(index);
+        }
+        break;
+      }
+    }
+  }
+  if (dropped.size === 0) {
+    return items.slice();
+  }
+  return items.filter((_item, index) => !dropped.has(index));
+}
+function stripReasoningEncryptedContent(item) {
+  const type = itemType(item);
+  if (type !== "reasoning" && type !== "compaction") {
+    return item;
+  }
+  const record = item;
+  const providerData = record.providerData;
+  const providerHasBlob = !!providerData && typeof providerData === "object" && ("encryptedContent" in providerData || "encrypted_content" in providerData);
+  const topLevelHasBlob = "encrypted_content" in record;
+  if (!providerHasBlob && !topLevelHasBlob) {
+    return item;
+  }
+  const clone = { ...record };
+  if (providerHasBlob) {
+    const providerClone = { ...providerData };
+    delete providerClone.encryptedContent;
+    delete providerClone.encrypted_content;
+    clone.providerData = providerClone;
+  }
+  if (topLevelHasBlob) {
+    delete clone.encrypted_content;
+  }
+  return clone;
+}
+function stripReasoningIdentityFromSerializedRunState(serialized) {
+  let parsed;
+  try {
+    parsed = JSON.parse(serialized);
+  } catch {
+    return serialized;
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return serialized;
+  }
+  let changed = false;
+  const scrubReasoning = (candidate) => {
+    if (!candidate || typeof candidate !== "object") {
+      return;
+    }
+    const record = candidate;
+    if (record.type !== "reasoning") {
+      return;
+    }
+    if ("id" in record) {
+      delete record.id;
+      changed = true;
+    }
+    const providerData = record.providerData;
+    if (providerData && typeof providerData === "object") {
+      const provider = providerData;
+      if ("encryptedContent" in provider) {
+        delete provider.encryptedContent;
+        changed = true;
+      }
+      if ("encrypted_content" in provider) {
+        delete provider.encrypted_content;
+        changed = true;
+      }
+    }
+    if ("encrypted_content" in record) {
+      delete record.encrypted_content;
+      changed = true;
+    }
+  };
+  const scrubItemArray = (arr) => {
+    if (Array.isArray(arr)) {
+      for (const item of arr) {
+        scrubReasoning(item);
+      }
+    }
+  };
+  const root = parsed;
+  scrubItemArray(root.originalInput);
+  if (Array.isArray(root.generatedItems)) {
+    for (const wrapper of root.generatedItems) {
+      if (wrapper && typeof wrapper === "object" && "rawItem" in wrapper) {
+        scrubReasoning(wrapper.rawItem);
+      }
+    }
+  }
+  const scrubResponseOutput = (response) => {
+    if (response && typeof response === "object") {
+      scrubItemArray(response.output);
+    }
+  };
+  if (Array.isArray(root.modelResponses)) {
+    for (const response of root.modelResponses) {
+      scrubResponseOutput(response);
+    }
+  }
+  scrubResponseOutput(root.lastModelResponse);
+  if (!changed) {
+    return serialized;
+  }
+  return JSON.stringify(parsed);
+}
+function neutralizeToolSearchItemsInSerializedRunState(serialized) {
+  let parsed;
+  try {
+    parsed = JSON.parse(serialized);
+  } catch {
+    return serialized;
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return serialized;
+  }
+  let changed = false;
+  const neutralize = (candidate) => {
+    if (!candidate || typeof candidate !== "object") {
+      return;
+    }
+    const record = candidate;
+    if (record.type !== "tool_search_call" && record.type !== "tool_search_output") {
+      return;
+    }
+    if (record.execution !== "server") {
+      record.execution = "server";
+      changed = true;
+    }
+  };
+  const neutralizeArray = (arr) => {
+    if (Array.isArray(arr)) {
+      for (const item of arr) {
+        neutralize(item);
+      }
+    }
+  };
+  const root = parsed;
+  neutralizeArray(root.originalInput);
+  if (Array.isArray(root.generatedItems)) {
+    for (const wrapper of root.generatedItems) {
+      if (wrapper && typeof wrapper === "object" && "rawItem" in wrapper) {
+        neutralize(wrapper.rawItem);
+      }
+    }
+  }
+  const neutralizeResponseOutput = (response) => {
+    if (response && typeof response === "object") {
+      neutralizeArray(response.output);
+    }
+  };
+  if (Array.isArray(root.modelResponses)) {
+    for (const response of root.modelResponses) {
+      neutralizeResponseOutput(response);
+    }
+  }
+  neutralizeResponseOutput(root.lastModelResponse);
+  if (!changed) {
+    return serialized;
+  }
+  return JSON.stringify(parsed);
+}
+function normalizeComputerCallActions(items) {
+  let changed = false;
+  const out = items.map((item) => {
+    if (itemType(item) !== "computer_call") {
+      return item;
+    }
+    const record = item;
+    const hasAction = record.action !== void 0 && record.action !== null;
+    const hasActions = Array.isArray(record.actions) && record.actions.length > 0;
+    if (hasAction && hasActions) {
+      changed = true;
+      const { action: _droppedAction, ...rest } = record;
+      return rest;
+    }
+    return item;
+  });
+  return changed ? out : items.slice();
+}
+function rewriteComputerCallsToActionsOnly(body) {
+  if (!body || typeof body !== "object") {
+    return false;
+  }
+  const input = body.input;
+  if (!Array.isArray(input)) {
+    return false;
+  }
+  let changed = false;
+  for (const item of input) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const record = item;
+    if (record.type !== "computer_call") {
+      continue;
+    }
+    const existingActions = Array.isArray(record.actions) && record.actions.length > 0 ? record.actions : void 0;
+    const actions = existingActions ?? (record.action !== void 0 && record.action !== null ? [record.action] : void 0);
+    if (actions === void 0) {
+      continue;
+    }
+    const hadAction = "action" in record;
+    const actionsAlreadyExact = existingActions !== void 0 && !hadAction;
+    if (actionsAlreadyExact) {
+      continue;
+    }
+    delete record.action;
+    record.actions = actions;
+    changed = true;
+  }
+  return changed;
+}
+var EMPTY_IMAGE_URL_PLACEHOLDER = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR4nGP4z8DwHwAFAAH/iZk9HQAAAABJRU5ErkJggg==";
+function rewriteEmptyComputerCallOutputImageUrls(body) {
+  if (!body || typeof body !== "object") {
+    return false;
+  }
+  const input = body.input;
+  if (!Array.isArray(input)) {
+    return false;
+  }
+  let changed = false;
+  for (const item of input) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const record = item;
+    if (record.type !== "computer_call_output") {
+      continue;
+    }
+    const output = record.output;
+    if (!output || typeof output !== "object") {
+      continue;
+    }
+    const out = output;
+    const imageUrl = out.image_url;
+    if (typeof imageUrl !== "string" || imageUrl.length === 0) {
+      out.image_url = EMPTY_IMAGE_URL_PLACEHOLDER;
+      changed = true;
+    }
+  }
+  return changed;
+}
+function computerCallNormalizingFetch(base) {
+  return (input, init) => {
+    if (init && typeof init.body === "string" && init.body.includes('"computer_call')) {
+      try {
+        const parsed = JSON.parse(init.body);
+        const changed1 = rewriteComputerCallsToActionsOnly(parsed);
+        const changed2 = rewriteEmptyComputerCallOutputImageUrls(parsed);
+        if (changed1 || changed2) {
+          return base(input, { ...init, body: JSON.stringify(parsed) });
+        }
+      } catch {
+      }
+    }
+    return base(input, init);
+  };
+}
+
+// src/codex-tool-search.ts
+import { toolSearchTool } from "@openai/agents";
+var CODEX_APPS_TOOL_PREFIX = "codex_apps__";
+var DEFAULT_SEARCH_LIMIT = 8;
+var MAX_SEARCH_LIMIT = 20;
+function isCodexAppsFunctionTool(tool2) {
+  return !!tool2 && typeof tool2 === "object" && tool2.type === "function" && typeof tool2.name === "string" && tool2.name.startsWith(CODEX_APPS_TOOL_PREFIX);
+}
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "of",
+  "to",
+  "in",
+  "on",
+  "for",
+  "with",
+  "by",
+  "at",
+  "is",
+  "are",
+  "be",
+  "do",
+  "does",
+  "my",
+  "me",
+  "your",
+  "you",
+  "it",
+  "its",
+  "this",
+  "that",
+  "from",
+  "as",
+  "up",
+  "out",
+  "all",
+  "some",
+  "any",
+  "can",
+  "will",
+  "would",
+  "should",
+  "want",
+  "need",
+  "please",
+  "user",
+  "users"
+]);
+function stem(token) {
+  if (token.length > 5 && token.endsWith("ing")) return token.slice(0, -3);
+  if (token.length > 4 && token.endsWith("ed")) return token.slice(0, -2);
+  if (token.length > 4 && token.endsWith("es")) return token.slice(0, -2);
+  if (token.length > 3 && token.endsWith("s") && !token.endsWith("ss")) return token.slice(0, -1);
+  return token;
+}
+function tokenize(text) {
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 1 && !STOPWORDS.has(t)).map(stem);
+}
+function toolSearchText(tool2) {
+  const raw = tool2.name ?? "";
+  const name = raw.startsWith(CODEX_APPS_TOOL_PREFIX) ? raw.slice(CODEX_APPS_TOOL_PREFIX.length) : raw;
+  const description = typeof tool2.description === "string" ? tool2.description : "";
+  const params = tool2.parameters?.properties;
+  const paramNames = params && typeof params === "object" ? Object.keys(params).join(" ") : "";
+  return `${name} ${name} ${description} ${paramNames}`;
+}
+function bm25RankTools(tools, query, limit) {
+  const qTokens = Array.from(new Set(tokenize(query)));
+  if (tools.length === 0 || qTokens.length === 0) return [];
+  const docs = tools.map((tool2) => {
+    const tokens = tokenize(toolSearchText(tool2));
+    const tf = /* @__PURE__ */ new Map();
+    for (const t of tokens) tf.set(t, (tf.get(t) ?? 0) + 1);
+    return { tool: tool2, len: tokens.length, tf };
+  });
+  const N = docs.length;
+  const avgdl = Math.max(1, docs.reduce((s, d) => s + d.len, 0) / N);
+  const df = /* @__PURE__ */ new Map();
+  for (const d of docs) for (const t of d.tf.keys()) df.set(t, (df.get(t) ?? 0) + 1);
+  const k1 = 1.5;
+  const b = 0.75;
+  const scored = docs.map((d) => {
+    let score = 0;
+    for (const qt of qTokens) {
+      const n = df.get(qt);
+      const f = d.tf.get(qt);
+      if (!n || !f) continue;
+      const idf = Math.log(1 + (N - n + 0.5) / (n + 0.5));
+      score += idf * (f * (k1 + 1) / (f + k1 * (1 - b + b * d.len / avgdl)));
+    }
+    return { tool: d.tool, score };
+  });
+  const hits = scored.filter((s) => s.score > 0).sort((a, b2) => b2.score - a.score);
+  return hits.slice(0, limit).map((s) => s.tool);
+}
+function parseSearchArgs(raw) {
+  let obj = {};
+  try {
+    obj = typeof raw === "string" ? raw.length ? JSON.parse(raw) : {} : raw && typeof raw === "object" ? raw : {};
+  } catch {
+    obj = {};
+  }
+  const query = typeof obj.query === "string" ? obj.query : "";
+  const limitRaw = typeof obj.limit === "number" && Number.isFinite(obj.limit) ? obj.limit : DEFAULT_SEARCH_LIMIT;
+  return { query, limit: Math.max(1, Math.min(MAX_SEARCH_LIMIT, Math.round(limitRaw))) };
+}
+function renderSearchToolDescription(connectorNamespaces) {
+  const base = `Search the user's connected app tools by capability. Describe in plain language WHAT you need to do (for example: "send an email", "create a calendar event") rather than guessing exact tool names. Returns the matching connector tools, which then become callable.`;
+  const sources = Array.from(connectorNamespaces).filter((n) => typeof n === "string" && n.length > 0).sort();
+  if (sources.length === 0) {
+    return `${base}
+Connected sources: none currently available.`;
+  }
+  return `${base}
+You have access to tools from the following sources:
+${sources.map((s) => `- ${s}`).join("\n")}`;
+}
+var SEARCH_TOOL_PARAMETERS = {
+  type: "object",
+  properties: {
+    query: { type: "string", description: "Plain-language description of the capability you need." },
+    limit: { type: "number", description: "Maximum number of tools to return (default 8)." }
+  },
+  required: ["query"],
+  additionalProperties: false
+};
+function codexToolSearchExecutor(args) {
+  const deferred = (args.availableTools ?? []).filter(isCodexAppsFunctionTool);
+  if (deferred.length === 0) return [];
+  const { query, limit } = parseSearchArgs(args.toolCall?.arguments);
+  return bm25RankTools(deferred, query, limit);
+}
+var NO_NAMESPACES = /* @__PURE__ */ new Set();
+function buildCodexToolSearchTool(connectorNamespaces = NO_NAMESPACES) {
+  return toolSearchTool({
+    execution: "client",
+    description: renderSearchToolDescription(connectorNamespaces),
+    parameters: SEARCH_TOOL_PARAMETERS,
+    execute: codexToolSearchExecutor
+  });
+}
+function isToolSearchTool(tool2) {
+  const t = tool2;
+  return !!t && (t.name === "tool_search" || t.providerData?.type === "tool_search");
+}
+function applyCodexToolSearch(tools, connectorNamespaces = NO_NAMESPACES) {
+  for (const tool2 of tools) {
+    if (isCodexAppsFunctionTool(tool2) && tool2.deferLoading !== true) {
+      tool2.deferLoading = true;
+    }
+  }
+  if (tools.some(isToolSearchTool)) {
+    return tools;
+  }
+  return [...tools, buildCodexToolSearchTool(connectorNamespaces)];
+}
+function installCodexToolSearch(agent, connectorNamespaces = NO_NAMESPACES) {
+  const originalGetAllTools = agent.getAllTools.bind(agent);
+  agent.getAllTools = (async (runContext) => applyCodexToolSearch(await originalGetAllTools(runContext), connectorNamespaces));
+  const originalClone = agent.clone?.bind(agent);
+  if (originalClone) {
+    const cloneWithToolSearch = (config) => {
+      const cloned = originalClone(config);
+      installCodexToolSearch(cloned, connectorNamespaces);
+      return cloned;
+    };
+    agent.clone = cloneWithToolSearch;
+  }
+}
+
+// src/context-compaction.ts
+var COMPACTION_SUMMARY_MARKER = "opengeni_context_summary";
+var SUMMARY_PREFIX = [
+  "[CONTEXT CHECKPOINT] The earlier part of this conversation was automatically compacted to stay within the model context window.",
+  "Durable facts already live in the workspace notebook / document bases (via MCP) \u2014 the summary below is a light working-memory bridge, not a full transcript.",
+  "Trust it for current objective, decisions, blockers, deployed/infra state, and next steps; re-read the notebook for anything authoritative.",
+  "",
+  "SUMMARY:"
+].join("\n");
+var RESULT_TYPE_BY_CALL_TYPE2 = {
+  function_call: "function_call_result",
+  computer_call: "computer_call_result",
+  shell_call: "shell_call_output",
+  apply_patch_call: "apply_patch_call_output"
+};
+var RESULT_TYPES2 = new Set(Object.values(RESULT_TYPE_BY_CALL_TYPE2));
+function itemType2(item) {
+  if (!item || typeof item !== "object") {
+    return void 0;
+  }
+  const type = item.type;
+  return typeof type === "string" ? type : void 0;
+}
+function itemRole(item) {
+  if (!item || typeof item !== "object") {
+    return void 0;
+  }
+  const role = item.role;
+  return typeof role === "string" ? role : void 0;
+}
+function isUserMessage(item) {
+  return itemType2(item) === "message" && itemRole(item) === "user";
+}
+function isCompactionSummary(item) {
+  return isUserMessage(item) && item[COMPACTION_SUMMARY_MARKER] === true;
+}
+function estimateItemTokens(item) {
+  let text;
+  try {
+    text = JSON.stringify(item);
+  } catch {
+    text = String(item);
+  }
+  return Math.ceil(text.length / 4);
+}
+function estimateTokens(items) {
+  let total = 0;
+  for (const item of items) {
+    total += estimateItemTokens(item);
+  }
+  return total;
+}
+function findKeepBoundary(items, keepRecentTokens) {
+  const boundaries = [];
+  for (let i = 0; i < items.length; i += 1) {
+    if (isUserMessage(items[i])) {
+      boundaries.push(i);
+    }
+  }
+  if (boundaries.length === 0) {
+    return 0;
+  }
+  for (let b = 0; b < boundaries.length; b += 1) {
+    const boundary = boundaries[b];
+    if (estimateTokens(items.slice(boundary)) <= keepRecentTokens) {
+      return boundary;
+    }
+  }
+  return boundaries[boundaries.length - 1];
+}
+function enforceInputBudget(items, maxTokens, trailingTokens = 0) {
+  const total = estimateTokens(items) + Math.max(0, trailingTokens);
+  if (items.length === 0 || total <= maxTokens) {
+    return { items: items.slice(), trimmed: false, droppedCount: 0, estimatedTokens: total };
+  }
+  const historyBudget = Math.max(0, maxTokens - Math.max(0, trailingTokens));
+  const boundary = findKeepBoundary(items, historyBudget);
+  if (boundary <= 0) {
+    return { items: items.slice(), trimmed: false, droppedCount: 0, estimatedTokens: total };
+  }
+  const kept = items.slice(boundary);
+  return {
+    items: kept,
+    trimmed: true,
+    droppedCount: boundary,
+    estimatedTokens: estimateTokens(kept) + Math.max(0, trailingTokens)
+  };
+}
+function planCompaction(input) {
+  const softLimit = Math.floor(input.inputBudgetTokens * input.softFraction);
+  const hardLimit = Math.floor(input.inputBudgetTokens * input.hardFraction);
+  const recorded = typeof input.lastInputTokens === "number" && input.lastInputTokens > 0 ? input.lastInputTokens : 0;
+  const signalTokens = Math.max(recorded, estimateTokens(input.items));
+  const hardForced = signalTokens >= hardLimit;
+  const empty = {
+    shouldCompact: false,
+    reason: "below_threshold",
+    signalTokens,
+    hardForced,
+    boundaryIndex: input.items.length,
+    prefixItems: [],
+    priorSummaryItem: null,
+    tailItems: [...input.items]
+  };
+  if (!input.force && signalTokens < softLimit) {
+    return empty;
+  }
+  const effectiveKeepRecent = hardForced ? Math.min(
+    Math.floor(input.keepRecentTokens / 2),
+    Math.floor(input.inputBudgetTokens / 4)
+  ) : input.keepRecentTokens;
+  const boundaryIndex = findKeepBoundary(input.items, effectiveKeepRecent);
+  if (boundaryIndex <= 0) {
+    return { ...empty, reason: "no_boundary", boundaryIndex };
+  }
+  const prefix = input.items.slice(0, boundaryIndex);
+  const tailItems = input.items.slice(boundaryIndex);
+  let priorSummaryItem = null;
+  const prefixItems = [];
+  for (const item of prefix) {
+    if (isCompactionSummary(item)) {
+      priorSummaryItem = item;
+      continue;
+    }
+    prefixItems.push(item);
+  }
+  if (prefixItems.length === 0) {
+    return { ...empty, reason: "nothing_to_summarize", boundaryIndex };
+  }
+  return {
+    shouldCompact: true,
+    reason: "compact",
+    signalTokens,
+    hardForced,
+    boundaryIndex,
+    prefixItems,
+    priorSummaryItem,
+    tailItems
+  };
+}
+function compactionSummaryText(item) {
+  if (!item) {
+    return "";
+  }
+  const content = item.content;
+  if (typeof content === "string") {
+    return stripSummaryPrefix(content);
+  }
+  if (Array.isArray(content)) {
+    const text = content.map((part) => {
+      if (part && typeof part === "object") {
+        const t = part.text;
+        return typeof t === "string" ? t : "";
+      }
+      return "";
+    }).join("");
+    return stripSummaryPrefix(text);
+  }
+  return "";
+}
+function stripSummaryPrefix(text) {
+  const marker = "SUMMARY:";
+  const idx = text.indexOf(marker);
+  return idx >= 0 ? text.slice(idx + marker.length) : text;
+}
+function buildSummaryItem(summaryBody) {
+  return {
+    type: "message",
+    role: "user",
+    content: `${SUMMARY_PREFIX}${summaryBody}`,
+    [COMPACTION_SUMMARY_MARKER]: true
+  };
+}
+var SUMMARY_INSTRUCTIONS = [
+  "You are compacting the earlier part of a long-running agent conversation into a compact working-memory checkpoint so the agent can continue past the model's context limit.",
+  "Durable facts already live in the workspace notebook and document bases (via MCP). Do NOT re-derive or copy those; summarize POINTERS, not contents.",
+  "Capture, concisely and factually:",
+  "- The current objective and the key decisions made so far.",
+  "- Open blockers and anything in-progress.",
+  "- Deployed / infrastructure state that has changed (what exists now).",
+  "- Environment and credential facts BY REFERENCE ONLY \u2014 name the env var keys, secret names, or notebook/document ids; NEVER copy a secret value, token, key, or password.",
+  "- Concrete next steps.",
+  "Say explicitly that durable facts are in the notebook and that this summary lists pointers, not contents.",
+  "Output only the summary body \u2014 no preamble, no markdown headers, plain prose or terse bullets."
+].join("\n");
+function renderPrefixTranscript(items, priorSummaryText) {
+  const lines = [];
+  if (priorSummaryText.trim().length > 0) {
+    lines.push("PRIOR CHECKPOINT SUMMARY (fold this forward; it already replaced even older history):");
+    lines.push(priorSummaryText.trim());
+    lines.push("");
+    lines.push("CONVERSATION SINCE THAT CHECKPOINT:");
+  } else {
+    lines.push("CONVERSATION TO SUMMARIZE:");
+  }
+  for (const item of items) {
+    lines.push(renderItem(item));
+  }
+  return lines.join("\n");
+}
+function renderItem(item) {
+  const type = itemType2(item) ?? "unknown";
+  if (type === "message") {
+    const role = itemRole(item) ?? "assistant";
+    return `[${role}] ${truncate(messageText(item), 4e3)}`;
+  }
+  if (type === "reasoning") {
+    return "[reasoning] (omitted)";
+  }
+  if (RESULT_TYPES2.has(type)) {
+    return `[tool_result] ${truncate(resultText(item), 2e3)}`;
+  }
+  if (RESULT_TYPE_BY_CALL_TYPE2[type]) {
+    return `[tool_call ${type}] ${truncate(callText(item), 1e3)}`;
+  }
+  return `[${type}] ${truncate(safeStringify(item), 1e3)}`;
+}
+function messageText(item) {
+  const content = item.content;
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      if (part && typeof part === "object") {
+        const t = part.text;
+        return typeof t === "string" ? t : "";
+      }
+      return "";
+    }).join("");
+  }
+  return "";
+}
+function resultText(item) {
+  const output = item.output;
+  if (typeof output === "string") {
+    return output;
+  }
+  return safeStringify(output ?? item);
+}
+function callText(item) {
+  const name = item.name;
+  const args = item.arguments;
+  const namePart = typeof name === "string" ? name : "";
+  const argPart = typeof args === "string" ? args : safeStringify(args ?? {});
+  return `${namePart} ${argPart}`.trim();
+}
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function truncate(text, max) {
+  if (text.length <= max) {
+    return text;
+  }
+  return `${text.slice(0, max)}\u2026 (${text.length - max} more chars)`;
+}
+function buildCompactionMessages(plan) {
+  const priorText = compactionSummaryText(plan.priorSummaryItem);
+  return {
+    system: SUMMARY_INSTRUCTIONS,
+    user: renderPrefixTranscript(plan.prefixItems, priorText)
+  };
+}
+
+// src/sandbox-computer.ts
+import { computerTool, tool } from "@openai/agents";
+import { Capability } from "@openai/agents/sandbox";
+import { KeyAction, PointerAction, PointerButton } from "@opengeni/agent-proto";
+function requireBoundSession(capabilityType, session) {
+  if (!session) {
+    throw new ComputerUnavailableError(`capability "${capabilityType}" used before bind(session)`);
+  }
+  return session;
+}
+var DEFAULT_DISPLAY = ":0";
+var DEFAULT_DIMENSIONS = [1280, 800];
+var ACTION_YIELD_MS = 15e3;
+var SCROLL_NOTCH_PIXELS = 100;
+var SCROLL_MAX_CLICKS = 15;
+var SCREENSHOT_MAX_ATTEMPTS = 3;
+var SCREENSHOT_RETRY_DELAY_MS = 400;
+var KEYSYM = {
+  ctrl: "ctrl",
+  control: "ctrl",
+  alt: "alt",
+  option: "alt",
+  shift: "shift",
+  cmd: "super",
+  meta: "super",
+  win: "super",
+  super: "super",
+  enter: "Return",
+  return: "Return",
+  tab: "Tab",
+  esc: "Escape",
+  escape: "Escape",
+  backspace: "BackSpace",
+  delete: "Delete",
+  space: "space",
+  up: "Up",
+  down: "Down",
+  left: "Left",
+  right: "Right",
+  pageup: "Prior",
+  pagedown: "Next",
+  home: "Home",
+  end: "End"
+};
+function toKeysym(k) {
+  const low = k.toLowerCase();
+  if (KEYSYM[low]) return KEYSYM[low];
+  if (/^f([1-9]|1[0-2])$/.test(low)) return low.toUpperCase();
+  return low.length === 1 ? low : k;
+}
+var BUTTON_NUM = { left: 1, wheel: 2, right: 3, back: 8, forward: 9 };
+var ComputerUnavailableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ComputerUnavailableError";
+  }
+};
+var ComputerReadOnlyError = class extends Error {
+  constructor() {
+    super("computer-use is read-only \u2014 write actions are disabled");
+    this.name = "ComputerReadOnlyError";
+  }
+};
+var ComputerActionError = class extends Error {
+  constructor(cmd, exitCode, stderr) {
+    super(`computer action failed (${exitCode}): ${cmd}${stderr ? `
+${stderr}` : ""}`);
+    this.cmd = cmd;
+    this.exitCode = exitCode;
+    this.stderr = stderr;
+    this.name = "ComputerActionError";
+  }
+  cmd;
+  exitCode;
+  stderr;
+};
+var SandboxComputer = class {
+  environment = "ubuntu";
+  dimensions;
+  session;
+  display;
+  runAs;
+  typeDelayMs;
+  readOnly;
+  tmp;
+  constructor(session, opts = {}) {
+    this.session = session;
+    this.display = opts.display ?? DEFAULT_DISPLAY;
+    this.dimensions = opts.dimensions ?? DEFAULT_DIMENSIONS;
+    if (opts.runAs !== void 0) {
+      this.runAs = opts.runAs;
+    }
+    this.typeDelayMs = opts.typeDelayMs ?? 12;
+    this.readOnly = opts.readOnly ?? false;
+    this.tmp = opts.screenshotTmpDir ?? "/tmp";
+  }
+  /** Rebind to a freshly resumed-by-id session after a box rollover / re-establish. */
+  rebind(session) {
+    this.session = session;
+  }
+  // The single command primitive. Dual-paths exec/execCommand (F1), then uses the
+  // established string-aware parsers (F2/F3): exitCode from the preamble, and
+  // "still running" → a retriable failure. Returns the command OUTPUT body.
+  async x(cmd) {
+    const args = {
+      cmd: `DISPLAY=${this.display} ${cmd}`,
+      ...this.runAs ? { runAs: this.runAs } : {},
+      yieldTimeMs: ACTION_YIELD_MS,
+      maxOutputTokens: 4e3
+    };
+    let result;
+    if (typeof this.session.exec === "function") {
+      result = await this.session.exec(args);
+    } else if (typeof this.session.execCommand === "function") {
+      result = await this.session.execCommand(args);
+    } else {
+      throw new ComputerUnavailableError("session cannot run commands (no exec/execCommand)");
+    }
+    const output = sandboxCommandOutput(result);
+    if (sandboxCommandStillRunning(result)) {
+      console.warn(
+        `[SandboxComputer] action command did not finish before the ${ACTION_YIELD_MS}ms yield window \u2014 proceeding to screenshot: ${cmd}`
+      );
+      return output;
+    }
+    const exitCode = sandboxCommandExitCode(result);
+    if (exitCode !== null && exitCode !== 0) {
+      throw new ComputerActionError(cmd, exitCode, output);
+    }
+    return output;
+  }
+  guardWrite() {
+    if (this.readOnly) throw new ComputerReadOnlyError();
+  }
+  shq(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+  }
+  async screenshot() {
+    let lastError;
+    for (let attempt = 0; attempt < SCREENSHOT_MAX_ATTEMPTS; attempt++) {
+      if (attempt > 0) {
+        await new Promise((r) => setTimeout(r, SCREENSHOT_RETRY_DELAY_MS));
+      }
+      const f = `${this.tmp}/og-shot-${Date.now()}-${Math.random().toString(36).slice(2)}.png`;
+      try {
+        await this.x(`scrot --pointer --overwrite ${f}`);
+        const bytes = await this.readScreenshotBytes(f);
+        if (bytes.length === 0) {
+          throw new ComputerUnavailableError("scrot produced an empty screenshot (display not up?)");
+        }
+        return Buffer.from(bytes).toString("base64");
+      } catch (error) {
+        lastError = error;
+      } finally {
+        await this.x(`rm -f ${f}`).catch(() => void 0);
+      }
+    }
+    if (lastError instanceof Error) {
+      throw lastError;
+    }
+    throw new ComputerUnavailableError("scrot produced an empty screenshot (display not up?)");
+  }
+  // Read the screenshot PNG bytes by base64-ing the absolute /tmp path through the
+  // SAME command primitive (exec ?? execCommand) — NOT `session.readFile` (Modal
+  // path-validates against /workspace and rejects /tmp) and NOT `this.x()` (its
+  // `sandboxCommandOutput` parser drops the execCommand STRING body, returning ""
+  // — only the exec-object path has a structured body). We capture the RAW result,
+  // strip the execCommand banner ("…Output:\n<base64>"), strip whitespace, and
+  // decode. Binary-safe: base64 of the scrot is plain ASCII over stdout, no
+  // truncation (maxOutputTokens:null), mirroring recording.ts readRecordingBytes.
+  async readScreenshotBytes(path) {
+    const args = {
+      cmd: `DISPLAY=${this.display} base64 ${path}`,
+      ...this.runAs ? { runAs: this.runAs } : {},
+      yieldTimeMs: ACTION_YIELD_MS,
+      // null disables the provider's output truncation so a full-screen PNG's
+      // base64 is never clipped (the SDK's truncateOutput passes through on null).
+      maxOutputTokens: null
+    };
+    let raw;
+    if (typeof this.session.exec === "function") {
+      raw = sandboxCommandOutput(await this.session.exec(args));
+    } else if (typeof this.session.execCommand === "function") {
+      raw = stripExecBanner(await this.session.execCommand(args));
+    } else {
+      throw new ComputerUnavailableError("session cannot run commands (no exec/execCommand) \u2014 screenshots unavailable");
+    }
+    const b64 = raw.replace(/\s+/g, "");
+    if (b64.length === 0) return new Uint8Array();
+    return Uint8Array.from(Buffer.from(b64, "base64"));
+  }
+  async click(xp, yp, button) {
+    this.guardWrite();
+    await this.x(`xdotool mousemove --sync ${xp} ${yp} click ${BUTTON_NUM[button] ?? 1}`);
+  }
+  async doubleClick(xp, yp) {
+    this.guardWrite();
+    await this.x(`xdotool mousemove --sync ${xp} ${yp} click --repeat 2 --delay 60 1`);
+  }
+  async move(xp, yp) {
+    this.guardWrite();
+    await this.x(`xdotool mousemove --sync ${xp} ${yp}`);
+  }
+  async scroll(xp, yp, sx, sy) {
+    this.guardWrite();
+    const notches = (px) => Math.min(SCROLL_MAX_CLICKS, Math.max(0, Math.round(Math.abs(px) / SCROLL_NOTCH_PIXELS)));
+    const vBtn = sy < 0 ? 4 : 5;
+    const hBtn = sx < 0 ? 6 : 7;
+    const vN = notches(sy);
+    const hN = notches(sx);
+    let cmd = `xdotool mousemove --sync ${xp} ${yp}`;
+    if (vN) cmd += ` click --repeat ${vN} ${vBtn}`;
+    if (hN) cmd += ` click --repeat ${hN} ${hBtn}`;
+    await this.x(cmd);
+  }
+  async type(text) {
+    this.guardWrite();
+    await this.x(`xdotool type --delay ${this.typeDelayMs} -- ${this.shq(text)}`);
+  }
+  async keypress(keys) {
+    this.guardWrite();
+    const combo = keys.map(toKeysym).join("+");
+    await this.x(`xdotool key -- ${this.shq(combo)}`);
+  }
+  async drag(path) {
+    this.guardWrite();
+    if (path.length === 0) return;
+    const [sx0, sy0] = path[0];
+    let cmd = `xdotool mousemove --sync ${sx0} ${sy0} mousedown 1`;
+    for (const [px, py] of path.slice(1)) cmd += ` mousemove --sync ${px} ${py}`;
+    cmd += ` mouseup 1`;
+    await this.x(cmd);
+  }
+  async wait() {
+    await new Promise((r) => setTimeout(r, 1e3));
+  }
+};
+var POINTER_BUTTON = {
+  left: PointerButton.POINTER_BUTTON_LEFT,
+  right: PointerButton.POINTER_BUTTON_RIGHT,
+  wheel: PointerButton.POINTER_BUTTON_MIDDLE,
+  back: PointerButton.POINTER_BUTTON_UNSPECIFIED,
+  forward: PointerButton.POINTER_BUTTON_UNSPECIFIED
+};
+var NativeDesktopComputer = class {
+  environment;
+  dimensions;
+  session;
+  readOnly;
+  constructor(session, opts = {}) {
+    this.session = session;
+    this.dimensions = opts.dimensions ?? DEFAULT_DIMENSIONS;
+    this.environment = opts.environment ?? "ubuntu";
+    this.readOnly = opts.readOnly ?? false;
+  }
+  /** Rebind to a freshly resumed-by-id session after a box rollover / re-establish. */
+  rebind(session) {
+    this.session = session;
+  }
+  guardWrite() {
+    if (this.readOnly) throw new ComputerReadOnlyError();
+  }
+  async pointer(x, y, action, button) {
+    await this.session.desktopInput({ $case: "pointer", pointer: { x, y, action, button } });
+  }
+  async screenshot() {
+    const { png } = await this.session.screenshot();
+    if (png.length === 0) {
+      throw new ComputerUnavailableError("native desktop screenshot returned an empty frame (display not up?)");
+    }
+    return Buffer.from(png).toString("base64");
+  }
+  async click(x, y, button) {
+    this.guardWrite();
+    await this.pointer(x, y, PointerAction.POINTER_ACTION_CLICK, POINTER_BUTTON[button] ?? PointerButton.POINTER_BUTTON_LEFT);
+  }
+  async doubleClick(x, y) {
+    this.guardWrite();
+    await this.pointer(x, y, PointerAction.POINTER_ACTION_DOUBLE_CLICK, PointerButton.POINTER_BUTTON_LEFT);
+  }
+  async move(x, y) {
+    this.guardWrite();
+    await this.pointer(x, y, PointerAction.POINTER_ACTION_MOVE, PointerButton.POINTER_BUTTON_UNSPECIFIED);
+  }
+  async scroll(x, y, sx, sy) {
+    this.guardWrite();
+    await this.session.desktopInput({ $case: "scroll", scroll: { x, y, deltaX: sx, deltaY: sy } });
+  }
+  async type(text) {
+    this.guardWrite();
+    await this.session.desktopInput({ $case: "key", key: { key: text, isText: true, action: KeyAction.KEY_ACTION_PRESS } });
+  }
+  async keypress(keys) {
+    this.guardWrite();
+    await this.session.desktopInput({ $case: "key", key: { key: keys.join("+"), isText: false, action: KeyAction.KEY_ACTION_PRESS } });
+  }
+  async drag(path) {
+    this.guardWrite();
+    if (path.length === 0) return;
+    const [sx, sy] = path[0];
+    await this.pointer(sx, sy, PointerAction.POINTER_ACTION_DOWN, PointerButton.POINTER_BUTTON_LEFT);
+    for (const [px, py] of path.slice(1)) {
+      await this.pointer(px, py, PointerAction.POINTER_ACTION_MOVE, PointerButton.POINTER_BUTTON_LEFT);
+    }
+    const [ex, ey] = path[path.length - 1];
+    await this.pointer(ex, ey, PointerAction.POINTER_ACTION_UP, PointerButton.POINTER_BUTTON_LEFT);
+  }
+  async wait() {
+    await new Promise((r) => setTimeout(r, 1e3));
+  }
+};
+function isNativeDesktopSession(session) {
+  const s = session;
+  return typeof s.desktopInput === "function" && typeof s.screenshot === "function";
+}
+function sniffScreenshotMediaType(bytes) {
+  if (bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) return "image/png";
+  if (bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return "image/jpeg";
+  if (bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 56) return "image/gif";
+  if (bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80) return "image/webp";
+  return "image/png";
+}
+function imageOutputFromScreenshotBytes(bytes) {
+  return { type: "image", image: { data: Uint8Array.from(bytes), mediaType: sniffScreenshotMediaType(bytes) } };
+}
+function renderImageForTextTransport(output) {
+  if (typeof output === "string") return output;
+  const { image } = output;
+  const mediaType = typeof image.mediaType === "string" ? image.mediaType : "application/octet-stream";
+  return `data:${mediaType};base64,${Buffer.from(image.data).toString("base64")}`;
+}
+function supportsStructuredToolOutputTransport(modelInstance) {
+  if (!modelInstance) return false;
+  const constructorName = typeof modelInstance === "object" && modelInstance && typeof modelInstance.constructor === "function" ? modelInstance.constructor.name ?? "" : "";
+  return !constructorName.includes("ChatCompletions");
+}
+var COMPUTER_READ_ONLY_MESSAGE = "computer-use is read-only for this session \u2014 click, double_click, move, scroll, type, keypress, and drag are disabled. Call computer_screenshot to observe the desktop.";
+var COORD_PROPS = {
+  x: { type: "integer", description: "X coordinate in the pixels of the most recent computer_screenshot" },
+  y: { type: "integer", description: "Y coordinate in the pixels of the most recent computer_screenshot" }
+};
+function objectSchema(properties, required) {
+  return { type: "object", properties, required, additionalProperties: false };
+}
+function computerFunctionTools(computer, readOnly, needsApproval, imageFunctionResults = false) {
+  const approval = needsApproval !== void 0 ? { needsApproval } : {};
+  const write = async (confirmation, action) => {
+    if (readOnly) return COMPUTER_READ_ONLY_MESSAGE;
+    try {
+      await action();
+      return confirmation;
+    } catch (error) {
+      if (error instanceof ComputerReadOnlyError) return COMPUTER_READ_ONLY_MESSAGE;
+      return `computer action failed: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  };
+  return [
+    tool({
+      name: "computer_screenshot",
+      description: "Capture the current desktop and return it as an image. Call this FIRST and again after each action \u2014 all coordinates for click/move/scroll/drag are pixels of the most recent screenshot.",
+      parameters: objectSchema({}, []),
+      strict: false,
+      execute: async () => {
+        const b64 = await computer.screenshot();
+        const bytes = Uint8Array.from(Buffer.from(b64, "base64"));
+        const image = imageOutputFromScreenshotBytes(bytes);
+        return imageFunctionResults ? image : renderImageForTextTransport(image);
+      }
+    }),
+    tool({
+      name: "computer_click",
+      description: "Click the mouse at (x, y). `button` is one of left|right|wheel|back|forward (default left). Take a computer_screenshot first to find coordinates.",
+      parameters: objectSchema(
+        { ...COORD_PROPS, button: { type: "string", enum: ["left", "right", "wheel", "back", "forward"], description: "Mouse button; defaults to left" } },
+        ["x", "y"]
+      ),
+      strict: false,
+      ...approval,
+      execute: async (input) => {
+        const { x, y, button } = input;
+        return write(`clicked ${button ?? "left"} at (${x}, ${y})`, () => computer.click(x, y, button ?? "left"));
+      }
+    }),
+    tool({
+      name: "computer_double_click",
+      description: "Double-click the left mouse button at (x, y). Take a computer_screenshot first to find coordinates.",
+      parameters: objectSchema({ ...COORD_PROPS }, ["x", "y"]),
+      strict: false,
+      ...approval,
+      execute: async (input) => {
+        const { x, y } = input;
+        return write(`double-clicked at (${x}, ${y})`, () => computer.doubleClick(x, y));
+      }
+    }),
+    tool({
+      name: "computer_move",
+      description: "Move the mouse cursor to (x, y) without clicking.",
+      parameters: objectSchema({ ...COORD_PROPS }, ["x", "y"]),
+      strict: false,
+      ...approval,
+      execute: async (input) => {
+        const { x, y } = input;
+        return write(`moved to (${x}, ${y})`, () => computer.move(x, y));
+      }
+    }),
+    tool({
+      name: "computer_scroll",
+      description: "Scroll at (x, y) by scroll_x / scroll_y pixels (positive scroll_y scrolls down, negative up; positive scroll_x scrolls right).",
+      parameters: objectSchema(
+        {
+          ...COORD_PROPS,
+          scroll_x: { type: "integer", description: "Horizontal scroll amount in pixels (positive = right)" },
+          scroll_y: { type: "integer", description: "Vertical scroll amount in pixels (positive = down)" }
+        },
+        ["x", "y", "scroll_x", "scroll_y"]
+      ),
+      strict: false,
+      ...approval,
+      execute: async (input) => {
+        const { x, y, scroll_x, scroll_y } = input;
+        return write(`scrolled (${scroll_x}, ${scroll_y}) at (${x}, ${y})`, () => computer.scroll(x, y, scroll_x, scroll_y));
+      }
+    }),
+    tool({
+      name: "computer_type",
+      description: "Type a literal text string at the current keyboard focus. Click the target field first.",
+      parameters: objectSchema({ text: { type: "string", description: "The literal text to type" } }, ["text"]),
+      strict: false,
+      ...approval,
+      execute: async (input) => {
+        const { text } = input;
+        return write(`typed ${text.length} character(s)`, () => computer.type(text));
+      }
+    }),
+    tool({
+      name: "computer_keypress",
+      description: 'Press a key or chord. `keys` is an ordered list pressed together, e.g. ["ctrl","c"] or ["Enter"]. Use key names (ctrl, alt, shift, cmd, enter, tab, esc, arrows\u2026), not characters.',
+      parameters: objectSchema(
+        { keys: { type: "array", items: { type: "string" }, description: "Keys pressed together as a chord" } },
+        ["keys"]
+      ),
+      strict: false,
+      ...approval,
+      execute: async (input) => {
+        const { keys } = input;
+        return write(`pressed ${keys.join("+")}`, () => computer.keypress(keys));
+      }
+    }),
+    tool({
+      name: "computer_drag",
+      description: "Drag the left mouse button along a path of points. `path` is an ordered list of {x, y} pixels; the button is pressed at the first point, moved through each, and released at the last.",
+      parameters: objectSchema(
+        {
+          path: {
+            type: "array",
+            description: "Ordered list of points to drag through",
+            items: {
+              type: "object",
+              properties: { x: { type: "integer" }, y: { type: "integer" } },
+              required: ["x", "y"],
+              additionalProperties: false
+            }
+          }
+        },
+        ["path"]
+      ),
+      strict: false,
+      ...approval,
+      execute: async (input) => {
+        const { path } = input;
+        const points = path.map((p) => [p.x, p.y]);
+        return write(`dragged through ${points.length} point(s)`, () => computer.drag(points));
+      }
+    })
+  ];
+}
+function computerUse(args = {}) {
+  return new ComputerUseCapability(args);
+}
+var ComputerUseCapability = class extends Capability {
+  constructor(args = {}) {
+    super();
+    this.args = args;
+  }
+  args;
+  type = "computer-use";
+  tools() {
+    const session = requireBoundSession("computer-use", this._session);
+    const computer = isNativeDesktopSession(session) ? new NativeDesktopComputer(session, {
+      ...this.args.dimensions ? { dimensions: this.args.dimensions } : {},
+      ...this.args.readOnly !== void 0 ? { readOnly: this.args.readOnly } : {}
+    }) : new SandboxComputer(session, {
+      ...this.args.dimensions ? { dimensions: this.args.dimensions } : {},
+      ...this.args.readOnly !== void 0 ? { readOnly: this.args.readOnly } : {},
+      ...this.args.display ? { display: this.args.display } : {},
+      // The SDK base exposes the bound runAs as a protected field.
+      ...typeof this._runAs === "string" ? { runAs: this._runAs } : {}
+    });
+    if (supportsStructuredToolOutputTransport(this._modelInstance)) {
+      return [
+        computerTool({
+          computer,
+          ...this.args.needsApproval !== void 0 ? { needsApproval: this.args.needsApproval } : {}
+        })
+      ];
+    }
+    return computerFunctionTools(computer, this.args.readOnly ?? false, this.args.needsApproval, this.args.imageFunctionResults ?? false);
+  }
+};
+
+// src/index.ts
+import { OpenAIChatCompletionsModel as OpenAIChatCompletionsModel2, OpenAIResponsesModel as OpenAIResponsesModel2 } from "@openai/agents";
+import { MaxTurnsExceededError as MaxTurnsExceededError2 } from "@openai/agents";
+setSelfhostedApplyDiff(applyDiff);
+ensureReadableStreamFrom();
+var SANDBOX_LIFECYCLE_COMMAND_TIMEOUT_MS = 12e4;
+function ensureReadableStreamFrom() {
+  const ctor = globalThis.ReadableStream;
+  if (!ctor || typeof ctor.from === "function") {
+    return;
+  }
+  Object.defineProperty(ctor, "from", {
+    configurable: true,
+    writable: true,
+    value(source) {
+      const iterator = isAsyncIterable(source) ? source[Symbol.asyncIterator]() : source[Symbol.iterator]();
+      return new ReadableStream({
+        async pull(controller) {
+          const next = await iterator.next();
+          if (next.done) {
+            controller.close();
+          } else {
+            controller.enqueue(next.value);
+          }
+        },
+        async cancel() {
+          await iterator.return?.();
+        }
+      });
+    }
+  });
+}
+function createProductionAgentRuntime(overrides = {}) {
+  return {
+    configure: configureOpenAI,
+    // A test/override model shadows the registry routing entirely (the scripted
+    // model used in worker tests is not in any provider's allow-list), so when
+    // one is supplied resolveTurnModel reports "no resolution" and the caller
+    // keeps the legacy global-client path with the override model.
+    resolveTurnModel: (settings, modelId) => overrides.model ? null : resolveTurnModel(settings, modelId),
+    buildAgent: (settings, resources, options) => buildOpenGeniAgent(settings, resources, {
+      ...options,
+      ...overrides.model ? { model: overrides.model } : {}
+    }),
+    prepareTools: prepareAgentTools,
+    prepareInput: prepareRunInput,
+    runStream: async (agent, input, settings, options) => await runAgentStream(agent, input, settings, {
+      ...options,
+      sandboxClient: overrides.sandboxClient
+    }),
+    serializeApprovals
+  };
+}
+function buildOpenAIClientFromSettings(settings) {
+  if (settings.openaiProvider === "azure") {
+    const baseURL = settings.azureOpenaiBaseUrl ?? azureDeploymentBaseUrl(settings);
+    const apiKey = settings.azureOpenaiApiKey ?? settings.azureOpenaiAdToken ?? "azure-ad-token";
+    return new OpenAI({
+      apiKey,
+      baseURL,
+      maxRetries: settings.openaiMaxRetries,
+      defaultQuery: azureOpenAIDefaultQuery(settings, baseURL),
+      defaultHeaders: settings.azureOpenaiAdToken && !settings.azureOpenaiApiKey ? { Authorization: `Bearer ${settings.azureOpenaiAdToken}` } : void 0,
+      // Rewrite every outbound /responses computer_call to the ACTIONS-ONLY shape
+      // the GA Azure computer tool (gpt-5.5) accepts. This is the lowest reachable
+      // seam — below the SDK responses converter, which always re-synthesizes BOTH
+      // `action` and `actions` (rejected 400 "exactly one of action or actions").
+      // See computerCallNormalizingFetch / rewriteComputerCallsToActionsOnly.
+      fetch: computerCallNormalizingFetch(globalThis.fetch)
+    });
+  }
+  return new OpenAI({
+    apiKey: settings.openaiApiKey ?? process.env.OPENAI_API_KEY,
+    ...settings.openaiBaseUrl ? { baseURL: settings.openaiBaseUrl } : {},
+    maxRetries: settings.openaiMaxRetries
+  });
+}
+var providerClientCache = /* @__PURE__ */ new Map();
+function buildProviderClient(provider, settings) {
+  const cached = providerClientCache.get(provider.id);
+  if (cached) {
+    return cached;
+  }
+  const client = provider.builtin ? buildOpenAIClientFromSettings(settings) : provider.kind === "codex-subscription" ? new OpenAI({
+    apiKey: provider.apiKey ?? "codex-subscription",
+    ...provider.baseUrl ? { baseURL: provider.baseUrl } : {},
+    maxRetries: settings.openaiMaxRetries,
+    fetch: codexSubscriptionFetch(globalThis.fetch)
+  }) : new OpenAI({
+    ...provider.apiKey ? { apiKey: provider.apiKey } : {},
+    ...provider.baseUrl ? { baseURL: provider.baseUrl } : {},
+    maxRetries: settings.openaiMaxRetries,
+    ...provider.defaultQuery ? { defaultQuery: provider.defaultQuery } : {},
+    ...provider.defaultHeaders ? { defaultHeaders: provider.defaultHeaders } : {}
+  });
+  providerClientCache.set(provider.id, client);
+  return client;
+}
+function buildModelInstance(provider, client, modelId) {
+  return provider.api === "chat" ? new OpenAIChatCompletionsModel(client, modelId) : new OpenAIResponsesModel(client, modelId);
+}
+function resolveTurnModel(settings, modelId) {
+  const resolved = resolveModelProvider(settings, modelId);
+  if (!resolved) {
+    return null;
+  }
+  const client = buildProviderClient(resolved.provider, settings);
+  return {
+    provider: resolved.provider,
+    client,
+    model: buildModelInstance(resolved.provider, client, resolved.model.id),
+    configured: resolved.model
+  };
+}
+var MultiProviderModelProvider = class {
+  constructor(settings) {
+    this.settings = settings;
+  }
+  settings;
+  fallback;
+  async getModel(modelName) {
+    if (modelName) {
+      const resolved = resolveTurnModel(this.settings, modelName);
+      if (resolved) {
+        if (modelName.startsWith(CODEX_MODEL_ID_PREFIX) && resolved.provider.kind !== "codex-subscription") {
+          throw new CodexSubscriptionUnavailableError(modelName);
+        }
+        return resolved.model;
+      }
+      if (modelName.startsWith(CODEX_MODEL_ID_PREFIX)) {
+        throw new CodexSubscriptionUnavailableError(modelName);
+      }
+    }
+    this.fallback ??= new OpenAIProvider();
+    return this.fallback.getModel(modelName);
+  }
+};
+var CodexSubscriptionUnavailableError = class extends Error {
+  constructor(modelName) {
+    super(
+      `Codex subscription model "${modelName}" is unavailable: no active Codex subscription is connected for this workspace. Connect (or reconnect) your ChatGPT/Codex subscription in Settings, then retry.`
+    );
+    this.name = "CodexSubscriptionUnavailableError";
+  }
+};
+function configureOpenAI(settings) {
+  setOpenAIResponsesTransport(settings.openaiResponsesTransport);
+  const router = new MultiProviderModelProvider(settings);
+  if (settings.openaiProvider === "azure") {
+    setDefaultOpenAIClient(buildOpenAIClientFromSettings(settings));
+    setDefaultModelProvider(router);
+    return;
+  }
+  if (settings.openaiApiKey) {
+    setDefaultOpenAIKey(settings.openaiApiKey);
+  }
+  if (settings.openaiBaseUrl) {
+    setDefaultOpenAIClient(buildOpenAIClientFromSettings(settings));
+  }
+  setDefaultModelProvider(router);
+}
+async function summarizeForCompaction(settings, messages, options = {}) {
+  const client = options.client ?? buildOpenAIClientFromSettings(settings);
+  const api = options.api ?? "responses";
+  const model = options.model ?? settings.openaiModel;
+  const maxTokens = options.maxOutputTokens ?? settings.contextSummaryMaxTokens;
+  try {
+    if (api === "chat") {
+      const completion = await client.chat.completions.create({
+        model,
+        max_tokens: maxTokens,
+        messages: [
+          { role: "system", content: messages.system },
+          { role: "user", content: messages.user }
+        ]
+      });
+      const text2 = completion.choices?.[0]?.message?.content;
+      const trimmed2 = typeof text2 === "string" ? text2.trim() : "";
+      return trimmed2.length > 0 ? trimmed2 : null;
+    }
+    const response = await client.responses.create({
+      model,
+      // store:false is the OpenAI-platform-only storeless precondition; Azure
+      // rejects it. The summarizer's resolved client is OpenAI/Azure on the
+      // built-in path (api "responses"), so gate it on the built-in provider.
+      ...settings.openaiProvider === "azure" ? {} : { store: false },
+      max_output_tokens: maxTokens,
+      input: [
+        { role: "system", content: messages.system },
+        { role: "user", content: messages.user }
+      ]
+    });
+    const text = extractResponseOutputText(response);
+    const trimmed = text.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  } catch (error) {
+    console.error("context compaction summarize failed (compaction skipped this turn)", error);
+    return null;
+  }
+}
+function extractResponseOutputText(response) {
+  if (!response || typeof response !== "object") {
+    return "";
+  }
+  const direct = response.output_text;
+  if (typeof direct === "string") {
+    return direct;
+  }
+  const output = response.output;
+  if (!Array.isArray(output)) {
+    return "";
+  }
+  const parts = [];
+  for (const item of output) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    if (item.type !== "message") {
+      continue;
+    }
+    if (item.role !== "assistant") {
+      continue;
+    }
+    const content = item.content;
+    if (!Array.isArray(content)) {
+      continue;
+    }
+    for (const part of content) {
+      if (part && typeof part === "object" && typeof part.text === "string") {
+        parts.push(part.text);
+      }
+    }
+  }
+  return parts.join("");
+}
+function workspaceEnvironmentInstructions(environment) {
+  const lines = [
+    `A workspace environment named "${environment.name}" is attached to this session; its variables are exported in the sandbox shell environment.`
+  ];
+  const variableNames = (environment.variableNames ?? []).filter((name) => name.length > 0);
+  if (variableNames.length > 0) {
+    lines.push(`Exported environment variables: ${[...variableNames].sort().join(", ")}.`);
+  }
+  const description = environment.description?.trim();
+  if (description) {
+    lines.push(`Environment notes from the operator: ${description}`);
+  }
+  return lines;
+}
+function coreInstructions(workspaceEnvironment) {
+  return [
+    "If the session has a goal, you own it: keep working until you call opengeni__goal_complete with concrete evidence or opengeni__goal_pause with a rationale; revise it with opengeni__goal_update; create one with opengeni__goal_set when given a long-running objective.",
+    ...workspaceEnvironment ? workspaceEnvironmentInstructions(workspaceEnvironment) : []
+  ];
+}
+function composeAgentInstructions(template, workspaceEnvironment) {
+  const core = coreInstructions(workspaceEnvironment).join(" ");
+  if (template.includes(AGENT_INSTRUCTIONS_CORE_PLACEHOLDER)) {
+    return template.split(AGENT_INSTRUCTIONS_CORE_PLACEHOLDER).join(core);
+  }
+  return core ? `${template} ${core}` : template;
+}
+var agentFileDownloads = /* @__PURE__ */ new WeakMap();
+var agentRepositoryCloneHooks = /* @__PURE__ */ new WeakMap();
+var agentGitTokenSeed = /* @__PURE__ */ new WeakMap();
+var agentActiveSandboxBackend = /* @__PURE__ */ new WeakMap();
+function buildOpenGeniAgent(settings, resources, options = {}) {
+  const compactionMode = options.compactionMode ?? resolveContextCompactionMode(settings);
+  const hostedWebSearch = options.hostedWebSearch ?? settings.webSearchEnabled;
+  const encryptedReasoning = options.encryptedReasoning ?? settings.openaiReasoningEncryptedContent;
+  const contextWindowTokens = options.contextWindowTokens ?? settings.contextWindowTokens;
+  const hostedTools = hostedWebSearch ? [webSearchTool()] : [];
+  const baseConfig = {
+    name: "OpenGeni Agent",
+    model: options.model ?? settings.openaiModel,
+    // White-label persona composition. The effective template is the per-call
+    // override (options.instructionsTemplate, resolved by the caller as
+    // session > workspace) falling back to the deployment default
+    // (settings.agentInstructionsTemplate, default DEFAULT_AGENT_INSTRUCTIONS).
+    // composeAgentInstructions substitutes the non-bypassable CORE (goal-loop
+    // ownership + workspace-environment block) at the {{core}} marker, or
+    // appends it when the template omits the marker. With the default template
+    // and no environment this is byte-identical to the historical preamble.
+    instructions: options.genesisTitleHint ? `${composeAgentInstructions(options.instructionsTemplate ?? settings.agentInstructionsTemplate, options.workspaceEnvironment)} ${GENESIS_TITLE_DIRECTIVE}` : composeAgentInstructions(options.instructionsTemplate ?? settings.agentInstructionsTemplate, options.workspaceEnvironment),
+    modelSettings: {
+      reasoning: { effort: options.reasoningEffort ?? settings.openaiReasoningEffort, summary: "detailed" },
+      // Server-side compaction (OpenAI platform) requires store=false: the
+      // server emits an opaque ENCRYPTED 'compaction' item that round-trips in
+      // the request rather than being anchored to a stored response. OpenGeni
+      // already runs storeless (provider item ids stripped, encrypted reasoning
+      // round-tripped), so this is consistent with the existing design and
+      // only set where the server compaction capability is attached. Gated on
+      // the RESOLVED compaction mode (registry providers resolve to "client",
+      // so they never carry store:false).
+      ...compactionMode === "server" ? { store: false } : {},
+      // Round-trip the encrypted reasoning payload with every call so chains
+      // of thought survive without provider-side response storage (which is
+      // what stripped provider item ids opt us out of — see
+      // stripProviderItemIds). providerData.include replaces any
+      // tool-derived include entries; OpenGeni's tools are MCP/sandbox
+      // function tools, which contribute none. Gated on the resolved
+      // encryptedReasoning flag: the chat wire API has no encrypted_content
+      // field, so registry "chat" providers turn it off.
+      ...encryptedReasoning ? { providerData: { include: ["reasoning.encrypted_content"] } } : {}
+    },
+    // Explicit hosted tools (web_search when enabled). Threaded into BOTH the
+    // `new Agent(baseConfig)` path (sandboxBackend === "none") and the
+    // `new SandboxAgent({ ...baseConfig, ... })` path via the shared baseConfig
+    // spread; the SDK concatenates these with MCP and sandbox capability tools.
+    ...hostedTools.length ? { tools: hostedTools } : {},
+    ...options.mcpServers?.length ? { mcpServers: options.mcpServers } : {}
+  };
+  if (settings.sandboxBackend === "none") {
+    const agent2 = new Agent(baseConfig);
+    maybeInstallCodexToolSearch(agent2, settings, options);
+    return agent2;
+  }
+  const runAs = sandboxRunAs(settings);
+  const agent = new SandboxAgent({
+    ...baseConfig,
+    defaultManifest: buildManifest(settings, resources, options.sandboxEnvironment, options.fileResourceDownloads),
+    ...runAs ? { runAs } : {},
+    capabilities: buildAgentCapabilities(settings, options.packSkills ?? [], {
+      compactionMode,
+      contextWindowTokens,
+      ...options.structuredToolTransport !== void 0 ? { structuredToolTransport: options.structuredToolTransport } : {}
+    })
+  });
+  agentFileDownloads.set(agent, normalizeSandboxFileDownloads(options.fileResourceDownloads ?? []).filter((download) => !download.content));
+  agentRepositoryCloneHooks.set(agent, sandboxRepositoryCloneHooks(settings, resources, options.activeSandboxBackend));
+  if (options.activeSandboxBackend) {
+    agentActiveSandboxBackend.set(agent, options.activeSandboxBackend);
+  }
+  if (options.gitTokenSeed) {
+    agentGitTokenSeed.set(agent, options.gitTokenSeed);
+  }
+  maybeInstallCodexToolSearch(agent, settings, options);
+  return agent;
+}
+function maybeInstallCodexToolSearch(agent, settings, options) {
+  if (settings.codexToolSearchEnabled && options.structuredToolTransport === false) {
+    installCodexToolSearch(
+      agent,
+      options.codexConnectorNamespaces ?? /* @__PURE__ */ new Set()
+    );
+  }
+}
+function neutralizeStructuredToolTransport(capability) {
+  const forceFunctionTransport = function() {
+    this._modelInstance = void 0;
+    return this;
+  };
+  capability.bindModel = forceFunctionTransport;
+}
+function buildAgentCapabilities(settings, packSkills, options = {}) {
+  const mode = options.compactionMode ?? resolveContextCompactionMode(settings);
+  const contextWindowTokens = options.contextWindowTokens ?? settings.contextWindowTokens;
+  const filesystemCapability = filesystem();
+  if (options.structuredToolTransport === false) {
+    neutralizeStructuredToolTransport(filesystemCapability);
+  }
+  const caps = [filesystemCapability, shell()];
+  if (mode === "server") {
+    caps.push(compaction({ policy: new StaticCompactionPolicy(contextServerCompactThreshold({ ...settings, contextWindowTokens })) }));
+  }
+  caps.push(skills({ lazyFrom: lazySkillSourceWithPackSkills(packSkills) }));
+  if (settings.computerUseEnabled && settings.sandboxDesktopEnabled && desktopCapableBackend(settings.sandboxBackend)) {
+    const computerCapability = computerUse({
+      dimensions: [settings.streamResolutionWidth, settings.streamResolutionHeight],
+      readOnly: settings.computerUseReadOnly,
+      // On the codex path the function tools deliver screenshots as a real image the
+      // model can see. The ChatGPT/Codex backend rejects HOSTED tool types but DOES
+      // accept `input_image` content items inside a `function_call_output` (proven by
+      // openai/codex codex-rs, whose view_image tool ships exactly that shape) — so a
+      // structured image tool result is seen, where a text data-URL would be unreadable.
+      ...options.structuredToolTransport === false ? { imageFunctionResults: true } : {}
+    });
+    if (options.structuredToolTransport === false) {
+      neutralizeStructuredToolTransport(computerCapability);
+    }
+    caps.push(computerCapability);
+  }
+  return caps;
+}
+function sandboxRunAs(_settings) {
+  return void 0;
+}
+async function prepareAgentTools(settings, tools, options = {}) {
+  const codexConnectorNamespaces = /* @__PURE__ */ new Set();
+  if (tools.length === 0) {
+    return { mcpServers: [], close: async () => {
+    }, codexConnectorNamespaces };
+  }
+  const registry = new Map(settings.mcpServers.map((server) => [server.id, server]));
+  const servers = await Promise.all(tools.map(async (tool2) => {
+    const config = registry.get(tool2.id);
+    if (!config) {
+      throw new Error(`Unknown MCP server id: ${tool2.id}`);
+    }
+    const url = firstPartyMcpServerUrlForRun(settings, config, options.workspaceId) ?? config.url;
+    const server = new PrefixedMcpServer(new MCPServerStreamableHttp({
+      url,
+      name: config.name ?? config.id,
+      cacheToolsList: config.cacheToolsList,
+      // codex_apps returns connector tools with empty `outputSchema: {}` that the
+      // MCP SDK's strict Tool schema rejects (fails the turn during tools/list);
+      // sanitize the response on the wire before validation. The namespace Set
+      // also captures each tool's original connector namespace (P4 Part B.1).
+      ...isCodexAppsMcpServer(config) ? { fetch: codexAppsSanitizingFetch(globalThis.fetch, codexConnectorNamespaces) } : {},
+      ...await mcpServerRequestInit(settings, config, options),
+      ...config.timeoutMs ? {
+        timeout: config.timeoutMs,
+        clientSessionTimeoutSeconds: Math.ceil(config.timeoutMs / 1e3)
+      } : {}
+    }), config.id, config.allowedTools);
+    const optional = tool2.optional === true;
+    return { server, bestEffort: isCodexAppsMcpServer(config) || optional, optional };
+  }));
+  const requiredServers = servers.filter((entry) => !entry.bestEffort).map((entry) => entry.server);
+  const bestEffortServers = servers.filter((entry) => entry.bestEffort).map((entry) => entry.server);
+  const optionalServerNames = new Set(
+    servers.filter((entry) => entry.optional).map((entry) => entry.server.name)
+  );
+  const connectedRequired = await connectMcpServers(requiredServers, {
+    connectInParallel: true,
+    strict: true
+  });
+  const connectedBestEffort = bestEffortServers.length ? await connectMcpServers(bestEffortServers, {
+    connectInParallel: true,
+    strict: false
+  }) : null;
+  if (connectedBestEffort) {
+    for (const failed of connectedBestEffort.failed) {
+      if (!optionalServerNames.has(failed.name)) {
+        continue;
+      }
+      const error = connectedBestEffort.errors.get(failed);
+      console.warn(
+        `[mcp] optional capability server "${failed.name}" failed to connect/list tools; skipping it for this turn`,
+        error instanceof Error ? error.message : error
+      );
+    }
+  }
+  return {
+    mcpServers: [...connectedRequired.active, ...connectedBestEffort?.active ?? []],
+    close: async () => {
+      await connectedRequired.close();
+      if (connectedBestEffort) {
+        await connectedBestEffort.close();
+      }
+    },
+    codexConnectorNamespaces
+  };
+}
+async function mcpServerRequestInit(settings, config, options) {
+  if (isCodexAppsMcpServer(config)) {
+    return await codexAppsMcpRequestInit(settings);
+  }
+  if (isFirstPartyMcpServer(settings, config)) {
+    return await firstPartyMcpRequestInit(settings, config, options);
+  }
+  if (config.headers && Object.keys(config.headers).length > 0) {
+    return { requestInit: { headers: { ...config.headers } } };
+  }
+  return {};
+}
+async function firstPartyMcpRequestInit(settings, config, options) {
+  if (!isFirstPartyMcpServer(settings, config)) {
+    return {};
+  }
+  const headers = {};
+  if (settings.authRequired && settings.accessKey) {
+    headers["x-opengeni-access-key"] = settings.accessKey;
+  }
+  if (settings.delegationSecret && options.accountId && options.workspaceId) {
+    headers.authorization = `Bearer ${await signDelegatedAccessToken(settings.delegationSecret, {
+      accountId: options.accountId,
+      workspaceId: options.workspaceId,
+      subjectId: options.subjectId ?? "worker:first-party-mcp",
+      ...options.subjectLabel ? { subjectLabel: options.subjectLabel } : {},
+      permissions: options.firstPartyPermissions ?? firstPartyMcpPermissions,
+      ...options.sessionId ? { sessionId: options.sessionId } : {},
+      exp: Math.floor(Date.now() / 1e3) + 60 * 60
+    })}`;
+  }
+  if (Object.keys(headers).length === 0) {
+    return {};
+  }
+  return {
+    requestInit: {
+      headers
+    }
+  };
+}
+async function codexAppsMcpRequestInit(settings) {
+  const ctx = codexRequestStorage.getStore();
+  if (!ctx) {
+    return {};
+  }
+  let token;
+  try {
+    token = await ctx.getToken();
+  } catch {
+    return {};
+  }
+  const headers = {
+    authorization: `Bearer ${token.accessToken}`,
+    // The ChatGPT backend sits behind Cloudflare, which 403s requests bearing a
+    // default runtime User-Agent (confirmed live: an HTML bot-block page, NOT an
+    // auth failure). Send the codex client identity — the same originator/version/
+    // User-Agent the model fetch uses — so the MCP connect handshake passes the edge.
+    originator: CODEX_ORIGINATOR,
+    "user-agent": `${CODEX_ORIGINATOR}/${ctx.clientVersion}`,
+    version: ctx.clientVersion
+  };
+  if (token.chatgptAccountId) {
+    headers["chatgpt-account-id"] = token.chatgptAccountId;
+  }
+  if (settings.codexProductSku) {
+    headers["X-OpenAI-Product-Sku"] = settings.codexProductSku;
+  }
+  return { requestInit: { headers } };
+}
+var firstPartyMcpPermissions = [
+  "workspace:read",
+  "files:read",
+  "documents:search",
+  "scheduled_tasks:manage",
+  "scheduled_tasks:run",
+  "goals:manage",
+  "sessions:read",
+  "sessions:create",
+  "sessions:control",
+  "environments:use",
+  "environments:manage",
+  "github:use"
+];
+function isCodexAppsMcpServer(config) {
+  return config.id === CODEX_APPS_MCP_SERVER_ID;
+}
+function isFirstPartyMcpServer(settings, config) {
+  if (!["opengeni", "files", "docs"].includes(config.id)) {
+    return false;
+  }
+  if (config.url.includes("{workspaceId}")) {
+    return true;
+  }
+  const url = normalizeUrl(config.url);
+  if (!url) {
+    return false;
+  }
+  return firstPartyMcpUrls(settings).some((candidate) => candidate === url);
+}
+function firstPartyMcpServerUrlForRun(settings, config, workspaceId) {
+  if (!workspaceId || !["opengeni", "files", "docs"].includes(config.id)) {
+    return null;
+  }
+  if (config.url.includes("{workspaceId}")) {
+    return config.url.replaceAll("{workspaceId}", workspaceId);
+  }
+  if (!isFirstPartyMcpServer(settings, config)) {
+    return null;
+  }
+  const rawBase = settings.opengeniMcpUrl?.includes("{workspaceId}") ? settings.opengeniMcpUrl.replaceAll("{workspaceId}", workspaceId) : settings.opengeniMcpUrl ? scopedMcpUrlFromConfiguredBase(settings.opengeniMcpUrl, workspaceId) : firstPartyMcpBaseUrl(settings).replaceAll("{workspaceId}", workspaceId);
+  const url = new URL(rawBase);
+  if (config.id === "docs") {
+    url.pathname = `${url.pathname.replace(/\/+$/, "")}/docs`;
+  }
+  return url.toString();
+}
+function scopedMcpUrlFromConfiguredBase(raw, workspaceId) {
+  const url = new URL(raw);
+  url.pathname = `/v1/workspaces/${workspaceId}/mcp`;
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+function firstPartyMcpUrls(settings) {
+  const base = normalizeUrl(settings.opengeniMcpUrl ?? firstPartyMcpBaseUrl(settings));
+  if (!base) {
+    return [];
+  }
+  const docs = new URL(base);
+  docs.pathname = `${docs.pathname.replace(/\/+$/, "")}/docs`;
+  return [base, normalizeUrl(docs.toString())].filter((value) => Boolean(value));
+}
+function normalizeUrl(raw) {
+  try {
+    const url = new URL(raw);
+    url.hash = "";
+    url.pathname = url.pathname.replace(/\/+$/, "");
+    return url.toString();
+  } catch {
+    return null;
+  }
+}
+function prefixedMcpToolName(registryId, toolName) {
+  return `${registryId}__${toolName}`;
+}
+var PrefixedMcpServer = class {
+  constructor(inner, registryId, allowedTools) {
+    this.inner = inner;
+    this.name = registryId;
+    this.prefix = prefixedMcpToolName(registryId, "");
+    this.cacheToolsList = inner.cacheToolsList;
+    this.allowedTools = allowedTools ? new Set(allowedTools) : void 0;
+  }
+  inner;
+  cacheToolsList;
+  name;
+  prefix;
+  allowedTools;
+  connect() {
+    return this.inner.connect();
+  }
+  close() {
+    return this.inner.close();
+  }
+  async listTools() {
+    const tools = await this.inner.listTools();
+    return tools.filter((tool2) => this.isAllowed(tool2.name)).map((tool2) => ({ ...tool2, name: prefixedMcpToolName(this.name, tool2.name) }));
+  }
+  async callTool(toolName, args, meta) {
+    const unprefixed = this.unprefixToolName(toolName);
+    if (!this.isAllowed(unprefixed)) {
+      throw new Error(`MCP tool ${unprefixed} is not allowed for server ${this.name}`);
+    }
+    return await this.inner.callTool(unprefixed, args, meta);
+  }
+  invalidateToolsCache() {
+    return this.inner.invalidateToolsCache();
+  }
+  async listResources(params) {
+    const resourcesServer = this.inner;
+    if (!resourcesServer.listResources) {
+      throw new Error(`MCP server ${this.name} does not support resources`);
+    }
+    return await resourcesServer.listResources(params);
+  }
+  async listResourceTemplates(params) {
+    const resourcesServer = this.inner;
+    if (!resourcesServer.listResourceTemplates) {
+      throw new Error(`MCP server ${this.name} does not support resource templates`);
+    }
+    return await resourcesServer.listResourceTemplates(params);
+  }
+  async readResource(uri) {
+    const resourcesServer = this.inner;
+    if (!resourcesServer.readResource) {
+      throw new Error(`MCP server ${this.name} does not support resource reads`);
+    }
+    return await resourcesServer.readResource(uri);
+  }
+  isAllowed(toolName) {
+    return !this.allowedTools || this.allowedTools.has(toolName);
+  }
+  unprefixToolName(toolName) {
+    if (!toolName.startsWith(this.prefix)) {
+      throw new Error(`MCP tool ${toolName} is missing expected ${this.name} prefix`);
+    }
+    return toolName.slice(this.prefix.length);
+  }
+};
+function guardAssembledInput(history, trailing, inputBudgetTokens) {
+  if (typeof inputBudgetTokens !== "number" || inputBudgetTokens <= 0) {
+    return [...history, trailing];
+  }
+  const trailingTokens = estimateItemTokens(trailing);
+  const guarded = enforceInputBudget(
+    history,
+    inputBudgetTokens,
+    trailingTokens
+  );
+  if (guarded.trimmed) {
+    console.warn(
+      `read-path budget guard trimmed ${guarded.droppedCount} oldest history item(s) to fit input budget (${inputBudgetTokens} tokens); the over-budget input was NOT sent`
+    );
+  }
+  return [...guarded.items, trailing];
+}
+async function prepareRunInput(agent, input, options = {}) {
+  if (input.kind === "message") {
+    if (input.historyItems && input.historyItems.length > 0) {
+      const sandboxSessionState2 = input.sandboxEnvelope ? await restoredSandboxSessionStateFromEntry(input.sandboxEnvelope, options.sandboxClient) : void 0;
+      const sanitizedHistory2 = sanitizeHistoryItemsForModel(
+        input.historyItems
+      );
+      return {
+        // Read-path budget guard: even after the orphan sanitizer, an assembled
+        // input can exceed the model window (pre-turn compaction is best-effort
+        // and can no-op). Trim the oldest history at a clean turn boundary so an
+        // over-budget request is never sent. No-op when no budget is supplied.
+        input: guardAssembledInput(
+          sanitizedHistory2,
+          {
+            type: "message",
+            role: "user",
+            content: input.text
+          },
+          options.inputBudgetTokens
+        ),
+        ...sandboxSessionState2 ? { sandboxSessionState: sandboxSessionState2 } : {}
+      };
+    }
+    if (!input.serializedRunState || isClearedRunStateBlob(input.serializedRunState)) {
+      return { input: input.text };
+    }
+    const state2 = await RunState.fromString(agent, input.serializedRunState);
+    const sandboxSessionState = await restoredSandboxSessionState(state2, options.sandboxClient);
+    const sanitizedHistory = sanitizeHistoryItemsForModel(
+      state2.history
+    );
+    return {
+      // Read-path budget guard (see the items path above): keep an over-budget
+      // resumed history off the wire by trimming the oldest turns when a budget
+      // is supplied.
+      input: guardAssembledInput(
+        sanitizedHistory,
+        {
+          type: "message",
+          role: "user",
+          content: input.text
+        },
+        options.inputBudgetTokens
+      ),
+      ...sandboxSessionState ? { sandboxSessionState } : {},
+      serializedRunStateForSandbox: input.serializedRunState
+    };
+  }
+  if (isClearedRunStateBlob(input.serializedRunState)) {
+    throw new Error("Cannot resume an approval: the session context was cleared, so the awaiting run state no longer exists.");
+  }
+  const state = await RunState.fromString(agent, input.serializedRunState);
+  const interruptions = state.getInterruptions();
+  const target = interruptions.find((item) => approvalIdentifier(item) === input.approvalId);
+  if (!target) {
+    throw new Error(`Approval not found in saved run state: ${input.approvalId}`);
+  }
+  if (input.decision === "approve") {
+    state.approve(target);
+  } else {
+    state.reject(target, input.message ? { message: input.message } : void 0);
+  }
+  return { input: state };
+}
+var GENESIS_TITLE_DIRECTIVE = "This is the first turn of a new session. Before responding to the user, call the opengeni__set_session_title tool with a concise 3-7 word title that summarizes what this session is about, then address the user's request normally.";
+var stripProviderItemIdsFilter = ({ modelData }) => ({
+  ...modelData,
+  input: modelData.input.map((item) => {
+    if (item && typeof item === "object" && "id" in item) {
+      const { id: _id, ...rest } = item;
+      return rest;
+    }
+    return item;
+  })
+});
+var normalizeComputerCallsFilter = ({ modelData }) => ({
+  ...modelData,
+  input: normalizeComputerCallActions(
+    modelData.input
+  )
+});
+function composeCallModelInputFilters(filters) {
+  return async (args) => {
+    let modelData = args.modelData;
+    for (const filter of filters) {
+      modelData = await filter({ ...args, modelData });
+    }
+    return modelData;
+  };
+}
+function callModelInputFilterForSettings(settings) {
+  const filters = [normalizeComputerCallsFilter];
+  if (settings.openaiProviderItemIds === "strip") {
+    filters.push(stripProviderItemIdsFilter);
+  }
+  return composeCallModelInputFilters(filters);
+}
+async function runAgentStream(agent, input, settings, overrides = {}) {
+  const prepared = typeof input === "string" || input instanceof RunState ? { input } : input;
+  const environment = overrides.sandboxEnvironment ?? collectSandboxEnvironment2(settings);
+  if (overrides.ownedSandbox) {
+    const { client: ownedClient, session, sessionState } = overrides.ownedSandbox;
+    const setupSession = overrides.ownedSandbox.setupSession ?? session;
+    const runAs2 = sandboxRunAs(settings);
+    const fileDownloads2 = sandboxFileDownloadsForAgent(agent);
+    const resourceClient2 = fileDownloads2.length > 0 ? withSandboxFileDownloads(ownedClient, fileDownloads2, {
+      ...overrides.onRuntimeEvent ? { onRuntimeEvent: overrides.onRuntimeEvent } : {},
+      ...runAs2 ? { runAs: runAs2 } : {}
+    }) : ownedClient;
+    const ownedGitTokenSeed = gitTokenSeedForAgent(agent);
+    const ownedHooks = [
+      ...sandboxLifecycleHooksForIds(sandboxLifecycleHookIds(settings)),
+      ...sandboxRepositoryCloneHooksForAgent(agent)
+    ];
+    const ownedHookContext = {
+      environment,
+      ...overrides.onRuntimeEvent ? { onRuntimeEvent: overrides.onRuntimeEvent } : {},
+      ...runAs2 ? { runAs: runAs2 } : {},
+      ...ownedGitTokenSeed ? { gitTokenSeed: ownedGitTokenSeed } : {}
+    };
+    if (agentActiveSandboxBackend.get(agent) !== "selfhosted") {
+      await runBeforeAgentStartHooks(setupSession, ownedHooks, ownedHookContext);
+      if (fileDownloads2.length > 0) {
+        await materializeSandboxFileDownloads(setupSession, fileDownloads2, {
+          ...overrides.onRuntimeEvent ? { onRuntimeEvent: overrides.onRuntimeEvent } : {},
+          ...runAs2 ? { runAs: runAs2 } : {}
+        });
+      }
+    }
+    const decoratedClient = withSandboxLifecycleHooks(resourceClient2, ownedHooks, ownedHookContext);
+    const ownedFilter = composeCallModelInputFilters(
+      [callModelInputFilterForSettings(settings), overrides.callModelInputFilter].filter(
+        (f) => Boolean(f)
+      )
+    );
+    const ownedRunOptions = {
+      stream: true,
+      maxTurns: settings.agentMaxModelCallsPerTurn,
+      callModelInputFilter: ownedFilter
+    };
+    ownedRunOptions.sandbox = {
+      client: decoratedClient,
+      session,
+      ...sessionState ? { sessionState } : {}
+    };
+    return await runScopedRunner(settings).run(agent, prepared.input, ownedRunOptions);
+  }
+  const rawClient = overrides.sandboxClient ?? createSandboxClient(settings, environment);
+  const refreshedClient = rawClient ? withManifestRefreshOnResume(rawClient, agent.defaultManifest) : void 0;
+  const runAs = sandboxRunAs(settings);
+  const fileDownloads = sandboxFileDownloadsForAgent(agent);
+  const resourceClient = refreshedClient && fileDownloads.length > 0 ? withSandboxFileDownloads(refreshedClient, fileDownloads, {
+    ...overrides.onRuntimeEvent ? { onRuntimeEvent: overrides.onRuntimeEvent } : {},
+    ...runAs ? { runAs } : {}
+  }) : refreshedClient;
+  const gitTokenSeed = gitTokenSeedForAgent(agent);
+  const client = resourceClient ? withSandboxLifecycleHooks(resourceClient, [
+    ...sandboxLifecycleHooksForIds(sandboxLifecycleHookIds(settings)),
+    ...sandboxRepositoryCloneHooksForAgent(agent)
+  ], {
+    environment,
+    ...overrides.onRuntimeEvent ? { onRuntimeEvent: overrides.onRuntimeEvent } : {},
+    ...runAs ? { runAs } : {},
+    ...gitTokenSeed ? { gitTokenSeed } : {}
+  }) : void 0;
+  const sandboxSessionState = prepared.sandboxSessionState ?? (prepared.serializedRunStateForSandbox && client ? await restoredSandboxSessionState(await RunState.fromString(agent, prepared.serializedRunStateForSandbox), client) : void 0);
+  const callModelInputFilter = composeCallModelInputFilters(
+    [callModelInputFilterForSettings(settings), overrides.callModelInputFilter].filter(
+      (f) => Boolean(f)
+    )
+  );
+  const runOptions = {
+    stream: true,
+    maxTurns: settings.agentMaxModelCallsPerTurn,
+    // Strip provider-assigned item ids from every model call (turn-start
+    // history replay AND mid-turn follow-ups) so requests never depend on the
+    // provider's server-side response store. A stored response can vanish
+    // between two calls of the same turn, failing the run with 400 "Item with
+    // id 'rs_…' not found"; with the ids gone the request is self-contained.
+    callModelInputFilter
+  };
+  void settings.disableOpenaiTracing;
+  if (client) {
+    runOptions.sandbox = {
+      client,
+      ...sandboxSessionState ? { sessionState: sandboxSessionState } : {}
+    };
+  }
+  return await runScopedRunner(settings).run(agent, prepared.input, runOptions);
+}
+function runScopedRunner(settings) {
+  return new Runner({ modelProvider: new MultiProviderModelProvider(settings) });
+}
+function maxTurnsExceededRunState(error) {
+  if (!(error instanceof MaxTurnsExceededError)) {
+    return null;
+  }
+  try {
+    return { serializedRunState: error.state ? error.state.toString() : null };
+  } catch {
+    return { serializedRunState: null };
+  }
+}
+function agentsErrorRunState(error) {
+  if (!(error instanceof AgentsError) || !error.state) {
+    return null;
+  }
+  try {
+    return error.state.toString();
+  } catch {
+    return null;
+  }
+}
+function withManifestRefreshOnResume(client, targetManifest) {
+  if (!targetManifest || !client.resume) {
+    return client;
+  }
+  return {
+    backendId: client.backendId,
+    ...client.supportsDefaultOptions !== void 0 ? { supportsDefaultOptions: client.supportsDefaultOptions } : {},
+    ...client.create ? { create: async (...args) => await client.create(...args) } : {},
+    resume: async (state) => {
+      const session = await client.resume(state);
+      await applyMissingManifestEntries(session, targetManifest);
+      return session;
+    },
+    ...client.delete ? { delete: async (state) => await client.delete(state) } : {},
+    ...client.serializeSessionState ? { serializeSessionState: async (state, options) => await client.serializeSessionState(state, options) } : {},
+    ...client.canPersistOwnedSessionState ? { canPersistOwnedSessionState: async (state) => await client.canPersistOwnedSessionState(state) } : {},
+    ...client.canReusePreservedOwnedSession ? { canReusePreservedOwnedSession: async (state) => await client.canReusePreservedOwnedSession(state) } : {},
+    ...client.deserializeSessionState ? { deserializeSessionState: async (state) => await client.deserializeSessionState(state) } : {}
+  };
+}
+async function applyMissingManifestEntries(session, targetManifest) {
+  const currentManifestValue = session.state?.manifest;
+  const currentManifest = currentManifestValue ? ensureManifest(currentManifestValue) : void 0;
+  const target = ensureManifest(targetManifest);
+  if (!currentManifest) {
+    if (Object.keys(target.entries).length === 0) {
+      return;
+    }
+    throw new Error("Resumed sandbox session cannot apply new manifest entries because current manifest state is unavailable");
+  }
+  if (!session.applyManifest && !session.materializeEntry) {
+    if (Object.keys(target.entries).length === 0) {
+      return;
+    }
+    throw new Error("Resumed sandbox session cannot apply new manifest entries because it does not support applyManifest() or materializeEntry()");
+  }
+  if (Object.keys(target.entries).length === 0) {
+    return;
+  }
+  if (currentManifest.root !== target.root) {
+    throw new Error("Cannot apply per-turn resources to a sandbox with a different manifest root");
+  }
+  const entries = {};
+  for (const [path, entry] of Object.entries(target.entries)) {
+    const existing = currentManifest.entries[path];
+    if (existing === void 0) {
+      entries[path] = entry;
+      continue;
+    }
+    if (stableJson(existing) !== stableJson(entry)) {
+      throw new Error(`Cannot replace existing sandbox manifest entry: ${path}`);
+    }
+  }
+  const environmentChanged = stableJson(currentManifest.environment) !== stableJson(target.environment);
+  if (environmentChanged && !session.applyManifest) {
+    throw new Error("Resumed sandbox session cannot refresh manifest environment because it does not support applyManifest()");
+  }
+  if (Object.keys(entries).length === 0 && !environmentChanged) {
+    return;
+  }
+  const extraPathGrants = mergePathGrants(currentManifest.extraPathGrants, target.extraPathGrants);
+  const delta = new Manifest({
+    root: currentManifest.root,
+    entries,
+    environment: target.environment,
+    ...extraPathGrants.length ? { extraPathGrants } : {}
+  });
+  if (session.applyManifest) {
+    await session.applyManifest(delta);
+  } else {
+    for (const [path, entry] of Object.entries(entries)) {
+      await session.materializeEntry({ path, entry });
+    }
+  }
+  session.state.manifest = new Manifest({
+    root: currentManifest.root,
+    environment: environmentChanged ? target.environment : currentManifest.environment,
+    entries: {
+      ...currentManifest.entries,
+      ...entries
+    },
+    ...extraPathGrants.length ? { extraPathGrants } : {}
+  });
+}
+function mergePathGrants(current, target) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const grant of [...current ?? [], ...target ?? []]) {
+    merged.set(grant.path, grant);
+  }
+  return [...merged.values()];
+}
+function withSandboxFileDownloads(client, downloads, context = {}) {
+  const normalizedDownloads = normalizeSandboxFileDownloads(downloads);
+  if (normalizedDownloads.length === 0) {
+    return client;
+  }
+  const completed = /* @__PURE__ */ new WeakSet();
+  const wrapSession = async (session) => {
+    if (typeof session === "object" && session !== null && !completed.has(session)) {
+      await materializeSandboxFileDownloads(session, normalizedDownloads, context);
+      completed.add(session);
+    }
+    return session;
+  };
+  return {
+    backendId: client.backendId,
+    ...client.supportsDefaultOptions !== void 0 ? { supportsDefaultOptions: client.supportsDefaultOptions } : {},
+    ...client.create ? { create: async (...args) => await wrapSession(await client.create(...args)) } : {},
+    ...client.resume ? { resume: async (state) => await wrapSession(await client.resume(state)) } : {},
+    ...client.delete ? { delete: async (state) => await client.delete(state) } : {},
+    ...client.serializeSessionState ? { serializeSessionState: async (state, options) => await client.serializeSessionState(state, options) } : {},
+    ...client.canPersistOwnedSessionState ? { canPersistOwnedSessionState: async (state) => await client.canPersistOwnedSessionState(state) } : {},
+    ...client.canReusePreservedOwnedSession ? { canReusePreservedOwnedSession: async (state) => await client.canReusePreservedOwnedSession(state) } : {},
+    ...client.deserializeSessionState ? { deserializeSessionState: async (state) => await client.deserializeSessionState(state) } : {}
+  };
+}
+async function materializeSandboxFileDownloads(session, downloads, context = {}) {
+  const normalizedDownloads = normalizeSandboxFileDownloads(downloads);
+  if (normalizedDownloads.length === 0) {
+    return;
+  }
+  if (!session.exec && !session.execCommand) {
+    throw new Error("Sandbox file download materialization requires command execution support");
+  }
+  for (const download of normalizedDownloads) {
+    const targetPath = sandboxDownloadTargetPath(download);
+    const payload = {
+      fileId: download.fileId,
+      path: targetPath,
+      sizeBytes: download.sizeBytes ?? null,
+      expiresAt: download.expiresAt ? new Date(download.expiresAt).toISOString() : null
+    };
+    await context.onRuntimeEvent?.({ type: "sandbox.operation.started", payload: { name: "file-resource-download", ...payload } });
+    try {
+      const result = session.exec ? await session.exec({
+        cmd: sandboxFileDownloadCommand(download, targetPath),
+        workdir: "/workspace",
+        ...context.runAs ? { runAs: context.runAs } : {},
+        yieldTimeMs: SANDBOX_LIFECYCLE_COMMAND_TIMEOUT_MS,
+        maxOutputTokens: 2e4
+      }) : await session.execCommand({
+        cmd: sandboxFileDownloadCommand(download, targetPath),
+        workdir: "/workspace",
+        ...context.runAs ? { runAs: context.runAs } : {},
+        yieldTimeMs: SANDBOX_LIFECYCLE_COMMAND_TIMEOUT_MS,
+        maxOutputTokens: 2e4
+      });
+      assertSandboxCommandSucceeded(result, `Sandbox file resource download ${download.fileId}`);
+      await context.onRuntimeEvent?.({ type: "sandbox.operation.completed", payload: { name: "file-resource-download", ...payload } });
+    } catch (error) {
+      await context.onRuntimeEvent?.({
+        type: "sandbox.operation.failed",
+        payload: {
+          name: "file-resource-download",
+          ...payload,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      });
+      throw error;
+    }
+  }
+}
+function sandboxFileDownloadsForAgent(agent) {
+  return typeof agent === "object" && agent !== null ? [...agentFileDownloads.get(agent) ?? []] : [];
+}
+function ensureManifest(manifest) {
+  if (manifest instanceof Manifest && typeof manifest.mountTargetsForMaterialization === "function") {
+    return manifest;
+  }
+  return new Manifest({
+    ...manifest.root ? { root: manifest.root } : {},
+    entries: manifest.entries ?? {},
+    environment: manifest.environment ?? {},
+    ...manifest.extraPathGrants?.length ? { extraPathGrants: manifest.extraPathGrants } : {}
+  });
+}
+function toImageBytes(data) {
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return data.every((n) => typeof n === "number") ? Uint8Array.from(data) : null;
+  }
+  if (data && typeof data === "object") {
+    const values = Object.values(data);
+    if (values.length > 0 && values.every((n) => typeof n === "number")) {
+      return Uint8Array.from(values);
+    }
+  }
+  return null;
+}
+function structuredImageToDataUrl(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const v = value;
+  if (v.type === "input_image") {
+    return typeof v.image === "string" && v.image.length > 0 ? v.image : null;
+  }
+  if (v.type !== "image" || !v.image || typeof v.image !== "object") {
+    return null;
+  }
+  const image = v.image;
+  if (typeof image.url === "string" && image.url.length > 0) {
+    return image.url;
+  }
+  const mediaType = typeof image.mediaType === "string" && image.mediaType.length > 0 ? image.mediaType : "image/png";
+  if (typeof image.data === "string") {
+    return image.data.startsWith("data:") ? image.data : `data:${mediaType};base64,${image.data}`;
+  }
+  const bytes = toImageBytes(image.data);
+  return bytes ? `data:${mediaType};base64,${Buffer.from(bytes).toString("base64")}` : null;
+}
+function normalizeToolOutputForEvent(output) {
+  const single = structuredImageToDataUrl(output);
+  if (single !== null) {
+    return single;
+  }
+  if (Array.isArray(output)) {
+    const normalized = output.map((el) => structuredImageToDataUrl(el) ?? el);
+    if (normalized.length === 1 && typeof normalized[0] === "string") {
+      return normalized[0];
+    }
+    return normalized;
+  }
+  return output;
+}
+function normalizeSdkEvent(event) {
+  const out = [];
+  if (event.type === "raw_model_stream_event") {
+    const data = event.data;
+    if (data?.type === "output_text_delta" && typeof data.delta === "string") {
+      out.push({ type: "agent.message.delta", payload: { text: data.delta } });
+      return out;
+    }
+  }
+  if (isOpenAIResponsesRawModelStreamEvent(event)) {
+    const raw = event.data?.event;
+    if (raw?.type === "response.reasoning_summary_text.delta" && typeof raw.delta === "string") {
+      out.push({ type: "agent.reasoning.delta", payload: { text: raw.delta } });
+    }
+    return out;
+  }
+  if (event.type === "agent_updated_stream_event") {
+    out.push({ type: "agent.updated", payload: { agent: event.agent?.name ?? null } });
+    return out;
+  }
+  if (event.type !== "run_item_stream_event") {
+    return out;
+  }
+  const item = event.item;
+  if (!item) {
+    return out;
+  }
+  if (item.type === "tool_call_item") {
+    const raw = item.rawItem ?? {};
+    out.push({
+      type: "agent.toolCall.created",
+      payload: {
+        id: raw.callId ?? raw.id ?? item.id ?? null,
+        name: raw.name ?? raw.type ?? "tool",
+        arguments: raw.arguments ?? raw.input ?? null,
+        raw
+      }
+    });
+  } else if (item.type === "tool_call_output_item") {
+    out.push({
+      type: "agent.toolCall.output",
+      payload: {
+        id: item.rawItem?.callId ?? item.id ?? null,
+        // Compact any structured/binary image output to a data-URL string so a
+        // screenshot never bloats session_events ~10x as an object-of-numbers.
+        output: normalizeToolOutputForEvent(item.output)
+      }
+    });
+  } else if (item.type === "tool_search_call_item") {
+    const raw = item.rawItem ?? {};
+    out.push({
+      type: "agent.toolCall.created",
+      payload: {
+        id: raw.call_id ?? raw.callId ?? raw.id ?? item.id ?? null,
+        name: "tool_search",
+        arguments: raw.arguments ?? null,
+        raw
+      }
+    });
+  } else if (item.type === "tool_search_output_item") {
+    const raw = item.rawItem ?? {};
+    const disclosed = Array.isArray(raw.tools) ? raw.tools.map((tool2) => typeof tool2?.name === "string" ? tool2.name : "").filter(Boolean) : [];
+    out.push({
+      type: "agent.toolCall.output",
+      payload: {
+        id: raw.call_id ?? raw.callId ?? item.id ?? null,
+        output: { type: "text", text: disclosed.length > 0 ? `Disclosed tools: ${disclosed.join(", ")}` : "No matching tools found." }
+      }
+    });
+  } else if (item.type === "message_output_item") {
+    const text = typeof item.text === "string" ? item.text : void 0;
+    if (text) {
+      out.push({ type: "agent.message.completed", payload: { text } });
+    }
+  }
+  return out;
+}
+function modelResponseUsageFromSdkEvent(event) {
+  const response = modelResponseFromSdkEvent(event);
+  const usage = usageFromResponse(response);
+  if (!usage) {
+    return null;
+  }
+  const responseId = typeof response?.id === "string" ? response.id : typeof response?.responseId === "string" ? response.responseId : void 0;
+  return {
+    ...responseId ? { responseId } : {},
+    usage
+  };
+}
+function modelResponseFromSdkEvent(event) {
+  if (event.type === "raw_model_stream_event") {
+    const data = event.data;
+    if (data?.type === "response_done") {
+      return data.response;
+    }
+  }
+  if (isOpenAIResponsesRawModelStreamEvent(event)) {
+    const raw = event.data?.event;
+    if (raw?.type === "response.completed") {
+      return raw.response;
+    }
+  }
+  return null;
+}
+function usageFromResponse(response) {
+  const raw = response?.usage;
+  if (!raw || typeof raw !== "object") {
+    return null;
+  }
+  const usage = {
+    ...numberProp(raw, "inputTokens", "inputTokens", "input_tokens"),
+    ...numberProp(raw, "outputTokens", "outputTokens", "output_tokens"),
+    ...numberProp(raw, "totalTokens", "totalTokens", "total_tokens"),
+    ...inputTokenDetailsProp(raw)
+  };
+  return Object.keys(usage).length > 0 ? usage : null;
+}
+function numberProp(raw, outputKey, camel, snake) {
+  const value = raw[camel] ?? raw[snake];
+  return typeof value === "number" && Number.isFinite(value) ? { [outputKey]: value } : {};
+}
+function inputTokenDetailsProp(raw) {
+  const details = raw.inputTokensDetails ?? raw.input_tokens_details;
+  if (!details || typeof details !== "object") {
+    return {};
+  }
+  return { inputTokensDetails: details };
+}
+function serializeApprovals(interruptions) {
+  return interruptions.map((item) => {
+    if (typeof item?.toJSON === "function") {
+      return item.toJSON();
+    }
+    return {
+      id: approvalIdentifier(item),
+      name: item?.name ?? item?.rawItem?.name ?? "tool",
+      arguments: item?.arguments ?? item?.rawItem?.arguments ?? null,
+      raw: item
+    };
+  });
+}
+function buildManifest(settings, resources, environment = collectSandboxEnvironment2(settings), fileResourceDownloads = []) {
+  const entries = {};
+  const downloadsByFileId = new Map(normalizeSandboxFileDownloads(fileResourceDownloads).map((download) => [download.fileId, download]));
+  for (const resource of resources) {
+    if (resource.kind === "repository") {
+      const url = new URL(resource.uri);
+      const host = url.hostname.toLowerCase();
+      const repo = url.pathname.replace(/^\/+|\/+$/g, "").replace(/\.git$/, "");
+      const mountPath = normalizeManifestPath(resource.mountPath ?? `repos/${repo}`);
+      if (repositoryUsesSandboxClone(settings, resource)) {
+        entries[mountPath] = dir();
+        continue;
+      }
+      entries[mountPath] = gitRepo({
+        host,
+        repo,
+        ref: resource.ref,
+        ...resource.subpath ? { subpath: normalizeManifestPath(resource.subpath) } : {}
+      });
+      continue;
+    }
+    if (resource.kind === "file") {
+      const mountPath = normalizeManifestPath(resource.mountPath ?? `files/${resource.fileId}`);
+      const download = downloadsByFileId.get(resource.fileId);
+      entries[mountPath] = download ? sandboxDownloadDirectory(download, mountPath) : objectStorageFileMount(settings, `files/${resource.fileId}/original`);
+    }
+  }
+  return new Manifest({
+    root: "/workspace",
+    entries,
+    environment
+  });
+}
+function sandboxDownloadDirectory(download, mountPath) {
+  if (download.mountPath !== mountPath) {
+    throw new Error(`File download materialization path mismatch for ${download.fileId}: expected ${mountPath}, got ${download.mountPath}`);
+  }
+  assertSafeSandboxFilename(download.filename, download.fileId);
+  if (download.content) {
+    return dir({
+      children: {
+        [download.filename]: file({ content: download.content })
+      }
+    });
+  }
+  return dir();
+}
+function objectStorageFileMount(settings, prefix) {
+  const nativeBucketMount = CAPABILITY_DESCRIPTORS2[settings.sandboxBackend].nativeBucketMount;
+  if (settings.objectStorageBackend === "azure-blob") {
+    if (nativeBucketMount) {
+      throw new Error("Modal sandbox Azure Blob file resources require pre-signed download materialization because the current OpenAI Agents SDK Modal client does not support Azure Blob mount entries.");
+    }
+    const config2 = azureBlobMountConfig(settings);
+    return azureBlobMount({
+      container: config2.container,
+      prefix,
+      accountName: config2.accountName,
+      accountKey: config2.accountKey,
+      endpointUrl: config2.endpointUrl,
+      readOnly: true,
+      mountStrategy: inContainerMountStrategy({ pattern: { type: "rclone", mode: "fuse" } })
+    });
+  }
+  if (settings.objectStorageBackend === "aws-s3" || settings.objectStorageBackend === "gcs") {
+    throw new Error(`${settings.objectStorageBackend} file resources require pre-signed download materialization`);
+  }
+  const config = s3CompatibleMountConfig(settings);
+  return s3Mount({
+    bucket: config.bucket,
+    prefix,
+    endpointUrl: config.endpointUrl,
+    region: config.region,
+    s3Provider: config.s3Provider,
+    accessKeyId: config.accessKeyId,
+    secretAccessKey: config.secretAccessKey,
+    readOnly: true,
+    mountStrategy: nativeBucketMount ? new ModalCloudBucketMountStrategy() : inContainerMountStrategy({ pattern: { type: "rclone", mode: "fuse" } })
+  });
+}
+function s3CompatibleMountConfig(settings) {
+  const endpointUrl = settings.objectStorageSandboxEndpoint ?? settings.objectStorageEndpoint;
+  if (!endpointUrl || !settings.objectStorageAccessKeyId || !settings.objectStorageSecretAccessKey) {
+    throw new Error("File resources require configured S3-compatible object storage");
+  }
+  return {
+    bucket: settings.objectStorageBucket,
+    endpointUrl,
+    region: settings.objectStorageRegion,
+    s3Provider: settings.objectStorageS3Provider,
+    accessKeyId: settings.objectStorageAccessKeyId,
+    secretAccessKey: settings.objectStorageSecretAccessKey
+  };
+}
+function azureBlobMountConfig(settings) {
+  const parsed = settings.objectStorageAzureConnectionString ? parseAzureConnectionString(settings.objectStorageAzureConnectionString) : {};
+  const accountName = settings.objectStorageAzureAccountName ?? parsed.AccountName;
+  const accountKey = settings.objectStorageAzureAccountKey ?? parsed.AccountKey;
+  if (!accountName || !accountKey) {
+    throw new Error("File resources require Azure Blob account name and account key");
+  }
+  const endpointUrl = azureBlobManifestEndpoint(settings.objectStorageAzureEndpoint ?? parsed.BlobEndpoint, accountName);
+  return {
+    container: settings.objectStorageBucket,
+    accountName,
+    accountKey,
+    ...endpointUrl ? { endpointUrl } : {}
+  };
+}
+function azureBlobManifestEndpoint(endpoint, accountName) {
+  if (!endpoint) {
+    return void 0;
+  }
+  const normalized = endpoint.replace(/\/+$/, "");
+  const standardAccountEndpoint = `https://${accountName}.blob.core.windows.net`;
+  return normalized === standardAccountEndpoint ? void 0 : normalized;
+}
+function parseAzureConnectionString(value) {
+  return Object.fromEntries(value.split(";").map((part) => part.trim()).filter(Boolean).map((part) => {
+    const index = part.indexOf("=");
+    return index === -1 ? [part, ""] : [part.slice(0, index), part.slice(index + 1)];
+  }));
+}
+function normalizeManifestPath(path) {
+  const normalized = path.replace(/^\/+|\/+$/g, "");
+  if (!normalized || normalized.includes("..")) {
+    throw new Error(`Invalid sandbox resource path: ${path}`);
+  }
+  return normalized;
+}
+function normalizeSandboxFileDownloads(downloads) {
+  return downloads.map((download) => {
+    const mountPath = normalizeManifestPath(download.mountPath);
+    assertSafeSandboxFilename(download.filename, download.fileId);
+    if (!download.content && !download.url?.trim()) {
+      throw new Error(`File download materialization requires content or a URL for ${download.fileId}`);
+    }
+    return {
+      ...download,
+      mountPath
+    };
+  });
+}
+function assertSafeSandboxFilename(filename, fileId) {
+  if (!filename || filename.includes("/") || filename.includes("\\") || filename === "." || filename === ".." || filename.includes("..")) {
+    throw new Error(`Invalid sandbox file name for ${fileId}: ${filename}`);
+  }
+}
+function sandboxDownloadTargetPath(download) {
+  return posixPath.join("/workspace", download.mountPath, download.filename);
+}
+function sandboxFileDownloadCommand(download, targetPath) {
+  if (!download.url) {
+    throw new Error(`File download materialization URL is empty for ${download.fileId}`);
+  }
+  const targetDir = posixPath.dirname(targetPath);
+  const tmpPath = `${targetPath}.opengeni-download-$$`;
+  return [
+    "set -euo pipefail",
+    `mkdir -p -- ${shellQuote(targetDir)}`,
+    `if [ ! -f ${shellQuote(targetPath)} ]; then`,
+    `  tmp=${shellQuote(tmpPath)}`,
+    '  cleanup() { rm -f -- "$tmp"; }',
+    "  trap cleanup EXIT",
+    `  curl --fail --location --silent --show-error --retry 3 --retry-delay 1 --output "$tmp" ${shellQuote(download.url)}`,
+    `  mv -- "$tmp" ${shellQuote(targetPath)}`,
+    "  trap - EXIT",
+    "fi",
+    `chmod a-w -- ${shellQuote(targetPath)} 2>/dev/null || true`
+  ].join("\n");
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+async function restoredSandboxSessionState(state, client) {
+  if (!client) {
+    return void 0;
+  }
+  const sandboxState = state._sandbox;
+  const entry = sandboxState?.sessionsByAgent?.[sandboxState.currentAgentKey] ?? (sandboxState?.currentAgentKey && sandboxState?.sessionState ? {
+    backendId: sandboxState.backendId,
+    currentAgentKey: sandboxState.currentAgentKey,
+    currentAgentName: sandboxState.currentAgentName,
+    sessionState: sandboxState.sessionState
+  } : void 0);
+  if (!entry) {
+    return void 0;
+  }
+  if (client.backendId !== entry.backendId) {
+    throw new Error("RunState sandbox backend does not match the configured sandbox client");
+  }
+  return await deserializeSandboxSessionStateEnvelope(client, entry.sessionState);
+}
+var builtInSandboxLifecycleHooks = {
+  "azure-cli-login": {
+    id: "azure-cli-login",
+    phase: "beforeAgentStart",
+    shouldRun: ({ environment }) => hasAzureServicePrincipal(environment),
+    run: runAzureCliLoginHook
+  }
+};
+function sandboxLifecycleHooksForIds(ids) {
+  return ids.map((id) => {
+    const hook = builtInSandboxLifecycleHooks[id];
+    if (!hook) {
+      throw new Error(`Unknown sandbox lifecycle hook ${id}`);
+    }
+    return hook;
+  });
+}
+function applicableBeforeAgentStartHooks(hooks, context) {
+  return hooks.filter((hook) => hook.phase === "beforeAgentStart" && (hook.shouldRun?.(context) ?? true));
+}
+async function runBeforeAgentStartHooks(session, hooks, context) {
+  for (const hook of applicableBeforeAgentStartHooks(hooks, context)) {
+    await hook.run(session, context);
+  }
+}
+function withSandboxLifecycleHooks(client, hooks, context) {
+  const beforeAgentStartHooks = applicableBeforeAgentStartHooks(hooks, context);
+  if (beforeAgentStartHooks.length === 0) {
+    return client;
+  }
+  const seen = /* @__PURE__ */ new WeakSet();
+  const wrapSession = async (session) => {
+    if (typeof session === "object" && session !== null && !seen.has(session)) {
+      for (const hook of beforeAgentStartHooks) {
+        await hook.run(session, context);
+      }
+      seen.add(session);
+    }
+    return session;
+  };
+  const wrapped = {
+    backendId: client.backendId,
+    ...client.supportsDefaultOptions !== void 0 ? { supportsDefaultOptions: client.supportsDefaultOptions } : {},
+    ...client.create ? { create: async (...args) => await wrapSession(await client.create(...args)) } : {},
+    ...client.resume ? { resume: async (state) => await wrapSession(await client.resume(state)) } : {},
+    ...client.delete ? { delete: async (state) => await client.delete(state) } : {},
+    ...client.serializeSessionState ? { serializeSessionState: async (state, options) => await client.serializeSessionState(state, options) } : {},
+    ...client.canPersistOwnedSessionState ? { canPersistOwnedSessionState: async (state) => await client.canPersistOwnedSessionState(state) } : {},
+    ...client.canReusePreservedOwnedSession ? { canReusePreservedOwnedSession: async (state) => await client.canReusePreservedOwnedSession(state) } : {},
+    ...client.deserializeSessionState ? { deserializeSessionState: async (state) => await client.deserializeSessionState(state) } : {}
+  };
+  return wrapped;
+}
+function sandboxRepositoryCloneHooksForAgent(agent) {
+  return agentRepositoryCloneHooks.get(agent) ?? [];
+}
+function gitTokenSeedForAgent(agent) {
+  return agentGitTokenSeed.get(agent);
+}
+function sandboxRepositoryCloneHooks(settings, resources, activeSandboxBackend = settings.sandboxBackend) {
+  const repositories = resources.filter((resource) => resource.kind === "repository" && repositoryUsesSandboxClone(settings, resource, activeSandboxBackend));
+  if (repositories.length === 0) {
+    return [];
+  }
+  return [{
+    id: "repository-clone",
+    phase: "beforeAgentStart",
+    run: async (session, context) => {
+      await runRepositoryCloneHook(session, repositories, context);
+    }
+  }];
+}
+function repositoryUsesSandboxClone(settings, resource, activeSandboxBackend = settings.sandboxBackend) {
+  if (activeSandboxBackend === "selfhosted") {
+    return false;
+  }
+  return settings.sandboxBackend === "modal" || Boolean(resource.githubInstallationId && resource.githubRepositoryId);
+}
+function repositoryCloneCommand(resources) {
+  const commands = [
+    "set -eu",
+    'export HOME="${HOME:-/workspace}"',
+    'export GIT_TERMINAL_PROMPT="${GIT_TERMINAL_PROMPT:-0}"',
+    // TOKEN-BROKER (B1/B2): seed the run-scoped GitHub token into the STABLE token FILE
+    // AND provision the git-askpass helper into the box AT SETUP (runtime) BEFORE any
+    // clone runs, so GIT_ASKPASS points at a per-box, user-writable script that reads
+    // that file for the fetch below. Provisioning the askpass here (rather than relying
+    // on a baked image script at /usr/local/bin/opengeni-git-askpass) removes the
+    // image-rebuild rollout gate: the askpass is correct on ANY box image, including
+    // pre-existing warm boxes on their next turn's clone hook, and no product image has
+    // to carry it. The seed rides the per-exec env (OPENGENI_GIT_TOKEN_SEED) — NEVER the
+    // box/agent manifest (validateNoEnvironmentDelta must not see a rotating value), so
+    // this whole block is a no-op when the seed is absent (e.g. the selfhosted path,
+    // which uses its own git creds). The token file lives at $OPENGENI_GIT_TOKEN_FILE
+    // (stable, from the shared base) with a $HOME/.opengeni/git-token fallback.
+    // $GIT_ASKPASS is on the box manifest env (set by
+    // sandboxEnvironmentForRun to $HOME/.opengeni/askpass), so it is available to this
+    // exec; the askpass script we write is byte-identical to docker/opengeni-git-askpass
+    // and is written via a QUOTED heredoc (<<'ASKPASS_EOF') so NOTHING inside it expands
+    // ($1, $HOME, ${OPENGENI_GIT_TOKEN_FILE:-...}, and the literal \n in printf all land
+    // verbatim), then chmod 0755 so git can exec it.
+    //
+    // ATOMIC REWRITE: this block now re-runs at the start of EVERY turn on a warm box
+    // that other turn holders may be actively using — an in-flight `git fetch` from a
+    // concurrent turn can invoke the askpass (which cats the token file) at any moment.
+    // Both files are therefore written to a pid-suffixed temp under umask 077 and
+    // renamed into place: rename is atomic, concurrent readers keep the old inode, and
+    // the token is never observable world-readable (no post-hoc chmod window).
+    'if [ -n "${OPENGENI_GIT_TOKEN_SEED:-}" ]; then',
+    '  seed_umask="$(umask)"',
+    "  umask 077",
+    '  git_token_file="${OPENGENI_GIT_TOKEN_FILE:-$HOME/.opengeni/git-token}"',
+    '  mkdir -p "$(dirname "$git_token_file")"',
+    `  printf '%s' "$OPENGENI_GIT_TOKEN_SEED" > "$git_token_file.tmp.$$"`,
+    '  mv -f "$git_token_file.tmp.$$" "$git_token_file"',
+    '  git_askpass="${GIT_ASKPASS:-$HOME/.opengeni/askpass}"',
+    '  mkdir -p "$(dirname "$git_askpass")"',
+    `  cat > "$git_askpass.tmp.$$" <<'ASKPASS_EOF'`,
+    "#!/usr/bin/env sh",
+    'case "$1" in',
+    `  *Username*) printf '%s\\n' "x-access-token" ;;`,
+    `  *Password*) cat "\${OPENGENI_GIT_TOKEN_FILE:-$HOME/.opengeni/git-token}" 2>/dev/null || printf '\\n' ;;`,
+    "  *) printf '\\n' ;;",
+    "esac",
+    "ASKPASS_EOF",
+    '  chmod 0755 "$git_askpass.tmp.$$"',
+    '  mv -f "$git_askpass.tmp.$$" "$git_askpass"',
+    '  umask "$seed_umask"',
+    "fi",
+    "ensure_git() {",
+    "  if command -v git >/dev/null 2>&1; then",
+    "    return 0",
+    "  fi",
+    "  if command -v apt-get >/dev/null 2>&1; then",
+    "    export DEBIAN_FRONTEND=noninteractive",
+    "    apt-get update >/dev/null",
+    "    apt-get install -y --no-install-recommends ca-certificates git >/dev/null",
+    "    rm -rf /var/lib/apt/lists/*",
+    "    command -v git >/dev/null 2>&1 && return 0",
+    "  fi",
+    '  echo "git is not installed in the sandbox and could not be bootstrapped" >&2',
+    "  exit 127",
+    "}",
+    "ensure_git",
+    "clone_repository() {",
+    '  target="$1"',
+    '  uri="$2"',
+    '  ref="$3"',
+    '  subpath="$4"',
+    '  if [ -e "$target" ] && { [ -f "$target" ] || [ -n "$(find "$target" -mindepth 1 -maxdepth 1 -print -quit 2>/dev/null)" ]; }; then',
+    // This hook re-runs every turn on a long-lived box, so \"non-empty\" alone is not
+    // proof of a completed materialization: an interrupted clone (worker crash /
+    // lifecycle timeout mid-mv/cp) leaves a partial tree that would otherwise pass
+    // this check forever. A full-repo target must actually BE a work tree to be
+    // skipped; a partial one is wiped and rebuilt (nothing legitimate writes under
+    // the mount path before the repo exists). Subpath extracts are not git repos —
+    // for those the plain non-empty check stands (no stronger signal available).
+    '    if [ -n "$subpath" ] || git -C "$target" rev-parse --is-inside-work-tree >/dev/null 2>&1; then',
+    '      echo "Repository resource already present at $target"',
+    "      return 0",
+    "    fi",
+    '    echo "Re-materializing partial repository resource at $target" >&2',
+    '    find "$target" -mindepth 1 -maxdepth 1 -exec rm -rf {} +',
+    "  fi",
+    '  mkdir -p "$(dirname "$target")"',
+    '  tmp="${target}.tmp.$$"',
+    '  rm -rf "$tmp"',
+    // Fetch failures must not leak the pid-suffixed tmp clone beside the mount
+    // (set -eu would exit before any cleanup).
+    '  if ! { git init "$tmp" >/dev/null && git -C "$tmp" remote add origin "$uri" && git -C "$tmp" fetch --depth 1 --no-tags --filter=blob:none origin "$ref" && git -C "$tmp" checkout --detach FETCH_HEAD >/dev/null; }; then',
+    '    rm -rf "$tmp"',
+    '    echo "Repository resource fetch failed for $target" >&2',
+    "    exit 1",
+    "  fi",
+    '  if [ -n "$subpath" ]; then',
+    '    if [ ! -e "$tmp/$subpath" ]; then',
+    '      echo "Repository subpath not found: $subpath" >&2',
+    '      rm -rf "$tmp"',
+    "      exit 1",
+    "    fi",
+    '    if [ -d "$tmp/$subpath" ]; then',
+    '      mkdir -p "$target"',
+    '      cp -a "$tmp/$subpath/." "$target/"',
+    "    else",
+    '      rmdir "$target" 2>/dev/null || true',
+    '      cp -a "$tmp/$subpath" "$target"',
+    "    fi",
+    '    rm -rf "$tmp"',
+    "  else",
+    '    rmdir "$target" 2>/dev/null || true',
+    // Two concurrent turn holders can race this install: without the existence
+    // re-check the loser's un-flagged `mv` would nest its tmp clone INSIDE the
+    // winner's tree as <name>.tmp.<pid>. If the winner produced a valid work tree,
+    // accept it; a non-empty non-repo survivor here is a mount point the manifest
+    // re-filled — install into it by content copy instead of rename.
+    '    if [ -e "$target" ]; then',
+    '      if git -C "$target" rev-parse --is-inside-work-tree >/dev/null 2>&1; then',
+    '        rm -rf "$tmp"',
+    '        echo "Repository resource already present at $target"',
+    "        return 0",
+    "      fi",
+    '      cp -a "$tmp/." "$target/"',
+    '      rm -rf "$tmp"',
+    "    else",
+    '      mv "$tmp" "$target"',
+    "    fi",
+    '    git -C "$target" rev-parse --is-inside-work-tree >/dev/null',
+    "  fi",
+    '  if [ ! -e "$target" ]; then',
+    '    echo "Repository resource was not materialized at $target" >&2',
+    "    exit 1",
+    "  fi",
+    '  echo "Repository resource ready at $target"',
+    "}"
+  ];
+  for (const resource of resources) {
+    const url = new URL(resource.uri);
+    const repo = url.pathname.replace(/^\/+|\/+$/g, "").replace(/\.git$/, "");
+    const mountPath = normalizeManifestPath(resource.mountPath ?? `repos/${repo}`);
+    commands.push([
+      "clone_repository",
+      shellQuote(posixPath.join("/workspace", mountPath)),
+      shellQuote(resource.uri),
+      shellQuote(resource.ref),
+      shellQuote(resource.subpath ? normalizeManifestPath(resource.subpath) : "")
+    ].join(" "));
+  }
+  return commands.join("\n");
+}
+async function runRepositoryCloneHook(session, resources, context = { environment: {} }) {
+  const payload = { name: "repository-clone", repositoryCount: resources.length };
+  await context.onRuntimeEvent?.({ type: "sandbox.operation.started", payload });
+  try {
+    const command = context.gitTokenSeed ? `export OPENGENI_GIT_TOKEN_SEED=${shellQuote(context.gitTokenSeed)}
+${repositoryCloneCommand(resources)}` : repositoryCloneCommand(resources);
+    if (session.exec) {
+      const result = await session.exec({
+        cmd: command,
+        workdir: "/workspace",
+        ...context.runAs ? { runAs: context.runAs } : {},
+        yieldTimeMs: SANDBOX_LIFECYCLE_COMMAND_TIMEOUT_MS,
+        maxOutputTokens: 2e4
+      });
+      assertSandboxCommandSucceeded(result, "Repository clone hook");
+    } else if (session.execCommand) {
+      const result = await session.execCommand({
+        cmd: command,
+        workdir: "/workspace",
+        ...context.runAs ? { runAs: context.runAs } : {},
+        yieldTimeMs: SANDBOX_LIFECYCLE_COMMAND_TIMEOUT_MS,
+        maxOutputTokens: 2e4
+      });
+      assertSandboxCommandSucceeded(result, "Repository clone hook");
+    } else {
+      throw new Error("Sandbox session does not support command execution");
+    }
+    await context.onRuntimeEvent?.({ type: "sandbox.operation.completed", payload });
+  } catch (error) {
+    await context.onRuntimeEvent?.({
+      type: "sandbox.operation.failed",
+      payload: {
+        ...payload,
+        error: error instanceof Error ? error.message : String(error)
+      }
+    });
+    throw error;
+  }
+}
+function azureCliLoginCommand() {
+  return [
+    'export HOME="${HOME:-/workspace}"',
+    'mkdir -p "$HOME/.azure"',
+    'CLIENT_ID="${AZURE_CLIENT_ID:-${ARM_CLIENT_ID:-}}"',
+    'CLIENT_SECRET="${AZURE_CLIENT_SECRET:-${ARM_CLIENT_SECRET:-}}"',
+    'TENANT_ID="${AZURE_TENANT_ID:-${ARM_TENANT_ID:-}}"',
+    'SUBSCRIPTION_ID="${AZURE_SUBSCRIPTION_ID:-${ARM_SUBSCRIPTION_ID:-}}"',
+    'if [ -n "$CLIENT_ID" ] && [ -n "$CLIENT_SECRET" ] && [ -n "$TENANT_ID" ]; then',
+    '  command -v az >/dev/null 2>&1 || { echo "Azure CLI is not installed in the sandbox" >&2; exit 127; }',
+    '  az account show --only-show-errors >/dev/null 2>&1 || az login --service-principal --username "$CLIENT_ID" --password "$CLIENT_SECRET" --tenant "$TENANT_ID" --allow-no-subscriptions --only-show-errors --output none',
+    // if/fi, NOT `[ -n ] && az`: this line ends the credentialed if-body, so with a
+    // no-subscription SP (an explicitly supported config — the login above passes
+    // --allow-no-subscriptions) the bare `[ -n ]` would exit the whole script 1 and
+    // fail the turn.
+    '  if [ -n "$SUBSCRIPTION_ID" ]; then az account set --subscription "$SUBSCRIPTION_ID" --only-show-errors; fi',
+    "fi"
+  ].join("\n");
+}
+function sandboxCommandExitCode(result) {
+  if (typeof result === "string") {
+    const match = result.match(/Process exited with code (-?\d+)/);
+    return match ? Number(match[1]) : null;
+  }
+  if (!result || typeof result !== "object") {
+    return null;
+  }
+  const candidate = result;
+  for (const value of [candidate.exitCode, candidate.exit_code, candidate.code, candidate.status]) {
+    if (typeof value === "number") {
+      return value;
+    }
+  }
+  return null;
+}
+function sandboxCommandOutput(result) {
+  if (!result || typeof result !== "object") {
+    return "";
+  }
+  const candidate = result;
+  return [candidate.output, candidate.stderr, candidate.stdout].filter((value) => typeof value === "string" && value.length > 0).join("\n");
+}
+function assertSandboxCommandSucceeded(result, operation) {
+  const output = sandboxCommandOutput(result);
+  if (sandboxCommandStillRunning(result)) {
+    throw new Error(`${operation} did not finish before the lifecycle command timeout${output ? `:
+${output}` : ""}`);
+  }
+  const exitCode = sandboxCommandExitCode(result);
+  if (exitCode !== null && exitCode !== 0) {
+    throw new Error(output || `${operation} failed with exit code ${exitCode}`);
+  }
+  if (exitCode === null) {
+    throw new Error(output || `${operation} did not return a command exit code`);
+  }
+}
+function sandboxCommandStillRunning(result) {
+  if (typeof result === "string") {
+    return /Process running with session ID \d+/u.test(result);
+  }
+  if (!result || typeof result !== "object") {
+    return false;
+  }
+  const candidate = result;
+  return typeof candidate.sessionId === "number" || typeof candidate.session_id === "number";
+}
+function hasAzureServicePrincipal(environment) {
+  const clientId = environment.AZURE_CLIENT_ID || environment.ARM_CLIENT_ID;
+  const clientSecret = environment.AZURE_CLIENT_SECRET || environment.ARM_CLIENT_SECRET;
+  const tenantId = environment.AZURE_TENANT_ID || environment.ARM_TENANT_ID;
+  return Boolean(clientId && clientSecret && tenantId);
+}
+async function runAzureCliLoginHook(session, context = { environment: {} }) {
+  const payload = { name: "azure-cli-login", command: "az login --service-principal" };
+  await context.onRuntimeEvent?.({ type: "sandbox.operation.started", payload });
+  try {
+    if (session.exec) {
+      const result = await session.exec({
+        cmd: azureCliLoginCommand(),
+        workdir: "/workspace",
+        ...context.runAs ? { runAs: context.runAs } : {},
+        yieldTimeMs: SANDBOX_LIFECYCLE_COMMAND_TIMEOUT_MS,
+        maxOutputTokens: 2e4
+      });
+      assertSandboxCommandSucceeded(result, "Azure CLI login hook");
+    } else if (session.execCommand) {
+      const result = await session.execCommand({
+        cmd: azureCliLoginCommand(),
+        workdir: "/workspace",
+        ...context.runAs ? { runAs: context.runAs } : {},
+        yieldTimeMs: SANDBOX_LIFECYCLE_COMMAND_TIMEOUT_MS,
+        maxOutputTokens: 2e4
+      });
+      assertSandboxCommandSucceeded(result, "Azure CLI login hook");
+    } else {
+      throw new Error("Sandbox session does not support command execution");
+    }
+    await context.onRuntimeEvent?.({ type: "sandbox.operation.completed", payload });
+  } catch (error) {
+    await context.onRuntimeEvent?.({
+      type: "sandbox.operation.failed",
+      payload: {
+        ...payload,
+        error: error instanceof Error ? error.message : String(error)
+      }
+    });
+    throw error;
+  }
+}
+function azureDeploymentBaseUrl(settings) {
+  const endpoint = settings.azureOpenaiEndpoint?.replace(/\/+$/, "");
+  if (!endpoint || !settings.azureOpenaiDeployment) {
+    throw new Error("Azure OpenAI endpoint/deployment settings are incomplete");
+  }
+  return `${endpoint}/openai/deployments/${settings.azureOpenaiDeployment}`;
+}
+function azureOpenAIDefaultQuery(settings, baseURL) {
+  if (!settings.azureOpenaiApiVersion) return void 0;
+  const normalized = baseURL.replace(/\/+$/, "").toLowerCase();
+  if (normalized.endsWith("/openai/v1")) {
+    return void 0;
+  }
+  return { "api-version": settings.azureOpenaiApiVersion };
+}
+var stagedBundledSkillsDir = null;
+function bundledSkillsDir() {
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  const packaged = [
+    join(moduleDir, "bundled_hashicorp_terraform_skills"),
+    join(moduleDir, "..", "src", "bundled_hashicorp_terraform_skills")
+  ].find((candidate) => existsSync(candidate)) ?? join(moduleDir, "bundled_hashicorp_terraform_skills");
+  if (isPathWithin(process.cwd(), packaged)) {
+    return packaged;
+  }
+  if (!stagedBundledSkillsDir) {
+    stagedBundledSkillsDir = stageBundledSkills(packaged, join(process.cwd(), ".opengeni", "bundled_hashicorp_terraform_skills"));
+  }
+  return stagedBundledSkillsDir;
+}
+function stageBundledSkills(packaged, target) {
+  const tmp = `${target}.tmp-${process.pid}`;
+  rmSync(tmp, { recursive: true, force: true });
+  mkdirSync(dirname(tmp), { recursive: true });
+  cpSync(packaged, tmp, { recursive: true });
+  rmSync(target, { recursive: true, force: true });
+  try {
+    renameSync(tmp, target);
+  } catch (error) {
+    rmSync(tmp, { recursive: true, force: true });
+    if (!existsSync(target)) {
+      throw error;
+    }
+  }
+  return target;
+}
+function isPathWithin(root, candidate) {
+  const relativePath = relative(root, candidate);
+  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute(relativePath);
+}
+function lazySkillSourceWithPackSkills(packSkills) {
+  const bundledDir = bundledSkillsDir();
+  const bundled = localDirLazySkillSource({ src: bundledDir });
+  if (packSkills.length === 0) {
+    return bundled;
+  }
+  const children = {};
+  for (const name of bundledSkillDirNames(bundledDir)) {
+    children[name] = localDir({ src: join(bundledDir, name) });
+  }
+  const packIndex = [];
+  const packNames = /* @__PURE__ */ new Set();
+  const packNameKeys = /* @__PURE__ */ new Set();
+  for (const skill of packSkills) {
+    assertSafePackSkillName(skill.name);
+    if (packNameKeys.has(skill.name.toLowerCase())) {
+      throw new Error(`Duplicate pack skill name: ${skill.name}`);
+    }
+    packNameKeys.add(skill.name.toLowerCase());
+    packNames.add(skill.name);
+    children[skill.name] = packSkillDirEntry(skill);
+    packIndex.push({ name: skill.name, description: packSkillDescription(skill), path: skill.name });
+  }
+  return {
+    source: dir({ children }),
+    getIndex: (manifest, skillsPath) => [
+      ...(bundled.getIndex?.(manifest, skillsPath) ?? []).filter((entry) => !packNames.has(entry.path ?? entry.name)),
+      ...packIndex
+    ]
+  };
+}
+function bundledSkillDirNames(root) {
+  return readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && existsSync(join(root, entry.name, "SKILL.md"))).map((entry) => entry.name).sort();
+}
+function packSkillDirEntry(skill) {
+  const root = { dirs: /* @__PURE__ */ new Map(), files: /* @__PURE__ */ new Map() };
+  for (const skillFile of skill.files) {
+    const segments = packSkillPathSegments(skill.name, skillFile.path);
+    let node = root;
+    for (const segment of segments.slice(0, -1)) {
+      if (node.files.has(segment)) {
+        throw new Error(`Pack skill ${skill.name} uses ${segment} as both a file and a directory`);
+      }
+      let next = node.dirs.get(segment);
+      if (!next) {
+        next = { dirs: /* @__PURE__ */ new Map(), files: /* @__PURE__ */ new Map() };
+        node.dirs.set(segment, next);
+      }
+      node = next;
+    }
+    const filename = segments[segments.length - 1];
+    if (node.dirs.has(filename) || node.files.has(filename)) {
+      throw new Error(`Duplicate pack skill file path in ${skill.name}: ${skillFile.path}`);
+    }
+    node.files.set(filename, skillFile.content);
+  }
+  if (!root.files.has("SKILL.md")) {
+    throw new Error(`Pack skill ${skill.name} is missing a top-level SKILL.md file`);
+  }
+  return packSkillDirFromNode(root);
+}
+function packSkillDirFromNode(node) {
+  const children = {};
+  for (const [name, child] of node.dirs) {
+    children[name] = packSkillDirFromNode(child);
+  }
+  for (const [name, content] of node.files) {
+    children[name] = file({ content });
+  }
+  return dir({ children });
+}
+function assertSafePackSkillName(name) {
+  if (packSkillPathSegments(name, name).length !== 1) {
+    throw new Error(`Invalid pack skill name: ${name}`);
+  }
+}
+function packSkillPathSegments(skillName, path) {
+  const segments = path.split("/");
+  if (path.startsWith("/") || path.includes("\\") || segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
+    throw new Error(`Invalid pack skill file path for ${skillName}: ${path}`);
+  }
+  return segments;
+}
+function packSkillDescription(skill) {
+  const explicit = skill.description?.trim();
+  if (explicit) {
+    return explicit;
+  }
+  const markdown = skill.files.find((skillFile) => skillFile.path === "SKILL.md")?.content ?? "";
+  return skillFrontmatterDescription(markdown) ?? "No description provided.";
+}
+function skillFrontmatterDescription(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") {
+    return null;
+  }
+  const end = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+  if (end === -1) {
+    return null;
+  }
+  const collected = [];
+  let inDescription = false;
+  for (const line of lines.slice(1, end)) {
+    const match = line.match(/^description:\s*(.*)$/);
+    if (match) {
+      const inline = match[1].trim();
+      if (inline && inline !== ">-" && inline !== ">" && inline !== "|" && inline !== "|-") {
+        return unquoteFrontmatterValue(inline);
+      }
+      inDescription = true;
+      continue;
+    }
+    if (inDescription) {
+      if (/^\s+\S/.test(line)) {
+        collected.push(line.trim());
+        continue;
+      }
+      break;
+    }
+  }
+  const blockValue = collected.join(" ").trim();
+  return blockValue ? blockValue : null;
+}
+function unquoteFrontmatterValue(value) {
+  if (value.length >= 2 && value[0] === value[value.length - 1] && (value[0] === '"' || value[0] === "'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function isAsyncIterable(source) {
+  return typeof source[Symbol.asyncIterator] === "function";
+}
+function stableJson(value) {
+  return JSON.stringify(sortJson(value));
+}
+function sortJson(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortJson);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, nested]) => [key, sortJson(nested)]));
+  }
+  return value;
+}
+function approvalIdentifier(item) {
+  return String(item?.rawItem?.callId ?? item?.rawItem?.id ?? item?.id ?? item?.name ?? "approval");
+}
+export {
+  ActiveBackendUnresolvableError,
+  CAPABILITY_DESCRIPTORS,
+  COMPACTION_SUMMARY_MARKER,
+  ChannelAConflictError,
+  ChannelANotFoundError,
+  ChannelAUnsupportedError,
+  ChannelAValidationError,
+  CodexSubscriptionUnavailableError,
+  ComputerActionError,
+  ComputerReadOnlyError,
+  ComputerUnavailableError,
+  ComputerUseCapability,
+  DEFAULT_DESKTOP_GEOMETRY,
+  DESKTOP_STREAM_PORT,
+  DISPLAY_STACK_TIMEOUT_MS,
+  DisplayStackError,
+  DisplayStackUnsupportedError,
+  GENESIS_TITLE_DIRECTIVE,
+  MaxTurnsExceededError2 as MaxTurnsExceededError,
+  MockAgentResponder,
+  MultiProviderModelProvider,
+  NatsControlRpc,
+  OpenAIChatCompletionsModel2 as OpenAIChatCompletionsModel,
+  OpenAIResponsesModel2 as OpenAIResponsesModel,
+  PROVIDER_REGISTRY,
+  RecordingError,
+  RecordingUnavailableError,
+  RoutingSandboxSession,
+  RoutingUnsupportedError,
+  SELFHOSTED_DEFAULT_TIMEOUT_MS,
+  SELFHOSTED_RECONNECT_WINDOW_MS,
+  SELFHOSTED_RELAY_STREAM_PATH,
+  STREAM_PORT,
+  STREAM_TOKEN_DEFAULT_TTL_SECONDS,
+  SUMMARY_INSTRUCTIONS,
+  SUMMARY_PREFIX,
+  SandboxChannelAService,
+  SandboxComputer,
+  SandboxConfigError,
+  SandboxProviderUnavailableError,
+  SelfhostedControlError,
+  SelfhostedSandboxClient,
+  SelfhostedSession,
+  StreamPortUnavailableError,
+  StreamTokenPayload,
+  TERMINAL_SERVER_TIMEOUT_MS,
+  TERMINAL_STREAM_PORT,
+  TerminalServerError,
+  TerminalServerUnsupportedError,
+  agentErrorToControlError,
+  agentsErrorRunState,
+  applyMissingManifestEntries,
+  assertDescriptorRegistryInvariants,
+  assertProviderRegistryInvariants,
+  assertSafeRelPath,
+  azureCliLoginCommand,
+  azureOpenAIDefaultQuery,
+  backendSupportsOs,
+  buildAgentCapabilities,
+  buildCompactionMessages,
+  buildDisplayStackScript,
+  buildManifest,
+  buildModelInstance,
+  buildOpenAIClientFromSettings,
+  buildOpenGeniAgent,
+  buildProviderClient,
+  buildSelfhostedBackendSession,
+  buildStreamUrl,
+  buildSummaryItem,
+  buildTerminalServerScript,
+  callModelInputFilterForSettings,
+  collectSandboxEnvironment,
+  compactionSummaryText,
+  composeAgentInstructions,
+  computerUse,
+  configureOpenAI,
+  contentTypeForCodec,
+  coreInstructions,
+  createProductionAgentRuntime,
+  createSandboxClient,
+  createSandboxClientForBackend,
+  decodeModalSnapshotId,
+  deletePriorPersistedSnapshot,
+  deleteRecordingArtifacts,
+  deserializeSandboxSessionStateEnvelope,
+  desktopCapableBackend,
+  enforceInputBudget,
+  ensureDisplayStack,
+  ensureReadableStreamFrom,
+  ensureTerminalServer,
+  establishSandboxSessionFromEnvelope,
+  estimateItemTokens,
+  estimateTokens,
+  exposeStreamPort,
+  extForCodec,
+  extractResponseOutputText,
+  findKeepBoundary,
+  isCompactionSummary,
+  isExecSessionLostBanner,
+  isProviderSandboxNotFoundError,
+  isSelfhostedProviderNotFoundError,
+  isUserMessage,
+  isWorkspaceEscapeError,
+  lazySkillSourceWithPackSkills,
+  makeActiveBackendResolver,
+  materializeSandboxFileDownloads,
+  maxTurnsExceededRunState,
+  mintStreamToken,
+  modelResponseUsageFromSdkEvent,
+  negotiateCapabilities,
+  negotiateSelfhostedCapabilities,
+  neutralizeToolSearchItemsInSerializedRunState,
+  normalizeComputerCallsFilter,
+  normalizeSdkEvent,
+  normalizeToolOutputForEvent,
+  offlineAgentError,
+  offlineControlResponse,
+  parseExecBannerSessionId,
+  parseExposedPorts,
+  parseNumstatZ,
+  parsePorcelainV2,
+  parseUnifiedPatch,
+  planCompaction,
+  prefixedMcpToolName,
+  prepareAgentTools,
+  prepareRunInput,
+  readRecordingBytes,
+  readWorkspaceArchiveFromEnvelopeSessionState,
+  recordingStorageKey,
+  renderPrefixTranscript,
+  repositoryCloneCommand,
+  repositoryUsesSandboxClone,
+  resolveTurnModel,
+  restoredSandboxSessionStateFromEntry,
+  runAgentStream,
+  runAzureCliLoginHook,
+  runBeforeAgentStartHooks,
+  runRepositoryCloneHook,
+  sandboxCommandExitCode,
+  sandboxCommandOutput,
+  sandboxCommandStillRunning,
+  sandboxFileDownloadsForAgent,
+  sandboxLifecycleHooksForIds,
+  sandboxRunAs,
+  sandboxStateEntryFromRunState,
+  sanitizeHistoryItemsForModel,
+  selectBackend,
+  selfhostedLiveness,
+  serializeApprovals,
+  serializeEstablishedSandboxEnvelope,
+  setSelfhostedApplyDiff,
+  startRecording,
+  stopRecording,
+  stripExecBanner,
+  stripProviderItemIdsFilter,
+  stripReasoningEncryptedContent,
+  stripReasoningIdentityFromSerializedRunState,
+  subjectFor,
+  summarizeForCompaction,
+  tearDownDisplayStack,
+  tearDownTerminalServer,
+  timeoutAgentError,
+  timeoutControlResponse,
+  verifyStreamToken,
+  withManifestRefreshOnResume,
+  withSandboxFileDownloads,
+  withSandboxLifecycleHooks,
+  workspaceEnvironmentInstructions
+};
+//# sourceMappingURL=index.js.map