@playcraft/cli 0.1.85-beta → 0.1.87

package/dist/utils/image-asset-context.js

@@ -2,7 +2,7 @@ import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import path from 'node:path';
 import JSON5 from 'json5';
 import sharp from 'sharp';
-import { extractAssetFields, getByPath, resolveAiImageTargetConstraints, resolveImageBackgroundRequirement, THEME_SCHEMA_PATH, themeDataPath, } from '@playcraft/common/prefab';
+import { extractAssetFields, getByPath, parseThemeIndexImportPath, resolveAiImageTargetConstraints, resolveImageBackgroundRequirement, THEME_INDEX_PATH, THEME_SCHEMA_PATH, themeDataPath, } from '@playcraft/common/prefab';
 function isWithinDirectory(root, file) {
     const relative = path.relative(root, file);
     return relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
@@ -38,20 +38,29 @@ export function assertImageAssetOutputPaths(context, outputPaths, projectDir = p
     const root = path.resolve(projectDir);
     const target = canonicalProjectPath(root, context.targetAssetPath);
     const targetStat = statSync(target);
-    const outputRoots = [root, ...allowedOutputRoots.map(outputRoot => path.resolve(root, outputRoot))];
+    const outputRoots = [
+        root,
+        ...allowedOutputRoots.map((outputRoot) => path.resolve(root, outputRoot)),
+    ];
     for (const output of outputPaths) {
         const mapped = output.startsWith('/project/') ? output.slice('/project/'.length) : output;
         const { dir, name } = path.parse(mapped);
         // The response encoding can change the requested extension.
-        const candidates = [mapped, ...['.png', '.webp', '.jpg', '.gif', '.bmp'].map(ext => path.join(dir, `${name}${ext}`))];
+        const candidates = [
+            mapped,
+            ...['.png', '.webp', '.jpg', '.gif', '.bmp'].map((ext) => path.join(dir, `${name}${ext}`)),
+        ];
         for (const candidate of candidates) {
             const candidatePath = path.resolve(root, candidate);
-            const outputRoot = outputRoots.find(allowed => isWithinDirectory(allowed, candidatePath));
+            const outputRoot = outputRoots.find((allowed) => isWithinDirectory(allowed, candidatePath));
             if (!outputRoot)
                 throw new Error(`Image output path is outside the project and allowed output roots: ${output}`);
             const file = canonicalProjectPath(outputRoot, candidatePath);
             const fileStat = existsSync(file) ? statSync(file) : undefined;
-            if (!path.relative(target, file) || (targetStat.ino !== 0 && fileStat?.ino === targetStat.ino && fileStat.dev === targetStat.dev)) {
+            if (!path.relative(target, file) ||
+                (targetStat.ino !== 0 &&
+                    fileStat?.ino === targetStat.ino &&
+                    fileStat.dev === targetStat.dev)) {
                 throw new Error(`Cannot overwrite shared image asset ${context.targetAssetPath}: other fields have different requirements. Use a separate outputPath, then explicitly update the selected field reference; no shared asset was changed.`);
             }
         }
@@ -71,8 +80,10 @@ function projectFile(root, input) {
 /** Read the same per-field constraints used by the asset image dialog. */
 export async function readImageAssetContext(assetPath, projectDir = process.cwd(), options = {}) {
     const targetFieldPath = options.targetFieldPath;
-    if (targetFieldPath !== undefined && (!Array.isArray(targetFieldPath)
-        || !targetFieldPath.length || targetFieldPath.some(key => typeof key !== 'string' || !key.length))) {
+    if (targetFieldPath !== undefined &&
+        (!Array.isArray(targetFieldPath) ||
+            !targetFieldPath.length ||
+            targetFieldPath.some((key) => typeof key !== 'string' || !key.length))) {
         throw new Error('targetFieldPath must be a non-empty array of non-empty field names.');
     }
     const root = path.resolve(projectDir);
@@ -81,24 +92,36 @@ export async function readImageAssetContext(assetPath, projectDir = process.cwd(
     const targetStat = statSync(target);
     const relativeTarget = path.relative(root, target).replace(/\\/g, '/');
     const themeMatch = relativeTarget.match(/^src\/theme\/([^/]+)\/assets\//);
+    const indexFile = path.join(root, THEME_INDEX_PATH);
+    const themeId = themeMatch?.[1] ??
+        (existsSync(indexFile)
+            ? parseThemeIndexImportPath(readFileSync(projectFile(root, THEME_INDEX_PATH), 'utf8'))
+            : null);
     let fields = [];
     const schemaFile = path.join(root, THEME_SCHEMA_PATH);
-    if (themeMatch && existsSync(schemaFile)) {
+    if (themeId && existsSync(schemaFile)) {
         const schema = JSON5.parse(readFileSync(projectFile(root, THEME_SCHEMA_PATH), 'utf8'));
-        const dataPath = themeDataPath(themeMatch[1]);
+        const dataPath = themeDataPath(themeId);
         const data = existsSync(path.join(root, dataPath))
-            ? JSON5.parse(readFileSync(projectFile(root, dataPath), 'utf8')) : {};
+            ? JSON5.parse(readFileSync(projectFile(root, dataPath), 'utf8'))
+            : {};
         const themeRoot = path.dirname(path.join(root, dataPath));
-        const matches = extractAssetFields(schema, data).filter(candidate => {
+        const matches = extractAssetFields(schema, data).filter((candidate) => {
             let configured = getByPath(data, candidate.path);
             if (configured === undefined && ['gameplay', 'gamePlay'].includes(candidate.path[0])) {
-                configured = getByPath(data, [candidate.path[0] === 'gameplay' ? 'gamePlay' : 'gameplay', ...candidate.path.slice(1)]);
+                configured = getByPath(data, [
+                    candidate.path[0] === 'gameplay' ? 'gamePlay' : 'gameplay',
+                    ...candidate.path.slice(1),
+                ]);
             }
             const value = typeof configured === 'string' ? configured : candidate.schema.default;
             if (typeof value !== 'string' || /^https?:\/\//i.test(value))
                 return false;
-            const configuredPath = value.startsWith('/project/') ? path.resolve(root, value.slice('/project/'.length))
-                : path.resolve(themeRoot, value);
+            const configuredPath = value.startsWith('/project/')
+                ? path.resolve(root, value.slice('/project/'.length))
+                : /^\/?src\//.test(value)
+                    ? path.resolve(root, value.replace(/^\//, ''))
+                    : path.resolve(themeRoot, value);
             if (configuredPath === target)
                 return true;
             try {
@@ -106,19 +129,22 @@ export async function readImageAssetContext(assetPath, projectDir = process.cwd(
                 if (!path.relative(realTarget, realpathSync(candidateFile)))
                     return true;
                 const candidateStat = statSync(candidateFile);
-                return targetStat.ino !== 0 && candidateStat.ino === targetStat.ino && candidateStat.dev === targetStat.dev;
+                return (targetStat.ino !== 0 &&
+                    candidateStat.ino === targetStat.ino &&
+                    candidateStat.dev === targetStat.dev);
             }
             catch {
                 // Other fields may reference missing files or paths outside this project.
                 return false;
             }
         });
-        if (!matches.length)
+        if (!matches.length && (themeMatch || targetFieldPath))
             throw new Error(`No image schema field matches ${relativeTarget}; check theme.data.json5 before generating.`);
         fields = matches;
-        if (targetFieldPath && !fields.some(candidate => candidate.path.length === targetFieldPath.length
-            && candidate.path.every((key, index) => key === targetFieldPath[index]))) {
-            throw new Error(`targetFieldPath ${JSON.stringify(targetFieldPath)} does not reference ${relativeTarget}. Matching fields: ${matches.map(candidate => JSON.stringify(candidate.path)).join(', ')}.`);
+        if (targetFieldPath &&
+            !fields.some((candidate) => candidate.path.length === targetFieldPath.length &&
+                candidate.path.every((key, index) => key === targetFieldPath[index]))) {
+            throw new Error(`targetFieldPath ${JSON.stringify(targetFieldPath)} does not reference ${relativeTarget}. Matching fields: ${matches.map((candidate) => JSON.stringify(candidate.path)).join(', ')}.`);
         }
     }
     else if (targetFieldPath) {
@@ -131,22 +157,35 @@ export async function readImageAssetContext(assetPath, projectDir = process.cwd(
         const ext = xp?.ext;
         // Schema references follow the dialog's root/theme conventions; explicit tool paths do not change.
         const schemaReferences = Array.isArray(ext?.reference_image)
-            ? ext.reference_image.filter(ref => typeof ref === 'string' && ref.trim()).map(ref => {
+            ? ext.reference_image
+                .filter((ref) => typeof ref === 'string' && ref.trim())
+                .map((ref) => {
                 const raw = ref.trim().replace(/\\/g, '/');
-                const normalized = raw.replace(/^\.\/+/, '').replace(/^\/+/, '').replace(/\/{2,}/g, '/');
+                const normalized = raw
+                    .replace(/^\.\/+/, '')
+                    .replace(/^\/+/, '')
+                    .replace(/\/{2,}/g, '/');
                 if (/^\/?(?:assets|src|public)\//.test(raw) || normalized.startsWith('src/'))
                     return normalized;
-                if (!themeMatch || path.isAbsolute(raw) || /^https?:\/\//i.test(raw))
+                if (!themeId || path.isAbsolute(raw) || /^https?:\/\//i.test(raw))
                     return raw;
-                return path.posix.join('src/theme', themeMatch[1], normalized);
-            }) : [];
-        const references = options.referenceImagePaths?.length ? options.referenceImagePaths
-            : options.useTargetReference === false ? [] : schemaReferences.length ? schemaReferences : [relativeTarget];
-        const referenceImagePaths = references.map(ref => /^https?:\/\//i.test(ref) ? ref
+                return path.posix.join('src/theme', themeId, normalized);
+            })
+            : [];
+        const references = options.referenceImagePaths?.length
+            ? options.referenceImagePaths
+            : options.useTargetReference === false
+                ? []
+                : schemaReferences.length
+                    ? schemaReferences
+                    : [relativeTarget];
+        const referenceImagePaths = references.map((ref) => /^https?:\/\//i.test(ref)
+            ? ref
             : path.relative(realpathSync(root), canonicalProjectPath(root, ref)).replace(/\\/g, '/'));
         const hasSchemaBackground = typeof ext?.remove_background === 'boolean';
         if (!hasSchemaBackground && targetHasTransparency === undefined) {
-            targetHasTransparency = !!targetMeta.hasAlpha && (await sharp(target).stats()).channels.at(-1).min < 250;
+            targetHasTransparency =
+                !!targetMeta.hasAlpha && (await sharp(target).stats()).channels.at(-1).min < 250;
         }
         const removeBackground = resolveImageBackgroundRequirement({
             prompt: options.prompt ?? '',
@@ -171,12 +210,16 @@ export async function readImageAssetContext(assetPath, projectDir = process.cwd(
             targetAssetPath: relativeTarget,
             fieldPath: field?.path,
             referenceImagePaths,
-            width: delivery.width, height: delivery.height,
+            width: delivery.width,
+            height: delivery.height,
             aspectRatio: typeof ext?.ratio === 'string' ? ext.ratio : `${delivery.width}:${delivery.height}`,
             outputFormat: (removeBackground && delivery.format === 'jpeg' && !delivery.fromSchemaMimeType
-                ? 'png' : delivery.format),
+                ? 'png'
+                : delivery.format),
             outputFormatFromSchema: delivery.fromSchemaMimeType,
-            fitMode: delivery.fitMode, removeBackground: delivery.removeBackground, paddingColor: delivery.paddingColor,
+            fitMode: delivery.fitMode,
+            removeBackground: delivery.removeBackground,
+            paddingColor: delivery.paddingColor,
             removeBackgroundFromSchema: hasSchemaBackground,
             imageModelRef: typeof ext?.imageModelRef === 'string' ? ext.imageModelRef : undefined,
         };
@@ -188,33 +231,40 @@ export async function readImageAssetContext(assetPath, projectDir = process.cwd(
             contexts.push(await contextForField(field));
         }
         catch (error) {
-            const selected = field?.path.length === targetFieldPath?.length
-                && field?.path.every((key, index) => key === targetFieldPath?.[index]);
+            const selected = field?.path.length === targetFieldPath?.length &&
+                field?.path.every((key, index) => key === targetFieldPath?.[index]);
             if (!targetFieldPath || selected)
                 throw error;
             // Invalid sibling requirements still protect the original shared file.
             unresolvedSharedField = true;
         }
     }
-    const context = targetFieldPath ? contexts.find(candidate => candidate.fieldPath?.length === targetFieldPath.length
-        && candidate.fieldPath.every((key, index) => key === targetFieldPath[index])) : contexts[0];
+    const context = targetFieldPath
+        ? contexts.find((candidate) => candidate.fieldPath?.length === targetFieldPath.length &&
+            candidate.fieldPath.every((key, index) => key === targetFieldPath[index]))
+        : contexts[0];
     const deliveryKey = ({ fieldPath: _fieldPath, outputFormatFromSchema: _formatSource, removeBackgroundFromSchema: _backgroundSource, aspectRatio, ...delivery }) => {
         const ratio = aspectRatio.match(/^\s*(\d+(?:\.\d+)?)\s*:\s*(\d+(?:\.\d+)?)\s*$/);
-        return JSON.stringify({ ...delivery, aspectRatio: ratio && Number(ratio[2]) > 0 ? Number(ratio[1]) / Number(ratio[2]) : aspectRatio });
+        return JSON.stringify({
+            ...delivery,
+            aspectRatio: ratio && Number(ratio[2]) > 0 ? Number(ratio[1]) / Number(ratio[2]) : aspectRatio,
+        });
     };
-    const conflicting = unresolvedSharedField || contexts.some(candidate => deliveryKey(candidate) !== deliveryKey(context));
+    const conflicting = unresolvedSharedField ||
+        contexts.some((candidate) => deliveryKey(candidate) !== deliveryKey(context));
     if (conflicting && !targetFieldPath) {
-        throw new Error(`Multiple image fields use ${relativeTarget} with different references or delivery constraints. Set targetFieldPath (or --target-field-path) to one of: ${fields.map(field => JSON.stringify(field.path)).join(', ')}.`);
+        throw new Error(`Multiple image fields use ${relativeTarget} with different references or delivery constraints. Set targetFieldPath (or --target-field-path) to one of: ${fields.map((field) => JSON.stringify(field.path)).join(', ')}.`);
     }
     if (targetFieldPath) {
         // A separate output retains exactly the selected field's requirements.
-        if (conflicting || contexts.some(candidate => (candidate.outputFormatFromSchema && !context.outputFormatFromSchema)
-            || (candidate.removeBackgroundFromSchema && !context.removeBackgroundFromSchema)))
+        if (conflicting ||
+            contexts.some((candidate) => (candidate.outputFormatFromSchema && !context.outputFormatFromSchema) ||
+                (candidate.removeBackgroundFromSchema && !context.removeBackgroundFromSchema)))
             context.requiresSeparateOutput = true;
     }
     else {
-        context.outputFormatFromSchema = contexts.some(candidate => candidate.outputFormatFromSchema);
-        context.removeBackgroundFromSchema = contexts.some(candidate => candidate.removeBackgroundFromSchema);
+        context.outputFormatFromSchema = contexts.some((candidate) => candidate.outputFormatFromSchema);
+        context.removeBackgroundFromSchema = contexts.some((candidate) => candidate.removeBackgroundFromSchema);
     }
     assertImageAssetOutputPaths(context, options.outputPaths ?? [], root, options.allowedOutputRoots);
     if (context.referenceImagePaths.length > 8)

package/dist/utils/tool-operation-journal.js

@@ -29,7 +29,7 @@ function holderAlive(holder) {
 }
 /** Persist an identity before sending. Store neither credentials nor request/response bodies. */
 export function beginToolOperation(path, serializedBody, recoverId, options = {}) {
-    const directory = process.env.PLAYCRAFT_TOOL_REQUEST_DIR ?? join(homedir(), '.playcraft', 'tool-requests');
+    const directory = options.directory ?? process.env.PLAYCRAFT_TOOL_REQUEST_DIR ?? join(homedir(), '.playcraft', 'tool-requests');
     if (!isAbsolute(directory))
         throw new Error('PLAYCRAFT_TOOL_REQUEST_DIR must be an absolute path');
     mkdirSync(directory, { recursive: true, mode: 0o700 });
@@ -98,8 +98,8 @@ export function beginToolOperation(path, serializedBody, recoverId, options = {}
     };
 }
 /** Read an existing identity without creating an intent or changing its receipt state. */
-export function findToolOperation(path, serializedBody, requestId) {
-    const directory = process.env.PLAYCRAFT_TOOL_REQUEST_DIR ?? join(homedir(), '.playcraft', 'tool-requests');
+export function findToolOperation(path, serializedBody, requestId, directoryOverride) {
+    const directory = directoryOverride ?? process.env.PLAYCRAFT_TOOL_REQUEST_DIR ?? join(homedir(), '.playcraft', 'tool-requests');
     if (!isAbsolute(directory))
         throw new Error('PLAYCRAFT_TOOL_REQUEST_DIR must be an absolute path');
     const inputHash = createHash('sha256').update(serializedBody).digest('hex');

package/dist/workspace-runtime/codex/config-toml.js

@@ -12,6 +12,7 @@ export function portableCodexConfig(catalogPath) {
     return {
         web_search: 'disabled',
         'features.multi_agent': true,
+        'features.unbounded_connection_retries': false,
         'features.goals': false,
         'features.apps': false,
         'features.plugins': false,
@@ -82,8 +83,8 @@ export async function writePortableCodexCatalog(input) {
     await writeFile(path, body, { encoding: 'utf8', mode: 0o644 }); // shared
     await chmod(path, 0o644);
     const versionPath = join(input.directory, 'portable-models.version.json');
-    await writeFile(// shared
-    versionPath, JSON.stringify({
+    // shared: version metadata sits beside the catalog, readable by both sandbox identities.
+    await writeFile(versionPath, JSON.stringify({
         version,
         sha256: createHash('sha256').update(body).digest('hex'),
     }), { encoding: 'utf8', mode: 0o644 });

package/dist/workspace-runtime/codex/model-broker-diagnostics.js

@@ -0,0 +1,149 @@
+const WAITING_LOG_MS = 30_000;
+const errorNames = new Set([
+    'Error',
+    'TypeError',
+    'SyntaxError',
+    'AbortError',
+    'TimeoutError',
+    'AggregateError',
+    'HeadersTimeoutError',
+    'BodyTimeoutError',
+    'SocketError',
+    'ConnectTimeoutError',
+]);
+/** Error messages may contain request bodies or credentials; retain only bounded classifications. */
+function errorChain(error) {
+    const chain = [];
+    const seen = new Set();
+    let current = error;
+    for (let depth = 0; depth < 5 && current && typeof current === 'object' && !seen.has(current); depth++) {
+        seen.add(current);
+        try {
+            const value = current;
+            const name = typeof value.name === 'string' && errorNames.has(value.name) ? value.name : undefined;
+            const code = typeof value.code === 'string' &&
+                /^(?:UND_ERR_|ERR_|E[A-Z]|CERT_|DEPTH_|UNABLE_|SELF_SIGNED_)[A-Z0-9_]{1,80}$/.test(value.code)
+                ? value.code
+                : typeof value.message === 'string' &&
+                    /^(?:model_(?:access_denied|credential_(?:unavailable|scope_mismatch|expired|timeout|invalid)|config_required|config_denied|request_(?:deadline_exceeded|cancelled|transport_error|invalid_json|too_large))|reasoning_effort_(?:denied|unsupported))$/.test(value.message)
+                    ? value.message
+                    : undefined;
+            if (name || code)
+                chain.push({ name, code });
+            current = value.cause;
+        }
+        catch {
+            break;
+        }
+    }
+    return chain;
+}
+/** Per-request metadata only; observing a stalled transfer never cancels or retries it. */
+export class ModelBrokerDiagnostics {
+    context;
+    started = performance.now();
+    stageStarted = this.started;
+    lastProgress = this.started;
+    stage = 'credential';
+    requestBytes = 0;
+    responseBytes = 0;
+    upstreamStatus;
+    abortReason;
+    responseIds = {};
+    timer;
+    constructor(context) {
+        this.context = context;
+        this.write('received');
+        this.timer = setInterval(() => {
+            if (performance.now() - this.lastProgress >= WAITING_LOG_MS)
+                this.write('waiting');
+        }, WAITING_LOG_MS);
+        this.timer.unref();
+    }
+    bind(context) {
+        Object.assign(this.context, context);
+    }
+    enter(stage) {
+        this.stage = stage;
+        this.stageStarted = this.lastProgress = performance.now();
+        this.write('stage');
+    }
+    requestChunk(bytes) {
+        this.requestBytes += bytes;
+        this.lastProgress = performance.now();
+    }
+    headers(status, headers) {
+        this.upstreamStatus = status;
+        for (const [header, field] of [
+            ['x-model-attempt-id', 'attemptId'],
+            ['x-request-id', 'proxyRequestId'],
+            ['eo-log-uuid', 'edgeOneRequestId'],
+            ['x-kong-request-id', 'kongRequestId'],
+        ]) {
+            const value = headers.get(header);
+            if (value && /^[A-Za-z0-9._:-]{1,128}$/.test(value))
+                this.responseIds[field] = value;
+        }
+        for (const [header, field] of [
+            ['x-kong-proxy-latency', 'kongProxyLatencyMs'],
+            ['x-kong-upstream-latency', 'kongUpstreamLatencyMs'],
+        ]) {
+            const value = headers.get(header);
+            if (value && /^\d{1,9}$/.test(value))
+                this.responseIds[field] = Number(value);
+        }
+        this.write('headers');
+        this.enter('response_body');
+    }
+    responseChunk(bytes) {
+        this.responseBytes += bytes;
+        this.lastProgress = performance.now();
+        if (bytes && this.responseBytes === bytes)
+            this.write('first_byte');
+    }
+    abort(reason) {
+        this.abortReason ??= reason;
+    }
+    finish(status, downstreamFinished, aborted, error) {
+        clearInterval(this.timer);
+        const outcome = error !== undefined
+            ? (this.abortReason ?? (aborted ? 'interrupted' : 'error'))
+            : this.upstreamStatus !== undefined && this.upstreamStatus >= 400
+                ? 'upstream_http_error'
+                : status >= 400
+                    ? 'rejected'
+                    : 'completed';
+        this.write('finished', {
+            outcome,
+            responseStatus: status,
+            downstreamFinished,
+            cancelled: aborted && !downstreamFinished,
+            ...(error !== undefined ? { errors: errorChain(error) } : {}),
+        });
+    }
+    write(observation, extra = {}) {
+        const now = performance.now();
+        try {
+            console.log(JSON.stringify({
+                event: 'model.broker.request',
+                time: Date.now(),
+                service: 'workspace-runtime',
+                ...this.context,
+                observation,
+                stage: this.stage,
+                elapsedMs: Math.max(0, Math.round(now - this.started)),
+                stageElapsedMs: Math.max(0, Math.round(now - this.stageStarted)),
+                idleMs: Math.max(0, Math.round(now - this.lastProgress)),
+                requestBytes: this.requestBytes,
+                responseBytes: this.responseBytes,
+                upstreamStatus: this.upstreamStatus,
+                abortReason: this.abortReason,
+                ...this.responseIds,
+                ...extra,
+            }));
+        }
+        catch {
+            /* Diagnostic output must not alter model execution. */
+        }
+    }
+}

package/dist/workspace-runtime/codex/model-broker-request.js

@@ -0,0 +1,59 @@
+export const MODEL_REQUEST_BUDGET_MS = 150_000;
+export class ModelBrokerRequestError extends Error {
+    status;
+    code;
+    constructor(status, code, cause) {
+        super(code, { cause });
+        this.status = status;
+        this.code = code;
+    }
+}
+/** Stop reading on cancellation without destroying the socket before its error response is sent. */
+export function readModelRequestBody(request, signal, append) {
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            request.off('data', data);
+            request.off('end', end);
+            request.off('error', fail);
+            signal.removeEventListener('abort', abort);
+        };
+        const fail = (error) => {
+            cleanup();
+            request.pause();
+            reject(error);
+        };
+        const data = (chunk) => {
+            try {
+                append(chunk);
+            }
+            catch (error) {
+                fail(error);
+            }
+        };
+        const end = () => {
+            cleanup();
+            resolve();
+        };
+        const abort = () => fail(signal.reason);
+        request.on('data', data);
+        request.once('end', end);
+        request.once('error', fail);
+        signal.addEventListener('abort', abort, { once: true });
+        if (signal.aborted)
+            abort();
+    });
+}
+/** Public errors contain stable classifications, never arbitrary transport or response text. */
+export function modelBrokerFailure(error, signal) {
+    if (signal.aborted) {
+        return signal.reason instanceof ModelBrokerRequestError
+            ? signal.reason
+            : new ModelBrokerRequestError(499, 'model_request_cancelled');
+    }
+    if (error instanceof ModelBrokerRequestError)
+        return error;
+    if (error instanceof Error && error.message === 'model_access_denied') {
+        return new ModelBrokerRequestError(403, error.message);
+    }
+    return new ModelBrokerRequestError(502, 'model_request_transport_error');
+}