@soimy/dingtalk 3.2.0 → 3.4.0

package/index.ts

@@ -1,9 +1,17 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import * as pluginSdk from "openclaw/plugin-sdk";
 import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
 import { dingtalkPlugin } from "./src/channel";
+import { getConfig } from "./src/config";
+import { appendToDoc, createDoc, DocCreateAppendError, listDocs, searchDocs } from "./src/docs-service";
 import { setDingTalkRuntime } from "./src/runtime";
 import type { DingtalkPluginModule } from "./src/types";
 
+type GatewayMethodContext = Pick<
+  Parameters<Parameters<OpenClawPluginApi["registerGatewayMethod"]>[1]>[0],
+  "params" | "respond"
+>;
+
 const plugin: DingtalkPluginModule = {
   id: "dingtalk",
   name: "DingTalk Channel",
@@ -12,6 +20,60 @@ const plugin: DingtalkPluginModule = {
   register(api: OpenClawPluginApi): void {
     setDingTalkRuntime(api.runtime);
     api.registerChannel({ plugin: dingtalkPlugin });
+    api.registerGatewayMethod("dingtalk.docs.create", async ({ respond, params }: GatewayMethodContext) => {
+      const accountId = pluginSdk.readStringParam(params, "accountId");
+      const spaceId = pluginSdk.readStringParam(params, "spaceId", { required: true });
+      const title = pluginSdk.readStringParam(params, "title", { required: true });
+      const content = pluginSdk.readStringParam(params, "content", { allowEmpty: true });
+      const parentId = pluginSdk.readStringParam(params, "parentId");
+      const config = getConfig(api.config, accountId ?? undefined);
+      try {
+        const doc = await createDoc(
+          config,
+          spaceId,
+          title,
+          content ?? undefined,
+          api.logger,
+          parentId ?? undefined,
+        );
+        return respond(true, doc);
+      } catch (error) {
+        if (error instanceof DocCreateAppendError) {
+          return respond(true, {
+            partialSuccess: true,
+            initContentAppended: false,
+            docId: error.doc.docId,
+            doc: error.doc,
+            appendError: error.message,
+          });
+        }
+        throw error;
+      }
+    });
+    api.registerGatewayMethod("dingtalk.docs.append", async ({ respond, params }: GatewayMethodContext) => {
+      const accountId = pluginSdk.readStringParam(params, "accountId");
+      const docId = pluginSdk.readStringParam(params, "docId", { required: true });
+      const content = pluginSdk.readStringParam(params, "content", { required: true, allowEmpty: false });
+      const config = getConfig(api.config, accountId ?? undefined);
+      const result = await appendToDoc(config, docId, content, api.logger);
+      return respond(true, result);
+    });
+    api.registerGatewayMethod("dingtalk.docs.search", async ({ respond, params }: GatewayMethodContext) => {
+      const accountId = pluginSdk.readStringParam(params, "accountId");
+      const keyword = pluginSdk.readStringParam(params, "keyword", { required: true });
+      const spaceId = pluginSdk.readStringParam(params, "spaceId");
+      const config = getConfig(api.config, accountId ?? undefined);
+      const docs = await searchDocs(config, keyword, spaceId, api.logger);
+      return respond(true, { docs });
+    });
+    api.registerGatewayMethod("dingtalk.docs.list", async ({ respond, params }: GatewayMethodContext) => {
+      const accountId = pluginSdk.readStringParam(params, "accountId");
+      const spaceId = pluginSdk.readStringParam(params, "spaceId", { required: true });
+      const parentId = pluginSdk.readStringParam(params, "parentId");
+      const config = getConfig(api.config, accountId ?? undefined);
+      const docs = await listDocs(config, spaceId, parentId, api.logger);
+      return respond(true, { docs });
+    });
   },
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soimy/dingtalk",
-  "version": "3.2.0",
+  "version": "3.4.0",
   "description": "DingTalk (钉钉) channel plugin for OpenClaw",
   "keywords": [
     "bot",
@@ -20,7 +20,7 @@
   },
   "files": [
     "index.ts",
-    "src/*.ts",
+    "src/**/*.ts",
     "openclaw.plugin.json",
     "clawbot.plugin.json"
   ],
@@ -44,6 +44,8 @@
     "axios": "^1.6.0",
     "dingtalk-stream": "^2.1.4",
     "form-data": "^4.0.0",
+    "mammoth": "^1.12.0",
+    "pdf-parse": "^2.4.5",
     "zod": "^4.3.6"
   },
   "devDependencies": {

package/src/access-control.ts

@@ -53,3 +53,86 @@ export function isSenderGroupAllowed(params: {
   }
   return false;
 }
+
+export type GroupAccessResult = {
+  allowed: boolean;
+  reason?: "disabled" | "group_not_allowed" | "sender_not_allowed";
+  legacyFallback?: boolean;
+};
+
+export type GroupAccessParams = {
+  groupPolicy: "open" | "allowlist" | "disabled";
+  groupId: string;
+  senderId: string;
+  groups?: Record<string, { groupAllowFrom?: string[] }>;
+  groupAllowFrom?: string[];
+  allowFrom?: string[]; // legacy fallback
+};
+
+export function resolveGroupAccess(params: GroupAccessParams): GroupAccessResult {
+  const { groupPolicy, groupId, senderId, groups, groupAllowFrom, allowFrom } = params;
+
+  // Step 1: disabled → block all
+  if (groupPolicy === "disabled") {
+    return { allowed: false, reason: "disabled" };
+  }
+
+  // Step 2: allowlist → group ID check
+  let legacyFallback = false;
+  if (groupPolicy === "allowlist") {
+    const groupConfig = groups?.[groupId];
+    const wildcardConfig = groups?.["*"];
+    const groupInConfig = groupConfig !== undefined || wildcardConfig !== undefined;
+
+    if (!groupInConfig) {
+      // Legacy fallback: check allowFrom for group ID
+      const legacyAllow = normalizeAllowFrom(allowFrom);
+      if (isSenderGroupAllowed({ allow: legacyAllow, groupId })) {
+        legacyFallback = true;
+        // Continue to sender check below
+      } else {
+        return { allowed: false, reason: "group_not_allowed" };
+      }
+    }
+  }
+
+  // Step 3: Sender check
+  // Priority: per-group > wildcard > top-level
+  const perGroupAllowFrom = groups?.[groupId]?.groupAllowFrom;
+  const wildcardAllowFrom = groups?.["*"]?.groupAllowFrom;
+  const effectiveAllowFrom = perGroupAllowFrom ?? wildcardAllowFrom ?? groupAllowFrom;
+
+  if (effectiveAllowFrom == null) {
+    return { allowed: true, legacyFallback: legacyFallback || undefined };
+  }
+
+  // Empty array = block all senders (fail-closed per official design)
+  if (effectiveAllowFrom.length === 0) {
+    return { allowed: false, reason: "sender_not_allowed" };
+  }
+
+  const normalized = normalizeAllowFrom(effectiveAllowFrom);
+  if (isSenderAllowed({ allow: normalized, senderId })) {
+    return { allowed: true, legacyFallback: legacyFallback || undefined };
+  }
+
+  return { allowed: false, reason: "sender_not_allowed" };
+}
+
+export function isSenderOwner(params: {
+  allow: NormalizedAllowFrom;
+  senderId?: string;
+  rawSenderId?: string;
+}): boolean {
+  const { allow, senderId, rawSenderId } = params;
+  if (!allow.hasEntries) {
+    return false;
+  }
+  if (senderId && allow.entriesLower.includes(senderId.toLowerCase())) {
+    return true;
+  }
+  if (rawSenderId && allow.entriesLower.includes(rawSenderId.toLowerCase())) {
+    return true;
+  }
+  return false;
+}

package/src/ack-reaction/dynamic-ack-reaction-controller.ts

@@ -0,0 +1,271 @@
+import { attachNativeAckReaction, recallNativeAckReactionWithRetry } from "../ack-reaction-service";
+import type { DingTalkConfig } from "../types";
+import { getErrorMessage } from "../utils";
+import {
+  createDynamicAckReactionCorrelator,
+  describeEvent,
+  type DynamicAckReactionLogger,
+  type RuntimeAgentEvent,
+  type RuntimeEventsSurface,
+} from "./dynamic-ack-reaction-events";
+import { resolveToolProgressReaction } from "./dynamic-ack-reaction-progress";
+
+type DynamicAckReactionControllerParams = {
+  enabled: boolean;
+  initialReaction: string;
+  initialAttached: boolean;
+  initialAttachedAt: number;
+  dingtalkConfig: DingTalkConfig;
+  msgId: string;
+  conversationId: string;
+  sessionKey: string;
+  log?: DynamicAckReactionLogger;
+  runtimeEvents?: RuntimeEventsSurface;
+  onReactionDisposed?: () => void;
+};
+
+const TOOL_REACTION_SILENCE_MS = 55_000;
+const TOOL_REACTION_HEARTBEAT_INTERVAL_MS = 60_000;
+const DYNAMIC_REACTION_MIN_SWITCH_INTERVAL_MS = 5_000;
+const OPTIMISTIC_RUN_ID_CAPTURE_WINDOW_MS = 5_000;
+const TOOL_HEARTBEAT_REACTION = "⏳";
+
+export function createDynamicAckReactionController(params: DynamicAckReactionControllerParams) {
+  let dynamicReactionStartedAt = 0;
+  let lastDynamicReactionAt = 0;
+  let currentAckReaction = params.initialReaction;
+  let ackReactionAttached = params.initialAttached;
+  let ackReactionAttachedAt = params.initialAttachedAt;
+  let progressHeartbeatInFlight = false;
+  let progressHeartbeatTimer: NodeJS.Timeout | undefined;
+  let dynamicReactionUpdatePromise: Promise<void> = Promise.resolve();
+  let lastDynamicReactionSwitchAt = 0;
+  let disposed = false;
+  const createdAt = Date.now();
+  const isCorrelatedEvent = createDynamicAckReactionCorrelator({
+    sessionKey: params.sessionKey,
+    enabled: params.enabled,
+    createdAt,
+    optimisticCaptureWindowMs: OPTIMISTIC_RUN_ID_CAPTURE_WINDOW_MS,
+    log: params.log,
+  });
+
+  const updateDynamicAckReaction = async (nextReaction: string) => {
+    const normalizedReaction = typeof nextReaction === "string" ? nextReaction.trim() : "";
+    if (disposed || !normalizedReaction || !params.enabled || !ackReactionAttached) {
+      params.log?.debug?.(
+        `[DingTalk] Dynamic ack reaction update skipped reaction=${normalizedReaction || "-"} ` +
+        `enabled=${params.enabled} ackReactionAttached=${ackReactionAttached} disposed=${disposed}`,
+      );
+      return;
+    }
+    if (normalizedReaction === currentAckReaction) {
+      params.log?.debug?.(
+        `[DingTalk] Dynamic ack reaction update skipped because reaction is unchanged: ${normalizedReaction}`,
+      );
+      if (dynamicReactionStartedAt === 0) {
+        dynamicReactionStartedAt = Date.now();
+      }
+      lastDynamicReactionAt = Date.now();
+      return;
+    }
+    if (
+      lastDynamicReactionSwitchAt > 0
+      && Date.now() - lastDynamicReactionSwitchAt < DYNAMIC_REACTION_MIN_SWITCH_INTERVAL_MS
+    ) {
+      params.log?.debug?.(
+        `[DingTalk] Dynamic ack reaction update throttled previous=${currentAckReaction} next=${normalizedReaction} ` +
+        `minIntervalMs=${DYNAMIC_REACTION_MIN_SWITCH_INTERVAL_MS}`,
+      );
+      return;
+    }
+
+    const previousReaction = currentAckReaction;
+    ackReactionAttached = false;
+    await recallNativeAckReactionWithRetry(
+      params.dingtalkConfig,
+      {
+        msgId: params.msgId,
+        conversationId: params.conversationId,
+        reactionName: previousReaction,
+      },
+      params.log,
+    );
+
+    const attached = await attachNativeAckReaction(
+      params.dingtalkConfig,
+      {
+        msgId: params.msgId,
+        conversationId: params.conversationId,
+        reactionName: normalizedReaction,
+      },
+      params.log,
+    );
+    if (!attached) {
+      if (disposed) {
+        return;
+      }
+      params.log?.debug?.(
+        `[DingTalk] Dynamic ack reaction attach did not succeed for reaction=${normalizedReaction}; restoring previous reaction=${previousReaction}`,
+      );
+      const restored = await attachNativeAckReaction(
+        params.dingtalkConfig,
+        {
+          msgId: params.msgId,
+          conversationId: params.conversationId,
+          reactionName: previousReaction,
+        },
+        params.log,
+      );
+      ackReactionAttached = restored;
+      if (restored) {
+        currentAckReaction = previousReaction;
+        ackReactionAttachedAt = Date.now();
+        if (dynamicReactionStartedAt === 0) {
+          dynamicReactionStartedAt = ackReactionAttachedAt;
+        }
+        lastDynamicReactionAt = ackReactionAttachedAt;
+      }
+      return;
+    }
+
+    params.log?.debug?.(`[DingTalk] Dynamic ack reaction switched to ${normalizedReaction}`);
+    ackReactionAttached = true;
+    currentAckReaction = normalizedReaction;
+    ackReactionAttachedAt = Date.now();
+    lastDynamicReactionSwitchAt = ackReactionAttachedAt;
+    if (dynamicReactionStartedAt === 0) {
+      dynamicReactionStartedAt = ackReactionAttachedAt;
+    }
+    lastDynamicReactionAt = ackReactionAttachedAt;
+  };
+
+  const queueDynamicAckReactionUpdate = (nextReaction: string) => {
+    if (disposed) {
+      return dynamicReactionUpdatePromise;
+    }
+    params.log?.debug?.(
+      `[DingTalk] Queue dynamic ack reaction update ${currentAckReaction || "-"} -> ${nextReaction || "-"}`,
+    );
+    dynamicReactionUpdatePromise = dynamicReactionUpdatePromise
+      .then(() => updateDynamicAckReaction(nextReaction))
+      .catch((err: unknown) => {
+        params.log?.warn?.(`[DingTalk] Dynamic ack reaction update failed: ${getErrorMessage(err)}`);
+      });
+    return dynamicReactionUpdatePromise;
+  };
+
+  const handleAgentEvent = async (event: unknown) => {
+    const agentEvent = event as RuntimeAgentEvent | undefined;
+    if (!params.enabled || disposed) {
+      return;
+    }
+    params.log?.debug?.(`[DingTalk] Dynamic reaction observed agent event ${describeEvent(agentEvent)}`);
+    if (agentEvent?.stream === "lifecycle" && agentEvent.data?.phase === "start") {
+      void isCorrelatedEvent(agentEvent);
+      return;
+    }
+    if (agentEvent?.stream !== "tool" || agentEvent.data?.phase !== "start") {
+      return;
+    }
+    if (!isCorrelatedEvent(agentEvent)) {
+      params.log?.debug?.(
+        `[DingTalk] Dynamic reaction ignored uncorrelated tool event ${describeEvent(agentEvent)}`,
+      );
+      return;
+    }
+    const toolCallId = typeof agentEvent.data?.toolCallId === "string" ? agentEvent.data.toolCallId : "-";
+    params.log?.debug?.(
+      `[DingTalk] Tool event received for dynamic ack reaction: name=${agentEvent.data?.name || "-"} toolCallId=${toolCallId}`,
+    );
+    await queueDynamicAckReactionUpdate(
+      resolveToolProgressReaction(agentEvent.data?.name, agentEvent.data?.args),
+    );
+  };
+
+  const unsubscribeAgentEvents = params.enabled && params.runtimeEvents?.onAgentEvent
+    ? params.runtimeEvents.onAgentEvent((event: unknown) => {
+        void handleAgentEvent(event).catch((err: unknown) => {
+          params.log?.warn?.(`[DingTalk] Dynamic ack reaction event handling failed: ${getErrorMessage(err)}`);
+        });
+      })
+    : () => {};
+
+  if (params.enabled && !params.runtimeEvents?.onAgentEvent) {
+    params.log?.debug?.("[DingTalk] onAgentEvent not available, dynamic reaction tracking disabled");
+  }
+
+  if (params.enabled) {
+    progressHeartbeatTimer = setInterval(() => {
+      if (
+        disposed
+        || !ackReactionAttached
+        || progressHeartbeatInFlight
+        || dynamicReactionStartedAt === 0
+        || lastDynamicReactionAt === 0
+      ) {
+        return;
+      }
+      if (Date.now() - lastDynamicReactionAt < TOOL_REACTION_SILENCE_MS) {
+        return;
+      }
+      params.log?.debug?.(
+        `[DingTalk] Dynamic ack reaction heartbeat triggered currentReaction=${currentAckReaction} ` +
+        `lastDynamicReactionAt=${lastDynamicReactionAt}`,
+      );
+      progressHeartbeatInFlight = true;
+      void queueDynamicAckReactionUpdate(TOOL_HEARTBEAT_REACTION).finally(() => {
+        progressHeartbeatInFlight = false;
+      });
+    }, TOOL_REACTION_HEARTBEAT_INTERVAL_MS);
+  }
+
+  const stop = (): void => {
+    if (disposed) {
+      return;
+    }
+    disposed = true;
+    unsubscribeAgentEvents();
+    if (progressHeartbeatTimer) {
+      clearInterval(progressHeartbeatTimer);
+      progressHeartbeatTimer = undefined;
+    }
+  };
+
+  return {
+    async awaitDrain(): Promise<void> {
+      await dynamicReactionUpdatePromise.catch(() => undefined);
+    },
+    async dispose(minVisibleMs: number): Promise<void> {
+      stop();
+      await this.awaitDrain();
+      if (!ackReactionAttached) {
+        params.onReactionDisposed?.();
+        return;
+      }
+      try {
+        const shouldRespectMinVisible = params.enabled && dynamicReactionStartedAt > 0;
+        const elapsedMs = ackReactionAttachedAt > 0 ? Date.now() - ackReactionAttachedAt : 0;
+        const remainingVisibleMs = shouldRespectMinVisible ? minVisibleMs - elapsedMs : 0;
+        if (remainingVisibleMs > 0) {
+          await new Promise(resolve => setTimeout(resolve, remainingVisibleMs));
+        }
+        await recallNativeAckReactionWithRetry(
+          params.dingtalkConfig,
+          {
+            msgId: params.msgId,
+            conversationId: params.conversationId,
+            reactionName: currentAckReaction,
+          },
+          params.log,
+        );
+      } catch (err: unknown) {
+        params.log?.warn?.(`[DingTalk] Dynamic ack reaction dispose recall failed: ${getErrorMessage(err)}`);
+      } finally {
+        ackReactionAttached = false;
+        params.onReactionDisposed?.();
+      }
+    },
+    stop,
+  };
+}

package/src/ack-reaction/dynamic-ack-reaction-events.ts

@@ -0,0 +1,123 @@
+import { getErrorMessage } from "../utils";
+
+export type DynamicAckReactionLogger = {
+  debug?: (msg: string) => void;
+  info?: (msg: string) => void;
+  warn?: (msg: string) => void;
+};
+
+export type RuntimeAgentEvent = {
+  stream?: string;
+  runId?: string;
+  sessionKey?: string;
+  data?: {
+    phase?: string;
+    name?: string;
+    args?: unknown;
+    runId?: string;
+    sessionKey?: string;
+    toolCallId?: string;
+    meta?: {
+      runId?: string;
+      sessionKey?: string;
+    } | null;
+  };
+};
+
+export type RuntimeEventsSurface = {
+  onAgentEvent?: (listener: (event: unknown) => void) => (() => void);
+};
+
+function firstTrimmedString(...values: unknown[]): string | undefined {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return undefined;
+}
+
+export function getEventRunId(event: RuntimeAgentEvent | undefined): string | undefined {
+  return firstTrimmedString(event?.runId, event?.data?.runId, event?.data?.meta?.runId);
+}
+
+export function getEventSessionKey(event: RuntimeAgentEvent | undefined): string | undefined {
+  return firstTrimmedString(event?.sessionKey, event?.data?.sessionKey, event?.data?.meta?.sessionKey);
+}
+
+export function describeEvent(event: RuntimeAgentEvent | undefined): string {
+  const stream = firstTrimmedString(event?.stream) || "-";
+  const phase = firstTrimmedString(event?.data?.phase) || "-";
+  const toolName = firstTrimmedString(event?.data?.name) || "-";
+  const toolCallId = firstTrimmedString(event?.data?.toolCallId) || "-";
+  return `stream=${stream} phase=${phase} runId=${getEventRunId(event) || "-"} ` +
+    `sessionKey=${getEventSessionKey(event) || "-"} toolCallId=${toolCallId} toolName=${toolName}`;
+}
+
+export function createDynamicAckReactionCorrelator(params: {
+  sessionKey: string;
+  enabled: boolean;
+  createdAt: number;
+  optimisticCaptureWindowMs: number;
+  log?: DynamicAckReactionLogger;
+}) {
+  let activeRunId: string | undefined;
+  let correlationUnavailableLogged = false;
+  let optimisticCaptureCount = 0;
+
+  return (event: RuntimeAgentEvent | undefined): boolean => {
+    const eventRunId = getEventRunId(event);
+    const eventSessionKey = getEventSessionKey(event);
+    const eventStream = firstTrimmedString(event?.stream) || "";
+    const eventPhase = firstTrimmedString(event?.data?.phase) || "";
+
+    if (activeRunId) {
+      const matched = eventRunId === activeRunId;
+      params.log?.debug?.(
+        `[DingTalk] Dynamic reaction correlation by runId matched=${matched} activeRunId=${activeRunId} ` +
+        `eventRunId=${eventRunId || "-"} eventSessionKey=${eventSessionKey || "-"}`,
+      );
+      return matched;
+    }
+
+    if (eventSessionKey === params.sessionKey) {
+      if (eventRunId) {
+        activeRunId = eventRunId;
+        params.log?.debug?.(
+          `[DingTalk] Dynamic reaction captured active runId=${activeRunId} from sessionKey=${params.sessionKey}`,
+        );
+      } else {
+        params.log?.debug?.(
+          `[DingTalk] Dynamic reaction correlated by sessionKey=${params.sessionKey} without runId`,
+        );
+      }
+      return true;
+    }
+
+    if (
+      optimisticCaptureCount === 0
+      && eventStream === "lifecycle"
+      && eventPhase === "start"
+      && eventRunId
+      && !eventSessionKey
+      && Date.now() - params.createdAt <= params.optimisticCaptureWindowMs
+    ) {
+      optimisticCaptureCount += 1;
+      activeRunId = eventRunId;
+      params.log?.debug?.(
+        `[DingTalk] Dynamic reaction optimistically captured active runId=${activeRunId} ` +
+        `from first lifecycle event without sessionKey windowMs=${params.optimisticCaptureWindowMs}`,
+      );
+      return true;
+    }
+
+    if (!correlationUnavailableLogged && params.enabled) {
+      correlationUnavailableLogged = true;
+      params.log?.debug?.(
+        `[DingTalk] Dynamic reaction ignored uncorrelated agent events; ` +
+        `reason=${getErrorMessage(eventRunId || eventSessionKey || "waiting for sessionKey/runId match")}`,
+      );
+    }
+    return false;
+  };
+}

package/src/ack-reaction/dynamic-ack-reaction-progress.ts

@@ -0,0 +1,59 @@
+function readToolArgString(args: unknown, keys: string[]): string | undefined {
+  if (!args || typeof args !== "object") {
+    return undefined;
+  }
+  const record = args as Record<string, unknown>;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Tool names here come from the runtime `onAgentEvent` tool-start payload.
+ * The runtime does not expose a typed enum on this event surface yet,
+ * so this mapping is intentionally best-effort and keeps a safe default.
+ */
+export function resolveToolProgressReaction(toolName: unknown, args: unknown): string {
+  const normalizedToolName = typeof toolName === "string" ? toolName.trim().toLowerCase() : "";
+  switch (normalizedToolName) {
+    case "bash":
+    case "exec":
+    case "process": {
+      const command = readToolArgString(args, ["command", "cmd"]);
+      if (!command) {
+        return "🛠️";
+      }
+      if (/\bbrew\s+install\s+/i.test(command) || /\b(?:pnpm|npm|yarn)\s+(?:add|install)\s+/i.test(command)) {
+        return "📦";
+      }
+      if (/\bwhich\s+/i.test(command)) {
+        return "🔍";
+      }
+      return "🛠️";
+    }
+    case "read":
+    case "view":
+      return "📂";
+    case "write":
+    case "edit":
+    case "patch":
+      return "✍️";
+    case "web_search":
+    case "search":
+    case "browser.search":
+    case "browser_search":
+      return "🌐";
+    case "fetch":
+    case "open":
+    case "open_url":
+    case "browser.open":
+    case "browser_open":
+      return "🔗";
+    default:
+      return "🛠️";
+  }
+}