@shadowob/openclaw-shadowob 1.1.0 → 1.1.3

package/dist/index.js

@@ -1,16 +1,1023 @@
 import {
-  shadowPlugin
-} from "./chunk-XPNVTXKL.js";
+  DEFAULT_ACCOUNT_ID,
+  getAccountConfig,
+  listAccountIds,
+  resolveAccount,
+  shadowPluginCapabilities,
+  shadowPluginConfig,
+  shadowPluginConfigSchema,
+  shadowPluginMeta,
+  shadowPluginSetup
+} from "./chunk-NBNZ7NVR.js";
 import {
   getShadowRuntime,
   monitorShadowProvider,
+  resolveOutboundMentions,
   setShadowRuntime,
   tryGetShadowRuntime
-} from "./chunk-QFUUQPJZ.js";
+} from "./chunk-PEV3R2R7.js";
 
 // index.ts
 import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
+
+// src/channel/plugin.ts
+import { ShadowClient as ShadowClient3 } from "@shadowob/sdk";
+import {
+  buildChannelOutboundSessionRoute,
+  buildThreadAwareOutboundSessionRoute,
+  createChatChannelPlugin
+} from "openclaw/plugin-sdk/core";
+
+// src/outbound.ts
 import { ShadowClient } from "@shadowob/sdk";
+var CHUNK_SIZE = 16e3;
+function chunkText(text, maxLen = CHUNK_SIZE) {
+  if (text.length <= maxLen) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > maxLen) {
+    let splitAt = maxLen;
+    const paraIdx = remaining.lastIndexOf("\n\n", maxLen);
+    if (paraIdx > maxLen * 0.5) {
+      splitAt = paraIdx + 2;
+    } else {
+      const lineIdx = remaining.lastIndexOf("\n", maxLen);
+      if (lineIdx > maxLen * 0.6) {
+        splitAt = lineIdx + 1;
+      } else {
+        const head = remaining.slice(0, maxLen);
+        const sentenceRe = /[。！？.!?][\s\u200B]*$/;
+        const m = head.match(sentenceRe);
+        if (m && m.index !== void 0 && m.index > maxLen * 0.4) {
+          splitAt = m.index + m[0].length;
+        }
+      }
+    }
+    chunks.push(remaining.slice(0, splitAt).trimEnd());
+    remaining = remaining.slice(splitAt).trimStart();
+  }
+  if (remaining.length > 0) {
+    chunks.push(remaining);
+  }
+  return chunks;
+}
+function parseTarget(to) {
+  const parts = to.split(":");
+  const prefix = parts[0];
+  if ((prefix === "shadowob" || prefix === "openclaw-shadowob") && parts[1] === "channel" && parts[2]) {
+    return {
+      channelId: parts[2],
+      ...parts[3] === "thread" && parts[4] ? { threadId: parts[4] } : {}
+    };
+  }
+  if ((prefix === "shadowob" || prefix === "openclaw-shadowob") && parts[1] === "thread" && parts[2]) {
+    return { threadId: parts[2] };
+  }
+  return { channelId: to };
+}
+function resolveClient(cfg, accountId) {
+  const account = getAccountConfig(cfg, accountId ?? DEFAULT_ACCOUNT_ID);
+  if (!account) return null;
+  return { client: new ShadowClient(account.serverUrl, account.token), account };
+}
+async function sendTextChunks(params) {
+  const { channelId, threadId: parsedThreadId } = parseTarget(params.to);
+  const threadId = params.threadId !== void 0 && params.threadId !== null ? String(params.threadId) : parsedThreadId;
+  const chunks = chunkText(params.text);
+  let lastMessage;
+  for (let i = 0; i < chunks.length; i++) {
+    const chunk = chunks[i];
+    const replyTo = i === 0 ? params.replyToMessageId ?? void 0 : lastMessage?.id;
+    if (threadId && channelId) {
+      const mentions = await resolveOutboundMentions({
+        client: params.client,
+        channelId,
+        content: chunk
+      });
+      lastMessage = await params.client.sendMessage(channelId, chunk, {
+        threadId,
+        replyToId: replyTo,
+        ...mentions ? { mentions } : {}
+      });
+    } else if (threadId) {
+      lastMessage = replyTo ? await params.client.sendToThread(threadId, chunk, { replyToId: replyTo }) : await params.client.sendToThread(threadId, chunk);
+    } else if (channelId) {
+      const mentions = await resolveOutboundMentions({
+        client: params.client,
+        channelId,
+        content: chunk
+      });
+      lastMessage = await params.client.sendMessage(channelId, chunk, {
+        replyToId: replyTo,
+        ...mentions ? { mentions } : {}
+      });
+    } else {
+      throw new Error("Could not resolve target channel or thread");
+    }
+  }
+  if (!lastMessage) {
+    throw new Error("No message was sent");
+  }
+  return { message: lastMessage, channelId, threadId };
+}
+function toDeliveryResult(params) {
+  return {
+    channel: "shadowob",
+    messageId: params.message.id,
+    channelId: params.channelId ?? params.message.channelId,
+    conversationId: params.threadId ?? params.channelId ?? params.message.channelId,
+    ...params.threadId ? {
+      meta: {
+        threadId: params.threadId
+      }
+    } : {}
+  };
+}
+async function sendMediaToShadow(params) {
+  const mediaUrls = [params.mediaUrl ?? params.filePath, ...params.mediaUrls ?? []].filter(
+    Boolean
+  );
+  if (mediaUrls.length === 0) {
+    throw new Error("No media URL or file path provided");
+  }
+  const sent = await sendTextChunks({
+    client: params.client,
+    to: params.to,
+    text: params.text || "\u200B",
+    threadId: params.threadId,
+    replyToMessageId: params.replyToMessageId
+  });
+  let result = toDeliveryResult(sent);
+  const uploadErrors = [];
+  for (const mediaUrl of mediaUrls) {
+    try {
+      await params.client.uploadMediaFromUrl(mediaUrl, sent.message.id);
+    } catch (err) {
+      const fallback = await sendTextChunks({
+        client: params.client,
+        to: params.to,
+        text: mediaUrl,
+        threadId: params.threadId,
+        replyToMessageId: result.messageId
+      });
+      uploadErrors.push(err instanceof Error ? err.message : String(err));
+      const fallbackResult = toDeliveryResult(fallback);
+      result = {
+        ...fallbackResult,
+        meta: {
+          ...fallbackResult.meta ?? {},
+          mediaUploadFallback: true,
+          mediaUploadErrors: uploadErrors
+        }
+      };
+    }
+  }
+  return result;
+}
+var shadowOutbound = {
+  deliveryMode: "direct",
+  chunker: chunkText,
+  textChunkLimit: CHUNK_SIZE,
+  sendText: async (params) => {
+    const resolved = resolveClient(params.cfg, params.accountId ?? void 0);
+    if (!resolved) throw new Error("Shadow account not configured");
+    const sent = await sendTextChunks({
+      client: resolved.client,
+      to: params.to,
+      text: params.text,
+      threadId: params.threadId,
+      replyToMessageId: params.replyToId
+    });
+    return toDeliveryResult(sent);
+  },
+  sendMedia: async (params) => {
+    const resolved = resolveClient(params.cfg, params.accountId ?? void 0);
+    if (!resolved) throw new Error("Shadow account not configured");
+    return sendMediaToShadow({
+      client: resolved.client,
+      to: params.to,
+      filePath: params.filePath,
+      mediaUrl: params.mediaUrl,
+      mediaUrls: params.mediaUrls,
+      text: params.text,
+      threadId: params.threadId,
+      replyToMessageId: params.replyToId
+    });
+  }
+};
+
+// src/channel/actions.ts
+import { ShadowClient as ShadowClient2 } from "@shadowob/sdk";
+
+// src/channel/interactive.ts
+var SHADOW_INTERACTIVE_KINDS = ["buttons", "select", "form", "approval"];
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function readStringLike(value, trim = true) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") return trim ? value.trim() : value;
+  if (typeof value === "number" || typeof value === "boolean") {
+    const stringValue = String(value);
+    return trim ? stringValue.trim() : stringValue;
+  }
+  return void 0;
+}
+function firstString(...values) {
+  for (const value of values) {
+    const stringValue = readStringLike(value);
+    if (stringValue) return stringValue;
+  }
+  return void 0;
+}
+function readMessageTarget(params) {
+  return firstString(params.to, params.target, params.recipient, params.channelId) ?? "";
+}
+function normalizeInteractiveKind(value) {
+  const raw = readStringLike(value)?.toLowerCase();
+  if (!raw) return void 0;
+  return SHADOW_INTERACTIVE_KINDS.includes(raw) ? raw : void 0;
+}
+function normalizeButtonStyle(value) {
+  const raw = readStringLike(value)?.toLowerCase();
+  if (raw === "primary" || raw === "secondary" || raw === "destructive") return raw;
+  if (raw === "danger") return "destructive";
+  return void 0;
+}
+function normalizeButtonItems(value) {
+  if (!Array.isArray(value)) return void 0;
+  const items = value.filter(isRecord).map((button, index) => {
+    const label = firstString(
+      button.label,
+      button.text,
+      button.title,
+      button.value,
+      `Option ${index + 1}`
+    );
+    const id = firstString(button.id, button.actionId, button.value, label, `button_${index + 1}`);
+    const normalized = { id, label };
+    const value2 = readStringLike(button.value, false);
+    const style = normalizeButtonStyle(button.style);
+    if (value2 !== void 0) normalized.value = value2;
+    if (style) normalized.style = style;
+    return normalized;
+  }).filter((button) => button.id && button.label);
+  return items.length > 0 ? items : void 0;
+}
+function normalizeSelectItems(value) {
+  if (!Array.isArray(value)) return void 0;
+  const items = value.filter(isRecord).map((option, index) => {
+    const label = firstString(
+      option.label,
+      option.text,
+      option.title,
+      option.value,
+      `Option ${index + 1}`
+    );
+    const value2 = firstString(option.value, option.id, label, `option_${index + 1}`);
+    const id = firstString(option.id, value2, `option_${index + 1}`);
+    return { id, label, value: value2 };
+  }).filter((option) => option.id && option.label && option.value);
+  return items.length > 0 ? items : void 0;
+}
+function normalizeFormFieldKind(value) {
+  const raw = readStringLike(value)?.toLowerCase();
+  if (["text", "textarea", "number", "checkbox", "select"].includes(raw ?? "")) return raw;
+  return void 0;
+}
+function normalizeFormFields(value) {
+  if (!Array.isArray(value)) return void 0;
+  const fields = value.filter(isRecord).map((field, index) => {
+    const label = firstString(field.label, field.name, field.id, `Field ${index + 1}`);
+    const id = firstString(field.id, field.name, label, `field_${index + 1}`);
+    const kind = normalizeFormFieldKind(field.kind) ?? normalizeFormFieldKind(field.type) ?? "text";
+    const normalized = { id, kind, label };
+    for (const key of ["placeholder", "defaultValue"]) {
+      const value2 = readStringLike(field[key], false);
+      if (value2 !== void 0) normalized[key] = value2;
+    }
+    if (typeof field.required === "boolean") normalized.required = field.required;
+    if (typeof field.maxLength === "number") normalized.maxLength = field.maxLength;
+    if (typeof field.min === "number") normalized.min = field.min;
+    if (typeof field.max === "number") normalized.max = field.max;
+    const options = normalizeSelectItems(field.options);
+    if (options) normalized.options = options;
+    return normalized;
+  }).filter((field) => field.id && field.kind && field.label);
+  return fields.length > 0 ? fields : void 0;
+}
+function resolveShadowInteractiveBlock(params) {
+  const rawInteractive = isRecord(params.interactive) ? params.interactive : void 0;
+  const source = rawInteractive && normalizeInteractiveKind(rawInteractive.kind) ? rawInteractive : params;
+  let kind = normalizeInteractiveKind(source.kind);
+  const buttons = normalizeButtonItems(source.buttons);
+  const options = normalizeSelectItems(source.options);
+  const fields = normalizeFormFields(source.fields);
+  if (!kind) {
+    if (fields) kind = "form";
+    else if (options) kind = "select";
+    else if (buttons) kind = "buttons";
+  }
+  if (!kind) return void 0;
+  const prompt = firstString(source.prompt, source.message, source.content, source.text);
+  const block = {
+    id: firstString(source.blockId, source.id) ?? `ia_${Date.now().toString(36)}`,
+    kind,
+    ...prompt ? { prompt } : {}
+  };
+  if (buttons) block.buttons = buttons;
+  if (options) block.options = options;
+  if (fields) block.fields = fields;
+  const submitLabel = readStringLike(source.submitLabel);
+  const responsePrompt = readStringLike(source.responsePrompt);
+  const approvalCommentLabel = readStringLike(source.approvalCommentLabel);
+  if (submitLabel) block.submitLabel = submitLabel;
+  if (responsePrompt) block.responsePrompt = responsePrompt;
+  if (approvalCommentLabel) block.approvalCommentLabel = approvalCommentLabel;
+  if (typeof source.oneShot === "boolean") block.oneShot = source.oneShot;
+  return block;
+}
+function validateApprovalMessageContent(content, interactiveBlock) {
+  if (interactiveBlock?.kind !== "approval") return null;
+  const trimmed = content.trim();
+  const prompt = readStringLike(interactiveBlock.prompt);
+  const normalized = trimmed.replace(/\s+/g, " ");
+  const normalizedPrompt = prompt?.replace(/\s+/g, " ");
+  const lines = trimmed.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (lines.length >= 4 || trimmed.length >= 240) return null;
+  if (trimmed.length >= 180 && normalized !== normalizedPrompt) return null;
+  return [
+    "approval dialogs must be attached to a visible proposal in the same message",
+    "include the concrete roadmap, MVP scope, plan, or decision before asking for approval"
+  ].join("; ");
+}
+
+// src/channel/send.ts
+async function sendShadowMessage(params) {
+  const { channelId, threadId: parsedThreadId } = parseTarget(params.to);
+  const threadId = params.threadId ?? parsedThreadId;
+  if (threadId && channelId) {
+    const mentions = params.mentions ?? await resolveOutboundMentions({
+      client: params.client,
+      channelId,
+      content: params.content
+    });
+    return params.client.sendMessage(channelId, params.content, {
+      threadId,
+      replyToId: params.replyToId,
+      ...mentions ? { mentions } : {},
+      metadata: params.metadata
+    });
+  }
+  if (threadId) {
+    return params.client.sendToThread(threadId, params.content, {
+      ...params.replyToId ? { replyToId: params.replyToId } : {},
+      metadata: params.metadata
+    });
+  }
+  if (channelId) {
+    const mentions = params.mentions ?? await resolveOutboundMentions({
+      client: params.client,
+      channelId,
+      content: params.content
+    });
+    return params.client.sendMessage(channelId, params.content, {
+      replyToId: params.replyToId,
+      ...mentions ? { mentions } : {},
+      metadata: params.metadata
+    });
+  }
+  throw new Error("Could not resolve target channel or thread");
+}
+
+// src/channel/typebox-schema.ts
+var TYPEBOX_KIND = /* @__PURE__ */ Symbol.for("TypeBox.Kind");
+var TYPEBOX_OPTIONAL = /* @__PURE__ */ Symbol.for("TypeBox.Optional");
+var OPENCLAW_TYPEBOX_KIND = "~kind";
+var OPENCLAW_TYPEBOX_OPTIONAL = "~optional";
+function typeboxSchema(kind, schema) {
+  Object.defineProperties(schema, {
+    [TYPEBOX_KIND]: { value: kind },
+    [OPENCLAW_TYPEBOX_KIND]: { value: kind }
+  });
+  return schema;
+}
+function optionalSchema(schema) {
+  Object.defineProperties(schema, {
+    [TYPEBOX_OPTIONAL]: { value: "Optional" },
+    [OPENCLAW_TYPEBOX_OPTIONAL]: { value: "Optional" }
+  });
+  return schema;
+}
+function stringSchema(description) {
+  return typeboxSchema("String", {
+    type: "string",
+    ...description ? { description } : {}
+  });
+}
+function numberSchema(description) {
+  return typeboxSchema("Number", {
+    type: "number",
+    ...description ? { description } : {}
+  });
+}
+function booleanSchema(description) {
+  return typeboxSchema("Boolean", {
+    type: "boolean",
+    ...description ? { description } : {}
+  });
+}
+function literalSchema(value) {
+  return typeboxSchema("Literal", { const: value, type: "string" });
+}
+function enumSchema(values, description) {
+  return typeboxSchema("Union", {
+    anyOf: values.map((value) => literalSchema(value)),
+    ...description ? { description } : {}
+  });
+}
+function arraySchema(items, options = {}) {
+  return typeboxSchema("Array", { type: "array", items, ...options });
+}
+function objectSchema(properties, options = {}) {
+  const required = Object.entries(properties).filter(([, schema]) => schema[TYPEBOX_OPTIONAL] !== "Optional").filter(([, schema]) => schema[OPENCLAW_TYPEBOX_OPTIONAL] !== "Optional").map(([key]) => key);
+  return typeboxSchema("Object", {
+    type: "object",
+    properties,
+    required,
+    ...options
+  });
+}
+var shadowInteractiveButtonSchema = objectSchema({
+  id: stringSchema("Stable button id returned in the interaction response."),
+  label: stringSchema("Button text shown to the user."),
+  value: optionalSchema(stringSchema("Optional value returned when selected.")),
+  style: optionalSchema(enumSchema(["primary", "secondary", "destructive"]))
+});
+var shadowInteractiveSelectOptionSchema = objectSchema({
+  id: stringSchema("Stable option id returned in the interaction response."),
+  label: stringSchema("Option text shown to the user."),
+  value: stringSchema("Value returned when selected.")
+});
+var shadowInteractiveFormFieldSchema = objectSchema({
+  id: stringSchema("Stable field id returned in submitted values."),
+  kind: optionalSchema(enumSchema(["text", "textarea", "number", "checkbox", "select"])),
+  type: optionalSchema(
+    enumSchema(["text", "textarea", "number", "checkbox", "select"], "Alias for kind.")
+  ),
+  label: stringSchema("Field label shown to the user."),
+  placeholder: optionalSchema(stringSchema()),
+  defaultValue: optionalSchema(stringSchema()),
+  required: optionalSchema(booleanSchema()),
+  options: optionalSchema(arraySchema(shadowInteractiveSelectOptionSchema, { maxItems: 20 })),
+  maxLength: optionalSchema(numberSchema()),
+  min: optionalSchema(numberSchema()),
+  max: optionalSchema(numberSchema())
+});
+var shadowMessageToolSchemaProperties = {
+  kind: optionalSchema(
+    enumSchema(
+      ["buttons", "select", "form", "approval"],
+      'Shadow interactive dialog kind. Use with action "send" when buttons, select, form, or approval UI is needed.'
+    )
+  ),
+  prompt: optionalSchema(
+    stringSchema("Prompt rendered inside a Shadow interactive block; usually match message.")
+  ),
+  blockId: optionalSchema(stringSchema("Optional stable interactive block id.")),
+  buttons: optionalSchema(arraySchema(shadowInteractiveButtonSchema, { maxItems: 8 })),
+  options: optionalSchema(arraySchema(shadowInteractiveSelectOptionSchema, { maxItems: 20 })),
+  fields: optionalSchema(arraySchema(shadowInteractiveFormFieldSchema, { maxItems: 12 })),
+  submitLabel: optionalSchema(stringSchema("Submit button label for form dialogs.")),
+  responsePrompt: optionalSchema(
+    stringSchema("Instruction sent back to the Buddy when this form is submitted.")
+  ),
+  approvalCommentLabel: optionalSchema(
+    stringSchema("Optional comment label for approval dialogs.")
+  ),
+  oneShot: optionalSchema(booleanSchema("Disable the dialog after one response.")),
+  media: optionalSchema(stringSchema("Attachment source URL or local path for file upload.")),
+  mediaUrl: optionalSchema(stringSchema("Alias for media.")),
+  url: optionalSchema(stringSchema("Alias for media.")),
+  path: optionalSchema(stringSchema("Local attachment path.")),
+  filePath: optionalSchema(stringSchema("Local attachment path alias.")),
+  file: optionalSchema(stringSchema("Local attachment path alias.")),
+  fileUrl: optionalSchema(stringSchema("Attachment URL alias.")),
+  buffer: optionalSchema(stringSchema("Base64 attachment payload for file upload.")),
+  filename: optionalSchema(stringSchema("Attachment filename when buffer is used.")),
+  contentType: optionalSchema(stringSchema("Attachment MIME type when buffer is used.")),
+  mimeType: optionalSchema(stringSchema("Alias for contentType.")),
+  caption: optionalSchema(stringSchema("Optional text sent with an attachment.")),
+  commerceOfferId: optionalSchema(
+    stringSchema("Shadow CommerceOfferId to attach as a purchasable product card.")
+  ),
+  offerId: optionalSchema(stringSchema("Alias for commerceOfferId."))
+};
+function buildShadowMessageToolSchemaProperties(input) {
+  const offers = (input?.commerceOffers ?? []).filter((offer) => offer.offerId?.trim() && !offer.offerId.includes("${env:")).slice(0, 12);
+  if (offers.length === 0) return shadowMessageToolSchemaProperties;
+  const offerHints = offers.map((offer) => {
+    const label = offer.name ?? offer.seedId ?? offer.offerId;
+    const summary = offer.summary ? ` - ${offer.summary}` : "";
+    return `${label}: ${offer.offerId}${summary}`;
+  }).join("; ");
+  return {
+    ...shadowMessageToolSchemaProperties,
+    commerceOfferId: optionalSchema(
+      stringSchema(
+        `Attach one of the available Shadow commerce offers as a purchasable product card. Available CommerceOfferIds: ${offerHints}. Use only when the user wants to buy, view pricing, or receive a product card.`
+      )
+    ),
+    offerId: optionalSchema(stringSchema("Alias for commerceOfferId."))
+  };
+}
+
+// src/channel/actions.ts
+var SHADOW_DISCOVERED_ACTIONS = ["send", "upload-file", "react", "edit", "delete"];
+var SHADOW_HANDLED_ACTIONS = [...SHADOW_DISCOVERED_ACTIONS, "get-connection-status"];
+function textResult(value) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(value)
+      }
+    ],
+    details: value
+  };
+}
+function readAttachmentSource(params) {
+  return firstString(
+    params.media,
+    params.mediaUrl,
+    params.mediaURL,
+    params.url,
+    params.path,
+    params.filePath,
+    params.file,
+    params.fileUrl,
+    params.fileURL
+  ) ?? "";
+}
+function hasAttachmentPayload(params) {
+  return Boolean(firstString(params.buffer) || readAttachmentSource(params));
+}
+function readAttachmentContentType(params) {
+  return firstString(params.contentType, params.mimeType) ?? "application/octet-stream";
+}
+function readAttachmentFilename(params) {
+  return firstString(params.filename, params.title) ?? "file";
+}
+function readCommerceOfferId(params) {
+  return firstString(params.commerceOfferId, params.offerId);
+}
+function buildSendMetadata(params) {
+  const metadata = {};
+  if (params.interactiveBlock) metadata.interactive = params.interactiveBlock;
+  if (params.commerceOfferId) {
+    metadata.commerceCards = [{ kind: "offer", offerId: params.commerceOfferId }];
+  }
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+async function uploadShadowAttachment(params) {
+  const contentType = readAttachmentContentType(params.actionParams);
+  const filename = readAttachmentFilename(params.actionParams);
+  const uploadTarget = params.messageId;
+  const base64Buffer = firstString(params.actionParams.buffer);
+  const mediaUrl = readAttachmentSource(params.actionParams);
+  if (base64Buffer) {
+    const raw = base64Buffer.includes(",") ? base64Buffer.split(",")[1] ?? "" : base64Buffer;
+    if (!raw) throw new Error("Invalid base64 attachment payload");
+    const bytes = Buffer.from(raw, "base64");
+    const blob = new Blob([Uint8Array.from(bytes)], { type: contentType });
+    await params.client.uploadMedia(blob, filename, contentType, uploadTarget);
+    return { filename, contentType, source: "buffer" };
+  }
+  if (mediaUrl) {
+    await params.client.uploadMediaFromUrl(mediaUrl, uploadTarget);
+    return { filename, contentType, source: "media", mediaUrl };
+  }
+  throw new Error("No buffer or media URL provided for attachment");
+}
+var shadowMessageActions = {
+  describeMessageTool: ({
+    cfg,
+    accountId
+  }) => {
+    const account = getAccountConfig(cfg, accountId ?? DEFAULT_ACCOUNT_ID);
+    return {
+      actions: [...SHADOW_DISCOVERED_ACTIONS],
+      capabilities: ["interactive"],
+      schema: {
+        visibility: "current-channel",
+        properties: buildShadowMessageToolSchemaProperties({
+          commerceOffers: account?.commerceOffers
+        })
+      },
+      mediaSourceParams: {
+        "upload-file": [
+          "media",
+          "mediaUrl",
+          "url",
+          "path",
+          "filePath",
+          "file",
+          "fileUrl",
+          "buffer"
+        ]
+      }
+    };
+  },
+  messageActionTargetAliases: {
+    "upload-file": { aliases: ["recipient", "to", "channelId"] }
+  },
+  supportsAction: ({ action }) => SHADOW_HANDLED_ACTIONS.includes(action),
+  handleAction: async (ctx) => {
+    const account = getAccountConfig(ctx.cfg, ctx.accountId ?? DEFAULT_ACCOUNT_ID);
+    if (!account) {
+      return textResult({ ok: false, error: "Shadow account not configured" });
+    }
+    const requestedAction = String(ctx.action);
+    const action = requestedAction;
+    const { params } = ctx;
+    if (action === "send") {
+      try {
+        const client = new ShadowClient2(account.serverUrl, account.token);
+        const to = readMessageTarget(params);
+        if (!to) return textResult({ ok: false, error: "target is required" });
+        const interactiveBlock = resolveShadowInteractiveBlock(params);
+        const commerceOfferId = readCommerceOfferId(params);
+        const hasAttachment = hasAttachmentPayload(params);
+        const content = firstString(params.message, params.content, params.text, params.caption, params.prompt) ?? (interactiveBlock ? "[interactive]" : "");
+        if (!content.trim() && !interactiveBlock && !hasAttachment && !commerceOfferId) {
+          return textResult({
+            ok: false,
+            error: "message, attachment, or commerceOfferId is required"
+          });
+        }
+        const approvalError = validateApprovalMessageContent(content, interactiveBlock);
+        if (approvalError) return textResult({ ok: false, error: approvalError });
+        const message = await sendShadowMessage({
+          client,
+          to,
+          content: content.trim() ? content : interactiveBlock ? "[interactive]" : "\u200B",
+          threadId: params.threadId,
+          replyToId: params.replyTo ?? params.replyToId,
+          metadata: buildSendMetadata({ interactiveBlock, commerceOfferId })
+        });
+        const attachment = hasAttachment ? await uploadShadowAttachment({
+          client,
+          to,
+          messageId: message.id,
+          actionParams: params
+        }) : void 0;
+        return textResult({
+          ok: true,
+          action: "send",
+          messageId: message.id,
+          interactive: !!interactiveBlock,
+          kind: interactiveBlock?.kind,
+          commerceCard: !!commerceOfferId,
+          offerId: commerceOfferId,
+          attachment: !!attachment,
+          filename: attachment?.filename
+        });
+      } catch (err) {
+        return textResult({ ok: false, error: err instanceof Error ? err.message : String(err) });
+      }
+    }
+    if (action === "upload-file") {
+      try {
+        const client = new ShadowClient2(account.serverUrl, account.token);
+        const to = readMessageTarget(params);
+        if (!to) return textResult({ ok: false, error: "target is required" });
+        if (!hasAttachmentPayload(params)) {
+          return textResult({
+            ok: false,
+            error: "upload-file requires buffer, media, path, or filePath"
+          });
+        }
+        const text = firstString(params.message, params.content, params.text, params.caption) ?? "";
+        const message = await sendShadowMessage({
+          client,
+          to,
+          content: text || "\u200B",
+          threadId: params.threadId,
+          replyToId: params.replyTo ?? params.replyToId
+        });
+        const attachment = await uploadShadowAttachment({
+          client,
+          to,
+          messageId: message.id,
+          actionParams: params
+        });
+        return textResult({
+          ok: true,
+          action: requestedAction,
+          canonicalAction: "upload-file",
+          messageId: message.id,
+          filename: attachment.filename
+        });
+      } catch (err) {
+        return textResult({ ok: false, error: err instanceof Error ? err.message : String(err) });
+      }
+    }
+    if (action === "react") {
+      const client = new ShadowClient2(account.serverUrl, account.token);
+      const messageId = params.messageId ?? params.message_id ?? "";
+      const emoji = params.emoji ?? params.reaction ?? "";
+      if (!messageId || !emoji) {
+        return textResult({ ok: false, error: "messageId and emoji are required" });
+      }
+      try {
+        await client.addReaction(messageId, emoji);
+        return textResult({ ok: true, action: "react", messageId, emoji });
+      } catch (err) {
+        return textResult({ ok: false, error: String(err) });
+      }
+    }
+    if (action === "edit") {
+      const client = new ShadowClient2(account.serverUrl, account.token);
+      const messageId = params.messageId ?? params.message_id ?? "";
+      const content = params.message ?? params.content ?? "";
+      if (!messageId || !content) {
+        return textResult({ ok: false, error: "messageId and content are required" });
+      }
+      try {
+        await client.editMessage(messageId, content);
+        return textResult({ ok: true, action: "edit", messageId });
+      } catch (err) {
+        return textResult({ ok: false, error: String(err) });
+      }
+    }
+    if (action === "delete") {
+      const client = new ShadowClient2(account.serverUrl, account.token);
+      const messageId = params.messageId ?? params.message_id ?? "";
+      if (!messageId) {
+        return textResult({ ok: false, error: "messageId is required" });
+      }
+      try {
+        await client.deleteMessage(messageId);
+        return textResult({ ok: true, action: "delete", messageId });
+      } catch (err) {
+        return textResult({ ok: false, error: String(err) });
+      }
+    }
+    if (action === "pin" || action === "unpin") {
+      return textResult({ ok: false, error: `${action} is not yet supported for Shadow channels` });
+    }
+    if (action === "get-connection-status") {
+      const accountIds = listAccountIds(ctx.cfg);
+      const results = await Promise.all(
+        accountIds.map(async (id) => {
+          const acc = getAccountConfig(ctx.cfg, id);
+          if (!acc) return { accountId: id, configured: false, ok: false, error: "not configured" };
+          if (!acc.token?.trim())
+            return { accountId: id, configured: false, ok: false, error: "no token" };
+          try {
+            const client = new ShadowClient2(acc.serverUrl, acc.token);
+            const me = await client.getMe();
+            return {
+              accountId: id,
+              configured: true,
+              enabled: acc.enabled !== false,
+              ok: true,
+              serverUrl: acc.serverUrl,
+              user: me
+            };
+          } catch (err) {
+            return {
+              accountId: id,
+              configured: true,
+              enabled: acc.enabled !== false,
+              ok: false,
+              serverUrl: acc.serverUrl,
+              error: err instanceof Error ? err.message : String(err)
+            };
+          }
+        })
+      );
+      return textResult({ ok: true, action: "get-connection-status", accounts: results });
+    }
+    return textResult({ ok: false, error: `Action ${action} not yet implemented` });
+  }
+};
+
+// src/channel/prompt.ts
+var shadowAgentPromptHints = [
+  "- When a Shadow user asks for buttons, choices, a select menu, a form, or approval, prefer sending a Shadow interactive dialog instead of plain text options.",
+  "- ShadowOwnBuddy enables inline buttons, forms, and file uploads for Shadow channels by default. Do not tell the user that `shadowob.capabilities.inlineButtons` or file sending is unavailable; use the message tool instead.",
+  '- Shadow interactive dialogs use the shared message tool with `action: "send"` plus `target`, `message`, `kind`, `prompt`, and shape fields. `message` is required by the shared tool; set `message` and `prompt` to the same user-visible text unless there is a specific reason not to. Supported `kind` values are `buttons`, `select`, `form`, and `approval`; Shadow stores these as `metadata.interactive` so the user can answer in-channel.',
+  '- Example buttons dialog: `action: "send"`, `target: "shadowob:channel:<ChannelId>"`, `message: "Choose the next step"`, `kind: "buttons"`, `prompt: "Choose the next step"`, `buttons: [{"id":"icp","label":"ICP / JTBD","value":"icp"}]`.',
+  '- Example form dialog: `action: "send"`, `target: "shadowob:channel:<ChannelId>"`, `message: "Fill the decision inputs"`, `kind: "form"`, `fields: [{"id":"decision","label":"Decision","kind":"textarea","required":true}]`.',
+  '- When Shadow context includes CommerceOfferIds and the user is interested in buying, viewing pricing, or receiving a product card, call the shared message tool yourself: `action: "send"`, `target: "shadowob:channel:<ChannelId>"`, `message: "A natural sales message"`, `commerceOfferId: "<CommerceOfferId>"`. Plain final text will not attach a product card.',
+  '- When a Shadow user asks for a file, prefer the shared message tool with `action: "send"` plus `target`, `message` or `caption`, and `path`/`filePath`/`media`. For a file-only upload, use OpenClaw\'s canonical `action: "upload-file"` plus `target`, `path`/`filePath`/`media` or `buffer`, optional `filename`, `contentType`, and `caption`. Shadow accepts arbitrary attachment types, including HTML; send the file directly instead of pasting source code as a workaround.',
+  "- Never use an `approval` dialog as a substitute for the proposal. Put the concrete roadmap, MVP scope, plan, or decision in `message` first; the approval block only locks that visible proposal."
+];
+
+// src/channel/plugin.ts
+var shadowPlugin = createChatChannelPlugin({
+  base: {
+    id: "shadowob",
+    meta: shadowPluginMeta,
+    capabilities: shadowPluginCapabilities,
+    config: shadowPluginConfig,
+    setup: shadowPluginSetup
+  },
+  threading: {
+    topLevelReplyToMode: "reply",
+    resolveReplyToMode: ({ cfg }) => {
+      const shadow = cfg.channels?.shadowob ?? cfg.channels?.["openclaw-shadowob"];
+      const mode = shadow?.replyToMode;
+      if (mode === "first" || mode === "all" || mode === "off") return mode;
+      return "first";
+    }
+  },
+  outbound: shadowOutbound
+});
+shadowPlugin.meta = shadowPluginMeta;
+shadowPlugin.capabilities = shadowPluginCapabilities;
+shadowPlugin.reload = {
+  configPrefixes: ["channels.shadowob"]
+};
+shadowPlugin.defaults = {
+  queue: { debounceMs: 500 }
+};
+shadowPlugin.configSchema = shadowPluginConfigSchema;
+shadowPlugin.agentPrompt = {
+  messageToolHints: () => shadowAgentPromptHints
+};
+shadowPlugin.mentions = {
+  stripPatterns: () => ["@[\\w-]+"]
+};
+shadowPlugin.streaming = {
+  blockStreamingCoalesceDefaults: { minChars: 1500, idleMs: 1e3 }
+};
+shadowPlugin.messaging = {
+  normalizeTarget: (raw) => {
+    if (/^(shadowob|openclaw-shadowob):(channel|thread):.+$/i.test(raw)) return raw;
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(raw)) {
+      return `shadowob:channel:${raw}`;
+    }
+    return void 0;
+  },
+  parseExplicitTarget: ({ raw }) => {
+    const normalized = shadowPlugin.messaging?.normalizeTarget?.(raw);
+    if (!normalized) return null;
+    const match = normalized.match(/^(?:shadowob|openclaw-shadowob):(channel|thread):(.+)$/i);
+    if (!match) return { to: normalized, chatType: "channel" };
+    return match[1] === "thread" ? { to: normalized, threadId: match[2], chatType: "channel" } : { to: normalized, chatType: "channel" };
+  },
+  inferTargetChatType: () => "channel",
+  resolveSessionTarget: ({ id, threadId }) => threadId ? `shadowob:channel:${id}:thread:${threadId}` : `shadowob:channel:${id}`,
+  resolveOutboundSessionRoute: ({ cfg, agentId, accountId, target, threadId }) => {
+    const normalized = shadowPlugin.messaging?.normalizeTarget?.(target) ?? target;
+    const match = normalized.match(/^(?:shadowob|openclaw-shadowob):(channel|thread):(.+)$/i);
+    if (!match) return null;
+    const kind = match[1];
+    const id = match[2];
+    const route = buildChannelOutboundSessionRoute({
+      cfg,
+      agentId,
+      channel: "shadowob",
+      accountId,
+      peer: { kind: "channel", id },
+      chatType: "channel",
+      from: `shadowob:${kind}:${id}`,
+      to: `shadowob:${kind}:${id}`,
+      threadId: kind === "thread" ? id : void 0
+    });
+    return buildThreadAwareOutboundSessionRoute({
+      route,
+      threadId: kind === "thread" ? id : threadId,
+      precedence: ["threadId"],
+      useSuffix: false
+    });
+  },
+  targetResolver: {
+    looksLikeId: (raw) => /^(shadowob|openclaw-shadowob):(channel|thread):.+$/i.test(raw) || /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(raw),
+    hint: "Provide a Shadow channel UUID or shadowob:channel:<uuid>"
+  }
+};
+shadowPlugin.status = {
+  defaultRuntime: {
+    accountId: DEFAULT_ACCOUNT_ID,
+    running: false,
+    lastStartAt: null,
+    lastStopAt: null,
+    lastError: null
+  },
+  probeAccount: async ({
+    account,
+    timeoutMs
+  }) => {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const client = new ShadowClient3(account.serverUrl, account.token);
+      const me = await client.getMe();
+      return { ok: true, user: me };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    } finally {
+      clearTimeout(timeout);
+    }
+  },
+  buildAccountSnapshot: ({
+    account,
+    runtime,
+    probe
+  }) => ({
+    accountId: DEFAULT_ACCOUNT_ID,
+    enabled: account?.enabled !== false,
+    configured: !!account?.token?.trim(),
+    running: runtime?.running ?? false,
+    lastStartAt: runtime?.lastStartAt ?? null,
+    lastStopAt: runtime?.lastStopAt ?? null,
+    lastError: runtime?.lastError ?? null,
+    probe
+  }),
+  buildChannelSummary: ({
+    snapshot
+  }) => ({
+    configured: snapshot.configured ?? false,
+    running: snapshot.running ?? false,
+    lastStartAt: snapshot.lastStartAt ?? null,
+    lastStopAt: snapshot.lastStopAt ?? null,
+    lastError: snapshot.lastError ?? null,
+    probe: snapshot.probe
+  })
+};
+shadowPlugin.gateway = {
+  startAccount: async (ctx) => {
+    const account = ctx.account;
+    const accountId = ctx.accountId;
+    ctx.setStatus({
+      accountId,
+      running: true,
+      lastStartAt: Date.now(),
+      lastError: null
+    });
+    ctx.log?.info(`Starting Shadow connection for account ${accountId}`);
+    const { monitorShadowProvider: monitorShadowProvider2 } = await import("./monitor-AE3LRQYD.js");
+    await monitorShadowProvider2({
+      account,
+      accountId,
+      config: ctx.cfg,
+      runtime: {
+        log: (msg) => ctx.log?.info(msg),
+        error: (msg) => ctx.log?.error(msg)
+      },
+      abortSignal: ctx.abortSignal,
+      channelRuntime: ctx.channelRuntime
+    });
+  },
+  stopAccount: async (ctx) => {
+    ctx.setStatus({
+      accountId: ctx.accountId,
+      running: false,
+      lastStopAt: Date.now()
+    });
+    ctx.log?.info(`Stopped Shadow connection for account ${ctx.accountId}`);
+  }
+};
+shadowPlugin.heartbeat = {
+  sendTyping: async ({ cfg, to, accountId, threadId }) => {
+    const account = resolveAccount(cfg, accountId);
+    if (!account.token?.trim()) return;
+    const normalized = shadowPlugin.messaging?.normalizeTarget?.(to) ?? to;
+    const match = normalized.match(/^(?:shadowob|openclaw-shadowob):(channel|thread):(.+)$/i);
+    const channelId = match?.[1] === "channel" ? match[2] : void 0;
+    const targetChannelId = channelId ?? (threadId ? void 0 : normalized);
+    if (!targetChannelId) return;
+    const { ShadowSocket } = await import("@shadowob/sdk");
+    const socket = new ShadowSocket({
+      serverUrl: account.serverUrl,
+      token: account.token,
+      transports: ["websocket", "polling"]
+    });
+    socket.connect();
+    await new Promise((resolve) => {
+      socket.onConnect(() => {
+        socket.sendTyping(targetChannelId);
+        socket.disconnect();
+        resolve();
+      });
+      socket.onConnectError(() => {
+        socket.disconnect();
+        resolve();
+      });
+      setTimeout(() => {
+        socket.disconnect();
+        resolve();
+      }, 3e3);
+    });
+  }
+};
+shadowPlugin.actions = shadowMessageActions;
+
+// index.ts
+import { ShadowClient as ShadowClient4 } from "@shadowob/sdk";
 var index_default = defineChannelPluginEntry({
   id: "openclaw-shadowob",
   name: "ShadowOwnBuddy",
@@ -21,7 +1028,7 @@ var index_default = defineChannelPluginEntry({
   }
 });
 export {
-  ShadowClient,
+  ShadowClient4 as ShadowClient,
   index_default as default,
   getShadowRuntime,
   monitorShadowProvider,