@navels/neal 0.1.0

package/dist/neal/providers/openai-compatible.js

@@ -0,0 +1,654 @@
+/**
+ * OpenAI-compatible structured-advisor provider on the AI SDK chat path
+ * (`@ai-sdk/openai-compatible`), replacing the bespoke `openai` npm client
+ * (Phase 2 adapter consolidation). The external contract is unchanged: same
+ * provider id, same config block, same capabilities (chat-only, no tools,
+ * no-read reviewer with inline context), same `NealProviderError`
+ * kinds/retryability, same provider events. The one sanctioned observable
+ * change is the `usage` payload shape, which is now the AI SDK's normalized
+ * shape (`inputTokens`/`outputTokens`/`totalTokens` plus details and a `raw`
+ * passthrough) instead of the raw response-body object.
+ *
+ * Gateway behaviors learned from live failures are preserved through a
+ * neal-owned `fetch` interceptor that inspects HTTP-200 JSON bodies before
+ * the SDK parses them (structural markers only — never text matching on
+ * content channels):
+ *
+ * - upstream errors embedded as a top-level `error` object inside an HTTP
+ *   200 body (OpenRouter wraps upstream 429s this way) are mapped with the
+ *   same status table as real HTTP errors so rate limits stay retryable;
+ * - responses with no assistant text in `message.content`,
+ *   `message.reasoning`, or `message.reasoning_content` are a retryable
+ *   `api_error` flowing into the bounded api-retry loop.
+ *
+ * Reasoning-model fallback (final text in `message.reasoning` /
+ * `message.reasoning_content` with empty `content`) is handled natively by
+ * the AI SDK, which surfaces both fields as `reasoningText`; the turn code
+ * prefers `result.text` and falls back to `result.reasoningText`.
+ */
+import { randomBytes } from 'node:crypto';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { generateText } from 'ai';
+import { runStructuredJsonProtocol } from '../agents/structured-json.js';
+import { getOpenAICompatibleSettings } from '../config.js';
+import { NealProviderError } from './types.js';
+const OPENAI_COMPATIBLE_PROVIDER_ID = 'openai-compatible';
+const API_RETRY_BASE_DELAY_MS = 500;
+const API_RETRY_MAX_DELAY_MS = 5_000;
+// Network-level error codes treated as transient (mirrors the
+// generic-agentic classification; statusCode 408/429/5xx, explicit
+// isRetryable, or one of these codes on the error or its cause).
+const NETWORK_ERROR_CODES = new Set([
+    'ECONNRESET',
+    'ECONNREFUSED',
+    'ETIMEDOUT',
+    'EPIPE',
+    'ENOTFOUND',
+    'EAI_AGAIN',
+    'UND_ERR_SOCKET',
+    'UND_ERR_CONNECT_TIMEOUT',
+]);
+function defaultSleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function createDefaultOpenAICompatibleModel(args) {
+    // maxRetries: 0 on each generateText call keeps Neal's own apiRetryLimit
+    // retry loop the only retry layer for this provider.
+    return createOpenAICompatible({
+        name: OPENAI_COMPATIBLE_PROVIDER_ID,
+        baseURL: args.baseUrl,
+        apiKey: args.apiKey,
+        headers: args.headers,
+        fetch: args.fetch,
+    }).chatModel(args.model);
+}
+function createOpenAICompatibleProviderError(args) {
+    return new NealProviderError({
+        message: args.message,
+        provider: OPENAI_COMPATIBLE_PROVIDER_ID,
+        role: 'structured-advisor',
+        sessionHandle: args.sessionHandle,
+        kind: args.kind,
+        retryable: args.retryable,
+        cause: args.cause,
+    });
+}
+function readStatusCode(error) {
+    const status = error.statusCode;
+    return typeof status === 'number' && Number.isFinite(status) ? status : null;
+}
+function isAbortLikeError(error) {
+    // AbortSignal.timeout aborts with a DOMException named TimeoutError on
+    // Node >= 22; caller AbortController.abort() defaults to AbortError. The
+    // AI SDK propagates the abort reason when maxRetries is 0.
+    const name = error.name;
+    return name === 'TimeoutError' || name === 'AbortError';
+}
+// Transient classification for errors WITHOUT an HTTP status: an explicit
+// SDK isRetryable marker or a known network error code (on the error or its
+// cause). Status-bearing errors must never reach this check — Neal's own
+// status table is the contract for those, and the AI SDK's APICallError
+// default marks statuses Neal treats as non-retryable (for example 409) as
+// retryable.
+function hasTransientStatuslessShape(error) {
+    if (error.isRetryable === true) {
+        return true;
+    }
+    const cause = error.cause;
+    const codes = [
+        error.code,
+        typeof cause === 'object' && cause !== null ? cause.code : undefined,
+    ];
+    return codes.some((code) => typeof code === 'string' && NETWORK_ERROR_CODES.has(code));
+}
+function describeError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'object' && error !== null) {
+        const candidate = error;
+        return typeof candidate.message === 'string' ? candidate.message : String(error);
+    }
+    return String(error);
+}
+/**
+ * Normalizes any thrown value into a NealProviderError with the bespoke
+ * adapter's classification table, expressed over AI SDK error shapes
+ * (structural markers only: `statusCode`, `isRetryable`, network `code`s,
+ * abort names) plus the abort-source disambiguation contract:
+ *
+ * - caller signal aborted -> `timeout`, retryable: false (the caller owns
+ *   the cancellation; never retried in-round);
+ * - abort without a caller abort -> inactivity expiry -> `timeout`,
+ *   retryable: true;
+ * - HTTP 401/403 -> `permission_denied`, non-retryable;
+ * - HTTP 408/429/5xx -> `api_error`, retryable;
+ * - any other HTTP status -> `provider_failed`, non-retryable (Neal's
+ *   status table is authoritative for status-bearing errors; the SDK's
+ *   `isRetryable` flag is never consulted for them because its default
+ *   marks 409 retryable, which this contract does not);
+ * - no HTTP status with explicit isRetryable or a network error code ->
+ *   `api_error`, retryable;
+ * - everything else -> `provider_failed`, non-retryable.
+ */
+function normalizeOpenAICompatibleError(error, ctx) {
+    if (error instanceof NealProviderError) {
+        return error;
+    }
+    if (ctx.callerSignal?.aborted) {
+        return createOpenAICompatibleProviderError({
+            message: `OpenAI-compatible ${ctx.label} request was aborted before completion.`,
+            sessionHandle: ctx.sessionHandle,
+            kind: 'timeout',
+            retryable: false,
+            cause: error,
+        });
+    }
+    if (typeof error === 'object' && error !== null) {
+        if (isAbortLikeError(error)) {
+            return createOpenAICompatibleProviderError({
+                message: `OpenAI-compatible ${ctx.label} request exceeded the inactivity timeout and was aborted.`,
+                sessionHandle: ctx.sessionHandle,
+                kind: 'timeout',
+                retryable: true,
+                cause: error,
+            });
+        }
+        const status = readStatusCode(error);
+        if (status !== null) {
+            // Status-bearing errors follow Neal's explicit table exclusively;
+            // the SDK's isRetryable flag is intentionally not consulted here.
+            if (status === 401 || status === 403) {
+                return createOpenAICompatibleProviderError({
+                    message: `OpenAI-compatible ${ctx.label} request was rejected with HTTP ${status}: ${describeError(error)}`,
+                    sessionHandle: ctx.sessionHandle,
+                    kind: 'permission_denied',
+                    retryable: false,
+                    cause: error,
+                });
+            }
+            if (status === 408 || status === 429 || status >= 500) {
+                return createOpenAICompatibleProviderError({
+                    message: `OpenAI-compatible ${ctx.label} request failed with HTTP ${status}: ${describeError(error)}`,
+                    sessionHandle: ctx.sessionHandle,
+                    kind: 'api_error',
+                    retryable: true,
+                    cause: error,
+                });
+            }
+            return createOpenAICompatibleProviderError({
+                message: `OpenAI-compatible ${ctx.label} request failed with HTTP ${status}: ${describeError(error)}`,
+                sessionHandle: ctx.sessionHandle,
+                kind: 'provider_failed',
+                retryable: false,
+                cause: error,
+            });
+        }
+        if (hasTransientStatuslessShape(error)) {
+            return createOpenAICompatibleProviderError({
+                message: `OpenAI-compatible ${ctx.label} request failed with a network error: ${describeError(error)}`,
+                sessionHandle: ctx.sessionHandle,
+                kind: 'api_error',
+                retryable: true,
+                cause: error,
+            });
+        }
+    }
+    return createOpenAICompatibleProviderError({
+        message: `OpenAI-compatible ${ctx.label} request failed: ${describeError(error)}`,
+        sessionHandle: ctx.sessionHandle,
+        kind: 'provider_failed',
+        retryable: false,
+        cause: error,
+    });
+}
+const EMBEDDED_ERROR_RAW_DETAIL_MAX_CHARS = 400;
+function extractEmbeddedErrorStatus(code) {
+    if (typeof code === 'number' && Number.isFinite(code)) {
+        return code;
+    }
+    if (typeof code === 'string' && /^\d+$/.test(code)) {
+        return Number(code);
+    }
+    return null;
+}
+// Some OpenAI-compatible gateways (for example OpenRouter) report upstream
+// provider failures as an `error` object inside an HTTP 200 body instead of a
+// non-200 status. Map those embedded errors with the same status rules as real
+// HTTP errors so upstream rate limits and outages stay retryable.
+function createEmbeddedResponseError(args) {
+    const errorObject = typeof args.embeddedError === 'object' && args.embeddedError !== null
+        ? args.embeddedError
+        : null;
+    const status = extractEmbeddedErrorStatus(errorObject?.code);
+    const messageText = errorObject && typeof errorObject.message === 'string' && errorObject.message
+        ? errorObject.message
+        : JSON.stringify(args.embeddedError);
+    const metadata = errorObject?.metadata;
+    const rawDetail = metadata && typeof metadata === 'object' && typeof metadata.raw === 'string'
+        ? ` (${String(metadata.raw).slice(0, EMBEDDED_ERROR_RAW_DETAIL_MAX_CHARS)})`
+        : '';
+    const message = `OpenAI-compatible ${args.label} response body reported ` +
+        `${status === null ? 'an error' : `error code ${status}`}: ${messageText}${rawDetail}`;
+    if (status === 401 || status === 403) {
+        return createOpenAICompatibleProviderError({
+            message,
+            sessionHandle: args.sessionHandle,
+            kind: 'permission_denied',
+            retryable: false,
+        });
+    }
+    if (status === 408 || status === 429 || (status !== null && status >= 500)) {
+        return createOpenAICompatibleProviderError({
+            message,
+            sessionHandle: args.sessionHandle,
+            kind: 'api_error',
+            retryable: true,
+        });
+    }
+    return createOpenAICompatibleProviderError({
+        message,
+        sessionHandle: args.sessionHandle,
+        kind: 'provider_failed',
+        retryable: false,
+    });
+}
+// Reasoning models served through OpenAI-compatible gateways can return
+// `message.content` as null or empty while the final text lands in
+// `message.reasoning` (OpenRouter) or `message.reasoning_content` (DeepSeek
+//-style APIs), for example when the response budget is consumed by reasoning
+// tokens. The AI SDK surfaces both fields as reasoning text, so a body with
+// text in any of these fields is usable; a body with text in none of them is
+// a transient upstream failure (see createInterceptingFetch).
+function extractAssistantText(message) {
+    if (typeof message?.content === 'string' && message.content !== '') {
+        return message.content;
+    }
+    if (typeof message?.reasoning === 'string' && message.reasoning !== '') {
+        return message.reasoning;
+    }
+    if (typeof message?.reasoning_content === 'string' && message.reasoning_content !== '') {
+        return message.reasoning_content;
+    }
+    return null;
+}
+function describeMissingAssistantText(response) {
+    const choice = response.choices?.[0];
+    if (!choice) {
+        return 'choices[0] was missing';
+    }
+    const message = choice.message;
+    const finishReason = typeof choice.finish_reason === 'string' ? choice.finish_reason : 'absent';
+    if (!message) {
+        return `choices[0].message was missing; finish_reason=${finishReason}`;
+    }
+    const describeField = (value) => value === undefined ? 'absent' : value === null ? 'null' : value === '' ? 'empty' : 'present';
+    return (`content=${describeField(message.content)}, reasoning=${describeField(message.reasoning)}, ` +
+        `reasoning_content=${describeField(message.reasoning_content)}; finish_reason=${finishReason}`);
+}
+/**
+ * Neal-owned fetch interceptor wired into the AI SDK provider. It inspects
+ * successful (2xx) JSON response bodies before the SDK parses them and
+ * throws the mapped NealProviderError for two gateway behaviors the SDK
+ * does not classify:
+ *
+ * - a top-level `error` object inside an HTTP 200 body (structural marker;
+ *   mapped by createEmbeddedResponseError's status table);
+ * - no assistant text in `message.content`, `message.reasoning`, or
+ *   `message.reasoning_content` (retryable `api_error`, flowing into the
+ *   bounded api-retry loop).
+ *
+ * Both checks gate on structural body shape — presence of an `error`
+ * object, absence of text fields — never on matching text that can contain
+ * document content (the channel rule). Non-2xx responses pass through
+ * untouched so the SDK's error handler attaches `statusCode` for
+ * normalizeOpenAICompatibleError. Thrown NealProviderErrors propagate
+ * unchanged through the SDK (it rethrows non-network fetch errors as-is and
+ * performs no internal retries with maxRetries: 0).
+ */
+function createInterceptingFetch(ctx) {
+    return async (input, init) => {
+        const response = await fetch(input, init);
+        if (!response.ok) {
+            return response;
+        }
+        const contentType = response.headers.get('content-type') ?? '';
+        if (!contentType.toLowerCase().includes('json')) {
+            return response;
+        }
+        let body;
+        try {
+            body = await response.clone().json();
+        }
+        catch {
+            // Let the SDK's own response handling report unparseable bodies.
+            return response;
+        }
+        if (typeof body !== 'object' || body === null) {
+            return response;
+        }
+        const completion = body;
+        if (completion.error !== undefined && completion.error !== null) {
+            throw createEmbeddedResponseError({
+                embeddedError: completion.error,
+                label: ctx.label,
+                sessionHandle: ctx.sessionHandle,
+            });
+        }
+        if (extractAssistantText(completion.choices?.[0]?.message) === null) {
+            // A response with no assistant text in any known field is treated as
+            // a transient upstream failure so it flows into the bounded API retry
+            // loop instead of permanently failing the round.
+            throw createOpenAICompatibleProviderError({
+                message: `OpenAI-compatible ${ctx.label} response did not include assistant text ` +
+                    `(${describeMissingAssistantText(completion)}).`,
+                sessionHandle: ctx.sessionHandle,
+                kind: 'api_error',
+                retryable: true,
+            });
+        }
+        return response;
+    };
+}
+function buildSyntheticSessionHandle() {
+    // Synthetic per-round handle for events only. This provider has no session
+    // resume; runStructuredRound always returns sessionHandle: null so no
+    // resumable reviewer handle is ever persisted for it.
+    return `${OPENAI_COMPATIBLE_PROVIDER_ID}:${new Date().toISOString()}:${randomBytes(4).toString('hex')}`;
+}
+function getApiRetryDelayMs(retryCount) {
+    return Math.min(API_RETRY_BASE_DELAY_MS * 2 ** (retryCount - 1), API_RETRY_MAX_DELAY_MS);
+}
+function composeAbortSignal(callerSignal, inactivityTimeoutMs) {
+    // Non-streaming chat turn, so the inactivity timeout acts as a
+    // whole-request timeout here. That is acceptable for advisor rounds, which
+    // are single prompt-in/text-out calls.
+    const timeoutSignal = AbortSignal.timeout(inactivityTimeoutMs);
+    return callerSignal ? AbortSignal.any([callerSignal, timeoutSignal]) : timeoutSignal;
+}
+async function emitProviderEvent(events, event) {
+    await events?.(event);
+}
+function resolveRoundSettings(args) {
+    let settings;
+    try {
+        settings = args.resolveSettings(args.cwd);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw createOpenAICompatibleProviderError({
+            message: `OpenAI-compatible ${args.label} settings could not be resolved: ${message}`,
+            kind: 'provider_failed',
+            retryable: false,
+            cause: error,
+        });
+    }
+    if (!settings.baseUrl) {
+        throw createOpenAICompatibleProviderError({
+            message: `OpenAI-compatible ${args.label} round has no base URL. ` +
+                'Set providers.openai_compatible.base_url in config.yml or the OPENAI_COMPATIBLE_BASE_URL environment variable.',
+            kind: 'provider_failed',
+            retryable: false,
+        });
+    }
+    const model = args.roundModel ?? args.roleModel ?? settings.defaultModel;
+    if (!model) {
+        throw createOpenAICompatibleProviderError({
+            message: `OpenAI-compatible ${args.label} round has no model. ` +
+                'Set a role model override (for example agent.reviewer.model), providers.openai_compatible.default_model in config.yml, or the OPENAI_COMPATIBLE_MODEL environment variable.',
+            kind: 'provider_failed',
+            retryable: false,
+        });
+    }
+    if (!settings.apiKey) {
+        throw createOpenAICompatibleProviderError({
+            message: `OpenAI-compatible ${args.label} round has no API key. ` +
+                `Set the ${settings.apiKeyEnv} environment variable.`,
+            kind: 'permission_denied',
+            retryable: false,
+        });
+    }
+    return {
+        baseUrl: settings.baseUrl,
+        apiKey: settings.apiKey,
+        model,
+        headers: settings.headers,
+    };
+}
+class OpenAICompatibleStructuredAdvisorAdapter {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async runStructuredRound(args) {
+        const sessionHandle = buildSyntheticSessionHandle();
+        try {
+            const protocol = args.structuredJsonProtocol;
+            if (!protocol || protocol.protocol !== 'neal-json-block-v1') {
+                throw createOpenAICompatibleProviderError({
+                    message: `OpenAI-compatible ${args.label} rounds require the neal-json-block-v1 structured JSON protocol; ` +
+                        'this provider does not support provider-native structured output schemas.',
+                    sessionHandle,
+                    kind: 'provider_failed',
+                    retryable: false,
+                });
+            }
+            const resolveSettings = this.options.resolveSettings ?? getOpenAICompatibleSettings;
+            const settings = resolveRoundSettings({
+                cwd: args.cwd,
+                roleModel: this.options.model ?? null,
+                roundModel: args.model ?? null,
+                label: args.label,
+                resolveSettings,
+            });
+            const createModel = this.options.createModel ?? createDefaultOpenAICompatibleModel;
+            const model = createModel({
+                baseUrl: settings.baseUrl,
+                apiKey: settings.apiKey,
+                headers: settings.headers,
+                model: settings.model,
+                fetch: createInterceptingFetch({ label: args.label, sessionHandle }),
+            });
+            await emitProviderEvent(args.events, {
+                type: 'session_started',
+                provider: OPENAI_COMPATIBLE_PROVIDER_ID,
+                role: 'structured-advisor',
+                label: args.label,
+                sessionHandle,
+            });
+            const result = await runStructuredJsonProtocol({
+                provider: OPENAI_COMPATIBLE_PROVIDER_ID,
+                role: 'structured-advisor',
+                label: args.label,
+                protocol,
+                prompt: args.prompt,
+                events: args.events,
+                initialSessionHandle: sessionHandle,
+                runInitial: async (prompt) => ({
+                    assistantText: await this.runChatTurnWithRetry({
+                        model,
+                        prompt,
+                        roundArgs: args,
+                        sessionHandle,
+                        // Only the primary turn is wired to external cancellation; repair
+                        // turns are short prompt-only turns (matching other adapters).
+                        signal: args.signal,
+                    }),
+                    sessionHandle,
+                }),
+                runRepair: async (prompt) => ({
+                    assistantText: await this.runChatTurnWithRetry({
+                        model,
+                        prompt,
+                        roundArgs: args,
+                        sessionHandle,
+                    }),
+                    sessionHandle,
+                }),
+                createProviderError: (errorArgs) => createOpenAICompatibleProviderError({
+                    message: errorArgs.message,
+                    sessionHandle: errorArgs.sessionHandle,
+                    kind: errorArgs.kind,
+                    retryable: false,
+                    cause: errorArgs.cause,
+                }),
+            });
+            return {
+                // Never persist a resumable handle for this provider.
+                sessionHandle: null,
+                structured: result.structured,
+            };
+        }
+        catch (error) {
+            const providerError = normalizeOpenAICompatibleError(error, {
+                label: args.label,
+                sessionHandle,
+                callerSignal: args.signal,
+            });
+            await emitProviderEvent(args.events, {
+                type: 'provider_error',
+                provider: OPENAI_COMPATIBLE_PROVIDER_ID,
+                role: 'structured-advisor',
+                label: args.label,
+                sessionHandle: providerError.sessionHandle ?? sessionHandle,
+                message: providerError.message,
+                errorKind: providerError.kind,
+            });
+            throw providerError;
+        }
+    }
+    /**
+     * One chat turn with the bounded transient-retry loop: emits
+     * `turn_started`, makes a single tool-less `generateText` call
+     * (`temperature: 0`, `maxRetries: 0`, abort/inactivity signal), applies
+     * the reasoning-text fallback, then emits `assistant_text`,
+     * `turn_completed`, and `usage_reported` (the latter only when the
+     * response body actually carried usage, observed structurally via the AI
+     * SDK's `usage.raw` passthrough — preserving the bespoke adapter's
+     * usage-is-opportunistic event behavior). Transient failures retry up to
+     * `args.apiRetryLimit` times with the standard backoff and `api_retry`
+     * event shape; a caller abort is non-retryable and never burns retry
+     * budget.
+     */
+    async runChatTurnWithRetry(callArgs) {
+        const { roundArgs } = callArgs;
+        const sleep = this.options.sleep ?? defaultSleep;
+        const apiRetryLimit = roundArgs.apiRetryLimit;
+        const base = {
+            provider: OPENAI_COMPATIBLE_PROVIDER_ID,
+            role: 'structured-advisor',
+            label: roundArgs.label,
+            sessionHandle: callArgs.sessionHandle,
+        };
+        let apiRetryCount = 0;
+        while (true) {
+            try {
+                await emitProviderEvent(roundArgs.events, { type: 'turn_started', ...base });
+                const result = await generateText({
+                    model: callArgs.model,
+                    prompt: callArgs.prompt,
+                    temperature: 0,
+                    maxRetries: 0,
+                    abortSignal: composeAbortSignal(callArgs.signal, roundArgs.inactivityTimeoutMs),
+                });
+                // Reasoning-model fallback: the AI SDK surfaces `message.reasoning`
+                // and `message.reasoning_content` as reasoningText. The intercepting
+                // fetch already rejected bodies with no assistant text in any field,
+                // so this guard is defense in depth for non-body-shaped gaps.
+                const assistantText = result.text.trim().length > 0 ? result.text : (result.reasoningText ?? '');
+                if (assistantText.trim().length === 0) {
+                    throw createOpenAICompatibleProviderError({
+                        message: `OpenAI-compatible ${roundArgs.label} response did not include assistant text ` +
+                            '(after the reasoning-text fallback).',
+                        sessionHandle: callArgs.sessionHandle,
+                        kind: 'api_error',
+                        retryable: true,
+                    });
+                }
+                await emitProviderEvent(roundArgs.events, {
+                    type: 'assistant_text',
+                    ...base,
+                    text: assistantText,
+                });
+                // usage.raw is the AI SDK's passthrough of the response body's usage
+                // object; it is undefined when the body carried no usage (structural
+                // marker, matching the bespoke adapter's "only report usage when the
+                // gateway provided it" behavior).
+                const hasUsage = result.usage.raw !== undefined;
+                await emitProviderEvent(roundArgs.events, {
+                    type: 'turn_completed',
+                    ...base,
+                    ...(hasUsage ? { usage: result.usage } : {}),
+                });
+                if (hasUsage) {
+                    await emitProviderEvent(roundArgs.events, {
+                        type: 'usage_reported',
+                        ...base,
+                        usage: result.usage,
+                    });
+                }
+                return assistantText;
+            }
+            catch (error) {
+                const providerError = normalizeOpenAICompatibleError(error, {
+                    label: roundArgs.label,
+                    sessionHandle: callArgs.sessionHandle,
+                    callerSignal: callArgs.signal,
+                });
+                // Caller cancellation never burns retry budget: a caller-signal
+                // abort is non-retryable and the aborted check is defensive depth.
+                if (providerError.retryable && apiRetryCount < apiRetryLimit && !callArgs.signal?.aborted) {
+                    apiRetryCount += 1;
+                    await emitProviderEvent(roundArgs.events, {
+                        type: 'tool_progress',
+                        ...base,
+                        toolName: 'api_retry',
+                        message: `transient API failure; retrying (${apiRetryCount}/${apiRetryLimit})`,
+                        isError: true,
+                        providerData: {
+                            retryCount: apiRetryCount,
+                            retryLimit: apiRetryLimit,
+                            message: providerError.message,
+                        },
+                    });
+                    await sleep(getApiRetryDelayMs(apiRetryCount));
+                    continue;
+                }
+                throw providerError;
+            }
+        }
+    }
+}
+export function createOpenAICompatibleStructuredAdvisorAdapter(options = {}) {
+    return new OpenAICompatibleStructuredAdvisorAdapter(options);
+}
+export const openAICompatibleProviderDefinition = {
+    id: OPENAI_COMPATIBLE_PROVIDER_ID,
+    displayName: 'OpenAI-Compatible',
+    capabilities: {
+        coder: {
+            supported: false,
+            toolAccess: { read: false, write: false, shell: false },
+            supportsSessionResume: false,
+            supportsModelOverride: true,
+            supportsStructuredOutput: false,
+            usageReporting: 'none',
+        },
+        'structured-advisor': {
+            supported: true,
+            toolAccess: { read: false, write: false, shell: false },
+            supportsSessionResume: false,
+            supportsModelOverride: true,
+            supportsStructuredOutput: true,
+            usageReporting: 'opportunistic',
+        },
+    },
+    createStructuredAdvisorAdapter: createOpenAICompatibleStructuredAdvisorAdapter,
+};
+export const openAICompatibleProviderTestHooks = {
+    createDefaultOpenAICompatibleModel,
+    normalizeOpenAICompatibleError,
+    createStructuredAdvisorAdapterWithInjection: (injection, options) => new OpenAICompatibleStructuredAdvisorAdapter({ ...options, ...injection }),
+};