clawdbot 2026.1.4-1

package/dist/agents/tools/sessions-list-tool.js

@@ -0,0 +1,143 @@
+import path from "node:path";
+import { Type } from "@sinclair/typebox";
+import { loadConfig } from "../../config/config.js";
+import { callGateway } from "../../gateway/call.js";
+import { jsonResult, readStringArrayParam } from "./common.js";
+import { classifySessionKind, deriveProvider, resolveDisplaySessionKey, resolveInternalSessionKey, resolveMainSessionAlias, stripToolMessages, } from "./sessions-helpers.js";
+const SessionsListToolSchema = Type.Object({
+    kinds: Type.Optional(Type.Array(Type.String())),
+    limit: Type.Optional(Type.Integer({ minimum: 1 })),
+    activeMinutes: Type.Optional(Type.Integer({ minimum: 1 })),
+    messageLimit: Type.Optional(Type.Integer({ minimum: 0 })),
+});
+export function createSessionsListTool() {
+    return {
+        label: "Sessions",
+        name: "sessions_list",
+        description: "List sessions with optional filters and last messages.",
+        parameters: SessionsListToolSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            const cfg = loadConfig();
+            const { mainKey, alias } = resolveMainSessionAlias(cfg);
+            const kindsRaw = readStringArrayParam(params, "kinds")?.map((value) => value.trim().toLowerCase());
+            const allowedKindsList = (kindsRaw ?? []).filter((value) => ["main", "group", "cron", "hook", "node", "other"].includes(value));
+            const allowedKinds = allowedKindsList.length
+                ? new Set(allowedKindsList)
+                : undefined;
+            const limit = typeof params.limit === "number" && Number.isFinite(params.limit)
+                ? Math.max(1, Math.floor(params.limit))
+                : undefined;
+            const activeMinutes = typeof params.activeMinutes === "number" &&
+                Number.isFinite(params.activeMinutes)
+                ? Math.max(1, Math.floor(params.activeMinutes))
+                : undefined;
+            const messageLimitRaw = typeof params.messageLimit === "number" &&
+                Number.isFinite(params.messageLimit)
+                ? Math.max(0, Math.floor(params.messageLimit))
+                : 0;
+            const messageLimit = Math.min(messageLimitRaw, 20);
+            const list = (await callGateway({
+                method: "sessions.list",
+                params: {
+                    limit,
+                    activeMinutes,
+                    includeGlobal: true,
+                    includeUnknown: true,
+                },
+            }));
+            const sessions = Array.isArray(list?.sessions) ? list.sessions : [];
+            const storePath = typeof list?.path === "string" ? list.path : undefined;
+            const rows = [];
+            for (const entry of sessions) {
+                if (!entry || typeof entry !== "object")
+                    continue;
+                const key = typeof entry.key === "string" ? entry.key : "";
+                if (!key)
+                    continue;
+                if (key === "unknown")
+                    continue;
+                if (key === "global" && alias !== "global")
+                    continue;
+                const gatewayKind = typeof entry.kind === "string" ? entry.kind : undefined;
+                const kind = classifySessionKind({ key, gatewayKind, alias, mainKey });
+                if (allowedKinds && !allowedKinds.has(kind))
+                    continue;
+                const displayKey = resolveDisplaySessionKey({
+                    key,
+                    alias,
+                    mainKey,
+                });
+                const surface = typeof entry.surface === "string" ? entry.surface : undefined;
+                const lastChannel = typeof entry.lastChannel === "string" ? entry.lastChannel : undefined;
+                const provider = deriveProvider({
+                    key,
+                    kind,
+                    surface,
+                    lastChannel,
+                });
+                const sessionId = typeof entry.sessionId === "string" ? entry.sessionId : undefined;
+                const transcriptPath = sessionId && storePath
+                    ? path.join(path.dirname(storePath), `${sessionId}.jsonl`)
+                    : undefined;
+                const row = {
+                    key: displayKey,
+                    kind,
+                    provider,
+                    displayName: typeof entry.displayName === "string"
+                        ? entry.displayName
+                        : undefined,
+                    updatedAt: typeof entry.updatedAt === "number" ? entry.updatedAt : undefined,
+                    sessionId,
+                    model: typeof entry.model === "string" ? entry.model : undefined,
+                    contextTokens: typeof entry.contextTokens === "number"
+                        ? entry.contextTokens
+                        : undefined,
+                    totalTokens: typeof entry.totalTokens === "number"
+                        ? entry.totalTokens
+                        : undefined,
+                    thinkingLevel: typeof entry.thinkingLevel === "string"
+                        ? entry.thinkingLevel
+                        : undefined,
+                    verboseLevel: typeof entry.verboseLevel === "string"
+                        ? entry.verboseLevel
+                        : undefined,
+                    systemSent: typeof entry.systemSent === "boolean"
+                        ? entry.systemSent
+                        : undefined,
+                    abortedLastRun: typeof entry.abortedLastRun === "boolean"
+                        ? entry.abortedLastRun
+                        : undefined,
+                    sendPolicy: typeof entry.sendPolicy === "string" ? entry.sendPolicy : undefined,
+                    lastChannel,
+                    lastTo: typeof entry.lastTo === "string" ? entry.lastTo : undefined,
+                    transcriptPath,
+                };
+                if (messageLimit > 0) {
+                    const resolvedKey = resolveInternalSessionKey({
+                        key: displayKey,
+                        alias,
+                        mainKey,
+                    });
+                    const history = (await callGateway({
+                        method: "chat.history",
+                        params: { sessionKey: resolvedKey, limit: messageLimit },
+                    }));
+                    const rawMessages = Array.isArray(history?.messages)
+                        ? history.messages
+                        : [];
+                    const filtered = stripToolMessages(rawMessages);
+                    row.messages =
+                        filtered.length > messageLimit
+                            ? filtered.slice(-messageLimit)
+                            : filtered;
+                }
+                rows.push(row);
+            }
+            return jsonResult({
+                count: rows.length,
+                sessions: rows,
+            });
+        },
+    };
+}

package/dist/agents/tools/sessions-send-helpers.js

@@ -0,0 +1,100 @@
+const ANNOUNCE_SKIP_TOKEN = "ANNOUNCE_SKIP";
+const REPLY_SKIP_TOKEN = "REPLY_SKIP";
+const DEFAULT_PING_PONG_TURNS = 5;
+const MAX_PING_PONG_TURNS = 5;
+export function resolveAnnounceTargetFromKey(sessionKey) {
+    const parts = sessionKey.split(":").filter(Boolean);
+    if (parts.length < 3)
+        return null;
+    const [surface, kind, ...rest] = parts;
+    if (kind !== "group" && kind !== "channel")
+        return null;
+    const id = rest.join(":").trim();
+    if (!id)
+        return null;
+    if (!surface)
+        return null;
+    const channel = surface.toLowerCase();
+    if (channel === "discord") {
+        return { channel, to: `channel:${id}` };
+    }
+    if (channel === "signal") {
+        return { channel, to: `group:${id}` };
+    }
+    return { channel, to: id };
+}
+export function buildAgentToAgentMessageContext(params) {
+    const lines = [
+        "Agent-to-agent message context:",
+        params.requesterSessionKey
+            ? `Agent 1 (requester) session: ${params.requesterSessionKey}.`
+            : undefined,
+        params.requesterSurface
+            ? `Agent 1 (requester) surface: ${params.requesterSurface}.`
+            : undefined,
+        `Agent 2 (target) session: ${params.targetSessionKey}.`,
+    ].filter(Boolean);
+    return lines.join("\n");
+}
+export function buildAgentToAgentReplyContext(params) {
+    const currentLabel = params.currentRole === "requester"
+        ? "Agent 1 (requester)"
+        : "Agent 2 (target)";
+    const lines = [
+        "Agent-to-agent reply step:",
+        `Current agent: ${currentLabel}.`,
+        `Turn ${params.turn} of ${params.maxTurns}.`,
+        params.requesterSessionKey
+            ? `Agent 1 (requester) session: ${params.requesterSessionKey}.`
+            : undefined,
+        params.requesterSurface
+            ? `Agent 1 (requester) surface: ${params.requesterSurface}.`
+            : undefined,
+        `Agent 2 (target) session: ${params.targetSessionKey}.`,
+        params.targetChannel
+            ? `Agent 2 (target) surface: ${params.targetChannel}.`
+            : undefined,
+        `If you want to stop the ping-pong, reply exactly "${REPLY_SKIP_TOKEN}".`,
+    ].filter(Boolean);
+    return lines.join("\n");
+}
+export function buildAgentToAgentAnnounceContext(params) {
+    const lines = [
+        "Agent-to-agent announce step:",
+        params.requesterSessionKey
+            ? `Agent 1 (requester) session: ${params.requesterSessionKey}.`
+            : undefined,
+        params.requesterSurface
+            ? `Agent 1 (requester) surface: ${params.requesterSurface}.`
+            : undefined,
+        `Agent 2 (target) session: ${params.targetSessionKey}.`,
+        params.targetChannel
+            ? `Agent 2 (target) surface: ${params.targetChannel}.`
+            : undefined,
+        `Original request: ${params.originalMessage}`,
+        params.roundOneReply
+            ? `Round 1 reply: ${params.roundOneReply}`
+            : "Round 1 reply: (not available).",
+        params.latestReply
+            ? `Latest reply: ${params.latestReply}`
+            : "Latest reply: (not available).",
+        `If you want to remain silent, reply exactly "${ANNOUNCE_SKIP_TOKEN}".`,
+        "Any other reply will be posted to the target channel.",
+        "After this reply, the agent-to-agent conversation is over.",
+    ].filter(Boolean);
+    return lines.join("\n");
+}
+export function isAnnounceSkip(text) {
+    return (text ?? "").trim() === ANNOUNCE_SKIP_TOKEN;
+}
+export function isReplySkip(text) {
+    return (text ?? "").trim() === REPLY_SKIP_TOKEN;
+}
+export function resolvePingPongTurns(cfg) {
+    const raw = cfg?.session?.agentToAgent?.maxPingPongTurns;
+    const fallback = DEFAULT_PING_PONG_TURNS;
+    if (typeof raw !== "number" || !Number.isFinite(raw))
+        return fallback;
+    const rounded = Math.floor(raw);
+    return Math.max(0, Math.min(MAX_PING_PONG_TURNS, rounded));
+}

package/dist/agents/tools/sessions-send-tool.js

@@ -0,0 +1,347 @@
+import crypto from "node:crypto";
+import { Type } from "@sinclair/typebox";
+import { loadConfig } from "../../config/config.js";
+import { callGateway } from "../../gateway/call.js";
+import { jsonResult, readStringParam } from "./common.js";
+import { extractAssistantText, resolveDisplaySessionKey, resolveInternalSessionKey, resolveMainSessionAlias, stripToolMessages, } from "./sessions-helpers.js";
+import { buildAgentToAgentAnnounceContext, buildAgentToAgentMessageContext, buildAgentToAgentReplyContext, isAnnounceSkip, isReplySkip, resolveAnnounceTargetFromKey, resolvePingPongTurns, } from "./sessions-send-helpers.js";
+const SessionsSendToolSchema = Type.Object({
+    sessionKey: Type.String(),
+    message: Type.String(),
+    timeoutSeconds: Type.Optional(Type.Integer({ minimum: 0 })),
+});
+export function createSessionsSendTool(opts) {
+    return {
+        label: "Session Send",
+        name: "sessions_send",
+        description: "Send a message into another session.",
+        parameters: SessionsSendToolSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            const sessionKey = readStringParam(params, "sessionKey", {
+                required: true,
+            });
+            const message = readStringParam(params, "message", { required: true });
+            const cfg = loadConfig();
+            const { mainKey, alias } = resolveMainSessionAlias(cfg);
+            const resolvedKey = resolveInternalSessionKey({
+                key: sessionKey,
+                alias,
+                mainKey,
+            });
+            const timeoutSeconds = typeof params.timeoutSeconds === "number" &&
+                Number.isFinite(params.timeoutSeconds)
+                ? Math.max(0, Math.floor(params.timeoutSeconds))
+                : 30;
+            const timeoutMs = timeoutSeconds * 1000;
+            const announceTimeoutMs = timeoutSeconds === 0 ? 30_000 : timeoutMs;
+            const idempotencyKey = crypto.randomUUID();
+            let runId = idempotencyKey;
+            const displayKey = resolveDisplaySessionKey({
+                key: sessionKey,
+                alias,
+                mainKey,
+            });
+            const agentMessageContext = buildAgentToAgentMessageContext({
+                requesterSessionKey: opts?.agentSessionKey,
+                requesterSurface: opts?.agentSurface,
+                targetSessionKey: displayKey,
+            });
+            const sendParams = {
+                message,
+                sessionKey: resolvedKey,
+                idempotencyKey,
+                deliver: false,
+                lane: "nested",
+                extraSystemPrompt: agentMessageContext,
+            };
+            const requesterSessionKey = opts?.agentSessionKey;
+            const requesterSurface = opts?.agentSurface;
+            const maxPingPongTurns = resolvePingPongTurns(cfg);
+            const resolveAnnounceTarget = async () => {
+                const parsed = resolveAnnounceTargetFromKey(resolvedKey);
+                if (parsed)
+                    return parsed;
+                try {
+                    const list = (await callGateway({
+                        method: "sessions.list",
+                        params: {
+                            includeGlobal: true,
+                            includeUnknown: true,
+                            limit: 200,
+                        },
+                    }));
+                    const sessions = Array.isArray(list?.sessions) ? list.sessions : [];
+                    const match = sessions.find((entry) => entry?.key === resolvedKey) ??
+                        sessions.find((entry) => entry?.key === displayKey);
+                    const channel = typeof match?.lastChannel === "string"
+                        ? match.lastChannel
+                        : undefined;
+                    const to = typeof match?.lastTo === "string" ? match.lastTo : undefined;
+                    if (channel && to)
+                        return { channel, to };
+                }
+                catch {
+                    // ignore; fall through to null
+                }
+                return null;
+            };
+            const readLatestAssistantReply = async (sessionKeyToRead) => {
+                const history = (await callGateway({
+                    method: "chat.history",
+                    params: { sessionKey: sessionKeyToRead, limit: 50 },
+                }));
+                const filtered = stripToolMessages(Array.isArray(history?.messages) ? history.messages : []);
+                const last = filtered.length > 0 ? filtered[filtered.length - 1] : undefined;
+                return last ? extractAssistantText(last) : undefined;
+            };
+            const runAgentStep = async (step) => {
+                const stepIdem = crypto.randomUUID();
+                const response = (await callGateway({
+                    method: "agent",
+                    params: {
+                        message: step.message,
+                        sessionKey: step.sessionKey,
+                        idempotencyKey: stepIdem,
+                        deliver: false,
+                        lane: "nested",
+                        extraSystemPrompt: step.extraSystemPrompt,
+                    },
+                    timeoutMs: 10_000,
+                }));
+                const stepRunId = typeof response?.runId === "string" && response.runId
+                    ? response.runId
+                    : stepIdem;
+                const stepAcceptedAt = typeof response?.acceptedAt === "number"
+                    ? response.acceptedAt
+                    : undefined;
+                const stepWaitMs = Math.min(step.timeoutMs, 60_000);
+                const wait = (await callGateway({
+                    method: "agent.wait",
+                    params: {
+                        runId: stepRunId,
+                        afterMs: stepAcceptedAt,
+                        timeoutMs: stepWaitMs,
+                    },
+                    timeoutMs: stepWaitMs + 2000,
+                }));
+                if (wait?.status !== "ok")
+                    return undefined;
+                return readLatestAssistantReply(step.sessionKey);
+            };
+            const runAgentToAgentFlow = async (roundOneReply, runInfo) => {
+                try {
+                    let primaryReply = roundOneReply;
+                    let latestReply = roundOneReply;
+                    if (!primaryReply && runInfo?.runId) {
+                        const waitMs = Math.min(announceTimeoutMs, 60_000);
+                        const wait = (await callGateway({
+                            method: "agent.wait",
+                            params: {
+                                runId: runInfo.runId,
+                                afterMs: runInfo.acceptedAt,
+                                timeoutMs: waitMs,
+                            },
+                            timeoutMs: waitMs + 2000,
+                        }));
+                        if (wait?.status === "ok") {
+                            primaryReply = await readLatestAssistantReply(resolvedKey);
+                            latestReply = primaryReply;
+                        }
+                    }
+                    if (!latestReply)
+                        return;
+                    const announceTarget = await resolveAnnounceTarget();
+                    const targetChannel = announceTarget?.channel ?? "unknown";
+                    if (maxPingPongTurns > 0 &&
+                        requesterSessionKey &&
+                        requesterSessionKey !== resolvedKey) {
+                        let currentSessionKey = requesterSessionKey;
+                        let nextSessionKey = resolvedKey;
+                        let incomingMessage = latestReply;
+                        for (let turn = 1; turn <= maxPingPongTurns; turn += 1) {
+                            const currentRole = currentSessionKey === requesterSessionKey
+                                ? "requester"
+                                : "target";
+                            const replyPrompt = buildAgentToAgentReplyContext({
+                                requesterSessionKey,
+                                requesterSurface,
+                                targetSessionKey: displayKey,
+                                targetChannel,
+                                currentRole,
+                                turn,
+                                maxTurns: maxPingPongTurns,
+                            });
+                            const replyText = await runAgentStep({
+                                sessionKey: currentSessionKey,
+                                message: incomingMessage,
+                                extraSystemPrompt: replyPrompt,
+                                timeoutMs: announceTimeoutMs,
+                            });
+                            if (!replyText || isReplySkip(replyText)) {
+                                break;
+                            }
+                            latestReply = replyText;
+                            incomingMessage = replyText;
+                            const swap = currentSessionKey;
+                            currentSessionKey = nextSessionKey;
+                            nextSessionKey = swap;
+                        }
+                    }
+                    const announcePrompt = buildAgentToAgentAnnounceContext({
+                        requesterSessionKey,
+                        requesterSurface,
+                        targetSessionKey: displayKey,
+                        targetChannel,
+                        originalMessage: message,
+                        roundOneReply: primaryReply,
+                        latestReply,
+                    });
+                    const announceReply = await runAgentStep({
+                        sessionKey: resolvedKey,
+                        message: "Agent-to-agent announce step.",
+                        extraSystemPrompt: announcePrompt,
+                        timeoutMs: announceTimeoutMs,
+                    });
+                    if (announceTarget &&
+                        announceReply &&
+                        announceReply.trim() &&
+                        !isAnnounceSkip(announceReply)) {
+                        await callGateway({
+                            method: "send",
+                            params: {
+                                to: announceTarget.to,
+                                message: announceReply.trim(),
+                                provider: announceTarget.channel,
+                                idempotencyKey: crypto.randomUUID(),
+                            },
+                            timeoutMs: 10_000,
+                        });
+                    }
+                }
+                catch {
+                    // Best-effort follow-ups; ignore failures to avoid breaking the caller response.
+                }
+            };
+            if (timeoutSeconds === 0) {
+                try {
+                    const response = (await callGateway({
+                        method: "agent",
+                        params: sendParams,
+                        timeoutMs: 10_000,
+                    }));
+                    const acceptedAt = typeof response?.acceptedAt === "number"
+                        ? response.acceptedAt
+                        : undefined;
+                    if (typeof response?.runId === "string" && response.runId) {
+                        runId = response.runId;
+                    }
+                    void runAgentToAgentFlow(undefined, { runId, acceptedAt });
+                    return jsonResult({
+                        runId,
+                        status: "accepted",
+                        sessionKey: displayKey,
+                    });
+                }
+                catch (err) {
+                    const messageText = err instanceof Error
+                        ? err.message
+                        : typeof err === "string"
+                            ? err
+                            : "error";
+                    return jsonResult({
+                        runId,
+                        status: "error",
+                        error: messageText,
+                        sessionKey: displayKey,
+                    });
+                }
+            }
+            let acceptedAt;
+            try {
+                const response = (await callGateway({
+                    method: "agent",
+                    params: sendParams,
+                    timeoutMs: 10_000,
+                }));
+                if (typeof response?.runId === "string" && response.runId) {
+                    runId = response.runId;
+                }
+                if (typeof response?.acceptedAt === "number") {
+                    acceptedAt = response.acceptedAt;
+                }
+            }
+            catch (err) {
+                const messageText = err instanceof Error
+                    ? err.message
+                    : typeof err === "string"
+                        ? err
+                        : "error";
+                return jsonResult({
+                    runId,
+                    status: "error",
+                    error: messageText,
+                    sessionKey: displayKey,
+                });
+            }
+            let waitStatus;
+            let waitError;
+            try {
+                const wait = (await callGateway({
+                    method: "agent.wait",
+                    params: {
+                        runId,
+                        afterMs: acceptedAt,
+                        timeoutMs,
+                    },
+                    timeoutMs: timeoutMs + 2000,
+                }));
+                waitStatus = typeof wait?.status === "string" ? wait.status : undefined;
+                waitError = typeof wait?.error === "string" ? wait.error : undefined;
+            }
+            catch (err) {
+                const messageText = err instanceof Error
+                    ? err.message
+                    : typeof err === "string"
+                        ? err
+                        : "error";
+                return jsonResult({
+                    runId,
+                    status: messageText.includes("gateway timeout") ? "timeout" : "error",
+                    error: messageText,
+                    sessionKey: displayKey,
+                });
+            }
+            if (waitStatus === "timeout") {
+                return jsonResult({
+                    runId,
+                    status: "timeout",
+                    error: waitError,
+                    sessionKey: displayKey,
+                });
+            }
+            if (waitStatus === "error") {
+                return jsonResult({
+                    runId,
+                    status: "error",
+                    error: waitError ?? "agent error",
+                    sessionKey: displayKey,
+                });
+            }
+            const history = (await callGateway({
+                method: "chat.history",
+                params: { sessionKey: resolvedKey, limit: 50 },
+            }));
+            const filtered = stripToolMessages(Array.isArray(history?.messages) ? history.messages : []);
+            const last = filtered.length > 0 ? filtered[filtered.length - 1] : undefined;
+            const reply = last ? extractAssistantText(last) : undefined;
+            void runAgentToAgentFlow(reply ?? undefined);
+            return jsonResult({
+                runId,
+                status: "ok",
+                reply,
+                sessionKey: displayKey,
+            });
+        },
+    };
+}