@oxchannels/sdk 1.0.0

package/dist/client.js

@@ -0,0 +1,661 @@
+import createClient from 'openapi-fetch';
+import { PARITY_CONTRACT_SET_VERSION, parseApiErrorEnvelopeV2, } from './generated/contracts/api-errors.js';
+const TrustedHeaders = globalThis.Headers;
+const TrustedRequest = globalThis.Request;
+const TrustedUrl = globalThis.URL;
+const trustedReflectApply = Reflect.apply;
+const trustedHeadersDelete = TrustedHeaders.prototype.delete;
+const trustedHeadersSet = TrustedHeaders.prototype.set;
+function captureIntrinsicGetter(prototype, property) {
+    const getter = Object.getOwnPropertyDescriptor(prototype, property)?.get;
+    if (getter === undefined)
+        throw new TypeError(`FETCH_INTRINSIC_MISSING:${property}`);
+    return (receiver) => trustedReflectApply(getter, receiver, []);
+}
+const trustedRequestCredentials = captureIntrinsicGetter(TrustedRequest.prototype, 'credentials');
+const trustedRequestHeaders = captureIntrinsicGetter(TrustedRequest.prototype, 'headers');
+const trustedRequestMethod = captureIntrinsicGetter(TrustedRequest.prototype, 'method');
+const trustedRequestRedirect = captureIntrinsicGetter(TrustedRequest.prototype, 'redirect');
+const trustedRequestSignal = captureIntrinsicGetter(TrustedRequest.prototype, 'signal');
+const trustedRequestUrl = captureIntrinsicGetter(TrustedRequest.prototype, 'url');
+const trustedUrlHash = captureIntrinsicGetter(TrustedUrl.prototype, 'hash');
+const trustedUrlHostname = captureIntrinsicGetter(TrustedUrl.prototype, 'hostname');
+const trustedUrlOrigin = captureIntrinsicGetter(TrustedUrl.prototype, 'origin');
+const trustedUrlPassword = captureIntrinsicGetter(TrustedUrl.prototype, 'password');
+const trustedUrlPathname = captureIntrinsicGetter(TrustedUrl.prototype, 'pathname');
+const trustedUrlProtocol = captureIntrinsicGetter(TrustedUrl.prototype, 'protocol');
+const trustedUrlSearch = captureIntrinsicGetter(TrustedUrl.prototype, 'search');
+const trustedUrlUsername = captureIntrinsicGetter(TrustedUrl.prototype, 'username');
+export const OXCHANNELS_CONTRACT_SET_VERSION = PARITY_CONTRACT_SET_VERSION;
+export class OxChannelsApiError extends Error {
+    status;
+    code;
+    traceId;
+    constructor(status, code, traceId) {
+        super(`OxChannels API request failed (${code})`);
+        this.status = status;
+        this.code = code;
+        this.traceId = traceId;
+    }
+}
+export class OxChannelsApiErrorV2 extends OxChannelsApiError {
+    schemaVersion = PARITY_CONTRACT_SET_VERSION;
+    envelope;
+    apiMessage;
+    correlationId;
+    retryable;
+    category;
+    effectEvidence;
+    retryAfterSeconds;
+    violations;
+    constructor(status, envelope) {
+        super(status, envelope.code, envelope.traceId);
+        this.name = 'OxChannelsApiErrorV2';
+        this.envelope = envelope;
+        this.apiMessage = envelope.message;
+        this.correlationId = envelope.correlationId;
+        this.retryable = envelope.retryable;
+        this.category = envelope.category;
+        this.effectEvidence = envelope.effectEvidence;
+        if (envelope.retryAfterSeconds !== undefined) {
+            this.retryAfterSeconds = envelope.retryAfterSeconds;
+        }
+        if (envelope.violations !== undefined)
+            this.violations = envelope.violations;
+    }
+}
+export class OxChannelsApiProtocolError extends Error {
+    status;
+    code = 'ERROR_ENVELOPE_INVALID';
+    constructor(status) {
+        super('OxChannels API returned a response outside the negotiated contract');
+        this.status = status;
+        this.name = 'OxChannelsApiProtocolError';
+    }
+}
+const MAX_ERROR_BODY_BYTES = 65_536;
+const MAX_ERROR_BODY_CHUNKS = 1_024;
+function cancelResponseBody(response) {
+    try {
+        void response.body?.cancel().catch(() => undefined);
+    }
+    catch {
+        // Cancellation is best-effort and must never delay the protocol failure.
+    }
+}
+function cancelReader(reader) {
+    try {
+        void reader.cancel().catch(() => undefined);
+    }
+    catch {
+        // Cancellation is best-effort and must never delay the protocol failure.
+    }
+}
+async function readBoundedResponseBody(response) {
+    if (response.body === null)
+        throw new TypeError('ERROR_ENVELOPE_INVALID');
+    const reader = response.body.getReader();
+    const chunks = [];
+    let totalBytes = 0;
+    let chunkCount = 0;
+    let canceled = false;
+    try {
+        while (true) {
+            const result = await reader.read();
+            if (result.done)
+                break;
+            const chunk = result.value;
+            chunkCount += 1;
+            totalBytes += chunk.byteLength;
+            if (chunkCount > MAX_ERROR_BODY_CHUNKS || totalBytes > MAX_ERROR_BODY_BYTES) {
+                canceled = true;
+                cancelReader(reader);
+                throw new TypeError('ERROR_ENVELOPE_INVALID');
+            }
+            chunks.push(chunk);
+        }
+    }
+    catch (error) {
+        if (!canceled)
+            cancelReader(reader);
+        throw error;
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(totalBytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+}
+async function readBoundedErrorJson(response) {
+    const mediaType = response.headers.get('content-type')?.split(';', 1)[0]?.trim().toLowerCase();
+    if (mediaType !== 'application/json') {
+        cancelResponseBody(response);
+        throw new TypeError('ERROR_ENVELOPE_INVALID');
+    }
+    const declaredLength = response.headers.get('content-length');
+    if (declaredLength !== null &&
+        (!/^\d+$/.test(declaredLength) || Number(declaredLength) > MAX_ERROR_BODY_BYTES)) {
+        cancelResponseBody(response);
+        throw new TypeError('ERROR_ENVELOPE_INVALID');
+    }
+    const bytes = await readBoundedResponseBody(response);
+    let value;
+    try {
+        value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+    }
+    catch {
+        throw new TypeError('ERROR_ENVELOPE_INVALID');
+    }
+    return value;
+}
+async function readV2ErrorEnvelope(response) {
+    const envelope = parseApiErrorEnvelopeV2(await readBoundedErrorJson(response));
+    const expectedCodes = response.status === 401
+        ? ['AUTHENTICATION_REQUIRED']
+        : response.status === 403
+            ? ['FORBIDDEN']
+            : response.status === 404
+                ? ['NOT_FOUND']
+                : response.status === 409
+                    ? ['CONFLICT', 'IDEMPOTENCY_CONFLICT']
+                    : response.status === 429
+                        ? ['RATE_LIMITED']
+                        : response.status >= 500 && response.status <= 599
+                            ? ['INTERNAL_SAFE_FAILURE']
+                            : response.status >= 400 && response.status <= 499
+                                ? ['INVALID_REQUEST']
+                                : [];
+    if (!expectedCodes.includes(envelope.code)) {
+        throw new TypeError('ERROR_ENVELOPE_STATUS_CODE_MISMATCH');
+    }
+    return envelope;
+}
+function contractV2ErrorMiddleware(onUnauthorized) {
+    return {
+        async onResponse({ response }) {
+            if (!response.ok) {
+                let envelope;
+                try {
+                    envelope = await readV2ErrorEnvelope(response);
+                }
+                catch {
+                    throw new OxChannelsApiProtocolError(response.status);
+                }
+                if (response.status === 401 && envelope.code === 'AUTHENTICATION_REQUIRED') {
+                    onUnauthorized?.();
+                }
+                throw new OxChannelsApiErrorV2(response.status, envelope);
+            }
+            return response;
+        },
+    };
+}
+function requiredHeaderValue(value, label, minimum, maximum) {
+    if (typeof value !== 'string' ||
+        value.length < minimum ||
+        value.length > maximum ||
+        value !== value.trim() ||
+        /[\r\n\0]/.test(value)) {
+        throw new TypeError(`${label}_INVALID`);
+    }
+    return value;
+}
+function optionalCorrelationId(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || !/^[A-Za-z0-9_-]{8,64}$/.test(value)) {
+        throw new TypeError('CORRELATION_ID_INVALID');
+    }
+    return value;
+}
+function combineAbortSignals(signals) {
+    const uniqueSignals = [...new Set(signals)];
+    if (typeof AbortSignal.any === 'function') {
+        return { signal: AbortSignal.any(uniqueSignals), cleanup: () => undefined };
+    }
+    const controller = new AbortController();
+    const listeners = [];
+    const cleanup = () => {
+        for (const { signal, listener } of listeners)
+            signal.removeEventListener('abort', listener);
+        listeners.length = 0;
+    };
+    const forwardAbort = (signal) => {
+        if (!controller.signal.aborted)
+            controller.abort(signal.reason);
+        cleanup();
+    };
+    for (const signal of uniqueSignals) {
+        if (signal.aborted) {
+            forwardAbort(signal);
+            break;
+        }
+        const listener = () => forwardAbort(signal);
+        listeners.push({ signal, listener });
+        signal.addEventListener('abort', listener, { once: true });
+    }
+    return { signal: controller.signal, cleanup };
+}
+function requestAbortSignal(input, init) {
+    if (init?.signal !== undefined && init.signal !== null)
+        return init.signal;
+    try {
+        return trustedRequestSignal(input);
+    }
+    catch {
+        return undefined;
+    }
+}
+function copyResponseMetadata(source, target) {
+    for (const property of ['url', 'redirected', 'type']) {
+        try {
+            Object.defineProperty(target, property, {
+                configurable: true,
+                enumerable: false,
+                value: source[property],
+            });
+        }
+        catch {
+            // Status, headers and body remain standards-compliant if a runtime rejects metadata shadowing.
+        }
+    }
+}
+function responseWithAbortLifecycle(response, signal, cleanup) {
+    if (response.body === null) {
+        cleanup();
+        return response;
+    }
+    const reader = response.body.getReader();
+    let controller;
+    let finished = false;
+    const finish = () => {
+        if (finished)
+            return false;
+        finished = true;
+        signal.removeEventListener('abort', abort);
+        cleanup();
+        return true;
+    };
+    function abort() {
+        if (!finish())
+            return;
+        const reason = signal.reason ?? new DOMException('Request aborted', 'AbortError');
+        try {
+            controller?.error(reason);
+        }
+        finally {
+            try {
+                void reader
+                    .cancel(reason)
+                    .catch(() => undefined)
+                    .finally(() => reader.releaseLock());
+            }
+            catch {
+                // Cancellation is best-effort after the abort has reached the consumer.
+            }
+        }
+    }
+    const body = new ReadableStream({
+        start(streamController) {
+            controller = streamController;
+            if (signal.aborted)
+                abort();
+            else
+                signal.addEventListener('abort', abort, { once: true });
+        },
+        async pull(streamController) {
+            try {
+                const result = await reader.read();
+                if (finished)
+                    return;
+                if (result.done) {
+                    reader.releaseLock();
+                    finish();
+                    streamController.close();
+                }
+                else {
+                    streamController.enqueue(result.value);
+                }
+            }
+            catch (error) {
+                if (finish()) {
+                    reader.releaseLock();
+                    streamController.error(error);
+                }
+            }
+        },
+        async cancel(reason) {
+            if (!finish())
+                return;
+            try {
+                await reader.cancel(reason);
+            }
+            catch {
+                // The consumer cancellation is already authoritative.
+            }
+            finally {
+                reader.releaseLock();
+            }
+        },
+    });
+    const wrapped = new Response(body, {
+        headers: response.headers,
+        status: response.status,
+        statusText: response.statusText,
+    });
+    copyResponseMetadata(response, wrapped);
+    return wrapped;
+}
+function boundedFetch(fetchImplementation, timeoutMs = 15_000) {
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 120_000) {
+        throw new TypeError('TIMEOUT_MS_INVALID');
+    }
+    const fetchWithTimeout = (input, init) => {
+        const timeoutController = new AbortController();
+        const timeoutId = setTimeout(() => timeoutController.abort(new DOMException('Request timed out', 'TimeoutError')), timeoutMs);
+        const callerSignal = requestAbortSignal(input, init);
+        const combined = combineAbortSignals(callerSignal === undefined
+            ? [timeoutController.signal]
+            : [callerSignal, timeoutController.signal]);
+        const cleanup = () => {
+            clearTimeout(timeoutId);
+            combined.cleanup();
+        };
+        try {
+            return Promise.resolve(fetchImplementation(input, { ...init, signal: combined.signal })).then((response) => responseWithAbortLifecycle(response, combined.signal, cleanup), (error) => {
+                cleanup();
+                throw error;
+            });
+        }
+        catch (error) {
+            cleanup();
+            throw error;
+        }
+    };
+    return fetchWithTimeout;
+}
+function isLoopbackHostname(hostname) {
+    return hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '[::1]';
+}
+function canonicalOpenApiFetchBaseUrl(baseUrl) {
+    if (baseUrl === '' || baseUrl === '/')
+        return '/';
+    return baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+}
+function validateClientBaseUrl(baseUrl, allowInsecureLoopbackForDevelopment, allowBrowserRelative, policyName) {
+    const errorCode = `${policyName}_BASE_URL_INVALID`;
+    if (typeof baseUrl !== 'string' || baseUrl !== baseUrl.trim() || /[\r\n\0\\]/.test(baseUrl)) {
+        throw new TypeError(errorCode);
+    }
+    if (!baseUrl.startsWith('https://') && !baseUrl.startsWith('http://')) {
+        if (!allowBrowserRelative ||
+            !baseUrl.startsWith('/') ||
+            baseUrl.startsWith('//') ||
+            baseUrl.includes('?') ||
+            baseUrl.includes('#')) {
+            throw new TypeError(errorCode);
+        }
+        let browserOrigin;
+        if (typeof globalThis.location?.origin === 'string') {
+            try {
+                browserOrigin = new TrustedUrl(globalThis.location.origin);
+            }
+            catch {
+                throw new TypeError(errorCode);
+            }
+            if (trustedUrlUsername(browserOrigin) !== '' ||
+                trustedUrlPassword(browserOrigin) !== '' ||
+                trustedUrlPathname(browserOrigin) !== '/' ||
+                trustedUrlSearch(browserOrigin) !== '' ||
+                trustedUrlHash(browserOrigin) !== '' ||
+                (trustedUrlProtocol(browserOrigin) !== 'https:' &&
+                    !(trustedUrlProtocol(browserOrigin) === 'http:' &&
+                        allowInsecureLoopbackForDevelopment &&
+                        isLoopbackHostname(trustedUrlHostname(browserOrigin))))) {
+                throw new TypeError(errorCode);
+            }
+        }
+        return {
+            canonicalBaseUrl: canonicalOpenApiFetchBaseUrl(baseUrl),
+            ...(browserOrigin === undefined ? {} : { origin: trustedUrlOrigin(browserOrigin) }),
+        };
+    }
+    let parsed;
+    try {
+        parsed = new TrustedUrl(baseUrl);
+    }
+    catch {
+        throw new TypeError(errorCode);
+    }
+    if (trustedUrlUsername(parsed) !== '' ||
+        trustedUrlPassword(parsed) !== '' ||
+        trustedUrlSearch(parsed) !== '' ||
+        trustedUrlHash(parsed) !== '' ||
+        (trustedUrlProtocol(parsed) !== 'https:' &&
+            !(trustedUrlProtocol(parsed) === 'http:' &&
+                allowInsecureLoopbackForDevelopment &&
+                isLoopbackHostname(trustedUrlHostname(parsed))))) {
+        throw new TypeError(errorCode);
+    }
+    return {
+        canonicalBaseUrl: canonicalOpenApiFetchBaseUrl(baseUrl),
+        origin: trustedUrlOrigin(parsed),
+    };
+}
+function assertTrustedRequest(request, baseUrl, expectedCredentials, policyName) {
+    if (trustedRequestRedirect(request) !== 'error') {
+        throw new TypeError(`${policyName}_REDIRECT_POLICY_INVALID`);
+    }
+    if (trustedRequestCredentials(request) !== expectedCredentials) {
+        throw new TypeError(`${policyName}_CREDENTIALS_POLICY_INVALID`);
+    }
+    let requestUrl;
+    try {
+        requestUrl = new TrustedUrl(trustedRequestUrl(request));
+    }
+    catch {
+        throw new TypeError(`${policyName}_REQUEST_URL_INVALID`);
+    }
+    if (baseUrl.origin === undefined ||
+        trustedUrlOrigin(requestUrl) !== baseUrl.origin ||
+        trustedUrlUsername(requestUrl) !== '' ||
+        trustedUrlPassword(requestUrl) !== '') {
+        throw new TypeError(`${policyName}_REQUEST_URL_INVALID`);
+    }
+}
+function createTrustedFetch(options) {
+    const downstream = options.timeoutMs === undefined
+        ? options.fetch
+        : boundedFetch(options.fetch, options.timeoutMs);
+    return async (input) => {
+        const trustedRequest = new TrustedRequest(input);
+        assertTrustedRequest(trustedRequest, options.baseUrl, options.credentials, options.policyName);
+        await options.decorate(trustedRequest);
+        return downstream(trustedRequest);
+    };
+}
+function setTrustedHeader(request, name, value) {
+    trustedReflectApply(trustedHeadersSet, trustedRequestHeaders(request), [name, value]);
+}
+function deleteTrustedHeader(request, name) {
+    trustedReflectApply(trustedHeadersDelete, trustedRequestHeaders(request), [name]);
+}
+const PROVIDER_BINDING_ROTATION_PATH = /(?:^|\/)v1\/workspaces\/([0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})\/provider-apps\/([0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})\/bindings$/iu;
+const PROVIDER_BINDING_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+function decorateProviderBindingRotationFence(request, supplier) {
+    deleteTrustedHeader(request, 'x-oxchannels-expected-binding-id');
+    if (supplier === undefined || trustedRequestMethod(request) !== 'POST')
+        return;
+    const requestUrl = new TrustedUrl(trustedRequestUrl(request));
+    const match = PROVIDER_BINDING_ROTATION_PATH.exec(trustedUrlPathname(requestUrl));
+    if (match === null)
+        return;
+    const workspaceId = match[1];
+    const registrationId = match[2];
+    if (workspaceId === undefined || registrationId === undefined) {
+        throw new TypeError('PROVIDER_BINDING_ROTATION_PATH_INVALID');
+    }
+    let expectedBindingId;
+    try {
+        expectedBindingId = supplier({
+            workspaceId: workspaceId.toLowerCase(),
+            registrationId: registrationId.toLowerCase(),
+        });
+    }
+    catch {
+        throw new TypeError('PROVIDER_BINDING_ROTATION_FENCE_UNAVAILABLE');
+    }
+    if (expectedBindingId === undefined)
+        return;
+    if (typeof expectedBindingId !== 'string' ||
+        !PROVIDER_BINDING_ID_PATTERN.test(expectedBindingId)) {
+        throw new TypeError('PROVIDER_BINDING_ROTATION_FENCE_INVALID');
+    }
+    setTrustedHeader(request, 'x-oxchannels-expected-binding-id', expectedBindingId.toLowerCase());
+}
+function trustBoundaryMiddleware(baseUrl, expectedCredentials, trustedFetch, policyName) {
+    return {
+        onRequest({ request, options }) {
+            assertTrustedRequest(request, baseUrl, expectedCredentials, policyName);
+            if (canonicalOpenApiFetchBaseUrl(options.baseUrl) !== baseUrl.canonicalBaseUrl) {
+                throw new TypeError(`${policyName}_REQUEST_URL_INVALID`);
+            }
+            if (options.fetch !== trustedFetch) {
+                throw new TypeError(`${policyName}_FETCH_POLICY_INVALID`);
+            }
+        },
+    };
+}
+export function createPublicClient(options = {}) {
+    const publicBaseUrl = validateClientBaseUrl(options.baseUrl ?? '/', options.allowInsecureLoopbackForDevelopment === true, true, 'PUBLIC');
+    const trustedFetch = createTrustedFetch({
+        baseUrl: publicBaseUrl,
+        credentials: 'omit',
+        policyName: 'PUBLIC',
+        fetch: options.fetch ?? globalThis.fetch,
+        timeoutMs: options.timeoutMs ?? 15_000,
+        decorate(request) {
+            setTrustedHeader(request, 'OxChannels-Contract-Set', OXCHANNELS_CONTRACT_SET_VERSION);
+        },
+    });
+    const client = createClient({
+        baseUrl: publicBaseUrl.canonicalBaseUrl,
+        credentials: 'omit',
+        redirect: 'error',
+        fetch: trustedFetch,
+    });
+    client.use(trustBoundaryMiddleware(publicBaseUrl, 'omit', trustedFetch, 'PUBLIC'));
+    client.use(contractV2ErrorMiddleware(options.onUnauthorized));
+    return client;
+}
+export function createDashboardV2Client(options) {
+    const dashboardBaseUrl = validateClientBaseUrl(options.baseUrl ?? '/', options.allowInsecureLoopbackForDevelopment === true, true, 'DASHBOARD');
+    const trustedFetch = createTrustedFetch({
+        baseUrl: dashboardBaseUrl,
+        credentials: 'include',
+        policyName: 'DASHBOARD',
+        fetch: options.fetch ?? globalThis.fetch,
+        timeoutMs: options.timeoutMs ?? 15_000,
+        decorate(request) {
+            setTrustedHeader(request, 'OxChannels-Contract-Set', OXCHANNELS_CONTRACT_SET_VERSION);
+            decorateProviderBindingRotationFence(request, options.expectedProviderBindingId);
+            const method = trustedRequestMethod(request);
+            if (method !== 'GET' && method !== 'HEAD') {
+                let untrustedCsrf;
+                try {
+                    untrustedCsrf = options.csrfToken();
+                }
+                catch {
+                    throw new TypeError('CSRF_TOKEN_UNAVAILABLE');
+                }
+                setTrustedHeader(request, 'x-csrf-token', requiredHeaderValue(untrustedCsrf, 'CSRF_TOKEN', 16, 4_096));
+            }
+            if (options.requestId !== undefined) {
+                setTrustedHeader(request, 'x-request-id', options.requestId());
+            }
+        },
+    });
+    const client = createClient({
+        baseUrl: dashboardBaseUrl.canonicalBaseUrl,
+        credentials: 'include',
+        redirect: 'error',
+        fetch: trustedFetch,
+    });
+    client.use(trustBoundaryMiddleware(dashboardBaseUrl, 'include', trustedFetch, 'DASHBOARD'));
+    client.use(contractV2ErrorMiddleware(options.onUnauthorized));
+    return client;
+}
+export function createPartnerClient(options) {
+    const partnerBaseUrl = validateClientBaseUrl(options.baseUrl, options.allowInsecureLoopbackForDevelopment === true, false, 'PARTNER');
+    const trustedFetch = createTrustedFetch({
+        baseUrl: partnerBaseUrl,
+        credentials: 'omit',
+        policyName: 'PARTNER',
+        fetch: options.fetch ?? globalThis.fetch,
+        timeoutMs: options.timeoutMs ?? 15_000,
+        decorate(request) {
+            setTrustedHeader(request, 'OxChannels-Contract-Set', OXCHANNELS_CONTRACT_SET_VERSION);
+            const readServiceKey = options.serviceKey ?? options.bearer;
+            if (readServiceKey === undefined)
+                throw new TypeError('SERVICE_KEY_REQUIRED');
+            let untrustedServiceKey;
+            try {
+                untrustedServiceKey = readServiceKey();
+            }
+            catch {
+                throw new TypeError('SERVICE_KEY_UNAVAILABLE');
+            }
+            const serviceKey = requiredHeaderValue(untrustedServiceKey, 'SERVICE_KEY', 1, 8_192);
+            setTrustedHeader(request, 'authorization', `Bearer ${serviceKey}`);
+            let untrustedCorrelationId;
+            try {
+                untrustedCorrelationId = options.correlationId?.();
+            }
+            catch {
+                throw new TypeError('CORRELATION_ID_UNAVAILABLE');
+            }
+            const correlationId = optionalCorrelationId(untrustedCorrelationId);
+            if (correlationId !== undefined) {
+                setTrustedHeader(request, 'x-correlation-id', correlationId);
+            }
+        },
+    });
+    const client = createClient({
+        baseUrl: partnerBaseUrl.canonicalBaseUrl,
+        credentials: 'omit',
+        redirect: 'error',
+        fetch: trustedFetch,
+    });
+    client.use(trustBoundaryMiddleware(partnerBaseUrl, 'omit', trustedFetch, 'PARTNER'));
+    client.use(contractV2ErrorMiddleware());
+    return client;
+}
+export function createAgentBootstrapClient(options) {
+    const agentBaseUrl = validateClientBaseUrl(options.baseUrl, options.allowInsecureLoopbackForDevelopment === true, false, 'AGENT_BOOTSTRAP');
+    const trustedFetch = createTrustedFetch({
+        baseUrl: agentBaseUrl,
+        credentials: 'omit',
+        policyName: 'AGENT_BOOTSTRAP',
+        fetch: options.fetch ?? globalThis.fetch,
+        timeoutMs: options.timeoutMs ?? 15_000,
+        decorate(request) {
+            setTrustedHeader(request, 'OxChannels-Contract-Set', OXCHANNELS_CONTRACT_SET_VERSION);
+        },
+    });
+    const client = createClient({
+        baseUrl: agentBaseUrl.canonicalBaseUrl,
+        credentials: 'omit',
+        redirect: 'error',
+        fetch: trustedFetch,
+    });
+    client.use(trustBoundaryMiddleware(agentBaseUrl, 'omit', trustedFetch, 'AGENT_BOOTSTRAP'));
+    client.use(contractV2ErrorMiddleware());
+    return client;
+}
+export const createDashboardContractClient = createDashboardV2Client;
+export const createOxStudioClient = createPartnerClient;