@newheap/platform-ai-chat 0.1.0

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

@@ -0,0 +1,911 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, signal, Injectable, makeEnvironmentProviders } from '@angular/core';
+import { NH_ASSISTANT_CONFIG, normalizeNhAssistantClientContext, applyNhAssistantApprovalDecision, applyNhAssistantEvent, NH_ASSISTANT_FETCH } from '@newheap/platform-ai-chat';
+
+const dashCase = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const styles = ['default', 'direct', 'personal', 'detailed'];
+const addressForms = ['informal', 'formal'];
+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 maxCustomInstructions = 1_000;
+const defaultPreferences = {
+    style: 'default',
+    addressForm: 'informal',
+    responseLength: 'normal',
+    customInstructions: null
+};
+/**
+ * In-memory administration and preference endpoints of the mock API. Follows the
+ * contract rules: secrets are write-only, new MCP tools start disabled as mutations, a
+ * changed remote schema disables a tool, and stale versions answer `409`.
+ */
+class NhAssistantMockAdmin {
+    constructor(scenario, now) {
+        this.scenario = scenario;
+        this.now = now;
+        this.agents = new Map();
+        this.servers = 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) {
+            this.agents.set(input.id, {
+                agent: this.toAgent(input, source, 1, false),
+                codeDefinition: source === 'code' ? structuredClone(input) : null
+            });
+        }
+        for (const { remoteTools, secret, ...input } of admin.mcpServers ?? []) {
+            this.servers.set(input.id, {
+                server: { ...toServerFields(input), lastSyncAt: null, lastSyncStatus: null },
+                secret: secret ?? null,
+                remoteTools: remoteTools ?? [],
+                tools: new Map()
+            });
+        }
+    }
+    get administers() {
+        return this.canAdminister;
+    }
+    setCanAdminister(value) {
+        this.canAdminister = value;
+    }
+    /** Replaces the tool list of a simulated remote server; the next sync picks it up. */
+    setRemoteTools(serverId, tools) {
+        const stored = this.servers.get(serverId);
+        if (stored) {
+            stored.remoteTools = structuredClone(tools);
+        }
+    }
+    /** Chat agents: enabled code agents keep their keys, admin agents carry literal text. */
+    chatAgents() {
+        const result = [];
+        for (const { agent } of this.agents.values()) {
+            if (!agent.isEnabled) {
+                continue;
+            }
+            const summary = this.scenario.agents.find(item => item.id === agent.id);
+            result.push(summary && agent.source === 'code'
+                ? { ...summary, version: agent.version }
+                : {
+                    id: agent.id,
+                    version: agent.version,
+                    displayNameKey: agent.displayName,
+                    descriptionKey: agent.description,
+                    canMutate: agent.autonomy === 'execute'
+                });
+        }
+        return result;
+    }
+    handlePreferences(method, body) {
+        if (method === 'GET') {
+            return { status: 200, body: this.preferences };
+        }
+        if (method !== 'PUT') {
+            return { status: 405 };
+        }
+        const input = body;
+        const instructions = input?.customInstructions ?? null;
+        if (!input || !styles.includes(input.style ?? '') || !addressForms.includes(input.addressForm ?? '') ||
+            !responseLengths.includes(input.responseLength ?? '') ||
+            (instructions !== null && (typeof instructions !== 'string' || instructions.length > maxCustomInstructions))) {
+            return validationFailure();
+        }
+        this.preferences = {
+            style: input.style,
+            addressForm: input.addressForm,
+            responseLength: input.responseLength,
+            customInstructions: instructions && instructions.trim().length > 0 ? instructions : null
+        };
+        return { status: 200, body: this.preferences };
+    }
+    handleAdmin(method, segments, body) {
+        if (!this.canAdminister) {
+            return failure(403, 'assistant-forbidden');
+        }
+        const [, area, id, action, child] = segments;
+        switch (area) {
+            case 'context':
+                return this.context(method, id, body);
+            case 'tools':
+                return method === 'GET' && segments.length === 2 ? { status: 200, body: this.toolCatalog() } : failure(404, 'assistant-not-found');
+            case 'agents':
+                return this.agentsEndpoint(method, id, action, body, segments.length);
+            case 'mcp-servers':
+                return this.serversEndpoint(method, id, action, child, body, segments.length);
+            default:
+                return failure(404, 'assistant-not-found');
+        }
+    }
+    context(method, sub, body) {
+        const current = this.contextVersions[this.contextVersions.length - 1];
+        if (sub === 'versions' && method === 'GET') {
+            return { status: 200, body: [...this.contextVersions].reverse().map(({ text, ...version }) => version) };
+        }
+        if (sub !== undefined) {
+            return failure(404, 'assistant-not-found');
+        }
+        if (method === 'GET') {
+            return { status: 200, body: toContext(current) };
+        }
+        if (method !== 'PUT') {
+            return { status: 405 };
+        }
+        const input = body;
+        if (typeof input?.text !== 'string' || typeof input.expectedVersion !== 'number') {
+            return validationFailure();
+        }
+        if (input.text.length > maxInstructions) {
+            return failure(400, 'assistant-instructions-too-long');
+        }
+        if (input.expectedVersion !== current.version) {
+            return failure(409, 'assistant-version-conflict');
+        }
+        const next = { version: current.version + 1, hash: hashText(input.text), updatedAt: this.now(), updatedBy: 'current-user', text: input.text };
+        this.contextVersions.push(next);
+        return { status: 200, body: toContext(next) };
+    }
+    toolCatalog() {
+        const catalog = [...(this.scenario.admin?.tools ?? [])];
+        for (const stored of this.servers.values()) {
+            for (const tool of stored.tools.values()) {
+                if (tool.isEnabled) {
+                    catalog.push({ id: tool.localId, source: 'mcp', effect: tool.effect, description: tool.descriptionOverride ?? tool.description });
+                }
+            }
+        }
+        return catalog;
+    }
+    agentsEndpoint(method, id, action, body, length) {
+        if (id === undefined) {
+            if (method === 'GET') {
+                return { status: 200, body: [...this.agents.values()].map(stored => stored.agent) };
+            }
+            if (method !== 'POST') {
+                return { status: 405 };
+            }
+            const input = body;
+            const invalid = this.agentFailure(input);
+            if (invalid) {
+                return invalid;
+            }
+            if (this.agents.has(input.id)) {
+                return failure(409, 'assistant-agent-exists');
+            }
+            const agent = this.toAgent(input, 'admin', 1, false);
+            this.agents.set(agent.id, { agent, codeDefinition: null });
+            return { status: 201, body: agent };
+        }
+        const stored = this.agents.get(id);
+        if (!stored) {
+            return failure(404, 'assistant-not-found');
+        }
+        if (length === 4 && action === 'reset' && method === 'POST') {
+            if (!stored.codeDefinition) {
+                return failure(409, 'assistant-agent-not-code');
+            }
+            stored.agent = this.toAgent(stored.codeDefinition, 'code', stored.agent.version + 1, false);
+            return { status: 200, body: stored.agent };
+        }
+        if (length !== 3) {
+            return failure(404, 'assistant-not-found');
+        }
+        if (method === 'PUT') {
+            const input = body;
+            const invalid = input?.id !== id ? validationFailure() : this.agentFailure(input);
+            if (invalid) {
+                return invalid;
+            }
+            if (input.expectedVersion !== stored.agent.version) {
+                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');
+            return { status: 200, body: stored.agent };
+        }
+        if (method === 'DELETE') {
+            if (stored.agent.source === 'code') {
+                return failure(409, 'assistant-code-agent-not-deletable');
+            }
+            this.agents.delete(id);
+            return { status: 204 };
+        }
+        return { status: 405 };
+    }
+    serversEndpoint(method, id, action, child, body, length) {
+        if (id === undefined) {
+            if (method === 'GET') {
+                return { status: 200, body: [...this.servers.values()].map(stored => this.toServer(stored)) };
+            }
+            if (method !== 'POST') {
+                return { status: 405 };
+            }
+            const input = body;
+            if (!validServer(input)) {
+                return validationFailure();
+            }
+            if (this.servers.has(input.id)) {
+                return failure(409, 'assistant-mcp-server-exists');
+            }
+            const stored = {
+                server: { ...toServerFields(input), lastSyncAt: null, lastSyncStatus: null },
+                secret: input.secret ? input.secret : null,
+                remoteTools: [],
+                tools: new Map()
+            };
+            this.servers.set(input.id, stored);
+            return { status: 201, body: this.toServer(stored) };
+        }
+        const stored = this.servers.get(id);
+        if (!stored) {
+            return failure(404, 'assistant-mcp-server-not-found');
+        }
+        if (length === 3) {
+            if (method === 'PUT') {
+                const input = body;
+                if (!validServer(input) || input.id !== id) {
+                    return validationFailure();
+                }
+                stored.server = { ...stored.server, ...toServerFields(input) };
+                if (input.secret !== undefined) {
+                    stored.secret = input.secret ? input.secret : null;
+                }
+                return { status: 200, body: this.toServer(stored) };
+            }
+            if (method === 'DELETE') {
+                this.servers.delete(id);
+                for (const agent of this.agents.values()) {
+                    agent.agent = { ...agent.agent, mcpServerIds: agent.agent.mcpServerIds.filter(serverId => serverId !== id) };
+                }
+                return { status: 204 };
+            }
+            return { status: 405 };
+        }
+        if (length === 4 && action === 'test' && method === 'POST') {
+            const code = this.connectionFailure(stored);
+            const result = code
+                ? { ok: false, code, toolCount: null }
+                : { ok: true, code: null, toolCount: stored.remoteTools.length };
+            return { status: 200, body: result };
+        }
+        if (length === 4 && action === 'sync' && method === 'POST') {
+            const code = this.connectionFailure(stored);
+            stored.server = { ...stored.server, lastSyncAt: this.now(), lastSyncStatus: code ? 'failed' : 'ok' };
+            if (code) {
+                // A blocked host is a configuration error; connection failures are upstream errors.
+                return failure(code === 'assistant-mcp-host-blocked' ? 400 : 502, code);
+            }
+            this.sync(stored);
+            return { status: 200, body: toTools(stored) };
+        }
+        if (length === 4 && action === 'tools' && method === 'GET') {
+            return { status: 200, body: toTools(stored) };
+        }
+        if (length === 5 && action === 'tools' && method === 'PUT' && child !== undefined) {
+            const tool = stored.tools.get(child);
+            const input = body;
+            if (!tool) {
+                return failure(404, 'assistant-mcp-tool-not-found');
+            }
+            if (typeof input?.isEnabled !== 'boolean' || (input.effect !== 'read-only' && input.effect !== 'mutation') ||
+                (input.descriptionOverride !== null && typeof input.descriptionOverride !== 'string')) {
+                return validationFailure();
+            }
+            if (input.isEnabled && tool.status === 'missing') {
+                return validationFailure('isEnabled');
+            }
+            const override = typeof input.descriptionOverride === 'string' && input.descriptionOverride.trim().length > 0
+                ? input.descriptionOverride.slice(0, 1_000)
+                : null;
+            const updated = {
+                ...tool,
+                isEnabled: input.isEnabled,
+                effect: input.effect,
+                descriptionOverride: override,
+                status: input.isEnabled && tool.status === 'schema-changed' ? 'available' : tool.status
+            };
+            stored.tools.set(child, updated);
+            return { status: 200, body: toTool(updated) };
+        }
+        return failure(404, 'assistant-not-found');
+    }
+    sync(stored) {
+        const seen = new Set();
+        for (const remote of stored.remoteTools) {
+            seen.add(remote.remoteName);
+            const existing = stored.tools.get(remote.remoteName);
+            const description = remote.description.slice(0, 1_000);
+            if (!existing) {
+                stored.tools.set(remote.remoteName, {
+                    remoteName: remote.remoteName,
+                    localId: `mcp.${stored.server.id}.${kebab(remote.remoteName)}`,
+                    description,
+                    descriptionOverride: null,
+                    isEnabled: false,
+                    effect: 'mutation',
+                    status: 'available',
+                    readOnlyHint: remote.readOnlyHint ?? null,
+                    inputSchemaHash: remote.inputSchemaHash
+                });
+                continue;
+            }
+            const changed = existing.inputSchemaHash !== remote.inputSchemaHash;
+            stored.tools.set(remote.remoteName, {
+                ...existing,
+                description,
+                readOnlyHint: remote.readOnlyHint ?? null,
+                inputSchemaHash: remote.inputSchemaHash,
+                isEnabled: changed ? false : existing.isEnabled,
+                status: changed ? 'schema-changed' : existing.status === 'missing' ? 'available' : existing.status
+            });
+        }
+        for (const [name, tool] of stored.tools) {
+            if (!seen.has(name)) {
+                stored.tools.set(name, { ...tool, isEnabled: false, status: 'missing' });
+            }
+        }
+    }
+    connectionFailure(stored) {
+        let url;
+        try {
+            url = new URL(stored.server.url);
+        }
+        catch {
+            return 'assistant-mcp-unreachable';
+        }
+        const host = url.hostname.toLowerCase();
+        if (host.startsWith('169.254.') || host.startsWith('[fe80') || host.includes('metadata')) {
+            return 'assistant-mcp-host-blocked';
+        }
+        if (stored.server.authMode === 'forward-user-token' && !(this.scenario.admin?.forwardUserTokenHosts ?? []).includes(host)) {
+            return 'assistant-mcp-host-blocked';
+        }
+        if (host.includes('unreachable')) {
+            return 'assistant-mcp-unreachable';
+        }
+        if ((stored.server.authMode === 'bearer' || stored.server.authMode === 'api-key') && !stored.secret) {
+            return 'assistant-mcp-unauthorized';
+        }
+        return null;
+    }
+    /** The contract failure for an invalid agent, or null when the agent is valid. */
+    agentFailure(input) {
+        if (typeof input?.instructions === 'string' && input.instructions.length > maxInstructions) {
+            return failure(400, 'assistant-instructions-too-long');
+        }
+        return this.validAgent(input) ? null : validationFailure();
+    }
+    validAgent(input) {
+        const policies = this.scenario.admin?.policies;
+        return !!input &&
+            typeof input.id === 'string' && input.id.length <= 60 && dashCase.test(input.id) &&
+            typeof input.displayName === 'string' && input.displayName.trim().length > 0 &&
+            typeof input.description === 'string' &&
+            typeof input.instructions === 'string' && input.instructions.length <= maxInstructions &&
+            Array.isArray(input.toolSelectors) && input.toolSelectors.every(selector => /^[a-z0-9*][a-z0-9.*-]*$/.test(selector)) &&
+            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';
+    }
+    toAgent(input, source, version, isOverridden) {
+        return {
+            ...structuredClone(input),
+            version,
+            source,
+            isOverridden,
+            instructionsHash: hashText(input.instructions),
+            updatedAt: this.now()
+        };
+    }
+    toServer(stored) {
+        return {
+            ...stored.server,
+            hasSecret: stored.secret !== null,
+            assignedAgentIds: [...this.agents.values()]
+                .filter(agent => agent.agent.mcpServerIds.includes(stored.server.id))
+                .map(agent => agent.agent.id)
+        };
+    }
+}
+function codeAgentFromSummary(agent) {
+    return {
+        id: agent.id,
+        displayName: agent.id,
+        description: '',
+        instructions: '',
+        toolSelectors: [],
+        mcpServerIds: [],
+        requiredPolicy: null,
+        autonomy: agent.canMutate ? 'execute' : 'explain',
+        isEnabled: true
+    };
+}
+function toServerFields(input) {
+    return {
+        id: input.id,
+        displayName: input.displayName,
+        url: input.url,
+        authMode: input.authMode,
+        headerName: input.authMode === 'api-key' ? (input.headerName || 'X-Api-Key') : null,
+        requiredPolicy: input.requiredPolicy,
+        isEnabled: input.isEnabled
+    };
+}
+function validServer(input) {
+    if (!input || typeof input.id !== 'string' || input.id.length > 40 || !dashCase.test(input.id) ||
+        typeof input.displayName !== 'string' || input.displayName.trim().length === 0 ||
+        !authModes.includes(input.authMode) || typeof input.isEnabled !== 'boolean') {
+        return false;
+    }
+    try {
+        const url = new URL(input.url);
+        return url.protocol === 'https:' || (url.protocol === 'http:' && url.hostname === 'localhost');
+    }
+    catch {
+        return false;
+    }
+}
+function toTool({ inputSchemaHash, ...tool }) {
+    return tool;
+}
+function toTools(stored) {
+    return [...stored.tools.values()].map(toTool);
+}
+function toContext(version) {
+    return { text: version.text, version: version.version, hash: version.hash, updatedAt: version.updatedAt, updatedBy: version.updatedBy };
+}
+/** A contract error response: `{ code, messageKey, errors? }`, never free text. */
+function failure(status, code, errors) {
+    return { status, body: { code, messageKey: `nh-assistant.errors.${code}`, ...(errors ? { errors } : {}) } };
+}
+function validationFailure(field) {
+    return failure(400, 'assistant-validation', field ? { [field]: ['invalid'] } : undefined);
+}
+function kebab(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/[^A-Za-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase();
+}
+/** A stable, non-cryptographic fingerprint; the mock only needs change detection. */
+function hashText(text) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < text.length; index++) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return `fnv1a:${hash.toString(16).padStart(8, '0')}`;
+}
+
+const NH_ASSISTANT_MOCK_SCENARIO = new InjectionToken('NH_ASSISTANT_MOCK_SCENARIO');
+const defaultLimits = { maxMessageChars: 4_000, maxToolCallsPerTurn: 8 };
+class RunStopped extends Error {
+}
+/**
+ * In-memory implementation of the assistant HTTP API and its event streams. It keeps
+ * conversations, plays scripted turns as contract events through a real
+ * `text/event-stream` response and handles approvals, cancellation and the feature flag.
+ */
+class NhAssistantMockBackend {
+    constructor() {
+        this.scenario = inject(NH_ASSISTANT_MOCK_SCENARIO);
+        this.config = inject(NH_ASSISTANT_CONFIG);
+        this.conversations = new Map();
+        this.pendingApprovals = new Map();
+        this.runs = new Map();
+        /** Page context of the latest message per conversation, as the server stores it. */
+        this.pageContexts = new Map();
+        this.enabledState = signal(this.scenario.enabled ?? true, ...(ngDevMode ? [{ debugName: "enabledState" }] : []));
+        this.admin = new NhAssistantMockAdmin(this.scenario, () => new Date().toISOString());
+        this.canAdministerState = signal(this.admin.administers, ...(ngDevMode ? [{ debugName: "canAdministerState" }] : []));
+        this.sequence = 0;
+        /** Requests received so far, oldest first. */
+        this.requests = [];
+        this.enabled = this.enabledState.asReadonly();
+        this.canAdminister = this.canAdministerState.asReadonly();
+        /** A `fetch` implementation that answers the assistant endpoints below `apiBaseUrl`. */
+        this.fetch = async (input, init) => {
+            const method = (init.method ?? 'GET').toUpperCase();
+            const url = new URL(input, 'http://mock.local');
+            const base = new URL(this.config.apiBaseUrl.replace(/\/+$/, ''), 'http://mock.local').pathname;
+            const path = url.pathname.startsWith(`${base}/`) ? url.pathname.slice(base.length + 1) : null;
+            const body = typeof init.body === 'string' && init.body.length > 0 ? JSON.parse(init.body) : undefined;
+            this.requests.push({ method, path: path ?? url.pathname, headers: { ...init.headers }, body });
+            if (init.signal?.aborted) {
+                throw new DOMException('The operation was aborted.', 'AbortError');
+            }
+            if (path === null) {
+                return this.empty(404);
+            }
+            return this.route(method, path, url.searchParams, body);
+        };
+        for (const conversation of this.scenario.conversations ?? []) {
+            this.conversations.set(conversation.id, structuredClone(conversation));
+        }
+    }
+    /** Switches the simulated `NewHeap:AI:Assistant:Enabled` flag. */
+    setEnabled(enabled) {
+        this.enabledState.set(enabled);
+    }
+    /** Switches whether the caller passes the admin policy (`canAdminister`, `admin/*`). */
+    setCanAdminister(canAdminister) {
+        this.admin.setCanAdminister(canAdminister);
+        this.canAdministerState.set(canAdminister);
+    }
+    /** Replaces the tools a simulated MCP server lists; the next sync picks them up. */
+    setRemoteTools(serverId, tools) {
+        this.admin.setRemoteTools(serverId, tools);
+    }
+    route(method, path, query, body) {
+        const segments = path.split('/').map(segment => decodeURIComponent(segment));
+        if (method === 'GET' && path === 'status') {
+            const limits = { ...defaultLimits, ...this.scenario.limits };
+            return this.json(200, this.enabledState()
+                ? { enabled: true, agents: this.admin.chatAgents(), limits, canAdminister: this.admin.administers }
+                : { enabled: false, agents: [], limits, canAdminister: false });
+        }
+        if (!this.enabledState()) {
+            return this.empty(404);
+        }
+        if (method === 'GET' && path === 'agents') {
+            return this.json(200, this.admin.chatAgents());
+        }
+        if (path === 'preferences') {
+            return this.result(this.admin.handlePreferences(method, body));
+        }
+        if (segments[0] === 'admin') {
+            return this.result(this.admin.handleAdmin(method, segments, body));
+        }
+        if (segments[0] !== 'conversations') {
+            return this.empty(404);
+        }
+        if (segments.length === 1) {
+            if (method === 'GET') {
+                return this.json(200, this.list(query));
+            }
+            if (method === 'POST') {
+                return this.create(body);
+            }
+            return this.empty(405);
+        }
+        const conversation = this.conversations.get(segments[1]);
+        if (!conversation) {
+            return this.empty(404);
+        }
+        if (segments.length === 2) {
+            if (method === 'GET') {
+                return this.json(200, conversation);
+            }
+            if (method === 'DELETE') {
+                this.conversations.delete(conversation.id);
+                this.pendingApprovals.delete(conversation.id);
+                return this.empty(204);
+            }
+            return this.empty(405);
+        }
+        if (method === 'POST' && segments.length === 3 && segments[2] === 'messages') {
+            return this.sendMessage(conversation, body);
+        }
+        if (method === 'POST' && segments.length === 3 && segments[2] === 'cancel') {
+            return this.cancel(conversation);
+        }
+        if (method === 'POST' && segments.length === 5 && segments[2] === 'approvals' && segments[4] === 'decide') {
+            return this.decide(conversation, segments[3], body);
+        }
+        return this.empty(404);
+    }
+    list(query) {
+        const page = Math.max(1, Number(query.get('page') ?? 1));
+        const itemsPerPage = Math.max(1, Number(query.get('itemsPerPage') ?? 20));
+        const all = [...this.conversations.values()]
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
+            .map(({ id, agentId, title, status, createdAt, updatedAt }) => ({ id, agentId, title, status, createdAt, updatedAt }));
+        return { items: all.slice((page - 1) * itemsPerPage, page * itemsPerPage), total: all.length };
+    }
+    create(request) {
+        const agent = this.admin.chatAgents().find(item => item.id === request?.agentId);
+        if (!agent) {
+            return this.empty(400);
+        }
+        const now = new Date().toISOString();
+        const conversation = {
+            id: this.nextId(),
+            agentId: agent.id,
+            agentVersion: agent.version,
+            title: request.title ?? null,
+            status: 'idle',
+            createdAt: now,
+            updatedAt: now,
+            messages: [],
+            pendingApproval: null
+        };
+        this.conversations.set(conversation.id, conversation);
+        return this.json(201, conversation);
+    }
+    sendMessage(conversation, request) {
+        const text = request?.text?.trim() ?? '';
+        const limit = this.scenario.limits?.maxMessageChars ?? defaultLimits.maxMessageChars;
+        if (text.length === 0 || text.length > limit || !request.clientMessageId) {
+            return this.empty(400);
+        }
+        if (conversation.status !== 'idle') {
+            return this.empty(409);
+        }
+        // Like the server: an invalid page context is dropped, never a 400.
+        const pageContext = normalizeNhAssistantClientContext(request.clientContext);
+        this.pageContexts.set(conversation.id, pageContext);
+        const turn = this.findTurn(text, conversation.agentId, pageContext);
+        const userMessageId = this.nextId();
+        const assistantMessageId = this.nextId();
+        this.update(conversation.id, current => ({
+            ...current,
+            title: current.title ?? text.slice(0, 60),
+            status: 'running',
+            messages: [...current.messages, { id: userMessageId, role: 'user', createdAt: new Date().toISOString(), parts: [{ type: 'text', text }] }]
+        }));
+        return this.stream(conversation.id, async (emit) => {
+            await emit({ type: 'turn.started', data: { turnId: this.nextId(), userMessageId, assistantMessageId } });
+            await this.playSteps(conversation.id, assistantMessageId, turn?.steps ?? [], emit);
+        });
+    }
+    decide(conversation, approvalId, request) {
+        const pending = this.pendingApprovals.get(conversation.id);
+        if (!pending || pending.approval.approvalId !== approvalId) {
+            return this.empty(404);
+        }
+        if (request?.expectedProposalHash !== pending.approval.proposalHash) {
+            return this.empty(409);
+        }
+        if (Date.parse(pending.approval.expiresAt) <= Date.now()) {
+            return this.empty(409);
+        }
+        this.pendingApprovals.delete(conversation.id);
+        const decision = request.decision;
+        const lastUser = [...conversation.messages].reverse().find(message => message.role === 'user');
+        this.update(conversation.id, current => applyNhAssistantApprovalDecision(current, approvalId, decision));
+        return this.stream(conversation.id, async (emit) => {
+            await emit({
+                type: 'turn.started',
+                data: { turnId: this.nextId(), userMessageId: lastUser?.id ?? pending.assistantMessageId, assistantMessageId: pending.assistantMessageId }
+            });
+            if (decision === 'approve') {
+                await emit({
+                    type: 'tool.completed',
+                    data: { invocationId: pending.invocationId, status: 'succeeded', resultCode: null, resultPreview: pending.step.resultPreview ?? null }
+                });
+                await this.playSteps(conversation.id, pending.assistantMessageId, pending.step.approved, emit);
+            }
+            else {
+                await this.playSteps(conversation.id, pending.assistantMessageId, pending.step.rejected, emit);
+            }
+        });
+    }
+    cancel(conversation) {
+        const run = this.runs.get(conversation.id);
+        if (run) {
+            run.cancelled = true;
+            return this.empty(202);
+        }
+        const pending = this.pendingApprovals.get(conversation.id);
+        if (pending) {
+            this.pendingApprovals.delete(conversation.id);
+            this.update(conversation.id, current => ({
+                ...applyNhAssistantApprovalDecision(current, pending.approval.approvalId, 'reject'),
+                status: 'idle'
+            }));
+        }
+        return this.empty(202);
+    }
+    async playSteps(conversationId, assistantMessageId, steps, emit) {
+        const usage = { inputTokens: 180, outputTokens: 0, toolCalls: 0 };
+        const complete = (status, errorCode = null) => emit({ type: 'turn.completed', data: { turnId: this.nextId(), status, usage, errorCode } });
+        for (const step of steps) {
+            if ('text' in step) {
+                const text = typeof step.text === 'function' ? step.text(this.pageContexts.get(conversationId) ?? null) : step.text;
+                for (const piece of text.match(/\S+\s*|\s+/g) ?? []) {
+                    usage.outputTokens++;
+                    await emit({ type: 'message.delta', data: { messageId: assistantMessageId, text: piece } });
+                }
+            }
+            else if ('tool' in step) {
+                const invocationId = this.nextId();
+                usage.toolCalls++;
+                await emit({
+                    type: 'tool.started',
+                    data: {
+                        invocationId,
+                        toolId: step.tool.toolId,
+                        toolVersion: step.tool.toolVersion ?? 1,
+                        displayName: step.tool.displayName,
+                        argumentsPreview: step.tool.argumentsPreview ?? null
+                    }
+                });
+                await emit({
+                    type: 'tool.completed',
+                    data: {
+                        invocationId,
+                        status: step.tool.status ?? 'succeeded',
+                        resultCode: step.tool.resultCode ?? null,
+                        resultPreview: step.tool.resultPreview ?? null
+                    }
+                });
+            }
+            else if ('approval' in step) {
+                await this.pauseForApproval(conversationId, assistantMessageId, step.approval, emit);
+                usage.toolCalls++;
+                await emit({ type: 'turn.completed', data: { turnId: this.nextId(), status: 'waiting-for-approval', usage, errorCode: null } });
+                return;
+            }
+            else if ('error' in step) {
+                await emit({ type: 'error', data: step.error });
+                // The mock keeps the conversation usable after a failed turn.
+                this.update(conversationId, current => ({ ...current, status: 'idle' }));
+                return;
+            }
+            else if ('fail' in step) {
+                await complete('failed', step.fail.errorCode);
+                return;
+            }
+        }
+        await complete('completed');
+    }
+    async pauseForApproval(conversationId, assistantMessageId, step, emit) {
+        const invocationId = this.nextId();
+        await emit({
+            type: 'tool.started',
+            data: {
+                invocationId,
+                toolId: step.toolId,
+                toolVersion: step.toolVersion ?? 1,
+                displayName: step.displayName,
+                argumentsPreview: step.argumentsPreview
+            }
+        });
+        const approval = {
+            type: 'approval',
+            approvalId: this.nextId(),
+            proposalId: this.nextId(),
+            proposalHash: `sha256:${this.nextId().replace(/-/g, '')}`,
+            toolId: step.toolId,
+            summary: step.summary,
+            argumentsPreview: step.argumentsPreview,
+            targets: step.targets,
+            expiresAt: new Date(Date.now() + (step.expiresInSeconds ?? 300) * 1000).toISOString(),
+            status: 'pending'
+        };
+        this.pendingApprovals.set(conversationId, { approval, invocationId, assistantMessageId, step });
+        await emit({ type: 'approval.required', data: approval });
+    }
+    stream(conversationId, play) {
+        const timing = this.scenario.timing ?? {};
+        const firstDelay = timing.firstEventDelayMs ?? 200;
+        const eventDelay = timing.eventDelayMs ?? 40;
+        const chunkSize = Math.max(1, timing.chunkSize ?? 23);
+        const encoder = new TextEncoder();
+        const run = { cancelled: false, aborted: false };
+        this.runs.set(conversationId, run);
+        let first = true;
+        let eventCount = 0;
+        return new Response(new ReadableStream({
+            start: controller => {
+                const write = (text) => {
+                    const bytes = encoder.encode(text);
+                    for (let offset = 0; offset < bytes.length; offset += chunkSize) {
+                        controller.enqueue(bytes.slice(offset, offset + chunkSize));
+                    }
+                };
+                const emit = async (event) => {
+                    await delay(first ? firstDelay : eventDelay);
+                    first = false;
+                    if (run.aborted) {
+                        throw new RunStopped();
+                    }
+                    if (run.cancelled && event.type !== 'turn.started') {
+                        throw new RunStopped();
+                    }
+                    this.update(conversationId, current => applyNhAssistantEvent(current, event));
+                    if (eventCount++ % 5 === 2) {
+                        write(': keep-alive\n\n');
+                    }
+                    write(`event: ${event.type}\ndata: ${JSON.stringify(event.data)}\n\n`);
+                };
+                void play(emit)
+                    .catch(async (error) => {
+                    if (!(error instanceof RunStopped) || run.aborted) {
+                        return;
+                    }
+                    const usage = { inputTokens: 180, outputTokens: 0, toolCalls: 0 };
+                    const cancelled = { type: 'turn.completed', data: { turnId: this.nextId(), status: 'cancelled', usage, errorCode: null } };
+                    this.update(conversationId, current => applyNhAssistantEvent(current, cancelled));
+                    write(`event: ${cancelled.type}\ndata: ${JSON.stringify(cancelled.data)}\n\n`);
+                })
+                    .finally(() => {
+                    if (this.runs.get(conversationId) === run) {
+                        this.runs.delete(conversationId);
+                    }
+                    if (!run.aborted) {
+                        controller.close();
+                    }
+                });
+            },
+            cancel: () => {
+                run.aborted = true;
+            }
+        }), { status: 200, headers: { 'content-type': 'text/event-stream; charset=utf-8', 'cache-control': 'no-cache' } });
+    }
+    findTurn(text, agentId, pageContext) {
+        return this.scenario.turns.find(turn => {
+            const match = turn.match;
+            if (match === undefined) {
+                return true;
+            }
+            if (typeof match === 'string') {
+                return text.toLowerCase().includes(match.toLowerCase());
+            }
+            if (match instanceof RegExp) {
+                return match.test(text);
+            }
+            return match(text, agentId, pageContext);
+        });
+    }
+    update(conversationId, change) {
+        const conversation = this.conversations.get(conversationId);
+        if (conversation) {
+            this.conversations.set(conversationId, { ...change(conversation), updatedAt: new Date().toISOString() });
+        }
+    }
+    nextId() {
+        this.sequence++;
+        const suffix = this.sequence.toString(16).padStart(12, '0');
+        return `00000000-0000-4000-8000-${suffix}`;
+    }
+    result(result) {
+        return result.body === undefined ? this.empty(result.status) : this.json(result.status, result.body);
+    }
+    json(status, value) {
+        return new Response(JSON.stringify(value), { status, headers: { 'content-type': 'application/json' } });
+    }
+    empty(status) {
+        return new Response(null, { status });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: NhAssistantMockBackend, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: NhAssistantMockBackend }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: NhAssistantMockBackend, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+function delay(milliseconds) {
+    return new Promise(resolve => setTimeout(resolve, milliseconds));
+}
+
+/**
+ * Replaces the assistant transport with an in-memory back-end that plays `script`.
+ * Register it after `provideNhAssistant(...)` in the same injector. Every client feature
+ * (status, agents, conversations, streamed turns, approvals, cancellation) then works
+ * without a server. Inject `NhAssistantMockBackend` to switch the feature flag or to
+ * inspect the received requests.
+ */
+function provideNhAssistantMockApi(script) {
+    return makeEnvironmentProviders([
+        { provide: NH_ASSISTANT_MOCK_SCENARIO, useValue: script },
+        NhAssistantMockBackend,
+        { provide: NH_ASSISTANT_FETCH, useFactory: () => inject(NhAssistantMockBackend).fetch }
+    ]);
+}
+
+/*
+ * Public API surface of @newheap/platform-ai-chat/testing.
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { NH_ASSISTANT_MOCK_SCENARIO, NhAssistantMockBackend, provideNhAssistantMockApi };
+//# sourceMappingURL=newheap-platform-ai-chat-testing.mjs.map