praxis-agent 0.53.0 → 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
@@ -227,14 +242,22 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   existing default behavior. This is a Praxis permission contract, not a claim
   of verified Claude Code 2.1.208 parity. Explicit concrete `--tools`
   selections load selected tools directly, while
-  `--disallowedTools ToolSearch` restores the complete tool list.
+  `--disallowedTools ToolSearch` restores the complete tool list. For each
+  context assembly, Git status is refreshed from the caller-resolved cwd while
+  environment and memory remain lifecycle-stable; collection uses
+  `--no-optional-locks`, fails closed on repository/status errors, and bounds
+  the rendered status to 2,048 UTF-8 bytes.
 - **Provider-neutral models** — native Provider Registry/Vault routing, API
   adapters, an experimental Codex OAuth adapter, explicit capability checks,
   separate per-attempt connect, byte-idle, and absolute-total timeouts, typed
   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/native/context.js

@@ -131,7 +131,7 @@ ${sections.join('\n\n')}`,
                 tailSections.push({
                     id: 'relocated-runtime-context',
                     placement: 'first-user',
-                    stability: 'session',
+                    stability: 'volatile',
                     content: renderClaudeDynamicUserContext({
                         environment: dynamic.environment,
                         ...(dynamic.gitStatus ? { gitStatus: dynamic.gitStatus } : {}),
@@ -143,8 +143,19 @@ ${sections.join('\n\n')}`,
                     id: 'runtime-context',
                     placement: 'system',
                     stability: 'session',
-                    content: renderClaudeDynamicSystemContext(dynamic),
+                    content: renderClaudeDynamicSystemContext({
+                        environment: dynamic.environment,
+                        ...(dynamic.memory ? { memory: dynamic.memory } : {}),
+                    }),
                 });
+                if (dynamic.gitStatus) {
+                    tailSections.push({
+                        id: 'git-status',
+                        placement: 'system',
+                        stability: 'volatile',
+                        content: dynamic.gitStatus,
+                    });
+                }
             }
         }
         const composition = this.composer.compose({
@@ -227,15 +238,22 @@ ${sections.join('\n\n')}`,
             throw new Error('Dynamic context loader is unavailable');
         if (!snapshot)
             return load(cwd);
-        if (!snapshot.dynamic) {
-            const pending = load(cwd);
-            snapshot.dynamic = pending;
+        const current = load(cwd);
+        if (!snapshot.stableDynamic) {
+            const pending = current.then(({ environment, memory }) => ({
+                environment,
+                ...(memory ? { memory } : {}),
+            }));
+            snapshot.stableDynamic = pending;
             void pending.catch(() => {
-                if (snapshot.dynamic === pending)
-                    delete snapshot.dynamic;
+                if (snapshot.stableDynamic === pending)
+                    delete snapshot.stableDynamic;
             });
         }
-        return snapshot.dynamic;
+        return Promise.all([current, snapshot.stableDynamic]).then(([fresh, stable]) => ({
+            ...stable,
+            ...(fresh.gitStatus ? { gitStatus: fresh.gitStatus } : {}),
+        }));
     }
     loadMcpInstructions(snapshot) {
         const load = this.options.loadMcpInstructions;

package/dist/native/dynamic-context.js

@@ -1,7 +1,8 @@
 import { spawn } from 'node:child_process';
 import { basename } from 'node:path';
 import { platform, release, type } from 'node:os';
-const MAX_GIT_OUTPUT_BYTES = 128 * 1024;
+const MAX_GIT_OUTPUT_BYTES = 2_048;
+const MAX_GIT_STATUS_BYTES = 2_048;
 const MAX_GIT_ERROR_BYTES = 8 * 1024;
 const GIT_TIMEOUT_MS = 5_000;
 function collectBounded(chunks, chunk, state, limit) {
@@ -16,6 +17,22 @@ function collectBounded(chunks, chunk, state, limit) {
     if (accepted.length < chunk.length)
         state.truncated = true;
 }
+function boundUtf8(value, limit, marker) {
+    if (Buffer.byteLength(value, 'utf8') <= limit)
+        return value;
+    const markerBytes = Buffer.byteLength(marker, 'utf8');
+    const prefixLimit = Math.max(0, limit - markerBytes);
+    let bytes = 0;
+    let prefix = '';
+    for (const character of value) {
+        const characterBytes = Buffer.byteLength(character, 'utf8');
+        if (bytes + characterBytes > prefixLimit)
+            break;
+        prefix += character;
+        bytes += characterBytes;
+    }
+    return `${prefix}${marker}`;
+}
 function defaultRunGit(cwd, args) {
     return new Promise((resolve, reject) => {
         const child = spawn('git', ['-C', cwd, ...args], {
@@ -93,9 +110,16 @@ async function renderGitStatus(runGit) {
         optionalGit(runGit, ['branch', '--show-current']),
         optionalGit(runGit, ['branch', '--format=%(refname:short)']),
         optionalGit(runGit, ['config', 'user.name']),
-        optionalGit(runGit, ['status', '--short', '--untracked-files=all']),
+        optionalGit(runGit, [
+            '--no-optional-locks',
+            'status',
+            '--short',
+            '--untracked-files=all',
+        ]),
         optionalGit(runGit, ['log', '-5', '--oneline']),
     ]);
+    if (!status.available)
+        return undefined;
     const branch = branchValue.output || 'HEAD';
     const sections = [
         '# gitStatus',
@@ -108,18 +132,16 @@ async function renderGitStatus(runGit) {
     if (user.available && user.output) {
         sections.push('', `Git user: ${user.output}`);
     }
-    const renderedStatus = !status.available
-        ? 'Unavailable'
-        : status.output
-            ? `${status.output}${status.truncated ? '\n... [truncated]' : ''}`
-            : status.truncated
-                ? '... [truncated]'
-                : 'Clean';
+    const renderedStatus = status.output
+        ? `${status.output}${status.truncated ? '\n... [truncated]' : ''}`
+        : status.truncated
+            ? '... [truncated]'
+            : 'Clean';
     sections.push('', 'Status:', renderedStatus);
     if (commits.available && commits.output) {
         sections.push('', 'Recent commits:', commits.output);
     }
-    return sections.join('\n');
+    return boundUtf8(sections.join('\n'), MAX_GIT_STATUS_BYTES, '\n... [truncated]');
 }
 export async function loadClaudeDynamicContext(options) {
     const configuredRunGit = options.runGit;

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>;
 }