doover-js 0.4.7 → 0.5.0-alpha.0

package/dist/react/useInvocationLogs.d.ts

@@ -0,0 +1,23 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { ChannelIdentifier } from "../types/viewer";
+export declare function invocationLogsQueryKey(agentId: string | undefined, channelName: string | undefined, messageId: string | undefined): readonly ["doover", "agent", string | undefined, "channel", string | undefined, "message", string | undefined, "logs"];
+export interface UseInvocationLogsOptions {
+    /** Defaults to true. Set false to skip the query (e.g. dialog closed). */
+    enabled?: boolean;
+    /**
+     * react-query retry behaviour. Defaults to false — the logs endpoint
+     * commonly 404s while logs are still materialising server-side, and a
+     * manual refetch button is friendlier than silent retry.
+     */
+    retry?: boolean | number;
+}
+/**
+ * Fetch the log entries for a single invocation message. The `/logs`
+ * endpoint is only meaningful for invocation messages (channel name like
+ * `dv-proc-inv-…`); other message types return 404.
+ *
+ * Generic on `TLog` — the shape of a single log entry. Defaults to `unknown`
+ * because log payloads are domain-specific (lambda telemetry, app-level
+ * structured logs, etc.) and doover-js does not own the canonical shape.
+ */
+export declare function useInvocationLogs<TLog = unknown>(identifier: ChannelIdentifier, messageId: string | undefined, options?: UseInvocationLogsOptions): UseQueryResult<TLog[]>;

package/dist/react/useInvocationLogs.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invocationLogsQueryKey = invocationLogsQueryKey;
+exports.useInvocationLogs = useInvocationLogs;
+const react_query_1 = require("@tanstack/react-query");
+const context_1 = require("./context");
+function invocationLogsQueryKey(agentId, channelName, messageId) {
+    return [
+        "doover",
+        "agent",
+        agentId,
+        "channel",
+        channelName,
+        "message",
+        messageId,
+        "logs",
+    ];
+}
+/**
+ * Fetch the log entries for a single invocation message. The `/logs`
+ * endpoint is only meaningful for invocation messages (channel name like
+ * `dv-proc-inv-…`); other message types return 404.
+ *
+ * Generic on `TLog` — the shape of a single log entry. Defaults to `unknown`
+ * because log payloads are domain-specific (lambda telemetry, app-level
+ * structured logs, etc.) and doover-js does not own the canonical shape.
+ */
+function useInvocationLogs(identifier, messageId, options) {
+    const client = (0, context_1.useDooverClient)();
+    const { agentId, channelName } = identifier;
+    return (0, react_query_1.useQuery)({
+        queryKey: invocationLogsQueryKey(agentId, channelName, messageId),
+        queryFn: () => client.messages.getInvocationLogs(agentId, channelName, messageId),
+        enabled: !!agentId &&
+            !!channelName &&
+            !!messageId &&
+            (options?.enabled ?? true),
+        retry: options?.retry ?? false,
+        staleTime: Infinity,
+    });
+}

package/dist/react/useMultiAgentAggregates.js

@@ -65,22 +65,16 @@ function useMultiAgentAggregates(channelName, agentIds, options) {
     (0, react_1.useEffect)(() => {
         if (!liveUpdates || agentIds.length === 0)
             return;
-        const noopMessage = () => { };
-        const subscriptions = agentIds.map((agentId) => {
-            const identifier = { agentId, channelName };
-            const messageCallback = noopMessage;
-            const aggregateCallback = (_id, aggregate) => {
-                patchAgentAggregate(agentId, aggregate);
-            };
-            void client.viewer.subscribeToChannel(identifier, messageCallback, aggregateCallback);
-            return { identifier, messageCallback };
+        const offs = agentIds.map((agentId) => {
+            const channel = { agent_id: agentId, name: channelName };
+            return client.gateway.subscribeToChannel(channel, {
+                onAggregate: (agg) => patchAgentAggregate(agentId, agg),
+            });
         });
+        void client.gateway.connect();
         return () => {
-            for (const { identifier, messageCallback } of subscriptions) {
-                client.viewer
-                    .unsubscribeFromChannel(identifier, messageCallback)
-                    .catch(() => { });
-            }
+            for (const off of offs)
+                off();
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [client, channelName, liveUpdates, agentIds.join(",")]);

package/dist/react/useMultiAgentChannelMessages.js

@@ -43,21 +43,16 @@ function useMultiAgentChannelMessages(channelName, agentIds, options) {
     (0, react_1.useEffect)(() => {
         if (!liveUpdates || agentIds.length === 0)
             return;
-        const subscriptions = agentIds.map((agentId) => {
-            const identifier = { agentId, channelName };
-            const messageCallback = (_id, message) => {
-                prependMessage(message);
-            };
-            const aggregateCallback = () => { };
-            void client.viewer.subscribeToChannel(identifier, messageCallback, aggregateCallback);
-            return { identifier, messageCallback };
+        const offs = agentIds.map((agentId) => {
+            const channel = { agent_id: agentId, name: channelName };
+            return client.gateway.subscribeToChannel(channel, {
+                onMessage: (msg) => prependMessage(msg),
+            });
         });
+        void client.gateway.connect();
         return () => {
-            for (const { identifier, messageCallback } of subscriptions) {
-                client.viewer
-                    .unsubscribeFromChannel(identifier, messageCallback)
-                    .catch(() => { });
-            }
+            for (const off of offs)
+                off();
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [client, channelName, liveUpdates, agentIds.join(",")]);

package/dist/react/useSendMessage.js

@@ -11,6 +11,11 @@ const context_1 = require("./context");
 function useSendMessage(identifier) {
     const client = (0, context_1.useDooverClient)();
     return (0, react_query_1.useMutation)({
-        mutationFn: (data) => client.viewer.sendMessage(identifier, data),
+        mutationFn: (data) => {
+            if (!identifier.agentId || !identifier.channelName) {
+                return Promise.reject(new Error("Identifier must include agentId and channelName"));
+            }
+            return client.messages.postMessage({ agentId: identifier.agentId, channelName: identifier.channelName }, { data: data });
+        },
     });
 }

package/dist/react/useSendRpc.js

@@ -115,7 +115,10 @@ function useSendRpc(identifier, options) {
                         ? { app_key: options.app_key }
                         : {}),
             };
-            return client.viewer.sendRPC(identifier, rpcRequest, {
+            if (!identifier.agentId || !identifier.channelName) {
+                throw new Error("Identifier must include agentId and channelName");
+            }
+            return client.rpc.send({ agentId: identifier.agentId, channelName: identifier.channelName }, rpcRequest, {
                 onStatus: (status) => appendStatus(commandId, status),
             });
         },

package/dist/react/useUpdateAggregate.js

@@ -16,9 +16,15 @@ function useUpdateAggregate(identifier, options) {
     const replace = options?.replace ?? false;
     const params = options?.params;
     return (0, react_query_1.useMutation)({
-        mutationFn: (data) => (replace
-            ? client.viewer.putAggregate(identifier, data, params)
-            : client.viewer.updateAggregate(identifier, data, params)),
+        mutationFn: (data) => {
+            if (!identifier.agentId || !identifier.channelName) {
+                return Promise.reject(new Error("Identifier must include agentId and channelName"));
+            }
+            const id = { agentId: identifier.agentId, channelName: identifier.channelName };
+            return (replace
+                ? client.aggregates.putAggregate(id, data, params)
+                : client.aggregates.patchAggregate(id, data, params));
+        },
         onSuccess: (aggregate) => {
             queryClient.setQueryData((0, useChannelAggregate_1.channelAggregateQueryKey)(identifier.agentId, identifier.channelName), aggregate);
         },

package/dist/rpc/errors.d.ts

@@ -0,0 +1,10 @@
+import type { RpcRequest, RpcStatus } from "../types/common";
+export declare class DooverRpcError extends Error {
+    readonly status: RpcStatus<unknown> & {
+        code: "error";
+    };
+    readonly request: RpcRequest;
+    constructor(status: RpcStatus<unknown> & {
+        code: "error";
+    }, request: RpcRequest);
+}

package/dist/rpc/errors.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DooverRpcError = void 0;
+class DooverRpcError extends Error {
+    constructor(status, request) {
+        const text = typeof status.message === "string"
+            ? status.message
+            : (() => {
+                try {
+                    return JSON.stringify(status.message);
+                }
+                catch {
+                    return "Unknown RPC error";
+                }
+            })();
+        super(text);
+        this.name = "DooverRpcError";
+        this.status = status;
+        this.request = request;
+        Object.setPrototypeOf(this, DooverRpcError.prototype);
+    }
+}
+exports.DooverRpcError = DooverRpcError;

package/dist/rpc/rpc-dispatcher.d.ts

@@ -0,0 +1,28 @@
+import type { MessagesApi } from "../apis/messages-api";
+import type { DooverStatsCollector } from "../client/stats";
+import type { GatewayClient } from "../gateway/gateway-client";
+import type { RpcRequest, RpcStatus } from "../types/common";
+export interface SendRpcOptions<TPending = undefined> {
+    onStatus?: (status: RpcStatus<TPending>) => void;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+interface ChannelIdentifierLike {
+    agentId: string;
+    channelName: string;
+}
+export declare class RpcDispatcher {
+    private readonly gateway;
+    private readonly messages;
+    private pending;
+    private channelRefs;
+    private stats;
+    constructor(gateway: GatewayClient, messages: MessagesApi);
+    setStats(collector: DooverStatsCollector | null): void;
+    send<TReq = object, TRes = object, TPending = undefined>(channel: ChannelIdentifierLike, request: RpcRequest<TReq>, options?: SendRpcOptions<TPending>): Promise<TRes>;
+    private acquireChannel;
+    private releaseChannel;
+    private route;
+    private settle;
+}
+export {};

package/dist/rpc/rpc-dispatcher.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcDispatcher = void 0;
+const errors_1 = require("./errors");
+function isRpcMessageData(data) {
+    return (typeof data === "object" &&
+        data !== null &&
+        "status" in data &&
+        "method" in data &&
+        "request" in data);
+}
+class RpcDispatcher {
+    constructor(gateway, messages) {
+        this.gateway = gateway;
+        this.messages = messages;
+        this.pending = new Map();
+        this.channelRefs = new Map();
+        this.stats = null;
+    }
+    setStats(collector) {
+        this.stats = collector;
+    }
+    send(channel, request, options) {
+        return new Promise((resolve, reject) => {
+            const channelRef = {
+                agent_id: channel.agentId,
+                name: channel.channelName,
+            };
+            const channelKey = `${channelRef.agent_id}/${channelRef.name}`;
+            this.acquireChannel(channelKey, channelRef);
+            const startedAt = this.stats?.recordRpcStart() ?? null;
+            this.messages
+                .postMessage(channel.agentId, channel.channelName, {
+                type: "rpc",
+                ...request,
+            })
+                .then((message) => {
+                const pending = {
+                    resolve: resolve,
+                    reject,
+                    onStatus: options?.onStatus,
+                    request: request,
+                    channelKey,
+                    channel: channelRef,
+                    startedAt,
+                };
+                if (options?.signal) {
+                    const onAbort = () => this.settle(message.id, "abort", undefined, options.signal?.reason);
+                    if (options.signal.aborted) {
+                        this.releaseChannel(channelKey);
+                        this.stats?.recordRpcEnd(startedAt, "abort");
+                        reject(options.signal.reason ?? new Error("Aborted"));
+                        return;
+                    }
+                    options.signal.addEventListener("abort", onAbort);
+                    pending.signal = options.signal;
+                    pending.abortListener = onAbort;
+                }
+                if (options?.timeoutMs !== undefined) {
+                    pending.timer = setTimeout(() => {
+                        this.settle(message.id, "timeout", undefined, new Error("RPC timed out"));
+                    }, options.timeoutMs);
+                }
+                this.pending.set(message.id, pending);
+            })
+                .catch((err) => {
+                // postMessage failed before we registered pending — release and reject.
+                this.releaseChannel(channelKey);
+                this.stats?.recordRpcEnd(startedAt, "error");
+                reject(err);
+            });
+        });
+    }
+    acquireChannel(channelKey, channelRef) {
+        const existing = this.channelRefs.get(channelKey);
+        if (existing) {
+            existing.refCount += 1;
+            return;
+        }
+        const handlers = {
+            onMessageUpdate: (msg, requestData) => this.route(msg, requestData),
+        };
+        const unsubscribe = this.gateway.subscribeToChannel(channelRef, handlers);
+        this.channelRefs.set(channelKey, { unsubscribe, refCount: 1 });
+    }
+    releaseChannel(channelKey) {
+        const entry = this.channelRefs.get(channelKey);
+        if (!entry)
+            return;
+        entry.refCount -= 1;
+        if (entry.refCount <= 0) {
+            entry.unsubscribe();
+            this.channelRefs.delete(channelKey);
+        }
+    }
+    route(msg, _requestData) {
+        const pending = this.pending.get(msg.id);
+        if (!pending)
+            return;
+        if (!isRpcMessageData(msg.data))
+            return;
+        const status = msg.data.status;
+        pending.onStatus?.(status);
+        if (status.code === "success") {
+            this.settle(msg.id, "success", msg.data.response);
+        }
+        else if (status.code === "error") {
+            this.settle(msg.id, "error", undefined, new errors_1.DooverRpcError(status, pending.request));
+        }
+    }
+    settle(messageId, outcome, response, rejection) {
+        const pending = this.pending.get(messageId);
+        if (!pending)
+            return;
+        this.pending.delete(messageId);
+        if (pending.timer)
+            clearTimeout(pending.timer);
+        if (pending.signal && pending.abortListener) {
+            pending.signal.removeEventListener("abort", pending.abortListener);
+        }
+        this.releaseChannel(pending.channelKey);
+        this.stats?.recordRpcEnd(pending.startedAt, outcome);
+        if (outcome === "success")
+            pending.resolve(response);
+        else
+            pending.reject(rejection);
+    }
+}
+exports.RpcDispatcher = RpcDispatcher;

package/dist/test/api-args.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/api-args.test.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const _args_1 = require("../apis/_args");
+describe("resolveChannelArgs", () => {
+    it("parses positional (agentId, channelName)", () => {
+        const result = (0, _args_1.resolveChannelArgs)(["a1", "c1"]);
+        (0, chai_1.expect)(result).to.deep.equal({ agentId: "a1", channelName: "c1", options: undefined });
+    });
+    it("parses positional with options", () => {
+        const result = (0, _args_1.resolveChannelArgs)(["a1", "c1", { x: 7 }]);
+        (0, chai_1.expect)(result).to.deep.equal({ agentId: "a1", channelName: "c1", options: { x: 7 } });
+    });
+    it("parses identifier object", () => {
+        const result = (0, _args_1.resolveChannelArgs)([
+            { agentId: "a1", channelName: "c1" },
+        ]);
+        (0, chai_1.expect)(result).to.deep.equal({ agentId: "a1", channelName: "c1", options: undefined });
+    });
+    it("parses identifier object with options", () => {
+        const result = (0, _args_1.resolveChannelArgs)([
+            { agentId: "a1", channelName: "c1" },
+            { x: 7 },
+        ]);
+        (0, chai_1.expect)(result).to.deep.equal({ agentId: "a1", channelName: "c1", options: { x: 7 } });
+    });
+});
+describe("resolveAgentArgs", () => {
+    it("parses positional agentId", () => {
+        const result = (0, _args_1.resolveAgentArgs)(["a1"]);
+        (0, chai_1.expect)(result).to.deep.equal({ agentId: "a1", options: undefined });
+    });
+    it("parses positional with options", () => {
+        const result = (0, _args_1.resolveAgentArgs)(["a1", { archived: true }]);
+        (0, chai_1.expect)(result).to.deep.equal({ agentId: "a1", options: { archived: true } });
+    });
+    it("parses identifier object", () => {
+        const result = (0, _args_1.resolveAgentArgs)([{ agentId: "a1" }]);
+        (0, chai_1.expect)(result).to.deep.equal({ agentId: "a1", options: undefined });
+    });
+    it("parses identifier object with options", () => {
+        const result = (0, _args_1.resolveAgentArgs)([
+            { agentId: "a1" },
+            { archived: true },
+        ]);
+        (0, chai_1.expect)(result).to.deep.equal({ agentId: "a1", options: { archived: true } });
+    });
+});

package/dist/test/api-overloads.test.d.ts

@@ -0,0 +1,9 @@
+import type { RestClient } from "../http/rest-client";
+interface RecordedCall {
+    method: "get" | "post" | "put" | "patch" | "delete" | "request";
+    args: unknown[];
+}
+export declare function makeRestStub(): RestClient & {
+    calls: RecordedCall[];
+};
+export {};