praxis-agent 0.48.0 → 0.48.1

package/README.md

@@ -215,8 +215,9 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   disconnect recovery that never replays an already-dispatched call.
 - **Provider-neutral models** — native Provider Registry/Vault routing, API
   adapters, an experimental Codex OAuth adapter, explicit capability checks,
-  per-attempt bounded deadlines, and token-only/no-API-dollar accounting for
-  subscription runs.
+  per-attempt bounded deadlines, typed recovery for malformed streamed tool
+  arguments without tool execution or lost resumability, and
+  token-only/no-API-dollar accounting for subscription runs.
 - **Transactional self-update** — `praxis update` verifies the package before
   installing it, rejects concurrent updates, and can roll back after an
   interruption or crash.
@@ -301,7 +302,7 @@ normal/low-capability full-frame p95 budgets of `<16.7/<33 ms`.
 `npm run test:coverage` measures all production code under `src/**` with V8 and
 enforces global floors of 79% statements, 70% branches, 85% functions, and 81% lines,
 and rejects any production runtime module with zero covered statements (while allowing
-type-only modules). `npm run test:fixtures` executes the 68-behavior native contract; 60 behaviors
+type-only modules). `npm run test:fixtures` executes the 69-behavior native contract; 61 behaviors
 are qualified and 8 are explicitly excluded. `npm run verify:fixture-contracts`
 performs the structural check and is part of `npm run check`.
 `npm run test:core-completion` is retained as a compatibility alias for

package/dist/application/session-service.js

@@ -15,7 +15,7 @@ import { projectNativeSessionEntries } from './native-session-projection.js';
 import { classifyClaudeInterruption, } from '../native/interruption.js';
 import { findUnresolvedClaudeToolCalls, getClaudeContentBlocks, } from '../native/tool-links.js';
 import { createClaudeAgentSettingEntry, createClaudeHookAttachmentEntries, createClaudeLastPromptEntry, createClaudeRuleAttachmentEntry, translateProviderEvents, } from '../native/translation.js';
-import { AgentRunCancelledError, AgentRuntime, ModelProviderError, } from '../core/runtime.js';
+import { AgentRunCancelledError, AgentRuntime, MALFORMED_TOOL_INPUT_MESSAGE, ModelProviderError, } from '../core/runtime.js';
 import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
 import { BackgroundTaskRuntime, } from './background-task-runtime.js';
 import { backgroundAgentNotificationMarkers, } from './background-agent-manager.js';
@@ -3347,7 +3347,11 @@ export class ClaudeSessionService {
                             : {}),
                     };
                     const unresolvedToolCall = unresolvedToolCalls[0];
-                    if (unresolvedToolCall && !approveRecovery) {
+                    if (unresolvedToolCall &&
+                        !unresolvedToolCalls.every((call) => call.inputError?.kind === 'malformed_json' &&
+                            call.inputError?.message ===
+                                MALFORMED_TOOL_INPUT_MESSAGE) &&
+                        !approveRecovery) {
                         throw new Error(`Claude session tool call ${unresolvedToolCall.id} requires explicit recovery approval`);
                     }
                     const recoveryResults = await runtime.recoverToolCalls(unresolvedToolCalls, recoveryRequest);

package/dist/core/runtime.d.ts

@@ -43,7 +43,14 @@ export interface ModelToolCall {
     id: string;
     name: string;
     input: Record<string, unknown>;
+    inputError?: ModelToolInputError;
 }
+export declare const MALFORMED_TOOL_INPUT_MESSAGE = "Malformed tool input";
+export interface ModelToolInputError {
+    kind: 'malformed_json';
+    message: typeof MALFORMED_TOOL_INPUT_MESSAGE;
+}
+export declare function malformedModelToolCall(id: string, name: string): ModelToolCall;
 export type ModelThinkingMode = 'enabled' | 'adaptive' | 'disabled';
 export type ModelThinkingBlock = {
     type: 'thinking';

package/dist/core/runtime.js

@@ -1,5 +1,17 @@
 import { ToolExecutionScheduler } from './tool-execution-scheduler.js';
 import { resolveToolSchedulingPolicy } from './tool-scheduling-policy.js';
+export const MALFORMED_TOOL_INPUT_MESSAGE = 'Malformed tool input';
+export function malformedModelToolCall(id, name) {
+    return {
+        id,
+        name,
+        input: {},
+        inputError: {
+            kind: 'malformed_json',
+            message: MALFORMED_TOOL_INPUT_MESSAGE,
+        },
+    };
+}
 const permissionDecisionSources = new WeakMap();
 const autoModePermissionOutcomes = new WeakMap();
 export function annotatePermissionDecision(decision, source) {
@@ -516,7 +528,12 @@ export class AgentRuntime {
                             }
                             toolCalls.push(event.call);
                             this.emit(event);
-                            const policy = resolveToolSchedulingPolicy(this.options.tools, event.call);
+                            const policy = event.call.inputError
+                                ? {
+                                    concurrency: 'exclusive',
+                                    startAfterAssistant: true,
+                                }
+                                : resolveToolSchedulingPolicy(this.options.tools, event.call);
                             toolScheduler.schedule(event.call, request.observer?.toolExecutionStarted
                                 ? { ...policy, startAfterAssistant: true }
                                 : policy);
@@ -863,6 +880,9 @@ export class AgentRuntime {
         try {
             if (emitPresentation)
                 emitProgress(0);
+            if (call.inputError) {
+                return { content: call.inputError.message, isError: true };
+            }
             const executed = await this.executeTool(call, { ...request, signal }, messages);
             const unsupportedImages = executed.images?.length && this.provider.capabilities.images !== true;
             const unsupportedDocuments = executed.documents?.length &&

package/dist/core/transcript-event.js

@@ -1,3 +1,4 @@
+import { MALFORMED_TOOL_INPUT_MESSAGE } from './runtime.js';
 const terminalReasons = new Set([
     'end_turn',
     'tool_use',
@@ -51,11 +52,17 @@ export function isModelContentBlock(value) {
     return isModelMedia(value);
 }
 function isModelToolCall(value) {
+    const inputError = isRecord(value) ? value.inputError : undefined;
     return (isRecord(value) &&
-        hasOnlyKeys(value, ['id', 'name', 'input']) &&
+        hasOnlyKeys(value, ['id', 'name', 'input', 'inputError']) &&
         isNonEmptyString(value.id) &&
         isNonEmptyString(value.name) &&
-        isRecord(value.input));
+        isRecord(value.input) &&
+        (inputError === undefined ||
+            (isRecord(inputError) &&
+                hasOnlyKeys(inputError, ['kind', 'message']) &&
+                inputError.kind === 'malformed_json' &&
+                inputError.message === MALFORMED_TOOL_INPUT_MESSAGE)));
 }
 function isModelThinkingBlock(value) {
     return isRecord(value) && value.type === 'thinking'

package/dist/providers/anthropic-compatible.js

@@ -1,4 +1,4 @@
-import { ModelProviderError, } from '../core/runtime.js';
+import { ModelProviderError, malformedModelToolCall, } from '../core/runtime.js';
 import { transportFailureKind } from './provider-errors.js';
 import { createAnthropicPromptCachePolicyResolver, } from './anthropic-prompt-cache.js';
 function isRecord(value) {
@@ -119,8 +119,16 @@ function completedToolCall(state, index) {
         try {
             input = JSON.parse(pending.partialJson);
         }
-        catch (error) {
-            throw new ModelProviderError(`Provider returned malformed tool arguments for ${pending.name}`, { retryable: false, cause: error });
+        catch {
+            if (!pending.id || !pending.name) {
+                throw new ModelProviderError('Provider returned an invalid tool call', {
+                    retryable: false,
+                });
+            }
+            return {
+                type: 'tool-call',
+                call: malformedModelToolCall(pending.id, pending.name),
+            };
         }
     }
     if (!pending.id || !pending.name || !isRecord(input)) {

package/dist/providers/codex-subscription.js

@@ -1,4 +1,4 @@
-import { ModelProviderError, } from '../core/runtime.js';
+import { ModelProviderError, malformedModelToolCall, } from '../core/runtime.js';
 import { CodexOAuthError, } from './codex-oauth.js';
 export const CODEX_RESPONSES_ENDPOINT = 'https://chatgpt.com/backend-api/codex/responses';
 const DEFAULT_MAX_STREAM = 1024 * 1024;
@@ -572,7 +572,12 @@ function parseEvent(value, state, limits) {
             parsed = JSON.parse(call.arguments || '{}');
         }
         catch {
-            throw invalid('Codex provider returned malformed function arguments');
+            if (!id || !name)
+                throw invalid('Codex provider returned an invalid tool call');
+            call.emitted = true;
+            state.toolCallEmitted = true;
+            events.push({ type: 'tool-call', call: malformedModelToolCall(id, name) });
+            return events;
         }
         if (!isRecord(parsed))
             throw invalid('Codex provider returned non-object function arguments');

package/dist/providers/openai-compatible.js

@@ -1,4 +1,4 @@
-import { ModelProviderError, } from '../core/runtime.js';
+import { ModelProviderError, malformedModelToolCall, } from '../core/runtime.js';
 import { transportFailureKind } from './provider-errors.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -64,8 +64,16 @@ function completedToolCallEvents(pending) {
         try {
             input = JSON.parse(call.arguments || '{}');
         }
-        catch (error) {
-            throw new ModelProviderError(`Provider returned malformed tool arguments for ${call.name}`, { retryable: false, cause: error });
+        catch {
+            if (!call.id || !call.name) {
+                throw new ModelProviderError('Provider returned an invalid tool call', {
+                    retryable: false,
+                });
+            }
+            return {
+                type: 'tool-call',
+                call: malformedModelToolCall(call.id, call.name),
+            };
         }
         if (!isRecord(input) || !call.id || !call.name) {
             throw new ModelProviderError('Provider returned an invalid tool call', {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-agent",
-  "version": "0.48.0",
+  "version": "0.48.1",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",