@newheap/platform-ai-chat 0.9.0 → 0.11.0

package/fesm2022/newheap-platform-ai-chat-testing.mjs

@@ -10,6 +10,7 @@ const responseLengths = ['short', 'normal', 'long'];
 const autonomyLevels = ['observe', 'explain', 'propose', 'simulate', 'execute'];
 const authModes = ['none', 'bearer', 'api-key', 'forward-user-token'];
 const maxInstructions = 20_000;
+const maxStateReason = 500;
 const maxCustomInstructions = 1_000;
 const defaultPreferences = {
     style: 'default',
@@ -28,15 +29,35 @@ class NhAssistantMockAdmin {
         this.now = now;
         this.agents = new Map();
         this.servers = new Map();
+        this.replays = new Map();
         this.contextVersions = [];
         const admin = scenario.admin ?? {};
         this.canAdminister = admin.canAdminister ?? true;
         this.preferences = { ...defaultPreferences, ...scenario.preferences };
         this.contextVersions.push({ version: 1, hash: hashText(admin.context ?? ''), updatedAt: now(), updatedBy: null, text: admin.context ?? '' });
-        const agents = admin.agents ?? scenario.agents.map(agent => ({ ...codeAgentFromSummary(agent), source: 'code' }));
-        for (const { source, ...input } of agents) {
+        const agents = admin.agents
+            ?? scenario.agents.map(agent => ({ ...codeAgentFromSummary(agent), source: 'code' }));
+        for (const { source, skills, shadowOf, ...input } of agents) {
             this.agents.set(input.id, {
-                agent: this.toAgent(input, source, 1, false),
+                agent: {
+                    ...this.toAgent(input, source, 1, false),
+                    shadowOf: shadowOf ?? null,
+                    skills: (skills ?? []).map((skill) => ({
+                        skillId: skill.skillId,
+                        description: skill.description,
+                        runState: 'active',
+                        changedAt: null,
+                        changedBy: null,
+                        reason: null,
+                        waitingInputs: 0,
+                        toolCallsToday: 0,
+                        tokensToday: 0,
+                        dailyToolCalls: null,
+                        dailyTokens: null,
+                        cancelledRuns: 0,
+                        startedRuns: 0
+                    }))
+                },
                 codeDefinition: source === 'code' ? structuredClone(input) : null
             });
         }
@@ -62,11 +83,11 @@ class NhAssistantMockAdmin {
             stored.remoteTools = structuredClone(tools);
         }
     }
-    /** Chat agents: enabled code agents keep their keys, admin agents carry literal text. */
+    /** Chat agents: code agents keep their keys, admin agents carry literal text; stopped agents are left out. */
     chatAgents() {
         const result = [];
         for (const { agent } of this.agents.values()) {
-            if (!agent.isEnabled) {
+            if (agent.runState === 'stopped' || agent.runState === 'configured-off') {
                 continue;
             }
             const summary = this.scenario.agents.find(item => item.id === agent.id);
@@ -104,7 +125,7 @@ class NhAssistantMockAdmin {
         };
         return { status: 200, body: this.preferences };
     }
-    handleAdmin(method, segments, body) {
+    handleAdmin(method, segments, body, query = new URLSearchParams()) {
         if (!this.canAdminister) {
             return failure(403, 'assistant-forbidden');
         }
@@ -118,6 +139,15 @@ class NhAssistantMockAdmin {
                 if (id !== undefined && action === 'feedback') {
                     return this.agentFeedback(method, id, child, segments.length);
                 }
+                if (id !== undefined && action === 'evaluation') {
+                    return this.agentEvaluation(method, id, child, segments.length, query);
+                }
+                if (id !== undefined && (action === 'replay' || action === 'replays') && segments.length === 4) {
+                    return this.agentReplay(method, id, action, body);
+                }
+                if (id !== undefined && action === 'skills' && child !== undefined && segments[5] === 'state' && segments.length === 6) {
+                    return this.skillStateEndpoint(method, id, child, body);
+                }
                 return this.agentsEndpoint(method, id, action, body, segments.length);
             case 'mcp-servers':
                 return this.serversEndpoint(method, id, action, child, body, segments.length);
@@ -192,9 +222,22 @@ class NhAssistantMockAdmin {
             if (!stored.codeDefinition) {
                 return failure(409, 'assistant-agent-not-code');
             }
-            stored.agent = this.toAgent(stored.codeDefinition, 'code', stored.agent.version + 1, false);
+            stored.agent = this.toAgent(stored.codeDefinition, 'code', stored.agent.version + 1, false, stored.agent);
             return { status: 200, body: stored.agent };
         }
+        if (length === 4 && action === 'state') {
+            return this.agentStateEndpoint(stored, method, body);
+        }
+        if (length === 4 && action === 'kill-switch' && method === 'POST') {
+            const engaged = body?.engaged;
+            if (typeof engaged !== 'boolean') {
+                return validationFailure();
+            }
+            const changed = this.agentStateEndpoint(stored, 'POST', { state: engaged ? 'stopped' : 'active' });
+            return changed.status === 200
+                ? { status: 200, body: { agentId: id, enabled: stored.agent.runState !== 'stopped', cancelledRuns: 0 } }
+                : changed;
+        }
         if (length !== 3) {
             return failure(404, 'assistant-not-found');
         }
@@ -208,7 +251,7 @@ class NhAssistantMockAdmin {
                 return failure(409, 'assistant-version-conflict');
             }
             const { expectedVersion, ...definition } = input;
-            stored.agent = this.toAgent(definition, stored.agent.source, stored.agent.version + 1, stored.agent.source === 'code');
+            stored.agent = this.toAgent(definition, stored.agent.source, stored.agent.version + 1, stored.agent.source === 'code', stored.agent);
             return { status: 200, body: stored.agent };
         }
         if (method === 'DELETE') {
@@ -220,6 +263,68 @@ class NhAssistantMockAdmin {
         }
         return { status: 405 };
     }
+    /**
+     * `POST admin/agents/{id}/skills/{skillId}/state`: the skill's state, next to the agent's.
+     */
+    skillStateEndpoint(method, agentId, skillId, body) {
+        const stored = this.agents.get(agentId);
+        const skill = stored?.agent.skills?.find(item => item.skillId === skillId);
+        if (!stored || !skill) {
+            return failure(404, 'assistant-skill-not-found');
+        }
+        if (method !== 'POST') {
+            return { status: 405 };
+        }
+        const request = body;
+        if (request?.state !== 'active' && request?.state !== 'paused' && request?.state !== 'stopped') {
+            return validationFailure();
+        }
+        const reason = typeof request.reason === 'string' && request.reason.trim().length > 0 ? request.reason.trim() : null;
+        const changed = skill.runState === request.state
+            ? skill
+            : { ...skill, runState: request.state, changedAt: this.now(), changedBy: 'current-user', reason };
+        stored.agent = { ...stored.agent, skills: stored.agent.skills.map(item => item.skillId === skillId ? changed : item) };
+        return { status: 200, body: changed };
+    }
+    /**
+     * `GET` and `POST admin/agents/{id}/state`. The mock runs no agents on their own, so a pause
+     * collects no waiting events and a stop cancels no runs; the version never changes.
+     */
+    agentStateEndpoint(stored, method, body) {
+        if (method === 'GET') {
+            return { status: 200, body: toAgentState(stored.agent) };
+        }
+        if (method !== 'POST') {
+            return { status: 405 };
+        }
+        const request = body;
+        if (request?.state === undefined || request.state === null) {
+            return validationFailure();
+        }
+        if (request.state !== 'active' && request.state !== 'paused' && request.state !== 'stopped') {
+            return validationFailure();
+        }
+        const reason = typeof request.reason === 'string' && request.reason.trim().length > 0 ? request.reason.trim() : null;
+        if (reason !== null && reason.length > maxStateReason) {
+            return validationFailure();
+        }
+        if (stored.agent.runState === 'configured-off') {
+            return request.state === 'active'
+                ? failure(409, 'assistant-agent-configured-off')
+                : { status: 200, body: toAgentState(stored.agent) };
+        }
+        if (stored.agent.runState !== request.state) {
+            stored.agent = {
+                ...stored.agent,
+                isEnabled: request.state !== 'stopped',
+                runState: request.state,
+                stateChangedAt: this.now(),
+                stateChangedBy: 'current-user',
+                stateReason: reason
+            };
+        }
+        return { status: 200, body: toAgentState(stored.agent) };
+    }
     /**
      * The feedback report of an agent. The mock runs no agents on their own and records no proposals,
      * so the summary, the list and the JSON Lines export are empty.
@@ -244,6 +349,92 @@ class NhAssistantMockAdmin {
         }
         return failure(404, 'assistant-not-found');
     }
+    /**
+     * The comparison of a shadow variant with its live agent. The mock runs no agents on their own,
+     * so it pairs no runs and the export is empty.
+     */
+    agentEvaluation(method, agentId, child, length, query) {
+        if (!this.agents.has(agentId)) {
+            return failure(404, 'assistant-agent-not-found');
+        }
+        if (method !== 'GET') {
+            return { status: 405 };
+        }
+        const variantId = query.get('variant') ?? '';
+        if (this.agents.get(variantId)?.agent.shadowOf !== agentId) {
+            return failure(400, 'assistant-evaluation-not-variant');
+        }
+        if (length === 5 && child === 'export') {
+            return { status: 200 };
+        }
+        if (length !== 4) {
+            return failure(404, 'assistant-not-found');
+        }
+        const to = query.get('to') ?? this.now();
+        const from = query.get('from') ?? new Date(Date.parse(to) - 7 * 24 * 60 * 60 * 1000).toISOString();
+        const noCost = {
+            runs: 0, modelCalls: 0, tokens: 0, toolCalls: 0,
+            averageModelCalls: 0, averageTokens: 0, averageToolCalls: 0,
+            p95ModelCalls: 0, p95Tokens: 0, p95ToolCalls: 0
+        };
+        return {
+            status: 200,
+            body: {
+                agentId,
+                variantId,
+                from,
+                to,
+                runs: { live: 0, variant: 0, paired: 0, replayed: 0, liveUnpaired: 0, variantUnpaired: 0, truncated: false },
+                tools: [],
+                liveCost: noCost,
+                variantCost: noCost,
+                routing: [],
+                differences: []
+            }
+        };
+    }
+    /**
+     * Replays into a shadow variant. The mock records no runs, so a replay completes at once
+     * without replaying any.
+     */
+    agentReplay(method, agentId, action, body) {
+        const stored = this.agents.get(agentId);
+        if (!stored) {
+            return failure(404, 'assistant-agent-not-found');
+        }
+        if (action === 'replays') {
+            return method === 'GET' ? { status: 200, body: { items: [...(this.replays.get(agentId) ?? [])].reverse() } } : { status: 405 };
+        }
+        if (method !== 'POST') {
+            return { status: 405 };
+        }
+        if (!stored.agent.shadowOf) {
+            return failure(400, 'assistant-replay-not-shadow');
+        }
+        const request = (body ?? {});
+        const maxRuns = request.maxRuns ?? 100;
+        if (maxRuns < 1 || maxRuns > 500) {
+            return failure(400, 'assistant-message-invalid');
+        }
+        const now = this.now();
+        const to = request.to ?? now;
+        const replay = {
+            id: crypto.randomUUID(),
+            variantAgentId: agentId,
+            sourceAgentId: request.sourceAgentId ?? stored.agent.shadowOf,
+            from: request.from ?? new Date(Date.parse(to) - 7 * 24 * 60 * 60 * 1000).toISOString(),
+            to,
+            maxRuns,
+            status: 'completed',
+            stopReason: null,
+            runsReplayed: 0,
+            runsSkipped: 0,
+            createdAt: now,
+            endedAt: now
+        };
+        this.replays.set(agentId, [...(this.replays.get(agentId) ?? []), replay]);
+        return { status: 202, body: replay };
+    }
     serversEndpoint(method, id, action, child, body, length) {
         if (id === undefined) {
             if (method === 'GET') {
@@ -418,16 +609,29 @@ class NhAssistantMockAdmin {
             Array.isArray(input.mcpServerIds) && input.mcpServerIds.every(serverId => this.servers.has(serverId)) &&
             (input.requiredPolicy === null || (typeof input.requiredPolicy === 'string' && (!policies || policies.includes(input.requiredPolicy)))) &&
             autonomyLevels.includes(input.autonomy) &&
-            typeof input.isEnabled === 'boolean';
+            (input.isEnabled === undefined || typeof input.isEnabled === 'boolean');
     }
-    toAgent(input, source, version, isOverridden) {
+    /**
+     * The stored agent. `isEnabled` in the input is ignored, as by the server: the state comes from
+     * `previous`, and a new agent starts active.
+     */
+    toAgent(input, source, version, isOverridden, previous) {
+        const { isEnabled, ...definition } = structuredClone(input);
         return {
-            ...structuredClone(input),
+            ...definition,
+            isEnabled: previous?.isEnabled ?? true,
             version,
             source,
             isOverridden,
             instructionsHash: hashText(input.instructions),
-            updatedAt: this.now()
+            updatedAt: this.now(),
+            runState: previous?.runState ?? 'active',
+            stateChangedAt: previous?.stateChangedAt ?? null,
+            stateChangedBy: previous?.stateChangedBy ?? null,
+            stateReason: previous?.stateReason ?? null,
+            waitingInputs: previous?.waitingInputs ?? 0,
+            skills: previous?.skills ?? [],
+            shadowOf: previous?.shadowOf ?? null
         };
     }
     toServer(stored) {
@@ -449,8 +653,22 @@ function codeAgentFromSummary(agent) {
         toolSelectors: [],
         mcpServerIds: [],
         requiredPolicy: null,
-        autonomy: agent.canMutate ? 'execute' : 'explain',
-        isEnabled: true
+        autonomy: agent.canMutate ? 'execute' : 'explain'
+    };
+}
+function toAgentState(agent) {
+    return {
+        agentId: agent.id,
+        runState: agent.runState,
+        active: agent.runState === 'active',
+        changedAt: agent.stateChangedAt,
+        changedBy: agent.stateChangedBy,
+        reason: agent.stateReason,
+        waitingInputs: agent.waitingInputs,
+        cancelledRuns: 0,
+        startedRuns: 0,
+        skills: agent.skills ?? [],
+        shadowOf: agent.shadowOf ?? null
     };
 }
 function toServerFields(input) {
@@ -655,7 +873,7 @@ class NhAssistantMockBackend {
             return this.error(404, 'assistant-push-unavailable');
         }
         if (segments[0] === 'admin') {
-            return this.result(this.admin.handleAdmin(method, segments, body));
+            return this.result(this.admin.handleAdmin(method, segments, body, query));
         }
         if (segments[0] !== 'conversations') {
             return this.empty(404);