@c8y/ngx-components 1024.15.16 → 1024.16.6

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

@@ -15,13 +15,13 @@ var DataStreamType;
     DataStreamType["TOOL_CALL_STREAMING"] = "tool-call-streaming";
     DataStreamType["TOOL_CALL_DELTA"] = "tool-call-delta";
     DataStreamType["TOOL_RESULT"] = "tool-result";
+    DataStreamType["TOOL_APPROVAL_REQUEST"] = "tool-approval-request";
     DataStreamType["REASONING"] = "reasoning";
     DataStreamType["REASONING_DELTA"] = "reasoning-delta";
     DataStreamType["REDACTED_REASONING"] = "redacted-reasoning";
     DataStreamType["REASONING_SIGNATURE"] = "reasoning-signature";
     DataStreamType["FINISH_REASONING"] = "finish-reasoning";
     DataStreamType["FINISH"] = "finish";
-    DataStreamType["FINISH_STEP"] = "finish-step";
     DataStreamType["ERROR"] = "error";
     DataStreamType["DATA"] = "data";
     DataStreamType["MESSAGE_ANNOTATIONS"] = "message-annotations";
@@ -57,7 +57,8 @@ class AIService {
             headers: { 'Content-Type': 'application/json' }
         });
         if (!response.ok) {
-            throw new Error(`Failed to create agent: ${response.statusText}`);
+            const detail = await response.text().catch(() => '');
+            throw new Error(`Failed to create agent: ${response.statusText}${detail ? ` - ${detail}` : ''}`);
         }
     }
     /**
@@ -294,32 +295,174 @@ class AIService {
         // We will need to rewrite this to include tool outputs soon (effectively this means targetting LanguageModelV*ToolResultOutput).
         // Once we have more fields than just role and content, we will need to convert between our format and
         // the Vercel format expected by the agent manager (e.g. steps->content parts)
-        return messages.map(m => {
+        // The result of an approved tool call streams in with the NEXT assistant message after the
+        // resume, but on the wire it must sit next to its approval exchange (the agent strips
+        // approval parts from the model prompt, so an exchange without a result leaves a dangling
+        // tool call the model provider rejects). Index all results up front so
+        // convertAssistantMessageWithApprovals can pull them into the right message.
+        const resultsByToolCallId = new Map();
+        for (const m of messages) {
+            if (m.role !== 'assistant')
+                continue;
+            for (const part of m.content) {
+                if (part.type === 'tool-result') {
+                    resultsByToolCallId.set(part.toolCallId, part);
+                }
+            }
+        }
+        const serializedToolCallIds = new Set();
+        return messages.flatMap(m => {
             if (m.role !== 'assistant') {
-                return {
-                    role: m.role,
-                    content: m.content
-                };
+                return [
+                    {
+                        role: m.role,
+                        content: m.content
+                    }
+                ];
             }
             // For assistant messages, check if there's an object part
             const objectPart = m.content.find((part) => part.type === 'object');
             if (objectPart) {
                 // If there's an object part, parse and send the JSON object as content
-                return {
-                    role: m.role,
-                    content: objectPart.jsonContent
-                };
+                return [
+                    {
+                        role: m.role,
+                        content: objectPart.jsonContent
+                    }
+                ];
+            }
+            // Messages containing tool approvals must round-trip with full fidelity so the agent
+            // can match the user's decision to the pending tool call.
+            if (m.content.some(part => part.type === 'tool-approval-requested' || part.type === 'tool-approval-responded')) {
+                return this.convertAssistantMessageWithApprovals(m, resultsByToolCallId, serializedToolCallIds);
             }
             // Otherwise, send text parts as joined string
-            return {
-                role: m.role,
-                content: m.content
-                    .filter((part) => part.type === 'text')
-                    .map(part => part.text)
-                    .join('\n\n')
-            };
+            return [
+                {
+                    role: m.role,
+                    content: m.content
+                        .filter((part) => part.type === 'text')
+                        .map(part => part.text)
+                        .join('\n\n')
+                }
+            ];
         });
     }
+    /**
+     * Converts an assistant message containing tool approval parts into the wire format expected by
+     * the agent: an assistant message carrying `tool-call` and `tool-approval-request` parts, followed
+     * (once the user has decided) by a `tool` role message carrying the matching `tool-approval-response`
+     * parts.
+     *
+     * The agent strips approval parts from the prompt it sends to the model provider, so a *resolved*
+     * exchange must also carry the call's outcome in its tool message: the executed result (found via
+     * `resultsByToolCallId`, since it streams in with the following assistant message) or an
+     * `execution-denied` marker. Each such result is serialized exactly once - `serializedToolCallIds`
+     * tracks consumed calls so the copy stored in the following message is not emitted again as a
+     * duplicate tool call.
+     */
+    convertAssistantMessageWithApprovals(m, resultsByToolCallId, serializedToolCallIds) {
+        const assistantContent = [];
+        const toolContent = [];
+        for (const part of m.content) {
+            switch (part.type) {
+                case 'text':
+                    assistantContent.push({ type: 'text', text: part.text });
+                    break;
+                case 'tool-approval-requested':
+                case 'tool-approval-responded':
+                    if (!part.approval)
+                        break;
+                    assistantContent.push({
+                        type: 'tool-call',
+                        toolCallId: part.toolCallId,
+                        toolName: part.toolName,
+                        input: part.input ?? {}
+                    });
+                    assistantContent.push({
+                        type: 'tool-approval-request',
+                        approvalId: part.approval.approvalId,
+                        toolCallId: part.toolCallId
+                    });
+                    if (part.approval.approved !== undefined) {
+                        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)) {
+                            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 } : {})
+                                    }
+                                });
+                                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;
+                case 'tool-result':
+                    // 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 ?? {}
+                    });
+                    toolContent.push({
+                        type: 'tool-result',
+                        toolCallId: part.toolCallId,
+                        toolName: part.toolName,
+                        output: this.convertToolResultOutputForAgent(part)
+                    });
+                    break;
+                default:
+                    // reasoning and step-start parts are not needed by the agent
+                    break;
+            }
+        }
+        const result = [{ role: 'assistant', content: assistantContent }];
+        if (toolContent.length > 0) {
+            result.push({ role: 'tool', content: toolContent });
+        }
+        return result;
+    }
+    /** Converts a tool output stored in our format back to the LanguageModelV*ToolResultOutput wire format. */
+    convertToolResultOutputForAgent(part) {
+        if (part.outputType === 'content') {
+            return { type: 'content', value: part.output };
+        }
+        if (part.error) {
+            return typeof part.output === 'string'
+                ? { type: 'error-text', value: part.output }
+                : { type: 'error-json', value: part.output ?? null };
+        }
+        return typeof part.output === 'string'
+            ? { type: 'text', value: part.output }
+            : { type: 'json', value: part.output ?? null };
+    }
     /**
      * Convert a tool output from the MCP/wire format (which is different/more compact than LanguageModelV3ToolResultOutput)
      * into our own standard representation, which can be roundtripped to the format we need to provide when making future requests.
@@ -464,6 +607,14 @@ class AIService {
                         changedPart: this.addToolCallInfo('tool-result', data, message.content)
                     });
                     return;
+                case DataStreamType.TOOL_APPROVAL_REQUEST: {
+                    // Emitted when a tool with `needsApproval` is called; the agent stops until the
+                    // conversation is resent with the user's decision (see convertAssistantMessageWithApprovals).
+                    const approvalPart = this.addToolCallInfo('tool-approval-requested', data.toolCall || data, message.content);
+                    approvalPart.approval = { approvalId: data.approvalId };
+                    observer.next({ message, changedPart: approvalPart });
+                    return;
+                }
                 case DataStreamType.FINISH:
                     message.finishReason = data.finishReason; // FUTURE could be anything, may not match the options in AIMessage
                     message.usage = data.totalUsage;
@@ -512,6 +663,19 @@ function defaultPruneMessagesForAgent(messages) {
     // to avoid too many tokens and context window consumption.
     // Some applications will want to entirely remove specific tool calls that have only transient use,
     // which can be done by providing their own pruneMessagesForAgent function.
+    // 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);
+            }
+        }
+    }
     return messages.map(m => {
         if (m.role !== 'assistant') {
             return {
@@ -521,6 +685,11 @@ function defaultPruneMessagesForAgent(messages) {
         }
         const textParts = m.content.filter((part) => part.type === 'text');
         const objectParts = m.content.filter((part) => part.type === 'object');
+        // Approval parts must survive pruning: the agent needs the pending tool call and the
+        // user's decision to resume a conversation that stopped for approval.
+        const approvalParts = m.content.filter((part) => part.type === 'tool-approval-requested' ||
+            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) {
@@ -531,6 +700,7 @@ function defaultPruneMessagesForAgent(messages) {
         }
         // Preserve object parts for object agents
         content.push(...objectParts);
+        content.push(...approvalParts);
         return {
             role: m.role,
             content
@@ -538,9 +708,149 @@ function defaultPruneMessagesForAgent(messages) {
     });
 }
 
+/**
+ * Remembers the user's "always approve" decisions for tool calls that require human approval.
+ *
+ * Decisions are held in memory only and are scoped to a chat session: each chat component
+ * instance identifies its conversation with a unique session ID, so approvals never outlive
+ * the conversation they were given in. Navigating away and back, reopening a dialog, or
+ * starting a new conversation creates a new session that prompts again. This applies both to
+ * single tools ("always approve this tool") and to the session-wide YOLO mode
+ * ({@link rememberAllTools}, "always approve all tools").
+ *
+ * Tools configured with `needsApproval` always prompt regardless of these preferences; that
+ * is enforced by the chat component, since it requires the agent definition. The chat
+ * component also offers a global "approve all tools" option persisted as a user preference,
+ * which is not managed by this service.
+ *
+ * Only approvals are remembered, never denials.
+ */
+class AiToolApprovalMemoryService {
+    constructor() {
+        /** Remembered approvals, keyed by chat session ID. */
+        this.sessions = new Map();
+        this.nextSessionId = 0;
+    }
+    /**
+     * Returns a new chat session ID, unique for the lifetime of the page. Chat components request
+     * one per conversation and pass it to the other methods to scope their approvals.
+     */
+    newSessionId() {
+        return `chat-session-${++this.nextSessionId}`;
+    }
+    /** Remembers that calls of the given tool are always approved within the given chat session. */
+    rememberTool(sessionId, toolName) {
+        this.session(sessionId).tools.add(toolName);
+    }
+    /**
+     * Enables YOLO mode for the given chat session: every tool of the conversation is approved
+     * automatically, without prompting, until the conversation ends.
+     */
+    rememberAllTools(sessionId) {
+        this.session(sessionId).approveAll = true;
+    }
+    /** Whether the user chose to always approve the given tool within the given chat session. */
+    isToolRemembered(sessionId, toolName) {
+        return this.sessions.get(sessionId)?.tools.has(toolName) ?? false;
+    }
+    /** Whether YOLO mode is enabled for the given chat session (see {@link rememberAllTools}). */
+    isApproveAllToolsEnabled(sessionId) {
+        return this.sessions.get(sessionId)?.approveAll ?? false;
+    }
+    /** Forgets the remembered approvals of a chat session, e.g. when the conversation ends. */
+    endSession(sessionId) {
+        this.sessions.delete(sessionId);
+    }
+    /** Forgets all remembered approvals of all sessions. */
+    clear() {
+        this.sessions.clear();
+    }
+    session(sessionId) {
+        let session = this.sessions.get(sessionId);
+        if (!session) {
+            session = { approveAll: false, tools: new Set() };
+            this.sessions.set(sessionId, session);
+        }
+        return session;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.19", ngImport: i0, type: AiToolApprovalMemoryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.19", ngImport: i0, type: AiToolApprovalMemoryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.19", ngImport: i0, type: AiToolApprovalMemoryService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/** REST resource segments the `cumulocity-api-request` tool commonly queries, mapped to a readable plural noun. */
+const RESOURCE_LABELS = {
+    managedObjects: gettext('inventory objects'),
+    alarms: gettext('alarms'),
+    measurements: gettext('measurements'),
+    events: gettext('events'),
+    operations: gettext('operations'),
+    users: gettext('users'),
+    applications: gettext('applications'),
+    identity: gettext('external IDs')
+};
+/** Common `fragmentType`/`type` filter values used to narrow an inventory query, mapped to a more specific noun than the generic "inventory objects" label. */
+const FRAGMENT_TYPE_LABELS = {
+    c8y_IsDevice: gettext('devices'),
+    c8y_IsDeviceGroup: gettext('device groups'),
+    c8y_IsAsset: gettext('assets')
+};
+/**
+ * A `labelProvider` (see `ToolCallConfig`) for the `cumulocity-api-request` tool: the generic
+ * Cumulocity REST query tool offered to AI agents to look up API data. For a tool call awaiting
+ * approval, produces a human-readable summary of the query - e.g. "Look up: alarms with status:
+ * active" -
+ * instead of the raw `{ "query": "/alarm/alarms?status=ACTIVE" }`, so the user can judge the
+ * request without reading the API path themselves.
+ *
+ * Only applies to the `tool-approval-requested`/`tool-approval-responded` states; for every other
+ * state this returns `undefined` so the caller's own `executingLabel`/`completedLabel` is used
+ * instead. It also returns `undefined` for any query it doesn't recognize, which keeps the generic
+ * "Tool cumulocity-api-request requires approval" text and the auto-expanded raw input as a
+ * fallback - recognizes the common read endpoints (inventory, alarms, measurements, events,
+ * operations, users, applications, identity).
+ *
+ * Assumes the tool's `query` input is a REST path with no separate `method`/body fields, matching
+ * its documented purpose of verifying/looking up API data.
+ */
+function cumulocityApiRequestLabelProvider(tool, translateService) {
+    if (tool.type !== 'tool-approval-requested' && tool.type !== 'tool-approval-responded') {
+        return undefined;
+    }
+    const query = tool.input?.query;
+    const summary = summarizeQuery(query, translateService);
+    if (!summary)
+        return undefined;
+    if (tool.type === 'tool-approval-responded') {
+        return translateService.instant(tool.approval?.approved ? gettext('Approved: {{summary}}') : gettext('Denied: {{summary}}'), { summary });
+    }
+    return summary;
+}
+function summarizeQuery(query, translateService) {
+    if (!query)
+        return undefined;
+    const [path, search] = query.split('?');
+    const resourceKey = path.split('/').find(segment => RESOURCE_LABELS[segment]);
+    if (!resourceKey)
+        return undefined;
+    const params = new URLSearchParams(search || '');
+    const fragmentType = params.get('fragmentType') || params.get('type');
+    const resource = translateService.instant((fragmentType && FRAGMENT_TYPE_LABELS[fragmentType]) || RESOURCE_LABELS[resourceKey]);
+    const status = params.get('status');
+    return status
+        ? translateService.instant(gettext('Look up: {{resource}} with status: {{status}}'), {
+            status: status.toLowerCase(),
+            resource
+        })
+        : translateService.instant(gettext('Look up: {{resource}}'), { resource });
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AIService, DataStreamType, defaultPruneMessagesForAgent };
+export { AIService, AiToolApprovalMemoryService, DataStreamType, cumulocityApiRequestLabelProvider, defaultPruneMessagesForAgent };
 //# sourceMappingURL=c8y-ngx-components-ai.mjs.map