@salesforce/sfdx-agent-harness-openai 0.0.1

package/dist/openai-agents-harness.js

@@ -0,0 +1,1014 @@
+/*
+ * Copyright 2026, Salesforce, Inc. All rights reserved.
+ * See LICENSE.txt for license terms.
+ */
+import { backfillCreatedAt, buildSummaryPrompt, getErrorMessage, isAbortError, RealClock, UUIDGenerator, } from '@salesforce/agentic-common';
+import { Agent, Runner } from '@openai/agents';
+import { AgentSDKError, AgentSDKErrorType, mcpServerConfigEqual, McpServerStatus, resolveToolApprovalPolicy, } from '@salesforce/sfdx-agent-sdk';
+import { HarnessBusOwner, SUPPORTED_PROTOCOL_VERSIONS } from '@salesforce/sfdx-agent-sdk/harness';
+import { OpenAIApprovalCoordinator } from './openai-approval-coordinator.js';
+import { OPENAI_BUILT_IN_TOOL_POLICIES } from './openai-built-in-policies.js';
+import { buildMcpErrorDetail, sanitizeMcpErrorMessage } from './mcp-error-classifier.js';
+import { hasEnabledServers, mapToOpenAIMcpServers } from './openai-mcp-config-mapper.js';
+import { MAX_TRANSCRIPT_CHARS, messagesToRecords, partToTranscriptText, recordsToMessages, splitIntoChunks, } from './openai-message-mapper.js';
+import { buildOpenAIModelProvider } from './openai-model-provider.js';
+import { OpenAISessionStore } from './openai-session-store.js';
+import { ConsumerToolRegistry, mapConsumerTools } from './openai-tool-mapper.js';
+import { buildRedactedMcpTools } from './openai-tool-redaction.js';
+/**
+ * OpenAI Agents SDK-backed implementation of the SDK's `AgentHarness` contract.
+ *
+ * Implements connectivity, streamed turns, disk-backed sessions, thread
+ * lifecycle, message history (with `createdAt`/`isError` persistence), tool
+ * approval (`approveToolCall` / `declineToolCall`), consumer-executed tools
+ * (`submitToolResult`), MCP server lifecycle (`getMcpServerInfo` /
+ * `reconnectMcpServer` / `updateAgent` preservation), and thread compaction
+ * (`compactThread`). A per-`(agentId, threadId)` {@link OpenAIApprovalCoordinator}
+ * owns each turn's run loop, the approval suspend/resume flow, the opt-in policy
+ * gate, the per-`toolCallId` timeout, and the consumer-tool parker.
+ *
+ * MCP tools attach via the SDK's native `Agent({ mcpServers })` path and are
+ * observable (`tool-call` / `tool-result`, enriched with `serverName` /
+ * `bareToolName`) but are NOT approval-gated this milestone — the native attach
+ * exposes no per-tool `needsApproval` hook, so gating is a deferred follow-up.
+ * MCP discovery/status telemetry and wire-communication events emit on their
+ * respective seams, and the `options.hooks.onToolResult` redaction hook fires
+ * per tool result (consumer tools at the parked `execute`; MCP tools via a
+ * `getAllMcpTools` materialize-and-wrap when a redactor is set). Every
+ * agent-scoped method throws `AGENT_NOT_FOUND` on an unregistered id first (SDK
+ * invariant).
+ */
+export class OpenAIAgentsHarness {
+    storageRootFolder;
+    harnessId = 'openai-agents';
+    protocolVersion = SUPPORTED_PROTOCOL_VERSIONS[0];
+    extensions = {};
+    buses = new HarnessBusOwner();
+    agents = new Map();
+    idGenerator;
+    clock;
+    innerFetch;
+    modelProviderFactory;
+    mcpServerFactory;
+    sessions;
+    toolApprovalTimeoutMs;
+    shuttingDown = false;
+    constructor(storageRootFolder, options = {}) {
+        this.storageRootFolder = storageRootFolder;
+        this.innerFetch = options.innerFetch;
+        this.idGenerator = options.idGenerator ?? new UUIDGenerator();
+        this.clock = options.clock ?? new RealClock();
+        this.modelProviderFactory =
+            options.modelProviderFactory ??
+                ((getInfo) => buildOpenAIModelProvider({
+                    getInfo,
+                    innerFetch: this.innerFetch,
+                    // The wire seam emits one request/response pair per outbound
+                    // HTTP call onto the harness's wire bus. The emitter swallows
+                    // the typed DISPOSED error a late emit during shutdown would
+                    // hit, so a trace hook never fails the underlying fetch.
+                    wireHooks: {
+                        emitWireCommunication: (event) => {
+                            try {
+                                this.buses.emitWireCommunication(event);
+                            }
+                            catch (error) {
+                                if (!isDisposedError(error))
+                                    throw error;
+                            }
+                        },
+                        clock: this.clock,
+                    },
+                }));
+        this.mcpServerFactory =
+            options.mcpServerFactory ?? ((config, orgJwt) => mapToOpenAIMcpServers(config, orgJwt, this.innerFetch));
+        this.sessions = new OpenAISessionStore(this.storageRootFolder, this.buses.getLogBus(), this.clock);
+        this.toolApprovalTimeoutMs = options.toolApprovalTimeoutMs;
+    }
+    // ── Telemetry / Log / Wire Subscription ──────────────────────────────
+    onTelemetry(callback) {
+        return this.buses.onTelemetry(callback);
+    }
+    onLog(callback) {
+        return this.buses.onLog(callback);
+    }
+    onWireCommunication(callback) {
+        return this.buses.onWireCommunication(callback);
+    }
+    async shutdown() {
+        if (this.shuttingDown)
+            return;
+        this.shuttingDown = true;
+        // Tear down every in-flight turn so a disposed harness leaves no pump
+        // running against a torn-down agent, and each consumer stream sees its
+        // terminal `error` + `finish('error')` pair.
+        for (const state of this.agents.values()) {
+            for (const coordinator of state.coordinators.values())
+                coordinator.dispose();
+            state.coordinators.clear();
+        }
+        // Close every MCP server so a disposed harness leaves no live transport /
+        // subprocess. Await discovery first so close can't race an in-flight
+        // connect; all closes settle before the registry is cleared.
+        await Promise.allSettled([...this.agents.values()].map((state) => this.closeMcpServers(state)));
+        this.agents.clear();
+        this.buses.dispose();
+    }
+    // ── Agent Lifecycle ──────────────────────────────────────────────────
+    async createAgent(agentId, projectRoot, modelConnectivityInfo, config, options) {
+        if (this.agents.has(agentId)) {
+            throw new Error(`Agent with id "${agentId}" is already registered`);
+        }
+        const state = {
+            projectRoot,
+            config: config ?? {},
+            modelConnectivityInfo,
+            hooks: options?.hooks ?? {},
+            // The provider reads the live bag on every `getModel()` so a
+            // within-shape modelId swap / JWT rotation lands without a rebuild.
+            modelProvider: this.modelProviderFactory(() => this.getAgentOrThrow(agentId).modelConnectivityInfo),
+            threads: new Set(),
+            coordinators: new Map(),
+            mcpServers: new Map(),
+            mcpConfig: config?.mcpServers,
+            mcpCatalog: new Map(),
+        };
+        this.agents.set(agentId, state);
+        // Construct + connect + discover the agent's MCP servers. Non-blocking:
+        // each server's discovery runs in the background (its promise parked on
+        // `entry.ready`) and a failure is recorded on per-server state rather
+        // than failing `createAgent` — the same soft-skip posture the thread
+        // rehydrate below uses.
+        this.startMcpServers(agentId, state, config?.mcpServers, options?.abortSignal);
+        // Rehydrate threads persisted under a prior harness instance so
+        // `getThreadIds` + history survive a restart and the SDK's boot-time
+        // restore path reattaches every session (mirrors Claude's rehydrate).
+        // A discovery failure is non-fatal — an agent with an unreadable
+        // sessions dir comes up with no threads rather than failing createAgent,
+        // matching the SDK's soft-skip posture on persisted state.
+        try {
+            for (const threadId of await this.sessions.listThreadIds(agentId)) {
+                state.threads.add(threadId);
+            }
+        }
+        catch (error) {
+            this.buses.getLogBus()?.warn('Failed to rehydrate OpenAI harness threads', {
+                agentId,
+                error: getErrorMessage(error),
+            });
+        }
+    }
+    async destroyAgent(agentId) {
+        const state = this.getAgentOrThrow(agentId);
+        // Tear down every in-flight turn on this agent before dropping it.
+        for (const coordinator of state.coordinators.values())
+            coordinator.dispose();
+        state.coordinators.clear();
+        // Close every MCP server (await discovery first so close can't race an
+        // in-flight connect) so a destroyed agent leaves no live transport.
+        await this.closeMcpServers(state);
+        // Best-effort delete every persisted thread so a destroyed agent leaves
+        // no orphan session files. A delete failure does not block the registry
+        // removal — the agent id is gone either way.
+        await Promise.allSettled([...state.threads].map((threadId) => this.sessions.delete(agentId, threadId)));
+        return this.agents.delete(agentId);
+    }
+    async getAgentIds() {
+        return [...this.agents.keys()];
+    }
+    // ── Thread Lifecycle ─────────────────────────────────────────────────
+    async createThread(agentId, threadId) {
+        const state = this.getAgentOrThrow(agentId);
+        const id = threadId ?? this.idGenerator.getUniqueId();
+        state.threads.add(id);
+        return id;
+    }
+    async getThreadIds(agentId) {
+        const state = this.getAgentOrThrow(agentId);
+        return [...state.threads];
+    }
+    async destroyThread(agentId, threadId) {
+        const state = this.getAgentOrThrow(agentId);
+        // Cancel an in-flight turn on this thread before deleting its history.
+        state.coordinators.get(threadId)?.dispose();
+        state.coordinators.delete(threadId);
+        state.threads.delete(threadId);
+        await this.sessions.delete(agentId, threadId);
+    }
+    async cloneThread(agentId, sourceThreadId) {
+        const state = this.getAgentOrThrow(agentId);
+        const newId = this.idGenerator.getUniqueId();
+        // Copy the source's persisted records verbatim (item + createdAt +
+        // isError) into a fresh thread. The OpenAI SDK has no `forkSession`
+        // primitive, so the harness copies the transcript itself — a
+        // never-streamed source yields an empty clone (no records to copy),
+        // matching the contract's two source-state shapes.
+        const records = await this.sessions.getRecords(agentId, sourceThreadId);
+        await this.sessions.appendRecords(agentId, newId, records);
+        state.threads.add(newId);
+        return newId;
+    }
+    // ── Core Messaging ───────────────────────────────────────────────────
+    async stream(agentId, threadId, message, options) {
+        const state = this.getAgentOrThrow(agentId);
+        const abortSignal = options?.abortSignal;
+        abortSignal?.throwIfAborted();
+        // A `stream()` on a thread the harness hasn't seen registers it — the
+        // SDK creates threads via `createThread`, but a direct `stream()` on a
+        // fresh id must still persist under that thread rather than silently
+        // dropping history.
+        state.threads.add(threadId);
+        const input = lowerMessageToText(message);
+        // The disk-backed Session the runner reads history from and appends new
+        // items to. Passing it to `run(..., { session })` is what makes the turn
+        // multi-turn-aware and persistent (the runner owns the write).
+        const session = this.sessions.session(agentId, threadId);
+        // The per-tool approval decider the coordinator consults to route each
+        // interruption, or `undefined` when gating is off for this turn (the
+        // SDK's "no policy ⇒ no gating" back-compat path). Frozen at stream start;
+        // the closure reads `state.config` live per call so a mid-turn
+        // `updateAgentConfig` ("Allow always") is honored. Note: no tool the
+        // harness registers today carries a `needsApproval` predicate — MCP tools
+        // attach via the SDK's native path, which exposes no per-tool
+        // `needsApproval` hook, so they are NOT approval-gated this milestone
+        // (gating is a deferred follow-up). This decider is therefore dormant in
+        // production, though the coordinator plumbing it drives is exercised by
+        // the coordinator unit tests.
+        const policy = this.buildPolicyGate(state);
+        // The tool-result redaction context, or `undefined` when the agent has no
+        // `onToolResult` hook (both redaction seams then take their zero-cost
+        // pass-through path). Built here — not per tool — so `threadId` is stable
+        // across approval resumes, and the live `mcpCatalog` supplies `serverName`
+        // for MCP tools.
+        const redaction = state.hooks.onToolResult !== undefined
+            ? { redactor: state.hooks.onToolResult, agentId, threadId, mcpCatalog: state.mcpCatalog }
+            : undefined;
+        // Consumer-executed tools (declared in `config.tools`, no `execute`): the
+        // model can call them, but the harness never runs them — each mapped
+        // tool's `execute` parks on this per-turn registry, and the consumer
+        // resolves it out-of-band via `submitToolResult`. `undefined` when the
+        // agent declares none, so a plain turn allocates nothing extra.
+        const consumerToolDefs = state.config.tools ?? [];
+        const consumerTools = consumerToolDefs.length > 0
+            ? new ConsumerToolRegistry(new Set(consumerToolDefs.map((t) => t.name)))
+            : undefined;
+        const tools = consumerTools ? mapConsumerTools(consumerToolDefs, consumerTools, redaction) : [];
+        const { agent, runner } = await this.buildAgent(agentId, state, tools, redaction);
+        // One coordinator owns this turn's run stream + sink + teardown. Dispose
+        // any prior coordinator on the same thread first so a re-`stream()`
+        // mid-turn can't leave a stale pump running against the old sink.
+        state.coordinators.get(threadId)?.dispose();
+        const coordinator = new OpenAIApprovalCoordinator({
+            runner,
+            agent,
+            input,
+            session,
+            policy,
+            consumerTools,
+            onConsumerToolErrors: (toolCallIds) => {
+                // Stamp `isError` onto the persisted `function_call_result`
+                // records for consumer tools the consumer settled with an error —
+                // the run loop wrote them without it (the OpenAI item shape has no
+                // `isError` field). Best-effort: a persistence failure here must
+                // not fail the settled turn, and the store's per-thread queue
+                // orders this after the run's writes.
+                void this.sessions.markToolResultError(agentId, threadId, toolCallIds).catch((error) => this.buses.getLogBus()?.warn('Failed to persist consumer-tool isError', {
+                    agentId,
+                    threadId,
+                    error: getErrorMessage(error),
+                }));
+            },
+            onSettled: () => {
+                // The coordinator removes its own entry when the turn settles —
+                // guard against a newer turn having already replaced it.
+                if (state.coordinators.get(threadId) === coordinator)
+                    state.coordinators.delete(threadId);
+            },
+            externalSignal: abortSignal,
+            // Live catalog reference so a mid-turn discovery settle enriches
+            // later MCP tool events; empty when the agent has no MCP servers.
+            mcpCatalog: state.mcpCatalog,
+            // Factory-configured per-`toolCallId` approval timeout; the
+            // coordinator falls back to its own default when undefined.
+            toolApprovalTimeoutMs: this.toolApprovalTimeoutMs,
+            // The turn's step limit → `run(..., { maxTurns })`. Undefined leaves
+            // the SDK default in place; a hit surfaces as `finish('max-steps')`.
+            maxTurns: options?.maxSteps,
+        });
+        state.coordinators.set(threadId, coordinator);
+        return coordinator.start();
+    }
+    // ── Message History ──────────────────────────────────────────────────
+    async getMessages(agentId, threadId) {
+        this.getAgentOrThrow(agentId);
+        const records = await this.sessions.getRecords(agentId, threadId);
+        // `recordsToMessages` maps each flat item to a Message and runs the
+        // shared `splitToolResultsIntoToolMessages` normalizer for the canonical
+        // #647 layout; sort ascending by `createdAt` afterwards (the #464
+        // read contract). The normalizer inherits each source message's
+        // `createdAt`, so a hoisted `role:'tool'` message sorts at-or-after its
+        // originating assistant call under the stable sort.
+        const messages = recordsToMessages(records);
+        messages.sort((a, b) => (a.createdAt?.getTime() ?? 0) - (b.createdAt?.getTime() ?? 0));
+        return messages;
+    }
+    async clearMessages(agentId, threadId) {
+        this.getAgentOrThrow(agentId);
+        // Clearing leaves the session id reusable, so the thread stays live with
+        // empty history — no id rotation is needed and the thread id stays in
+        // `state.threads`.
+        await this.sessions.clear(agentId, threadId);
+    }
+    async addContext(agentId, threadId, messages) {
+        const state = this.getAgentOrThrow(agentId);
+        state.threads.add(threadId);
+        // Backfill `createdAt` on any message missing it (per-position
+        // `nextAfter` so a bulk insert is strictly ascending) BEFORE lowering to
+        // records, so the persisted `createdAt` drives the `getMessages` sort.
+        // Defensively backfill at the harness boundary too — a direct
+        // `harness.addContext` bypassing the SDK still yields sortable records.
+        const filled = backfillCreatedAt(messages, this.clock);
+        await this.sessions.appendRecords(agentId, threadId, messagesToRecords(filled));
+    }
+    // ── Agent Update (#541 MCP preservation) ─────────────────────────────
+    /**
+     * Apply a new connectivity bag + config to a live agent, preserving any MCP
+     * client whose config is structurally unchanged (#541) and cycling only the
+     * changed/added/removed servers. No eager `Agent` rebuild is needed: this
+     * harness constructs a fresh `Agent` on every `stream()` (see
+     * {@link buildAgent}) reading `state.config` / `state.modelConnectivityInfo`
+     * / `state.mcpServers` live, so mutating state here is sufficient — the next
+     * turn picks up the change. Does NOT dispose in-flight coordinators, touch
+     * sessions, or persist (persistence is the SDK's responsibility).
+     */
+    async updateAgent(agentId, modelConnectivityInfo, config, options) {
+        const state = this.getAgentOrThrow(agentId);
+        options?.abortSignal?.throwIfAborted();
+        // Phase 0 — validate non-MCP inputs BEFORE touching any MCP client, so a
+        // bad input can't leave servers half-cycled. This harness has no
+        // rules/skills/workspace to load (unlike Mastra), and `instructions` is a
+        // plain string, so there is nothing to validate today — the phase is a
+        // deliberate no-op. Kept as an explicit ordering anchor so a future
+        // non-MCP validation lands here, before Phase 1.
+        // Phase 1 — diff the next MCP config against the applied one, preserving
+        // structurally-equal servers and cycling the rest. Per-server Map
+        // mutations are synchronous so a re-entrant rollback `updateAgent`
+        // (SDK-driven, against the previous config) sees current truth.
+        const next = config?.mcpServers ?? {};
+        this.diffMcpServers(agentId, state, next, config?.orgJwt, options?.abortSignal);
+        // Phase 2 — apply non-MCP changes. The model provider closure and
+        // `buildAgent` both read these live, so no provider/agent rebuild is
+        // required; `hooks` is re-stamped for the next turn's tool-result seam.
+        state.config = config ?? {};
+        state.mcpConfig = config?.mcpServers;
+        state.modelConnectivityInfo = modelConnectivityInfo;
+        state.hooks = options?.hooks ?? {};
+    }
+    // ── MCP Introspection / Reconnect ────────────────────────────────────
+    /**
+     * Synchronous snapshot of the agent's MCP servers: connected servers with
+     * their discovered tools, errored servers with a sanitized message +
+     * structured `errorDetail`, in-flight servers as `Connecting` /
+     * `Reconnecting`, and configured-but-disabled servers (never constructed) as
+     * `Disabled`. Status is updated asynchronously by background discovery, so a
+     * caller polls this to observe a `createAgent` / `reconnectMcpServer` result.
+     */
+    getMcpServerInfo(agentId) {
+        const state = this.getAgentOrThrow(agentId);
+        const results = [];
+        for (const [name, server] of state.mcpServers) {
+            if (server.status === McpServerStatus.Connected) {
+                results.push({ name, status: server.status, tools: server.tools });
+            }
+            else if (server.status === McpServerStatus.Error) {
+                results.push({
+                    name,
+                    status: server.status,
+                    tools: [],
+                    ...(server.error !== undefined ? { error: server.error } : {}),
+                    ...(server.errorDetail !== undefined ? { errorDetail: server.errorDetail } : {}),
+                });
+            }
+            else {
+                // Connecting / Reconnecting — no tools yet.
+                results.push({ name, status: server.status, tools: [] });
+            }
+        }
+        // Disabled servers live only in config (never constructed) — report them
+        // so a consumer can see the full configured roster.
+        if (state.mcpConfig) {
+            for (const [name, cfg] of Object.entries(state.mcpConfig)) {
+                if (cfg.enabled === false)
+                    results.push({ name, status: McpServerStatus.Disabled, tools: [] });
+            }
+        }
+        return results;
+    }
+    /**
+     * Cycle one MCP server's transport and re-discover its tools. Eager: awaits
+     * the close → connect → `invalidateToolsCache` → `listTools` round-trip, but
+     * a transient transport / discovery failure is recorded on per-server state
+     * (surfaced via `getMcpServerInfo`) rather than rejected — only the three
+     * programming errors throw. `getAgentOrThrow` runs first (AGENT_NOT_FOUND
+     * wins), then an unconfigured server throws `MCP_SERVER_NOT_FOUND` and a
+     * disabled one `MCP_SERVER_DISABLED`.
+     */
+    async reconnectMcpServer(agentId, serverName) {
+        const state = this.getAgentOrThrow(agentId);
+        const entry = state.mcpServers.get(serverName);
+        if (entry === undefined) {
+            const disabled = state.mcpConfig?.[serverName]?.enabled === false;
+            throw new AgentSDKError(disabled
+                ? `MCP server "${serverName}" is disabled on agent "${agentId}".`
+                : `No MCP server "${serverName}" configured on agent "${agentId}".`, disabled ? AgentSDKErrorType.MCP_SERVER_DISABLED : AgentSDKErrorType.MCP_SERVER_NOT_FOUND);
+        }
+        // Cycle status (Connected → Reconnecting; recovery-from-Error →
+        // Connecting) and emit the transient `status-changed` before the transport
+        // work; then `runMcpDiscovery` emits the discovery triple + the terminal
+        // status-change. Clear the stale snapshot before the transport work.
+        const transientStatus = entry.status === McpServerStatus.Connected ? McpServerStatus.Reconnecting : McpServerStatus.Connecting;
+        this.prepareMcpStatusChange(agentId, serverName, entry, transientStatus)?.();
+        entry.error = undefined;
+        entry.errorDetail = undefined;
+        entry.tools = [];
+        this.removeCatalogForServer(state, serverName);
+        entry.ready = this.runMcpDiscovery(agentId, state, serverName, entry.server, { reconnect: true });
+        await entry.ready;
+    }
+    // ── Compaction ───────────────────────────────────────────────────────
+    /**
+     * Compact a thread's history into a fresh thread seeded with an LLM-generated
+     * summary, then destroy the source (the `AgentHarness` contract). The OpenAI
+     * Agents SDK ships a server-side `OpenAIResponsesCompactionAwareSession.runCompaction`
+     * (via `responses.compact`), but it relies on `previous_response_id` /
+     * stored responses — unavailable against the stateless Salesforce gateway
+     * (`store: false`, the same reason the coordinator pins `reasoningItemIdPolicy: 'omit'`).
+     * So this hand-rolls summarize+seed+destroy, mirroring the Mastra/Claude harnesses.
+     *
+     * `getAgentOrThrow` runs first (AGENT_NOT_FOUND). An empty source is compacted
+     * to a fresh empty thread (leaving it attached would leak). A summarization or
+     * seed failure surfaces as `AgentSDKError(COMPACTION_FAILED)` with the source
+     * left intact; the source is destroyed best-effort only after the new thread
+     * is safely seeded.
+     */
+    async compactThread(agentId, threadId) {
+        const state = this.getAgentOrThrow(agentId);
+        const messages = await this.getMessages(agentId, threadId);
+        if (messages.length === 0) {
+            const newThreadId = await this.createThread(agentId);
+            // Empty source still gets compacted away — leaving it attached would
+            // be a leak. Mirrors the non-empty path's destroy below; both exit
+            // with the source detached.
+            await this.destroyThreadBestEffort(agentId, threadId);
+            return newThreadId;
+        }
+        const transcript = messages
+            .map((m) => {
+            const text = typeof m.content === 'string' ? m.content : m.content.map((p) => partToTranscriptText(p)).join(' ');
+            return `${m.role}: ${text}`;
+        })
+            .join('\n');
+        let newThreadId;
+        try {
+            const summaryText = transcript.length <= MAX_TRANSCRIPT_CHARS
+                ? await this.summarize(state, buildSummaryPrompt(transcript))
+                : await this.summarizeInChunks(state, transcript);
+            newThreadId = await this.createThread(agentId);
+            const userTs = this.clock.now();
+            const assistantTs = this.clock.nextAfter(userTs);
+            await this.addContext(agentId, newThreadId, [
+                {
+                    id: this.idGenerator.getUniqueId(),
+                    role: 'user',
+                    content: `The following is a summary of our prior conversation, provided as context for this session:\n\n${summaryText}`,
+                    createdAt: userTs,
+                },
+                {
+                    id: this.idGenerator.getUniqueId(),
+                    role: 'assistant',
+                    content: 'Understood. I have the context from our prior conversation and am ready to continue.',
+                    createdAt: assistantTs,
+                },
+            ]);
+        }
+        catch (error) {
+            throw new AgentSDKError(`Failed to compact thread "${threadId}" for agent "${agentId}": ${getErrorMessage(error)}`, AgentSDKErrorType.COMPACTION_FAILED, { cause: error });
+        }
+        // Source-thread cleanup is best-effort. The user's data is already safely
+        // seeded into newThreadId; a failed delete leaves an orphan session file
+        // but does not invalidate the compaction outcome.
+        await this.destroyThreadBestEffort(agentId, threadId);
+        return newThreadId;
+    }
+    // ── Tool Execution ───────────────────────────────────────────────────
+    /**
+     * Feed a consumer-executed tool's result back into the thread's in-flight
+     * turn. `getAgentOrThrow` runs FIRST (AGENT_NOT_FOUND wins over the
+     * coordinator lookup, per the SDK invariant); a thread with no in-flight
+     * coordinator throws `TOOL_CALL_NOT_FOUND`. The coordinator resolves the
+     * parked `execute` keyed by `toolCallId`, the run continues on the SAME
+     * eventStream the consumer is already iterating, and idempotency (#589) is
+     * owned downstream. `error` rides through as an error-shaped outcome so a
+     * consumer-reported failure reaches the tool call.
+     */
+    async submitToolResult(agentId, threadId, toolResult) {
+        const state = this.getAgentOrThrow(agentId);
+        const coordinator = state.coordinators.get(threadId);
+        if (coordinator === undefined) {
+            throw new AgentSDKError(`No in-flight tool call for thread "${threadId}".`, AgentSDKErrorType.TOOL_CALL_NOT_FOUND);
+        }
+        coordinator.submitToolResult(toolResult.toolCallId, {
+            result: toolResult.isError && toolResult.error ? toolResult.error : toolResult.result,
+            isError: toolResult.isError,
+        });
+    }
+    // ── Tool Approval ────────────────────────────────────────────────────
+    async approveToolCall(agentId, threadId, toolCallId) {
+        this.settleToolApproval(agentId, threadId, toolCallId, 'approve');
+    }
+    async declineToolCall(agentId, threadId, toolCallId) {
+        this.settleToolApproval(agentId, threadId, toolCallId, 'decline');
+    }
+    // ── Internals ────────────────────────────────────────────────────────
+    /**
+     * Forward an approve / decline to the thread's in-flight coordinator.
+     * `getAgentOrThrow` runs FIRST so an unregistered agent surfaces
+     * `AGENT_NOT_FOUND` (the SDK invariant: agent-registry check before the
+     * per-`(agentId, threadId)` coordinator lookup) — distinguishable from a
+     * registered agent with no in-flight run, which throws `TOOL_CALL_NOT_FOUND`.
+     * The coordinator owns idempotency (#589): a repeat / post-teardown settle is
+     * a silent no-op there. Post-resume events flow through the SAME eventStream
+     * the consumer is already iterating from `stream()`.
+     */
+    settleToolApproval(agentId, threadId, toolCallId, decision) {
+        const state = this.getAgentOrThrow(agentId);
+        const coordinator = state.coordinators.get(threadId);
+        if (coordinator === undefined) {
+            throw new AgentSDKError(`No in-flight tool approval for thread "${threadId}".`, AgentSDKErrorType.TOOL_CALL_NOT_FOUND);
+        }
+        if (decision === 'approve')
+            coordinator.approve(toolCallId);
+        else
+            coordinator.decline(toolCallId);
+    }
+    /**
+     * Build the `@openai/agents` `Agent` + `Runner` a turn runs against. One seam
+     * for the pair so a `stream()` constructs them identically each turn. The
+     * `Runner` binds the agent's live `modelProvider` (JWT rotation lands per
+     * request) with tracing off. `tools` carries the turn's consumer-executed
+     * tools (mapped from `config.tools`).
+     *
+     * **MCP attach, two paths.** Without a redaction hook (`redaction`
+     * undefined — the common case), the agent's live MCP server instances attach
+     * via the native `mcpServers` field; the SDK fetches their tools per run.
+     * Because each instance has `cacheToolsList: true` (cache keyed by
+     * `server.name`) and this harness reuses the SAME connected instances across
+     * turns, a rebuilt `Agent` here does not re-run `tools/list` for a preserved
+     * server — the #541 preservation mechanic. MCP tools are NOT approval-gated
+     * this milestone (the native attach exposes no per-tool `needsApproval`).
+     *
+     * **When a redaction hook is set,** the native attach exposes no per-result
+     * rewrite seam, so MCP tools are materialized via `getAllMcpTools(...)` and
+     * their `invoke` wrapped with the redactor (see {@link buildRedactedMcpTools});
+     * they attach as `tools` rather than `mcpServers`. #541 is preserved because
+     * `getAllMcpTools` reads each server's warm `cacheToolsList` cache with no
+     * network `tools/list`. This makes the method async (the materialize awaits
+     * `listTools()`), so `stream()` awaits it.
+     */
+    async buildAgent(agentId, state, tools = [], redaction) {
+        const mcpServerInstances = [...state.mcpServers.values()].map((s) => s.server);
+        // Redaction path: materialize + wrap MCP tools so their result passes
+        // through the redactor (the native `mcpServers` attach has no such seam).
+        // Only CONNECTED servers are materialized: their `cacheToolsList` cache is
+        // warm (discovery succeeded), so `getAllMcpTools` reads it with no network
+        // `tools/list` and cannot throw — where an errored / still-connecting
+        // server would make `getAllMcpTools` (which fails fast on the first
+        // server's throw) reject the whole turn PRE-stream. Skipping them keeps a
+        // failed MCP server from failing the turn (the WI-D contract) and matches
+        // the Claude harness's "only connected servers surface" posture; an
+        // errored server contributes no usable tools on the native path either.
+        const connectedMcpServers = [...state.mcpServers.values()]
+            .filter((s) => s.status === McpServerStatus.Connected)
+            .map((s) => s.server);
+        const redactedMcpTools = redaction !== undefined && connectedMcpServers.length > 0
+            ? await buildRedactedMcpTools(connectedMcpServers, redaction)
+            : [];
+        const allTools = [...tools, ...redactedMcpTools];
+        // Attach MCP natively only when we did NOT materialize them for redaction.
+        const attachMcpServers = redaction === undefined && mcpServerInstances.length > 0;
+        const agent = new Agent({
+            name: agentId,
+            instructions: state.config.instructions ?? '',
+            model: state.modelConnectivityInfo.nativeModelId,
+            ...(allTools.length > 0 ? { tools: allTools } : {}),
+            ...(attachMcpServers ? { mcpServers: mcpServerInstances } : {}),
+        });
+        const runner = new Runner({ modelProvider: state.modelProvider, tracingDisabled: true });
+        return { agent, runner };
+    }
+    // ── Compaction internals ─────────────────────────────────────────────
+    /**
+     * One-shot, non-agentic summarization for `compactThread`. Builds a throwaway
+     * `Agent` (summarization-role instructions, NO tools, NO MCP servers) bound to
+     * the agent's live `modelProvider`, and runs it non-streaming with no
+     * `session` (the summary call must not leak into the thread's persisted
+     * history). Returns the model's final text; throws if it produced none.
+     *
+     * `reasoningItemIdPolicy: 'omit'` is load-bearing for the same reason the
+     * turn coordinator pins it — the stateless gateway (`store: false`) rejects
+     * reasoning items sent by id reference.
+     */
+    async summarize(state, prompt) {
+        const summaryAgent = new Agent({
+            name: 'openai-harness-summarizer',
+            instructions: 'You are a summarization assistant. ' +
+                'Summarize the conversation transcript provided in the user message. ' +
+                'Preserve numeric values, dates, and proper names verbatim. ' +
+                'Do not invent details that are not present in the transcript.',
+            model: state.modelConnectivityInfo.nativeModelId,
+        });
+        const runner = new Runner({ modelProvider: state.modelProvider, tracingDisabled: true });
+        const result = await runner.run(summaryAgent, prompt, { reasoningItemIdPolicy: 'omit' });
+        const text = typeof result.finalOutput === 'string' ? result.finalOutput : '';
+        if (text.length === 0) {
+            throw new Error('Summary call produced no result text');
+        }
+        return text;
+    }
+    /**
+     * Two-pass summarization for transcripts above {@link MAX_TRANSCRIPT_CHARS}.
+     * Splits on line boundaries, summarizes each chunk, then summarizes the
+     * concatenated chunk-summaries (recursing if the merge itself is still over
+     * budget). Mirrors the sibling harnesses' map/reduce so cross-harness
+     * compaction behavior matches.
+     */
+    async summarizeInChunks(state, transcript) {
+        const chunks = splitIntoChunks(transcript, MAX_TRANSCRIPT_CHARS);
+        const chunkSummaries = [];
+        for (const chunk of chunks) {
+            chunkSummaries.push(await this.summarize(state, buildSummaryPrompt(chunk)));
+        }
+        const merged = chunkSummaries.map((s, i) => `Part ${i + 1}:\n${s}`).join('\n\n');
+        return merged.length <= MAX_TRANSCRIPT_CHARS
+            ? this.summarize(state, buildSummaryPrompt(merged))
+            : this.summarizeInChunks(state, merged);
+    }
+    /**
+     * Best-effort `destroyThread`: swallows the error so `compactThread`'s outer
+     * flow isn't aborted by a teardown blip, but logs it at `warn` so a future
+     * `destroyThread` regression stays observable. Used on both the empty-source
+     * and non-empty compaction paths.
+     */
+    async destroyThreadBestEffort(agentId, threadId) {
+        try {
+            await this.destroyThread(agentId, threadId);
+        }
+        catch (error) {
+            this.buses
+                .getLogBus()
+                ?.warn('Best-effort destroyThread failed during compactThread', { agentId, threadId }, error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    // ── MCP lifecycle internals ──────────────────────────────────────────
+    /**
+     * Construct the agent's enabled MCP servers and kick off background discovery
+     * for each. Synchronous: it inserts every server entry (status `Connecting`)
+     * then assigns its background discovery promise to `entry.ready`, so
+     * `createAgent` / `updateAgent` never block on `connect()` / `listTools()`.
+     * A no-op when the config declares no enabled servers.
+     */
+    startMcpServers(agentId, state, config, abortSignal) {
+        if (!hasEnabledServers(config))
+            return;
+        const servers = this.mcpServerFactory(config, state.config.orgJwt);
+        for (const [name, server] of servers) {
+            const entry = {
+                server,
+                config: config[name],
+                status: McpServerStatus.Connecting,
+                tools: [],
+                ready: Promise.resolve(),
+            };
+            state.mcpServers.set(name, entry);
+            entry.ready = this.runMcpDiscovery(agentId, state, name, server, { abortSignal });
+        }
+    }
+    /**
+     * Connect + list tools for one MCP server, recording the outcome on
+     * per-server state and emitting the discovery telemetry triple
+     * (`started` → `completed` | `failed`) plus the terminal `status-changed`.
+     * Guards against an orphaned write by re-checking the server instance
+     * identity after each await — a superseded cycle replaces the entry with a
+     * fresh instance, so a stale discovery must neither clobber state nor emit
+     * (every terminal emit sits behind the `isCurrent()` guard). Discovery
+     * failure is recorded on state (status `Error`, sanitized message +
+     * structured detail) and never rethrown — matching the "failed server ≠
+     * failed create/reconnect" contract; an aborted run records the state but
+     * emits no `failed` telemetry.
+     */
+    async runMcpDiscovery(agentId, state, name, server, options = {}) {
+        // Guard: only write back if this instance is still the agent's server for
+        // `name` (a cycle/reconnect may have replaced it while we awaited).
+        const isCurrent = () => state.mcpServers.get(name)?.server === server;
+        // Emitted synchronously at entry (before the first await) when this
+        // instance is still current — so `started` always precedes its terminal
+        // event in timestamp order and a superseded run stays silent. The
+        // `reconnect` flag does not change which event fires — one `started` per
+        // discovery run whether triggered by create / update / reconnect.
+        const startTime = this.clock.now().getTime();
+        this.emitMcpTelemetry({
+            type: 'mcp-server-discovery-started',
+            timestamp: this.clock.now(),
+            agentId,
+            serverName: name,
+        });
+        try {
+            options.abortSignal?.throwIfAborted();
+            if (options.reconnect) {
+                await server.close().catch(() => undefined);
+                await server.connect();
+                await server.invalidateToolsCache();
+            }
+            else {
+                await server.connect();
+            }
+            const tools = await server.listTools();
+            if (!isCurrent())
+                return;
+            const entry = state.mcpServers.get(name);
+            if (entry === undefined)
+                return;
+            entry.tools = tools.map((tool) => toMcpToolInfo(name, tool));
+            entry.error = undefined;
+            entry.errorDetail = undefined;
+            this.refreshCatalogForServer(state, name, tools);
+            // Flip status synchronously, then emit `completed` before the
+            // `status-changed` so a subscriber to both sees discovery → status in
+            // the same order a `getMcpServerInfo()` snapshot would (#373).
+            const emitStatusChange = this.prepareMcpStatusChange(agentId, name, entry, McpServerStatus.Connected);
+            this.emitMcpTelemetry({
+                type: 'mcp-server-discovery-completed',
+                timestamp: this.clock.now(),
+                agentId,
+                serverName: name,
+                toolCount: entry.tools.length,
+                durationMs: this.clock.now().getTime() - startTime,
+            });
+            emitStatusChange?.();
+        }
+        catch (error) {
+            if (!isCurrent())
+                return;
+            const entry = state.mcpServers.get(name);
+            if (entry === undefined)
+                return;
+            const aborted = isAbortError(error) || options.abortSignal?.aborted === true;
+            entry.tools = [];
+            const errorMessage = sanitizeMcpErrorMessage(error);
+            entry.error = errorMessage;
+            entry.errorDetail = buildMcpErrorDetail(error);
+            this.removeCatalogForServer(state, name);
+            this.buses.getLogBus()?.warn('MCP server discovery failed', {
+                serverName: name,
+                error: getErrorMessage(error),
+            });
+            // Flip status synchronously either way; emit only when NOT aborted (an
+            // aborted discovery isn't a server failure the consumer should see).
+            const emitStatusChange = this.prepareMcpStatusChange(agentId, name, entry, McpServerStatus.Error, errorMessage);
+            if (!aborted) {
+                this.emitMcpTelemetry({
+                    type: 'mcp-server-discovery-failed',
+                    timestamp: this.clock.now(),
+                    agentId,
+                    serverName: name,
+                    durationMs: this.clock.now().getTime() - startTime,
+                    error: error instanceof Error ? error : new Error(String(error)),
+                    ...(entry.errorDetail !== undefined ? { errorDetail: entry.errorDetail } : {}),
+                });
+                emitStatusChange?.();
+            }
+        }
+    }
+    /**
+     * Emit an MCP telemetry event, swallowing only the typed `DISPOSED` error a
+     * post-`shutdown()` background discovery callback would hit (the bus is gone).
+     * Any other emit failure rethrows so a real regression surfaces. Every MCP
+     * emit is background / racing shutdown, so all route through here.
+     */
+    emitMcpTelemetry(event) {
+        try {
+            this.buses.emitTelemetry(event);
+        }
+        catch (error) {
+            if (!isDisposedError(error))
+                throw error;
+        }
+    }
+    /**
+     * Flip a server's status synchronously and return a closure that emits the
+     * matching `mcp-server-status-changed` telemetry — or `undefined` when the
+     * status is unchanged (same-status transitions are deduped here so callers
+     * don't have to). Splitting the flip from the emit lets callers order the
+     * emit AFTER the discovery-terminal event (#373), while a synchronous reader
+     * of `getMcpServerInfo()` already sees the post-flip status.
+     */
+    prepareMcpStatusChange(agentId, serverName, entry, nextStatus, error) {
+        const previousStatus = entry.status;
+        if (previousStatus === nextStatus)
+            return undefined;
+        entry.status = nextStatus;
+        return () => this.emitMcpTelemetry({
+            type: 'mcp-server-status-changed',
+            timestamp: this.clock.now(),
+            agentId,
+            serverName,
+            previousStatus,
+            nextStatus,
+            ...(error !== undefined ? { error } : {}),
+        });
+    }
+    /**
+     * Diff the next MCP config against the applied one and preserve / cycle / add
+     * / remove servers accordingly. `mcpServerConfigEqual` (SDK-exported, uniform
+     * across harnesses) is the preserve predicate: an equal server is left
+     * completely untouched (its live instance + warm tool-list cache survive — no
+     * `close`, no `tools/list`, the #541 checkpoint). A changed / removed server
+     * is closed and dropped; a changed / added enabled server is constructed
+     * fresh and discovered in the background.
+     */
+    diffMcpServers(agentId, state, next, orgJwt, abortSignal) {
+        const prev = state.mcpConfig ?? {};
+        const names = new Set([...Object.keys(prev), ...Object.keys(next)]);
+        for (const name of names) {
+            if (mcpServerConfigEqual(prev[name], next[name])) {
+                // Preserve: nothing changed for this server. Its live instance +
+                // warm tool-list cache survive untouched (no close, no
+                // `tools/list`, no fresh construction — the #541 checkpoint).
+                // Refresh the stored config to the new (structurally-equal)
+                // object for a clean next diff.
+                const entry = state.mcpServers.get(name);
+                if (entry !== undefined && next[name] !== undefined)
+                    entry.config = next[name];
+                continue;
+            }
+            // Changed or removed: tear down the previous instance if we held one.
+            const prevEntry = state.mcpServers.get(name);
+            if (prevEntry !== undefined) {
+                state.mcpServers.delete(name);
+                this.removeCatalogForServer(state, name);
+                // Fire-and-forget: the cycle must not block on the old server's
+                // close (the #541 "cycle doesn't wait" design). `closeServerEntry`
+                // owns the terminal catch so a synchronous throw from `close()`
+                // can't become an unhandled rejection.
+                void closeServerEntry(prevEntry);
+            }
+            // Changed or added: construct + discover a fresh instance if the next
+            // config enables this server. Constructed per-name (not for the whole
+            // next config) so a preserved server is never rebuilt.
+            const nextConfig = next[name];
+            if (nextConfig !== undefined && nextConfig.enabled !== false) {
+                const server = this.mcpServerFactory({ [name]: nextConfig }, orgJwt).get(name);
+                if (server !== undefined) {
+                    const entry = {
+                        server,
+                        config: nextConfig,
+                        status: McpServerStatus.Connecting,
+                        tools: [],
+                        ready: Promise.resolve(),
+                    };
+                    state.mcpServers.set(name, entry);
+                    entry.ready = this.runMcpDiscovery(agentId, state, name, server, { abortSignal });
+                }
+            }
+        }
+    }
+    /** Close every MCP server on an agent, awaiting in-flight discovery first. */
+    async closeMcpServers(state) {
+        await Promise.allSettled([...state.mcpServers.values()].map((entry) => closeServerEntry(entry)));
+        state.mcpServers.clear();
+        state.mcpCatalog.clear();
+    }
+    /** Rebuild the catalog entries for one server from its freshly-discovered tools. */
+    refreshCatalogForServer(state, serverName, tools) {
+        this.removeCatalogForServer(state, serverName);
+        for (const tool of tools) {
+            const annotations = tool.annotations;
+            state.mcpCatalog.set(tool.name, { serverName, ...(annotations !== undefined ? { annotations } : {}) });
+        }
+    }
+    /** Drop every catalog entry that points at `serverName`. */
+    removeCatalogForServer(state, serverName) {
+        for (const [bareToolName, entry] of state.mcpCatalog) {
+            if (entry.serverName === serverName)
+                state.mcpCatalog.delete(bareToolName);
+        }
+    }
+    /**
+     * Decide whether the tool-approval gate engages this turn and, if so, return
+     * the per-tool policy decider the coordinator consults. `undefined` ⇒ gate
+     * inactive; the coordinator suspends nothing and tools run free (the SDK's
+     * "no policy ⇒ no gating" back-compat invariant), avoiding a suspend/resume
+     * round-trip per call.
+     *
+     * Gating is **opt-in**: it engages only when the consumer set
+     * `config.toolPolicies` (non-empty) or `config.defaultToolDecision`. Whether
+     * the gate engaged is frozen at stream start (the closure is built iff gating
+     * is active now), but the closure itself reads `state.config` **live on every
+     * call** rather than a snapshot — a mid-turn `updateAgentConfig` (notably the
+     * `source: 'remember'` rule an "Allow always" click appends) reassigns
+     * `state.config` in place on this same `state` without disposing the in-flight
+     * coordinator, so a snapshot would leave approvals 2..N in that turn
+     * re-prompting even though the rule is persisted (#638). Reading live makes
+     * the remembered decision auto-resolve subsequent matching calls.
+     * `OPENAI_BUILT_IN_TOOL_POLICIES` is the `tiers.harness` slice (empty today).
+     */
+    buildPolicyGate(state) {
+        const config = state.config;
+        const gatingActive = (config.toolPolicies?.length ?? 0) > 0 || config.defaultToolDecision !== undefined;
+        if (!gatingActive)
+            return undefined;
+        return (invocation) => resolveToolApprovalPolicy(invocation, state.config, { harness: OPENAI_BUILT_IN_TOOL_POLICIES }).decision;
+    }
+    getAgentOrThrow(agentId) {
+        const state = this.agents.get(agentId);
+        if (state === undefined) {
+            throw new AgentSDKError(`No Agent found with id: "${agentId}"`, AgentSDKErrorType.AGENT_NOT_FOUND);
+        }
+        return state;
+    }
+}
+/**
+ * `true` for the typed `DISPOSED` error `HarnessBusOwner` throws after
+ * `dispose()`. A background MCP-discovery callback that resolves after
+ * `shutdown()` hits this when it emits telemetry; the emit helper swallows only
+ * this error and rethrows anything else (Mastra's `isDisposedError` pattern).
+ */
+function isDisposedError(error) {
+    return error instanceof AgentSDKError && error.type === AgentSDKErrorType.DISPOSED;
+}
+/**
+ * Await an MCP server's in-flight discovery, then close its transport. Every
+ * step is defended so the whole thing resolves rather than rejects — the sole
+ * teardown primitive for both the blocking path (`closeMcpServers` under
+ * `Promise.allSettled`) and the fire-and-forget cycle path in `diffMcpServers`
+ * (where a bare `.then(() => close())` chain could otherwise surface a
+ * synchronous `close()` throw as an unhandled rejection). Awaiting `ready`
+ * first ensures close never races an in-flight `connect()`.
+ */
+async function closeServerEntry(entry) {
+    try {
+        await entry.ready;
+    }
+    catch {
+        // Discovery already failed / was recorded on state — proceed to close.
+    }
+    try {
+        await entry.server.close();
+    }
+    catch {
+        // Best-effort close: a torn-down transport must not throw out of teardown.
+    }
+}
+/**
+ * Map one discovered `@openai/agents` MCP tool to the SDK's {@link McpToolInfo}.
+ * The `@openai/agents` native attach registers tools under their bare name (no
+ * `${server}_` namespacing), so the display `name`, the authoritative `toolName`,
+ * and the catalog key are all the same bare string. `annotations` is read
+ * structurally because the installed `MCPTool` schema does not carry it — a
+ * future SDK version that adds it will surface here without a code change.
+ */
+function toMcpToolInfo(serverName, tool) {
+    const annotations = tool.annotations;
+    return {
+        name: tool.name,
+        serverName,
+        toolName: tool.name,
+        ...(tool.description !== undefined ? { description: tool.description } : {}),
+        ...(isJsonObject(tool.inputSchema) ? { inputSchema: tool.inputSchema } : {}),
+        ...(annotations !== undefined ? { annotations } : {}),
+    };
+}
+/** Narrow an unknown to a plain JSON-object record (MCP `inputSchema` shape). */
+function isJsonObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Lowers a `stream()` message to the plain-text `input` the OpenAI Agents run
+ * loop takes. Only `text` parts are supported; multimodal input is not yet
+ * implemented.
+ */
+function lowerMessageToText(message) {
+    if (typeof message === 'string')
+        return message;
+    const texts = [];
+    for (const part of message) {
+        if (part.type === 'text') {
+            texts.push(part.text);
+        }
+        else {
+            throw new AgentSDKError(`The OpenAI harness does not yet support "${part.type}" message parts (text only).`, AgentSDKErrorType.INVALID_MESSAGE_CONTENT);
+        }
+    }
+    return texts.join('\n');
+}
+//# sourceMappingURL=openai-agents-harness.js.map