openclawdreams 2.3.0 → 2.4.0

package/dist/openclaw/src/agents/tool-mutation.js

@@ -1,170 +0,0 @@
-const MUTATING_TOOL_NAMES = new Set([
-    "write",
-    "edit",
-    "apply_patch",
-    "exec",
-    "bash",
-    "process",
-    "message",
-    "sessions_send",
-    "cron",
-    "gateway",
-    "canvas",
-    "nodes",
-    "session_status",
-]);
-const READ_ONLY_ACTIONS = new Set([
-    "get",
-    "list",
-    "read",
-    "status",
-    "show",
-    "fetch",
-    "search",
-    "query",
-    "view",
-    "poll",
-    "log",
-    "inspect",
-    "check",
-    "probe",
-]);
-const PROCESS_MUTATING_ACTIONS = new Set(["write", "send_keys", "submit", "paste", "kill"]);
-const MESSAGE_MUTATING_ACTIONS = new Set([
-    "send",
-    "reply",
-    "thread_reply",
-    "threadreply",
-    "edit",
-    "delete",
-    "react",
-    "pin",
-    "unpin",
-]);
-function asRecord(value) {
-    return value && typeof value === "object" ? value : undefined;
-}
-function normalizeActionName(value) {
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    const normalized = value
-        .trim()
-        .toLowerCase()
-        .replace(/[\s-]+/g, "_");
-    return normalized || undefined;
-}
-function normalizeFingerprintValue(value) {
-    if (typeof value === "string") {
-        const normalized = value.trim();
-        return normalized ? normalized.toLowerCase() : undefined;
-    }
-    if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
-        return String(value).toLowerCase();
-    }
-    return undefined;
-}
-export function isLikelyMutatingToolName(toolName) {
-    const normalized = toolName.trim().toLowerCase();
-    if (!normalized) {
-        return false;
-    }
-    return (MUTATING_TOOL_NAMES.has(normalized) ||
-        normalized.endsWith("_actions") ||
-        normalized.startsWith("message_") ||
-        normalized.includes("send"));
-}
-export function isMutatingToolCall(toolName, args) {
-    const normalized = toolName.trim().toLowerCase();
-    const record = asRecord(args);
-    const action = normalizeActionName(record?.action);
-    switch (normalized) {
-        case "write":
-        case "edit":
-        case "apply_patch":
-        case "exec":
-        case "bash":
-        case "sessions_send":
-            return true;
-        case "process":
-            return action != null && PROCESS_MUTATING_ACTIONS.has(action);
-        case "message":
-            return ((action != null && MESSAGE_MUTATING_ACTIONS.has(action)) ||
-                typeof record?.content === "string" ||
-                typeof record?.message === "string");
-        case "session_status":
-            return typeof record?.model === "string" && record.model.trim().length > 0;
-        default: {
-            if (normalized === "cron" || normalized === "gateway" || normalized === "canvas") {
-                return action == null || !READ_ONLY_ACTIONS.has(action);
-            }
-            if (normalized === "nodes") {
-                return action == null || action !== "list";
-            }
-            if (normalized.endsWith("_actions")) {
-                return action == null || !READ_ONLY_ACTIONS.has(action);
-            }
-            if (normalized.startsWith("message_") || normalized.includes("send")) {
-                return true;
-            }
-            return false;
-        }
-    }
-}
-export function buildToolActionFingerprint(toolName, args, meta) {
-    if (!isMutatingToolCall(toolName, args)) {
-        return undefined;
-    }
-    const normalizedTool = toolName.trim().toLowerCase();
-    const record = asRecord(args);
-    const action = normalizeActionName(record?.action);
-    const parts = [`tool=${normalizedTool}`];
-    if (action) {
-        parts.push(`action=${action}`);
-    }
-    let hasStableTarget = false;
-    for (const key of [
-        "path",
-        "filePath",
-        "oldPath",
-        "newPath",
-        "to",
-        "target",
-        "messageId",
-        "sessionKey",
-        "jobId",
-        "id",
-        "model",
-    ]) {
-        const value = normalizeFingerprintValue(record?.[key]);
-        if (value) {
-            parts.push(`${key.toLowerCase()}=${value}`);
-            hasStableTarget = true;
-        }
-    }
-    const normalizedMeta = meta?.trim().replace(/\s+/g, " ").toLowerCase();
-    // Meta text often carries volatile details (for example "N chars").
-    // Prefer stable arg-derived keys for matching; only fall back to meta
-    // when no stable target key is available.
-    if (normalizedMeta && !hasStableTarget) {
-        parts.push(`meta=${normalizedMeta}`);
-    }
-    return parts.join("|");
-}
-export function buildToolMutationState(toolName, args, meta) {
-    const actionFingerprint = buildToolActionFingerprint(toolName, args, meta);
-    return {
-        mutatingAction: actionFingerprint != null,
-        actionFingerprint,
-    };
-}
-export function isSameToolMutationAction(existing, next) {
-    if (existing.actionFingerprint != null || next.actionFingerprint != null) {
-        // For mutating flows, fail closed: only clear when both fingerprints exist and match.
-        return (existing.actionFingerprint != null &&
-            next.actionFingerprint != null &&
-            existing.actionFingerprint === next.actionFingerprint);
-    }
-    return existing.toolName === next.toolName && (existing.meta ?? "") === (next.meta ?? "");
-}
-//# sourceMappingURL=tool-mutation.js.map

package/dist/openclaw/src/agents/tool-policy-pipeline.d.ts

@@ -1,28 +0,0 @@
-import type { AnyAgentTool } from "./pi-tools.types.js";
-import { type ToolPolicyLike } from "./tool-policy.js";
-export type ToolPolicyPipelineStep = {
-    policy: ToolPolicyLike | undefined;
-    label: string;
-    stripPluginOnlyAllowlist?: boolean;
-};
-export declare function buildDefaultToolPolicyPipelineSteps(params: {
-    profilePolicy?: ToolPolicyLike;
-    profile?: string;
-    providerProfilePolicy?: ToolPolicyLike;
-    providerProfile?: string;
-    globalPolicy?: ToolPolicyLike;
-    globalProviderPolicy?: ToolPolicyLike;
-    agentPolicy?: ToolPolicyLike;
-    agentProviderPolicy?: ToolPolicyLike;
-    groupPolicy?: ToolPolicyLike;
-    agentId?: string;
-}): ToolPolicyPipelineStep[];
-export declare function applyToolPolicyPipeline(params: {
-    tools: AnyAgentTool[];
-    toolMeta: (tool: AnyAgentTool) => {
-        pluginId: string;
-    } | undefined;
-    warn: (message: string) => void;
-    steps: ToolPolicyPipelineStep[];
-}): AnyAgentTool[];
-//# sourceMappingURL=tool-policy-pipeline.d.ts.map

package/dist/openclaw/src/agents/tool-policy-pipeline.js

@@ -1,70 +0,0 @@
-import { filterToolsByPolicy } from "./pi-tools.policy.js";
-import { buildPluginToolGroups, expandPolicyWithPluginGroups, normalizeToolName, stripPluginOnlyAllowlist, } from "./tool-policy.js";
-export function buildDefaultToolPolicyPipelineSteps(params) {
-    const agentId = params.agentId?.trim();
-    const profile = params.profile?.trim();
-    const providerProfile = params.providerProfile?.trim();
-    return [
-        {
-            policy: params.profilePolicy,
-            label: profile ? `tools.profile (${profile})` : "tools.profile",
-            stripPluginOnlyAllowlist: true,
-        },
-        {
-            policy: params.providerProfilePolicy,
-            label: providerProfile
-                ? `tools.byProvider.profile (${providerProfile})`
-                : "tools.byProvider.profile",
-            stripPluginOnlyAllowlist: true,
-        },
-        { policy: params.globalPolicy, label: "tools.allow", stripPluginOnlyAllowlist: true },
-        {
-            policy: params.globalProviderPolicy,
-            label: "tools.byProvider.allow",
-            stripPluginOnlyAllowlist: true,
-        },
-        {
-            policy: params.agentPolicy,
-            label: agentId ? `agents.${agentId}.tools.allow` : "agent tools.allow",
-            stripPluginOnlyAllowlist: true,
-        },
-        {
-            policy: params.agentProviderPolicy,
-            label: agentId ? `agents.${agentId}.tools.byProvider.allow` : "agent tools.byProvider.allow",
-            stripPluginOnlyAllowlist: true,
-        },
-        { policy: params.groupPolicy, label: "group tools.allow", stripPluginOnlyAllowlist: true },
-    ];
-}
-export function applyToolPolicyPipeline(params) {
-    const coreToolNames = new Set(params.tools
-        .filter((tool) => !params.toolMeta(tool))
-        .map((tool) => normalizeToolName(tool.name))
-        .filter(Boolean));
-    const pluginGroups = buildPluginToolGroups({
-        tools: params.tools,
-        toolMeta: params.toolMeta,
-    });
-    let filtered = params.tools;
-    for (const step of params.steps) {
-        if (!step.policy) {
-            continue;
-        }
-        let policy = step.policy;
-        if (step.stripPluginOnlyAllowlist) {
-            const resolved = stripPluginOnlyAllowlist(policy, pluginGroups, coreToolNames);
-            if (resolved.unknownAllowlist.length > 0) {
-                const entries = resolved.unknownAllowlist.join(", ");
-                const suffix = resolved.strippedAllowlist
-                    ? "Ignoring allowlist so core tools remain available. Use tools.alsoAllow for additive plugin tool enablement."
-                    : "These entries won't match any tool unless the plugin is enabled.";
-                params.warn(`tools: ${step.label} allowlist contains unknown entries (${entries}). ${suffix}`);
-            }
-            policy = resolved.policy;
-        }
-        const expanded = expandPolicyWithPluginGroups(policy, pluginGroups);
-        filtered = expanded ? filterToolsByPolicy(filtered, expanded) : filtered;
-    }
-    return filtered;
-}
-//# sourceMappingURL=tool-policy-pipeline.js.map

package/dist/openclaw/src/agents/tool-policy-shared.d.ts

@@ -1,12 +0,0 @@
-import { type ToolProfileId } from "./tool-catalog.js";
-type ToolProfilePolicy = {
-    allow?: string[];
-    deny?: string[];
-};
-export declare const TOOL_GROUPS: Record<string, string[]>;
-export declare function normalizeToolName(name: string): string;
-export declare function normalizeToolList(list?: string[]): string[];
-export declare function expandToolGroups(list?: string[]): string[];
-export declare function resolveToolProfilePolicy(profile?: string): ToolProfilePolicy | undefined;
-export type { ToolProfileId };
-//# sourceMappingURL=tool-policy-shared.d.ts.map

package/dist/openclaw/src/agents/tool-policy-shared.js

@@ -1,33 +0,0 @@
-import { CORE_TOOL_GROUPS, resolveCoreToolProfilePolicy, } from "./tool-catalog.js";
-const TOOL_NAME_ALIASES = {
-    bash: "exec",
-    "apply-patch": "apply_patch",
-};
-export const TOOL_GROUPS = { ...CORE_TOOL_GROUPS };
-export function normalizeToolName(name) {
-    const normalized = name.trim().toLowerCase();
-    return TOOL_NAME_ALIASES[normalized] ?? normalized;
-}
-export function normalizeToolList(list) {
-    if (!list) {
-        return [];
-    }
-    return list.map(normalizeToolName).filter(Boolean);
-}
-export function expandToolGroups(list) {
-    const normalized = normalizeToolList(list);
-    const expanded = [];
-    for (const value of normalized) {
-        const group = TOOL_GROUPS[value];
-        if (group) {
-            expanded.push(...group);
-            continue;
-        }
-        expanded.push(value);
-    }
-    return Array.from(new Set(expanded));
-}
-export function resolveToolProfilePolicy(profile) {
-    return resolveCoreToolProfilePolicy(profile);
-}
-//# sourceMappingURL=tool-policy-shared.js.map

package/dist/openclaw/src/agents/tool-policy.d.ts

@@ -1,34 +0,0 @@
-import type { AnyAgentTool } from "./tools/common.js";
-export { expandToolGroups, normalizeToolList, normalizeToolName, resolveToolProfilePolicy, TOOL_GROUPS, } from "./tool-policy-shared.js";
-export type { ToolProfileId } from "./tool-policy-shared.js";
-export declare function isOwnerOnlyToolName(name: string): boolean;
-export declare function applyOwnerOnlyToolPolicy(tools: AnyAgentTool[], senderIsOwner: boolean): AnyAgentTool[];
-export type ToolPolicyLike = {
-    allow?: string[];
-    deny?: string[];
-};
-export type PluginToolGroups = {
-    all: string[];
-    byPlugin: Map<string, string[]>;
-};
-export type AllowlistResolution = {
-    policy: ToolPolicyLike | undefined;
-    unknownAllowlist: string[];
-    strippedAllowlist: boolean;
-};
-export declare function collectExplicitAllowlist(policies: Array<ToolPolicyLike | undefined>): string[];
-export declare function buildPluginToolGroups<T extends {
-    name: string;
-}>(params: {
-    tools: T[];
-    toolMeta: (tool: T) => {
-        pluginId: string;
-    } | undefined;
-}): PluginToolGroups;
-export declare function expandPluginGroups(list: string[] | undefined, groups: PluginToolGroups): string[] | undefined;
-export declare function expandPolicyWithPluginGroups(policy: ToolPolicyLike | undefined, groups: PluginToolGroups): ToolPolicyLike | undefined;
-export declare function stripPluginOnlyAllowlist(policy: ToolPolicyLike | undefined, groups: PluginToolGroups, coreTools: Set<string>): AllowlistResolution;
-export declare function mergeAlsoAllowPolicy<TPolicy extends {
-    allow?: string[];
-}>(policy: TPolicy | undefined, alsoAllow?: string[]): TPolicy | undefined;
-//# sourceMappingURL=tool-policy.d.ts.map

package/dist/openclaw/src/agents/tool-policy.js

@@ -1,149 +0,0 @@
-import { expandToolGroups, normalizeToolList, normalizeToolName, } from "./tool-policy-shared.js";
-export { expandToolGroups, normalizeToolList, normalizeToolName, resolveToolProfilePolicy, TOOL_GROUPS, } from "./tool-policy-shared.js";
-// Keep tool-policy browser-safe: do not import tools/common at runtime.
-function wrapOwnerOnlyToolExecution(tool, senderIsOwner) {
-    if (tool.ownerOnly !== true || senderIsOwner || !tool.execute) {
-        return tool;
-    }
-    return {
-        ...tool,
-        execute: async () => {
-            throw new Error("Tool restricted to owner senders.");
-        },
-    };
-}
-const OWNER_ONLY_TOOL_NAME_FALLBACKS = new Set(["whatsapp_login", "cron", "gateway"]);
-export function isOwnerOnlyToolName(name) {
-    return OWNER_ONLY_TOOL_NAME_FALLBACKS.has(normalizeToolName(name));
-}
-function isOwnerOnlyTool(tool) {
-    return tool.ownerOnly === true || isOwnerOnlyToolName(tool.name);
-}
-export function applyOwnerOnlyToolPolicy(tools, senderIsOwner) {
-    const withGuard = tools.map((tool) => {
-        if (!isOwnerOnlyTool(tool)) {
-            return tool;
-        }
-        return wrapOwnerOnlyToolExecution(tool, senderIsOwner);
-    });
-    if (senderIsOwner) {
-        return withGuard;
-    }
-    return withGuard.filter((tool) => !isOwnerOnlyTool(tool));
-}
-export function collectExplicitAllowlist(policies) {
-    const entries = [];
-    for (const policy of policies) {
-        if (!policy?.allow) {
-            continue;
-        }
-        for (const value of policy.allow) {
-            if (typeof value !== "string") {
-                continue;
-            }
-            const trimmed = value.trim();
-            if (trimmed) {
-                entries.push(trimmed);
-            }
-        }
-    }
-    return entries;
-}
-export function buildPluginToolGroups(params) {
-    const all = [];
-    const byPlugin = new Map();
-    for (const tool of params.tools) {
-        const meta = params.toolMeta(tool);
-        if (!meta) {
-            continue;
-        }
-        const name = normalizeToolName(tool.name);
-        all.push(name);
-        const pluginId = meta.pluginId.toLowerCase();
-        const list = byPlugin.get(pluginId) ?? [];
-        list.push(name);
-        byPlugin.set(pluginId, list);
-    }
-    return { all, byPlugin };
-}
-export function expandPluginGroups(list, groups) {
-    if (!list || list.length === 0) {
-        return list;
-    }
-    const expanded = [];
-    for (const entry of list) {
-        const normalized = normalizeToolName(entry);
-        if (normalized === "group:plugins") {
-            if (groups.all.length > 0) {
-                expanded.push(...groups.all);
-            }
-            else {
-                expanded.push(normalized);
-            }
-            continue;
-        }
-        const tools = groups.byPlugin.get(normalized);
-        if (tools && tools.length > 0) {
-            expanded.push(...tools);
-            continue;
-        }
-        expanded.push(normalized);
-    }
-    return Array.from(new Set(expanded));
-}
-export function expandPolicyWithPluginGroups(policy, groups) {
-    if (!policy) {
-        return undefined;
-    }
-    return {
-        allow: expandPluginGroups(policy.allow, groups),
-        deny: expandPluginGroups(policy.deny, groups),
-    };
-}
-export function stripPluginOnlyAllowlist(policy, groups, coreTools) {
-    if (!policy?.allow || policy.allow.length === 0) {
-        return { policy, unknownAllowlist: [], strippedAllowlist: false };
-    }
-    const normalized = normalizeToolList(policy.allow);
-    if (normalized.length === 0) {
-        return { policy, unknownAllowlist: [], strippedAllowlist: false };
-    }
-    const pluginIds = new Set(groups.byPlugin.keys());
-    const pluginTools = new Set(groups.all);
-    const unknownAllowlist = [];
-    let hasCoreEntry = false;
-    for (const entry of normalized) {
-        if (entry === "*") {
-            hasCoreEntry = true;
-            continue;
-        }
-        const isPluginEntry = entry === "group:plugins" || pluginIds.has(entry) || pluginTools.has(entry);
-        const expanded = expandToolGroups([entry]);
-        const isCoreEntry = expanded.some((tool) => coreTools.has(tool));
-        if (isCoreEntry) {
-            hasCoreEntry = true;
-        }
-        if (!isCoreEntry && !isPluginEntry) {
-            unknownAllowlist.push(entry);
-        }
-    }
-    const strippedAllowlist = !hasCoreEntry;
-    // When an allowlist contains only plugin tools, we strip it to avoid accidentally
-    // disabling core tools. Users who want additive behavior should prefer `tools.alsoAllow`.
-    if (strippedAllowlist) {
-        // Note: logging happens in the caller (pi-tools/tools-invoke) after this function returns.
-        // We keep this note here for future maintainers.
-    }
-    return {
-        policy: strippedAllowlist ? { ...policy, allow: undefined } : policy,
-        unknownAllowlist: Array.from(new Set(unknownAllowlist)),
-        strippedAllowlist,
-    };
-}
-export function mergeAlsoAllowPolicy(policy, alsoAllow) {
-    if (!policy?.allow || !Array.isArray(alsoAllow) || alsoAllow.length === 0) {
-        return policy;
-    }
-    return { ...policy, allow: Array.from(new Set([...policy.allow, ...alsoAllow])) };
-}
-//# sourceMappingURL=tool-policy.js.map

package/dist/openclaw/src/agents/tool-summaries.d.ts

@@ -1,3 +0,0 @@
-import type { AgentTool } from "@mariozechner/pi-agent-core";
-export declare function buildToolSummaryMap(tools: AgentTool[]): Record<string, string>;
-//# sourceMappingURL=tool-summaries.d.ts.map

package/dist/openclaw/src/agents/tool-summaries.js

@@ -1,12 +0,0 @@
-export function buildToolSummaryMap(tools) {
-    const summaries = {};
-    for (const tool of tools) {
-        const summary = tool.description?.trim() || tool.label?.trim();
-        if (!summary) {
-            continue;
-        }
-        summaries[tool.name.toLowerCase()] = summary;
-    }
-    return summaries;
-}
-//# sourceMappingURL=tool-summaries.js.map

package/dist/openclaw/src/agents/tools/agent-step.d.ts

@@ -1,16 +0,0 @@
-export declare function readLatestAssistantReply(params: {
-    sessionKey: string;
-    limit?: number;
-}): Promise<string | undefined>;
-export declare function runAgentStep(params: {
-    sessionKey: string;
-    message: string;
-    extraSystemPrompt: string;
-    timeoutMs: number;
-    channel?: string;
-    lane?: string;
-    sourceSessionKey?: string;
-    sourceChannel?: string;
-    sourceTool?: string;
-}): Promise<string | undefined>;
-//# sourceMappingURL=agent-step.d.ts.map

package/dist/openclaw/src/agents/tools/agent-step.js

@@ -1,65 +0,0 @@
-import crypto from "node:crypto";
-import { callGateway } from "../../gateway/call.js";
-import { INTERNAL_MESSAGE_CHANNEL } from "../../utils/message-channel.js";
-import { AGENT_LANE_NESTED } from "../lanes.js";
-import { extractAssistantText, stripToolMessages } from "./sessions-helpers.js";
-export async function readLatestAssistantReply(params) {
-    const history = await callGateway({
-        method: "chat.history",
-        params: { sessionKey: params.sessionKey, limit: params.limit ?? 50 },
-    });
-    const filtered = stripToolMessages(Array.isArray(history?.messages) ? history.messages : []);
-    for (let i = filtered.length - 1; i >= 0; i -= 1) {
-        const candidate = filtered[i];
-        if (!candidate || typeof candidate !== "object") {
-            continue;
-        }
-        if (candidate.role !== "assistant") {
-            continue;
-        }
-        const text = extractAssistantText(candidate);
-        if (!text?.trim()) {
-            continue;
-        }
-        return text;
-    }
-    return undefined;
-}
-export async function runAgentStep(params) {
-    const stepIdem = crypto.randomUUID();
-    const response = await callGateway({
-        method: "agent",
-        params: {
-            message: params.message,
-            sessionKey: params.sessionKey,
-            idempotencyKey: stepIdem,
-            deliver: false,
-            channel: params.channel ?? INTERNAL_MESSAGE_CHANNEL,
-            lane: params.lane ?? AGENT_LANE_NESTED,
-            extraSystemPrompt: params.extraSystemPrompt,
-            inputProvenance: {
-                kind: "inter_session",
-                sourceSessionKey: params.sourceSessionKey,
-                sourceChannel: params.sourceChannel,
-                sourceTool: params.sourceTool ?? "sessions_send",
-            },
-        },
-        timeoutMs: 10_000,
-    });
-    const stepRunId = typeof response?.runId === "string" && response.runId ? response.runId : "";
-    const resolvedRunId = stepRunId || stepIdem;
-    const stepWaitMs = Math.min(params.timeoutMs, 60_000);
-    const wait = await callGateway({
-        method: "agent.wait",
-        params: {
-            runId: resolvedRunId,
-            timeoutMs: stepWaitMs,
-        },
-        timeoutMs: stepWaitMs + 2000,
-    });
-    if (wait?.status !== "ok") {
-        return undefined;
-    }
-    return await readLatestAssistantReply({ sessionKey: params.sessionKey });
-}
-//# sourceMappingURL=agent-step.js.map

package/dist/openclaw/src/agents/tools/agents-list-tool.d.ts

@@ -1,7 +0,0 @@
-import type { AnyAgentTool } from "./common.js";
-export declare function createAgentsListTool(opts?: {
-    agentSessionKey?: string;
-    /** Explicit agent ID override for cron/hook sessions. */
-    requesterAgentIdOverride?: string;
-}): AnyAgentTool;
-//# sourceMappingURL=agents-list-tool.d.ts.map

package/dist/openclaw/src/agents/tools/agents-list-tool.js

@@ -1,72 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import { loadConfig } from "../../config/config.js";
-import { DEFAULT_AGENT_ID, normalizeAgentId, parseAgentSessionKey, } from "../../routing/session-key.js";
-import { resolveAgentConfig } from "../agent-scope.js";
-import { jsonResult } from "./common.js";
-import { resolveInternalSessionKey, resolveMainSessionAlias } from "./sessions-helpers.js";
-const AgentsListToolSchema = Type.Object({});
-export function createAgentsListTool(opts) {
-    return {
-        label: "Agents",
-        name: "agents_list",
-        description: 'List OpenClaw agent ids you can target with `sessions_spawn` when `runtime="subagent"` (based on subagent allowlists).',
-        parameters: AgentsListToolSchema,
-        execute: async () => {
-            const cfg = loadConfig();
-            const { mainKey, alias } = resolveMainSessionAlias(cfg);
-            const requesterInternalKey = typeof opts?.agentSessionKey === "string" && opts.agentSessionKey.trim()
-                ? resolveInternalSessionKey({
-                    key: opts.agentSessionKey,
-                    alias,
-                    mainKey,
-                })
-                : alias;
-            const requesterAgentId = normalizeAgentId(opts?.requesterAgentIdOverride ??
-                parseAgentSessionKey(requesterInternalKey)?.agentId ??
-                DEFAULT_AGENT_ID);
-            const allowAgents = resolveAgentConfig(cfg, requesterAgentId)?.subagents?.allowAgents ?? [];
-            const allowAny = allowAgents.some((value) => value.trim() === "*");
-            const allowSet = new Set(allowAgents
-                .filter((value) => value.trim() && value.trim() !== "*")
-                .map((value) => normalizeAgentId(value)));
-            const configuredAgents = Array.isArray(cfg.agents?.list) ? cfg.agents?.list : [];
-            const configuredIds = configuredAgents.map((entry) => normalizeAgentId(entry.id));
-            const configuredNameMap = new Map();
-            for (const entry of configuredAgents) {
-                const name = entry?.name?.trim() ?? "";
-                if (!name) {
-                    continue;
-                }
-                configuredNameMap.set(normalizeAgentId(entry.id), name);
-            }
-            const allowed = new Set();
-            allowed.add(requesterAgentId);
-            if (allowAny) {
-                for (const id of configuredIds) {
-                    allowed.add(id);
-                }
-            }
-            else {
-                for (const id of allowSet) {
-                    allowed.add(id);
-                }
-            }
-            const all = Array.from(allowed);
-            const rest = all
-                .filter((id) => id !== requesterAgentId)
-                .toSorted((a, b) => a.localeCompare(b));
-            const ordered = [requesterAgentId, ...rest];
-            const agents = ordered.map((id) => ({
-                id,
-                name: configuredNameMap.get(id),
-                configured: configuredIds.includes(id),
-            }));
-            return jsonResult({
-                requester: requesterAgentId,
-                allowAny,
-                agents,
-            });
-        },
-    };
-}
-//# sourceMappingURL=agents-list-tool.js.map