@opengeni/runtime 0.7.1 → 0.11.0

package/dist/chunk-4YJ5Z52Z.js

@@ -0,0 +1,1789 @@
+import {
+  Manifest,
+  SandboxMountError,
+  SandboxPathResolutionError,
+  SandboxUnsupportedFeatureError,
+  UserError,
+  WorkspacePathPolicy,
+  addTraceProcessor,
+  cloneManifest,
+  defaultProcessor,
+  getLogger,
+  isMount,
+  isRecord,
+  logger,
+  mergeManifestDelta,
+  mergeManifestEntryDelta,
+  mergeMaterializedEnvironment,
+  normalizePosixPath,
+  normalizeRelativePath,
+  randomUUID,
+  relativePosixPathWithinRoot,
+  shellQuote
+} from "./chunk-K4V4QYCL.js";
+
+// ../../node_modules/.bun/@openai+agents-core@0.13.3+bd37e07cd49ea605/node_modules/@openai/agents-core/dist/mcpServers.mjs
+var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
+var DEFAULT_CLOSE_TIMEOUT_MS = 1e4;
+var logger2 = getLogger("openai-agents:mcp-servers");
+var ServerWorker = class {
+  server;
+  connectTimeoutMs;
+  closeTimeoutMs;
+  queue = [];
+  draining = false;
+  done = false;
+  closing = null;
+  closeResult = null;
+  constructor(server, connectTimeoutMs, closeTimeoutMs) {
+    this.server = server;
+    this.connectTimeoutMs = connectTimeoutMs;
+    this.closeTimeoutMs = closeTimeoutMs;
+  }
+  get isDone() {
+    return this.done;
+  }
+  connect() {
+    return this.submit("connect", this.connectTimeoutMs);
+  }
+  close() {
+    return this.submit("close", this.closeTimeoutMs);
+  }
+  submit(action, timeoutMs) {
+    if (this.done) {
+      return Promise.reject(createClosedError(this.server));
+    }
+    if (this.closeResult || this.closing) {
+      if (action === "close" && this.closeResult) {
+        return this.closeResult;
+      }
+      return Promise.reject(createClosingError(this.server));
+    }
+    let resolveCommand;
+    let rejectCommand;
+    const promise = new Promise((resolve2, reject) => {
+      resolveCommand = resolve2;
+      rejectCommand = reject;
+    });
+    const command = {
+      action,
+      timeoutMs,
+      resolve: resolveCommand,
+      reject: rejectCommand
+    };
+    if (action === "close") {
+      this.closeResult = promise;
+    }
+    this.queue.push(command);
+    void this.drain();
+    return promise;
+  }
+  async drain() {
+    if (this.draining) {
+      return;
+    }
+    this.draining = true;
+    while (this.queue.length > 0) {
+      const command = this.queue.shift();
+      if (!command) {
+        continue;
+      }
+      const shouldExit = command.action === "close";
+      let closeError = null;
+      try {
+        if (command.action === "connect") {
+          await runWithTimeout(() => this.server.connect(), command.timeoutMs, createTimeoutError("connect", this.server, command.timeoutMs));
+        } else {
+          const closeTask = this.server.close();
+          this.closing = closeTask.then(() => void 0, () => void 0).finally(() => {
+            this.closing = null;
+          });
+          await runWithTimeoutTask(closeTask, command.timeoutMs, createTimeoutError("close", this.server, command.timeoutMs));
+        }
+        command.resolve();
+      } catch (error) {
+        const err = toError(error);
+        command.reject(err);
+        if (shouldExit) {
+          closeError = err;
+        }
+      }
+      if (shouldExit) {
+        const pendingError = closeError ?? createClosedError(this.server);
+        while (this.queue.length > 0) {
+          const pending = this.queue.shift();
+          if (pending) {
+            pending.reject(pendingError);
+          }
+        }
+        this.closeResult = null;
+        if (!closeError) {
+          this.done = true;
+        }
+        break;
+      }
+    }
+    this.draining = false;
+  }
+};
+var MCPServers = class _MCPServers {
+  allServers;
+  activeServers;
+  failedServers = [];
+  failedServerSet = /* @__PURE__ */ new Set();
+  errorsByServer = /* @__PURE__ */ new Map();
+  suppressedAbortFailures = /* @__PURE__ */ new Set();
+  workers = /* @__PURE__ */ new Map();
+  connectTimeoutMs;
+  closeTimeoutMs;
+  dropFailed;
+  strict;
+  suppressAbortError;
+  connectInParallel;
+  static {
+    const asyncDispose = Symbol.asyncDispose;
+    if (asyncDispose) {
+      Object.defineProperty(this.prototype, asyncDispose, {
+        value: function() {
+          return this.close();
+        },
+        configurable: true
+      });
+    }
+  }
+  constructor(servers, options) {
+    this.allServers = [...servers];
+    this.activeServers = [...servers];
+    this.connectTimeoutMs = options?.connectTimeoutMs === void 0 ? DEFAULT_CONNECT_TIMEOUT_MS : options.connectTimeoutMs;
+    this.closeTimeoutMs = options?.closeTimeoutMs === void 0 ? DEFAULT_CLOSE_TIMEOUT_MS : options.closeTimeoutMs;
+    this.dropFailed = options?.dropFailed ?? true;
+    this.strict = options?.strict ?? false;
+    this.suppressAbortError = options?.suppressAbortError ?? true;
+    this.connectInParallel = options?.connectInParallel ?? false;
+  }
+  static async open(servers, options) {
+    const session = new _MCPServers(servers, options);
+    logger2.debug(`Opening MCPServers with ${session.allServers.length} server(s).`);
+    await session.connectAll();
+    return session;
+  }
+  get all() {
+    return [...this.allServers];
+  }
+  get active() {
+    return [...this.activeServers];
+  }
+  get failed() {
+    return [...this.failedServers];
+  }
+  get errors() {
+    return new Map(this.errorsByServer);
+  }
+  async reconnect(options = {}) {
+    const failedOnly = options.failedOnly ?? true;
+    let serversToRetry;
+    if (failedOnly) {
+      serversToRetry = uniqueServers(this.failedServers);
+    } else {
+      serversToRetry = [...this.allServers];
+      this.failedServers = [];
+      this.failedServerSet = /* @__PURE__ */ new Set();
+      this.errorsByServer = /* @__PURE__ */ new Map();
+      this.suppressedAbortFailures = /* @__PURE__ */ new Set();
+    }
+    logger2.debug(`Reconnecting MCP servers (failedOnly=${failedOnly}) with ${serversToRetry.length} target(s).`);
+    if (this.connectInParallel) {
+      await this.connectAllParallel(serversToRetry);
+    } else {
+      for (const server of serversToRetry) {
+        await this.attemptConnect(server);
+      }
+    }
+    this.refreshActiveServers();
+    return this.active;
+  }
+  async close() {
+    await this.closeAll();
+  }
+  async connectAll() {
+    this.failedServers = [];
+    this.failedServerSet = /* @__PURE__ */ new Set();
+    this.errorsByServer = /* @__PURE__ */ new Map();
+    this.suppressedAbortFailures = /* @__PURE__ */ new Set();
+    const serversToConnect = [...this.allServers];
+    let connectedServers = [];
+    logger2.debug(`Connecting ${serversToConnect.length} MCP server(s).`);
+    try {
+      if (this.connectInParallel) {
+        await this.connectAllParallel(serversToConnect);
+      } else {
+        for (const server of serversToConnect) {
+          await this.attemptConnect(server);
+          if (!this.failedServerSet.has(server)) {
+            connectedServers.push(server);
+          }
+        }
+      }
+    } catch (error) {
+      if (this.connectInParallel) {
+        connectedServers = serversToConnect.filter((server) => !this.failedServerSet.has(server));
+      }
+      const serversToCleanup = uniqueServers([
+        ...connectedServers,
+        ...this.failedServers
+      ]);
+      await this.closeServers(serversToCleanup);
+      this.activeServers = [];
+      throw error;
+    }
+    this.refreshActiveServers();
+    return this.active;
+  }
+  async closeAll() {
+    for (const server of [...this.allServers].reverse()) {
+      await this.closeServer(server);
+    }
+  }
+  async attemptConnect(server) {
+    const raiseOnError = this.strict;
+    try {
+      logger2.debug(`Connecting MCP server '${server.name}'.`);
+      await this.runConnect(server);
+      logger2.debug(`Connected MCP server '${server.name}'.`);
+      if (this.failedServerSet.has(server)) {
+        this.removeFailedServer(server);
+        this.errorsByServer.delete(server);
+      }
+    } catch (error) {
+      const err = toError(error);
+      if (isAbortError(err)) {
+        this.recordFailure(server, err, "connect");
+        if (!this.suppressAbortError) {
+          this.suppressedAbortFailures.delete(server);
+          throw err;
+        }
+        this.suppressedAbortFailures.add(server);
+        return;
+      }
+      this.suppressedAbortFailures.delete(server);
+      this.recordFailure(server, err, "connect");
+      if (raiseOnError) {
+        throw err;
+      }
+    }
+  }
+  refreshActiveServers() {
+    if (this.dropFailed) {
+      const failed = new Set(this.failedServerSet);
+      this.activeServers = this.allServers.filter((server) => !failed.has(server));
+    } else {
+      this.activeServers = [...this.allServers];
+    }
+    logger2.debug(`Active MCP servers: ${this.activeServers.length}; failed: ${this.failedServers.length}.`);
+  }
+  recordFailure(server, error, phase) {
+    logger2.error(`Failed to ${phase} MCP server '${server.name}':`, error);
+    if (!this.failedServerSet.has(server)) {
+      this.failedServers.push(server);
+      this.failedServerSet.add(server);
+    }
+    this.errorsByServer.set(server, error);
+  }
+  async runConnect(server) {
+    if (this.connectInParallel) {
+      const worker = this.getWorker(server);
+      await worker.connect();
+      return;
+    }
+    await runWithTimeout(() => server.connect(), this.connectTimeoutMs, createTimeoutError("connect", server, this.connectTimeoutMs));
+  }
+  async closeServer(server) {
+    try {
+      logger2.debug(`Closing MCP server '${server.name}'.`);
+      await this.runClose(server);
+      logger2.debug(`Closed MCP server '${server.name}'.`);
+    } catch (error) {
+      const err = toError(error);
+      if (isAbortError(err)) {
+        if (!this.suppressAbortError) {
+          throw err;
+        }
+        logger2.debug(`Close cancelled for MCP server '${server.name}': ${err}`);
+        this.errorsByServer.set(server, err);
+        return;
+      }
+      logger2.error(`Failed to close MCP server '${server.name}':`, err);
+      this.errorsByServer.set(server, err);
+    }
+  }
+  async runClose(server) {
+    if (this.connectInParallel && this.workers.has(server)) {
+      const worker = this.workers.get(server);
+      if (worker) {
+        await worker.close();
+        if (worker.isDone) {
+          this.workers.delete(server);
+        }
+        return;
+      }
+    }
+    await runWithTimeout(() => server.close(), this.closeTimeoutMs, createTimeoutError("close", server, this.closeTimeoutMs));
+  }
+  async closeServers(servers) {
+    for (const server of [...servers].reverse()) {
+      await this.closeServer(server);
+    }
+  }
+  async connectAllParallel(servers) {
+    const results = await Promise.allSettled(servers.map((server) => this.attemptConnect(server)));
+    const rejection = results.find((result) => result.status === "rejected");
+    if (rejection) {
+      throw rejection.reason;
+    }
+    if (this.strict && this.failedServers.length > 0) {
+      const firstFailure = this.failedServers.find((server) => !this.suppressedAbortFailures.has(server));
+      if (firstFailure) {
+        const error = this.errorsByServer.get(firstFailure);
+        if (error) {
+          throw error;
+        }
+        throw new Error(`Failed to connect MCP server '${firstFailure.name}'.`);
+      }
+    }
+  }
+  getWorker(server) {
+    const worker = this.workers.get(server);
+    if (!worker || worker.isDone) {
+      const next = new ServerWorker(server, this.connectTimeoutMs, this.closeTimeoutMs);
+      this.workers.set(server, next);
+      return next;
+    }
+    return worker;
+  }
+  removeFailedServer(server) {
+    if (this.failedServerSet.has(server)) {
+      this.failedServerSet.delete(server);
+    }
+    this.suppressedAbortFailures.delete(server);
+    this.failedServers = this.failedServers.filter((failedServer) => failedServer !== server);
+  }
+};
+async function connectMcpServers(servers, options) {
+  return MCPServers.open(servers, options);
+}
+function createTimeoutError(action, server, timeoutMs) {
+  if (timeoutMs === null) {
+    return new Error(`MCP server ${action} timed out.`);
+  }
+  const error = new Error(`MCP server ${action} timed out after ${timeoutMs}ms for '${server.name}'.`);
+  error.name = "TimeoutError";
+  return error;
+}
+function createClosedError(server) {
+  const error = new Error(`MCP server '${server.name}' is closed.`);
+  error.name = "ClosedError";
+  return error;
+}
+function createClosingError(server) {
+  const error = new Error(`MCP server '${server.name}' is closing.`);
+  error.name = "ClosingError";
+  return error;
+}
+async function runWithTimeout(fn, timeoutMs, timeoutError) {
+  if (timeoutMs === null) {
+    await fn();
+    return;
+  }
+  let timer;
+  let timedOut = false;
+  const task = fn();
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      timedOut = true;
+      reject(timeoutError);
+    }, timeoutMs);
+  });
+  try {
+    await Promise.race([task, timeoutPromise]);
+  } finally {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    if (timedOut) {
+      task.catch(() => void 0);
+    }
+  }
+}
+async function runWithTimeoutTask(task, timeoutMs, timeoutError) {
+  if (timeoutMs === null) {
+    await task;
+    return;
+  }
+  let timer;
+  let timedOut = false;
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      timedOut = true;
+      reject(timeoutError);
+    }, timeoutMs);
+  });
+  try {
+    await Promise.race([task, timeoutPromise]);
+  } finally {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    if (timedOut) {
+      task.catch(() => void 0);
+    }
+  }
+}
+function toError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(String(error));
+}
+function isAbortError(error) {
+  const code = error.code;
+  return error.name === "AbortError" || error.name === "CanceledError" || error.name === "CancelledError" || code === "ABORT_ERR" || code === "ERR_ABORTED";
+}
+function uniqueServers(servers) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const server of servers) {
+    if (!seen.has(server)) {
+      seen.add(server);
+      unique.push(server);
+    }
+  }
+  return unique;
+}
+
+// ../../node_modules/.bun/@openai+agents-core@0.13.3+bd37e07cd49ea605/node_modules/@openai/agents-core/dist/memory/historyMutations.mjs
+function applySessionHistoryMutations(items, mutations) {
+  let nextItems = items.map((item) => structuredClone(item));
+  for (const mutation of mutations) {
+    if (mutation.type === "replace_function_call") {
+      nextItems = applyReplaceFunctionCallMutation(nextItems, mutation);
+    }
+  }
+  return nextItems;
+}
+function applyReplaceFunctionCallMutation(items, mutation) {
+  const replacement = structuredClone(mutation.replacement);
+  const nextItems = [];
+  let keptReplacement = false;
+  for (const item of items) {
+    if (item.type === "function_call" && item.callId === mutation.callId) {
+      if (!keptReplacement) {
+        nextItems.push(replacement);
+        keptReplacement = true;
+      }
+      continue;
+    }
+    nextItems.push(item);
+  }
+  return nextItems;
+}
+
+// ../../node_modules/.bun/@openai+agents-core@0.13.3+bd37e07cd49ea605/node_modules/@openai/agents-core/dist/memory/memorySession.mjs
+var MemorySession = class {
+  sessionId;
+  logger;
+  items;
+  constructor(options = {}) {
+    this.sessionId = options.sessionId ?? randomUUID();
+    this.items = options.initialItems ? options.initialItems.map(cloneAgentItem) : [];
+    this.logger = options.logger ?? logger;
+  }
+  async getSessionId() {
+    return this.sessionId;
+  }
+  async getItems(limit) {
+    if (limit === void 0) {
+      const cloned = this.items.map(cloneAgentItem);
+      this.logger.debug(`Getting items from memory session (${this.sessionId}): ${JSON.stringify(cloned)}`);
+      return cloned;
+    }
+    if (limit <= 0) {
+      return [];
+    }
+    const start = Math.max(this.items.length - limit, 0);
+    const items = this.items.slice(start).map(cloneAgentItem);
+    this.logger.debug(`Getting items from memory session (${this.sessionId}): ${JSON.stringify(items)}`);
+    return items;
+  }
+  async addItems(items) {
+    if (items.length === 0) {
+      return;
+    }
+    const cloned = items.map(cloneAgentItem);
+    this.logger.debug(`Adding items to memory session (${this.sessionId}): ${JSON.stringify(cloned)}`);
+    this.items = [...this.items, ...cloned];
+  }
+  async popItem() {
+    if (this.items.length === 0) {
+      return void 0;
+    }
+    const item = this.items[this.items.length - 1];
+    const cloned = cloneAgentItem(item);
+    this.logger.debug(`Popping item from memory session (${this.sessionId}): ${JSON.stringify(cloned)}`);
+    this.items = this.items.slice(0, -1);
+    return cloned;
+  }
+  async clearSession() {
+    this.logger.debug(`Clearing memory session (${this.sessionId})`);
+    this.items = [];
+  }
+  async applyHistoryMutations(args) {
+    if (args.mutations.length === 0) {
+      return;
+    }
+    this.items = applySessionHistoryMutations(this.items, args.mutations);
+  }
+};
+function cloneAgentItem(item) {
+  return structuredClone(item);
+}
+
+// ../../node_modules/.bun/@openai+agents-core@0.13.3+bd37e07cd49ea605/node_modules/@openai/agents-core/dist/index.mjs
+addTraceProcessor(defaultProcessor());
+
+// ../../node_modules/.bun/@openai+agents-core@0.13.3+bd37e07cd49ea605/node_modules/@openai/agents-core/dist/sandbox/shared/output.mjs
+var APPROX_BYTES_PER_TOKEN = 4;
+function truncateOutput(output, maxOutputTokens) {
+  if (maxOutputTokens == null) {
+    return { text: output };
+  }
+  const maxBytes = Math.max(0, maxOutputTokens) * APPROX_BYTES_PER_TOKEN;
+  const outputBytes = byteLength(output);
+  if (outputBytes <= maxBytes) {
+    return { text: output };
+  }
+  const originalTokenCount = approximateTokenCountFromBytes(outputBytes);
+  const totalLines = countLines(output);
+  const marker = `...${approximateTokenCountFromBytes(outputBytes - maxBytes)} tokens truncated...`;
+  const preservedPrefix = getPreservedLeadingNotice(output);
+  const prefixBytes = byteLength(preservedPrefix);
+  const body = preservedPrefix ? output.slice(preservedPrefix.length) : output;
+  const bodyBudget = Math.max(0, maxBytes - prefixBytes);
+  const truncatedBody = bodyBudget === 0 ? marker : truncateWithByteBudget(body, bodyBudget, marker);
+  const truncated = `${preservedPrefix}${truncatedBody}`;
+  return {
+    text: `Total output lines: ${totalLines}
+
+${truncated}`,
+    originalTokenCount
+  };
+}
+function formatExecResponse(args) {
+  const lines = [
+    `Chunk ID: ${randomUUID().replace(/-/g, "").slice(0, 6)}`,
+    `Wall time: ${args.wallTimeSeconds.toFixed(4)} seconds`
+  ];
+  if (typeof args.sessionId === "number") {
+    lines.push(`Process running with session ID ${args.sessionId}`);
+  } else if (typeof args.exitCode === "number") {
+    lines.push(`Process exited with code ${args.exitCode}`);
+  }
+  if (typeof args.originalTokenCount === "number") {
+    lines.push(`Original token count: ${args.originalTokenCount}`);
+  }
+  lines.push("Output:");
+  lines.push(args.output);
+  return lines.join("\n");
+}
+function elapsedSeconds(start) {
+  return (Date.now() - start) / 1e3;
+}
+function truncateWithByteBudget(output, maxBytes, marker) {
+  const leftBudget = Math.floor(maxBytes / 2);
+  const rightBudget = maxBytes - leftBudget;
+  const totalBytes = byteLength(output);
+  const tailStartTarget = Math.max(0, totalBytes - rightBudget);
+  let prefixEnd = 0;
+  let suffixStart = totalBytes;
+  let suffixStarted = false;
+  let byteIndex = 0;
+  for (const character of output) {
+    const characterBytes = byteLength(character);
+    const characterEnd = byteIndex + characterBytes;
+    if (characterEnd <= leftBudget) {
+      prefixEnd = characterEnd;
+      byteIndex = characterEnd;
+      continue;
+    }
+    if (byteIndex >= tailStartTarget) {
+      if (!suffixStarted) {
+        suffixStart = byteIndex;
+        suffixStarted = true;
+      }
+      byteIndex = characterEnd;
+      continue;
+    }
+    byteIndex = characterEnd;
+  }
+  if (suffixStart < prefixEnd) {
+    suffixStart = prefixEnd;
+  }
+  const bytes = new TextEncoder().encode(output);
+  const prefix = new TextDecoder().decode(bytes.slice(0, prefixEnd));
+  const suffix = new TextDecoder().decode(bytes.slice(suffixStart));
+  return `${prefix}${marker}${suffix}`;
+}
+function getPreservedLeadingNotice(output) {
+  const match = output.match(/^\[\.\.\.\d+ characters truncated from process output\.\.\.\]\n/u);
+  return match?.[0] ?? "";
+}
+function countLines(output) {
+  if (output.length === 0) {
+    return 0;
+  }
+  return output.split(/\r\n|\r|\n/).length;
+}
+function byteLength(output) {
+  return new TextEncoder().encode(output).byteLength;
+}
+function approximateTokenCountFromBytes(bytes) {
+  if (bytes <= 0) {
+    return 0;
+  }
+  return Math.ceil(bytes / APPROX_BYTES_PER_TOKEN);
+}
+
+// ../../node_modules/.bun/@openai+agents-core@0.13.3+bd37e07cd49ea605/node_modules/@openai/agents-core/dist/sandbox/shared/hostPath.mjs
+import { isAbsolute, relative, sep } from "path";
+function relativeHostPathEscapesRoot(relativePath) {
+  return relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath);
+}
+function relativeHostPathEscapesRootOrSelf(relativePath) {
+  return relativePath === "" || relativeHostPathEscapesRoot(relativePath);
+}
+function isHostPathWithinRoot(root, path) {
+  return !relativeHostPathEscapesRoot(relative(root, path));
+}
+function isHostPathStrictlyWithinRoot(root, path) {
+  return !relativeHostPathEscapesRootOrSelf(relative(root, path));
+}
+
+// ../../node_modules/.bun/@openai+agents-core@0.13.3+bd37e07cd49ea605/node_modules/@openai/agents-core/dist/sandbox/shared/credentials.mjs
+function validateCredentialPair({ accessKeyId, secretAccessKey, message, details, code }) {
+  if (Boolean(accessKeyId) !== Boolean(secretAccessKey)) {
+    throw new SandboxMountError(message, details, code);
+  }
+}
+
+// ../../node_modules/.bun/@openai+agents-core@0.13.3+bd37e07cd49ea605/node_modules/@openai/agents-core/dist/sandbox/shared/media.mjs
+var MAX_VIEW_IMAGE_BYTES = 10 * 1024 * 1024;
+function assertViewImageByteLength(path, byteLength2) {
+  if (byteLength2 > MAX_VIEW_IMAGE_BYTES) {
+    throw new UserError(`Image file exceeds the 10 MB limit: ${path}`);
+  }
+}
+function imageOutputFromBytes(path, bytes) {
+  assertViewImageByteLength(path, bytes.byteLength);
+  const mediaType = sniffImageMediaType(bytes, path);
+  if (!mediaType) {
+    throw new UserError(`Unsupported image format for view_image: ${path}`);
+  }
+  return {
+    type: "image",
+    image: {
+      data: Uint8Array.from(bytes),
+      mediaType
+    }
+  };
+}
+function sniffImageMediaType(bytes, path) {
+  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";
+  }
+  if (bytes[0] === 66 && bytes[1] === 77) {
+    return "image/bmp";
+  }
+  if (bytes[0] === 73 && bytes[1] === 73 && bytes[2] === 42 && bytes[3] === 0 || bytes[0] === 77 && bytes[1] === 77 && bytes[2] === 0 && bytes[3] === 42) {
+    return "image/tiff";
+  }
+  if (looksLikeSvg(bytes)) {
+    return "image/svg+xml";
+  }
+  return mediaTypeFromPath(path);
+}
+async function toUint8Array(value) {
+  if (!value) {
+    return new Uint8Array();
+  }
+  if (value instanceof Uint8Array) {
+    return Uint8Array.from(value);
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (typeof value === "string") {
+    return new TextEncoder().encode(value);
+  }
+  if (typeof Blob !== "undefined" && value instanceof Blob) {
+    return new Uint8Array(await value.arrayBuffer());
+  }
+  return Uint8Array.from(value);
+}
+function looksLikeSvg(bytes) {
+  const prefix = new TextDecoder().decode(bytes.subarray(0, Math.min(bytes.byteLength, 512))).trimStart().toLowerCase();
+  return prefix.startsWith("<svg") || /^<\?xml[\s\S]*<svg/u.test(prefix);
+}
+function mediaTypeFromPath(path) {
+  const lowerPath = path?.trim().toLowerCase() ?? "";
+  if (lowerPath.endsWith(".png")) {
+    return "image/png";
+  }
+  if (lowerPath.endsWith(".jpg") || lowerPath.endsWith(".jpeg")) {
+    return "image/jpeg";
+  }
+  if (lowerPath.endsWith(".gif")) {
+    return "image/gif";
+  }
+  if (lowerPath.endsWith(".webp")) {
+    return "image/webp";
+  }
+  if (lowerPath.endsWith(".bmp")) {
+    return "image/bmp";
+  }
+  if (lowerPath.endsWith(".tif") || lowerPath.endsWith(".tiff")) {
+    return "image/tiff";
+  }
+  if (lowerPath.endsWith(".svg") || lowerPath.endsWith(".svgz")) {
+    return "image/svg+xml";
+  }
+  return null;
+}
+
+// ../../node_modules/.bun/@openai+agents-extensions@0.13.3+d7f081875ac70c34/node_modules/@openai/agents-extensions/dist/sandbox/shared/localSources.mjs
+import { constants } from "fs";
+import { lstat, mkdtemp, open, readFile, readdir, realpath, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname, join, resolve } from "path";
+
+// ../../node_modules/.bun/@openai+agents-extensions@0.13.3+d7f081875ac70c34/node_modules/@openai/agents-extensions/dist/sandbox/shared/git.mjs
+function normalizeGitRepository(repositoryOrEntry) {
+  const repository = typeof repositoryOrEntry === "string" ? repositoryOrEntry : repositoryOrEntry.repo;
+  if (!repository) {
+    throw new UserError("git_repo entries require a repo.");
+  }
+  if (repository.includes("://") || repository.startsWith("git@")) {
+    return repository;
+  }
+  const host = typeof repositoryOrEntry === "string" ? "github.com" : repositoryOrEntry.host ?? "github.com";
+  return `https://${host}/${repository}.git`;
+}
+
+// ../../node_modules/.bun/@openai+agents-core@0.13.3+bd37e07cd49ea605/node_modules/@openai/agents-core/dist/sandbox/sandboxes/shared/runProcess.mjs
+import { spawn } from "child_process";
+var DEFAULT_MAX_OUTPUT_BYTES = 1024 * 1024;
+var FORCE_KILL_DELAY_MS = 5e3;
+async function runSandboxProcess(command, args, options = {}) {
+  return new Promise((resolve2) => {
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let error;
+    let timedOut = false;
+    let closed = false;
+    let settled = false;
+    let timeout;
+    let forceKillTimeout;
+    const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const captureChunk = (chunks, currentBytes, chunk) => {
+      const remainingBytes = maxOutputBytes - currentBytes;
+      if (remainingBytes <= 0) {
+        return currentBytes;
+      }
+      const captured = chunk.length > remainingBytes ? chunk.subarray(0, remainingBytes) : chunk;
+      chunks.push(captured);
+      return currentBytes + captured.length;
+    };
+    const finish = (status, signal) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      closed = true;
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      if (forceKillTimeout) {
+        clearTimeout(forceKillTimeout);
+      }
+      resolve2({
+        status,
+        signal,
+        stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf8"),
+        error,
+        timedOut
+      });
+    };
+    child.stdout.on("data", (chunk) => {
+      stdoutBytes = captureChunk(stdoutChunks, stdoutBytes, chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderrBytes = captureChunk(stderrChunks, stderrBytes, chunk);
+    });
+    child.on("error", (childError) => {
+      error = childError;
+      finish(null, null);
+    });
+    if (options.timeoutMs !== void 0) {
+      timeout = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGTERM");
+        forceKillTimeout = setTimeout(() => {
+          if (!closed) {
+            child.kill("SIGKILL");
+          }
+        }, FORCE_KILL_DELAY_MS);
+      }, options.timeoutMs);
+    }
+    child.on("close", (status, signal) => {
+      finish(status, signal);
+    });
+  });
+}
+function formatSandboxProcessError(result) {
+  if (result.timedOut) {
+    return "process timed out";
+  }
+  return result.stderr || result.stdout || result.error?.message || "process failed";
+}
+
+// ../../node_modules/.bun/@openai+agents-core@0.13.3+bd37e07cd49ea605/node_modules/@openai/agents-core/dist/sandbox/client.mjs
+var DEFAULT_SANDBOX_ARCHIVE_LIMITS = {
+  maxInputBytes: 1024 * 1024 * 1024,
+  maxExtractedBytes: 4 * 1024 * 1024 * 1024,
+  maxMembers: 1e5
+};
+function normalizeSandboxClientCreateArgs(args, manifestOptions) {
+  if (args instanceof Manifest) {
+    return {
+      manifest: args,
+      options: manifestOptions,
+      snapshot: readSnapshotOption(manifestOptions),
+      concurrencyLimits: readConcurrencyLimitsOption(manifestOptions),
+      archiveLimits: readArchiveLimitsOption(manifestOptions)
+    };
+  }
+  const manifest = args?.manifest;
+  return {
+    manifest: manifest ? manifest instanceof Manifest ? manifest : cloneManifest(manifest) : new Manifest(),
+    options: args?.options,
+    snapshot: args?.snapshot,
+    concurrencyLimits: args?.concurrencyLimits,
+    archiveLimits: args?.archiveLimits
+  };
+}
+function resolveSandboxArchiveLimits(limits) {
+  if (limits == null) {
+    return null;
+  }
+  validateSandboxArchiveLimits(limits);
+  return {
+    maxInputBytes: limits.maxInputBytes === void 0 ? DEFAULT_SANDBOX_ARCHIVE_LIMITS.maxInputBytes : limits.maxInputBytes,
+    maxExtractedBytes: limits.maxExtractedBytes === void 0 ? DEFAULT_SANDBOX_ARCHIVE_LIMITS.maxExtractedBytes : limits.maxExtractedBytes,
+    maxMembers: limits.maxMembers === void 0 ? DEFAULT_SANDBOX_ARCHIVE_LIMITS.maxMembers : limits.maxMembers
+  };
+}
+function validateSandboxArchiveLimits(limits) {
+  if (limits == null) {
+    return;
+  }
+  validatePositiveArchiveLimit("maxInputBytes", limits.maxInputBytes);
+  validatePositiveArchiveLimit("maxExtractedBytes", limits.maxExtractedBytes);
+  validatePositiveArchiveLimit("maxMembers", limits.maxMembers);
+}
+function validatePositiveArchiveLimit(name, value) {
+  if (value == null) {
+    return;
+  }
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new UserError(`archiveLimits.${name} must be at least 1.`);
+  }
+}
+function readSnapshotOption(options) {
+  if (!isRecord(options)) {
+    return void 0;
+  }
+  return options.snapshot;
+}
+function readConcurrencyLimitsOption(options) {
+  if (!isRecord(options)) {
+    return void 0;
+  }
+  return options.concurrencyLimits;
+}
+function readArchiveLimitsOption(options) {
+  if (!isRecord(options)) {
+    return void 0;
+  }
+  return options.archiveLimits;
+}
+
+// ../../node_modules/.bun/@openai+agents-core@0.13.3+bd37e07cd49ea605/node_modules/@openai/agents-core/dist/sandbox/snapshot.mjs
+function isNoopSnapshotSpec(spec) {
+  return spec?.type === "noop";
+}
+
+// ../../node_modules/.bun/@openai+agents-extensions@0.13.3+d7f081875ac70c34/node_modules/@openai/agents-extensions/dist/sandbox/shared/paths.mjs
+var RESOLVE_WORKSPACE_PATH_HELPER = String.raw`#!/bin/sh
+set -eu
+
+root="$1"
+candidate="$2"
+for_write="$3"
+shift 3
+max_symlink_depth=64
+
+case "$for_write" in
+  0|1) ;;
+  *) printf 'for_write must be 0 or 1: %s\n' "$for_write" >&2; exit 64 ;;
+esac
+
+if [ $(( $# % 2 )) -ne 0 ]; then
+  printf 'extra path grants must be root/read_only pairs\n' >&2
+  exit 64
+fi
+
+resolve_path() {
+  path="$1"
+  depth="$2"
+  seen=""
+  if [ "$#" -ge 3 ]; then
+    seen="$3"
+  fi
+  if [ "$path" = "/" ]; then
+    printf '/\n'
+    return 0
+  fi
+  if [ "$depth" -ge "$max_symlink_depth" ]; then
+    printf 'symlink resolution depth exceeded: %s\n' "$path" >&2
+    exit 112
+  fi
+  if [ -d "$path" ]; then
+    (cd "$path" && pwd -P)
+    return 0
+  fi
+  parent=$(dirname "$path")
+  base=$(basename "$path")
+  if [ -z "$parent" ] || [ "$parent" = "$path" ]; then
+    parent="/"
+  fi
+  resolved_parent=$(resolve_path "$parent" "$depth" "$seen")
+  candidate_path=$(join_child_path "$resolved_parent" "$base")
+  if [ -L "$candidate_path" ]; then
+    case ":$seen:" in
+      *":$candidate_path:"*)
+        printf 'symlink resolution depth exceeded: %s\n' "$candidate_path" >&2
+        exit 112
+        ;;
+    esac
+    target=$(readlink "$candidate_path")
+    next_depth=$((depth + 1))
+    next_seen="$seen:$candidate_path"
+    case "$target" in
+      /*) resolve_path "$target" "$next_depth" "$next_seen" ;;
+      *)
+        relative_target=$(join_child_path "$resolved_parent" "$target")
+        resolve_path "$relative_target" "$next_depth" "$next_seen"
+        ;;
+    esac
+    return 0
+  fi
+  printf '%s\n' "$candidate_path"
+}
+
+join_child_path() {
+  parent="$1"
+  child="$2"
+  if [ "$parent" = "/" ]; then
+    printf '/%s\n' "$child"
+  else
+    printf '%s/%s\n' "$parent" "$child"
+  fi
+}
+
+resolved_candidate=$(resolve_path "$candidate" 0)
+best_grant_root=""
+best_grant_original=""
+best_grant_read_only="0"
+best_grant_len=0
+
+check_workspace_root() {
+  resolved_root=$(resolve_path "$root" 0)
+  if [ "$resolved_root" = "/" ]; then
+    case "$resolved_candidate" in
+      /*)
+        printf '%s\n' "$resolved_candidate"
+        exit 0
+        ;;
+    esac
+  fi
+  case "$resolved_candidate" in
+    "$resolved_root"|"$resolved_root"/*)
+      printf '%s\n' "$resolved_candidate"
+      exit 0
+      ;;
+  esac
+}
+
+consider_extra_grant() {
+  allowed_root="$1"
+  read_only="$2"
+  case "$read_only" in
+    0|1) ;;
+    *) printf 'extra path grant read_only must be 0 or 1: %s\n' "$read_only" >&2; exit 64 ;;
+  esac
+  resolved_root=$(resolve_path "$allowed_root" 0)
+  if [ "$resolved_root" = "/" ]; then
+    printf 'extra path grant must not resolve to filesystem root: %s\n' "$allowed_root" >&2
+    exit 113
+  fi
+  case "$resolved_candidate" in
+    "$resolved_root"|"$resolved_root"/*)
+      root_len=$(printf '%s' "$resolved_root" | wc -c | tr -d ' ')
+      if [ "$root_len" -gt "$best_grant_len" ]; then
+        best_grant_root="$resolved_root"
+        best_grant_original="$allowed_root"
+        best_grant_read_only="$read_only"
+        best_grant_len="$root_len"
+      fi
+      ;;
+  esac
+}
+
+while [ "$#" -gt 0 ]; do
+  consider_extra_grant "$1" "$2"
+  shift 2
+done
+
+check_workspace_root
+if [ -n "$best_grant_root" ]; then
+  if [ "$for_write" = "1" ] && [ "$best_grant_read_only" = "1" ]; then
+    printf 'read-only extra path grant: %s\nresolved path: %s\n' "$best_grant_original" "$resolved_candidate" >&2
+    exit 114
+  fi
+  printf '%s\n' "$resolved_candidate"
+  exit 0
+fi
+
+printf 'workspace escape: %s\n' "$resolved_candidate" >&2
+exit 111`;
+function createRemotePathHelperId() {
+  const crypto = globalThis.crypto;
+  if (typeof crypto?.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  if (typeof crypto?.getRandomValues === "function") {
+    return Array.from(crypto.getRandomValues(new Uint32Array(4)), (value) => value.toString(36)).join("-");
+  }
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function resolveSandboxAbsolutePath(root, path, options = {}) {
+  return new WorkspacePathPolicy({
+    root,
+    extraPathGrants: options.extraPathGrants
+  }).resolve(path, { forWrite: options.forWrite }).path;
+}
+async function validateRemoteSandboxPath({ root, path, options = {}, runCommand }) {
+  const candidate = resolveSandboxAbsolutePath(root, path, options);
+  const helperDir = `/tmp/openai-agents-resolve-path-${createRemotePathHelperId()}`;
+  const helperArgs = [
+    root,
+    candidate,
+    options.forWrite ? "1" : "0",
+    ...(options.extraPathGrants ?? []).flatMap((grant) => [
+      grant.path,
+      grant.readOnly ? "1" : "0"
+    ])
+  ];
+  const command = [
+    `helper_dir=${shellQuote(helperDir)}`,
+    'helper_path="$helper_dir/resolve-workspace-path.sh"',
+    'cleanup() { rm -rf "$helper_dir"; }',
+    "trap cleanup EXIT HUP INT TERM",
+    "umask 077",
+    'mkdir "$helper_dir" || exit 125',
+    `cat > "$helper_path" <<'OPENAI_AGENTS_RESOLVE_PATH'`,
+    RESOLVE_WORKSPACE_PATH_HELPER,
+    "OPENAI_AGENTS_RESOLVE_PATH",
+    `sh "$helper_path" ${helperArgs.map(shellQuote).join(" ")}`
+  ].join("\n");
+  const result = await runCommand(command);
+  if (result.status !== 0) {
+    const message = (result.stderr || result.stdout || "remote validation failed").trim().split(/\r?\n/u).join("; ");
+    throw new SandboxPathResolutionError(`Sandbox path "${path ?? ""}" failed remote validation: ${message}`, {
+      root,
+      path: path ?? "",
+      forWrite: options.forWrite ?? false
+    });
+  }
+  const resolvedPath = result.stdout?.trim().split(/\r?\n/u).pop();
+  if (!resolvedPath?.startsWith("/")) {
+    throw new SandboxPathResolutionError(`Sandbox path "${path ?? ""}" failed remote validation: validator did not return an absolute resolved path.`, {
+      root,
+      path: path ?? "",
+      forWrite: options.forWrite ?? false
+    });
+  }
+  return resolvedPath;
+}
+async function validateRemoteSandboxPathForManifest({ manifest, path, options = {}, runCommand }) {
+  return await validateRemoteSandboxPath({
+    root: manifest.root,
+    path,
+    options: {
+      ...options,
+      extraPathGrants: manifest.extraPathGrants
+    },
+    runCommand
+  });
+}
+function resolveSandboxRelativePath(root, path) {
+  const resolved = new WorkspacePathPolicy({
+    root
+  }).resolve(path, { forWrite: true });
+  if (typeof resolved.workspaceRelativePath !== "string") {
+    throw new UserError(`Sandbox path "${path ?? ""}" escapes the workspace root.`);
+  }
+  return normalizeRelativePath(resolved.workspaceRelativePath);
+}
+function resolveSandboxWorkdir(root, path) {
+  return resolveSandboxAbsolutePath(root, path);
+}
+
+// ../../node_modules/.bun/@openai+agents-extensions@0.13.3+d7f081875ac70c34/node_modules/@openai/agents-extensions/dist/sandbox/shared/manifest.mjs
+function cloneManifestWithRoot(manifest, root) {
+  return cloneManifestWithOverrides(manifest, {
+    root,
+    entries: rebaseManifestEntryPathsForRoot(manifest.entries, manifest.root, root)
+  });
+}
+function cloneManifestWithoutMountEntries(manifest) {
+  return cloneManifestWithOverrides(manifest, {
+    entries: removeMountEntries(manifest.entries)
+  });
+}
+function manifestContainsLocalSource(manifest) {
+  for (const { entry } of manifest.iterEntries()) {
+    if (isLocalSourceEntry(entry)) {
+      return true;
+    }
+  }
+  return false;
+}
+function entryContainsLocalSource(entry) {
+  if (isLocalSourceEntry(entry)) {
+    return true;
+  }
+  if (entry.type !== "dir" || !entry.children) {
+    return false;
+  }
+  return Object.values(entry.children).some((childEntry) => entryContainsLocalSource(childEntry));
+}
+function isLocalSourceEntry(entry) {
+  return entry.type === "local_file" || entry.type === "local_dir" || entry.type === "git_repo";
+}
+function cloneManifestWithOverrides(manifest, overrides = {}) {
+  return new Manifest({
+    version: manifest.version,
+    root: overrides.root ?? manifest.root,
+    entries: structuredClone(overrides.entries ?? manifest.entries),
+    environment: Object.fromEntries(Object.entries(manifest.environment).map(([key, value]) => [
+      key,
+      value.init()
+    ])),
+    users: structuredClone(manifest.users),
+    groups: structuredClone(manifest.groups),
+    extraPathGrants: structuredClone(manifest.extraPathGrants),
+    remoteMountCommandAllowlist: [...manifest.remoteMountCommandAllowlist]
+  });
+}
+function rebaseManifestEntryPathsForRoot(entries, fromRoot, toRoot) {
+  return Object.fromEntries(Object.entries(entries).map(([path, entry]) => [
+    path,
+    rebaseManifestEntryForRoot(entry, fromRoot, toRoot)
+  ]));
+}
+function rebaseManifestEntryForRoot(entry, fromRoot, toRoot) {
+  const cloned = structuredClone(entry);
+  if (isMount(cloned) && cloned.mountPath?.startsWith("/")) {
+    cloned.mountPath = rebaseAbsolutePathWithinRoot(cloned.mountPath, fromRoot, toRoot);
+  }
+  if (cloned.type === "dir" && cloned.children) {
+    cloned.children = rebaseManifestEntryPathsForRoot(cloned.children, fromRoot, toRoot);
+  }
+  return cloned;
+}
+function rebaseAbsolutePathWithinRoot(path, fromRoot, toRoot) {
+  const relativePath = relativePosixPathWithinRoot(normalizePosixPath(fromRoot), normalizePosixPath(path));
+  if (relativePath === null) {
+    return path;
+  }
+  if (!relativePath) {
+    return normalizePosixPath(toRoot);
+  }
+  const normalizedToRoot = normalizePosixPath(toRoot);
+  if (normalizedToRoot === "/") {
+    return `/${relativePath}`;
+  }
+  return `${normalizedToRoot}/${relativePath}`;
+}
+async function applyInlineManifestEntryToState(state, path, entry, providerLabel, writer, resolvePath, options = {}) {
+  await applyMaterializedManifestEntryToState(state, path, entry, providerLabel, writer, resolvePath, materializeInlineManifestEntry, options);
+}
+async function applyInlineManifestToState(state, manifest, providerLabel, writer, resolvePath, options = {}) {
+  await applyMaterializedManifestToState(state, manifest, providerLabel, writer, resolvePath, materializeInlineManifestEntry, options);
+}
+async function applyMaterializedManifestEntryToState(state, path, entry, providerLabel, writer, resolvePath, materializeEntry, options) {
+  const logicalPath = resolveSandboxRelativePath(state.manifest.root, path);
+  await materializeManifestEntries(writer, new Manifest({
+    root: state.manifest.root,
+    entries: {
+      [logicalPath]: entry
+    }
+  }), providerLabel, resolvePath, materializeEntry, options);
+  state.manifest = mergeManifestEntryDelta(state.manifest, logicalPath, entry);
+}
+async function applyMaterializedManifestToState(state, manifest, providerLabel, writer, resolvePath, materializeEntry, options) {
+  const previousManifest = state.manifest;
+  await materializeManifestEntries(writer, manifest, providerLabel, resolvePath, materializeEntry, options);
+  state.manifest = mergeManifestDelta(previousManifest, manifest);
+  state.environment = await mergeMaterializedEnvironment(previousManifest, state.manifest, state.environment);
+}
+async function materializeManifestEntries(writer, manifest, providerLabel, resolvePath, materializeEntry, options) {
+  const deferredOptions = {
+    ...options,
+    skipMountEntries: true
+  };
+  const entries = Object.entries(manifest.entries).filter(([, entry]) => !isMount(entry));
+  await runLimited(entries, resolveManifestEntryConcurrency(options.concurrencyLimits), async ([path, entry]) => {
+    const logicalPath = normalizeRelativePath(path);
+    const absolutePath = await resolvePath(logicalPath, { forWrite: true });
+    const entryOptions = {
+      ...deferredOptions,
+      resolvePath,
+      logicalPath
+    };
+    await materializeEntry(writer, absolutePath, entry, providerLabel, entryOptions);
+  });
+  for (const { mountPath, entry } of manifest.mountTargetsForMaterialization()) {
+    const logicalPath = resolveSandboxRelativePath(manifest.root, mountPath);
+    const absolutePath = await resolvePath(logicalPath, { forWrite: true });
+    await materializeEntry(writer, absolutePath, entry, providerLabel, options);
+  }
+}
+async function runLimited(items, limit, fn) {
+  if (items.length === 0) {
+    return;
+  }
+  let nextIndex = 0;
+  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (nextIndex < items.length) {
+      const item = items[nextIndex++];
+      await fn(item);
+    }
+  });
+  await Promise.all(workers);
+}
+function resolveManifestEntryConcurrency(limits) {
+  return normalizeConcurrencyLimit(limits?.manifestEntries, 4);
+}
+function resolveLocalDirFileConcurrency(limits) {
+  return normalizeConcurrencyLimit(limits?.localDirFiles, 4);
+}
+function normalizeConcurrencyLimit(value, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (!Number.isFinite(value) || value < 1) {
+    throw new UserError("Sandbox concurrency limits must be positive numbers.");
+  }
+  return Math.floor(value);
+}
+async function materializeInlineManifestEntry(writer, absolutePath, entry, providerLabel, options = {}) {
+  if (isMount(entry)) {
+    if (options.skipMountEntries) {
+      return;
+    }
+    if (options.materializeMount) {
+      await options.materializeMount(absolutePath, entry);
+      return;
+    }
+    throw new SandboxUnsupportedFeatureError(`${providerLabel} does not support mount entries yet: ${absolutePath}`);
+  }
+  switch (entry.type) {
+    case "dir":
+      await writer.mkdir(absolutePath);
+      if (entry.children) {
+        for (const [childPath, childEntry] of Object.entries(entry.children)) {
+          const child = await resolveMaterializedChildPath(absolutePath, childPath, options);
+          await materializeInlineManifestEntry(writer, child.absolutePath, childEntry, providerLabel, {
+            ...options,
+            logicalPath: child.logicalPath
+          });
+        }
+      }
+      break;
+    case "file":
+      await writer.writeFile(absolutePath, entry.content);
+      break;
+    case "local_file":
+    case "local_dir":
+    case "git_repo":
+      throw new UserError(`${providerLabel} cannot materialize ${entry.type} entries in this runtime. Use inline file or dir entries, or materialize local sources from a Node-compatible runtime.`);
+    default:
+      throw new UserError(`Unsupported sandbox entry type: ${entry.type}`);
+  }
+  await options.applyMetadata?.(absolutePath, entry);
+}
+async function resolveMaterializedChildPath(parentAbsolutePath, childPath, options) {
+  const normalizedChildPath = normalizeRelativePath(childPath);
+  const logicalPath = options.logicalPath !== void 0 ? options.logicalPath ? `${options.logicalPath}/${normalizedChildPath}` : normalizedChildPath : void 0;
+  if (options.resolvePath && logicalPath !== void 0) {
+    return {
+      absolutePath: await options.resolvePath(logicalPath, { forWrite: true }),
+      logicalPath
+    };
+  }
+  return {
+    absolutePath: `${parentAbsolutePath}/${normalizedChildPath}`,
+    logicalPath
+  };
+}
+function removeMountEntries(entries) {
+  const result = {};
+  for (const [path, entry] of Object.entries(entries)) {
+    if (isMount(entry)) {
+      continue;
+    }
+    if (entry.type === "dir" && entry.children) {
+      result[path] = {
+        ...structuredClone(entry),
+        children: removeMountEntries(entry.children)
+      };
+      continue;
+    }
+    result[path] = structuredClone(entry);
+  }
+  return result;
+}
+
+// ../../node_modules/.bun/@openai+agents-extensions@0.13.3+d7f081875ac70c34/node_modules/@openai/agents-extensions/dist/sandbox/shared/localSources.mjs
+var GIT_VERSION_TIMEOUT_MS = 1e4;
+var GIT_CLONE_TIMEOUT_MS = 5 * 6e4;
+var COMMIT_REF_PATTERN = /^[0-9a-fA-F]{7,40}$/;
+var LOCAL_SOURCE_FILE_READ_FLAGS = constants.O_RDONLY | constants.O_NOFOLLOW;
+var LOCAL_SOURCE_DIRECTORY_READ_FLAGS = constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_DIRECTORY;
+async function applyLocalSourceManifestEntryToState(state, path, entry, providerLabel, writer, resolvePath, options = {}) {
+  await applyMaterializedManifestEntryToState(state, path, entry, providerLabel, writer, resolvePath, materializeLocalSourceManifestEntry, {
+    ...options,
+    localSourceGrants: state.manifest.extraPathGrants
+  });
+}
+async function applyLocalSourceManifestToState(state, manifest, providerLabel, writer, resolvePath, options = {}) {
+  const sourceManifest = mergeManifestDelta(state.manifest, manifest);
+  await applyMaterializedManifestToState(state, manifest, providerLabel, writer, resolvePath, materializeLocalSourceManifestEntry, {
+    ...options,
+    localSourceGrants: sourceManifest.extraPathGrants
+  });
+}
+async function materializeLocalSourceManifest(writer, manifest, providerLabel, resolvePath, options = {}) {
+  await materializeManifestEntries(writer, manifest, providerLabel, resolvePath, materializeLocalSourceManifestEntry, {
+    ...options,
+    localSourceGrants: manifest.extraPathGrants
+  });
+}
+async function materializeLocalSourceManifestEntry(writer, absolutePath, entry, providerLabel, options = {}) {
+  switch (entry.type) {
+    case "dir":
+      await writer.mkdir(absolutePath);
+      if (entry.children) {
+        for (const [childPath, childEntry] of Object.entries(entry.children)) {
+          const child = await resolveMaterializedChildPath(absolutePath, childPath, options);
+          await materializeLocalSourceManifestEntry(writer, child.absolutePath, childEntry, providerLabel, {
+            ...options,
+            logicalPath: child.logicalPath
+          });
+        }
+      }
+      break;
+    case "local_file":
+      await writer.writeFile(absolutePath, await readStableLocalFile(resolveLocalSourcePath("local_file", entry.src, options)));
+      break;
+    case "local_dir":
+      await materializeLocalDirectory(writer, absolutePath, resolveLocalSourcePath("local_dir", entry.src, options), options);
+      break;
+    case "git_repo":
+      await materializeGitRepo(writer, absolutePath, entry, entry.ref, providerLabel, options);
+      break;
+    default:
+      await materializeInlineManifestEntry(writer, absolutePath, entry, providerLabel, options);
+      return;
+  }
+  await options.applyMetadata?.(absolutePath, entry);
+}
+function resolveLocalSourcePath(entryType, sourcePath, options) {
+  const base = resolve(options.localSourceBaseDir ?? process.cwd());
+  const resolvedSourcePath = resolve(base, sourcePath);
+  if (isHostPathWithinRoot(base, resolvedSourcePath) || (options.localSourceGrants ?? []).some((grant) => isHostPathWithinRoot(resolve(grant.path), resolvedSourcePath))) {
+    return resolvedSourcePath;
+  }
+  throw new UserError(`${entryType} source must stay within the local source base directory or manifest.extraPathGrants: ${resolvedSourcePath} (base: ${base})`);
+}
+async function materializeLocalDirectory(writer, absolutePath, sourceDir, options, expectedSourceStat) {
+  const source = await resolveStableLocalDirectorySource(sourceDir, expectedSourceStat);
+  await writer.mkdir(absolutePath);
+  const entries = await readStableLocalDirectoryEntries(sourceDir, source.stat);
+  await runLimited(entries, resolveLocalDirFileConcurrency(options.concurrencyLimits), async (entry) => {
+    const sourcePath = join(sourceDir, entry.name);
+    const destinationPath = `${absolutePath}/${entry.name}`;
+    if (entry.isDirectory()) {
+      const childSourceStat = await assertStableLocalDirectoryChild(source.root, sourcePath);
+      await materializeLocalDirectory(writer, destinationPath, sourcePath, options, childSourceStat);
+      return;
+    }
+    if (entry.isFile()) {
+      await writer.writeFile(destinationPath, await readStableLocalDirectoryFile(source.root, sourcePath));
+      return;
+    }
+    if (entry.isSymbolicLink()) {
+      throw new UserError(`local_dir entries do not support symbolic links: ${sourcePath}`);
+    }
+  });
+}
+async function resolveStableLocalDirectorySource(sourceDir, expectedSourceStat) {
+  await assertNoLocalSourceSymlinkAncestors(sourceDir, "local_dir", localDirectoryPathChangedError);
+  const sourceStat = await statStableLocalSourcePath(sourceDir);
+  if (sourceStat.isSymbolicLink()) {
+    throw new UserError(`local_dir entries do not support symbolic links: ${sourceDir}`);
+  }
+  if (!sourceStat.isDirectory()) {
+    throw new UserError(`local_dir source must be a directory: ${sourceDir}`);
+  }
+  if (expectedSourceStat && !sameFilesystemEntry(sourceStat, expectedSourceStat)) {
+    throw localDirectoryPathChangedError(sourceDir);
+  }
+  const sourceRoot = await realpathStableLocalSourcePath(sourceDir);
+  let handle;
+  try {
+    handle = await open(sourceDir, LOCAL_SOURCE_DIRECTORY_READ_FLAGS);
+  } catch (error) {
+    if (isPathChangedError(error)) {
+      throw localDirectoryPathChangedError(sourceDir);
+    }
+    throw error;
+  }
+  try {
+    const openedStat = await handle.stat();
+    if (!openedStat.isDirectory() || !sameFilesystemEntry(openedStat, sourceStat)) {
+      throw localDirectoryPathChangedError(sourceDir);
+    }
+    return { root: sourceRoot, stat: openedStat };
+  } finally {
+    await handle.close();
+  }
+}
+async function readStableLocalDirectoryEntries(sourceDir, expectedStat) {
+  let entries;
+  try {
+    entries = await readdir(sourceDir, { withFileTypes: true });
+  } catch (error) {
+    if (isPathChangedError(error)) {
+      throw localDirectoryPathChangedError(sourceDir);
+    }
+    throw error;
+  }
+  await assertStableLocalDirectoryPath(sourceDir, expectedStat);
+  return entries;
+}
+async function assertStableLocalDirectoryPath(sourcePath, expectedStat) {
+  const currentStat = await statStableLocalSourcePath(sourcePath);
+  if (currentStat.isSymbolicLink() || !currentStat.isDirectory() || !sameFilesystemEntry(currentStat, expectedStat)) {
+    throw localDirectoryPathChangedError(sourcePath);
+  }
+}
+async function readStableLocalFile(sourcePath) {
+  await assertNoLocalSourceSymlinkAncestors(sourcePath, "local_file", localFilePathChangedError);
+  const sourceStat = await statStableLocalSourcePath(sourcePath, localFilePathChangedError);
+  if (sourceStat.isSymbolicLink()) {
+    throw new UserError(`local_file entries do not support symbolic links: ${sourcePath}`);
+  }
+  if (!sourceStat.isFile()) {
+    throw localFilePathChangedError(sourcePath);
+  }
+  let handle;
+  try {
+    handle = await open(sourcePath, LOCAL_SOURCE_FILE_READ_FLAGS);
+  } catch (error) {
+    if (isPathChangedError(error)) {
+      throw localFilePathChangedError(sourcePath);
+    }
+    throw error;
+  }
+  try {
+    const openedStat = await handle.stat();
+    if (!openedStat.isFile() || !sameFilesystemEntry(openedStat, sourceStat)) {
+      throw localFilePathChangedError(sourcePath);
+    }
+    return await handle.readFile();
+  } finally {
+    await handle.close();
+  }
+}
+async function assertNoLocalSourceSymlinkAncestors(sourcePath, entryType, pathChangedError) {
+  const resolvedPath = resolve(sourcePath);
+  let current = dirname(resolvedPath);
+  while (current !== dirname(current)) {
+    const parent = dirname(current);
+    if (parent === dirname(parent)) {
+      break;
+    }
+    let currentStat;
+    try {
+      currentStat = await lstat(current);
+    } catch (error) {
+      if (isPathChangedError(error)) {
+        throw pathChangedError(sourcePath);
+      }
+      throw error;
+    }
+    if (currentStat.isSymbolicLink()) {
+      throw new UserError(`${entryType} entries do not support symbolic link ancestors: ${sourcePath}`);
+    }
+    current = parent;
+  }
+}
+async function readStableLocalDirectoryFile(sourceRoot, sourcePath) {
+  const sourceStat = await statStableLocalSourcePath(sourcePath);
+  if (sourceStat.isSymbolicLink()) {
+    throw new UserError(`local_dir entries do not support symbolic links: ${sourcePath}`);
+  }
+  if (!sourceStat.isFile()) {
+    throw localDirectoryPathChangedError(sourcePath);
+  }
+  const resolvedSourcePath = await realpathStableLocalSourcePath(sourcePath);
+  assertPathInsideRootChild(sourceRoot, resolvedSourcePath, `local_dir entry path changed while materializing: ${sourcePath}`);
+  let handle;
+  try {
+    handle = await open(sourcePath, LOCAL_SOURCE_FILE_READ_FLAGS);
+  } catch (error) {
+    if (isPathChangedError(error)) {
+      throw localDirectoryPathChangedError(sourcePath);
+    }
+    throw error;
+  }
+  try {
+    const openedStat = await handle.stat();
+    if (!openedStat.isFile() || !sameFilesystemEntry(openedStat, sourceStat)) {
+      throw localDirectoryPathChangedError(sourcePath);
+    }
+    return await handle.readFile();
+  } finally {
+    await handle.close();
+  }
+}
+async function assertStableLocalDirectoryChild(sourceRoot, sourcePath) {
+  const sourceStat = await statStableLocalSourcePath(sourcePath);
+  if (sourceStat.isSymbolicLink()) {
+    throw new UserError(`local_dir entries do not support symbolic links: ${sourcePath}`);
+  }
+  if (!sourceStat.isDirectory()) {
+    throw localDirectoryPathChangedError(sourcePath);
+  }
+  const resolvedSourcePath = await realpathStableLocalSourcePath(sourcePath);
+  assertPathInsideRootChild(sourceRoot, resolvedSourcePath, `local_dir entry path changed while materializing: ${sourcePath}`);
+  return sourceStat;
+}
+async function statStableLocalSourcePath(sourcePath, pathChangedError = localDirectoryPathChangedError) {
+  try {
+    return await lstat(sourcePath);
+  } catch (error) {
+    if (isPathChangedError(error)) {
+      throw pathChangedError(sourcePath);
+    }
+    throw error;
+  }
+}
+async function realpathStableLocalSourcePath(sourcePath, pathChangedError = localDirectoryPathChangedError) {
+  try {
+    return await realpath(sourcePath);
+  } catch (error) {
+    if (isPathChangedError(error)) {
+      throw pathChangedError(sourcePath);
+    }
+    throw error;
+  }
+}
+function localDirectoryPathChangedError(sourcePath) {
+  return new UserError(`local_dir entry path changed while materializing: ${sourcePath}`);
+}
+function localFilePathChangedError(sourcePath) {
+  return new UserError(`local_file entry path changed while materializing: ${sourcePath}`);
+}
+function isPathChangedError(error) {
+  return typeof error === "object" && error !== null && "code" in error && (error.code === "ELOOP" || error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+function sameFilesystemEntry(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+function assertPathInsideRootChild(sourceRoot, resolvedSourcePath, errorMessage) {
+  if (!isHostPathStrictlyWithinRoot(sourceRoot, resolvedSourcePath)) {
+    throw new UserError(errorMessage);
+  }
+}
+async function materializeGitRepo(writer, absolutePath, repository, ref, providerLabel, options) {
+  const gitVersion = await runSandboxProcess("git", ["--version"], {
+    timeoutMs: GIT_VERSION_TIMEOUT_MS
+  });
+  if (gitVersion.status !== 0) {
+    throw new UserError("git_repo entries require a local `git` executable, but `git` was not found.");
+  }
+  const tempDir = await mkdtemp(join(tmpdir(), `openai-agents-${providerLabel}-git-`));
+  try {
+    const repositoryUrl = normalizeGitRepository(repository);
+    const { result: cloneResult, commitFetchError } = await cloneGitRepo(repositoryUrl, tempDir, ref);
+    if (cloneResult.status !== 0) {
+      throw new UserError(`Failed to materialize git_repo entry ${formatGitRepositoryForError(repository)}: ${formatSandboxProcessError(commitFetchError ?? cloneResult)}`);
+    }
+    const subpath = typeof repository === "string" ? void 0 : repository.subpath;
+    const sourcePath = subpath ? join(tempDir, subpath) : tempDir;
+    if (subpath) {
+      const cloneRoot = await realpath(tempDir);
+      const sourceRealpath = await realpath(sourcePath);
+      assertPathInsideRootChild(cloneRoot, sourceRealpath, `git_repo subpath escapes the cloned repository: ${subpath}`);
+    }
+    await materializeGitRepoSource(writer, absolutePath, sourcePath, options, subpath);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+}
+async function cloneGitRepo(repositoryUrl, destination, ref) {
+  if (!ref || !looksLikeCommitRef(ref)) {
+    return { result: await cloneNamedRef(repositoryUrl, destination, ref) };
+  }
+  const result = await fetchCommitRef(repositoryUrl, destination, ref);
+  if (result.status === 0) {
+    return { result };
+  }
+  await rm(destination, { recursive: true, force: true });
+  return {
+    result: await cloneNamedRef(repositoryUrl, destination, ref),
+    commitFetchError: result
+  };
+}
+async function cloneNamedRef(repositoryUrl, destination, ref) {
+  const cloneArgs = ["clone", "--depth", "1", "--no-tags"];
+  if (ref) {
+    cloneArgs.push("--branch", ref);
+  }
+  cloneArgs.push(repositoryUrl, destination);
+  return await runSandboxProcess("git", cloneArgs, {
+    timeoutMs: GIT_CLONE_TIMEOUT_MS
+  });
+}
+async function fetchCommitRef(repositoryUrl, destination, ref) {
+  const steps = [
+    ["init", destination],
+    ["-C", destination, "remote", "add", "origin", repositoryUrl],
+    ["-C", destination, "fetch", "--depth", "1", "--no-tags", "origin", ref],
+    ["-C", destination, "checkout", "--detach", "FETCH_HEAD"]
+  ];
+  for (const args of steps) {
+    const result = await runSandboxProcess("git", args, {
+      timeoutMs: GIT_CLONE_TIMEOUT_MS
+    });
+    if (result.status !== 0) {
+      return result;
+    }
+  }
+  return {
+    status: 0,
+    signal: null,
+    stdout: "",
+    stderr: "",
+    timedOut: false
+  };
+}
+function looksLikeCommitRef(ref) {
+  return COMMIT_REF_PATTERN.test(ref);
+}
+async function materializeGitRepoSource(writer, absolutePath, sourcePath, options, subpath) {
+  const sourceInfo = await lstat(sourcePath);
+  if (sourceInfo.isDirectory()) {
+    await materializeLocalDirectory(writer, absolutePath, sourcePath, options);
+    return;
+  }
+  if (sourceInfo.isFile()) {
+    await writer.writeFile(absolutePath, await readFile(sourcePath));
+    return;
+  }
+  throw new UserError(`git_repo subpath must resolve to a file or directory: ${subpath ?? "."}`);
+}
+function formatGitRepositoryForError(repository) {
+  if (typeof repository === "string") {
+    return repository;
+  }
+  return repository.repo;
+}
+
+export {
+  connectMcpServers,
+  MemorySession,
+  normalizeSandboxClientCreateArgs,
+  resolveSandboxArchiveLimits,
+  validateSandboxArchiveLimits,
+  isNoopSnapshotSpec,
+  relativeHostPathEscapesRoot,
+  isHostPathWithinRoot,
+  isHostPathStrictlyWithinRoot,
+  runSandboxProcess,
+  formatSandboxProcessError,
+  assertViewImageByteLength,
+  imageOutputFromBytes,
+  toUint8Array,
+  truncateOutput,
+  formatExecResponse,
+  elapsedSeconds,
+  validateCredentialPair,
+  resolveSandboxAbsolutePath,
+  validateRemoteSandboxPathForManifest,
+  resolveSandboxRelativePath,
+  resolveSandboxWorkdir,
+  cloneManifestWithRoot,
+  cloneManifestWithoutMountEntries,
+  manifestContainsLocalSource,
+  entryContainsLocalSource,
+  applyInlineManifestEntryToState,
+  applyInlineManifestToState,
+  applyLocalSourceManifestEntryToState,
+  applyLocalSourceManifestToState,
+  materializeLocalSourceManifest,
+  materializeLocalSourceManifestEntry
+};
+//# sourceMappingURL=chunk-4YJ5Z52Z.js.map