@adongguo/dingtalk 0.1.3

package/src/config-schema.ts

@@ -0,0 +1,119 @@
+import { z } from "zod";
+export { z };
+
+const DmPolicySchema = z.enum(["open", "pairing", "allowlist"]);
+const GroupPolicySchema = z.enum(["open", "allowlist", "disabled"]);
+const DingTalkConnectionModeSchema = z.enum(["stream", "webhook"]);
+
+const ToolPolicySchema = z
+  .object({
+    allow: z.array(z.string()).optional(),
+    deny: z.array(z.string()).optional(),
+  })
+  .strict()
+  .optional();
+
+const DmConfigSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    systemPrompt: z.string().optional(),
+  })
+  .strict()
+  .optional();
+
+const MarkdownConfigSchema = z
+  .object({
+    mode: z.enum(["native", "escape", "strip"]).optional(),
+    tableMode: z.enum(["native", "ascii", "simple"]).optional(),
+  })
+  .strict()
+  .optional();
+
+// Message render mode: auto (default) = detect markdown, raw = plain text, card = always action_card
+const RenderModeSchema = z.enum(["auto", "raw", "card"]).optional();
+
+const BlockStreamingCoalesceSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    minDelayMs: z.number().int().positive().optional(),
+    maxDelayMs: z.number().int().positive().optional(),
+  })
+  .strict()
+  .optional();
+
+const ChannelHeartbeatVisibilitySchema = z
+  .object({
+    visibility: z.enum(["visible", "hidden"]).optional(),
+    intervalMs: z.number().int().positive().optional(),
+  })
+  .strict()
+  .optional();
+
+// AI Card streaming mode: enabled (default) = use AI Card, disabled = use regular messages
+const AICardModeSchema = z.enum(["enabled", "disabled"]).optional();
+
+export const DingTalkGroupSchema = z
+  .object({
+    requireMention: z.boolean().optional(),
+    tools: ToolPolicySchema,
+    skills: z.array(z.string()).optional(),
+    enabled: z.boolean().optional(),
+    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    systemPrompt: z.string().optional(),
+  })
+  .strict();
+
+export const DingTalkConfigSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    appKey: z.string().optional(), // DingTalk uses appKey (ClientID)
+    appSecret: z.string().optional(), // DingTalk uses appSecret (ClientSecret)
+    robotCode: z.string().optional(), // Robot code for identifying the bot
+    connectionMode: DingTalkConnectionModeSchema.optional().default("stream"),
+    webhookPath: z.string().optional().default("/dingtalk/events"),
+    webhookPort: z.number().int().positive().optional(),
+    capabilities: z.array(z.string()).optional(),
+    markdown: MarkdownConfigSchema,
+    configWrites: z.boolean().optional(),
+    dmPolicy: DmPolicySchema.optional().default("pairing"),
+    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+    groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    requireMention: z.boolean().optional().default(true),
+    groups: z.record(z.string(), DingTalkGroupSchema.optional()).optional(),
+    historyLimit: z.number().int().min(0).optional(),
+    dmHistoryLimit: z.number().int().min(0).optional(),
+    dms: z.record(z.string(), DmConfigSchema).optional(),
+    textChunkLimit: z.number().int().positive().optional(),
+    chunkMode: z.enum(["length", "newline"]).optional(),
+    blockStreamingCoalesce: BlockStreamingCoalesceSchema,
+    mediaMaxMb: z.number().positive().optional(),
+    heartbeat: ChannelHeartbeatVisibilitySchema,
+    renderMode: RenderModeSchema, // raw = plain text, card = action card with markdown
+    // DingTalk specific options
+    cooldownMs: z.number().int().positive().optional(), // Cooldown between messages to avoid rate limiting
+    // AI Card streaming options
+    aiCardMode: AICardModeSchema, // enabled (default) = use AI Card streaming, disabled = regular messages
+    sessionTimeout: z.number().int().positive().optional().default(1800000), // Session timeout in ms (default 30 min)
+    // Gateway integration options
+    gatewayToken: z.string().optional(), // Gateway auth token (Bearer)
+    gatewayPassword: z.string().optional(), // Gateway auth password (alternative to token)
+    gatewayPort: z.number().int().positive().optional().default(18789), // Gateway port
+    // Media options
+    enableMediaUpload: z.boolean().optional().default(true), // Enable image post-processing upload
+    systemPrompt: z.string().optional(), // Custom system prompt
+  })
+  .strict()
+  .superRefine((value, ctx) => {
+    if (value.dmPolicy === "open") {
+      const allowFrom = value.allowFrom ?? [];
+      const hasWildcard = allowFrom.some((entry) => String(entry).trim() === "*");
+      if (!hasWildcard) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["allowFrom"],
+          message: 'channels.dingtalk.dmPolicy="open" requires channels.dingtalk.allowFrom to include "*"',
+        });
+      }
+    }
+  });

package/src/directory.ts

@@ -0,0 +1,90 @@
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import type { DingTalkConfig } from "./types.js";
+import { normalizeDingTalkTarget } from "./targets.js";
+
+export type DingTalkDirectoryPeer = {
+  kind: "user";
+  id: string;
+  name?: string;
+};
+
+export type DingTalkDirectoryGroup = {
+  kind: "group";
+  id: string;
+  name?: string;
+};
+
+export async function listDingTalkDirectoryPeers(params: {
+  cfg: ClawdbotConfig;
+  query?: string;
+  limit?: number;
+}): Promise<DingTalkDirectoryPeer[]> {
+  const dingtalkCfg = params.cfg.channels?.dingtalk as DingTalkConfig | undefined;
+  const q = params.query?.trim().toLowerCase() || "";
+  const ids = new Set<string>();
+
+  for (const entry of dingtalkCfg?.allowFrom ?? []) {
+    const trimmed = String(entry).trim();
+    if (trimmed && trimmed !== "*") ids.add(trimmed);
+  }
+
+  for (const userId of Object.keys(dingtalkCfg?.dms ?? {})) {
+    const trimmed = userId.trim();
+    if (trimmed) ids.add(trimmed);
+  }
+
+  return Array.from(ids)
+    .map((raw) => raw.trim())
+    .filter(Boolean)
+    .map((raw) => normalizeDingTalkTarget(raw) ?? raw)
+    .filter((id) => (q ? id.toLowerCase().includes(q) : true))
+    .slice(0, params.limit && params.limit > 0 ? params.limit : undefined)
+    .map((id) => ({ kind: "user" as const, id }));
+}
+
+export async function listDingTalkDirectoryGroups(params: {
+  cfg: ClawdbotConfig;
+  query?: string;
+  limit?: number;
+}): Promise<DingTalkDirectoryGroup[]> {
+  const dingtalkCfg = params.cfg.channels?.dingtalk as DingTalkConfig | undefined;
+  const q = params.query?.trim().toLowerCase() || "";
+  const ids = new Set<string>();
+
+  for (const groupId of Object.keys(dingtalkCfg?.groups ?? {})) {
+    const trimmed = groupId.trim();
+    if (trimmed && trimmed !== "*") ids.add(trimmed);
+  }
+
+  for (const entry of dingtalkCfg?.groupAllowFrom ?? []) {
+    const trimmed = String(entry).trim();
+    if (trimmed && trimmed !== "*") ids.add(trimmed);
+  }
+
+  return Array.from(ids)
+    .map((raw) => raw.trim())
+    .filter(Boolean)
+    .filter((id) => (q ? id.toLowerCase().includes(q) : true))
+    .slice(0, params.limit && params.limit > 0 ? params.limit : undefined)
+    .map((id) => ({ kind: "group" as const, id }));
+}
+
+// DingTalk doesn't provide directory listing APIs via bot API
+// These stubs return the same results as the config-based versions
+export async function listDingTalkDirectoryPeersLive(params: {
+  cfg: ClawdbotConfig;
+  query?: string;
+  limit?: number;
+}): Promise<DingTalkDirectoryPeer[]> {
+  // DingTalk bot API doesn't support listing users
+  return listDingTalkDirectoryPeers(params);
+}
+
+export async function listDingTalkDirectoryGroupsLive(params: {
+  cfg: ClawdbotConfig;
+  query?: string;
+  limit?: number;
+}): Promise<DingTalkDirectoryGroup[]> {
+  // DingTalk bot API doesn't support listing groups
+  return listDingTalkDirectoryGroups(params);
+}

package/src/gateway-stream.ts

@@ -0,0 +1,159 @@
+/**
+ * Gateway SSE Streaming for DingTalk
+ *
+ * Connects to local OpenClaw/Clawdbot Gateway for streaming chat completions.
+ * Implements Server-Sent Events (SSE) client for real-time response streaming.
+ */
+
+// ============ Types ============
+
+export interface GatewayOptions {
+  userContent: string;
+  systemPrompts: string[];
+  sessionKey: string;
+  gatewayUrl?: string; // Full URL or just hostname/port will be resolved
+  gatewayPort?: number;
+  gatewayAuth?: string; // token or password, both use Bearer format
+  log?: {
+    info?: (msg: string) => void;
+    warn?: (msg: string) => void;
+    error?: (msg: string) => void;
+  };
+}
+
+// ============ Gateway Streaming ============
+
+/**
+ * Stream content from Gateway via SSE (Server-Sent Events).
+ * Yields content chunks as they arrive.
+ *
+ * @param options - Gateway connection and message options
+ * @returns AsyncGenerator yielding content chunks
+ */
+export async function* streamFromGateway(options: GatewayOptions): AsyncGenerator<string, void, unknown> {
+  const { userContent, systemPrompts, sessionKey, gatewayUrl, gatewayPort, gatewayAuth, log } = options;
+
+  // Resolve gateway URL
+  let url: string;
+  if (gatewayUrl) {
+    url = gatewayUrl;
+  } else {
+    const port = gatewayPort || 18789;
+    url = `http://127.0.0.1:${port}/v1/chat/completions`;
+  }
+
+  // Build messages
+  const messages: Array<{ role: "system" | "user"; content: string }> = [];
+  for (const prompt of systemPrompts) {
+    messages.push({ role: "system", content: prompt });
+  }
+  messages.push({ role: "user", content: userContent });
+
+  // Build headers
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+  };
+  if (gatewayAuth) {
+    headers.Authorization = `Bearer ${gatewayAuth}`;
+  }
+
+  log?.info?.(`[DingTalk][Gateway] POST ${url}, session=${sessionKey}, messages=${messages.length}`);
+
+  let response: Response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        model: "default",
+        messages,
+        stream: true,
+        user: sessionKey,
+      }),
+    });
+  } catch (err: unknown) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    log?.error?.(`[DingTalk][Gateway] Connection failed: ${errMsg}`);
+    throw new Error(`Gateway connection failed: ${errMsg}`);
+  }
+
+  log?.info?.(`[DingTalk][Gateway] Response status=${response.status}, ok=${response.ok}, hasBody=${!!response.body}`);
+
+  if (!response.ok || !response.body) {
+    let errText = "";
+    try {
+      errText = await response.text();
+    } catch {
+      errText = "(no body)";
+    }
+    log?.error?.(`[DingTalk][Gateway] Error response: ${errText}`);
+    throw new Error(`Gateway error: ${response.status} - ${errText}`);
+  }
+
+  // Parse SSE stream
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+
+        const data = line.slice(6).trim();
+        if (data === "[DONE]") return;
+
+        try {
+          const chunk = JSON.parse(data) as {
+            choices?: Array<{ delta?: { content?: string } }>;
+          };
+          const content = chunk.choices?.[0]?.delta?.content;
+          if (content) {
+            yield content;
+          }
+        } catch {
+          // Ignore JSON parse errors for malformed chunks
+          log?.warn?.(`[DingTalk][Gateway] Failed to parse chunk: ${data.slice(0, 100)}`);
+        }
+      }
+    }
+
+    // Handle any remaining buffered data
+    if (buffer && buffer.startsWith("data: ")) {
+      const data = buffer.slice(6).trim();
+      if (data !== "[DONE]") {
+        try {
+          const chunk = JSON.parse(data) as {
+            choices?: Array<{ delta?: { content?: string } }>;
+          };
+          const content = chunk.choices?.[0]?.delta?.content;
+          if (content) {
+            yield content;
+          }
+        } catch {
+          // Ignore
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+/**
+ * Make a single (non-streaming) request to Gateway and get full response.
+ */
+export async function getGatewayCompletion(options: GatewayOptions): Promise<string> {
+  let fullResponse = "";
+  for await (const chunk of streamFromGateway(options)) {
+    fullResponse += chunk;
+  }
+  return fullResponse;
+}