@otto-code/client 0.8.12 → 0.8.14

package/dist/daemon-client.js

@@ -117,6 +117,7 @@ function toTimeoutError(error, label, timeoutMs) {
 const DEFAULT_RECONNECT_BASE_DELAY_MS = 1500;
 const DEFAULT_RECONNECT_MAX_DELAY_MS = 30000;
 const DEFAULT_SESSION_RPC_TIMEOUT_MS = 60000;
+const PUSH_TOKEN_REVOCATION_TIMEOUT_MS = 2000;
 const DEFAULT_CONNECT_TIMEOUT_MS = 15000;
 const DEFAULT_LIVENESS_TIMEOUT_MS = 5000;
 const LIVENESS_HEARTBEAT_INTERVAL_MS = 10000;
@@ -185,6 +186,30 @@ function concatByteChunks(chunks, size) {
     }
     return bytes;
 }
+function extractDispatchAgentId(message) {
+    if (message.type === "agent_stream") {
+        return message.payload.agentId;
+    }
+    if (message.type === "agent_update") {
+        return message.payload.kind === "upsert" ? message.payload.agent.id : message.payload.agentId;
+    }
+    return undefined;
+}
+function getTransportFrameSize(frame) {
+    if (typeof frame === "string") {
+        return frame.length;
+    }
+    return frame.byteLength;
+}
+function describeInboundTransportFrame(frame, rawBytes) {
+    if (typeof frame === "string") {
+        return { kind: "text", size: String(frame.length) };
+    }
+    if (rawBytes) {
+        return { kind: "binary", size: String(rawBytes.byteLength) };
+    }
+    return { kind: "unknown", size: "0" };
+}
 function hashForLog(value) {
     let hash = 0;
     for (let index = 0; index < value.length; index += 1) {
@@ -595,6 +620,45 @@ export class DaemonClient {
     // ============================================================================
     // Core Send Helpers
     // ============================================================================
+    beginTraceSection(name, args) {
+        const trace = this.config.trace;
+        if (!trace?.isEnabled()) {
+            return false;
+        }
+        trace.beginSection(name, args);
+        return true;
+    }
+    endTraceSection(isOpen) {
+        if (isOpen) {
+            this.config.trace?.endSection();
+        }
+    }
+    traceInstant(name, args) {
+        const isOpen = this.beginTraceSection(name, args);
+        this.endTraceSection(isOpen);
+    }
+    sendJsonMessage(envelopeType, messageType, message) {
+        this.traceInstant("otto.ws.message.outbound", {
+            envelopeType,
+            messageType,
+        });
+        this.sendTransportFrame(JSON.stringify(message));
+    }
+    sendTransportFrame(frame) {
+        if (!this.transport) {
+            throw new Error("Transport not connected");
+        }
+        const isOpen = this.beginTraceSection("otto.ws.frame.outbound", {
+            kind: typeof frame === "string" ? "text" : "binary",
+            size: String(getTransportFrameSize(frame)),
+        });
+        try {
+            this.transport.send(frame);
+        }
+        finally {
+            this.endTraceSection(isOpen);
+        }
+    }
     /**
      * Send a session message. For fire-and-forget messages (heartbeats, etc.),
      * failures are suppressed if `suppressSendErrors` is configured.
@@ -609,7 +673,7 @@ export class DaemonClient {
         }
         const payload = SessionInboundMessageSchema.parse(message);
         try {
-            this.transport.send(JSON.stringify({ type: "session", message: payload }));
+            this.sendJsonMessage("session", payload.type, { type: "session", message: payload });
         }
         catch (error) {
             if (this.config.suppressSendErrors) {
@@ -626,7 +690,11 @@ export class DaemonClient {
             throw new Error(`Transport not connected (status: ${this.connectionState.status})`);
         }
         try {
-            this.transport.send(frame);
+            this.traceInstant("otto.ws.message.outbound", {
+                envelopeType: "binary",
+                messageType: "binary",
+            });
+            this.sendTransportFrame(frame);
         }
         catch (error) {
             if (this.config.suppressSendErrors) {
@@ -646,7 +714,7 @@ export class DaemonClient {
         // If connected, send immediately
         if (this.transport && status === "connected") {
             const payload = SessionInboundMessageSchema.parse(message);
-            this.transport.send(JSON.stringify({ type: "session", message: payload }));
+            this.sendJsonMessage("session", payload.type, { type: "session", message: payload });
             return Promise.resolve();
         }
         // If connecting, queue the message to be sent once connected
@@ -677,7 +745,7 @@ export class DaemonClient {
             try {
                 if (this.transport && this.connectionState.status === "connected") {
                     const payload = SessionInboundMessageSchema.parse(pending.message);
-                    this.transport.send(JSON.stringify({ type: "session", message: payload }));
+                    this.sendJsonMessage("session", payload.type, { type: "session", message: payload });
                     pending.resolve();
                 }
                 else {
@@ -785,7 +853,7 @@ export class DaemonClient {
         }
         const payload = SessionInboundMessageSchema.parse(message);
         try {
-            this.transport.send(JSON.stringify({ type: "session", message: payload }));
+            this.sendJsonMessage("session", payload.type, { type: "session", message: payload });
         }
         catch (error) {
             throw error instanceof Error ? error : new Error(String(error));
@@ -855,6 +923,15 @@ export class DaemonClient {
             token,
         });
     }
+    async unregisterPushToken(token) {
+        const requestId = this.createRequestId();
+        await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "push.unregister.request", token, requestId },
+            responseType: "push.unregister.response",
+            timeout: PUSH_TOKEN_REVOCATION_TIMEOUT_MS,
+        });
+    }
     async ping(params) {
         const requestId = params?.requestId ?? `ping-${Date.now()}-${Math.random().toString(36).slice(2)}`;
         const clientSentAt = Date.now();
@@ -934,7 +1011,7 @@ export class DaemonClient {
         };
         this.pingProbe = probe;
         try {
-            this.transport.send(JSON.stringify({ type: "ping" }));
+            this.sendJsonMessage("ping", "ping", { type: "ping" });
         }
         catch (error) {
             this.clearPingProbe();
@@ -1007,6 +1084,7 @@ export class DaemonClient {
             type: "fetch_agent_history_request",
             requestId: resolvedRequestId,
             ...(options?.filter ? { filter: options.filter } : {}),
+            ...(options?.search ? { search: options.search } : {}),
             ...(options?.sort ? { sort: options.sort } : {}),
             ...(options?.page ? { page: options.page } : {}),
         });
@@ -1778,6 +1856,14 @@ export class DaemonClient {
         }
         return { target: payload.target };
     }
+    async setProjectIcon(projectId, source, requestId) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: { type: "project.icon.set.request", projectId, source },
+        });
+        if (!payload.accepted)
+            throw new Error(payload.error ?? "setProjectIcon rejected");
+    }
     async removeProject(projectId, requestId) {
         const payload = await this.sendNamespacedCorrelatedSessionRequest({
             requestId,
@@ -2262,6 +2348,7 @@ export class DaemonClient {
             ...(options.cursor ? { cursor: options.cursor } : {}),
             ...(typeof options.limit === "number" ? { limit: options.limit } : {}),
             ...(options.projection ? { projection: options.projection } : {}),
+            ...(options.mergeWindow === true ? { mergeWindow: true } : {}),
         });
         const payload = await this.sendRequest({
             requestId: resolvedRequestId,
@@ -2283,6 +2370,28 @@ export class DaemonClient {
         }
         return payload;
     }
+    async listAgentTimelinePrompts(agentId, options = {}) {
+        const requestId = this.createRequestId(options.requestId);
+        const message = SessionInboundMessageSchema.parse({
+            type: "agent.timeline.list_prompts.request",
+            agentId,
+            requestId,
+        });
+        const payload = await this.sendRequest({
+            requestId,
+            message,
+            timeout: options.timeout,
+            options: { skipQueue: true },
+            select: (response) => response.type === "agent.timeline.list_prompts.response" &&
+                response.payload.requestId === requestId
+                ? response.payload
+                : null,
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload;
+    }
     async buildAgentForkContext(agentId, options = {}) {
         const resolvedRequestId = this.createRequestId(options.requestId);
         const message = SessionInboundMessageSchema.parse({
@@ -2647,6 +2756,40 @@ export class DaemonClient {
         }
         return payload.notice ?? null;
     }
+    /**
+     * Applies a whole agent-config bundle in one request. Use this instead of
+     * chaining the single-field setters when the values belong together so client
+     * interruption and other mutations cannot interleave between steps. A
+     * provider rejection can still leave earlier steps applied.
+     * Gated on `server_info.features.agentConfigApply`.
+     */
+    async applyAgentConfig(agentId, config) {
+        const requestId = this.createRequestId();
+        const message = SessionInboundMessageSchema.parse({
+            type: "agent.config.apply.request",
+            agentId,
+            config,
+            requestId,
+        });
+        const payload = await this.sendRequest({
+            requestId,
+            message,
+            options: { skipQueue: true },
+            select: (msg) => {
+                if (msg.type !== "agent.config.apply.response") {
+                    return null;
+                }
+                if (msg.payload.requestId !== requestId) {
+                    return null;
+                }
+                return msg.payload;
+            },
+        });
+        if (!payload.accepted) {
+            throw new Error(payload.error ?? "applyAgentConfig rejected");
+        }
+        return payload.notice ?? null;
+    }
     async restartServer(reason, requestId) {
         const resolvedRequestId = this.createRequestId(requestId);
         const message = SessionInboundMessageSchema.parse({
@@ -3712,48 +3855,6 @@ export class DaemonClient {
             requestId: input.requestId,
         }));
     }
-    /** Create an empty file or a directory. Never overwrites - see FileCreateResultSchema. */
-    async createFileEntry(options) {
-        const payload = await this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "file.create.request",
-                cwd: options.cwd,
-                path: options.path,
-                kind: options.kind,
-            },
-            responseType: "file.create.response",
-        });
-        return payload.result;
-    }
-    /** Permanent delete - an unlink, not a move to any trash. */
-    async deleteFileEntry(options) {
-        const payload = await this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "file.delete.request",
-                cwd: options.cwd,
-                path: options.path,
-                recursive: options.recursive,
-            },
-            responseType: "file.delete.response",
-        });
-        return payload.result;
-    }
-    /** Rename, which is also move. Never clobbers an occupied destination. */
-    async renameFileEntry(options) {
-        const payload = await this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "file.rename.request",
-                cwd: options.cwd,
-                path: options.path,
-                newPath: options.newPath,
-            },
-            responseType: "file.rename.response",
-        });
-        return payload.result;
-    }
     async refineFile(options) {
         const payload = await this.sendCorrelatedSessionRequest({
             requestId: options.requestId,
@@ -4446,6 +4547,7 @@ export class DaemonClient {
             message: {
                 type: "get_providers_snapshot_request",
                 cwd: options?.cwd,
+                ifNoneMatch: options?.ifNoneMatch,
             },
             responseType: "get_providers_snapshot_response",
         });
@@ -4978,6 +5080,31 @@ export class DaemonClient {
         });
         return unwrapBrainJob(payload);
     }
+    async createFileEntry(input) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "fs.entry.create.request", ...input },
+        });
+    }
+    async renameFileEntry(input) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "fs.entry.rename.request", ...input },
+        });
+    }
+    async duplicateFileEntry(input) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "fs.entry.duplicate.request", ...input },
+        });
+    }
+    async deleteFileEntry(input) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "fs.entry.delete.request", ...input },
+        });
+    }
+    async checkoutDiscardChanges(cwd, input) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            message: { type: "checkout.discard_changes.request", cwd, paths: input.paths },
+        });
+    }
     async brainJobsList(requestId) {
         const payload = await this.sendCorrelatedSessionRequest({
             requestId,
@@ -5093,6 +5220,15 @@ export class DaemonClient {
         }
         return payload.status;
     }
+    async getProjectIcon(projectId, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: { type: "project.icon.get.request", projectId },
+        });
+    }
+    // ============================================================================
+    // Provider Models / Commands
+    // ============================================================================
     /** Delete a model's files. The brain refuses while that model is loaded. */
     async brainModelDelete(modelId, requestId) {
         const payload = await this.sendCorrelatedSessionRequest({
@@ -5689,86 +5825,6 @@ export class DaemonClient {
             responseType: "terminal.compatibility.diagnostic.response",
         });
     }
-    async createChatRoom(options) {
-        return this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "chat/create",
-                name: options.name,
-                ...(options.purpose ? { purpose: options.purpose } : {}),
-            },
-            responseType: "chat/create/response",
-        });
-    }
-    async listChatRooms(requestId) {
-        return this.sendCorrelatedSessionRequest({
-            requestId,
-            message: {
-                type: "chat/list",
-            },
-            responseType: "chat/list/response",
-        });
-    }
-    async inspectChatRoom(options) {
-        return this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "chat/inspect",
-                room: options.room,
-            },
-            responseType: "chat/inspect/response",
-        });
-    }
-    async deleteChatRoom(options) {
-        return this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "chat/delete",
-                room: options.room,
-            },
-            responseType: "chat/delete/response",
-        });
-    }
-    async postChatMessage(options) {
-        return this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "chat/post",
-                room: options.room,
-                body: options.body,
-                ...(options.authorAgentId ? { authorAgentId: options.authorAgentId } : {}),
-                ...(options.replyToMessageId ? { replyToMessageId: options.replyToMessageId } : {}),
-            },
-            responseType: "chat/post/response",
-        });
-    }
-    async readChatMessages(options) {
-        return this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "chat/read",
-                room: options.room,
-                ...(typeof options.limit === "number" ? { limit: options.limit } : {}),
-                ...(options.since ? { since: options.since } : {}),
-                ...(options.authorAgentId ? { authorAgentId: options.authorAgentId } : {}),
-            },
-            responseType: "chat/read/response",
-            timeout: options.timeout,
-        });
-    }
-    async waitForChatMessages(options) {
-        return this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "chat/wait",
-                room: options.room,
-                ...(options.afterMessageId ? { afterMessageId: options.afterMessageId } : {}),
-                ...(typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : {}),
-            },
-            responseType: "chat/wait/response",
-            timeout: (options.timeoutMs ?? 0) + 10000,
-        });
-    }
     async scheduleCreate(options) {
         return this.sendCorrelatedSessionRequest({
             requestId: options.requestId,
@@ -5968,76 +6024,6 @@ export class DaemonClient {
             responseType: "artifact.get-content.response",
         });
     }
-    async loopRun(options) {
-        return this.sendCorrelatedSessionRequest({
-            requestId: options.requestId,
-            message: {
-                type: "loop/run",
-                prompt: options.prompt,
-                cwd: options.cwd,
-                ...(options.provider ? { provider: options.provider } : {}),
-                ...(options.model ? { model: options.model } : {}),
-                ...(options.modeId ? { modeId: options.modeId } : {}),
-                ...(options.verifierProvider ? { verifierProvider: options.verifierProvider } : {}),
-                ...(options.verifierModel ? { verifierModel: options.verifierModel } : {}),
-                ...(options.verifierModeId ? { verifierModeId: options.verifierModeId } : {}),
-                ...(options.verifyPrompt ? { verifyPrompt: options.verifyPrompt } : {}),
-                ...(options.verifyChecks && options.verifyChecks.length > 0
-                    ? { verifyChecks: options.verifyChecks }
-                    : {}),
-                ...(options.name ? { name: options.name } : {}),
-                ...(typeof options.sleepMs === "number" ? { sleepMs: options.sleepMs } : {}),
-                ...(typeof options.maxIterations === "number"
-                    ? { maxIterations: options.maxIterations }
-                    : {}),
-                ...(typeof options.maxTimeMs === "number" ? { maxTimeMs: options.maxTimeMs } : {}),
-            },
-            responseType: "loop/run/response",
-        });
-    }
-    async loopList(requestId) {
-        return this.sendCorrelatedSessionRequest({
-            requestId,
-            message: {
-                type: "loop/list",
-            },
-            responseType: "loop/list/response",
-        });
-    }
-    async loopInspect(options) {
-        const normalized = typeof options === "string" ? { id: options } : options;
-        return this.sendCorrelatedSessionRequest({
-            requestId: normalized.requestId,
-            message: {
-                type: "loop/inspect",
-                id: normalized.id,
-            },
-            responseType: "loop/inspect/response",
-        });
-    }
-    async loopLogs(options, afterSeq) {
-        const normalized = typeof options === "string" ? { id: options, afterSeq } : options;
-        return this.sendCorrelatedSessionRequest({
-            requestId: normalized.requestId,
-            message: {
-                type: "loop/logs",
-                id: normalized.id,
-                ...(typeof normalized.afterSeq === "number" ? { afterSeq: normalized.afterSeq } : {}),
-            },
-            responseType: "loop/logs/response",
-        });
-    }
-    async loopStop(options) {
-        const normalized = typeof options === "string" ? { id: options } : options;
-        return this.sendCorrelatedSessionRequest({
-            requestId: normalized.requestId,
-            message: {
-                type: "loop/stop",
-                id: normalized.id,
-            },
-            responseType: "loop/stop/response",
-        });
-    }
     onTerminalStreamEvent(handler) {
         return this.terminalStreams.onEvent(handler);
     }
@@ -6078,6 +6064,14 @@ export class DaemonClient {
     getTrafficHotspots(limit) {
         return this.runtimeMetrics?.getTrafficHotspots(limit) ?? [];
     }
+    /**
+     * Bounded, timestamped dispatch phases for matching an inbound daemon
+     * message to a browser Long Animation Frame. This is diagnostic evidence,
+     * not a protocol surface.
+     */
+    getInboundDispatchTimings(sinceMs) {
+        return this.runtimeMetrics?.getInboundDispatchTimings(sinceMs) ?? [];
+    }
     resolveTransportUrlForAttempt() {
         return this.config.url;
     }
@@ -6091,7 +6085,7 @@ export class DaemonClient {
             return;
         }
         try {
-            this.transport.send(JSON.stringify({
+            this.sendJsonMessage("hello", "hello", {
                 type: "hello",
                 clientId: this.config.clientId,
                 clientType: this.config.clientType ?? "cli",
@@ -6105,10 +6099,11 @@ export class DaemonClient {
                     // so dropping it silently kills cross-session project renames.
                     [CLIENT_CAPS.projectUpdates]: true,
                     [CLIENT_CAPS.communicationsPresenceUpdates]: true,
+                    [CLIENT_CAPS.compactProviderSnapshots]: true,
                     ...this.config.capabilities,
                 },
                 ...(this.config.appVersion ? { appVersion: this.config.appVersion } : {}),
-            }));
+            });
         }
         catch (error) {
             const message = error instanceof Error ? error.message : "Failed to send hello message";
@@ -6173,25 +6168,38 @@ export class DaemonClient {
             return;
         }
         const rawBytes = asUint8Array(rawData);
-        if (rawBytes && this.tryHandleBinaryFrame(rawBytes)) {
-            return;
+        const isOpen = this.beginTraceSection("otto.ws.frame.inbound", describeInboundTransportFrame(rawData, rawBytes));
+        try {
+            if (rawBytes && this.tryHandleBinaryFrame(rawBytes)) {
+                return;
+            }
+            const payload = decodeMessageData(rawData);
+            if (!payload) {
+                return;
+            }
+            this.handleJsonPayload(payload, rawBytes?.byteLength);
         }
-        const payload = decodeMessageData(rawData);
-        if (!payload) {
-            return;
+        finally {
+            this.endTraceSection(isOpen);
         }
-        this.handleJsonPayload(payload, rawBytes?.byteLength);
     }
     handleJsonPayload(payload, rawBytesLength) {
         const bytes = rawBytesLength ?? payload.length;
+        const dispatchAt = Date.now();
         const startMs = perfNow();
         let parsedJson;
+        const parseTraceOpen = this.beginTraceSection("otto.ws.json.parse", {
+            size: String(bytes),
+        });
         try {
             parsedJson = JSON.parse(payload);
         }
         catch {
             return;
         }
+        finally {
+            this.endTraceSection(parseTraceOpen);
+        }
         const parsed = validateWSOutboundMessage(parsedJson);
         if (!parsed.success) {
             const responseIdentity = extractCorrelatedResponseIdentity(parsedJson);
@@ -6210,13 +6218,33 @@ export class DaemonClient {
         }
         this.consecutiveLivenessFailures = 0;
         if (parsed.data.type === "pong") {
+            this.traceInstant("otto.ws.message.inbound", {
+                envelopeType: "pong",
+                messageType: "pong",
+            });
             this.resolvePingProbe();
             this.runtimeMetrics?.recordMessage("pong", bytes, perfNow() - startMs);
             return;
         }
-        this.handleSessionMessage(parsed.data.message);
+        this.traceInstant("otto.ws.message.inbound", {
+            envelopeType: "session",
+            messageType: parsed.data.message.type,
+        });
+        const phases = this.handleSessionMessage(parsed.data.message);
         const msgType = parsed.data.message.type;
-        this.runtimeMetrics?.recordMessage(msgType, bytes, perfNow() - startMs);
+        const totalMs = perfNow() - startMs;
+        this.runtimeMetrics?.recordMessage(msgType, bytes, totalMs);
+        this.runtimeMetrics?.recordInboundDispatch({
+            at: dispatchAt,
+            type: msgType,
+            agentId: extractDispatchAgentId(parsed.data.message),
+            bytes,
+            decodeAndValidateMs: phases.startedAtMs - startMs,
+            internalDispatchMs: phases.internalDispatchMs,
+            rawListenersMs: phases.rawListenersMs,
+            typedHandlersMs: phases.typedHandlersMs,
+            totalMs,
+        });
         if (parsed.data.message.type === "agent_stream") {
             this.runtimeMetrics?.recordAgentStream(parsed.data.message.payload);
         }
@@ -6224,6 +6252,11 @@ export class DaemonClient {
     tryHandleBinaryFrame(rawBytes) {
         const fileFrame = decodeFileTransferFrame(rawBytes);
         if (fileFrame) {
+            this.traceInstant("otto.ws.message.inbound", {
+                envelopeType: "binary",
+                messageType: "file",
+                opcode: String(fileFrame.opcode),
+            });
             this.consecutiveLivenessFailures = 0;
             this.handleFileTransferFrame(fileFrame);
             this.runtimeMetrics?.recordBinaryFrame("other", rawBytes.byteLength, 0);
@@ -6233,6 +6266,11 @@ export class DaemonClient {
         if (!frame) {
             return false;
         }
+        this.traceInstant("otto.ws.message.inbound", {
+            envelopeType: "binary",
+            messageType: "terminal",
+            opcode: String(frame.opcode),
+        });
         this.consecutiveLivenessFailures = 0;
         const binaryStartMs = perfNow();
         this.terminalStreams.handleFrame(frame);
@@ -6418,6 +6456,7 @@ export class DaemonClient {
         });
     }
     handleSessionMessage(msg) {
+        const startedAtMs = perfNow();
         const consumerMessage = normalizeProviderSnapshotUpdateMessage(msg);
         if (consumerMessage.type === "status") {
             const serverInfo = parseServerInfoStatusPayload(consumerMessage.payload);
@@ -6445,6 +6484,7 @@ export class DaemonClient {
         if (consumerMessage.type === "project.scaffold.progress") {
             this.scaffoldProgressListeners.get(consumerMessage.payload.requestId)?.(consumerMessage.payload);
         }
+        const rawListenersStartedAtMs = perfNow();
         if (this.rawMessageListeners.size > 0) {
             for (const handler of this.rawMessageListeners) {
                 try {
@@ -6455,6 +6495,7 @@ export class DaemonClient {
                 }
             }
         }
+        const typedHandlersStartedAtMs = perfNow();
         const handlers = this.messageHandlers.get(consumerMessage.type);
         if (handlers) {
             for (const handler of handlers) {
@@ -6473,6 +6514,13 @@ export class DaemonClient {
             }
         }
         this.resolveWaiters(consumerMessage);
+        const finishedAtMs = perfNow();
+        return {
+            startedAtMs,
+            internalDispatchMs: rawListenersStartedAtMs - startedAtMs,
+            rawListenersMs: typedHandlersStartedAtMs - rawListenersStartedAtMs,
+            typedHandlersMs: finishedAtMs - typedHandlersStartedAtMs,
+        };
     }
     resolveWaiters(msg) {
         for (const waiter of Array.from(this.waiters)) {