@clawroom/openclaw 0.5.23 → 0.5.25

package/node_modules/@clawroom/protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawroom/protocol",
-  "version": "0.5.23",
+  "version": "0.5.25",
   "description": "ClawRoom shared types — models, messages, and protocol definitions",
   "type": "module",
   "license": "MIT",
@@ -11,6 +11,9 @@
   "files": [
     "src"
   ],
+  "dependencies": {
+    "zod": "^3.23.0"
+  },
   "exports": {
     ".": "./src/index.ts"
   }

package/node_modules/@clawroom/protocol/src/index.ts

@@ -1,3 +1,235 @@
+import { z } from "zod";
+
+export const TASK_ROLE_VALUES = ["root", "child"] as const;
+export type TaskRole = (typeof TASK_ROLE_VALUES)[number];
+
+export const TASK_STATUS_VALUES = ["open", "in_progress", "in_review", "done", "failed"] as const;
+export type TaskStatus = (typeof TASK_STATUS_VALUES)[number];
+
+export const TASK_KIND_VALUES = ["work", "decision", "approval", "follow_up"] as const;
+export type TaskKind = (typeof TASK_KIND_VALUES)[number];
+
+export const TASK_PRIORITY_VALUES = ["urgent", "high", "normal", "low"] as const;
+export type TaskPriority = (typeof TASK_PRIORITY_VALUES)[number];
+
+export const TASK_BLOCKING_STATE_VALUES = ["none", "needs_human", "external"] as const;
+export type TaskBlockingState = (typeof TASK_BLOCKING_STATE_VALUES)[number];
+
+export const TASK_REVIEW_VERDICT_VALUES = ["approve", "revise"] as const;
+export type TaskReviewVerdict = (typeof TASK_REVIEW_VERDICT_VALUES)[number];
+
+export const LIST_TASK_FILTER_VALUES = ["mine", "channel", "open"] as const;
+export type ListTasksFilter = (typeof LIST_TASK_FILTER_VALUES)[number];
+
+export const SERVER_CHAT_WAKE_REASON_VALUES = [
+  "mention",
+  "dm",
+  "follow_through",
+  "goal_drift",
+  "trigger",
+  "broadcast",
+  "routed",
+  "coordination",
+  "review",
+] as const;
+export type ServerChatWakeReason = (typeof SERVER_CHAT_WAKE_REASON_VALUES)[number];
+
+export interface TaskExecutionPlanSubtask {
+  title: string;
+  description: string;
+  suggestedAssignee: string | null;
+  blockedBy: number[];
+}
+
+export interface TaskExecutionPlan {
+  summary: string;
+  subtasks: TaskExecutionPlanSubtask[];
+  confirmedAt?: number;
+}
+
+export interface TaskExecutionBrief {
+  goal: string;
+  doneDefinition: string;
+  plan?: TaskExecutionPlan;
+}
+
+export const TASK_PLAN_LIMITS = {
+  minSubtasks: 1,
+  maxSubtasks: 10,
+} as const;
+
+export const taskRoleSchema = z.enum(TASK_ROLE_VALUES);
+export const taskStatusSchema = z.enum(TASK_STATUS_VALUES);
+export const taskKindSchema = z.enum(TASK_KIND_VALUES);
+export const taskPrioritySchema = z.enum(TASK_PRIORITY_VALUES);
+export const taskBlockingStateSchema = z.enum(TASK_BLOCKING_STATE_VALUES);
+export const taskReviewVerdictSchema = z.enum(TASK_REVIEW_VERDICT_VALUES);
+export const listTasksFilterSchema = z.enum(LIST_TASK_FILTER_VALUES);
+
+export function createTaskKindSchema(zod: typeof z) {
+  return zod.enum(TASK_KIND_VALUES);
+}
+
+export function createTaskStatusSchema(zod: typeof z) {
+  return zod.enum(TASK_STATUS_VALUES);
+}
+
+export function createTaskPrioritySchema(zod: typeof z) {
+  return zod.enum(TASK_PRIORITY_VALUES);
+}
+
+export function createTaskBlockingStateSchema(zod: typeof z) {
+  return zod.enum(TASK_BLOCKING_STATE_VALUES);
+}
+
+export function createTaskReviewVerdictSchema(zod: typeof z) {
+  return zod.enum(TASK_REVIEW_VERDICT_VALUES);
+}
+
+export function createListTasksFilterSchema(zod: typeof z) {
+  return zod.enum(LIST_TASK_FILTER_VALUES);
+}
+
+export function createTaskExecutionPlanSubtaskSchema(zod: typeof z) {
+  return zod.object({
+    title: zod.string(),
+    description: zod.string(),
+    suggestedAssignee: zod.string().nullable(),
+    blockedBy: zod.array(zod.number()),
+  });
+}
+
+export function createTaskExecutionPlanSchema(zod: typeof z) {
+  return zod.object({
+    summary: zod.string(),
+    subtasks: zod.array(createTaskExecutionPlanSubtaskSchema(zod)),
+    confirmedAt: zod.number().optional(),
+  });
+}
+
+export function createTaskExecutionBriefInputSchema(zod: typeof z) {
+  return zod.object({
+    goal: zod.string(),
+    doneDefinition: zod.string(),
+  });
+}
+
+export function createTaskExecutionBriefSchema(zod: typeof z) {
+  return createTaskExecutionBriefInputSchema(zod).extend({
+    plan: createTaskExecutionPlanSchema(zod).optional(),
+  });
+}
+
+export function createTaskPlanSubtaskSchema(zod: typeof z) {
+  return zod.object({
+    title: zod.string(),
+    description: zod.string(),
+    suggestedAssignee: zod.string(),
+    blockedBy: zod.array(zod.number()).optional(),
+  });
+}
+
+export const taskExecutionPlanSubtaskSchema = createTaskExecutionPlanSubtaskSchema(z);
+export const taskExecutionPlanSchema = createTaskExecutionPlanSchema(z);
+export const taskExecutionBriefInputSchema = createTaskExecutionBriefInputSchema(z);
+export const taskExecutionBriefSchema = createTaskExecutionBriefSchema(z);
+
+export const taskCoordinationPatchSchema = z.object({
+  priority: taskPrioritySchema.optional(),
+  blockingState: taskBlockingStateSchema.optional(),
+  blockingNote: z.string().nullable().optional(),
+  executionBrief: taskExecutionBriefInputSchema.optional(),
+  accepted: z.boolean().optional(),
+});
+
+export const sendMessagePayloadSchema = z.object({
+  channelId: z.string().min(1),
+  content: z.string(),
+  mentionIds: z.array(z.string().min(1)).optional(),
+});
+
+export const createTaskPayloadSchema = z.object({
+  title: z.string(),
+  description: z.string(),
+  channelId: z.string().min(1).optional(),
+  assigneeName: z.string().min(1).nullable().optional(),
+  priority: taskPrioritySchema.optional(),
+  kind: taskKindSchema.optional(),
+  scheduledFor: z.number().optional(),
+  parentTaskId: z.string().min(1).nullable().optional(),
+});
+
+export const planTaskPayloadSchema = z.object({
+  taskId: z.string().min(1),
+  summary: z.string(),
+  subtasks: z.array(createTaskPlanSubtaskSchema(z).extend({
+    blockedBy: z.array(z.number().int().min(0)).optional(),
+  })).min(TASK_PLAN_LIMITS.minSubtasks).max(TASK_PLAN_LIMITS.maxSubtasks),
+});
+
+export const updateTaskCoordinationPayloadSchema = taskCoordinationPatchSchema.extend({
+  taskId: z.string().min(1),
+});
+
+export const submitTaskPayloadSchema = z.object({
+  taskId: z.string().min(1),
+  output: z.string(),
+  filePaths: z.array(z.string().min(1)).optional(),
+});
+
+export const failTaskPayloadSchema = z.object({
+  taskId: z.string().min(1),
+  reason: z.string(),
+});
+
+export const reviewTaskPayloadSchema = z.object({
+  taskId: z.string().min(1),
+  score: z.number().int().min(1).max(5),
+  verdict: taskReviewVerdictSchema,
+  feedback: z.string(),
+});
+
+export const listTasksPayloadSchema = z.object({
+  filter: listTasksFilterSchema.optional(),
+  channelId: z.string().min(1).optional(),
+});
+
+export const uploadTaskFilePayloadSchema = z.object({
+  taskId: z.string().min(1),
+  filePath: z.string().min(1),
+});
+
+export const taskExecutionBriefJsonSchema = {
+  type: "object",
+  description: "Execution brief for a root task. Both fields are required.",
+  properties: {
+    goal: { type: "string", description: "What this task aims to achieve." },
+    doneDefinition: { type: "string", description: "What 'done' looks like." },
+  },
+  required: ["goal", "doneDefinition"],
+} as const;
+
+export const taskPlanSubtaskJsonSchema = {
+  type: "object",
+  properties: {
+    title: { type: "string", description: "Subtask title." },
+    description: { type: "string", description: "Detailed subtask description." },
+    suggestedAssignee: { type: "string", description: "Agent name best suited for the subtask." },
+    blockedBy: {
+      type: "array",
+      description: "Indexes of prior subtasks this one depends on.",
+      items: { type: "number" },
+    },
+  },
+  required: ["title", "description", "suggestedAssignee"],
+} as const;
+
+export const taskPlanSubtaskSchema = createTaskPlanSubtaskSchema(z);
+
+export const taskPlanSubtasksSchema = z.array(taskPlanSubtaskSchema)
+  .min(TASK_PLAN_LIMITS.minSubtasks)
+  .max(TASK_PLAN_LIMITS.maxSubtasks);
+
 export interface AgentHeartbeat {
   type: "agent.heartbeat";
 }
@@ -69,10 +301,10 @@ export interface ServerTask {
   sourceMessageContent?: string | null;
   sourceMessageSenderName?: string | null;
   sourceMessageAttachments?: ChatAttachmentRef[];
-  taskRole?: "root" | "child";
+  taskRole?: TaskRole;
   assignedAgentId?: string | null;
   assignedAgentName?: string | null;
-  executionBrief?: ServerTaskExecutionBrief | null;
+  executionBrief?: TaskExecutionBrief | null;
   taskDiscussionContext?: ServerTaskDiscussionEntry[];
 }
 
@@ -83,14 +315,7 @@ export interface AgentChatProfile {
   continuityPacket: string;
 }
 
-export interface ServerTaskExecutionBrief {
-  goal: string;
-  firstActions: string[];
-  blockingUnknowns: string[];
-  nonBlockingUnknowns: string[];
-  doneDefinition: string;
-  nextCheckpoint: string;
-}
+export type ServerTaskExecutionBrief = TaskExecutionBrief;
 
 export interface ServerTaskDiscussionEntry {
   id: string;
@@ -108,6 +333,20 @@ export interface ChatAttachmentRef {
   downloadUrl: string;
 }
 
+export interface ServerMessageContextEntry {
+  id: string;
+  senderType: string;
+  senderName: string;
+  content: string;
+  createdAt: number;
+}
+
+export interface ChannelMemberRef {
+  id: string;
+  name: string;
+  type: string;
+}
+
 export interface ServerChatMessage {
   type: "server.chat";
   kind: "chat_reply" | "wake";
@@ -119,26 +358,20 @@ export interface ServerChatMessage {
   content: string;
   attachments?: ChatAttachmentRef[];
   isMention?: boolean;
-  wakeReason?: "mention" | "dm" | "follow_through" | "goal_drift" | "trigger" | "broadcast" | "routed" | "coordination" | "review";
+  wakeReason?: ServerChatWakeReason;
   triggerReason?: string;
   agentProfile: AgentChatProfile;
-  context: Array<{
-    id: string;
-    senderType: string;
-    senderName: string;
-    content: string;
-    createdAt: number;
-  }>;
+  context: ServerMessageContextEntry[];
   replyToMessageId?: string | null;
   senderName?: string;
   senderType?: string;
   createdAt?: number;
-  channelMembers?: Array<{ id: string; name: string; type: string }>;
+  channelMembers?: ChannelMemberRef[];
   taskTitle?: string | null;
-  taskRole?: "root" | "child";
+  taskRole?: TaskRole;
   assignedAgentId?: string | null;
   assignedAgentName?: string | null;
-  executionBrief?: ServerTaskExecutionBrief | null;
+  executionBrief?: TaskExecutionBrief | null;
   taskDiscussionContext?: ServerTaskDiscussionEntry[];
 }
 

package/node_modules/@clawroom/sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawroom/sdk",
-  "version": "0.5.23",
+  "version": "0.5.25",
   "description": "ClawRoom SDK — polling client and protocol types for connecting any agent to ClawRoom",
   "type": "module",
   "license": "MIT",

package/node_modules/zod/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Colin McDonnell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/zod/README.md

@@ -0,0 +1,208 @@
+<p align="center">
+  <img src="logo.svg" width="200px" align="center" alt="Zod logo" />
+  <h1 align="center">Zod</h1>
+  <p align="center">
+    TypeScript-first schema validation with static type inference
+    <br/>
+    by <a href="https://x.com/colinhacks">@colinhacks</a>
+  </p>
+</p>
+<br/>
+
+<p align="center">
+<a href="https://github.com/colinhacks/zod/actions?query=branch%3Amaster"><img src="https://github.com/colinhacks/zod/actions/workflows/test.yml/badge.svg?event=push&branch=master" alt="Zod CI status" /></a>
+<a href="https://opensource.org/licenses/MIT" rel="nofollow"><img src="https://img.shields.io/github/license/colinhacks/zod" alt="License"></a>
+<a href="https://www.npmjs.com/package/zod" rel="nofollow"><img src="https://img.shields.io/npm/dw/zod.svg" alt="npm"></a>
+<a href="https://discord.gg/KaSRdyX2vc" rel="nofollow"><img src="https://img.shields.io/discord/893487829802418277?label=Discord&logo=discord&logoColor=white" alt="discord server"></a>
+<a href="https://github.com/colinhacks/zod" rel="nofollow"><img src="https://img.shields.io/github/stars/colinhacks/zod" alt="stars"></a>
+</p>
+
+<div align="center">
+  <a href="https://zod.dev/api">Docs</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://discord.gg/RcG33DQJdf">Discord</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://twitter.com/colinhacks">𝕏</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://bsky.app/profile/zod.dev">Bluesky</a>
+  <br />
+</div>
+
+<br/>
+<br/>
+
+<h2 align="center">Featured sponsor: Jazz</h2>
+
+<div align="center">
+  <a href="https://jazz.tools/?utm_source=zod">
+    <picture width="85%" >
+      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/garden-co/jazz/938f6767e46cdfded60e50d99bf3b533f4809c68/homepage/homepage/public/Zod%20sponsor%20message.png">
+      <img alt="jazz logo" src="https://raw.githubusercontent.com/garden-co/jazz/938f6767e46cdfded60e50d99bf3b533f4809c68/homepage/homepage/public/Zod%20sponsor%20message.png" width="85%">
+    </picture>
+  </a>
+  <br/>
+  <p><sub>Learn more about <a target="_blank" rel="noopener noreferrer" href="mailto:sponsorship@colinhacks.com">featured sponsorships</a></sub></p>
+</div>
+
+<br/>
+<br/>
+<br/>
+
+### [Read the docs →](https://zod.dev/api)
+
+<br/>
+<br/>
+
+## What is Zod?
+
+Zod is a TypeScript-first validation library. Define a schema and parse some data with it. You'll get back a strongly typed, validated result.
+
+```ts
+import * as z from "zod/v4";
+
+const User = z.object({
+  name: z.string(),
+});
+
+// some untrusted data...
+const input = {
+  /* stuff */
+};
+
+// the parsed result is validated and type safe!
+const data = User.parse(input);
+
+// so you can use it with confidence :)
+console.log(data.name);
+```
+
+<br/>
+
+## Features
+
+- Zero external dependencies
+- Works in Node.js and all modern browsers
+- Tiny: `2kb` core bundle (gzipped)
+- Immutable API: methods return a new instance
+- Concise interface
+- Works with TypeScript and plain JS
+- Built-in JSON Schema conversion
+- Extensive ecosystem
+
+<br/>
+
+## Installation
+
+```sh
+npm install zod
+```
+
+<br/>
+
+## Basic usage
+
+Before you can do anything else, you need to define a schema. For the purposes of this guide, we'll use a simple object schema.
+
+```ts
+import * as z from "zod/v4";
+
+const Player = z.object({
+  username: z.string(),
+  xp: z.number(),
+});
+```
+
+### Parsing data
+
+Given any Zod schema, use `.parse` to validate an input. If it's valid, Zod returns a strongly-typed _deep clone_ of the input.
+
+```ts
+Player.parse({ username: "billie", xp: 100 });
+// => returns { username: "billie", xp: 100 }
+```
+
+**Note** — If your schema uses certain asynchronous APIs like `async` [refinements](#refine) or [transforms](#transform), you'll need to use the `.parseAsync()` method instead.
+
+```ts
+const schema = z.string().refine(async (val) => val.length <= 8);
+
+await schema.parseAsync("hello");
+// => "hello"
+```
+
+### Handling errors
+
+When validation fails, the `.parse()` method will throw a `ZodError` instance with granular information about the validation issues.
+
+```ts
+try {
+  Player.parse({ username: 42, xp: "100" });
+} catch (err) {
+  if (err instanceof z.ZodError) {
+    err.issues;
+    /* [
+      {
+        expected: 'string',
+        code: 'invalid_type',
+        path: [ 'username' ],
+        message: 'Invalid input: expected string'
+      },
+      {
+        expected: 'number',
+        code: 'invalid_type',
+        path: [ 'xp' ],
+        message: 'Invalid input: expected number'
+      }
+    ] */
+  }
+}
+```
+
+To avoid a `try/catch` block, you can use the `.safeParse()` method to get back a plain result object containing either the successfully parsed data or a `ZodError`. The result type is a [discriminated union](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions), so you can handle both cases conveniently.
+
+```ts
+const result = Player.safeParse({ username: 42, xp: "100" });
+if (!result.success) {
+  result.error; // ZodError instance
+} else {
+  result.data; // { username: string; xp: number }
+}
+```
+
+**Note** — If your schema uses certain asynchronous APIs like `async` [refinements](#refine) or [transforms](#transform), you'll need to use the `.safeParseAsync()` method instead.
+
+```ts
+const schema = z.string().refine(async (val) => val.length <= 8);
+
+await schema.safeParseAsync("hello");
+// => { success: true; data: "hello" }
+```
+
+### Inferring types
+
+Zod infers a static type from your schema definitions. You can extract this type with the `z.infer<>` utility and use it however you like.
+
+```ts
+const Player = z.object({
+  username: z.string(),
+  xp: z.number(),
+});
+
+// extract the inferred type
+type Player = z.infer<typeof Player>;
+
+// use it in your code
+const player: Player = { username: "billie", xp: 100 };
+```
+
+In some cases, the input & output types of a schema can diverge. For instance, the `.transform()` API can convert the input from one type to another. In these cases, you can extract the input and output types independently:
+
+```ts
+const mySchema = z.string().transform((val) => val.length);
+
+type MySchemaIn = z.input<typeof mySchema>;
+// => string
+
+type MySchemaOut = z.output<typeof mySchema>; // equivalent to z.infer<typeof mySchema>
+// number
+```

package/node_modules/zod/index.cjs

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.z = void 0;
+const z = __importStar(require("./v3/external.cjs"));
+exports.z = z;
+__exportStar(require("./v3/external.cjs"), exports);
+exports.default = z;

package/node_modules/zod/index.d.cts

@@ -0,0 +1,4 @@
+import * as z from "./v3/external.cjs";
+export * from "./v3/external.cjs";
+export { z };
+export default z;

package/node_modules/zod/index.d.ts

@@ -0,0 +1,4 @@
+import * as z from "./v3/external.js";
+export * from "./v3/external.js";
+export { z };
+export default z;

package/node_modules/zod/index.js

@@ -0,0 +1,4 @@
+import * as z from "./v3/external.js";
+export * from "./v3/external.js";
+export { z };
+export default z;