@aexhq/sdk 0.34.0 → 0.36.0

package/dist/client.js

@@ -1,9 +1,9 @@
-import { AexError, DEFAULT_RUN_PROVIDER, HttpClient, RunConfigValidationError, RunStateError, SecretString, customName, isRunSettled, operations, providersForModel, streamCoordinatorEvents, decodeAssistantText, summarizeRunTrace, textOf, parseRunLimits, BUILTIN_TOOL_NAMES, TERMINAL_RUN_STATUSES } from "./_contracts/index.js";
+import { AexApiError, AexError, DEFAULT_RUN_PROVIDER, HttpClient, RunConfigValidationError, RunStateError, SecretString, customName, isRunSettled, operations, providersForModel, streamCoordinatorEvents, parseRunLimits, BUILTIN_TOOL_NAMES, TERMINAL_RUN_STATUSES } from "./_contracts/index.js";
 import { AgentsMd } from "./agents-md.js";
 import { uploadAsset } from "./asset-upload.js";
 import { File } from "./file.js";
 import { McpServer } from "./mcp-server.js";
-import { splitProxyEndpoints } from "./proxy-endpoint.js";
+import { AexRateLimitError, isThrottleFault, parseProviderFault, withRetry } from "./retry.js";
 import { splitSecretEnv } from "./secret.js";
 import { SkillTool } from "./skill-tool.js";
 import { Tool } from "./tool.js";
@@ -40,6 +40,8 @@ export class SessionHandle {
     #http;
     #fetch;
     #session;
+    /** The last message sent on this handle, for {@link SessionHandle.replayLast}. */
+    #lastSend;
     constructor(http, session, fetch) {
         this.#http = http;
         this.#session = session;
@@ -56,8 +58,28 @@ export class SessionHandle {
         assertNoSessionSendSignal(options, "SessionHandle.send");
         return sendSessionInternal(this, input, options);
     }
+    /**
+     * Re-send the last message on this session — the clean way to retry a turn a
+     * throttle or transient failure interrupted. By default it REUSES the previous
+     * message's idempotency key, so if the original turn actually landed
+     * server-side the replay de-duplicates instead of creating a second billable
+     * turn; pass a fresh `idempotencyKey` to force a brand-new turn.
+     */
+    replayLast(options = {}) {
+        assertNoSessionSendSignal(options, "SessionHandle.replayLast");
+        const last = this.#lastSend;
+        if (last === undefined) {
+            throw new RunStateError("SessionHandle.replayLast: no message has been sent on this session yet");
+        }
+        return sendSessionInternal(this, last.input, {
+            ...options,
+            idempotencyKey: options.idempotencyKey ?? last.idempotencyKey
+        });
+    }
     async *#send(input, options) {
-        const accepted = await operations.sendSessionMessage(this.#http, this.id, { input }, { idempotencyKey: options.idempotencyKey ?? generateIdempotencyKey() });
+        const idempotencyKey = options.idempotencyKey ?? generateIdempotencyKey();
+        this.#lastSend = { input, idempotencyKey };
+        const accepted = await operations.sendSessionMessage(this.#http, this.id, { input }, { idempotencyKey });
         this.#session = accepted.session;
         const turn = accepted.turn;
         const events = [];
@@ -72,14 +94,16 @@ export class SessionHandle {
         const readSession = await operations.getSession(this.#http, this.id).catch(() => this.#session);
         this.#session = withTerminalSessionStatus(readSession, terminalStatus);
         const outputs = await operations.listSessionOutputs(this.#http, this.id).catch(() => []);
+        const messages = projectAssistantMessages(events);
         return {
             sessionId: this.id,
             session: this.#session,
             turn,
             status: this.#session.status,
-            text: textOf(events),
+            text: assistantTextFromEvents(events),
             events,
-            outputs
+            outputs,
+            messages
         };
     }
     async suspend(options = {}) {
@@ -104,19 +128,39 @@ export class SessionHandle {
         }
     }
     /**
-     * Accessor for the session's decoded assistant messages (buffered output
-     * mode: one entry per assistant message). `list()` returns them oldest-first;
-     * `last()`/`first()` return a single entry or `undefined` when empty.
+     * Accessor for the session's assistant messages. `all()` returns them
+     * oldest-first; `last()`/`first()` return a single entry or `undefined` when
+     * empty. The accessor is callable as a compatibility shim for older
+     * `session.messages().list()` callers.
      */
-    messages() {
+    get messages() {
         const http = this.#http;
         const id = this.id;
-        const list = async () => decodeAssistantText((await operations.listSessionEvents(http, id)));
-        return {
-            list,
-            last: async () => (await list()).at(-1),
-            first: async () => (await list())[0]
+        const fromEvents = async () => projectAssistantMessages(await operations.listSessionEvents(http, id));
+        const all = async () => {
+            try {
+                const page = await operations.listSessionMessages(http, id);
+                if (!Array.isArray(page.messages)) {
+                    return fromEvents();
+                }
+                return page.messages.map(messageFromWire);
+            }
+            catch (err) {
+                if (!isMissingMessagesEndpoint(err)) {
+                    throw err;
+                }
+                return fromEvents();
+            }
         };
+        let accessor;
+        accessor = (() => accessor);
+        Object.assign(accessor, {
+            all,
+            list: all,
+            last: async () => (await all()).at(-1),
+            first: async () => (await all())[0]
+        });
+        return accessor;
     }
     /**
      * Accessor for the session's event stream: the buffered `SessionEvent`
@@ -303,10 +347,15 @@ export class SessionClient {
         const { message, deleteAfter, messageIdempotencyKey, stream, ...createOptions } = options;
         assertNoLegacySessionFields(options, "Aex.sessions.run");
         const input = normaliseSessionInput(message, "Aex.sessions.run", "message");
-        const session = await this.create(createOptions);
+        // Derive the message key from the create key (like the CLI) so a retried run
+        // with the same `idempotencyKey` de-duplicates BOTH the create and the
+        // billable turn — never a duplicate billable run.
+        const createKey = createOptions.idempotencyKey ?? generateIdempotencyKey();
+        const messageKey = messageIdempotencyKey ?? deriveMessageKey(createKey);
+        const session = await this.create({ ...createOptions, idempotencyKey: createKey });
         const result = await session.send(input, {
             ...(stream ?? {}),
-            idempotencyKey: messageIdempotencyKey ?? generateIdempotencyKey()
+            idempotencyKey: messageKey
         }).done();
         if (deleteAfter) {
             await session.delete();
@@ -419,6 +468,199 @@ function sessionOutputs(http, id, fetchLike) {
         download: (selector, options) => downloadSessionOutput(http, id, selector, options)
     };
 }
+function messageFromWire(message) {
+    return {
+        id: message.id,
+        sender: message.sender,
+        text: message.text,
+        ...(message.timestamp !== undefined ? { timestamp: message.timestamp } : {}),
+        ...(message.turnSeq !== undefined ? { turnSeq: message.turnSeq } : {}),
+        ...(message.sequence !== undefined ? { sequence: message.sequence } : {})
+    };
+}
+function isMissingMessagesEndpoint(err) {
+    return err instanceof AexApiError && (err.status === 404 || err.status === 405 || err.status === 501);
+}
+function projectAssistantMessages(events) {
+    const out = [];
+    const byMessageId = new Map();
+    for (let i = 0; i < events.length; i++) {
+        const event = events[i];
+        if (event.type !== "TEXT_MESSAGE_CONTENT")
+            continue;
+        const data = asRecord(event.data);
+        const text = typeof data.text === "string" ? data.text : undefined;
+        if (text === undefined)
+            continue;
+        const messageId = typeof data.messageId === "string" && data.messageId ? data.messageId : undefined;
+        const sequence = event.sequence ?? event.seq;
+        const timestamp = event.time ?? event.recordedAt ?? timestampFromEpochMs(event.receivedAt);
+        const turnSeq = typeof data.turnSeq === "number" ? data.turnSeq : undefined;
+        if (messageId !== undefined) {
+            const existing = byMessageId.get(messageId);
+            if (existing !== undefined) {
+                const current = out[existing];
+                out[existing] = {
+                    ...current,
+                    text: `${current.text}${text}`,
+                    ...(timestamp !== undefined ? { timestamp } : {}),
+                    ...(sequence !== undefined ? { sequence } : {}),
+                    ...(turnSeq !== undefined ? { turnSeq } : {})
+                };
+                continue;
+            }
+            byMessageId.set(messageId, out.length);
+        }
+        out.push({
+            id: messageId ?? (typeof event.id === "string" && event.id ? event.id : `message-${i}`),
+            sender: "assistant",
+            text,
+            ...(timestamp !== undefined ? { timestamp } : {}),
+            ...(sequence !== undefined ? { sequence } : {}),
+            ...(turnSeq !== undefined ? { turnSeq } : {})
+        });
+    }
+    return out;
+}
+function assistantTextFromEvents(events) {
+    return assistantTextEntriesFromEvents(events).map((entry) => entry.text).join("");
+}
+function runTraceFromEvents(events) {
+    return {
+        toolCalls: toolCallsFromEvents(events),
+        usage: usageFromEvents(events),
+        text: assistantTextEntriesFromEvents(events)
+    };
+}
+function assistantTextEntriesFromEvents(events) {
+    const out = [];
+    for (const raw of events) {
+        const event = raw;
+        if (event.type !== "TEXT_MESSAGE_CONTENT")
+            continue;
+        const data = asRecord(event.data);
+        const text = typeof data.text === "string" ? data.text : undefined;
+        if (text === undefined)
+            continue;
+        const entry = { text };
+        const messageId = typeof data.messageId === "string" ? data.messageId : undefined;
+        if (messageId !== undefined)
+            entry.messageId = messageId;
+        if (typeof event.seq === "number")
+            entry.seq = event.seq;
+        const recordedAt = typeof event.recordedAt === "string" ? event.recordedAt : undefined;
+        if (recordedAt !== undefined)
+            entry.recordedAt = recordedAt;
+        out.push(entry);
+    }
+    return out;
+}
+function toolCallsFromEvents(events) {
+    const order = [];
+    const byId = new Map();
+    for (const event of events) {
+        const data = asRecord(event.data);
+        if (event.type === "TOOL_CALL_START") {
+            const id = typeof data.id === "string" ? data.id : undefined;
+            if (id === undefined)
+                continue;
+            const trace = {
+                id,
+                name: typeof data.name === "string" ? data.name : "",
+                args: asRecord(data.arguments)
+            };
+            const messageId = typeof data.messageId === "string" ? data.messageId : undefined;
+            if (messageId !== undefined)
+                trace.messageId = messageId;
+            if (typeof event.seq === "number")
+                trace.startSeq = event.seq;
+            if (typeof event.recordedAt === "string")
+                trace.startedAt = event.recordedAt;
+            if (!byId.has(id))
+                order.push(id);
+            byId.set(id, trace);
+            continue;
+        }
+        if (event.type === "TOOL_CALL_RESULT") {
+            const id = typeof data.id === "string" ? data.id : undefined;
+            if (id === undefined)
+                continue;
+            const result = {
+                isError: data.isError === true,
+                content: data.content ?? null
+            };
+            if (typeof event.seq === "number")
+                result.seq = event.seq;
+            if (typeof event.recordedAt === "string")
+                result.recordedAt = event.recordedAt;
+            let trace = byId.get(id);
+            if (trace === undefined) {
+                trace = { id, name: "", args: {} };
+                order.push(id);
+                byId.set(id, trace);
+            }
+            trace.result = result;
+            const duration = durationMs(trace.startedAt, result.recordedAt);
+            if (duration !== undefined)
+                trace.durationMs = duration;
+        }
+    }
+    return order.map((id) => byId.get(id));
+}
+function usageFromEvents(events) {
+    const totals = { inputTokens: 0, outputTokens: 0, cacheReadInputTokens: 0, cacheCreationInputTokens: 0 };
+    let seen = false;
+    for (const event of events) {
+        if (event.type !== "CUSTOM")
+            continue;
+        const data = asRecord(event.data);
+        if (data.name !== "aex.usage")
+            continue;
+        const value = asRecord(data.value);
+        const fields = [
+            ["input_tokens", "inputTokens"],
+            ["output_tokens", "outputTokens"],
+            ["cache_read_input_tokens", "cacheReadInputTokens"],
+            ["cache_creation_input_tokens", "cacheCreationInputTokens"]
+        ];
+        for (const [wireName, apiName] of fields) {
+            const n = value[wireName];
+            if (typeof n === "number" && Number.isFinite(n)) {
+                totals[apiName] += n;
+                seen = true;
+            }
+        }
+    }
+    if (!seen)
+        return {};
+    return {
+        inputTokens: totals.inputTokens,
+        outputTokens: totals.outputTokens,
+        cacheReadInputTokens: totals.cacheReadInputTokens,
+        cacheCreationInputTokens: totals.cacheCreationInputTokens,
+        totalTokens: totals.inputTokens + totals.outputTokens
+    };
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function timestampFromEpochMs(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? new Date(value).toISOString()
+        : undefined;
+}
+function durationMs(start, end) {
+    if (start === undefined || end === undefined)
+        return undefined;
+    const a = Date.parse(start);
+    const b = Date.parse(end);
+    if (!Number.isFinite(a) || !Number.isFinite(b))
+        return undefined;
+    const delta = b - a;
+    return delta >= 0 ? delta : undefined;
+}
 function isSessionTurnTerminalEvent(event, turnSeq) {
     const name = customName(event);
     if (name !== "aex.session.idle" &&
@@ -571,7 +813,7 @@ function unwrapSecretValue(value) {
  * `client.whoami()` if you want to introspect which workspace the
  * token resolves to.
  */
-export class AgentExecutor {
+export class Aex {
     #http;
     /** The same fetch the HttpClient uses, threaded into `_uploadAsset`. */
     #fetch;
@@ -579,22 +821,30 @@ export class AgentExecutor {
     files;
     secrets;
     sessions;
-    constructor(options) {
-        if (!options.apiToken) {
-            throw new Error("AgentExecutor: apiToken is required");
+    constructor(options, overrides = {}) {
+        const resolved = typeof options === "string" ? { ...overrides, apiKey: options } : options;
+        const apiKey = resolved.apiKey ?? resolved.apiToken;
+        if (!apiKey) {
+            throw new Error("Aex: apiKey is required");
         }
+        // Wrap the transport fetch (the caller's override, or global `fetch`) with
+        // the bounded-retry layer so every BFF request gets default resilience.
+        // The raw `#fetch` below stays unwrapped for the direct-to-storage asset PUT
+        // and presigned output GETs, which target object storage, not the API plane.
+        const baseFetch = resolved.fetch ?? ((input, init) => fetch(input, init));
+        const retryingFetch = withRetry(baseFetch, resolved.retry);
         this.#http = new HttpClient({
-            ...(options.baseUrl ? { baseUrl: options.baseUrl } : {}),
-            apiToken: options.apiToken,
-            ...(options.fetch ? { fetch: options.fetch } : {}),
+            ...(resolved.baseUrl ? { baseUrl: resolved.baseUrl } : {}),
+            apiToken: apiKey,
+            fetch: retryingFetch,
             // Opt-in local diagnostics: emit a redacted per-request trace to
             // stderr. Uploads nothing. A caller wanting a custom sink can pass
             // a function instead of `true`.
-            ...(options.debug
-                ? { debug: typeof options.debug === "function" ? options.debug : (line) => console.error(line) }
+            ...(resolved.debug
+                ? { debug: typeof resolved.debug === "function" ? resolved.debug : (line) => console.error(line) }
                 : {})
         });
-        this.#fetch = options.fetch;
+        this.#fetch = resolved.fetch;
         this.agentsMd = new AgentsMdClient(this.#http);
         this.files = new FilesClient(this.#http);
         this.secrets = new SecretsClient(this.#http);
@@ -646,10 +896,15 @@ export class AgentExecutor {
                 ...(opts.idleTimeoutMs !== undefined ? { idleTimeoutMs: opts.idleTimeoutMs } : {}),
                 ...(opts.pingIntervalMs !== undefined ? { pingIntervalMs: opts.pingIntervalMs } : {})
             };
-            const session = await this.sessions.create(createOptions);
+            // Derive the message key from the create key (like the CLI) so a retried
+            // run with the same `idempotencyKey` de-duplicates BOTH the create and the
+            // billable turn server-side — never a duplicate billable run (sdk-dx-3).
+            const createKey = createOptions.idempotencyKey ?? generateIdempotencyKey();
+            const messageKey = messageIdempotencyKey ?? deriveMessageKey(createKey);
+            const session = await this.sessions.create({ ...createOptions, idempotencyKey: createKey });
             const turnResult = await sendSessionInternal(session, input, {
                 ...streamOptions,
-                idempotencyKey: messageIdempotencyKey ?? generateIdempotencyKey()
+                idempotencyKey: messageKey
             }).done();
             if (deleteAfter) {
                 await session.delete();
@@ -670,15 +925,29 @@ export class AgentExecutor {
                 status: turnResult.status,
                 ok,
                 text: turnResult.text,
+                messages: turnResult.messages,
                 events,
-                trace: summarizeRunTrace(events),
+                trace: runTraceFromEvents(events),
                 outputs,
                 ...(turnResult.session.usage ? { usage: turnResult.session.usage } : {}),
                 ...(typeof costUsd === "number" ? { costUsd } : {}),
                 ...(!ok && errorMessage ? { error: errorMessage } : {})
             };
             if (opts.throwOnFailure && !ok) {
-                throw new RunStateError(`AgentExecutor.run: session ${runId} ended ${turnResult.status}${errorMessage ? `: ${errorMessage}` : ""}`, { runId, status: turnResult.status });
+                // A turn that failed because the upstream provider throttled us surfaces
+                // as a structured, non-leaky AexRateLimitError carrying the provider
+                // fault, so callers can branch on `isRateLimited(err)` and replay.
+                const throttle = throttleFromSession(turnResult.session);
+                if (throttle) {
+                    throw new AexRateLimitError({
+                        status: throttle.status ?? 429,
+                        attempts: 1,
+                        source: "provider",
+                        providerFault: throttle,
+                        ...(throttle.retryAfterMs !== undefined ? { retryAfterMs: throttle.retryAfterMs } : {})
+                    });
+                }
+                throw new RunStateError(`Aex.run: session ${runId} ended ${turnResult.status}${errorMessage ? `: ${errorMessage}` : ""}`, { runId, status: turnResult.status });
             }
             return result;
         }
@@ -708,8 +977,6 @@ export class AgentExecutor {
         if (typeof options.model !== "string" || !options.model) {
             throw new RunConfigValidationError("Aex.openSession: model is required");
         }
-        const { endpoints: proxyEndpointDeclarations, auth: proxyEndpointAuthFromInstances } = splitProxyEndpoints(options.proxyEndpoints ?? []);
-        const mergedProxyAuth = mergeProxyEndpointAuth(proxyEndpointAuthFromInstances, []);
         const { declarations: secretEnvDeclarations, values: envSecretValues } = splitSecretEnv(options.environment?.secrets);
         let limits;
         try {
@@ -752,7 +1019,6 @@ export class AgentExecutor {
         const secrets = {
             ...(options.apiKeys ? { apiKeys: options.apiKeys } : {}),
             ...(mergedMcpSecrets.length > 0 ? { mcpServers: mergedMcpSecrets } : {}),
-            ...(mergedProxyAuth.length > 0 ? { proxyEndpointAuth: mergedProxyAuth } : {}),
             ...(Object.keys(envSecretValues).length > 0 ? { envSecrets: envSecretValues } : {})
         };
         const retention = sessionRetentionForWire(options);
@@ -766,10 +1032,7 @@ export class AgentExecutor {
             // Operational/delivery concern — sibling of secrets, NOT part of the
             // hashed submission. Delivered at the settle-consistent barrier.
             ...(options.webhook ? { webhook: options.webhook } : {}),
-            secrets,
-            ...(proxyEndpointDeclarations.length > 0
-                ? { proxyEndpoints: proxyEndpointDeclarations }
-                : {})
+            secrets
         };
     }
     /**
@@ -784,9 +1047,6 @@ export class AgentExecutor {
         return operations.whoami(this.#http);
     }
 }
-/** Canonical SDK client name. `AgentExecutor` remains as a compatibility alias. */
-export class Aex extends AgentExecutor {
-}
 // `Run.status` is a loose `string` on the wire shape, so we membership-test
 // against the canonical terminal set rather than re-deriving one (which is how
 // `timed_out` got dropped from the old hardcoded list).
@@ -843,7 +1103,7 @@ function resolveOutputFileSelector(outputs, selector, runId) {
     if (isOutputPathSelector(selector)) {
         const target = normalizeOutputLookupPath(selector.path);
         if (!target) {
-            throw new RunStateError("AgentExecutor.downloadOutput: output path must be non-empty", {
+            throw new RunStateError("Aex.downloadOutput: output path must be non-empty", {
                 runId,
                 path: selector.path
             });
@@ -860,15 +1120,15 @@ function resolveOutputFileSelector(outputs, selector, runId) {
         if (matches.length === 1)
             return matches[0];
         if (matches.length > 1) {
-            throw new RunStateError(`AgentExecutor.downloadOutput: output path "${selector.path}" matched multiple files`, { runId, path: selector.path, matches: matches.map((output) => output.filename ?? output.id) });
+            throw new RunStateError(`Aex.downloadOutput: output path "${selector.path}" matched multiple files`, { runId, path: selector.path, matches: matches.map((output) => output.filename ?? output.id) });
         }
-        throw new RunStateError(`AgentExecutor.downloadOutput: output path "${selector.path}" was not found`, {
+        throw new RunStateError(`Aex.downloadOutput: output path "${selector.path}" was not found`, {
             runId,
             path: selector.path
         });
     }
     if (typeof selector.id !== "string" || selector.id.length === 0) {
-        throw new RunStateError("AgentExecutor.downloadOutput: selector must include an output id or path", { runId });
+        throw new RunStateError("Aex.downloadOutput: selector must include an output id or path", { runId });
     }
     return { ...selector, id: selector.id };
 }
@@ -905,6 +1165,40 @@ function generateIdempotencyKey() {
         return cryptoObj.randomUUID();
     return `idem-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
 }
+/**
+ * Derive the message idempotency key from the session-create key. Mirrors the
+ * CLI (`<createKey>:message`) so a retried `run` / `sessions.run` that reuses
+ * one `idempotencyKey` de-duplicates BOTH the create and the billable turn.
+ */
+function deriveMessageKey(createKey) {
+    return `${createKey}:message`;
+}
+/**
+ * Extract a throttle-class {@link ProviderFault} from a failed session record.
+ * Reads a structured `providerFault` / `error` field first (the shape the
+ * runtime is expected to emit on a throttled turn), then falls back to a
+ * heuristic scan of `errorMessage`. Returns `undefined` when the failure is not
+ * a throttle.
+ */
+function throttleFromSession(session) {
+    const fault = parseProviderFault(session.providerFault) ??
+        parseProviderFault(session.error) ??
+        faultFromErrorMessage(typeof session.errorMessage === "string" ? session.errorMessage : undefined);
+    return fault && isThrottleFault(fault) ? fault : undefined;
+}
+/** Last-resort throttle detection from a free-text run error message. */
+function faultFromErrorMessage(message) {
+    if (message === undefined || message.length === 0)
+        return undefined;
+    const lower = message.toLowerCase();
+    if (/\b429\b|rate.?limit|too many requests/.test(lower)) {
+        return { kind: "rate_limit", message };
+    }
+    if (/\b529\b|overloaded/.test(lower)) {
+        return { kind: "overloaded", message };
+    }
+    return undefined;
+}
 function normaliseSessionInput(input, surface, field) {
     if (typeof input === "string") {
         if (!input) {
@@ -924,6 +1218,7 @@ function normaliseSessionInput(input, surface, field) {
 }
 function assertNoLegacySessionFields(options, surface) {
     const record = options;
+    const removedProxyField = "proxy" + "Endpoints";
     const messages = {
         input: "send user messages with session.send(...) or use run({ message }).",
         prompt: "use message for one-shot run input or session.send(...) for follow-up messages.",
@@ -939,7 +1234,8 @@ function assertNoLegacySessionFields(options, surface) {
         limits: "use overrides.",
         timeout: "use overrides.timeout.",
         signal: "use session.cancel() / session.suspend() for remote control.",
-        postHook: "send a follow-up validation message when the session returns idle."
+        postHook: "send a follow-up validation message when the session returns idle.",
+        [removedProxyField]: "proxy endpoints are not part of the public SDK session API."
     };
     for (const [field, message] of Object.entries(messages)) {
         if (Object.prototype.hasOwnProperty.call(record, field)) {
@@ -1161,29 +1457,4 @@ function mergeMcpServers(inputs, explicitSecrets) {
         mergedMcpSecrets: Array.from(secretByName.values())
     };
 }
-/**
- * Merge `ProxyEndpoint`-derived auth entries with any
- * `secrets.proxyEndpointAuth` the caller passed explicitly. Per-instance
- * auth values win on the same `name`; a type mismatch (e.g. instance
- * declares `bearer` but secrets carry `header` for the same name) is a
- * call-site error and we throw at the SDK boundary instead of letting
- * the BFF reject the submission an HTTP request later.
- */
-function mergeProxyEndpointAuth(fromInstances, fromExplicitSecrets) {
-    if (fromInstances.length === 0 && fromExplicitSecrets.length === 0)
-        return [];
-    const byName = new Map();
-    for (const entry of fromExplicitSecrets) {
-        byName.set(entry.name, entry);
-    }
-    for (const entry of fromInstances) {
-        const existing = byName.get(entry.name);
-        if (existing && existing.value.type !== entry.value.type) {
-            throw new RunConfigValidationError(`aex: proxyEndpoint "${entry.name}" auth type conflicts ` +
-                `with secrets.proxyEndpointAuth (instance=${entry.value.type}, secrets=${existing.value.type})`);
-        }
-        byName.set(entry.name, entry);
-    }
-    return Array.from(byName.values());
-}
 //# sourceMappingURL=client.js.map