@c8y/ngx-components 1024.20.1 → 1024.21.3

package/fesm2022/c8y-ngx-components-ai.mjs

@@ -5,6 +5,143 @@ import { FetchClient } from '@c8y/client';
 import { Observable } from 'rxjs';
 import { gettext } from '@c8y/ngx-components/gettext';
 
+function convertToolOutputToAgentFormat(tool) {
+    const { output, outputType, error } = tool;
+    // Content arrays need outputType="content" for roundtripping (set by convertStreamingToolOutputToToolCallPart)
+    if (outputType === 'content' && Array.isArray(output)) {
+        return { type: 'content', value: output };
+    }
+    if (error) {
+        return typeof output === 'string'
+            ? { type: 'error-text', value: output }
+            : { type: 'error-json', value: output ?? null };
+    }
+    if (typeof output === 'string') {
+        return { type: 'text', value: output };
+    }
+    if (output == null) {
+        return { type: 'text', value: '' };
+    }
+    return { type: 'json', value: output };
+}
+/** Builds the `tool-call` content part for a tool call or a tool call awaiting/holding an approval decision. */
+function toToolCallContent(part) {
+    return {
+        type: 'tool-call',
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        input: part.input ?? {} // must be a dict
+    };
+}
+/**
+ * Resolves the outcome to record beside a decided tool-approval exchange: the refusal itself when
+ * the user said no, or the result of the call it authorised. Returns `undefined` when the call was
+ * approved but has not produced a result yet.
+ *
+ * @param part The approval part; `part.approval.approved` must already be defined.
+ * @param resultsByToolCallId Completed tool results indexed by call id. The result of an approved
+ *   call usually streams in with a later message, but may also live on `part` itself already, when
+ *   the conversation being converted was itself restored from storage.
+ * @param convertOutput Converts a completed tool call's recorded output into the wire format.
+ */
+function resolveApprovalOutcome(part, resultsByToolCallId, convertOutput) {
+    if (!part.approval?.approved) {
+        return {
+            type: 'tool-result',
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            output: {
+                type: 'execution-denied',
+                ...(part.approval?.reason ? { reason: part.approval.reason } : {})
+            }
+        };
+    }
+    const result = resultsByToolCallId.get(part.toolCallId) ?? (part.output !== undefined ? part : undefined);
+    // No result anywhere means the call was approved but has not run yet.
+    return result
+        ? {
+            type: 'tool-result',
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            output: convertOutput(result)
+        }
+        : undefined;
+}
+/**
+ * Splits an assistant message's content into per-step groups at `step-start` boundaries.
+ * Parts before the first `step-start` are placed in an implicit first step, and empty groups
+ * (from leading, consecutive or trailing `step-start` parts) are dropped.
+ *
+ * Each step has to become its own message in the wire format, which has no `step-start` part:
+ * this ensures text from a later step is never placed after tool calls from an earlier step,
+ * which some AI providers forbid.
+ */
+function splitIntoSteps(content) {
+    const steps = [[]];
+    for (const part of content) {
+        if (part.type === 'step-start') {
+            if (steps[steps.length - 1].length > 0)
+                steps.push([]);
+        }
+        else {
+            steps[steps.length - 1].push(part);
+        }
+    }
+    if (steps[steps.length - 1].length === 0)
+        steps.pop();
+    return steps;
+}
+/**
+ * Converts from our UI-friendly message format back to the format the API requires when
+ * sending message history back to the agent manager service.
+ *
+ * Currently the format is Vercel v6 ModelMessage (so this is a little similar to Vercel's convertToModelMessages).
+ *
+ * We do not bother with details such as reasoning (not worth the tokens) or in-progress tool calls
+ * (since this method is only used on completed responses).
+ */
+function convertToAgentMessageFormat(messages) {
+    return messages.flatMap(message => {
+        if (message.role === 'user' || message.role === 'system') {
+            return [{ role: message.role, content: message.content }];
+        }
+        // Each step maps to its own assistant message + optional tool message.
+        const steps = splitIntoSteps(message.content);
+        const stepMessages = [];
+        for (const stepParts of steps) {
+            const stepAssistantContent = [];
+            const stepToolResultContent = [];
+            for (const part of stepParts) {
+                if (part.type === 'text' && part.text) {
+                    stepAssistantContent.push({ type: 'text', text: part.text });
+                }
+                else if (part.type === 'tool-result') {
+                    stepAssistantContent.push({
+                        type: 'tool-call',
+                        toolCallId: part.toolCallId,
+                        toolName: part.toolName,
+                        input: !part.input ? {} : part.input // must be a dict
+                    });
+                    stepToolResultContent.push({
+                        type: 'tool-result',
+                        toolCallId: part.toolCallId,
+                        toolName: part.toolName,
+                        output: convertToolOutputToAgentFormat(part)
+                    });
+                }
+                // Reasoning, tool-input-streaming and tool-executing (in-progress calls) are intentionally skipped
+            }
+            if (stepAssistantContent.length > 0) {
+                stepMessages.push({ role: 'assistant', content: stepAssistantContent });
+            }
+            if (stepToolResultContent.length > 0) {
+                stepMessages.push({ role: 'tool', content: stepToolResultContent });
+            }
+        }
+        return stepMessages;
+    });
+}
+
 // Internal implementation detail; maybe we don't even need this enum since
 var DataStreamType;
 (function (DataStreamType) {
@@ -305,7 +442,10 @@ class AIService {
             if (m.role !== 'assistant')
                 continue;
             for (const part of m.content) {
-                if (part.type === 'tool-result') {
+                // A conversation restored from storage carries the result on the approval part itself,
+                // rather than in the following message where it originally streamed in.
+                if (part.type === 'tool-result' ||
+                    (part.type === 'tool-approval-responded' && part.output !== undefined)) {
                     resultsByToolCallId.set(part.toolCallId, part);
                 }
             }
@@ -373,12 +513,7 @@ class AIService {
                 case 'tool-approval-responded':
                     if (!part.approval)
                         break;
-                    assistantContent.push({
-                        type: 'tool-call',
-                        toolCallId: part.toolCallId,
-                        toolName: part.toolName,
-                        input: part.input ?? {}
-                    });
+                    assistantContent.push(toToolCallContent(part));
                     assistantContent.push({
                         type: 'tool-approval-request',
                         approvalId: part.approval.approvalId,
@@ -392,32 +527,13 @@ class AIService {
                             ...(part.approval.reason ? { reason: part.approval.reason } : {})
                         });
                         if (!serializedToolCallIds.has(part.toolCallId)) {
-                            if (!part.approval.approved) {
-                                toolContent.push({
-                                    type: 'tool-result',
-                                    toolCallId: part.toolCallId,
-                                    toolName: part.toolName,
-                                    output: {
-                                        type: 'execution-denied',
-                                        ...(part.approval.reason ? { reason: part.approval.reason } : {})
-                                    }
-                                });
+                            // No outcome means the call was approved but has not run yet: this approval is the
+                            // one triggering the resume, and the agent executes the tool itself.
+                            const outcome = resolveApprovalOutcome(part, resultsByToolCallId, result => this.convertToolResultOutputForAgent(result));
+                            if (outcome) {
+                                toolContent.push(outcome);
                                 serializedToolCallIds.add(part.toolCallId);
                             }
-                            else {
-                                const result = resultsByToolCallId.get(part.toolCallId);
-                                if (result) {
-                                    toolContent.push({
-                                        type: 'tool-result',
-                                        toolCallId: part.toolCallId,
-                                        toolName: part.toolName,
-                                        output: this.convertToolResultOutputForAgent(result)
-                                    });
-                                    serializedToolCallIds.add(part.toolCallId);
-                                }
-                                // No result yet: this approval is the one triggering the resume,
-                                // and the agent executes the tool itself.
-                            }
                         }
                     }
                     break;
@@ -425,12 +541,7 @@ class AIService {
                     // Skip results already serialized next to their approval exchange in an earlier message
                     if (serializedToolCallIds.has(part.toolCallId))
                         break;
-                    assistantContent.push({
-                        type: 'tool-call',
-                        toolCallId: part.toolCallId,
-                        toolName: part.toolName,
-                        input: part.input ?? {}
-                    });
+                    assistantContent.push(toToolCallContent(part));
                     toolContent.push({
                         type: 'tool-result',
                         toolCallId: part.toolCallId,
@@ -666,22 +777,10 @@ function defaultPruneMessagesForAgent(messages) {
     // Tool calls that went through an approval exchange must keep their results as well:
     // the wire format pairs each resolved approval with its result, so pruning the result
     // would leave the approved tool call dangling in the prompt sent to the model.
-    const approvalToolCallIds = new Set();
-    for (const m of messages) {
-        if (m.role !== 'assistant')
-            continue;
-        for (const part of m.content) {
-            if (part.type === 'tool-approval-requested' || part.type === 'tool-approval-responded') {
-                approvalToolCallIds.add(part.toolCallId);
-            }
-        }
-    }
+    const approvalToolCallIds = collectApprovalToolCallIds(messages);
     return messages.map(m => {
         if (m.role !== 'assistant') {
-            return {
-                role: m.role,
-                content: m.content
-            };
+            return { role: m.role, content: m.content };
         }
         const textParts = m.content.filter((part) => part.type === 'text');
         const objectParts = m.content.filter((part) => part.type === 'object');
@@ -691,22 +790,364 @@ function defaultPruneMessagesForAgent(messages) {
             part.type === 'tool-approval-responded' ||
             (part.type === 'tool-result' && approvalToolCallIds.has(part.toolCallId)));
         const content = [];
-        // Only add text part if there are text parts
         if (textParts.length > 0) {
-            content.push({
-                type: 'text',
-                text: textParts.map(part => part.text).join('\n\n')
-            });
+            content.push({ type: 'text', text: textParts.map(part => part.text).join('\n\n') });
         }
-        // Preserve object parts for object agents
         content.push(...objectParts);
         content.push(...approvalParts);
-        return {
-            role: m.role,
-            content
-        };
+        return { role: m.role, content };
+    });
+}
+/**
+ * The default implementation for preparing messages for conversation persistence.
+ *
+ * Unlike `defaultPruneMessagesForAgent` (which strips tool calls for token efficiency),
+ * this preserves tool call history so stored conversations can be fully restored in the UI.
+ *
+ * Strips only transient streaming states that should never be persisted:
+ * reasoning blocks, in-progress tool-input-streaming, and tool-executing parts.
+ *
+ * Tool outputs longer than 10,000 characters are truncated, as the storage service rejects
+ * conversations of about 1 MB and above. `defaultPruneMessagesForAgent` never sends these outputs
+ * back to the agent, so the truncation only shows in the UI once the conversation is reopened.
+ * The results of tool calls that went through an approval are the exception: the agent does get
+ * them back, so they are kept whole for a reopened conversation to send it the same history.
+ *
+ * Step boundaries are kept because `toConversationMessages`, which converts the result into the
+ * format the storage service accepts, needs them to split a multi-step turn into one message per step.
+ *
+ * Implements `pruneMessagesFunction`.
+ */
+function defaultPruneMessagesForPersistence(messages) {
+    const approvalToolCallIds = collectApprovalToolCallIds(messages);
+    return messages.map(m => {
+        if (m.role !== 'assistant') {
+            return m;
+        }
+        const content = m.content
+            .filter(part => part.type === 'step-start' ||
+            part.type === 'text' ||
+            part.type === 'tool-result' ||
+            part.type === 'object' ||
+            // Approval parts carry the user's decision on a tool call, including a refusal, which is
+            // the only record that the call was attempted at all.
+            part.type === 'tool-approval-requested' ||
+            part.type === 'tool-approval-responded')
+            .map(part => part.type === 'tool-result' && !approvalToolCallIds.has(part.toolCallId)
+            ? truncateToolOutput(part)
+            : part);
+        return { ...m, content };
     });
 }
+const MAX_PERSISTED_TOOL_OUTPUT_LENGTH = 10_000;
+/** Matches the note `truncateToolOutput` appends to the outputs it cuts. */
+const TRUNCATED_OUTPUT_PATTERN = /… \[truncated to \d+ of \d+ characters\]$/;
+/**
+ * Cuts a tool output longer than `MAX_PERSISTED_TOOL_OUTPUT_LENGTH` characters (of its JSON form,
+ * for a structured output) down to that length. The cut no longer parses, so it is kept as text.
+ */
+function truncateToolOutput(part) {
+    const serialized = typeof part.output === 'string' ? part.output : JSON.stringify(part.output);
+    if (!serialized || serialized.length <= MAX_PERSISTED_TOOL_OUTPUT_LENGTH) {
+        return part;
+    }
+    // Cut when the conversation was saved before, so it already notes the original size, which
+    // cutting it again would replace with the size of the cut.
+    if (typeof part.output === 'string' && TRUNCATED_OUTPUT_PATTERN.test(part.output)) {
+        return part;
+    }
+    return {
+        ...part,
+        output: `${serialized.slice(0, MAX_PERSISTED_TOOL_OUTPUT_LENGTH)}… [truncated to ${MAX_PERSISTED_TOOL_OUTPUT_LENGTH} of ${serialized.length} characters]`,
+        outputType: undefined
+    };
+}
+/** Collects the ids of the tool calls that went through an approval exchange. */
+function collectApprovalToolCallIds(messages) {
+    const ids = new Set();
+    for (const m of messages) {
+        if (m.role !== 'assistant')
+            continue;
+        for (const part of m.content) {
+            if (part.type === 'tool-approval-requested' || part.type === 'tool-approval-responded') {
+                ids.add(part.toolCallId);
+            }
+        }
+    }
+    return ids;
+}
+
+/**
+ * Converts chat messages into the format accepted by the conversation storage API.
+ *
+ * Unlike the history sent to the agent, tool calls are preserved so a stored conversation can be
+ * restored with its full transcript by `fromConversationMessages`. Note that:
+ * - each step of a multi-step assistant turn becomes its own message, since the wire format has no
+ *   `step-start` part — `fromConversationMessages` rebuilds the boundaries from the message split;
+ * - a tool call that required approval keeps its full exchange: the `tool-approval-request` beside
+ *   the call, and the user's `tool-approval-response` beside the outcome, which for a refused call
+ *   is an `execution-denied` result;
+ * - the agent that produced an assistant turn is recorded on every assistant message of that turn,
+ *   so it survives pruning of individual steps;
+ * - `object` parts are stored as text, as the wire format has no structured-object equivalent;
+ * - `system` messages are dropped, as the service rejects them: a conversation's system prompt
+ *   comes from the agent's server-side configuration, never from stored history;
+ * - reasoning and in-progress tool calls are dropped, as they are not worth persisting.
+ *
+ * @param messages The chat messages to store, typically already pruned for persistence.
+ */
+function toConversationMessages(messages) {
+    // The result of an approved tool call streams in with a later assistant message, but on the wire
+    // it has to sit beside its approval exchange, so index every result up front.
+    const resultsByToolCallId = new Map();
+    for (const message of messages) {
+        if (message.role !== 'assistant')
+            continue;
+        for (const part of message.content) {
+            if (part.type === 'tool-result')
+                resultsByToolCallId.set(part.toolCallId, part);
+        }
+    }
+    // Tracks calls already written beside their approval, so the copy carried by a later message is
+    // not written a second time.
+    const serializedToolCallIds = new Set();
+    return messages.flatMap(message => {
+        if (message.role === 'system') {
+            return [];
+        }
+        if (message.role === 'user') {
+            return [withDisplayMetadata({ role: 'user', content: message.content }, message)];
+        }
+        const stored = [];
+        for (const stepParts of splitIntoSteps(message.content)) {
+            stored.push(...buildStepMessages(stepParts, resultsByToolCallId, serializedToolCallIds));
+        }
+        if (stored.length > 0) {
+            stored[0] = withDisplayMetadata(stored[0], message);
+        }
+        return message.agentName
+            ? stored.map(m => (m.role === 'assistant' ? { ...m, agentName: message.agentName } : m))
+            : stored;
+    });
+}
+/**
+ * Converts one step's parts into the `assistant` message it maps to, paired with a `tool` message
+ * when the step carries tool results or approval decisions.
+ *
+ * @param resultsByToolCallId Completed tool results indexed by call id, so an approved call's result
+ *   (which streams in with a later message) can be matched to the approval it belongs beside.
+ * @param serializedToolCallIds Tracks calls already written beside their approval, so the copy
+ *   carried by a later message is not written a second time.
+ */
+function buildStepMessages(stepParts, resultsByToolCallId, serializedToolCallIds) {
+    const assistantContent = [];
+    const toolContent = [];
+    for (const part of stepParts) {
+        if (part.type === 'text' && part.text) {
+            assistantContent.push({ type: 'text', text: part.text });
+        }
+        else if (part.type === 'object') {
+            assistantContent.push({ type: 'text', text: part.jsonContent });
+        }
+        else if (part.type === 'tool-approval-requested' || part.type === 'tool-approval-responded') {
+            if (!part.approval)
+                continue;
+            assistantContent.push(toToolCallContent(part));
+            assistantContent.push({
+                type: 'tool-approval-request',
+                approvalId: part.approval.approvalId,
+                toolCallId: part.toolCallId
+            });
+            // An undecided approval is stored as the pending request alone.
+            if (part.approval.approved === undefined)
+                continue;
+            toolContent.push({
+                type: 'tool-approval-response',
+                approvalId: part.approval.approvalId,
+                approved: part.approval.approved,
+                ...(part.approval.reason ? { reason: part.approval.reason } : {})
+            });
+            if (serializedToolCallIds.has(part.toolCallId))
+                continue;
+            const outcome = resolveApprovalOutcome(part, resultsByToolCallId, convertToolOutputToAgentFormat);
+            if (outcome) {
+                toolContent.push(outcome);
+                serializedToolCallIds.add(part.toolCallId);
+            }
+        }
+        else if (part.type === 'tool-result') {
+            if (serializedToolCallIds.has(part.toolCallId))
+                continue;
+            assistantContent.push(toToolCallContent(part));
+            toolContent.push({
+                type: 'tool-result',
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                output: convertToolOutputToAgentFormat(part)
+            });
+        }
+    }
+    const stepMessages = [];
+    if (assistantContent.length > 0) {
+        stepMessages.push({ role: 'assistant', content: assistantContent });
+    }
+    if (toolContent.length > 0) {
+        stepMessages.push({ role: 'tool', content: toolContent });
+    }
+    return stepMessages;
+}
+/**
+ * Restores stored messages into the format the chat renders, inverting `toConversationMessages`.
+ *
+ * The consecutive assistant and tool messages that one assistant turn was split into are merged
+ * back into a single message, with a `step-start` part marking each boundary, and each tool call
+ * is reunited with its result and, where it needed one, with the user's approval decision.
+ *
+ * A restored approved call carries its result on the approval part itself, rather than in the
+ * following message where it originally streamed in. The chat renders that identically, and a
+ * restored decision is never re-actionable: the approval buttons only appear on the latest message.
+ *
+ * Note that the wire format marks where a step ended but not where a turn did, so assistant
+ * messages that followed one another without the user speaking in between — an approval and the
+ * response resumed from it, for example — come back merged into a single turn. Every part and its
+ * order is preserved; only the split into separate messages is not. The merged turn carries the
+ * sum of their token usage and the timestamp of the last one. Messages recorded as coming from
+ * different agents are never merged.
+ *
+ * @param messages The messages of a stored conversation.
+ */
+function fromConversationMessages(messages) {
+    const restored = [];
+    // The assistant turn currently being rebuilt, or undefined when the last message was not one.
+    let turn;
+    for (const message of messages) {
+        if (message.role === 'tool') {
+            for (const part of message.content) {
+                if (part.type === 'tool-approval-response') {
+                    applyApprovalResponse(turn, part);
+                }
+                else {
+                    applyToolResult(turn, part);
+                }
+            }
+        }
+        else if (message.role === 'assistant') {
+            // A different agent answering starts a new turn, even without the user speaking in between.
+            const agentChanged = !!turn?.agentName && !!message.agentName && turn.agentName !== message.agentName;
+            if (!turn || agentChanged) {
+                turn = {
+                    role: 'assistant',
+                    content: [],
+                    ...(message.timestamp ? { timestamp: message.timestamp } : {}),
+                    ...(message.usage ? { usage: message.usage } : {}),
+                    ...(message.agentName ? { agentName: message.agentName } : {})
+                };
+                restored.push(turn);
+            }
+            else {
+                if (!turn.agentName && message.agentName)
+                    turn.agentName = message.agentName;
+                // Only the first stored message of a chat message carries its metadata, so a later one with
+                // it was a separate chat message, such as the response resumed after a tool approval.
+                if (message.usage)
+                    turn.usage = addUsage(turn.usage, message.usage);
+                if (message.timestamp)
+                    turn.timestamp = message.timestamp;
+                turn.content.push({ type: 'step-start' });
+            }
+            // Another client may store an assistant message as plain text, which the wire format allows.
+            const content = typeof message.content === 'string'
+                ? [{ type: 'text', text: message.content }]
+                : message.content;
+            for (const part of content) {
+                if (part.type === 'text') {
+                    turn.content.push({ type: 'text', text: part.text });
+                }
+                else if (part.type === 'tool-call') {
+                    // Stored as a completed call: its output is filled in from the tool message that follows.
+                    turn.content.push({
+                        type: 'tool-result',
+                        toolName: part.toolName,
+                        toolCallId: part.toolCallId,
+                        input: part.input
+                    });
+                }
+                else if (part.type === 'tool-approval-request') {
+                    const call = findToolCall(turn, part.toolCallId);
+                    if (call) {
+                        call.type = 'tool-approval-requested';
+                        call.approval = { approvalId: part.approvalId };
+                    }
+                }
+            }
+        }
+        else {
+            turn = undefined;
+            restored.push({
+                role: message.role,
+                content: message.content,
+                ...(message.timestamp ? { timestamp: message.timestamp } : {})
+            });
+        }
+    }
+    return restored;
+}
+function withDisplayMetadata(stored, source) {
+    return {
+        ...stored,
+        ...(source.timestamp ? { timestamp: source.timestamp } : {}),
+        ...(source.role === 'assistant' && source.usage ? { usage: source.usage } : {})
+    };
+}
+function addUsage(total, usage) {
+    if (!total)
+        return usage;
+    return {
+        inputTokens: (total.inputTokens ?? 0) + (usage.inputTokens ?? 0),
+        outputTokens: (total.outputTokens ?? 0) + (usage.outputTokens ?? 0),
+        totalTokens: (total.totalTokens ?? 0) + (usage.totalTokens ?? 0)
+    };
+}
+function findToolCall(turn, toolCallId) {
+    return turn?.content.find((candidate) => 'toolCallId' in candidate && candidate.toolCallId === toolCallId);
+}
+function applyApprovalResponse(turn, part) {
+    const call = turn?.content.find((candidate) => 'approval' in candidate && candidate.approval?.approvalId === part.approvalId);
+    if (!call) {
+        return;
+    }
+    call.type = 'tool-approval-responded';
+    call.approval = {
+        approvalId: part.approvalId,
+        approved: part.approved,
+        ...(part.reason ? { reason: part.reason } : {})
+    };
+}
+function applyToolResult(turn, part) {
+    const call = findToolCall(turn, part.toolCallId);
+    if (!call) {
+        return;
+    }
+    const output = part.output;
+    switch (part.output.type) {
+        case 'execution-denied':
+            // A refused call never ran, so it has no output — the decision itself is on the approval part.
+            break;
+        case 'content':
+            call.output = output.value;
+            // Marks the output as a multi-part content array so it can be sent back to the agent as one.
+            call.outputType = 'content';
+            break;
+        case 'error-text':
+        case 'error-json':
+            call.output = output.value;
+            call.error = true;
+            break;
+        default:
+            // text and json outputs both restore to the plain value the UI renders.
+            call.output = output.value;
+    }
+}
 
 /**
  * Remembers the user's "always approve" decisions for tool calls that require human approval.
@@ -852,5 +1293,5 @@ function summarizeQuery(query, translateService) {
  * Generated bundle index. Do not edit.
  */
 
-export { AIService, AiToolApprovalMemoryService, DataStreamType, cumulocityApiRequestLabelProvider, defaultPruneMessagesForAgent };
+export { AIService, AiToolApprovalMemoryService, DataStreamType, cumulocityApiRequestLabelProvider, defaultPruneMessagesForAgent, defaultPruneMessagesForPersistence, fromConversationMessages, toConversationMessages };
 //# sourceMappingURL=c8y-ngx-components-ai.mjs.map