return redacted.length > 2000 ? `${redacted.slice(0, 2000)}…<truncated>` : redacted;

}

function readRecordString(record: Record<string, unknown> | undefined, key: string): string {

type ResponsesFailedNoDetailsObservation = {

event: "openai_responses_response_failed_without_details";

provider: string;

api: Api;

transportModel: string;

providerRuntimeFailureKind: "no_error_details";

responseId: string;

responseStatus: string;

responseModel: string;

responseObject: string;

metadataKeys: string[];

requestIdHashes: string[];

failureFieldsPreview: string;

responsePreview: string;

};

type ResponsesFailedEventSummary = {

message: string;

responseId?: string;

observation?: ResponsesFailedNoDetailsObservation;

};

const RESPONSE_FAILED_FAILURE_FIELD_KEYS = [

"error",

"incomplete_details",

"status_details",

"failure_reason",

"last_error",

"provider_error",

"error_details",

] as const;

function readResponseFailedString(

record: Record<string, unknown> | undefined,

key: string,

): string {

return stringifyUnknown(record?.[key]);

}

function buildResponsesFailedEventSummary(

message: string,

responseId: string | undefined,

observation?: ResponsesFailedNoDetailsObservation,

): ResponsesFailedEventSummary {

const summary: ResponsesFailedEventSummary = { message };

if (responseId) {

summary.responseId = responseId;

}

if (observation) {

summary.observation = observation;

}

return summary;

}

function isResponseFailedIdentifierKey(key: string): boolean {

const normalized = key.replace(/[-_\s]/g, "").toLowerCase();

return (

return out;

}

function redactResponseFailedIdentifierFields(

function redactResponseFailedDiagnosticValue(

value: unknown,

opts: {

key?: string;

seen.add(value);

if (Array.isArray(value)) {

return value.slice(0, 16).map((item) =>

redactResponseFailedIdentifierFields(item, {

redactResponseFailedDiagnosticValue(item, {

key,

depth: depth + 1,

seen,

}

const out: Record<string, unknown> = {};

for (const [childKey, child] of Object.entries(value as Record<string, unknown>)) {

out[childKey] = redactResponseFailedIdentifierFields(child, {

out[childKey] = redactResponseFailedDiagnosticValue(child, {

key: childKey,

depth: depth + 1,

seen,

return out;

}

function buildResponsesFailedFailureFields(response: Record<string, unknown> | undefined) {

function buildResponsesFailedFailureFields(

response: Record<string, unknown> | undefined,

): Record<string, unknown> {

if (!response) {

return {};

}

const fields: Record<string, unknown> = {};

for (const key of [

"error",

"incomplete_details",

"status_details",

"failure_reason",

"last_error",

"provider_error",

"error_details",

]) {

for (const key of RESPONSE_FAILED_FAILURE_FIELD_KEYS) {

if (response[key] !== undefined && response[key] !== null) {

fields[key] = response[key];

}

function buildResponsesFailedNoDetailsObservation(

event: Record<string, unknown>,

model: Model<Api>,

) {

const response = isRecord(event.response) ? event.response : undefined;

const failureFields = redactResponseFailedIdentifierFields(

response: Record<string, unknown> | undefined = isRecord(event.response)

? event.response

: undefined,

): ResponsesFailedNoDetailsObservation {

const failureFields = redactResponseFailedDiagnosticValue(

buildResponsesFailedFailureFields(response),

) as Record<string, unknown>;

const metadataKeys = isRecord(response?.metadata)

? Object.keys(response.metadata).toSorted()

: [];

const responsePreview = {

id: readRecordString(response, "id"),

status: readRecordString(response, "status"),

model: readRecordString(response, "model"),

object: readRecordString(response, "object"),

id: readResponseFailedString(response, "id"),

status: readResponseFailedString(response, "status"),

model: readResponseFailedString(response, "model"),

object: readResponseFailedString(response, "object"),

failureFields,

metadataKeys: isRecord(response?.metadata)

? Object.keys(response.metadata).toSorted().join(",")

: "",

metadataKeys,

};

return {

event: "openai_responses_response_failed_without_details",

responseId: responsePreview.id,

responseStatus: responsePreview.status,

responseModel: responsePreview.model,

responseObject: responsePreview.object,

metadataKeys,

requestIdHashes: collectResponseFailedIdentifierHashes(event),

failureFieldsPreview: stringifyRedactedEvent(failureFields),

responsePreview: stringifyRedactedEvent(responsePreview),

};

}

function summarizeResponsesFailedNoDetailsObservation(

observation: ReturnType<typeof buildResponsesFailedNoDetailsObservation>,

observation: ResponsesFailedNoDetailsObservation,

): string {

const requestIds = observation.requestIdHashes.join(",");

const metadataKeys = observation.metadataKeys.join(",");

return (

`responseId=${safeDebugValue(observation.responseId || undefined)} ` +

`responseStatus=${safeDebugValue(observation.responseStatus || undefined)} ` +

`responseModel=${safeDebugValue(observation.responseModel || undefined)} ` +

`requestIds=${requestIds || "none"} response=${observation.responsePreview}`

`requestIds=${requestIds || "none"} metadataKeys=${metadataKeys || "none"} ` +

`failureFields=${observation.failureFieldsPreview}`

);

}

function responseFailedErrorMessage(

error: { code?: unknown; message?: unknown } | null | undefined,

): string | undefined {

const code = stringifyUnknown(error?.code).trim();

const message = stringifyUnknown(error?.message).trim();

if (!code && !message) {

return undefined;

function normalizeResponsesFailedEvent(

event: Record<string, unknown>,

model: Model<Api>,

): ResponsesFailedEventSummary {

const response = isRecord(event.response) ? event.response : undefined;

const responseId = readResponseFailedString(response, "id") || undefined;

const error = isRecord(response?.error) ? response.error : undefined;

if (error) {

const code = readResponseFailedString(error, "code").trim();

const message = readResponseFailedString(error, "message").trim();

if (code || message) {

return buildResponsesFailedEventSummary(

`${code || "unknown"}: ${message || "no message"}`,

responseId,

);

}

}

return `${code || "unknown"}: ${message || "no message"}`;

const incompleteDetails = isRecord(response?.incomplete_details)

? response.incomplete_details

: undefined;

const incompleteReason = readResponseFailedString(incompleteDetails, "reason");

if (incompleteReason) {

return buildResponsesFailedEventSummary(`incomplete: ${incompleteReason}`, responseId);

}

return buildResponsesFailedEventSummary(

RESPONSE_FAILED_NO_DETAILS_MESSAGE,

responseId,

buildResponsesFailedNoDetailsObservation(event, model, response),

);

}

function logResponsesFailedNoDetails(observation: ResponsesFailedNoDetailsObservation): void {

log.warn(

`[responses] response.failed missing error details provider=${observation.provider} ` +

`api=${observation.api} model=${observation.transportModel} ` +

summarizeResponsesFailedNoDetailsObservation(observation),

observation,

);

}

function summarizeResponsesPayload(params: unknown): string {

`Error Code ${stringifyUnknown(event.code, "unknown")}: ${stringifyUnknown(event.message, "Unknown error")}`,

);

} else if (type === "response.failed") {

const response = event.response as

| {

id?: string;

error?: { code?: unknown; message?: unknown } | null;

incomplete_details?: { reason?: string };

}

| undefined;

if (typeof response?.id === "string") {

output.responseId = response.id;

const failure = normalizeResponsesFailedEvent(event, model);

if (failure.responseId) {

output.responseId = failure.responseId;

}

const detailedErrorMessage = responseFailedErrorMessage(response?.error);

const msg = detailedErrorMessage

? detailedErrorMessage

: response?.incomplete_details?.reason

? `incomplete: ${response.incomplete_details.reason}`

: RESPONSE_FAILED_NO_DETAILS_MESSAGE;

if (msg === RESPONSE_FAILED_NO_DETAILS_MESSAGE) {

const observation = buildResponsesFailedNoDetailsObservation(event, model);

log.warn(

`[responses] response.failed missing error details provider=${model.provider} api=${model.api} model=${model.id} ` +

summarizeResponsesFailedNoDetailsObservation(observation),

observation,

);

if (failure.observation) {

logResponsesFailedNoDetails(failure.observation);

}

throw new Error(msg);

throw new Error(failure.message);

}

await cooperativeScheduler.afterEvent();

}

processResponsesStream,

formatModelTransportDebugBaseUrl,

buildResponsesFailedNoDetailsObservation,

normalizeResponsesFailedEvent,

summarizeResponsesFailedNoDetailsObservation,

summarizeResponsesPayload,

summarizeResponsesTools,