newmark-agent 0.4.8 → 0.5.0

package/dist/core/agent.js

@@ -1051,7 +1051,9 @@ class Agent {
     }
     updateProviders(value) {
         const before = this.config.providers();
-        this.config.set('models', 'providers', (0, config_1.mergeProviderSecrets)(value, before));
+        const merged = (0, config_1.mergeProviderSecrets)(value, before);
+        resetEditedModelValidationEvidence(merged, before);
+        this.config.set('models', 'providers', merged);
         const after = this.config.providers();
         const beforeById = new Map(before.map(provider => [provider.id, provider]));
         const afterById = new Map(after.map(provider => [provider.id, provider]));
@@ -3479,6 +3481,27 @@ class Agent {
         this.writeStoredConversationState(stored, targetWs);
         return true;
     }
+    reorderConversationContinuations(orderedIds) {
+        const currentIds = this.continuations
+            .filter(item => item.queueMode === 'followUp' && !!item.clientMessageId)
+            .map(item => String(item.clientMessageId));
+        const completeOrder = orderedIds.length === currentIds.length
+            && new Set(orderedIds).size === orderedIds.length
+            && orderedIds.every(id => currentIds.includes(id));
+        if (!completeOrder)
+            throw new Error('A complete queue order with unique current item ids is required');
+        const byId = new Map(this.continuations.flatMap(item => item.queueMode === 'followUp' && item.clientMessageId
+            ? [[String(item.clientMessageId), item]]
+            : []));
+        let nextIndex = 0;
+        this.continuations = this.continuations.map(item => {
+            if (item.queueMode !== 'followUp' || !item.clientMessageId)
+                return item;
+            return byId.get(orderedIds[nextIndex++]);
+        });
+        this.saveWorkspaceConversationState(true);
+        return this.conversationContinuations();
+    }
     renameConversation(id, title, ws = this.workspace.current) {
         const targetWs = ws || this.workspace.current;
         if (!targetWs)
@@ -6593,6 +6616,13 @@ class Agent {
         const fallbackEnabled = this.config.getBool('models', 'fallback_on_unavailable');
         const observedFailure = (0, autoRouter_1.classifyRouteFailure)(errorText);
         const observedDeployment = this.activeDeployment();
+        // Keep balance exhaustion scoped to the deployment that actually failed.
+        // Provider adapters normally record this before returning an error, but
+        // fallback callers are also a public recovery boundary and must not rely
+        // on every adapter/error path having performed that side effect first.
+        if (observedFailure.type === 'balance_exhausted' && observedDeployment) {
+            this.providerBalanceBlockedUntilByDeployment.set(deploymentIdentity(observedDeployment), Date.now() + 5 * 60_000);
+        }
         const previousAttempt = observedDeployment && this.lastRouteDecision
             ? [...this.lastRouteDecision.attempts].reverse().find(attempt => deploymentIdentity(attempt.deployment) === deploymentIdentity(observedDeployment))
             : undefined;
@@ -6654,16 +6684,15 @@ class Agent {
         }
         if (!fallbackEnabled)
             return null;
-        if (!observedFailure.retryable || !observedFailure.switchAllowed || this.routeStreamCommitted || this.routeSideEffectCommitted)
+        if (!observedFailure.switchAllowed || this.routeStreamCommitted || this.routeSideEffectCommitted)
             return null;
         const current = this.model;
-        const all = this.scopedSwitchModels(current).filter(m => m.name !== current);
+        const currentDeployment = observedDeployment;
+        const all = this.scopedSwitchModels(current).filter(m => !currentDeployment
+            || deploymentIdentity(this.deploymentRef(m)) !== deploymentIdentity(currentDeployment));
         if (!all.length)
             return null;
-        const usable = all.filter(m => {
-            const status = String(m.evaluation?.status || 'unknown').toLowerCase();
-            return status !== 'unavailable' && !status.startsWith('error');
-        });
+        const usable = all.filter(m => !this.isBalanceBlockedDeployment(this.deploymentRef(m)) && !modelConfigIsUnavailable(m));
         if (!usable.length)
             return null;
         const pref = this.config.autoSwitchPreference();
@@ -7436,7 +7465,7 @@ class Agent {
                 throw e;
             }
             const msg = e instanceof Error ? e.message : String(e);
-            if (/\b402\b|insufficient balance|insufficient funds|payment required|余额不足/i.test(msg)) {
+            if (/\b402\b|insufficient balance|insufficient funds|payment required|insufficient[_ -]?quota|quota (?:exceeded|exhausted)|credit(?:s| balance)? (?:exhausted|depleted)|billing hard limit|budget exhausted|余额不足|额度不足|配额(?:不足|耗尽|超限)/i.test(msg)) {
                 this.noteProviderBalanceFailure();
             }
             this.status = 'error';
@@ -9539,11 +9568,74 @@ function routeProviderFingerprint(provider) {
         enabled: provider.enabled,
         models: (provider.models || []).map(model => ({
             name: model.name,
+            display: model.display,
+            description: model.description,
+            maxTokens: model.max_tokens,
+            vision: model.vision,
+            thinking: !!model.thinking,
+            imageOutput: !!model.image_output,
             enabled: model.enabled !== false,
+            preview: !!model.preview,
             logicalModelGroupId: model.logical_model_group_id || '',
+            privacy: model.privacy || [],
+            capabilities: model.capabilities || [],
+            supportedParameters: model.supported_parameters || [],
+            routePreference: model.route_preference,
+            fallbackOnly: !!model.fallback_only,
+            thinkingTierMap: model.thinking_tier_map || {},
         })),
     });
 }
+function modelConfigurationFingerprint(model) {
+    const { validation, evaluation, _previous_name, previous_name, ...configuration } = model;
+    void validation;
+    void evaluation;
+    void _previous_name;
+    void previous_name;
+    return JSON.stringify(configuration);
+}
+function resetEditedModelValidationEvidence(incomingProviders, existingProviders) {
+    const existingById = new Map(existingProviders.map(provider => [provider.id, provider]));
+    const existingByName = new Map(existingProviders.map(provider => [provider.name, provider]));
+    for (const rawProvider of incomingProviders) {
+        if (!rawProvider || typeof rawProvider !== 'object' || Array.isArray(rawProvider))
+            continue;
+        const provider = rawProvider;
+        const previousProvider = existingById.get(String(provider.id || ''))
+            || existingByName.get(String(provider._previous_name || provider.previous_name || provider.name || ''));
+        const models = Array.isArray(provider.models) ? provider.models : [];
+        // Endpoint/protocol edits invalidate capability evidence. A display-name
+        // change or credential rotation only resets runtime health/circuits via the
+        // provider fingerprint and must not discard still-valid model capabilities.
+        const providerConnectionChanged = !!previousProvider && (String(provider.base_url || provider.endpoint || '') !== previousProvider.base_url
+            || String(provider.protocol || '') !== previousProvider.protocol);
+        for (const rawModel of models) {
+            if (!rawModel || typeof rawModel !== 'object' || Array.isArray(rawModel))
+                continue;
+            const model = rawModel;
+            const previousName = String(model._previous_name || model.previous_name || model.name || '');
+            const previousModel = previousProvider?.models.find(candidate => candidate.name === previousName);
+            const edited = providerConnectionChanged || (!!previousModel
+                && modelConfigurationFingerprint(model) !== modelConfigurationFingerprint(previousModel));
+            delete model._previous_name;
+            delete model.previous_name;
+            if (!edited)
+                continue;
+            model.validation = { level: 'discovered', status: 'degraded', checked_at: '', capabilities: {} };
+            delete model.evaluation;
+            model.speed_rating = 'unknown';
+            model.capability_rating = 'unknown';
+        }
+    }
+}
+function modelConfigIsUnavailable(model) {
+    const validationStatus = effectiveModelValidationStatus(model);
+    if (model.validation?.level !== 'discovered'
+        && (validationStatus === 'unavailable' || validationStatus === 'auth_error' || validationStatus === 'invalid_config'))
+        return true;
+    const evaluationStatus = validationStatus === 'degraded' ? 'degraded' : String(model.evaluation?.status || '').toLowerCase();
+    return evaluationStatus === 'unavailable' || evaluationStatus.startsWith('error');
+}
 function parseDeploymentSelectionValue(value) {
     const marker = String(value || '').trim();
     if (!marker.startsWith('deployment:'))
@@ -9564,6 +9656,8 @@ function effectiveModelValidationStatus(model) {
     const raw = String(model.validation?.status || '').toLowerCase();
     if (raw === 'auth_error')
         return raw;
+    if (String(model.validation?.level || '').toLowerCase() === 'discovered')
+        return 'degraded';
     const textEvidence = model.validation?.capabilities?.text === true
         || model.validation?.capabilities?.text_input === true
         || model.validation?.capabilities?.text_output === true
@@ -9571,8 +9665,6 @@ function effectiveModelValidationStatus(model) {
         || model.evaluation?.text_output === true;
     if (textEvidence && raw === 'unavailable')
         return 'degraded';
-    if (!raw && String(model.validation?.level || '').toLowerCase() === 'discovered')
-        return 'degraded';
     return (['verified', 'degraded', 'unavailable', 'auth_error', 'rate_limited', 'invalid_config'].includes(raw)
         ? raw
         : 'unavailable');

package/dist/core/agentKernelRunner.js

@@ -662,7 +662,7 @@ async function runAgentKernel(agent) {
                         return;
                     }
                     const publicError = normalizePublicProviderError(error, [currentAgent.activeModelConfig()?.api_key]);
-                    if (/\b402\b|insufficient balance|insufficient funds|payment required|余额不足/i.test(publicError)) {
+                    if (/\b402\b|insufficient balance|insufficient funds|payment required|insufficient[_ -]?quota|quota (?:exceeded|exhausted)|credit(?:s| balance)? (?:exhausted|depleted)|billing hard limit|budget exhausted|余额不足|额度不足|配额(?:不足|耗尽|超限)/i.test(publicError)) {
                         currentAgent.noteProviderBalanceFailure();
                     }
                     const final = assistantMessage(model, [{ type: 'text', text: `[Error] ${publicError}` }], 'error');

package/dist/core/autoRouter.d.ts

@@ -85,7 +85,7 @@ export interface RankedRouteCandidate {
 export type RouteAttemptStatus = 'planned' | 'success' | 'failed' | 'blocked';
 export interface RouteAttempt {
     deployment: DeploymentRef;
-    kind: 'initial' | 'retry_same_deployment' | 'equivalent_deployment' | 'fallback_model';
+    kind: 'initial' | 'retry_same_deployment' | 'equivalent_deployment' | 'fallback_model' | 'alternate_model';
     status: RouteAttemptStatus;
     errorType?: RouteFailureType;
     durationMs?: number;

package/dist/core/autoRouter.js

@@ -115,8 +115,8 @@ function classifyRouteFailure(error) {
     if (statusCode === 400 || /bad request|invalid parameter|invalid request/i.test(text)) {
         return { type: 'invalid_request', retryable: false, switchAllowed: false, statusCode };
     }
-    if (statusCode === 402 || /insufficient balance|insufficient funds|payment required|余额不足/i.test(text)) {
-        return { type: 'balance_exhausted', retryable: false, switchAllowed: false, statusCode: 402 };
+    if (statusCode === 402 || /insufficient balance|insufficient funds|payment required|insufficient[_ -]?quota|quota (?:exceeded|exhausted)|credit(?:s| balance)? (?:exhausted|depleted)|billing hard limit|budget exhausted|余额不足|额度不足|配额(?:不足|耗尽|超限)/i.test(text)) {
+        return { type: 'balance_exhausted', retryable: false, switchAllowed: true, statusCode: statusCode || 402 };
     }
     if (statusCode === 429 || /rate limit|too many requests/i.test(text)) {
         return { type: 'rate_limited', retryable: true, switchAllowed: true, statusCode: 429, retryAfterMs };
@@ -270,7 +270,7 @@ class AutoRouter {
     }
     planAttempts(decision, candidates, failure) {
         const current = decision.resolvedDeployment;
-        if (!current || !failure.error.retryable || !failure.error.switchAllowed || failure.streamCommitted || failure.sideEffectCommitted)
+        if (!current || !failure.error.switchAllowed || failure.streamCommitted || failure.sideEffectCommitted)
             return [];
         const remainingAttempts = Math.max(0, 3 - decision.attempts.length);
         if (!remainingAttempts)
@@ -279,7 +279,7 @@ class AutoRouter {
         const retryDelayMs = failure.error.retryAfterMs ?? 250;
         const alreadyRetriedCurrent = decision.attempts.some(attempt => attempt.kind === 'retry_same_deployment'
             && sameDeployment(attempt.deployment, current));
-        if (!alreadyRetriedCurrent && retryDelayMs <= (decision.retryBudgetMs ?? 5_000)) {
+        if (failure.error.retryable && !alreadyRetriedCurrent && retryDelayMs <= (decision.retryBudgetMs ?? 5_000)) {
             attempts.push({
                 deployment: { ...current },
                 kind: 'retry_same_deployment',
@@ -310,12 +310,21 @@ class AutoRouter {
             ? eligible.find(candidate => candidate.deployment.logicalModelGroupId === currentGroup && !candidate.fallbackOnly)
             : undefined;
         const fallback = eligible.find(candidate => candidate.fallbackOnly);
-        for (const next of [equivalent, fallback]) {
+        const rankedAlternates = decision.rankedCandidates
+            .map(ranked => eligible.find(candidate => sameDeployment(candidate.deployment, ranked.deployment)))
+            .filter((candidate) => !!candidate && candidate !== equivalent && candidate !== fallback && !candidate.fallbackOnly);
+        for (const candidate of eligible) {
+            if (candidate === equivalent || candidate === fallback || candidate.fallbackOnly
+                || rankedAlternates.some(existing => sameDeployment(existing.deployment, candidate.deployment)))
+                continue;
+            rankedAlternates.push(candidate);
+        }
+        for (const next of [equivalent, fallback, ...rankedAlternates]) {
             if (!next || attempts.length >= 2)
                 continue;
             attempts.push({
                 deployment: { ...next.deployment },
-                kind: next === equivalent ? 'equivalent_deployment' : 'fallback_model',
+                kind: next === equivalent ? 'equivalent_deployment' : next === fallback ? 'fallback_model' : 'alternate_model',
                 status: 'planned',
                 errorType: failure.error.type,
                 streamCommitted: false,
@@ -578,6 +587,6 @@ function percentile(values, fraction) {
 }
 function failureFromType(type) {
     const retryable = type === 'timeout' || type === 'rate_limited' || type === 'transport' || type === 'server_error' || type === 'empty_response';
-    return { type, retryable, switchAllowed: retryable };
+    return { type, retryable, switchAllowed: retryable || type === 'balance_exhausted' };
 }
 //# sourceMappingURL=autoRouter.js.map

package/dist/core/conversationKernel.d.ts

@@ -12,7 +12,15 @@ export interface ConversationQueueItemSnapshot {
     runId?: string;
     createdAt: string;
 }
-export type ConversationQueueAction = 'enqueue' | 'update' | 'delete' | 'toggle_pause' | 'guide';
+export type ConversationQueueAction = 'enqueue' | 'update' | 'delete' | 'reorder' | 'toggle_pause' | 'guide';
+export interface ConversationQueueActionInput {
+    id?: string;
+    text?: string;
+    requestedMode?: string;
+    goalObjective?: string;
+    createdAt?: string;
+    orderedIds?: string[];
+}
 export interface AgentPromptMessage {
     text: string;
     /** Public transcript text when the execution prompt contains hidden orchestration instructions. */
@@ -196,14 +204,9 @@ export declare class ConversationKernel {
     }): ConversationQueueItemSnapshot;
     updateQueueItem(target: ConversationTargetInput, idInput: string, textInput: string): ConversationQueueItemSnapshot;
     deleteQueueItem(target: ConversationTargetInput, idInput: string): boolean;
+    reorderQueueItems(target: ConversationTargetInput, orderedIdsInput: string[]): ConversationQueueItemSnapshot[];
     setQueuePaused(target: ConversationTargetInput, paused: boolean): boolean;
-    queueAction(target: ConversationTargetInput, action: ConversationQueueAction, input?: {
-        id?: string;
-        text?: string;
-        requestedMode?: string;
-        goalObjective?: string;
-        createdAt?: string;
-    }): {
+    queueAction(target: ConversationTargetInput, action: ConversationQueueAction, input?: ConversationQueueActionInput): {
         ok: boolean;
         queueItems: ConversationQueueItemSnapshot[];
         queuePaused: boolean;
@@ -268,6 +271,7 @@ export declare class ConversationKernel {
     rewind(target: ConversationTargetInput, messageIndex: number): ReturnType<Agent['rewindConversation']>;
     prompt(message: string | AgentPromptMessage, target: ConversationTargetInput, options: ConversationKernelRunOptions, queueMode?: ConversationQueueMode): Promise<ConversationKernelRunResult>;
     private settleCooperativeStop;
+    private stopAutomaticContinuationAfterError;
     private run;
     /**
      * Apply a model selection recorded while a Build block was running. The
@@ -277,6 +281,7 @@ export declare class ConversationKernel {
      */
     private syncPendingModel;
     private runSingle;
+    private consumeFailedAutomaticContinuation;
     private processTimeoutMs;
     private runtime;
     private scheduleGoalContinuation;

package/dist/core/conversationKernel.js

@@ -160,6 +160,46 @@ class ConversationKernel {
         this.emitQueueUpdate(runtime);
         return true;
     }
+    reorderQueueItems(target, orderedIdsInput) {
+        const runtime = this.findRuntime(target);
+        if (!runtime)
+            throw new Error('Target conversation runtime is unavailable');
+        const currentItems = this.queueItems(runtime.target);
+        const orderedIds = Array.isArray(orderedIdsInput)
+            ? orderedIdsInput.map(id => String(id || '').trim())
+            : [];
+        const currentIds = currentItems.map(item => item.id);
+        const completeOrder = orderedIds.length === currentIds.length
+            && new Set(orderedIds).size === orderedIds.length
+            && orderedIds.every(id => currentIds.includes(id));
+        if (!completeOrder)
+            throw new Error('A complete queue order with unique current item ids is required');
+        const persistedIds = runtime.runner.conversationContinuations()
+            .filter(item => item.queueMode === 'followUp' && !!item.clientMessageId)
+            .map(item => String(item.clientMessageId));
+        if (persistedIds.length !== currentIds.length
+            || new Set(persistedIds).size !== persistedIds.length
+            || persistedIds.some(id => !currentIds.includes(id))) {
+            throw new Error('Persisted queue does not match the complete queue order');
+        }
+        const pendingById = new Map(runtime.pendingNextTurn.flatMap(item => {
+            if (item.queueMode !== 'followUp' || typeof item.message === 'string' || !item.message.clientMessageId)
+                return [];
+            return [[String(item.message.clientMessageId), item]];
+        }));
+        const reorderedPending = orderedIds.map(id => pendingById.get(id));
+        let nextIndex = 0;
+        runtime.pendingNextTurn = runtime.pendingNextTurn.map(item => {
+            if (item.queueMode !== 'followUp' || typeof item.message === 'string' || !item.message.clientMessageId)
+                return item;
+            return reorderedPending[nextIndex++];
+        });
+        runtime.runner.reorderConversationContinuations(orderedIds);
+        runtime.queued.followUp = orderedIds.map(id => pendingById.get(id))
+            .map(item => typeof item.message === 'string' ? item.message : item.message.text);
+        this.emitQueueUpdate(runtime);
+        return this.queueItems(runtime.target);
+    }
     setQueuePaused(target, paused) {
         const runtime = this.findRuntime(target);
         if (!runtime)
@@ -192,6 +232,9 @@ class ConversationKernel {
             if (!this.deleteQueueItem(runtime.target, String(input.id || '')))
                 throw new Error('Queue item was not found');
         }
+        else if (action === 'reorder') {
+            this.reorderQueueItems(runtime.target, input.orderedIds || []);
+        }
         else if (action === 'toggle_pause') {
             this.setQueuePaused(runtime.target, !runtime.queuePaused);
         }
@@ -310,7 +353,7 @@ class ConversationKernel {
         const existing = runtime ? this.guideReceipt(runtime, clientMessageId) : undefined;
         if (existing)
             return existing;
-        if (!runtime?.activePromise || !runtime.runId) {
+        if (!runtime?.runId) {
             return { ...base, reason: 'Target conversation is not running' };
         }
         if (requestedRunId && requestedRunId !== runtime.runId) {
@@ -318,6 +361,12 @@ class ConversationKernel {
             runtime.guideReceipts.set(clientMessageId, rejected);
             return runtime.runner.recordGuideReceipt(rejected);
         }
+        const canReactivateFinalizingRun = !runtime.activePromise
+            && runtime.guideAcceptanceClosedRunId === runtime.runId
+            && (!requestedRunId || requestedRunId === runtime.runId);
+        if (!runtime.activePromise && !canReactivateFinalizingRun) {
+            return { ...base, reason: 'Target conversation is not running' };
+        }
         let safeImages = [];
         let safeAttachments = [];
         try {
@@ -417,6 +466,8 @@ class ConversationKernel {
                     attachments: safeAttachments.map(attachment => ({ ...attachment })),
                     createdAt: deferred.createdAt,
                 }]);
+            this.trackQueuedMessage(runtime, safeEnvelope.text, 'steer');
+            this.emitQueueUpdate(runtime);
             this.activateAcceptedGoal(runtime, envelope.goalObjective);
             this.schedulePendingRuntimeContinuation(runtime, runtime.runId);
             return deferred;
@@ -711,6 +762,7 @@ class ConversationKernel {
         activePromise = (async () => {
             let result = null;
             let stopped = false;
+            let failed = false;
             try {
                 result = await this.run(runtime, message, options);
                 stopped = runtime.runId === runId && runtime.stopRequestedRunId === runId;
@@ -720,6 +772,8 @@ class ConversationKernel {
                     stopped = true;
                 }
                 else {
+                    failed = true;
+                    this.stopAutomaticContinuationAfterError(runtime, runId);
                     runtime.runner.finishConversationWorkRun(runId, 'error', undefined, error instanceof Error ? error.message : String(error));
                     throw error;
                 }
@@ -731,7 +785,7 @@ class ConversationKernel {
                         stopped = true;
                         this.settleCooperativeStop(runtime, runId);
                     }
-                    else if (!runtime.queuePaused && runtime.pendingNextTurn.length > 0) {
+                    else if (!failed && !runtime.queuePaused && runtime.pendingNextTurn.length > 0) {
                         // A renderer/IPC Guide can arrive after the final-drain barrier's
                         // last check but before this promise settles. Do not leave the
                         // deferred continuation queued on an idle runtime.
@@ -739,7 +793,7 @@ class ConversationKernel {
                     }
                 }
             }
-            if (!stopped && runtime.runId === runId)
+            if (!failed && !stopped && runtime.runId === runId)
                 this.scheduleGoalContinuation(runtime, runId);
             if (stopped) {
                 const settled = this.result(runtime, []);
@@ -766,6 +820,30 @@ class ConversationKernel {
         this.emitQueueUpdate(runtime);
         return true;
     }
+    stopAutomaticContinuationAfterError(runtime, runId) {
+        if (runtime.runId !== runId)
+            return;
+        if (runtime.goalContinuationTimer) {
+            clearTimeout(runtime.goalContinuationTimer);
+            runtime.goalContinuationTimer = undefined;
+        }
+        runtime.pendingContinuationRunId = undefined;
+        this.rejectOutstandingGuides(runtime, 'The provider failed before this Guide could be applied; submit again to retry.');
+        runtime.pendingNextTurn = runtime.pendingNextTurn.filter(item => {
+            const automatic = item.queueMode === 'steer'
+                || (typeof item.message !== 'string' && item.message.hiddenUserInput === true);
+            if (automatic) {
+                runtime.runner.consumeConversationContinuation({
+                    content: typeof item.message === 'string' ? item.message : item.message.text,
+                    queueMode: item.queueMode,
+                    clientMessageId: typeof item.message === 'string' ? undefined : item.message.clientMessageId,
+                });
+            }
+            return !automatic;
+        });
+        this.queueState(runtime);
+        this.emitQueueUpdate(runtime);
+    }
     async run(runtime, message, options) {
         this.applyOptions(runtime.runner, options);
         let lastTokens = await this.runSingle(runtime, message);
@@ -871,7 +949,14 @@ class ConversationKernel {
         this.consumeQueuedMessage(runtime, typeof message === 'string' ? message : message.text);
         const timeoutMs = this.processTimeoutMs(runtime);
         if (timeoutMs <= 0) {
-            const tokens = await runtime.runner.process(message);
+            let tokens;
+            try {
+                tokens = await runtime.runner.process(message);
+            }
+            catch (error) {
+                this.consumeFailedAutomaticContinuation(runtime, message, continuationMode);
+                throw error;
+            }
             if (continuationMode)
                 runtime.runner.consumeConversationContinuation({
                     content: typeof message === 'string' ? message : message.text,
@@ -882,12 +967,19 @@ class ConversationKernel {
         }
         let timeout;
         try {
-            const tokens = await Promise.race([
-                runtime.runner.process(message),
-                new Promise((_, reject) => {
-                    timeout = setTimeout(() => reject(new Error(`Process timeout (${Math.round(timeoutMs / 1000)}s)`)), timeoutMs);
-                }),
-            ]);
+            let tokens;
+            try {
+                tokens = await Promise.race([
+                    runtime.runner.process(message),
+                    new Promise((_, reject) => {
+                        timeout = setTimeout(() => reject(new Error(`Process timeout (${Math.round(timeoutMs / 1000)}s)`)), timeoutMs);
+                    }),
+                ]);
+            }
+            catch (error) {
+                this.consumeFailedAutomaticContinuation(runtime, message, continuationMode);
+                throw error;
+            }
             if (continuationMode)
                 runtime.runner.consumeConversationContinuation({
                     content: typeof message === 'string' ? message : message.text,
@@ -901,6 +993,15 @@ class ConversationKernel {
                 clearTimeout(timeout);
         }
     }
+    consumeFailedAutomaticContinuation(runtime, message, continuationMode) {
+        if (!continuationMode || typeof message === 'string' || message.hiddenUserInput !== true)
+            return;
+        runtime.runner.consumeConversationContinuation({
+            content: message.text,
+            queueMode: continuationMode,
+            clientMessageId: message.clientMessageId,
+        });
+    }
     processTimeoutMs(runtime) {
         const raw = runtime.runner.config.getNum('agent', 'process_timeout_ms') || this.host.config.getNum('agent', 'process_timeout_ms');
         if (!Number.isFinite(raw) || raw <= 0)

package/dist/core/electronUtilityAgentClient.d.ts

@@ -1,7 +1,7 @@
 import { spawn } from 'child_process';
 import { NormalizedConversationTarget } from './conversationTarget';
 import { AgentMode, AgentWorkEvent, ConversationInputEnvelope, GuideReceipt } from './types';
-import { ConversationQueueAction } from './conversationKernel';
+import { ConversationQueueAction, ConversationQueueActionInput } from './conversationKernel';
 import { UtilityAgentPromptResult, UtilityAutoRouteRatingResult, UtilityAgentSnapshotResult, UtilityAgentStopResult, UtilityConversationRewindResult, UtilityHostToolRequest, UtilityPromptRequest } from './utilityAgentProtocol';
 type WindowsProcessTreeHelperRuntime = {
     kind: 'precompiled' | 'runtime_compile';
@@ -95,13 +95,7 @@ export declare class ElectronUtilityAgentClient {
     rewind(messageIndex: number): Promise<UtilityConversationRewindResult>;
     requestStop(runId?: string): Promise<UtilityAgentStopResult>;
     enqueueGuide(envelope: ConversationInputEnvelope): Promise<GuideReceipt>;
-    queueAction(action: ConversationQueueAction, input?: {
-        id?: string;
-        text?: string;
-        requestedMode?: string;
-        goalObjective?: string;
-        createdAt?: string;
-    }): Promise<Record<string, unknown>>;
+    queueAction(action: ConversationQueueAction, input?: ConversationQueueActionInput): Promise<Record<string, unknown>>;
     checkpoint(): Promise<Record<string, unknown>>;
     contextCompress(options?: {
         keepRecent?: number;

package/dist/core/electronUtilityRuntimePool.d.ts

@@ -1,5 +1,5 @@
 import { AgentMode, AgentWorkEvent, ConversationInputEnvelope, GuideReceipt } from './types';
-import { ConversationQueueAction } from './conversationKernel';
+import { ConversationQueueAction, ConversationQueueActionInput } from './conversationKernel';
 import { ConversationRuntimeTarget, NormalizedConversationTarget } from './conversationTarget';
 import { UtilityHostToolHandler } from './electronUtilityAgentClient';
 import { UtilityAgentPromptResult, UtilityAutoRouteRatingResult, UtilityConversationRewindResult, UtilityAgentSnapshotResult, UtilityAgentStopResult, UtilityPromptRequest } from './utilityAgentProtocol';
@@ -11,13 +11,7 @@ export interface ElectronTargetRuntimeClient {
     rewind(messageIndex: number): Promise<UtilityConversationRewindResult>;
     requestStop(runId?: string): Promise<UtilityAgentStopResult>;
     enqueueGuide(envelope: ConversationInputEnvelope): Promise<GuideReceipt>;
-    queueAction?(action: ConversationQueueAction, input?: {
-        id?: string;
-        text?: string;
-        requestedMode?: string;
-        goalObjective?: string;
-        createdAt?: string;
-    }): Promise<Record<string, unknown>>;
+    queueAction?(action: ConversationQueueAction, input?: ConversationQueueActionInput): Promise<Record<string, unknown>>;
     checkpoint(): Promise<Record<string, unknown>>;
     contextCompress?(options?: {
         keepRecent?: number;
@@ -79,13 +73,7 @@ export declare class ElectronUtilityRuntimePool {
     rewind(target: ConversationRuntimeTarget, messageIndex: number): Promise<UtilityConversationRewindResult>;
     requestStop(target: ConversationRuntimeTarget, runId?: string): Promise<ElectronPoolStopResult>;
     enqueueGuide(envelope: ConversationInputEnvelope): Promise<GuideReceipt>;
-    queueAction(target: ConversationRuntimeTarget, action: ConversationQueueAction, input?: {
-        id?: string;
-        text?: string;
-        requestedMode?: string;
-        goalObjective?: string;
-        createdAt?: string;
-    }): Promise<Record<string, unknown>>;
+    queueAction(target: ConversationRuntimeTarget, action: ConversationQueueAction, input?: ConversationQueueActionInput): Promise<Record<string, unknown>>;
     checkpoint(target: ConversationRuntimeTarget): Promise<Record<string, unknown>>;
     contextCompress(target: ConversationRuntimeTarget, options?: {
         keepRecent?: number;

package/dist/core/utilityAgentProtocol.d.ts

@@ -1,6 +1,6 @@
 import { BrowserControlRequest, BrowserControlResult } from './browserControl';
 import { BrowserUseRequest } from './browserUse';
-import { AgentPromptMessage, ConversationContextCompressOptions, ConversationKernelRunOptions, ConversationKernelRunResult, ConversationQueueAction, ConversationQueueMode, ConversationRuntimeState, ConversationStopResult } from './conversationKernel';
+import { AgentPromptMessage, ConversationContextCompressOptions, ConversationKernelRunOptions, ConversationKernelRunResult, ConversationQueueAction, ConversationQueueActionInput, ConversationQueueMode, ConversationRuntimeState, ConversationStopResult } from './conversationKernel';
 import { ConversationRuntimeTarget, NormalizedConversationTarget } from './conversationTarget';
 import { AgentMode, AgentWorkEvent, ConversationInputEnvelope, GuideReceipt } from './types';
 import type { AutoRouteRatingResult, ConversationSnapshot } from './agent';
@@ -106,13 +106,7 @@ export type UtilityAgentRequest = {
     params: {
         target: ConversationRuntimeTarget;
         action: ConversationQueueAction;
-        input?: {
-            id?: string;
-            text?: string;
-            requestedMode?: string;
-            goalObjective?: string;
-            createdAt?: string;
-        };
+        input?: ConversationQueueActionInput;
     };
 } | {
     id: string;

package/dist/core/workEventCoalescer.d.ts

@@ -0,0 +1,16 @@
+import type { AgentWorkEvent } from './types';
+/**
+ * Bounds cross-process traffic for high-rate streaming text without changing
+ * durable work-run events. Non-text events always flush pending text first.
+ */
+export declare class WorkEventCoalescer {
+    private readonly emit;
+    private readonly windowMs;
+    private readonly pending;
+    constructor(emit: (event: AgentWorkEvent) => void, windowMs?: number);
+    push(event: AgentWorkEvent): void;
+    flush(key: string): void;
+    flushAll(): void;
+    pendingCount(): number;
+}
+//# sourceMappingURL=workEventCoalescer.d.ts.map