@openai/agents-core
Version:
The OpenAI Agents SDK is a lightweight yet powerful framework for building multi-agent workflows.
185 lines • 6.9 kB
JavaScript
;
/// <reference lib="dom" />
Object.defineProperty(exports, "__esModule", { value: true });
exports.timer = exports.MCPServerSSE = exports.MCPServerStreamableHttp = exports.MCPServerStdio = exports.AsyncLocalStorage = exports.TransformStream = exports.ReadableStreamController = exports.ReadableStream = exports.Readable = exports.randomUUID = exports.RuntimeEventEmitter = exports.BrowserEventEmitter = exports.loadEnv = exports.isBrowserEnvironment = void 0;
exports.isTracingLoopRunningByDefault = isTracingLoopRunningByDefault;
exports.supportsProcessLifecycleEvents = supportsProcessLifecycleEvents;
var config_browser_1 = require("./config-browser.js");
Object.defineProperty(exports, "isBrowserEnvironment", { enumerable: true, get: function () { return config_browser_1.isBrowserEnvironment; } });
Object.defineProperty(exports, "loadEnv", { enumerable: true, get: function () { return config_browser_1.loadEnv; } });
class BrowserEventEmitter {
#target = new EventTarget();
#listenerWrappers = new Map();
on(type, listener) {
const eventType = type;
let listenersForType = this.#listenerWrappers.get(eventType);
if (!listenersForType) {
listenersForType = new Map();
this.#listenerWrappers.set(eventType, listenersForType);
}
let wrappers = listenersForType.get(listener);
if (!wrappers) {
wrappers = new Set();
listenersForType.set(listener, wrappers);
}
const wrapper = ((event) => listener(...(event.detail ?? [])));
wrappers.add(wrapper);
this.#target.addEventListener(eventType, wrapper);
return this;
}
off(type, listener) {
const eventType = type;
const listenersForType = this.#listenerWrappers.get(eventType);
const wrappers = listenersForType?.get(listener);
if (wrappers?.size) {
for (const wrapper of wrappers) {
this.#target.removeEventListener(eventType, wrapper);
}
listenersForType?.delete(listener);
if (listenersForType?.size === 0) {
this.#listenerWrappers.delete(eventType);
}
}
return this;
}
emit(type, ...args) {
const event = new CustomEvent(type, { detail: args });
return this.#target.dispatchEvent(event);
}
once(type, listener) {
const handler = (...args) => {
this.off(type, handler);
listener(...args);
};
this.on(type, handler);
return this;
}
}
exports.BrowserEventEmitter = BrowserEventEmitter;
exports.RuntimeEventEmitter = BrowserEventEmitter;
const randomUUID = () => {
if (typeof crypto !== 'undefined' && crypto.randomUUID) {
return crypto.randomUUID();
}
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
const r = (Math.random() * 16) | 0;
const v = c === 'x' ? r : (r & 0x3) | 0x8;
return v.toString(16);
});
};
exports.randomUUID = randomUUID;
const Readable = class Readable {
constructor() { }
pipeTo(_destination, _options) { }
pipeThrough(_transform, _options) { }
};
exports.Readable = Readable;
exports.ReadableStream = globalThis.ReadableStream;
exports.ReadableStreamController = globalThis.ReadableStreamDefaultController;
exports.TransformStream = globalThis.TransformStream;
function isPromiseLike(value) {
return (typeof value === 'object' &&
value !== null &&
typeof value.then === 'function' &&
typeof value.finally === 'function');
}
function getDeferredRestorePromise(value) {
if (typeof value !== 'object' || value === null) {
return undefined;
}
const streamLoopPromise = value._getStreamLoopPromise?.();
if (isPromiseLike(streamLoopPromise)) {
return streamLoopPromise;
}
return undefined;
}
class AsyncLocalStorage {
context = undefined;
#stack = [];
constructor() { }
run(context, fn) {
const entry = { context };
this.#stack.push(entry);
this.context = context;
const restore = () => {
const index = this.#stack.indexOf(entry);
if (index !== -1) {
this.#stack.splice(index, 1);
}
this.context = this.#stack.at(-1)?.context;
};
try {
const result = fn();
if (isPromiseLike(result)) {
return result.then((value) => {
const deferredRestore = getDeferredRestorePromise(value);
if (deferredRestore) {
void deferredRestore.then(restore, restore);
}
else {
restore();
}
return value;
}, (error) => {
restore();
throw error;
});
}
restore();
return result;
}
catch (error) {
restore();
throw error;
}
}
getStore() {
return this.context;
}
enterWith(context) {
const current = this.#stack.at(-1);
if (current) {
current.context = context;
}
else if (context !== undefined) {
this.#stack.push({ context });
}
else {
this.context = context;
return;
}
this.context = context;
}
}
exports.AsyncLocalStorage = AsyncLocalStorage;
function isTracingLoopRunningByDefault() {
return false;
}
function supportsProcessLifecycleEvents() {
return false;
}
var browser_1 = require("./mcp-server/browser.js");
Object.defineProperty(exports, "MCPServerStdio", { enumerable: true, get: function () { return browser_1.MCPServerStdio; } });
Object.defineProperty(exports, "MCPServerStreamableHttp", { enumerable: true, get: function () { return browser_1.MCPServerStreamableHttp; } });
Object.defineProperty(exports, "MCPServerSSE", { enumerable: true, get: function () { return browser_1.MCPServerSSE; } });
class BrowserTimer {
constructor() { }
setTimeout(callback, ms) {
const timeout = setTimeout(callback, ms);
timeout.ref =
typeof timeout.ref === 'function' ? timeout.ref : () => timeout;
timeout.unref =
typeof timeout.unref === 'function' ? timeout.unref : () => timeout;
timeout.hasRef =
typeof timeout.hasRef === 'function' ? timeout.hasRef : () => true;
timeout.refresh =
typeof timeout.refresh === 'function' ? timeout.refresh : () => timeout;
return timeout;
}
clearTimeout(timeoutId) {
window.clearTimeout(timeoutId);
}
}
const timer = new BrowserTimer();
exports.timer = timer;
//# sourceMappingURL=shims-browser.js.map