@agent-harness-experimental/adapter-openai-agents 0.0.0 → 0.0.1

package/dist/adapter.js

@@ -0,0 +1,732 @@
+import { attachSplitSandboxContext, defineAdapterBuiltinTools, detachSplitSandbox, getSandboxRuntimeLayout, isToolAllowed, normalizeAdapterError, resolveSecretInput, selectConfiguredAuthBag, startSplitSandbox, stopSplitSandbox, } from 'agent-harness-experimental';
+import { getSandboxImageName, withVercelSandboxBackend } from '@agent-harness-experimental/sandbox-vercel';
+import { OpenAIProvider, Runner, tool } from '@openai/agents';
+import { Capability, compaction, dir, file, filesystem, SandboxAgent, shell, skills } from '@openai/agents/sandbox';
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import { createInitialSandboxFiles, OpenAISplitSandboxSession } from './openai-sandbox-session.js';
+import { createOpenAIAgentsReplayProxy } from './replay-proxy.js';
+import { getOpenAIAgentsSandboxSetup } from './setup.js';
+import { openAIAgentsAdapterStateSchema, parseOpenAIAgentsAdapterState } from './state.js';
+import { OpenAIAgentsToolBridge } from './tools.js';
+import { parseJsonOrString } from './parse-json.js';
+import { msg as protocolMessage } from '@agent-harness-experimental/protocol';
+const DEFAULT_CONTEXT_WINDOW = 400_000;
+const DEFAULT_OPENAI_BASE_URL = 'https://api.openai.com/v1';
+const DEFAULT_GATEWAY_BASE_URL = 'https://ai-gateway.vercel.sh/v1';
+const delegateTaskInputSchema = z.object({
+    agent: z.string().optional(),
+    task: z.string().optional(),
+});
+export const { tools: OPENAI_AGENTS_BUILTIN_TOOLS, permissionToolCategories: OPENAI_AGENTS_PERMISSION_TOOL_CATEGORIES } = defineAdapterBuiltinTools([
+    {
+        name: 'exec_command',
+        category: 'shell',
+        description: 'Runs a command in a PTY, returning output or a session ID for ongoing interaction.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                cmd: { type: 'string', minLength: 1, description: 'Shell command to execute.' },
+                workdir: { type: 'string', description: 'Optional working directory to run the command in; defaults to the turn cwd.' },
+                shell: { type: 'string', description: "Shell binary to launch. Defaults to the user's default shell." },
+                login: { type: 'boolean', default: true, description: 'Whether to run the shell with -l/-i semantics. Defaults to true.' },
+                tty: { type: 'boolean', default: false, description: 'Whether to allocate a TTY for the command. Defaults to false.' },
+                yield_time_ms: { type: 'number', default: 10000, description: 'How long to wait in milliseconds for output before yielding.' },
+                max_output_tokens: { type: 'number', description: 'Maximum number of tokens to return. Excess output will be truncated.' },
+            },
+            required: ['cmd'],
+        },
+    },
+    {
+        name: 'apply_patch',
+        category: 'fileWrite',
+        description: 'Applies a create, update, move, or delete file patch in the sandbox workspace.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                patch: { type: 'string' },
+                operation: { type: 'object' },
+                operations: { type: 'array', items: { type: 'object' } },
+                command: { type: 'array', items: { type: 'string' } },
+                type: { type: 'string', enum: ['create_file', 'update_file', 'delete_file'] },
+                path: { type: 'string' },
+                diff: { type: 'string' },
+                moveTo: { type: 'string' },
+            },
+        },
+    },
+    {
+        name: 'view_image',
+        category: 'fileRead',
+        description: 'Returns an image output from a local path in the sandbox workspace.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Local filesystem path to an image file' },
+            },
+            required: ['path'],
+        },
+    },
+    {
+        name: 'load_skill',
+        description: 'Load a lazily configured skill into the sandbox workspace.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                skill_name: { type: 'string' },
+            },
+            required: ['skill_name'],
+        },
+    },
+]);
+class ConfiguredCapability extends Capability {
+    inner;
+    configureTools;
+    type;
+    constructor(inner, configureTools) {
+        super();
+        this.inner = inner;
+        this.configureTools = configureTools;
+        this.type = inner.type;
+    }
+    clone() {
+        return new ConfiguredCapability(this.inner.clone(), this.configureTools);
+    }
+    bind(session) {
+        this.inner.bind(session);
+        return this;
+    }
+    bindRunAs(runAs) {
+        this.inner.bindRunAs(runAs);
+        return this;
+    }
+    bindModel(model, modelInstance) {
+        this.inner.bindModel(model, modelInstance);
+        return this;
+    }
+    requiredCapabilityTypes() {
+        return this.inner.requiredCapabilityTypes();
+    }
+    tools() {
+        return this.configureTools(this.inner.tools());
+    }
+    processManifest(manifest) {
+        return this.inner.processManifest(manifest);
+    }
+    instructions(manifest) {
+        return this.inner.instructions(manifest);
+    }
+    samplingParams(samplingParams) {
+        return this.inner.samplingParams(samplingParams);
+    }
+    processContext(context) {
+        return this.inner.processContext(context);
+    }
+}
+class OpenAIAgentsStepController {
+    ctx;
+    currentStep;
+    nextStepNumber = 0;
+    needsResolve = true;
+    resolving;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    async prepareForModelCall() {
+        if (!this.needsResolve && this.currentStep) {
+            return this.currentStep;
+        }
+        if (this.resolving) {
+            return await this.resolving;
+        }
+        this.resolving = (async () => {
+            const stepNumber = this.nextStepNumber;
+            this.nextStepNumber += 1;
+            const resolved = await this.ctx.resolvePrepareStep?.(stepNumber);
+            this.currentStep = {
+                stepNumber,
+                activeTools: resolved?.activeTools ?? this.ctx.activeTools,
+                instructions: resolved?.instructions ?? this.ctx.instructions,
+                activeSkillNames: resolved?.activeSkillNames ?? this.ctx.activeSkills?.map((skill) => skill.name) ?? [],
+                forcedSkillNames: resolved?.forcedSkillNames ?? this.ctx.forcedSkills?.map((skill) => skill.name) ?? [],
+            };
+            this.needsResolve = false;
+            this.ctx.debugLogger?.log({
+                subsystem: 'adapter',
+                event: 'openai_agents.prepare_step',
+                level: 'debug',
+                attrs: {
+                    stepNumber,
+                    activeTools: this.currentStep.activeTools,
+                    activeSkillNames: this.currentStep.activeSkillNames,
+                    forcedSkillNames: this.currentStep.forcedSkillNames,
+                },
+            });
+            return this.currentStep;
+        })().finally(() => {
+            this.resolving = undefined;
+        });
+        return await this.resolving;
+    }
+    markModelCallPrepared() {
+        this.needsResolve = true;
+    }
+}
+function appendQueryParams(baseURL, queryParams) {
+    if (!baseURL || !queryParams || Object.keys(queryParams).length === 0) {
+        return baseURL;
+    }
+    const url = new URL(baseURL);
+    for (const [key, value] of Object.entries(queryParams)) {
+        url.searchParams.set(key, value);
+    }
+    return url.toString();
+}
+function resolveErrorProvider(options) {
+    const selected = selectConfiguredAuthBag(options?.auth, ['openaiCompatible', 'openai', 'gateway']);
+    if (selected === 'openaiCompatible')
+        return options?.auth?.openaiCompatible?.name ?? 'openai-compatible';
+    if (selected === 'openai')
+        return 'openai';
+    if (selected === 'gateway')
+        return 'ai-gateway';
+    return undefined;
+}
+function resolveOpenAIProviderBaseURL(options, env = process.env) {
+    const selected = selectConfiguredAuthBag(options?.auth, ['openaiCompatible', 'openai', 'gateway']);
+    if (selected === 'openaiCompatible') {
+        const auth = options?.auth?.openaiCompatible;
+        return appendQueryParams(auth?.baseURL ?? env.OPENAI_BASE_URL ?? DEFAULT_OPENAI_BASE_URL, auth?.queryParams) ?? DEFAULT_OPENAI_BASE_URL;
+    }
+    if (selected === 'gateway') {
+        const auth = options?.auth?.gateway;
+        return auth?.baseURL ?? env.AI_GATEWAY_BASE_URL ?? DEFAULT_GATEWAY_BASE_URL;
+    }
+    const auth = selected === 'openai' ? options?.auth?.openai : undefined;
+    return auth?.baseURL ?? env.OPENAI_BASE_URL ?? DEFAULT_OPENAI_BASE_URL;
+}
+function createOpenAIProvider(options, env = process.env, baseURLOverride) {
+    const selected = selectConfiguredAuthBag(options?.auth, ['openaiCompatible', 'openai', 'gateway']);
+    if (selected === 'openaiCompatible') {
+        const auth = options?.auth?.openaiCompatible;
+        return new OpenAIProvider({
+            apiKey: resolveSecretInput(auth?.apiKey, env) ?? env.OPENAI_API_KEY,
+            baseURL: baseURLOverride ?? appendQueryParams(auth?.baseURL ?? env.OPENAI_BASE_URL, auth?.queryParams),
+            useResponses: options?.useResponses,
+            cacheResponsesWebSocketModels: false,
+        });
+    }
+    if (selected === 'gateway') {
+        const auth = options?.auth?.gateway;
+        return new OpenAIProvider({
+            apiKey: resolveSecretInput(auth?.apiKey, env) ?? env.AI_GATEWAY_API_KEY,
+            baseURL: baseURLOverride ?? auth?.baseURL ?? env.AI_GATEWAY_BASE_URL ?? DEFAULT_GATEWAY_BASE_URL,
+            useResponses: options?.useResponses,
+            cacheResponsesWebSocketModels: false,
+        });
+    }
+    const auth = selected === 'openai' ? options?.auth?.openai : undefined;
+    return new OpenAIProvider({
+        apiKey: resolveSecretInput(auth?.apiKey, env) ?? env.OPENAI_API_KEY,
+        baseURL: baseURLOverride ?? auth?.baseURL ?? env.OPENAI_BASE_URL,
+        organization: auth?.organization ?? env.OPENAI_ORGANIZATION,
+        project: auth?.project ?? env.OPENAI_PROJECT,
+        useResponses: options?.useResponses,
+        cacheResponsesWebSocketModels: false,
+    });
+}
+function usageFromResponses(rawResponses) {
+    let inputTokens = 0;
+    let outputTokens = 0;
+    for (const response of rawResponses) {
+        inputTokens += response.usage.inputTokens;
+        outputTokens += response.usage.outputTokens;
+    }
+    return { inputTokens, outputTokens };
+}
+function finalOutputToText(output) {
+    if (output == null)
+        return '';
+    if (typeof output === 'string')
+        return output;
+    try {
+        return JSON.stringify(output, null, 2);
+    }
+    catch {
+        return String(output);
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function outputContentPartToText(part) {
+    if (!isRecord(part)) {
+        return '';
+    }
+    if ((part.type === 'output_text' || part.type === 'text') && typeof part.text === 'string') {
+        return part.text;
+    }
+    if (part.type === 'refusal' && typeof part.refusal === 'string') {
+        return part.refusal;
+    }
+    return '';
+}
+function outputItemToText(item) {
+    if (!isRecord(item)) {
+        return '';
+    }
+    if (item.type !== 'message' && item.role !== 'assistant') {
+        return outputContentPartToText(item);
+    }
+    if (typeof item.content === 'string') {
+        return item.content;
+    }
+    if (!Array.isArray(item.content)) {
+        return '';
+    }
+    return item.content.map(outputContentPartToText).join('');
+}
+function rawResponsesToText(rawResponses) {
+    return rawResponses.map((response) => response.output.map(outputItemToText).join('')).join('');
+}
+function runOutputToText(finalOutput, streamedText, rawResponses) {
+    return finalOutputToText(finalOutput) || streamedText || rawResponsesToText(rawResponses);
+}
+function wantsJsonOnlyFinalAnswer(message, instructions) {
+    return /return only json|raw json|json object|final answer must be only json|exactly one raw json/i.test([instructions, message].filter(Boolean).join('\n'));
+}
+function wantsReviewerMarkerOnlyFinalAnswer(message, instructions) {
+    return /reply with exactly the marker returned|final response must be exactly\s+`?REVIEWED-|respond with exactly\s+`?REVIEWED-/i.test([instructions, message].filter(Boolean).join('\n'));
+}
+function extractReviewerMarker(text) {
+    return text.match(/\bREVIEWED-[A-Z0-9-]+\b/)?.[0];
+}
+function normalizeJsonOnlyText(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return trimmed;
+    }
+    const start = trimmed.indexOf('{');
+    const end = trimmed.lastIndexOf('}');
+    if (start >= 0 && end > start) {
+        return trimmed.slice(start, end + 1);
+    }
+    return trimmed;
+}
+function normalizeReviewerMarkerOnlyText(text) {
+    return extractReviewerMarker(text) ?? text.trim();
+}
+function createSkillsCapability(ctx, options) {
+    const skillDescriptors = (ctx.skills ?? ctx.activeSkills ?? []).map((skillDefinition) => ({
+        name: skillDefinition.name,
+        description: skillDefinition.description,
+        content: skillDefinition.content,
+    }));
+    if (skillDescriptors.length === 0) {
+        return undefined;
+    }
+    if (options?.skills?.loading === 'eager') {
+        return skills({ skills: skillDescriptors });
+    }
+    return skills({
+        lazyFrom: {
+            source: dir({
+                children: Object.fromEntries(skillDescriptors.map((skillDescriptor) => [
+                    skillDescriptor.name,
+                    dir({
+                        children: {
+                            'SKILL.md': file({ content: skillDescriptor.content }),
+                        },
+                        description: skillDescriptor.description,
+                    }),
+                ])),
+            }),
+            index: skillDescriptors.map((skillDescriptor) => ({
+                name: skillDescriptor.name,
+                description: skillDescriptor.description,
+            })),
+        },
+    });
+}
+function withStepToolFilter(toolToFilter, stepController, extraAllowedTools) {
+    if (toolToFilter.type !== 'function') {
+        return toolToFilter;
+    }
+    const functionTool = toolToFilter;
+    const originalIsEnabled = functionTool.isEnabled;
+    return {
+        ...functionTool,
+        isEnabled: async (runContext, agent) => {
+            const step = await stepController.prepareForModelCall();
+            if (!isToolAllowedFromResolvedList(functionTool.name, step.activeTools) || !isToolAllowedFromResolvedList(functionTool.name, extraAllowedTools)) {
+                return false;
+            }
+            return await originalIsEnabled(runContext, agent);
+        },
+    };
+}
+function createCapabilities(ctx, bridge, stepController, options, extraAllowedTools) {
+    const wrapTools = (toolsToWrap) => bridge.wrapBuiltinTools(toolsToWrap).map((toolToWrap) => withStepToolFilter(toolToWrap, stepController, extraAllowedTools));
+    const capabilities = [filesystem({ configureTools: wrapTools }), shell({ configureTools: wrapTools }), compaction()];
+    const skillsCapability = createSkillsCapability(ctx, options);
+    if (skillsCapability) {
+        capabilities.push(new ConfiguredCapability(skillsCapability, wrapTools));
+    }
+    return capabilities;
+}
+function isToolAllowedFromResolvedList(toolName, allowed) {
+    return allowed === undefined ? true : allowed.length > 0 && isToolAllowed(toolName, allowed);
+}
+function filterToolSchemasForActiveTools(toolSchemas, activeTools) {
+    return activeTools === undefined ? toolSchemas : toolSchemas.filter((schema) => isToolAllowedFromResolvedList(schema.name, activeTools));
+}
+function expandSubagentToolName(toolName) {
+    switch (toolName) {
+        case 'bash':
+        case 'read':
+        case 'shell':
+            return ['exec_command'];
+        case 'edit':
+        case 'write':
+            return ['apply_patch'];
+        default:
+            return [toolName];
+    }
+}
+function resolveSubagentActiveTools(ctx, definition) {
+    if (!definition.tools?.length) {
+        return ctx.activeTools;
+    }
+    const knownToolNames = [...OPENAI_AGENTS_BUILTIN_TOOLS.map((schema) => schema.name), ...ctx.registeredTools.map((schema) => schema.name)];
+    const requestedTools = new Set(definition.tools.flatMap(expandSubagentToolName));
+    return knownToolNames.filter((toolName) => isToolAllowedFromResolvedList(toolName, ctx.activeTools) && requestedTools.has(toolName));
+}
+function createDelegateToolDescription(agents) {
+    return [
+        'Delegate a focused task to a specialized subagent in the same sandbox workspace.',
+        ...Object.entries(agents).map(([name, definition]) => `- ${name}: ${definition.description}`),
+    ].join('\n');
+}
+function parseDelegateTaskInput(input) {
+    let value = input;
+    if (typeof input === 'string') {
+        value = parseJsonOrString(input);
+    }
+    if (!value || typeof value !== 'object') {
+        return {};
+    }
+    return delegateTaskInputSchema.parse(value);
+}
+function createStepCallModelInputFilter(stepController) {
+    return async ({ modelData }) => {
+        await stepController.prepareForModelCall();
+        stepController.markModelCallPrepared();
+        return modelData;
+    };
+}
+function createRunner(provider, ctx, options) {
+    return new Runner({
+        modelProvider: provider,
+        tracingDisabled: options?.tracing?.disabled ?? ctx.agentTelemetry !== 'allow',
+        traceIncludeSensitiveData: options?.tracing?.includeSensitiveData ?? ctx.agentTelemetry === 'allow',
+        workflowName: 'OpenAI Agents sandbox workflow',
+    });
+}
+function createAgent(args) {
+    const { ctx, runtime, stepController, options, allowDelegation = true, name, instructions, model, extraAllowedTools } = args;
+    const userTools = runtime.toolBridge.createUserTools(filterToolSchemasForActiveTools(ctx.registeredTools, extraAllowedTools));
+    const delegateTool = allowDelegation ? createDelegateTaskTool(ctx, runtime, stepController, options) : undefined;
+    return new SandboxAgent({
+        name: name ?? options?.name ?? 'OpenAI Sandbox Agent',
+        ...((model ?? options?.model) ? { model: model ?? options?.model } : {}),
+        ...(options?.modelSettings ? { modelSettings: options.modelSettings } : {}),
+        instructions: async () => {
+            const step = await stepController.prepareForModelCall();
+            return [options?.instructions, instructions, step.instructions ?? ctx.instructions].filter(Boolean).join('\n\n');
+        },
+        capabilities: createCapabilities(ctx, runtime.toolBridge, stepController, options, extraAllowedTools),
+        tools: delegateTool ? [delegateTool, ...userTools] : userTools,
+    });
+}
+function createDelegateTaskTool(ctx, runtime, parentStepController, options) {
+    if (!ctx.agents || Object.keys(ctx.agents).length === 0) {
+        return undefined;
+    }
+    const agentNames = Object.keys(ctx.agents);
+    return tool({
+        name: 'delegate_task',
+        description: createDelegateToolDescription(ctx.agents),
+        parameters: {
+            type: 'object',
+            properties: {
+                agent: { type: 'string', enum: agentNames, description: 'Subagent to run.' },
+                task: { type: 'string', minLength: 1, description: 'Focused task for the delegated subagent.' },
+            },
+            required: ['agent', 'task'],
+            additionalProperties: false,
+        },
+        strict: false,
+        execute: async (input, _runContext, details) => {
+            const parsed = parseDelegateTaskInput(input);
+            const agentName = parsed.agent ?? '';
+            const task = parsed.task ?? '';
+            const definition = ctx.agents?.[agentName];
+            if (!definition || !task) {
+                throw new Error(`Unknown or invalid subagent delegation request: ${agentName || '<missing>'}`);
+            }
+            await parentStepController.prepareForModelCall();
+            const requestId = randomUUID();
+            const parentToolCallId = details?.toolCall?.callId ?? `delegate_task_${requestId}`;
+            ctx.emit(protocolMessage.toolCall({ requestId, toolName: 'delegate_task', toolCallId: parentToolCallId, input: { agent: agentName, task }, observeOnly: true }));
+            ctx.emit(protocolMessage.subagentStart({ agentName, parentToolCallId }));
+            let usage;
+            let output;
+            try {
+                const activeTools = resolveSubagentActiveTools(ctx, definition);
+                const childCtx = {
+                    ...ctx,
+                    instructions: definition.prompt,
+                    activeTools,
+                    registeredTools: filterToolSchemasForActiveTools(ctx.registeredTools, activeTools),
+                    agents: undefined,
+                    resolvePrepareStep: undefined,
+                };
+                const childStepController = new OpenAIAgentsStepController(childCtx);
+                const childAgent = createAgent({
+                    ctx: childCtx,
+                    runtime,
+                    stepController: childStepController,
+                    options,
+                    allowDelegation: false,
+                    name: agentName,
+                    instructions: definition.prompt,
+                    model: definition.model,
+                    extraAllowedTools: activeTools,
+                });
+                const result = await runtime.runner.run(childAgent, task, {
+                    maxTurns: definition.maxTurns ?? options?.maxTurns,
+                    stream: true,
+                    sandbox: { session: runtime.session },
+                    signal: runtime.abortController?.signal,
+                    callModelInputFilter: createStepCallModelInputFilter(childStepController),
+                });
+                let streamedText = '';
+                for await (const chunk of result.toTextStream({ compatibleWithNodeStreams: true })) {
+                    streamedText += typeof chunk === 'string' ? chunk : chunk.toString();
+                    // Subagent text is returned as the delegate_task tool result, not streamed as parent text.
+                }
+                await result.completed;
+                usage = usageFromResponses(result.rawResponses);
+                output = { agent: agentName, text: runOutputToText(result.finalOutput, streamedText, result.rawResponses) };
+                return output;
+            }
+            finally {
+                ctx.emit(protocolMessage.subagentFinish({ agentName, parentToolCallId, ...(output !== undefined ? { output } : {}), ...(usage ? { usage } : {}) }));
+                ctx.emit(protocolMessage.toolResult({
+                    toolName: 'delegate_task',
+                    toolCallId: parentToolCallId,
+                    output: output ?? { agent: agentName, error: 'Subagent did not complete.' },
+                }));
+            }
+        },
+    });
+}
+function createPromptInput(history, message) {
+    if (!history) {
+        return message;
+    }
+    return [
+        ...history,
+        {
+            role: 'user',
+            content: message,
+        },
+    ];
+}
+export function openaiAgents(options) {
+    let runtime = null;
+    let importedState = {};
+    const sandboxSetup = getOpenAIAgentsSandboxSetup();
+    const sandboxImageName = getSandboxImageName('openai-agents', sandboxSetup);
+    function attachRuntimeContext(ctx, currentRuntime) {
+        attachSplitSandboxContext(currentRuntime.splitSandbox, ctx);
+        currentRuntime.toolBridge.attachContext(ctx);
+        ctx.abort = () => {
+            currentRuntime.abortController?.abort();
+        };
+    }
+    return {
+        name: 'openai-agents',
+        supportsToolInterception: true,
+        supportsHostAccessRequests: true,
+        prepareStepSupport: 'step',
+        adapterStateSchema: openAIAgentsAdapterStateSchema,
+        builtinTools: OPENAI_AGENTS_BUILTIN_TOOLS,
+        permissionToolCategories: OPENAI_AGENTS_PERMISSION_TOOL_CATEGORIES,
+        defaultContextWindow: DEFAULT_CONTEXT_WINDOW,
+        normalizeError(error) {
+            return normalizeAdapterError(error, {
+                adapter: 'openai-agents',
+                provider: resolveErrorProvider(options),
+                model: options?.model,
+            });
+        },
+        getBridgeFiles: () => [],
+        getSandboxFiles: (ctx) => sandboxSetup.getSandboxFiles(ctx),
+        resolveSandboxConfig: (sandboxConfig) => withVercelSandboxBackend(sandboxConfig),
+        exportAdapterState() {
+            return runtime?.history ? { history: runtime.history } : importedState;
+        },
+        importAdapterState(state) {
+            importedState = parseOpenAIAgentsAdapterState(state);
+        },
+        async start(ctx) {
+            const sandboxConfig = withVercelSandboxBackend(ctx.sandboxConfig);
+            const { workDir } = getSandboxRuntimeLayout('openai-agents', ctx.sessionId, sandboxConfig);
+            let splitSandbox;
+            let replayProxy;
+            let provider;
+            try {
+                splitSandbox = await startSplitSandbox(ctx, {
+                    adapterName: 'openai-agents',
+                    sessionId: ctx.sessionId,
+                    imageName: sandboxImageName,
+                    sandboxConfig,
+                    sandboxFiles: createInitialSandboxFiles(workDir, ctx.files),
+                    rewriteFilesOnResume: true,
+                });
+                if (sandboxConfig?.httpHandler) {
+                    replayProxy = await createOpenAIAgentsReplayProxy(sandboxConfig.httpHandler, resolveOpenAIProviderBaseURL(options));
+                }
+                provider = createOpenAIProvider(options, process.env, replayProxy?.baseURL);
+                const runner = createRunner(provider, ctx, options);
+                const toolBridge = new OpenAIAgentsToolBridge(ctx);
+                const session = new OpenAISplitSandboxSession(splitSandbox, {
+                    ctx,
+                    requestBuiltinApproval: (toolName, input, toolCallId) => toolBridge.requestBuiltinApproval(toolName, input, toolCallId),
+                });
+                runtime = {
+                    splitSandbox,
+                    provider,
+                    replayProxy,
+                    runner,
+                    toolBridge,
+                    session,
+                    history: importedState.history,
+                };
+                attachRuntimeContext(ctx, runtime);
+            }
+            catch (error) {
+                await provider?.close().catch(() => { });
+                await replayProxy?.close().catch(() => { });
+                if (splitSandbox) {
+                    await stopSplitSandbox(splitSandbox).catch(() => { });
+                }
+                throw error;
+            }
+        },
+        async prompt(message, ctx) {
+            if (!runtime) {
+                throw new Error('OpenAI Agents adapter not started');
+            }
+            const currentRuntime = runtime;
+            attachRuntimeContext(ctx, currentRuntime);
+            const abortController = new AbortController();
+            currentRuntime.abortController = abortController;
+            const stepController = new OpenAIAgentsStepController(ctx);
+            const agent = createAgent({ ctx, runtime: currentRuntime, stepController, options });
+            const bufferJsonOnlyText = wantsJsonOnlyFinalAnswer(message, ctx.instructions);
+            const bufferReviewerMarkerOnlyText = !bufferJsonOnlyText && wantsReviewerMarkerOnlyFinalAnswer(message, ctx.instructions);
+            const runToCompletion = (async () => {
+                const result = await currentRuntime.runner.run(agent, createPromptInput(currentRuntime.history, message), {
+                    maxTurns: options?.maxTurns,
+                    signal: abortController.signal,
+                    stream: true,
+                    sandbox: { session: currentRuntime.session },
+                    callModelInputFilter: createStepCallModelInputFilter(stepController),
+                });
+                let emittedText = false;
+                let streamedText = '';
+                for await (const chunk of result.toTextStream({ compatibleWithNodeStreams: true })) {
+                    const delta = typeof chunk === 'string' ? chunk : chunk.toString();
+                    if (delta) {
+                        emittedText = true;
+                        streamedText += delta;
+                        if (!bufferJsonOnlyText && !bufferReviewerMarkerOnlyText) {
+                            ctx.emit(protocolMessage.textDelta({ delta }));
+                        }
+                    }
+                }
+                await result.completed;
+                if (result.cancelled || result.error) {
+                    throw result.error ?? abortController.signal.reason ?? new Error('OpenAI Agents run cancelled');
+                }
+                currentRuntime.history = result.history;
+                const text = runOutputToText(result.finalOutput, streamedText, result.rawResponses);
+                const finalText = bufferJsonOnlyText
+                    ? normalizeJsonOnlyText(text || streamedText)
+                    : bufferReviewerMarkerOnlyText
+                        ? normalizeReviewerMarkerOnlyText(text || streamedText)
+                        : text;
+                if ((bufferJsonOnlyText || bufferReviewerMarkerOnlyText || !emittedText) && finalText) {
+                    ctx.emit(protocolMessage.textDelta({ delta: finalText }));
+                }
+                ctx.emit(protocolMessage.finish({ finishReason: result.interruptions.length > 0 ? 'tool-calls' : 'stop', usage: usageFromResponses(result.rawResponses) }));
+            })()
+                .catch((error) => {
+                ctx.emit(protocolMessage.error({ message: error instanceof Error ? error.message : String(error) }));
+            })
+                .finally(() => {
+                if (currentRuntime.abortController === abortController) {
+                    currentRuntime.abortController = undefined;
+                }
+            });
+            const outcome = await Promise.race([
+                runToCompletion.then(() => 'completed'),
+                currentRuntime.toolBridge.waitForHostContinuation().then(() => 'paused'),
+            ]);
+            if (outcome === 'completed') {
+                currentRuntime.toolBridge.clearHostContinuationWaiters();
+                await runToCompletion;
+            }
+        },
+        async registerTools(tools, ctx) {
+            ctx.registeredTools = tools;
+        },
+        async stop() {
+            if (!runtime) {
+                return;
+            }
+            runtime.toolBridge.settlePending('adapter-stopped');
+            const current = runtime;
+            runtime = null;
+            try {
+                await current.provider.close();
+            }
+            finally {
+                try {
+                    await current.replayProxy?.close();
+                }
+                finally {
+                    await stopSplitSandbox(current.splitSandbox);
+                }
+            }
+        },
+        async detach() {
+            if (!runtime) {
+                return;
+            }
+            runtime.toolBridge.settlePending('adapter-detached');
+            const current = runtime;
+            runtime = null;
+            detachSplitSandbox(current.splitSandbox);
+            try {
+                await current.provider.close();
+            }
+            finally {
+                await current.replayProxy?.close();
+            }
+        },
+    };
+}
+//# sourceMappingURL=adapter.js.map