@playcraft/cli 0.1.86 → 0.1.87

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');
+}