newmark-agent 0.5.14 → 0.6.0

package/dist/core/autoRouter.js

@@ -34,19 +34,6 @@ function inSubset(deployment, subset) {
 function inScope(deployment, scope) {
     return scope.kind === 'global' || deployment.providerId === scope.providerId;
 }
-function validationEligible(candidate, now) {
-    const reasons = [];
-    if (candidate.validation.level !== 'standard' && candidate.validation.level !== 'extended') {
-        reasons.push(`validation_level:${candidate.validation.level}`);
-    }
-    if (candidate.validation.status !== 'verified' && candidate.validation.status !== 'degraded') {
-        reasons.push(`validation_status:${candidate.validation.status}`);
-    }
-    const checkedAt = Date.parse(candidate.validation.checkedAt);
-    if (!Number.isFinite(checkedAt) || now - checkedAt > VALIDATION_TTL_MS)
-        reasons.push('validation_expired');
-    return reasons;
-}
 function normalizeAutoPreference(value) {
     switch (String(value || '').toLowerCase()) {
         case 'performance':
@@ -93,6 +80,18 @@ function classifyTaskClasses(taskText, requiredCapabilities, estimatedInputToken
 }
 function classifyRouteFailure(error) {
     const text = error instanceof Error ? `${error.name} ${error.message}` : String(error || '');
+    // Gateways may return HTTP 200 followed by a structured provider error.
+    // Match actual code/type fields, never incidental overload words in prose.
+    let structuredCodes = [];
+    const jsonStart = text.indexOf('{');
+    if (jsonStart >= 0) {
+        try {
+            const payload = JSON.parse(text.slice(jsonStart));
+            const detail = payload?.error || payload?.response?.error || payload;
+            structuredCodes = [detail?.code, detail?.type].filter(value => typeof value === 'string').map(value => value.toLowerCase());
+        }
+        catch { /* Ordinary non-JSON errors retain their existing classification. */ }
+    }
     const statusMatch = text.match(/(?:http|error|status)?\s*[:=]?\s*(408|429|4\d\d|5\d\d)\b/i);
     const statusCode = statusMatch ? Number(statusMatch[1]) : undefined;
     const retryAfterMatch = text.match(/retry[- ]after\s*[:=]?\s*(\d+(?:\.\d+)?)\s*(ms|s|seconds?)?/i);
@@ -122,10 +121,11 @@ function classifyRouteFailure(error) {
         return { type: 'rate_limited', retryable: true, switchAllowed: true, statusCode: 429, retryAfterMs };
     }
     if (statusCode === 408 || /timeout|timed out|aborterror/i.test(text)) {
-        return { type: 'timeout', retryable: true, switchAllowed: true, statusCode };
+        return { type: 'timeout', retryable: true, switchAllowed: true, statusCode, ...(retryAfterMs === undefined ? {} : { retryAfterMs }) };
     }
-    if (statusCode !== undefined && statusCode >= 500) {
-        return { type: 'server_error', retryable: true, switchAllowed: true, statusCode };
+    if ((statusCode !== undefined && statusCode >= 500)
+        || structuredCodes.some(code => ['server_is_overloaded', 'overloaded_error', 'service_unavailable_error', 'server_error', 'internal_server_error'].includes(code))) {
+        return { type: 'server_error', retryable: true, switchAllowed: true, statusCode, ...(retryAfterMs === undefined ? {} : { retryAfterMs }) };
     }
     if (/empty response|no response body|empty completion/i.test(text))
         return { type: 'empty_response', retryable: true, switchAllowed: true };
@@ -178,7 +178,6 @@ class AutoRouter {
             this.claimEndpointAttempt(fixed.deployment);
             return decision;
         }
-        const requiredCapabilities = new Set([...policy.requiredCapabilities, ...request.requiredCapabilities].map(item => String(item).toLowerCase()));
         const eligible = [];
         for (const candidate of candidates) {
             const reasons = [];
@@ -192,13 +191,8 @@ class AutoRouter {
                 reasons.push('fallback_only');
             if (candidate.preview && !policy.allowPreview)
                 reasons.push('preview_disallowed');
-            reasons.push(...validationEligible(candidate, now));
             if (request.estimatedInputTokens + request.expectedOutputTokens > Math.max(0, candidate.maxContextTokens || 0))
                 reasons.push('context_too_small');
-            const capabilities = new Set(candidate.capabilities.map(item => String(item).toLowerCase()));
-            for (const capability of requiredCapabilities)
-                if (!capabilities.has(capability))
-                    reasons.push(`missing_capability:${capability}`);
             if (policy.privacy !== 'default' && !candidate.privacy.includes(policy.privacy))
                 reasons.push(`privacy:${policy.privacy}`);
             if (policy.dataRegion) {
@@ -217,8 +211,6 @@ class AutoRouter {
             if (policy.maxExpectedCostUsd !== undefined && (expectedCost === undefined || expectedCost > policy.maxExpectedCostUsd)) {
                 reasons.push(expectedCost === undefined ? 'unknown_cost' : 'budget_exceeded');
             }
-            if (this.circuitState(candidate.deployment, now, false) === 'open')
-                reasons.push('circuit_open');
             if (reasons.length)
                 decision.excludedCandidates.push({ deployment: { ...candidate.deployment }, reasons: [...new Set(reasons)] });
             else
@@ -312,9 +304,7 @@ class AutoRouter {
             && inSubset(candidate.deployment, subset)
             && !sameDeployment(candidate.deployment, current)
             && !attemptedDeployments.some(attempted => sameDeployment(candidate.deployment, attempted))
-            && validationEligible(candidate, now).length === 0
-            && this.passedInitialHardFilters(decision, candidate)
-            && this.circuitState(candidate.deployment, now, false) !== 'open');
+            && this.passedInitialHardFilters(decision, candidate));
         const equivalent = currentGroup
             ? eligible.find(candidate => candidate.deployment.logicalModelGroupId === currentGroup && !candidate.fallbackOnly)
             : undefined;

package/dist/core/config.d.ts

@@ -1,3 +1,4 @@
+import { ModelResponseHealth } from './modelResponseHealth';
 export interface JsonValue {
     [key: string]: unknown;
 }
@@ -20,6 +21,7 @@ export interface ProviderConfig {
     models: ModelConfig[];
 }
 export interface ModelConfig {
+    response_health?: ModelResponseHealth;
     name: string;
     display: string;
     description: string;

package/dist/core/config.js

@@ -44,6 +44,7 @@ exports.mergeProviderSecrets = mergeProviderSecrets;
 exports.defaultModelConfig = defaultModelConfig;
 exports.stableProviderId = stableProviderId;
 exports.defaultConfig = defaultConfig;
+const modelResponseHealth_1 = require("./modelResponseHealth");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const crypto_1 = require("crypto");
@@ -191,7 +192,12 @@ class ConfigManager {
         this.workspaceOverrides.clear();
     }
     providers() {
-        return this.normalizeProviders((this.getGlobal('models', 'providers')) || []);
+        return this.normalizeProviders((this.getGlobal('models', 'providers')) || []).map(provider => ({
+            ...provider,
+            models: provider.models.map(model => ({ ...model, response_health: (0, modelResponseHealth_1.readModelResponseHealth)(this.rootPath, {
+                    providerId: provider.id, modelId: model.name, endpoint: provider.base_url, protocol: provider.protocol, credential: provider.api_key,
+                }) })),
+        }));
     }
     allModels() {
         const models = [];

package/dist/core/conversationCommandState.d.ts

@@ -0,0 +1,17 @@
+export interface ConversationCommandState {
+    mode?: 'build' | 'plan' | 'chat' | 'goal' | 'flow';
+    inputMode?: 'guide' | 'next';
+    queuePaused?: boolean;
+}
+/** GUI command owner only; execution and continuation payloads remain owned by their Agent. */
+export declare class ConversationCommandStateStore {
+    private readonly file;
+    private records;
+    constructor(root: string);
+    get(key: string): ConversationCommandState | undefined;
+    set(key: string, patch: ConversationCommandState): ConversationCommandState;
+    delete(key: string): void;
+    private key;
+    private persist;
+}
+//# sourceMappingURL=conversationCommandState.d.ts.map

package/dist/core/conversationCommandState.js

@@ -0,0 +1,140 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationCommandStateStore = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const modes = new Set(['build', 'plan', 'chat', 'goal', 'flow']);
+function stateValue(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Invalid conversation command state');
+    const row = value;
+    const result = {};
+    if (row.mode !== undefined) {
+        if (typeof row.mode !== 'string' || !modes.has(row.mode))
+            throw new Error('Invalid conversation mode');
+        result.mode = row.mode;
+    }
+    if (row.inputMode !== undefined) {
+        if (row.inputMode !== 'guide' && row.inputMode !== 'next')
+            throw new Error('Invalid conversation input mode');
+        result.inputMode = row.inputMode;
+    }
+    if (row.queuePaused !== undefined) {
+        if (typeof row.queuePaused !== 'boolean')
+            throw new Error('Invalid conversation queue pause state');
+        result.queuePaused = row.queuePaused;
+    }
+    return result;
+}
+/** GUI command owner only; execution and continuation payloads remain owned by their Agent. */
+class ConversationCommandStateStore {
+    file;
+    records = new Map();
+    constructor(root) {
+        this.file = path.join(path.resolve(root), 'conversation-command-state.json');
+        let source;
+        try {
+            source = fs.readFileSync(this.file, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+        const saved = JSON.parse(source);
+        if (saved?.version !== 1 || !saved.targets || typeof saved.targets !== 'object' || Array.isArray(saved.targets)) {
+            throw new Error('Unsupported conversation command state file');
+        }
+        for (const [key, value] of Object.entries(saved.targets))
+            this.records.set(this.key(key), stateValue(value));
+    }
+    get(key) {
+        const value = this.records.get(this.key(key));
+        return value ? { ...value } : undefined;
+    }
+    set(key, patch) {
+        const target = this.key(key);
+        const before = this.records.get(target);
+        const after = { ...before, ...stateValue(patch) };
+        if (before && before.mode === after.mode && before.inputMode === after.inputMode && before.queuePaused === after.queuePaused)
+            return { ...before };
+        const next = new Map(this.records);
+        next.set(target, after);
+        this.persist(next);
+        return { ...after };
+    }
+    delete(key) {
+        const target = this.key(key);
+        if (!this.records.has(target))
+            return;
+        const next = new Map(this.records);
+        next.delete(target);
+        this.persist(next);
+    }
+    key(value) {
+        if (typeof value !== 'string' || !value.trim())
+            throw new Error('Conversation target key is required');
+        return value;
+    }
+    persist(next) {
+        fs.mkdirSync(path.dirname(this.file), { recursive: true });
+        const temp = this.file + '.' + (0, node_crypto_1.randomUUID)() + '.tmp';
+        let descriptor;
+        try {
+            descriptor = fs.openSync(temp, 'wx', 0o600);
+            fs.writeFileSync(descriptor, JSON.stringify({ version: 1, targets: Object.fromEntries(next) }) + '\n');
+            fs.fsyncSync(descriptor);
+            fs.closeSync(descriptor);
+            descriptor = undefined;
+            fs.renameSync(temp, this.file);
+            this.records = next;
+        }
+        finally {
+            if (descriptor !== undefined)
+                fs.closeSync(descriptor);
+            try {
+                fs.unlinkSync(temp);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+    }
+}
+exports.ConversationCommandStateStore = ConversationCommandStateStore;
+//# sourceMappingURL=conversationCommandState.js.map

package/dist/core/conversationKernel.d.ts

@@ -11,8 +11,9 @@ export interface ConversationQueueItemSnapshot {
     goalObjective?: string;
     runId?: string;
     createdAt: string;
+    images?: AgentPromptMessage['images'];
 }
-export type ConversationQueueAction = 'enqueue' | 'update' | 'delete' | 'reorder' | 'toggle_pause' | 'guide';
+export type ConversationQueueAction = 'enqueue' | 'update' | 'delete' | 'reorder' | 'toggle_pause' | 'set_pause' | 'guide';
 export interface ConversationQueueActionInput {
     id?: string;
     text?: string;
@@ -21,6 +22,7 @@ export interface ConversationQueueActionInput {
     createdAt?: string;
     images?: AgentPromptMessage['images'];
     orderedIds?: string[];
+    paused?: boolean;
 }
 export interface AgentPromptMessage {
     text: string;
@@ -38,6 +40,9 @@ export interface AgentPromptMessage {
     }>;
     attachments?: ConversationImageAttachment[];
     clientMessageId?: string;
+    /** Stable ordinary user identity; unlike clientMessageId alone, never denotes a Guide. */
+    userMessageId?: string;
+    createdAt?: string;
     guideId?: string;
     runId?: string;
     /**
@@ -189,7 +194,19 @@ export declare class ConversationKernel {
     constructor(root: string, host: Agent, automation: AutomationManager | null, lifecycle?: ConversationKernelLifecycle);
     subscribe(listener: WorkListener): () => void;
     isRunning(target: ConversationTargetInput): boolean;
+    conversationOwner(target: ConversationTargetInput): Agent | null;
+    /** Branch mutations retain the Agent but reload that branch's durable queue. */
+    refreshIdleConversation(target: ConversationTargetInput): void;
+    /** Detach idle owners before config replacement or workspace removal. */
+    disposeIdle(workspaceKey?: string): string[];
+    /** A Flow and its queue share one Agent; no second history writer is created. */
+    beginExternalRun(targetInput: ConversationTargetInput, options: ConversationKernelRunOptions, createOwner: () => Agent, previousQueuePaused?: boolean): Agent;
+    settleExternalRun(target: ConversationTargetInput, completed: boolean): void;
+    releaseExternalRun(target: ConversationTargetInput, paused: boolean): void;
+    prepareForArchive(target: ConversationTargetInput): Promise<Agent | null>;
+    finishArchive(target: ConversationTargetInput, completed: boolean, preserveOwner?: boolean): void;
     isAnyRunning(): boolean;
+    hasRetainedWork(): boolean;
     flushPersistence(): void;
     queued(target: ConversationTargetInput): {
         steering: string[];
@@ -216,7 +233,7 @@ export declare class ConversationKernel {
         createdAt?: string;
         images?: AgentPromptMessage['images'];
     }): ConversationQueueItemSnapshot;
-    updateQueueItem(target: ConversationTargetInput, idInput: string, textInput: string): ConversationQueueItemSnapshot;
+    updateQueueItem(target: ConversationTargetInput, idInput: string, textInput: string, input?: ConversationQueueActionInput): ConversationQueueItemSnapshot;
     deleteQueueItem(target: ConversationTargetInput, idInput: string): boolean;
     reorderQueueItems(target: ConversationTargetInput, orderedIdsInput: string[]): ConversationQueueItemSnapshot[];
     setQueuePaused(target: ConversationTargetInput, paused: boolean): boolean;
@@ -233,7 +250,10 @@ export declare class ConversationKernel {
     events(target: ConversationTargetInput): AgentWorkEvent[];
     waitForIdle(target: ConversationTargetInput): Promise<void>;
     pendingOptions(target: ConversationTargetInput): OptionQuestion[] | undefined;
-    snapshot(target: ConversationTargetInput): ReturnType<Agent['getConversationSnapshot']> & {
+    snapshot(target: ConversationTargetInput, options?: {
+        window?: number;
+        before?: number;
+    }): ReturnType<Agent['getConversationSnapshot']> & {
         target: NormalizedConversationTarget;
         queued: {
             steering: string[];
@@ -277,6 +297,7 @@ export declare class ConversationKernel {
     setMode(target: ConversationTargetInput, mode: AgentMode): AgentMode;
     setModel(target: ConversationTargetInput, model: string): string;
     toggleGoalPause(target: ConversationTargetInput): Promise<boolean>;
+    updateGoal(target: ConversationTargetInput, objective: string): ReturnType<Agent['getConversationSnapshot']>['goal'];
     clearGoal(target: ConversationTargetInput): boolean;
     updateSetting(section: string, key: string, value: unknown): void;
     runtimeState(target: ConversationTargetInput): ConversationRuntimeState | null;
@@ -304,6 +325,7 @@ export declare class ConversationKernel {
     private runtime;
     private scheduleGoalContinuation;
     private schedulePendingRuntimeContinuation;
+    private runPendingQueueItem;
     private startGoalDrivenBuild;
     private createRunner;
     private enqueueRootInboxWake;
@@ -320,7 +342,6 @@ export declare class ConversationKernel {
     private enqueueSameSession;
     private trackQueuedMessage;
     private consumeQueuedMessage;
-    private replaceTrackedQueuedMessage;
     private emitQueueUpdate;
     private clearQueued;
     private queueState;