@newbase-clawchat/openclaw-clawchat 2026.5.12-2 → 2026.5.12-21

package/src/clawchat-metadata.test.ts

@@ -0,0 +1,350 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { readClawChatMemoryFile } from "./clawchat-memory.ts";
+import {
+  pullGroupMetadata,
+  pullOwnerMetadata,
+  pullUserMetadata,
+  pushMetadata,
+  updateMetadata,
+} from "./clawchat-metadata.ts";
+
+let roots: string[] = [];
+
+function tempRoot(): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-clawchat-metadata-"));
+  roots.push(root);
+  return root;
+}
+
+afterEach(() => {
+  for (const root of roots) fs.rmSync(root, { recursive: true, force: true });
+  roots = [];
+});
+
+describe("clawchat metadata mapping", () => {
+  it("maps agent detail to owner.md metadata fields including behavior", async () => {
+    const root = tempRoot();
+    const api = {
+      getAgentDetail: vi.fn().mockResolvedValue({
+        agent: {
+          id: "agent_row_1",
+          user_id: "usr_self",
+          owner_id: "usr_owner",
+          type: "agent",
+          nickname: "Hermes\nBot",
+          avatar_url: "https://example.test/hermes.png",
+          bio: "Line 1\r\nLine 2",
+          behavior: "Be concise\rBe kind",
+          visibility: "public",
+          status: "online",
+          raw: { ignored: true },
+          updated_at: "2026-05-24T10:00:00.000Z",
+        },
+      }),
+    };
+
+    const result = await pullOwnerMetadata({
+      memoryRoot: root,
+      agentId: "agent_row_1",
+      accountUserId: "usr_self",
+      accountOwnerUserId: "usr_owner",
+      api,
+    });
+
+    expect(result).toMatchObject({ ok: true, failures: [] });
+    expect(api.getAgentDetail).toHaveBeenCalledWith("agent_row_1");
+    await expect(readClawChatMemoryFile(root, { targetType: "owner", targetId: "owner" }))
+      .resolves.toMatchObject({
+        metadata: {
+          updated_at: "2026-05-24T10:00:00.000Z",
+          agent_id: "usr_self",
+          owner_id: "usr_owner",
+          nickname: "Hermes Bot",
+          avatar_url: "https://example.test/hermes.png",
+          bio: "Line 1 Line 2",
+          behavior: "Be concise Be kind",
+        },
+      });
+    const file = fs.readFileSync(path.join(root, "owner.md"), "utf8");
+    expect(file).not.toContain("visibility");
+    expect(file).not.toContain("status");
+    expect(file).not.toContain("raw");
+    expect(file).not.toContain("type:");
+  });
+
+  it("maps user profile to users/<id>.md metadata fields and drops unknown fields", async () => {
+    const root = tempRoot();
+    const api = {
+      getUserProfile: vi.fn().mockResolvedValue({
+        id: "usr_peer",
+        type: "user",
+        nickname: "Peer",
+        avatar_url: "https://example.test/peer.png",
+        bio: "",
+        display_name: "Dropped display name",
+        kind: "dropped",
+        updated_at: "2026-05-24T10:01:00.000Z",
+      }),
+    };
+
+    await pullUserMetadata({ memoryRoot: root, userId: "usr_peer", api });
+
+    const file = await readClawChatMemoryFile(root, { targetType: "user", targetId: "usr_peer" });
+    expect(file.metadata).toEqual({
+      updated_at: "2026-05-24T10:01:00.000Z",
+      id: "usr_peer",
+      nickname: "Peer",
+      avatar_url: "https://example.test/peer.png",
+      bio: "",
+      profile_type: "user",
+    });
+  });
+
+  it("maps conversation detail to groups/<id>.md and participant users without writing participants into group metadata", async () => {
+    const root = tempRoot();
+    const api = {
+      getConversation: vi.fn().mockResolvedValue({
+        conversation: {
+          id: "grp_1",
+          type: "group",
+          title: "Launch\nRoom",
+          description: "Planning\r\nNotes",
+          creator_id: "usr_owner",
+          created_at: "2026-05-24T09:59:00.000Z",
+          updated_at: "2026-05-24T10:02:00.000Z",
+          visibility: "private",
+          participants: [
+            {
+              conversation_id: "grp_1",
+              user_id: "usr_participant",
+              role: "member",
+              joined_at: "2026-05-24T10:03:00.000Z",
+            },
+          ],
+        },
+      }),
+      getUserProfile: vi.fn().mockResolvedValue({
+        id: "usr_participant",
+        nickname: "Participant",
+        avatar_url: "https://example.test/usr-participant.png",
+        bio: "Product lead",
+        type: "user",
+      }),
+    };
+
+    const result = await pullGroupMetadata({ memoryRoot: root, groupId: "grp_1", api });
+
+    expect(result).toMatchObject({ ok: true, failures: [] });
+    expect(api.getUserProfile).toHaveBeenCalledWith("usr_participant");
+    const groupFile = await readClawChatMemoryFile(root, { targetType: "group", targetId: "grp_1" });
+    expect(groupFile.metadata).toEqual({
+      updated_at: "2026-05-24T10:02:00.000Z",
+      id: "grp_1",
+      type: "group",
+      title: "Launch Room",
+      description: "Planning Notes",
+      creator_id: "usr_owner",
+      created_at: "2026-05-24T09:59:00.000Z",
+    });
+    expect(groupFile.raw).not.toContain("participants");
+    expect(groupFile.raw).not.toContain("usr_participant");
+
+    await expect(readClawChatMemoryFile(root, { targetType: "user", targetId: "usr_participant" }))
+      .resolves.toMatchObject({
+        metadata: {
+          id: "usr_participant",
+          nickname: "Participant",
+          avatar_url: "https://example.test/usr-participant.png",
+          bio: "Product lead",
+          profile_type: "user",
+        },
+      });
+  });
+
+  it("writes requested group target even when the response id differs", async () => {
+    const root = tempRoot();
+    const api = {
+      getConversation: vi.fn().mockResolvedValue({
+        conversation: {
+          id: "grp_response",
+          type: "group",
+          title: "Launch Room",
+          participants: [],
+        },
+      }),
+    };
+
+    await pullGroupMetadata({ memoryRoot: root, groupId: "grp_requested", api });
+
+    await expect(readClawChatMemoryFile(root, { targetType: "group", targetId: "grp_requested" }))
+      .resolves.toMatchObject({
+        exists: true,
+        metadata: { id: "grp_requested", type: "group", title: "Launch Room" },
+      });
+    await expect(readClawChatMemoryFile(root, { targetType: "group", targetId: "grp_response" }))
+      .resolves.toMatchObject({ exists: false });
+  });
+
+  it("does not overwrite an existing participant user metadata file during group pull", async () => {
+    const root = tempRoot();
+    fs.mkdirSync(path.join(root, "users"), { recursive: true });
+    fs.writeFileSync(
+      path.join(root, "users", "usr_participant.md"),
+      [
+        "<!-- clawchat:metadata:start -->",
+        "id: usr_participant",
+        "nickname: Existing",
+        "bio: Existing bio",
+        "<!-- clawchat:metadata:end -->",
+        "",
+        "Existing body.",
+      ].join("\n"),
+    );
+    const api = {
+      getConversation: vi.fn().mockResolvedValue({
+        conversation: {
+          id: "grp_1",
+          type: "group",
+          title: "Launch Room",
+          participants: [{ user_id: "usr_participant", role: "member" }],
+        },
+      }),
+      getUserProfile: vi.fn(),
+    };
+
+    await pullGroupMetadata({ memoryRoot: root, groupId: "grp_1", api });
+
+    expect(api.getUserProfile).not.toHaveBeenCalled();
+    await expect(readClawChatMemoryFile(root, { targetType: "user", targetId: "usr_participant" }))
+      .resolves.toMatchObject({
+        metadata: { id: "usr_participant", nickname: "Existing", bio: "Existing bio" },
+        body: "Existing body.",
+      });
+  });
+
+  it("returns partial participant write failures without rolling back group metadata", async () => {
+    const root = tempRoot();
+    fs.symlinkSync(os.tmpdir(), path.join(root, "users"));
+    const api = {
+      getConversation: vi.fn().mockResolvedValue({
+        conversation: {
+          id: "grp_partial",
+          type: "group",
+          title: "Partial",
+          creator_id: "usr_owner",
+          created_at: "2026-05-24T09:59:00.000Z",
+          updated_at: "2026-05-24T10:02:00.000Z",
+          participants: [{ user_id: "usr_blocked", user: { id: "usr_blocked", nickname: "Blocked" } }],
+        },
+      }),
+      getUserProfile: vi.fn().mockRejectedValue(new Error("user unavailable")),
+    };
+
+    const result = await pullGroupMetadata({ memoryRoot: root, groupId: "grp_partial", api });
+
+    expect(result.ok).toBe(false);
+    expect(result.failures).toEqual([
+      expect.objectContaining({ targetType: "user", targetId: "usr_blocked" }),
+    ]);
+    await expect(readClawChatMemoryFile(root, { targetType: "group", targetId: "grp_partial" }))
+      .resolves.toMatchObject({
+        metadata: expect.objectContaining({ id: "grp_partial", title: "Partial" }),
+      });
+  });
+});
+
+describe("clawchat metadata push and update", () => {
+  let root: string;
+
+  beforeEach(() => {
+    root = tempRoot();
+  });
+
+  it("pushes whitelisted owner metadata to the server before rewriting owner.md from the response", async () => {
+    fs.writeFileSync(
+      path.join(root, "owner.md"),
+      [
+        "<!-- clawchat:metadata:start -->",
+        "nickname: Local",
+        "avatar_url: https://example.test/local.png",
+        "bio: Local bio",
+        "behavior: local-only",
+        "<!-- clawchat:metadata:end -->",
+        "",
+        "Keep body.",
+      ].join("\n"),
+    );
+    const api = {
+      patchAgent: vi.fn().mockResolvedValue({
+        agent: {
+          id: "agent_row_1",
+          user_id: "usr_self",
+          owner_id: "usr_owner",
+          nickname: "Server",
+          avatar_url: "https://example.test/server.png",
+          bio: "Server bio",
+          behavior: "Server behavior",
+          updated_at: "2026-05-24T10:05:00.000Z",
+        },
+      }),
+    };
+
+    await pushMetadata({
+      memoryRoot: root,
+      targetType: "owner",
+      targetId: "owner",
+      fields: ["nickname", "avatar_url", "bio", "behavior"],
+      agentId: "agent_row_1",
+      accountUserId: "usr_self",
+      api,
+    });
+
+    expect(api.patchAgent).toHaveBeenCalledWith("agent_row_1", {
+      nickname: "Local",
+      avatar_url: "https://example.test/local.png",
+      bio: "Local bio",
+      behavior: "local-only",
+    });
+    await expect(readClawChatMemoryFile(root, { targetType: "owner", targetId: "owner" }))
+      .resolves.toMatchObject({
+        metadata: expect.objectContaining({ nickname: "Server", behavior: "Server behavior" }),
+        body: "Keep body.",
+      });
+  });
+
+  it("updates group metadata through the server and leaves the local file unchanged on failure", async () => {
+    fs.mkdirSync(path.join(root, "groups"));
+    fs.writeFileSync(
+      path.join(root, "groups", "grp_1.md"),
+      [
+        "<!-- clawchat:metadata:start -->",
+        "id: grp_1",
+        "title: Old",
+        "<!-- clawchat:metadata:end -->",
+        "",
+        "Group body.",
+      ].join("\n"),
+    );
+    const before = fs.readFileSync(path.join(root, "groups", "grp_1.md"), "utf8");
+    const api = {
+      patchConversation: vi.fn().mockRejectedValue(new Error("server refused")),
+    };
+
+    await expect(updateMetadata({
+      memoryRoot: root,
+      targetType: "group",
+      targetId: "grp_1",
+      patch: { title: "New", description: "New description", visibility: "dropped" },
+      api,
+    })).rejects.toThrow("server refused");
+
+    expect(api.patchConversation).toHaveBeenCalledWith("grp_1", {
+      title: "New",
+      description: "New description",
+    });
+    expect(fs.readFileSync(path.join(root, "groups", "grp_1.md"), "utf8")).toBe(before);
+  });
+});

package/src/clawchat-metadata.ts

@@ -0,0 +1,352 @@
+import type {
+  AgentMetadataPatch,
+  AgentProfile,
+  ConversationDetails,
+  ConversationMetadataPatch,
+  Profile,
+} from "./api-types.ts";
+import {
+  readClawChatMemoryFile,
+  writeClawChatMetadata,
+  type ClawChatMemoryTargetType,
+} from "./clawchat-memory.ts";
+
+export interface MetadataWriteTarget {
+  targetType: ClawChatMemoryTargetType;
+  targetId: string;
+}
+
+export interface MetadataFailure extends MetadataWriteTarget {
+  error: string;
+}
+
+export interface MetadataPullResult {
+  ok: boolean;
+  writes: MetadataWriteTarget[];
+  failures: MetadataFailure[];
+  conversation?: ConversationDetails;
+}
+
+export interface MetadataPushResult extends MetadataPullResult {
+  metadata: Record<string, string>;
+}
+
+type MetadataApi = {
+  getConversation?: (conversationId: string) => Promise<{ conversation: ConversationDetails }>;
+  getUserInfo?: (userId: string) => Promise<Profile>;
+  getUserProfile?: (userId: string) => Promise<Profile>;
+  getAgentDetail?: (agentId: string) => Promise<{ agent: unknown }>;
+  getAgentProfile?: (agentId: string) => Promise<{ agent: unknown }>;
+  patchAgent?: (agentId: string, patch: AgentMetadataPatch) => Promise<{ agent: AgentProfile }>;
+  patchConversation?: (
+    conversationId: string,
+    patch: ConversationMetadataPatch,
+  ) => Promise<{ conversation: ConversationDetails }>;
+  updateMyProfile?: (patch: { nickname?: string; avatar_url?: string; bio?: string }) => Promise<Profile>;
+};
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === "object" ? value as Record<string, unknown> : null;
+}
+
+function hasOwn(record: Record<string, unknown>, key: string): boolean {
+  return Object.prototype.hasOwnProperty.call(record, key);
+}
+
+function stringField(record: Record<string, unknown>, key: string): string | undefined {
+  if (!hasOwn(record, key)) return undefined;
+  const value = record[key];
+  return typeof value === "string" ? value : undefined;
+}
+
+function addStringField(
+  metadata: Record<string, string>,
+  outputKey: string,
+  record: Record<string, unknown>,
+  inputKey = outputKey,
+): void {
+  const value = stringField(record, inputKey);
+  if (value !== undefined) metadata[outputKey] = value;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function ownerMetadataFromAgent(
+  agent: Record<string, unknown>,
+  params: { accountUserId?: string; accountOwnerUserId?: string },
+): Record<string, string> {
+  const metadata: Record<string, string> = {};
+  addStringField(metadata, "updated_at", agent);
+  const agentId = stringField(agent, "user_id") ?? params.accountUserId;
+  if (agentId !== undefined) metadata.agent_id = agentId;
+  const ownerId = stringField(agent, "owner_id") ?? params.accountOwnerUserId;
+  if (ownerId !== undefined) metadata.owner_id = ownerId;
+  addStringField(metadata, "nickname", agent);
+  addStringField(metadata, "avatar_url", agent);
+  addStringField(metadata, "bio", agent);
+  addStringField(metadata, "behavior", agent);
+  return metadata;
+}
+
+function userMetadataFromRecord(
+  record: Record<string, unknown>,
+  targetUserId: string,
+): Record<string, string> | null {
+  const metadata: Record<string, string> = {};
+  addStringField(metadata, "updated_at", record);
+  metadata.id = targetUserId;
+  addStringField(metadata, "nickname", record);
+  addStringField(metadata, "avatar_url", record);
+  addStringField(metadata, "bio", record);
+  addStringField(metadata, "profile_type", record, "type");
+  return metadata;
+}
+
+function userMetadataFromProfile(profile: Profile, userId: string): Record<string, string> {
+  const metadata = userMetadataFromRecord(profile as Profile & Record<string, unknown>, userId);
+  if (metadata === null) {
+    throw new Error("ClawChat user metadata response is missing id");
+  }
+  return metadata;
+}
+
+function participantUserMetadata(participant: Record<string, unknown>): { userId: string; metadata: Record<string, string> } | null {
+  const userRecord = asRecord(participant.user);
+  const source = userRecord ?? participant;
+  const userId = stringField(source, "id") ?? stringField(participant, "user_id");
+  if (!userId) return null;
+  const metadata = userMetadataFromRecord(source, userId);
+  return metadata ? { userId, metadata } : null;
+}
+
+function groupMetadataFromConversation(conversation: ConversationDetails, groupId: string): Record<string, string> {
+  const record = conversation as ConversationDetails & Record<string, unknown>;
+  const metadata: Record<string, string> = {};
+  addStringField(metadata, "updated_at", record);
+  metadata.id = groupId;
+  addStringField(metadata, "type", record);
+  addStringField(metadata, "title", record);
+  addStringField(metadata, "description", record);
+  addStringField(metadata, "creator_id", record);
+  addStringField(metadata, "created_at", record);
+  return metadata;
+}
+
+function pickUpdatePatch<T extends Record<string, string>>(
+  patchInput: Record<string, unknown>,
+  keys: readonly (keyof T & string)[],
+): T {
+  const patch: Record<string, string> = {};
+  for (const key of keys) {
+    if (hasOwn(patchInput, key) && typeof patchInput[key] === "string") {
+      patch[key] = patchInput[key];
+    }
+  }
+  if (Object.keys(patch).length === 0) {
+    throw new Error("ClawChat metadata update must include at least one mutable field");
+  }
+  return patch as T;
+}
+
+export async function pullOwnerMetadata(params: {
+  memoryRoot: string;
+  agentId: string;
+  accountUserId?: string;
+  accountOwnerUserId?: string;
+  api: MetadataApi;
+}): Promise<MetadataPullResult> {
+  const getAgent = params.api.getAgentDetail ?? params.api.getAgentProfile;
+  if (!getAgent) throw new Error("ClawChat metadata pull requires getAgentDetail");
+  if (!params.agentId) throw new Error("ClawChat owner metadata pull requires agentId");
+  const data = await getAgent(params.agentId);
+  const metadata = ownerMetadataFromAgent(asRecord(data.agent) ?? {}, params);
+  await writeClawChatMetadata(params.memoryRoot, { targetType: "owner", targetId: "owner" }, metadata);
+  return { ok: true, writes: [{ targetType: "owner", targetId: "owner" }], failures: [] };
+}
+
+export async function pullUserMetadata(params: {
+  memoryRoot: string;
+  userId: string;
+  api: MetadataApi;
+}): Promise<MetadataPullResult> {
+  const getUser = params.api.getUserProfile ?? params.api.getUserInfo;
+  if (!getUser) throw new Error("ClawChat metadata pull requires getUserProfile");
+  const profile = await getUser(params.userId);
+  const metadata = userMetadataFromProfile(profile, params.userId);
+  await writeClawChatMetadata(params.memoryRoot, { targetType: "user", targetId: params.userId }, metadata);
+  return { ok: true, writes: [{ targetType: "user", targetId: params.userId }], failures: [] };
+}
+
+export async function pullGroupMetadata(params: {
+  memoryRoot: string;
+  groupId: string;
+  api: MetadataApi;
+}): Promise<MetadataPullResult> {
+  if (!params.api.getConversation) throw new Error("ClawChat metadata pull requires getConversation");
+  const getUser = params.api.getUserProfile ?? params.api.getUserInfo;
+  const data = await params.api.getConversation(params.groupId);
+  const writes: MetadataWriteTarget[] = [];
+  const failures: MetadataFailure[] = [];
+
+  await writeClawChatMetadata(
+    params.memoryRoot,
+    { targetType: "group", targetId: params.groupId },
+    groupMetadataFromConversation(data.conversation, params.groupId),
+  );
+  writes.push({ targetType: "group", targetId: params.groupId });
+
+  const participants = Array.isArray(data.conversation.participants)
+    ? data.conversation.participants
+    : [];
+  for (const participant of participants) {
+    const mapped = participantUserMetadata(participant as Record<string, unknown>);
+    if (!mapped) continue;
+    try {
+      const existing = await readClawChatMemoryFile(params.memoryRoot, {
+        targetType: "user",
+        targetId: mapped.userId,
+      });
+      if (existing.exists) continue;
+      if (!getUser) throw new Error("ClawChat participant metadata pull requires getUserProfile");
+      const profile = await getUser(mapped.userId);
+      const metadata = userMetadataFromProfile(profile, mapped.userId);
+      await writeClawChatMetadata(
+        params.memoryRoot,
+        { targetType: "user", targetId: mapped.userId },
+        metadata,
+      );
+      writes.push({ targetType: "user", targetId: mapped.userId });
+    } catch (error) {
+      failures.push({ targetType: "user", targetId: mapped.userId, error: errorMessage(error) });
+    }
+  }
+
+  return { ok: failures.length === 0, writes, failures, conversation: data.conversation };
+}
+
+export async function pushMetadata(params: {
+  memoryRoot: string;
+  targetType: ClawChatMemoryTargetType;
+  targetId: string;
+  fields: string[];
+  agentId?: string;
+  accountUserId: string;
+  api: MetadataApi;
+}): Promise<MetadataPushResult> {
+  const file = await readClawChatMemoryFile(params.memoryRoot, {
+    targetType: params.targetType,
+    targetId: params.targetId,
+  });
+  return await updateMetadata({
+    memoryRoot: params.memoryRoot,
+    targetType: params.targetType,
+    targetId: params.targetId,
+    agentId: params.agentId,
+    accountUserId: params.accountUserId,
+    patch: pickPushPatch(params.targetType, params.targetId, file.metadata, {
+      fields: params.fields,
+      agentId: params.agentId,
+      accountUserId: params.accountUserId,
+    }),
+    api: params.api,
+  });
+}
+
+function mutableFieldsForTarget(
+  targetType: ClawChatMemoryTargetType,
+  targetId: string,
+  params: { agentId?: string; accountUserId?: string },
+): readonly string[] {
+  if (targetType === "owner") {
+    if (targetId !== "owner") throw new Error("ClawChat owner metadata targetId must be owner");
+    if (!params.agentId) throw new Error("ClawChat owner metadata update requires agentId");
+    return ["nickname", "avatar_url", "bio", "behavior"];
+  }
+  if (targetType === "user") {
+    if (!params.accountUserId) throw new Error("ClawChat user metadata update requires accountUserId");
+    if (targetId !== params.accountUserId) {
+      throw new Error("ClawChat user metadata update is allowed only for the connected user");
+    }
+    return ["nickname", "avatar_url", "bio"];
+  }
+  return ["title", "description"];
+}
+
+function pickPushPatch(
+  targetType: ClawChatMemoryTargetType,
+  targetId: string,
+  metadata: Record<string, string>,
+  params: { fields: string[]; agentId?: string; accountUserId?: string },
+): Record<string, string> {
+  if (!Array.isArray(params.fields) || params.fields.length === 0) {
+    throw new Error("fields are required for metadata push");
+  }
+  const allowed = mutableFieldsForTarget(targetType, targetId, params);
+  const patch: Record<string, string> = {};
+  for (const field of params.fields) {
+    if (typeof field !== "string" || field.length === 0) {
+      throw new Error("fields must contain non-empty strings");
+    }
+    if (!allowed.includes(field)) {
+      throw new Error(`fields contain non-pushable metadata field: ${field}`);
+    }
+    if (!hasOwn(metadata, field)) {
+      throw new Error(`missing_metadata_field: ${field}`);
+    }
+    patch[field] = metadata[field]!;
+  }
+  return patch;
+}
+
+export async function updateMetadata(params: {
+  memoryRoot: string;
+  targetType: ClawChatMemoryTargetType;
+  targetId: string;
+  agentId?: string;
+  accountUserId?: string;
+  patch: Record<string, unknown>;
+  api: MetadataApi;
+}): Promise<MetadataPushResult> {
+  if (params.targetType === "owner") {
+    if (!params.agentId) throw new Error("ClawChat owner metadata update requires agentId");
+    if (!params.api.patchAgent) throw new Error("ClawChat owner metadata update requires patchAgent");
+    const patch = pickUpdatePatch<AgentMetadataPatch & Record<string, string>>(
+      params.patch,
+      ["nickname", "avatar_url", "bio", "behavior"],
+    );
+    const response = await params.api.patchAgent(params.agentId, patch);
+    const metadata = ownerMetadataFromAgent(response.agent as AgentProfile & Record<string, unknown>, {
+      accountUserId: params.accountUserId,
+    });
+    await writeClawChatMetadata(params.memoryRoot, { targetType: "owner", targetId: "owner" }, metadata);
+    return { ok: true, writes: [{ targetType: "owner", targetId: "owner" }], failures: [], metadata };
+  }
+
+  if (params.targetType === "user") {
+    if (!params.accountUserId) throw new Error("ClawChat user metadata update requires accountUserId");
+    if (params.targetId !== params.accountUserId) {
+      throw new Error("ClawChat user metadata update is allowed only for the connected user");
+    }
+    if (!params.api.updateMyProfile) throw new Error("ClawChat user metadata update requires updateMyProfile");
+    const patch = pickUpdatePatch<{ nickname?: string; avatar_url?: string; bio?: string } & Record<string, string>>(
+      params.patch,
+      ["nickname", "avatar_url", "bio"],
+    );
+    const profile = await params.api.updateMyProfile(patch);
+    const metadata = userMetadataFromProfile(profile, params.targetId);
+    await writeClawChatMetadata(params.memoryRoot, { targetType: "user", targetId: params.targetId }, metadata);
+    return { ok: true, writes: [{ targetType: "user", targetId: params.targetId }], failures: [], metadata };
+  }
+
+  if (!params.api.patchConversation) throw new Error("ClawChat group metadata update requires patchConversation");
+  const patch = pickUpdatePatch<ConversationMetadataPatch & Record<string, string>>(
+    params.patch,
+    ["title", "description"],
+  );
+  const response = await params.api.patchConversation(params.targetId, patch);
+  const metadata = groupMetadataFromConversation(response.conversation, params.targetId);
+  await writeClawChatMetadata(params.memoryRoot, { targetType: "group", targetId: params.targetId }, metadata);
+  return { ok: true, writes: [{ targetType: "group", targetId: params.targetId }], failures: [], metadata };
+}