praxis-agent 0.53.1 → 0.54.0

package/README.md

@@ -13,7 +13,8 @@ Praxis is a local-first, single-user general agent for the command line.
 
 It provides an interactive or headless agent loop, local tools, permissions,
 sessions, skills, hooks, MCP, plugins, background agents, and provider-neutral
-Anthropic/OpenAI-compatible model access. Praxis deliberately excludes
+Anthropic, OpenAI-compatible Chat Completions, and OpenAI Responses model
+access. Praxis deliberately excludes
 accounts, organizations, billing, managed enterprise policy, remote control,
 IDE surfaces, and telemetry control planes.
 
@@ -27,9 +28,9 @@ sessions, configuration, or compatibility directories.
 - macOS or Linux
 - Node.js 24 or newer
 - [`ripgrep`](https://github.com/BurntSushi/ripgrep) (`rg`) for the Grep tool
-- an API key and model ID for an Anthropic or OpenAI-compatible provider (the
-  stable setup), or the explicitly enabled experimental ChatGPT-backed Codex
-  subscription integration
+- an API key and model ID for an Anthropic, OpenAI-compatible, or OpenAI
+  Responses provider (the stable setup), or the explicitly enabled experimental
+  ChatGPT-backed Codex subscription integration
 
 Praxis does not use Claude subscription authentication. Claude-shaped message,
 tool, and CLI protocol forms remain supported where they are part of the
@@ -63,6 +64,20 @@ cd /path/to/project
 praxis
 ```
 
+To use OpenAI's Responses API with an explicit API-key provider:
+
+```sh
+export PRAXIS_PROVIDER="openai-responses"
+export OPENAI_API_KEY="your-api-key"
+export PRAXIS_MODEL="your-responses-model-id"
+
+cd /path/to/project
+praxis
+```
+
+The `openai` provider remains OpenAI-compatible Chat Completions. Provider
+protocols are selected explicitly; model IDs never switch protocols implicitly.
+
 Praxis also has an experimental `openai-codex` provider for ChatGPT-backed
 Codex subscriptions. It is separate from OpenAI API-key access, requires
 `experimental.codexSubscription: true`, and stores OAuth credentials in the
@@ -238,7 +253,11 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   recovery for malformed streamed tool arguments without tool execution or
   lost resumability, one default-on bounded Anthropic non-streaming replay for
   eligible stream/idle failures without exposing failed-attempt output, and
-  token-only/no-API-dollar accounting for subscription runs.
+  token-only/no-API-dollar accounting for subscription runs. For each main user
+  turn, failed provider attempts stay buffered; the first successful route,
+  whether primary or fallback, is sticky and sealed through that turn's tool
+  continuations; incompatible fallback routes fail closed, and each new main
+  user turn starts from primary.
 - **Transactional self-update** — `praxis update` verifies the package before
   installing it, rejects concurrent updates, and can roll back after an
   interruption or crash.

package/dist/application/session-service.d.ts

@@ -70,6 +70,8 @@ export interface ClaudeSessionServiceOptions {
     enableWorkflows?: boolean;
     providerForModel?: (model: string) => ModelProvider;
     providerForMainModel?: (model: string) => ModelProvider;
+    /** Creates one fresh main-turn provider per outer user turn; never used for auxiliary model calls. */
+    providerForTurn?: (model?: string) => ModelProvider;
     /** Creates a provider adapter dedicated to Session memory requests so
      *  adapter-local cache and retry state are not shared with the foreground. */
     sessionMemoryProviderFactory?: () => ModelProvider;

package/dist/application/session-service.js

@@ -745,7 +745,16 @@ export class ClaudeSessionService {
             ? (options.extensions?.agent(options.agent) ?? null)
             : null;
         if (configuredAgent && options.provider) {
-            this.activeProvider = this.providerForAgent(configuredAgent);
+            const selectedModel = !options.explicitModel &&
+                configuredAgent.model &&
+                configuredAgent.model !== 'inherit'
+                ? configuredAgent.model
+                : undefined;
+            const selectProvider = options.providerForMainModel ?? options.providerForModel;
+            this.activeProvider =
+                selectedModel !== undefined && selectProvider
+                    ? selectProvider(selectedModel)
+                    : this.options.provider;
         }
     }
     nextScheduledPrompt(signal) {
@@ -5043,6 +5052,12 @@ export class ClaudeSessionService {
     providerForAgent(agent) {
         const inherited = this.provider();
         const selectProvider = this.options.providerForMainModel ?? this.options.providerForModel;
+        const effectiveModel = !this.options.explicitModel && agent?.model && agent.model !== 'inherit'
+            ? agent.model
+            : inherited.model;
+        if (this.options.providerForTurn) {
+            return this.options.providerForTurn(effectiveModel);
+        }
         if (this.options.explicitModel ||
             !agent?.model ||
             agent.model === 'inherit' ||

package/dist/cli-runtime.js

@@ -1044,6 +1044,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
     let provider;
     let providerForModel;
     let providerForMainModel;
+    let providerForTurn;
     let providerBillingMode;
     const context = parseContextEnvironment(runtimeEnvironment);
     const apiKey = runtimeEnvironment.PRAXIS_API_KEY;
@@ -1164,17 +1165,25 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             providerBillingMode = registry.target.billingMode;
             providerForModel = (selectedModel) => registry.create(selectedModel);
             const createProvider = providerForModel;
-            providerForMainModel = (primaryModel) => {
+            const createProviderStack = (primaryModel, routeScope) => {
                 const models = [primaryModel, ...(cli.fallbackModels ?? [])].filter((candidate, index, all) => all.indexOf(candidate) === index);
                 const providers = models.map((candidate) => createProvider(candidate));
                 const selected = providers[0];
                 if (!selected)
                     throw new Error('A primary model is required');
                 return providers.length > 1
-                    ? new FallbackModelProvider({ providers })
+                    ? new FallbackModelProvider({ providers, routeScope })
                     : selected;
             };
-            provider = providerForMainModel(model);
+            providerForMainModel = (primaryModel) => createProviderStack(primaryModel, 'completion');
+            const defaultProvider = providerForMainModel(model);
+            provider = defaultProvider;
+            providerForTurn = (turnModel) => {
+                const selectedModel = turnModel ?? model;
+                return selectedModel === undefined
+                    ? defaultProvider
+                    : createProviderStack(selectedModel, 'turn');
+            };
         }
         catch (error) {
             const optionalProviderError = error instanceof ProviderAuthenticationError ||
@@ -1918,6 +1927,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             provider: hostedToolProvider,
             ...(providerForModel ? { providerForModel } : {}),
             ...(providerForMainModel ? { providerForMainModel } : {}),
+            ...(providerForTurn ? { providerForTurn } : {}),
             tools: filteredTools,
             toolCapabilityEnvironment: runtimeEnvironment,
             ...(!experimentalNativeTranscriptWrites ? { mcp: mcpTools } : {}),

package/dist/providers/codex-subscription.d.ts

@@ -14,19 +14,13 @@ export interface CodexSubscriptionProviderOptions {
     maxErrorBodyBytes?: number;
     thinking?: ModelThinkingConfig;
 }
-export declare function serializeCodexRequest(request: ModelRequest, model: string, configuredThinking?: ModelThinkingConfig): Record<string, unknown>;
-export declare function parseCodexSseFrame(data: string): ModelStreamEvent[];
 export declare class CodexSubscriptionProvider implements ModelProvider {
     private readonly options;
     readonly model: string;
     readonly capabilities: ModelProvider['capabilities'];
     private readonly fetchImplementation;
-    private readonly maxStreamBufferBytes;
-    private readonly maxToolArgumentsBytes;
-    private readonly maxToolCallsPerResponse;
-    private readonly maxToolMetadataBytes;
-    private readonly maxReasoningBytes;
     private readonly maxErrorBodyBytes;
+    private readonly responsesCodec;
     constructor(options: CodexSubscriptionProviderOptions);
     complete(request: ModelRequest): AsyncIterable<ModelStreamEvent>;
 }