openclaw-multi-auto 1.3.6 → 1.3.8

package/ui/src/ui/controllers/chat.ts

@@ -0,0 +1,318 @@
+import { extractText } from "../chat/message-extract.ts";
+import type { GatewayBrowserClient } from "../gateway.ts";
+import type { ChatAttachment } from "../ui-types.ts";
+import { generateUUID } from "../uuid.ts";
+
+const SILENT_REPLY_PATTERN = /^\s*NO_REPLY\s*$/;
+
+function isSilentReplyStream(text: string): boolean {
+  return SILENT_REPLY_PATTERN.test(text);
+}
+/** Client-side defense-in-depth: detect assistant messages whose text is purely NO_REPLY. */
+function isAssistantSilentReply(message: unknown): boolean {
+  if (!message || typeof message !== "object") {
+    return false;
+  }
+  const entry = message as Record<string, unknown>;
+  const role = typeof entry.role === "string" ? entry.role.toLowerCase() : "";
+  if (role !== "assistant") {
+    return false;
+  }
+  // entry.text takes precedence — matches gateway extractAssistantTextForSilentCheck
+  if (typeof entry.text === "string") {
+    return isSilentReplyStream(entry.text);
+  }
+  const text = extractText(message);
+  return typeof text === "string" && isSilentReplyStream(text);
+}
+
+export type ChatState = {
+  client: GatewayBrowserClient | null;
+  connected: boolean;
+  sessionKey: string;
+  chatLoading: boolean;
+  chatMessages: unknown[];
+  chatThinkingLevel: string | null;
+  chatSending: boolean;
+  chatMessage: string;
+  chatAttachments: ChatAttachment[];
+  chatRunId: string | null;
+  chatStream: string | null;
+  chatStreamStartedAt: number | null;
+  lastError: string | null;
+};
+
+export type ChatEventPayload = {
+  runId: string;
+  sessionKey: string;
+  state: "delta" | "final" | "aborted" | "error";
+  message?: unknown;
+  errorMessage?: string;
+};
+
+export async function loadChatHistory(state: ChatState) {
+  if (!state.client || !state.connected) {
+    return;
+  }
+  state.chatLoading = true;
+  state.lastError = null;
+  try {
+    const res = await state.client.request<{ messages?: Array<unknown>; thinkingLevel?: string }>(
+      "chat.history",
+      {
+        sessionKey: state.sessionKey,
+        limit: 200,
+      },
+    );
+    const messages = Array.isArray(res.messages) ? res.messages : [];
+    state.chatMessages = messages.filter((message) => !isAssistantSilentReply(message));
+    state.chatThinkingLevel = res.thinkingLevel ?? null;
+  } catch (err) {
+    state.lastError = String(err);
+  } finally {
+    state.chatLoading = false;
+  }
+}
+
+function dataUrlToBase64(dataUrl: string): { content: string; mimeType: string } | null {
+  const match = /^data:([^;]+);base64,(.+)$/.exec(dataUrl);
+  if (!match) {
+    return null;
+  }
+  return { mimeType: match[1], content: match[2] };
+}
+
+type AssistantMessageNormalizationOptions = {
+  roleRequirement: "required" | "optional";
+  roleCaseSensitive?: boolean;
+  requireContentArray?: boolean;
+  allowTextField?: boolean;
+};
+
+function normalizeAssistantMessage(
+  message: unknown,
+  options: AssistantMessageNormalizationOptions,
+): Record<string, unknown> | null {
+  if (!message || typeof message !== "object") {
+    return null;
+  }
+  const candidate = message as Record<string, unknown>;
+  const roleValue = candidate.role;
+  if (typeof roleValue === "string") {
+    const role = options.roleCaseSensitive ? roleValue : roleValue.toLowerCase();
+    if (role !== "assistant") {
+      return null;
+    }
+  } else if (options.roleRequirement === "required") {
+    return null;
+  }
+
+  if (options.requireContentArray) {
+    return Array.isArray(candidate.content) ? candidate : null;
+  }
+  if (!("content" in candidate) && !(options.allowTextField && "text" in candidate)) {
+    return null;
+  }
+  return candidate;
+}
+
+function normalizeAbortedAssistantMessage(message: unknown): Record<string, unknown> | null {
+  return normalizeAssistantMessage(message, {
+    roleRequirement: "required",
+    roleCaseSensitive: true,
+    requireContentArray: true,
+  });
+}
+
+function normalizeFinalAssistantMessage(message: unknown): Record<string, unknown> | null {
+  return normalizeAssistantMessage(message, {
+    roleRequirement: "optional",
+    allowTextField: true,
+  });
+}
+
+export async function sendChatMessage(
+  state: ChatState,
+  message: string,
+  attachments?: ChatAttachment[],
+): Promise<string | null> {
+  if (!state.client || !state.connected) {
+    return null;
+  }
+  const msg = message.trim();
+  const hasAttachments = attachments && attachments.length > 0;
+  if (!msg && !hasAttachments) {
+    return null;
+  }
+
+  const now = Date.now();
+
+  // Build user message content blocks
+  const contentBlocks: Array<{ type: string; text?: string; source?: unknown }> = [];
+  if (msg) {
+    contentBlocks.push({ type: "text", text: msg });
+  }
+  // Add image previews to the message for display
+  if (hasAttachments) {
+    for (const att of attachments) {
+      contentBlocks.push({
+        type: "image",
+        source: { type: "base64", media_type: att.mimeType, data: att.dataUrl },
+      });
+    }
+  }
+
+  state.chatMessages = [
+    ...state.chatMessages,
+    {
+      role: "user",
+      content: contentBlocks,
+      timestamp: now,
+    },
+  ];
+
+  state.chatSending = true;
+  state.lastError = null;
+  const runId = generateUUID();
+  state.chatRunId = runId;
+  state.chatStream = "";
+  state.chatStreamStartedAt = now;
+
+  // Convert attachments to API format
+  const apiAttachments = hasAttachments
+    ? attachments
+        .map((att) => {
+          const parsed = dataUrlToBase64(att.dataUrl);
+          if (!parsed) {
+            return null;
+          }
+          return {
+            type: "image",
+            mimeType: parsed.mimeType,
+            content: parsed.content,
+          };
+        })
+        .filter((a): a is NonNullable<typeof a> => a !== null)
+    : undefined;
+
+  try {
+    await state.client.request("chat.send", {
+      sessionKey: state.sessionKey,
+      message: msg,
+      deliver: false,
+      idempotencyKey: runId,
+      attachments: apiAttachments,
+    });
+    return runId;
+  } catch (err) {
+    const error = String(err);
+    state.chatRunId = null;
+    state.chatStream = null;
+    state.chatStreamStartedAt = null;
+    state.lastError = error;
+    state.chatMessages = [
+      ...state.chatMessages,
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "Error: " + error }],
+        timestamp: Date.now(),
+      },
+    ];
+    return null;
+  } finally {
+    state.chatSending = false;
+  }
+}
+
+export async function abortChatRun(state: ChatState): Promise<boolean> {
+  if (!state.client || !state.connected) {
+    return false;
+  }
+  const runId = state.chatRunId;
+  try {
+    await state.client.request(
+      "chat.abort",
+      runId ? { sessionKey: state.sessionKey, runId } : { sessionKey: state.sessionKey },
+    );
+    return true;
+  } catch (err) {
+    state.lastError = String(err);
+    return false;
+  }
+}
+
+export function handleChatEvent(state: ChatState, payload?: ChatEventPayload) {
+  if (!payload) {
+    return null;
+  }
+  if (payload.sessionKey !== state.sessionKey) {
+    return null;
+  }
+
+  // Final from another run (e.g. sub-agent announce): refresh history to show new message.
+  // See https://github.com/openclaw/openclaw/issues/1909
+  if (payload.runId && state.chatRunId && payload.runId !== state.chatRunId) {
+    if (payload.state === "final") {
+      const finalMessage = normalizeFinalAssistantMessage(payload.message);
+      if (finalMessage && !isAssistantSilentReply(finalMessage)) {
+        state.chatMessages = [...state.chatMessages, finalMessage];
+        return null;
+      }
+      return "final";
+    }
+    return null;
+  }
+
+  if (payload.state === "delta") {
+    const next = extractText(payload.message);
+    if (typeof next === "string" && !isSilentReplyStream(next)) {
+      const current = state.chatStream ?? "";
+      if (!current || next.length >= current.length) {
+        state.chatStream = next;
+      }
+    }
+  } else if (payload.state === "final") {
+    const finalMessage = normalizeFinalAssistantMessage(payload.message);
+    if (finalMessage && !isAssistantSilentReply(finalMessage)) {
+      state.chatMessages = [...state.chatMessages, finalMessage];
+    } else if (state.chatStream?.trim() && !isSilentReplyStream(state.chatStream)) {
+      state.chatMessages = [
+        ...state.chatMessages,
+        {
+          role: "assistant",
+          content: [{ type: "text", text: state.chatStream }],
+          timestamp: Date.now(),
+        },
+      ];
+    }
+    state.chatStream = null;
+    state.chatRunId = null;
+    state.chatStreamStartedAt = null;
+  } else if (payload.state === "aborted") {
+    const normalizedMessage = normalizeAbortedAssistantMessage(payload.message);
+    if (normalizedMessage && !isAssistantSilentReply(normalizedMessage)) {
+      state.chatMessages = [...state.chatMessages, normalizedMessage];
+    } else {
+      const streamedText = state.chatStream ?? "";
+      if (streamedText.trim() && !isSilentReplyStream(streamedText)) {
+        state.chatMessages = [
+          ...state.chatMessages,
+          {
+            role: "assistant",
+            content: [{ type: "text", text: streamedText }],
+            timestamp: Date.now(),
+          },
+        ];
+      }
+    }
+    state.chatStream = null;
+    state.chatRunId = null;
+    state.chatStreamStartedAt = null;
+  } else if (payload.state === "error") {
+    state.chatStream = null;
+    state.chatRunId = null;
+    state.chatStreamStartedAt = null;
+    state.lastError = payload.errorMessage ?? "chat error";
+  }
+  return payload.state;
+}

package/ui/src/ui/controllers/config/form-coerce.ts

@@ -0,0 +1,160 @@
+import { schemaType, type JsonSchema } from "../../views/config-form.shared.ts";
+
+function coerceNumberString(value: string, integer: boolean): number | undefined | string {
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    return undefined;
+  }
+  const parsed = Number(trimmed);
+  if (!Number.isFinite(parsed)) {
+    return value;
+  }
+  if (integer && !Number.isInteger(parsed)) {
+    return value;
+  }
+  return parsed;
+}
+
+function coerceBooleanString(value: string): boolean | string {
+  const trimmed = value.trim();
+  if (trimmed === "true") {
+    return true;
+  }
+  if (trimmed === "false") {
+    return false;
+  }
+  return value;
+}
+
+/**
+ * Walk a form value tree alongside its JSON Schema and coerce string values
+ * to their schema-defined types (number, boolean).
+ *
+ * HTML `<input>` elements always produce string `.value` properties.  Even
+ * though the form rendering code converts values correctly for most paths,
+ * some interactions (map-field repopulation, re-renders, paste, etc.) can
+ * leak raw strings into the config form state.  This utility acts as a
+ * safety net before serialization so that `config.set` always receives
+ * correctly typed JSON.
+ */
+export function coerceFormValues(value: unknown, schema: JsonSchema): unknown {
+  if (value === null || value === undefined) {
+    return value;
+  }
+
+  if (schema.allOf && schema.allOf.length > 0) {
+    let next: unknown = value;
+    for (const segment of schema.allOf) {
+      next = coerceFormValues(next, segment);
+    }
+    return next;
+  }
+
+  const type = schemaType(schema);
+
+  // Handle anyOf/oneOf — try to match the value against a variant
+  if (schema.anyOf || schema.oneOf) {
+    const variants = (schema.anyOf ?? schema.oneOf ?? []).filter(
+      (v) => !(v.type === "null" || (Array.isArray(v.type) && v.type.includes("null"))),
+    );
+
+    if (variants.length === 1) {
+      return coerceFormValues(value, variants[0]);
+    }
+
+    // Try number/boolean coercion for string values
+    if (typeof value === "string") {
+      for (const variant of variants) {
+        const variantType = schemaType(variant);
+        if (variantType === "number" || variantType === "integer") {
+          const coerced = coerceNumberString(value, variantType === "integer");
+          if (coerced === undefined || typeof coerced === "number") {
+            return coerced;
+          }
+        }
+        if (variantType === "boolean") {
+          const coerced = coerceBooleanString(value);
+          if (typeof coerced === "boolean") {
+            return coerced;
+          }
+        }
+      }
+    }
+
+    // For non-string values (objects, arrays), try to recurse into matching variant
+    for (const variant of variants) {
+      const variantType = schemaType(variant);
+      if (variantType === "object" && typeof value === "object" && !Array.isArray(value)) {
+        return coerceFormValues(value, variant);
+      }
+      if (variantType === "array" && Array.isArray(value)) {
+        return coerceFormValues(value, variant);
+      }
+    }
+
+    return value;
+  }
+
+  if (type === "number" || type === "integer") {
+    if (typeof value === "string") {
+      const coerced = coerceNumberString(value, type === "integer");
+      if (coerced === undefined || typeof coerced === "number") {
+        return coerced;
+      }
+    }
+    return value;
+  }
+
+  if (type === "boolean") {
+    if (typeof value === "string") {
+      const coerced = coerceBooleanString(value);
+      if (typeof coerced === "boolean") {
+        return coerced;
+      }
+    }
+    return value;
+  }
+
+  if (type === "object") {
+    if (typeof value !== "object" || Array.isArray(value)) {
+      return value;
+    }
+    const obj = value as Record<string, unknown>;
+    const props = schema.properties ?? {};
+    const additional =
+      schema.additionalProperties && typeof schema.additionalProperties === "object"
+        ? schema.additionalProperties
+        : null;
+    const result: Record<string, unknown> = {};
+    for (const [key, val] of Object.entries(obj)) {
+      const propSchema = props[key] ?? additional;
+      const coerced = propSchema ? coerceFormValues(val, propSchema) : val;
+      // Omit undefined — "clear field = unset" for optional properties
+      if (coerced !== undefined) {
+        result[key] = coerced;
+      }
+    }
+    return result;
+  }
+
+  if (type === "array") {
+    if (!Array.isArray(value)) {
+      return value;
+    }
+    if (Array.isArray(schema.items)) {
+      // Tuple form: each index has its own schema
+      const tuple = schema.items;
+      return value.map((item, i) => {
+        const s = i < tuple.length ? tuple[i] : undefined;
+        return s ? coerceFormValues(item, s) : item;
+      });
+    }
+    const itemsSchema = schema.items;
+    if (!itemsSchema) {
+      return value;
+    }
+    return value.map((item) => coerceFormValues(item, itemsSchema)).filter((v) => v !== undefined);
+  }
+
+  return value;
+}