praxis-agent 0.53.1 → 0.55.0

package/dist/providers/fallback-provider.d.ts

@@ -2,12 +2,16 @@ import { type ModelProvider, type ModelStreamEvent, type ModelRequest } from '..
 export interface FallbackModelProviderOptions {
     providers: readonly ModelProvider[];
     retryDelayMs?: number;
+    routeScope?: 'completion' | 'turn';
 }
 /** Routes each complete request through Claude's retry-then-fallback policy. */
 export declare class FallbackModelProvider implements ModelProvider {
     private active;
     private readonly retryDelayMs;
-    private readonly fallbackProviders;
+    private readonly configuredProviders;
+    private readonly routeScope;
+    private currentProviderIndex;
+    private routeSealed;
     constructor(options: FallbackModelProviderOptions);
     /** Capabilities of the currently active provider after any fallback routing. */
     get capabilities(): ModelProvider['capabilities'];

package/dist/providers/fallback-provider.js

@@ -42,14 +42,18 @@ async function waitForRetry(delayMs, signal) {
 export class FallbackModelProvider {
     active;
     retryDelayMs;
-    fallbackProviders;
+    configuredProviders;
+    routeScope;
+    currentProviderIndex = 0;
+    routeSealed = false;
     constructor(options) {
         if (options.providers.length === 0) {
             throw new Error('Fallback provider requires at least one provider');
         }
         this.active = options.providers[0];
-        this.fallbackProviders = options.providers;
+        this.configuredProviders = options.providers;
         this.retryDelayMs = options.retryDelayMs ?? 500;
+        this.routeScope = options.routeScope ?? 'turn';
     }
     /** Capabilities of the currently active provider after any fallback routing. */
     get capabilities() {
@@ -60,9 +64,12 @@ export class FallbackModelProvider {
     }
     async *complete(request) {
         let lastError;
-        for (const provider of this.providers()) {
+        for (const [providerIndex, provider] of this.providers()) {
+            if (providerIndex > 0)
+                validateCapabilities(provider, request);
             for (let attempt = 0; attempt < MAX_ATTEMPTS_PER_MODEL; attempt += 1) {
                 throwIfAborted(request.signal);
+                this.currentProviderIndex = providerIndex;
                 this.active = provider;
                 const attemptStartedAt = performance.now();
                 try {
@@ -97,6 +104,9 @@ export class FallbackModelProvider {
                     if (provider.capabilities.terminalReasons === true && !terminalSeen) {
                         throw new ModelProviderError('Provider stream ended without a terminal reason', { retryable: true });
                     }
+                    this.currentProviderIndex = providerIndex;
+                    this.active = provider;
+                    this.routeSealed = this.routeScope === 'turn';
                     yield {
                         type: 'api-attempt-duration',
                         durationMs: attemptDurationMs ??
@@ -133,7 +143,55 @@ export class FallbackModelProvider {
             : new Error(String(lastError ?? 'All model providers failed'));
     }
     providers() {
-        return this.fallbackProviders;
+        if (this.routeSealed) {
+            const provider = this.configuredProviders[this.currentProviderIndex];
+            return provider === undefined
+                ? []
+                : [[this.currentProviderIndex, provider]];
+        }
+        return this.configuredProviders.map((provider, index) => [index, provider]);
+    }
+}
+function validateCapabilities(provider, request) {
+    const capabilities = provider.capabilities;
+    if (!capabilities.streaming) {
+        throw capabilityError(provider, 'streaming');
+    }
+    if (request.tools !== undefined &&
+        request.tools.length > 0 &&
+        !capabilities.tools) {
+        throw capabilityError(provider, 'tools');
+    }
+    const hasImages = request.messages.some((message) => ('images' in message &&
+        message.images !== undefined &&
+        message.images.length > 0) ||
+        ('contentBlocks' in message &&
+            message.contentBlocks?.some((block) => block.type === 'image') ===
+                true));
+    if (hasImages && !capabilities.images)
+        throw capabilityError(provider, 'images');
+    const hasDocuments = request.messages.some((message) => ('documents' in message &&
+        message.documents !== undefined &&
+        message.documents.length > 0) ||
+        ('contentBlocks' in message &&
+            message.contentBlocks?.some((block) => block.type === 'document') ===
+                true));
+    if (hasDocuments && !capabilities.documents)
+        throw capabilityError(provider, 'documents');
+    if (request.webSearch !== undefined && !capabilities.webSearch) {
+        throw capabilityError(provider, 'webSearch');
     }
+    const thinking = request.thinking;
+    if (thinking?.maxTokens !== undefined && !capabilities.thinking?.maxTokens) {
+        throw capabilityError(provider, 'thinking maxTokens');
+    }
+    if (thinking !== undefined) {
+        if (!capabilities.thinking?.modes.includes(thinking.mode)) {
+            throw capabilityError(provider, `thinking mode ${thinking.mode}`);
+        }
+    }
+}
+function capabilityError(provider, capability) {
+    return new ModelProviderError(`Provider ${provider.model ?? 'unknown'} does not support ${capability}`, { kind: 'invalid_request', retryable: false });
 }
 //# sourceMappingURL=fallback-provider.js.map

package/dist/providers/openai-responses.d.ts

@@ -0,0 +1,26 @@
+import { type ModelProvider, type ModelRequest, type ModelStreamEvent, type ModelThinkingConfig } from '../core/runtime.js';
+export interface OpenAIResponsesProviderOptions {
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+    contextWindowTokens?: number;
+    thinking?: ModelThinkingConfig;
+    maxStreamBufferBytes?: number;
+    maxToolArgumentsBytes?: number;
+    maxToolCallsPerResponse?: number;
+    maxToolMetadataBytes?: number;
+    maxReasoningBytes?: number;
+    maxErrorBodyBytes?: number;
+    fetchImplementation?: typeof fetch;
+}
+export declare class OpenAIResponsesProvider implements ModelProvider {
+    private readonly options;
+    readonly model: string;
+    readonly capabilities: ModelProvider['capabilities'];
+    private readonly fetchImplementation;
+    private readonly codec;
+    private readonly maxErrorBodyBytes;
+    constructor(options: OpenAIResponsesProviderOptions);
+    complete(request: ModelRequest): AsyncIterable<ModelStreamEvent>;
+}
+//# sourceMappingURL=openai-responses.d.ts.map

package/dist/providers/openai-responses.js

@@ -0,0 +1,162 @@
+import { ModelProviderError, } from '../core/runtime.js';
+import { ResponsesCodec } from './responses-codec.js';
+import { reportProviderTransportActivity } from './provider-transport-activity.js';
+function error(kind, retryable, status) {
+    return new ModelProviderError(status === undefined
+        ? 'OpenAI Responses provider request failed'
+        : `OpenAI Responses provider request failed with HTTP ${status}`, { kind, retryable, ...(status === undefined ? {} : { status }) });
+}
+function statusError(status) {
+    if (status === 401 || status === 403)
+        return error('authentication_failed', false, status);
+    if (status === 402)
+        return error('billing_error', false, status);
+    if (status === 408)
+        return error('timeout', true, status);
+    if (status === 429)
+        return error('rate_limit', true, status);
+    if (status === 529)
+        return error('overloaded', true, status);
+    if (status >= 500)
+        return error('server_error', true, status);
+    return error('invalid_request', false, status);
+}
+function classifyErrorBody(body, status) {
+    let value;
+    try {
+        value = JSON.parse(body);
+    }
+    catch {
+        return statusError(status);
+    }
+    const record = value && typeof value === 'object'
+        ? value
+        : undefined;
+    const nested = record?.error && typeof record.error === 'object'
+        ? record.error
+        : record;
+    const text = [nested?.type, nested?.code, nested?.message]
+        .filter((item) => typeof item === 'string')
+        .join(' ');
+    if (/context[_ -]?length|prompt[_ -]?too[_ -]?long|context.{0,40}(?:exceed|too long)/iu.test(text))
+        return error('prompt_too_long', false, status);
+    if (nested?.type === 'overloaded_error')
+        return error('overloaded', true, status);
+    return statusError(status);
+}
+async function readErrorBody(response, maxBytes, request) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        return '';
+    const decoder = new TextDecoder();
+    let body = '';
+    let remaining = maxBytes;
+    let ended = false;
+    try {
+        while (remaining > 0) {
+            const next = await reader.read();
+            if (next.done) {
+                ended = true;
+                body += decoder.decode();
+                break;
+            }
+            if (next.value.byteLength > 0)
+                reportProviderTransportActivity(request, 'response-chunk');
+            const chunk = next.value.subarray(0, remaining);
+            body += decoder.decode(chunk, { stream: chunk.byteLength === remaining });
+            remaining -= chunk.byteLength;
+            if (chunk.byteLength < next.value.byteLength)
+                break;
+        }
+        return body;
+    }
+    finally {
+        if (!ended) {
+            try {
+                await reader.cancel();
+            }
+            catch {
+                /* preserve the redacted HTTP error */
+            }
+        }
+        reader.releaseLock();
+    }
+}
+export class OpenAIResponsesProvider {
+    options;
+    model;
+    capabilities;
+    fetchImplementation;
+    codec;
+    maxErrorBodyBytes;
+    constructor(options) {
+        this.options = options;
+        this.model = options.model;
+        this.fetchImplementation = options.fetchImplementation ?? fetch;
+        this.codec = new ResponsesCodec({
+            providerLabel: 'OpenAI Responses provider',
+            ...options,
+        });
+        this.maxErrorBodyBytes = options.maxErrorBodyBytes ?? 64 * 1024;
+        if (!Number.isSafeInteger(this.maxErrorBodyBytes) ||
+            this.maxErrorBodyBytes <= 0)
+            throw new Error('OpenAI Responses provider limits must be positive integers');
+        this.capabilities = {
+            streaming: true,
+            usage: true,
+            tools: true,
+            images: true,
+            documents: false,
+            webSearch: false,
+            thinking: {
+                modes: ['disabled', 'enabled', 'adaptive'],
+                maxTokens: false,
+            },
+            ...(options.contextWindowTokens === undefined
+                ? {}
+                : { contextWindowTokens: options.contextWindowTokens }),
+            terminalReasons: true,
+        };
+    }
+    async *complete(request) {
+        const body = this.codec.serialize(request, this.model);
+        const signal = request.signal;
+        let response;
+        try {
+            reportProviderTransportActivity(request, 'request-started');
+            response = await this.fetchImplementation(`${this.options.baseUrl.replace(/\/+$/u, '')}/responses`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.options.apiKey}`,
+                    accept: 'text/event-stream',
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify(body),
+                ...(signal ? { signal } : {}),
+            });
+            reportProviderTransportActivity(request, 'response-received');
+        }
+        catch {
+            if (signal?.aborted)
+                throw error('cancelled', false);
+            throw error('transport_error', true);
+        }
+        if (!response.ok) {
+            let body = '';
+            try {
+                body = await readErrorBody(response, this.maxErrorBodyBytes, request);
+            }
+            catch {
+                /* preserve the redacted status classification */
+            }
+            throw classifyErrorBody(body, response.status);
+        }
+        if (!response.body)
+            throw error('transport_error', true);
+        yield* this.codec.stream(response.body, {
+            ...(signal === undefined ? {} : { signal }),
+            onChunk: () => reportProviderTransportActivity(request, 'response-chunk'),
+        });
+    }
+}
+//# sourceMappingURL=openai-responses.js.map

package/dist/providers/provider-registry.js

@@ -1,5 +1,6 @@
 import { AnthropicCompatibleProvider } from './anthropic-compatible.js';
 import { OpenAICompatibleProvider } from './openai-compatible.js';
+import { OpenAIResponsesProvider } from './openai-responses.js';
 import { CodexSubscriptionProvider } from './codex-subscription.js';
 import { DeadlineModelProvider } from './deadline-provider.js';
 import { NonStreamingFallbackModelProvider } from './non-streaming-fallback-provider.js';
@@ -132,6 +133,27 @@ class NativeProviderRegistry {
                     : { fetchImplementation: this.options.fetchImplementation }),
             }));
         }
+        if (target.protocol === 'openai-responses') {
+            if (this.options.credential.type !== 'api-key') {
+                throw new ProviderAuthenticationError('invalid_credential', 'Provider authentication failed: an API key is required');
+            }
+            return this.withDeadline(new OpenAIResponsesProvider({
+                baseUrl: target.baseUrl,
+                model: target.modelId,
+                apiKey: this.options.credential.secret,
+                ...(this.options.context?.contextWindowTokens === undefined
+                    ? {}
+                    : {
+                        contextWindowTokens: this.options.context.contextWindowTokens,
+                    }),
+                ...(this.options.openAiThinking === undefined
+                    ? {}
+                    : { thinking: this.options.openAiThinking }),
+                ...(this.options.fetchImplementation === undefined
+                    ? {}
+                    : { fetchImplementation: this.options.fetchImplementation }),
+            }));
+        }
         if (target.protocol === 'anthropic-messages') {
             if (this.options.credential.type !== 'api-key') {
                 throw new ProviderAuthenticationError('invalid_credential', 'Provider authentication failed: an API key is required');

package/dist/providers/provider-settings.d.ts

@@ -1,4 +1,4 @@
-export type ProviderProtocol = 'openai-compatible' | 'anthropic-messages' | 'codex-subscription';
+export type ProviderProtocol = 'openai-compatible' | 'openai-responses' | 'anthropic-messages' | 'codex-subscription';
 export type CredentialSource = {
     source: 'env';
     name: string;

package/dist/providers/provider-settings.js

@@ -18,6 +18,15 @@ const BUILT_INS = {
             },
         },
     },
+    'openai-responses': {
+        protocol: 'openai-responses',
+        profiles: {
+            default: {
+                baseUrl: 'https://api.openai.com/v1',
+                credential: { source: 'env', name: 'OPENAI_API_KEY' },
+            },
+        },
+    },
     anthropic: {
         protocol: 'anthropic-messages',
         profiles: {
@@ -148,8 +157,10 @@ function parseProvider(value, providerId) {
         'profiles',
     ]);
     const protocol = value.protocol;
-    if (protocol !== 'openai-compatible' && protocol !== 'anthropic-messages') {
-        fail(`providers.${providerId}.protocol must be openai-compatible or anthropic-messages`);
+    if (protocol !== 'openai-compatible' &&
+        protocol !== 'openai-responses' &&
+        protocol !== 'anthropic-messages') {
+        fail(`providers.${providerId}.protocol must be openai-compatible, openai-responses, or anthropic-messages`);
     }
     if (!isRecord(value.profiles) || Object.keys(value.profiles).length === 0)
         fail(`providers.${providerId}.profiles must be a non-empty object`);

package/dist/providers/responses-codec.d.ts

@@ -0,0 +1,31 @@
+import { type ModelRequest, type ModelStreamEvent, type ModelThinkingConfig } from '../core/runtime.js';
+export interface ResponsesCodecOptions {
+    providerLabel?: string;
+    thinking?: ModelThinkingConfig;
+    maxStreamBufferBytes?: number;
+    maxToolArgumentsBytes?: number;
+    maxToolCallsPerResponse?: number;
+    maxToolMetadataBytes?: number;
+    maxReasoningBytes?: number;
+}
+export interface ResponsesStreamOptions {
+    signal?: AbortSignal;
+    onChunk?: () => void;
+}
+export declare class ResponsesCodec {
+    readonly maxStreamBufferBytes: number;
+    readonly maxToolArgumentsBytes: number;
+    readonly maxToolCallsPerResponse: number;
+    readonly maxToolMetadataBytes: number;
+    readonly maxReasoningBytes: number;
+    private readonly label;
+    private readonly configuredThinking;
+    constructor(options?: ResponsesCodecOptions);
+    serialize(request: ModelRequest, model: string): Record<string, unknown>;
+    stream(body: ReadableStream<Uint8Array>, options?: ResponsesStreamOptions): AsyncIterable<ModelStreamEvent>;
+    private createParser;
+    private parseFrame;
+    private contextualize;
+    private failure;
+}
+//# sourceMappingURL=responses-codec.d.ts.map