@datalayer/agent-runtimes 1.5.26 → 1.5.27

package/lib/portable/runMeasures.d.ts

@@ -0,0 +1,46 @@
+/**
+ * How a streamed turn went, measured without its words (MOBILE M-036, §10):
+ * the time to its first streamed token, to its complete answer, how long a
+ * Stop took, the category of a stream that failed, and how often a lost
+ * stream was read back. Never a prompt, an answer, a tool's arguments or an
+ * id — only durations, counts and coarse categories — and an OTLP/JSON body
+ * of them for the platform's metrics ingest.
+ *
+ * Pure: the clock is given.
+ *
+ * @module portable/runMeasures
+ */
+import { type AgUiEvent } from './agui';
+/** Why a stream failed, coarsely. */
+export type StreamFailure = 'refused' | 'cut_short' | 'network' | 'other';
+/** One turn, measured. */
+export type RunMeasure = {
+    surface: 'application' | 'agent';
+    firstTokenMs: number | null;
+    answerMs: number | null;
+    stopLatencyMs: number | null;
+    failure: StreamFailure | null;
+};
+/** The category of a stream's failure; never its message. */
+export declare function failureOf(error: unknown): StreamFailure;
+/** Measures one turn from its start: fed its events, its Stop, its failure; read once it ended. */
+export declare class RunMeter {
+    private readonly surface;
+    private readonly now;
+    private readonly started;
+    private firstToken;
+    private answered;
+    private stopLatency;
+    private failed;
+    constructor(surface: RunMeasure['surface'], now?: () => number);
+    event(event: AgUiEvent): void;
+    stopped(latencyMs: number): void;
+    failure(error: unknown): void;
+    read(): RunMeasure;
+}
+/**
+ * The OTLP/JSON body of turns measured and lost streams read back: gauges of
+ * milliseconds and counters, each point with the surface and, for a failure,
+ * its category — nothing else.
+ */
+export declare function otlpMetricsOf(measures: RunMeasure[], recoveries: number, resource: Record<string, string>, nowMs: number): Record<string, unknown>;

package/lib/portable/runMeasures.js

@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * How a streamed turn went, measured without its words (MOBILE M-036, §10):
+ * the time to its first streamed token, to its complete answer, how long a
+ * Stop took, the category of a stream that failed, and how often a lost
+ * stream was read back. Never a prompt, an answer, a tool's arguments or an
+ * id — only durations, counts and coarse categories — and an OTLP/JSON body
+ * of them for the platform's metrics ingest.
+ *
+ * Pure: the clock is given.
+ *
+ * @module portable/runMeasures
+ */
+import { RUN_CUT_SHORT } from './agui';
+import { RuntimeRefusal } from './sessions';
+/** The category of a stream's failure; never its message. */
+export function failureOf(error) {
+    if (error instanceof RuntimeRefusal)
+        return 'refused';
+    const message = error instanceof Error ? error.message : String(error);
+    if (message === RUN_CUT_SHORT || message.includes(RUN_CUT_SHORT))
+        return 'cut_short';
+    if (error instanceof TypeError ||
+        /network|offline|timed? ?out|fetch/i.test(message))
+        return 'network';
+    return 'other';
+}
+/** Measures one turn from its start: fed its events, its Stop, its failure; read once it ended. */
+export class RunMeter {
+    surface;
+    now;
+    started;
+    firstToken = null;
+    answered = null;
+    stopLatency = null;
+    failed = null;
+    constructor(surface, now = () => Date.now()) {
+        this.surface = surface;
+        this.now = now;
+        this.started = now();
+    }
+    event(event) {
+        if (this.firstToken === null && event.type === 'TEXT_MESSAGE_CONTENT') {
+            this.firstToken = this.now() - this.started;
+        }
+        if (event.type === 'RUN_FINISHED' && this.answered === null) {
+            this.answered = this.now() - this.started;
+        }
+    }
+    stopped(latencyMs) {
+        this.stopLatency = Math.max(0, latencyMs);
+    }
+    failure(error) {
+        this.failed = failureOf(error);
+    }
+    read() {
+        return {
+            surface: this.surface,
+            firstTokenMs: this.firstToken,
+            answerMs: this.failed || this.stopLatency !== null ? null : this.answered,
+            stopLatencyMs: this.stopLatency,
+            failure: this.failed,
+        };
+    }
+}
+const attributes = (values) => Object.entries(values).map(([key, value]) => ({
+    key,
+    value: { stringValue: value },
+}));
+/**
+ * The OTLP/JSON body of turns measured and lost streams read back: gauges of
+ * milliseconds and counters, each point with the surface and, for a failure,
+ * its category — nothing else.
+ */
+export function otlpMetricsOf(measures, recoveries, resource, nowMs) {
+    const time = String(BigInt(Math.trunc(nowMs)) * 1000000n);
+    const gauge = (name, pick) => ({
+        name,
+        unit: 'ms',
+        gauge: {
+            dataPoints: measures.flatMap(measure => {
+                const value = pick(measure);
+                return value === null
+                    ? []
+                    : [
+                        {
+                            asDouble: value,
+                            timeUnixNano: time,
+                            attributes: attributes({ surface: measure.surface }),
+                        },
+                    ];
+            }),
+        },
+    });
+    const failures = new Map();
+    for (const measure of measures) {
+        if (measure.failure) {
+            const key = `${measure.surface}\n${measure.failure}`;
+            failures.set(key, (failures.get(key) ?? 0) + 1);
+        }
+    }
+    const metrics = [
+        gauge('datalayer.client.run.first_token', measure => measure.firstTokenMs),
+        gauge('datalayer.client.run.answer', measure => measure.answerMs),
+        gauge('datalayer.client.run.stop_latency', measure => measure.stopLatencyMs),
+        {
+            name: 'datalayer.client.run.failures',
+            sum: {
+                aggregationTemporality: 1,
+                isMonotonic: true,
+                dataPoints: [...failures].map(([key, count]) => {
+                    const [surface, category] = key.split('\n');
+                    return {
+                        asInt: String(count),
+                        timeUnixNano: time,
+                        attributes: attributes({ surface, category }),
+                    };
+                }),
+            },
+        },
+        {
+            name: 'datalayer.client.run.recoveries',
+            sum: {
+                aggregationTemporality: 1,
+                isMonotonic: true,
+                dataPoints: recoveries > 0
+                    ? [
+                        {
+                            asInt: String(recoveries),
+                            timeUnixNano: time,
+                            attributes: [],
+                        },
+                    ]
+                    : [],
+            },
+        },
+    ].filter(metric => 'gauge' in metric
+        ? metric.gauge.dataPoints.length > 0
+        : metric.sum.dataPoints.length > 0);
+    return {
+        resourceMetrics: [
+            {
+                resource: { attributes: attributes(resource) },
+                scopeMetrics: [
+                    {
+                        scope: { name: '@datalayer/agent-runtimes/portable/runMeasures' },
+                        metrics,
+                    },
+                ],
+            },
+        ],
+    };
+}

package/lib/protocols/ACPAdapter.js

@@ -454,15 +454,20 @@ export class ACPAdapter extends BaseProtocolAdapter {
             });
         }
         if (updateType === 'tool_call_update') {
+            // A call's result, once it says it ended; its progress before then is
+            // not a result. ACP names the call it updates.
             const progress = update;
-            this.emit({
-                type: 'tool-result',
-                toolResult: {
-                    success: progress.status !== 'failed',
-                    result: progress.rawOutput,
-                },
-                timestamp: new Date(),
-            });
+            if (progress.status === 'completed' || progress.status === 'failed') {
+                this.emit({
+                    type: 'tool-result',
+                    toolResult: {
+                        toolCallId: progress.toolCallId ?? '',
+                        success: progress.status === 'completed',
+                        result: progress.rawOutput,
+                    },
+                    timestamp: new Date(),
+                });
+            }
         }
         if (updateType === 'agent_thought_chunk') {
             const thought = textOf(update.content);

package/lib/utils/utils.d.ts

@@ -4,6 +4,7 @@
  * @module chat/utils
  */
 import { QueryClient } from '@tanstack/react-query';
+import { sanitizeAssistantContent } from '../portable/adapterEvents';
 import type { ChatMessage } from '../types/messages';
 import type { ProtocolConfig } from '../types/protocol';
 import { type BaseProtocolAdapter } from '../protocols';
@@ -16,14 +17,7 @@ export declare const PRIMER_PORTAL_ROOT_ID = "__primerPortalRoot__";
  * Check if an item is a tool call message
  */
 export declare function isToolCallMessage(item: DisplayItem): item is ToolCallMessage;
-/**
- * Strip low-level protocol/tool-call markup from assistant text content.
- *
- * Some models occasionally leak internal call formats (for example,
- * <calls>...</calls> or <tml:invoke ...>) into natural-language responses.
- * Keep user/system text untouched and sanitize assistant-visible text only.
- */
-export declare function sanitizeAssistantContent(content: string): string;
+export { sanitizeAssistantContent };
 /**
  * Extract text content from a ChatMessage
  */

package/lib/utils/utils.js

@@ -8,6 +8,7 @@
  * @module chat/utils
  */
 import { QueryClient } from '@tanstack/react-query';
+import { sanitizeAssistantContent } from '../portable/adapterEvents';
 import { AGUIAdapter, A2AAdapter, VercelAIAdapter, ACPAdapter, BrowserAgentAdapter, } from '../protocols';
 // ---------------------------------------------------------------------------
 // Constants
@@ -32,32 +33,8 @@ export const PRIMER_PORTAL_ROOT_ID = '__primerPortalRoot__';
 export function isToolCallMessage(item) {
     return 'type' in item && item.type === 'tool-call';
 }
-/**
- * Strip low-level protocol/tool-call markup from assistant text content.
- *
- * Some models occasionally leak internal call formats (for example,
- * <calls>...</calls> or <tml:invoke ...>) into natural-language responses.
- * Keep user/system text untouched and sanitize assistant-visible text only.
- */
-export function sanitizeAssistantContent(content) {
-    if (!content || !content.includes('<')) {
-        return content;
-    }
-    let sanitized = content;
-    // Remove complete blocks first.
-    sanitized = sanitized
-        .replace(/<\s*calls\b[\s\S]*?<\s*\/\s*calls\s*>/gi, '')
-        .replace(/<\s*(?:an:)?tml:invoke\b[\s\S]*?<\s*\/\s*(?:an:)?tml:invoke\s*>/gi, '')
-        .replace(/<\s*(?:an:)?tml:parameter\b[\s\S]*?<\s*\/\s*(?:an:)?tml:parameter\s*>/gi, '');
-    // Remove standalone/open/close tags and malformed tag fragments.
-    sanitized = sanitized
-        .replace(/<\s*\/?\s*(?:an:[a-z_]+|tml:[a-z_]+|calls)\b[^>]*>?/gi, '')
-        .replace(/<\s*\/\s*>/g, '')
-        .replace(/^[ \t]+$/gm, '')
-        .replace(/\n{3,}/g, '\n\n')
-        .trim();
-    return sanitized;
-}
+// What a model leaked of its call markup, taken out: one rule for every client.
+export { sanitizeAssistantContent };
 /**
  * Extract text content from a ChatMessage
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@datalayer/agent-runtimes",
-    "version": "1.5.26",
+    "version": "1.5.27",
     "type": "module",
     "workspaces": [
         ".",