@coolclaw/coolclaw 1.0.16 → 1.0.17

package/dist/{chunk-BVFSS5UA.js → chunk-3YKMAM6K.js}

@@ -180,6 +180,7 @@ var FileAckStore = class {
 
 // src/agent-task.ts
 import { createHash } from "crypto";
+var WEREWOLF_STRUCTURED_ACTION_PROTOCOL_VERSION = "WEREWOLF_STRUCTURED_JSON_MESSAGE_V1";
 function normalizeAgentTask(value) {
   if (!isRecord(value)) return null;
   const actionContract = normalizeActionContract(value.actionContract);
@@ -191,6 +192,9 @@ function normalizeAgentTask(value) {
     renderedPrompt: readString(value.renderedPrompt) ?? "",
     renderedPromptHash: readString(value.renderedPromptHash),
     actionFormat: readString(value.actionFormat),
+    actionProtocolVersion: readString(value.actionProtocolVersion),
+    outputSchema: isRecord(value.outputSchema) ? value.outputSchema : void 0,
+    retryPolicy: normalizeRetryPolicy(value.retryPolicy),
     conversationKey: readString(value.conversationKey),
     actionContract,
     fallbackAction,
@@ -200,6 +204,9 @@ function normalizeAgentTask(value) {
 function isDispatchableAgentTask(task) {
   return task.requiresReply === true && task.renderedPrompt.trim().length > 0 && allowedActionTypes(task).length > 0;
 }
+function isStructuredJsonTask(task) {
+  return task.actionProtocolVersion === WEREWOLF_STRUCTURED_ACTION_PROTOCOL_VERSION || task.actionFormat === "STRICT_JSON_OBJECT";
+}
 function validateAgentAction(action, task) {
   if (!isRecord(action.actionData)) {
     return { ok: false, reason: "invalid_action_shape" };
@@ -216,12 +223,18 @@ function validateAgentAction(action, task) {
   if (!matchesActionDataSchema(repaired.actionData, option.actionDataSchema)) {
     return { ok: false, reason: "invalid_action_shape" };
   }
+  if (isStructuredJsonTask(task) && !matchesRootOutputSchema(action, task.outputSchema)) {
+    return { ok: false, reason: "invalid_action_shape" };
+  }
+  const normalizedAction = {
+    actionType: action.actionType,
+    actionData: repaired.actionData
+  };
+  if (typeof action.speech === "string") normalizedAction.speech = action.speech;
+  if (typeof action.reason === "string") normalizedAction.reason = action.reason;
   return {
     ok: true,
-    action: {
-      actionType: action.actionType,
-      actionData: repaired.actionData
-    },
+    action: normalizedAction,
     repairReason: repaired.repairReason
   };
 }
@@ -251,6 +264,14 @@ function normalizeActionContract(value) {
     finalOutputRules: Array.isArray(value.finalOutputRules) ? value.finalOutputRules.filter((rule) => typeof rule === "string") : void 0
   };
 }
+function normalizeRetryPolicy(value) {
+  if (!isRecord(value)) return void 0;
+  return {
+    maxRetries: readNumber(value.maxRetries),
+    shareDeadline: typeof value.shareDeadline === "boolean" ? value.shareDeadline : void 0,
+    rejectedOutputActionType: readString(value.rejectedOutputActionType)
+  };
+}
 function normalizeActionOption(value) {
   if (!isRecord(value) || typeof value.actionType !== "string" || value.actionType.length === 0) {
     return [];
@@ -266,20 +287,17 @@ function allowedActionTypes(task) {
 }
 function matchesActionDataSchema(actionData, schema) {
   if (!schema || Object.keys(schema).length === 0) return true;
-  if (typeof schema.type === "string" && schema.type !== "object") return false;
-  const properties = isRecord(schema.properties) ? schema.properties : {};
-  const required = Array.isArray(schema.required) ? schema.required.filter((field) => typeof field === "string" && field.length > 0) : [];
-  for (const field of required) {
-    if (!Object.prototype.hasOwnProperty.call(actionData, field)) return false;
-    if (!matchesSchemaValue(actionData[field], properties[field], true)) return false;
-  }
-  for (const [field, value] of Object.entries(actionData)) {
-    const propertySchema = properties[field];
-    if (propertySchema !== void 0 && !matchesSchemaValue(value, propertySchema, false)) {
-      return false;
-    }
-  }
-  return true;
+  return matchesSchemaValue(actionData, schema, true);
+}
+function matchesRootOutputSchema(action, schema) {
+  if (!schema || Object.keys(schema).length === 0) return true;
+  const root = {
+    actionType: action.actionType,
+    actionData: action.actionData
+  };
+  if (typeof action.speech === "string") root.speech = action.speech;
+  if (typeof action.reason === "string") root.reason = action.reason;
+  return matchesSchemaValue(root, schema, true);
 }
 function repairActionDataForSchema(actionData, schema) {
   if (!schema || Object.keys(schema).length === 0) {
@@ -315,12 +333,28 @@ function repairActionDataForSchema(actionData, schema) {
   };
 }
 function matchesSchemaValue(value, schema, required) {
-  if (value == null) return !required;
   if (!isRecord(schema)) return true;
+  if (value == null) {
+    return !required || schemaAllowsType(schema.type, "null");
+  }
+  const oneOf = Array.isArray(schema.oneOf) ? schema.oneOf : [];
+  if (oneOf.length > 0) {
+    return oneOf.some((variant) => matchesSchemaValue(value, variant, required));
+  }
   if (Array.isArray(schema.enum) && !schema.enum.includes(value)) {
     return false;
   }
-  switch (schema.type) {
+  const allowedTypes = Array.isArray(schema.type) ? schema.type.filter((type) => typeof type === "string") : typeof schema.type === "string" ? [schema.type] : [];
+  if (allowedTypes.length === 0) {
+    return true;
+  }
+  return allowedTypes.some((type) => matchesSchemaTypedValue(value, schema, type));
+}
+function schemaAllowsType(typeNode, type) {
+  return Array.isArray(typeNode) ? typeNode.includes(type) : typeNode === type;
+}
+function matchesSchemaTypedValue(value, schema, type) {
+  switch (type) {
     case "integer":
       return typeof value === "number" && Number.isInteger(value);
     case "number":
@@ -330,13 +364,33 @@ function matchesSchemaValue(value, schema, required) {
     case "boolean":
       return typeof value === "boolean";
     case "object":
-      return isRecord(value);
+      return matchesObjectSchema(value, schema);
     case "array":
       return Array.isArray(value);
+    case "null":
+      return value == null;
     default:
       return true;
   }
 }
+function matchesObjectSchema(value, schema) {
+  if (!isRecord(value)) return false;
+  const properties = isRecord(schema.properties) ? schema.properties : {};
+  const required = Array.isArray(schema.required) ? schema.required.filter((field) => typeof field === "string" && field.length > 0) : [];
+  for (const field of required) {
+    if (!Object.prototype.hasOwnProperty.call(value, field)) return false;
+    if (!matchesSchemaValue(value[field], properties[field], true)) return false;
+  }
+  for (const [field, fieldValue] of Object.entries(value)) {
+    const propertySchema = properties[field];
+    if (propertySchema === void 0) {
+      if (schema.additionalProperties === false) return false;
+      continue;
+    }
+    if (!matchesSchemaValue(fieldValue, propertySchema, false)) return false;
+  }
+  return true;
+}
 function readString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
@@ -1047,7 +1101,17 @@ async function sendGameAction(input) {
     rawResponsePreview: input.rawResponsePreview,
     modelActionRejected: input.modelActionRejected,
     modelActionType: input.modelActionType,
-    validationReason: input.validationReason
+    validationReason: input.validationReason,
+    submissionStatus: input.submissionStatus,
+    structuredProtocolVersion: input.structuredProtocolVersion,
+    retryCount: input.retryCount,
+    firstRawResponseHash: input.firstRawResponseHash,
+    firstModelActionType: input.firstModelActionType,
+    firstValidationReason: input.firstValidationReason,
+    retryRawResponseHash: input.retryRawResponseHash,
+    retryValidationReason: input.retryValidationReason,
+    speech: input.speech,
+    reason: input.reason
   });
   const response = await input.client.request(frame);
   if (response.ok === false) {
@@ -1123,6 +1187,59 @@ function parseAgentAction(text) {
   }
   return lastError ?? { error: "no_action_block" };
 }
+function parseStrictJsonAgentAction(text) {
+  if (typeof text !== "string" || text.length === 0) {
+    return { error: "no_action_block" };
+  }
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{")) {
+    return { error: "invalid_json", detail: "strict_json_object_required" };
+  }
+  const objectEnd = topLevelJsonObjectEnd(trimmed);
+  if (objectEnd === null) {
+    return { error: "invalid_json", detail: "strict_json_object_required" };
+  }
+  if (objectEnd !== trimmed.length - 1) {
+    return { error: "invalid_json", detail: "trailing_text_after_json" };
+  }
+  return parseActionJsonStrict(trimmed);
+}
+function topLevelJsonObjectEnd(text) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{") {
+      depth += 1;
+      continue;
+    }
+    if (ch === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return i;
+      }
+      if (depth < 0) {
+        return null;
+      }
+    }
+  }
+  return null;
+}
 function parseActionJson(body) {
   let obj;
   try {
@@ -1151,7 +1268,38 @@ function parseActionJson(body) {
   }
   return {
     actionType: rec.actionType,
-    actionData: rec.actionData
+    actionData: rec.actionData,
+    ...typeof rec.speech === "string" ? { speech: rec.speech } : {},
+    ...typeof rec.reason === "string" ? { reason: rec.reason } : {}
+  };
+}
+function parseActionJsonStrict(body) {
+  let obj;
+  try {
+    obj = JSON.parse(body);
+  } catch (e) {
+    return { error: "invalid_json", detail: e instanceof Error ? e.message : String(e) };
+  }
+  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+    return { error: "invalid_json", detail: "not an object" };
+  }
+  const rec = obj;
+  for (const field of Object.keys(rec)) {
+    if (!["speech", "reason", "actionType", "actionData"].includes(field)) {
+      return { error: "invalid_json", detail: `unknown_top_level_field:${field}` };
+    }
+  }
+  if (typeof rec.actionType !== "string" || rec.actionType.length === 0) {
+    return { error: "missing_action_type" };
+  }
+  if (typeof rec.actionData !== "object" || rec.actionData === null || Array.isArray(rec.actionData)) {
+    return { error: "missing_action_data" };
+  }
+  return {
+    actionType: rec.actionType,
+    actionData: rec.actionData,
+    ...typeof rec.speech === "string" ? { speech: rec.speech } : {},
+    ...typeof rec.reason === "string" ? { reason: rec.reason } : {}
   };
 }
 function removeTrailingCommas(body) {
@@ -1202,7 +1350,7 @@ function inferRejectedModelAction(rawResponse, task) {
       validationReason: "no_model_output"
     };
   }
-  const parsed = parseAgentAction(rawResponse);
+  const parsed = isStructuredJsonTask(task) ? parseStrictJsonAgentAction(rawResponse) : parseAgentAction(rawResponse);
   if ("error" in parsed) {
     return {
       modelActionRejected: true,
@@ -1620,11 +1768,13 @@ var CoolclawWsClient = class {
   async connect() {
     this.notifyState("connecting");
     const lastAckedSeq = await this.options.ackStore.getLastAckedSeq(this.options.accountKey);
+    const capabilities = this.options.capabilities ?? [WEREWOLF_STRUCTURED_ACTION_PROTOCOL_VERSION];
     const socket = new WebSocket(buildWsUrl(this.options.gatewayUrl, lastAckedSeq), {
       headers: {
         Authorization: `Bearer ${this.options.token}`,
         "X-CoolClaw-Agent-Id": this.options.agentId,
-        "X-CoolClaw-Plugin-Version": this.options.pluginVersion
+        "X-CoolClaw-Plugin-Version": this.options.pluginVersion,
+        "X-CoolClaw-Capabilities": capabilities.join(",")
       }
     });
     this.socket = socket;
@@ -1838,6 +1988,42 @@ function logAckFailure(params) {
   const target = params.target ? ` target=${params.target}` : "";
   params.log(`${params.channel} ack cleanup failed${target}: ${String(params.error)}`);
 }
+function buildStructuredActionRetryPrompt(renderedPrompt, reason) {
+  const reasonText = reason && reason.trim().length > 0 ? reason.trim() : "invalid_output";
+  return `${renderedPrompt}
+
+\u4E0A\u4E00\u6B21\u8F93\u51FA\u672A\u88AB\u72FC\u4EBA\u6740\u7ED3\u6784\u5316\u52A8\u4F5C\u534F\u8BAE\u63A5\u53D7\uFF0C\u5931\u8D25\u539F\u56E0\uFF1A${reasonText}\u3002
+\u8BF7\u91CD\u65B0\u4F5C\u7B54\uFF1A\u53EA\u8F93\u51FA\u4E00\u4E2A\u5B8C\u6574 JSON \u5BF9\u8C61\uFF0C\u4E0D\u8981\u8F93\u51FA Markdown\u3001\u89E3\u91CA\u6587\u5B57\u3001\u4EE3\u7801\u5757\u6216\u65E7\u52A8\u4F5C\u6807\u7B7E\u3002`;
+}
+function hasStructuredRetryBudget(deadlineEpochMs, nowEpochMs = Date.now(), safetyMarginMs = 1e3) {
+  if (!deadlineEpochMs || deadlineEpochMs <= 0) {
+    return true;
+  }
+  return nowEpochMs < deadlineEpochMs - Math.max(0, safetyMarginMs);
+}
+function shouldSubmitStructuredRejectedOutput(params) {
+  if (!params.structuredTask || params.gameSubmitted) {
+    return false;
+  }
+  if (params.modelActionRejected === false) {
+    return false;
+  }
+  if (params.fallbackReason?.startsWith("llm_action_submit_failed:")) {
+    return false;
+  }
+  return true;
+}
+function flattenForLog(text) {
+  return text.replace(/\r/g, "").replace(/\n/g, " \\n ");
+}
+function logStructuredActionValidation(params) {
+  const message = `[COOLCLAW-GAME-ACTION-VALIDATE] gameId=${params.meta.gameId} roomId=${params.meta.roomId} eventType=${params.meta.eventType} eventId=${params.meta.eventId} turnSeq=${params.meta.turnSeq} retryCount=${params.retryCount} submissionStatus=${params.submissionStatus} result=${params.result} reason=${params.reason ?? ""} actionType=${params.actionType ?? ""} promptPolicyVersion=${params.meta.promptPolicyVersion ?? ""} renderedPromptHash=${params.meta.renderedPromptHash ?? ""} rawResponseHash=${params.rawResponseHash ?? ""}`;
+  if (params.result === "pass") {
+    params.log?.info?.(message);
+  } else {
+    params.log?.warn?.(message);
+  }
+}
 function assertInboundRuntimeAvailable(runtime, context) {
   if (runtime?.channel) {
     return runtime.channel;
@@ -1852,7 +2038,10 @@ async function submitGameActionWithLog(action, meta, wsClient, log, source, rawR
     log?.error?.(`[GAME-ACTION] submit skipped: ws not connected eventId=${meta.eventId}`);
     return "failed";
   }
-  const responseHash = rawResponse && rawResponse.length > 0 ? sha256Hex(rawResponse) : void 0;
+  const responseHash = typeof rawResponse === "string" ? sha256Hex(rawResponse) : void 0;
+  const structured = isStructuredJsonTask(meta.agentTask);
+  const retryCount = auditMeta?.retryCount ?? 0;
+  const structuredProtocolVersion = auditMeta?.structuredProtocolVersion ?? meta.agentTask.actionProtocolVersion;
   log?.info?.(
     `[GAME-ACTION] submit start source=${source} eventType=${meta.eventType} actionType=${action.actionType} gameId=${meta.gameId} roomId=${meta.roomId} turnSeq=${meta.turnSeq} eventId=${meta.eventId} promptPolicyVersion=${meta.promptPolicyVersion ?? ""} renderedPromptHash=${meta.renderedPromptHash ?? ""} rawResponseHash=${responseHash ?? ""}`
   );
@@ -1873,10 +2062,20 @@ async function submitGameActionWithLog(action, meta, wsClient, log, source, rawR
       renderedPromptHash: meta.renderedPromptHash,
       parseSource: source,
       rawResponseHash: responseHash,
-      rawResponsePreview: rawResponse ? rawResponsePreview(rawResponse) : void 0,
+      rawResponsePreview: typeof rawResponse === "string" ? rawResponsePreview(rawResponse, Number.MAX_SAFE_INTEGER) : void 0,
       modelActionRejected: auditMeta?.modelActionRejected,
       modelActionType: auditMeta?.modelActionType,
-      validationReason: normalizeAuditText(auditMeta?.validationReason)
+      validationReason: normalizeAuditText(auditMeta?.validationReason),
+      submissionStatus: auditMeta?.submissionStatus ?? (structured ? "VALID" : void 0),
+      structuredProtocolVersion,
+      retryCount: structured ? retryCount : void 0,
+      firstRawResponseHash: auditMeta?.firstRawResponseHash ?? (structured ? responseHash : void 0),
+      firstModelActionType: auditMeta?.firstModelActionType,
+      firstValidationReason: normalizeAuditText(auditMeta?.firstValidationReason),
+      retryRawResponseHash: auditMeta?.retryRawResponseHash,
+      retryValidationReason: normalizeAuditText(auditMeta?.retryValidationReason),
+      speech: action.speech,
+      reason: action.reason
     });
     if (response.uncertain === true) {
       log?.warn?.(
@@ -1902,6 +2101,128 @@ async function submitGameActionWithLog(action, meta, wsClient, log, source, rawR
     return "failed";
   }
 }
+async function submitRejectedOutputWithLog(params) {
+  const rawResponse = params.rawResponse ?? "";
+  const rawHash = sha256Hex(rawResponse);
+  const retryCount = params.auditMeta?.retryCount ?? 0;
+  params.log?.warn?.(
+    `[COOLCLAW-GAME-ACTION-VALIDATE] gameId=${params.meta.gameId} roomId=${params.meta.roomId} eventType=${params.meta.eventType} eventId=${params.meta.eventId} turnSeq=${params.meta.turnSeq} retryCount=${retryCount} submissionStatus=REJECTED_OUTPUT result=submit reason=${params.reason} actionType=INVALID_OUTPUT promptPolicyVersion=${params.meta.promptPolicyVersion ?? ""} renderedPromptHash=${params.meta.renderedPromptHash ?? ""} rawResponseHash=${rawHash ?? ""}`
+  );
+  return submitGameActionWithLog(
+    { actionType: "INVALID_OUTPUT", actionData: {} },
+    params.meta,
+    params.wsClient,
+    params.log,
+    "rejected_output",
+    rawResponse,
+    {
+      modelActionRejected: true,
+      validationReason: params.reason,
+      submissionStatus: "REJECTED_OUTPUT",
+      structuredProtocolVersion: params.meta.agentTask.actionProtocolVersion,
+      retryCount,
+      firstRawResponseHash: params.auditMeta?.firstRawResponseHash ?? rawHash,
+      firstModelActionType: params.auditMeta?.firstModelActionType,
+      firstValidationReason: params.auditMeta?.firstValidationReason,
+      retryRawResponseHash: params.auditMeta?.retryRawResponseHash ?? (retryCount > 0 ? rawHash : void 0),
+      retryValidationReason: params.auditMeta?.retryValidationReason ?? (retryCount > 0 ? params.reason : void 0)
+    }
+  );
+}
+async function submitStructuredFinalActionWithLog(params) {
+  const rawResponse = params.rawResponse ?? "";
+  const rawHash = sha256Hex(rawResponse);
+  if (rawResponse.trim().length === 0) {
+    logStructuredActionValidation({
+      log: params.log,
+      meta: params.meta,
+      retryCount: params.retryCount,
+      submissionStatus: "REJECTED_OUTPUT",
+      result: "reject",
+      reason: "no_model_output",
+      rawResponseHash: rawHash
+    });
+    return { submitted: false, reason: "no_model_output", rawHash };
+  }
+  const parsed = parseStrictJsonAgentAction(rawResponse);
+  if ("error" in parsed) {
+    const reason = parsed.error === "invalid_json" ? `invalid_json:${parsed.detail}` : parsed.error;
+    logStructuredActionValidation({
+      log: params.log,
+      meta: params.meta,
+      retryCount: params.retryCount,
+      submissionStatus: "REJECTED_OUTPUT",
+      result: "reject",
+      reason,
+      rawResponseHash: rawHash
+    });
+    return {
+      submitted: false,
+      reason,
+      rawHash
+    };
+  }
+  const validation = validateAgentAction(parsed, params.meta.agentTask);
+  if (!validation.ok) {
+    logStructuredActionValidation({
+      log: params.log,
+      meta: params.meta,
+      retryCount: params.retryCount,
+      submissionStatus: "REJECTED_OUTPUT",
+      result: "reject",
+      reason: validation.reason,
+      actionType: parsed.actionType,
+      rawResponseHash: rawHash
+    });
+    return {
+      submitted: false,
+      reason: validation.reason,
+      rawHash,
+      modelActionType: parsed.actionType
+    };
+  }
+  logStructuredActionValidation({
+    log: params.log,
+    meta: params.meta,
+    retryCount: params.retryCount,
+    submissionStatus: "VALID",
+    result: "pass",
+    reason: validation.repairReason,
+    actionType: validation.action.actionType,
+    rawResponseHash: rawHash
+  });
+  const status = await submitGameActionWithLog(
+    validation.action,
+    params.meta,
+    params.wsClient,
+    params.log,
+    "llm",
+    rawResponse,
+    {
+      ...params.auditMeta,
+      modelActionRejected: false,
+      modelActionType: validation.action.actionType,
+      validationReason: validation.repairReason,
+      submissionStatus: "VALID",
+      structuredProtocolVersion: params.meta.agentTask.actionProtocolVersion,
+      retryCount: params.retryCount,
+      firstRawResponseHash: params.auditMeta?.firstRawResponseHash ?? rawHash,
+      firstModelActionType: params.auditMeta?.firstModelActionType,
+      firstValidationReason: params.auditMeta?.firstValidationReason,
+      retryRawResponseHash: params.retryCount > 0 ? params.auditMeta?.retryRawResponseHash ?? rawHash : params.auditMeta?.retryRawResponseHash,
+      retryValidationReason: params.retryCount > 0 ? params.auditMeta?.retryValidationReason ?? validation.repairReason : params.auditMeta?.retryValidationReason
+    }
+  );
+  return {
+    submitted: status === "submitted" || status === "uncertain",
+    status,
+    reason: status === "failed" ? `llm_action_submit_failed:${validation.action.actionType}` : void 0,
+    rawHash,
+    modelActionType: validation.action.actionType,
+    validationReason: validation.repairReason,
+    validAction: true
+  };
+}
 async function submitBackendFallbackWithLog(params) {
   const fb = backendFallbackAction(params.meta.agentTask);
   if (!fb) {
@@ -2114,6 +2435,14 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                       let gameModelActionType;
                       let gameValidationReason;
                       let gameModelActionRejected;
+                      let gameReplyAttempt = 0;
+                      let gameFirstRawResponseHash;
+                      let gameFirstModelActionType;
+                      let gameFirstValidationReason;
+                      let gameRetryRawResponseHash;
+                      let gameRetryValidationReason;
+                      let gameBaseReplyContext = null;
+                      let dispatchGameReply = null;
                       const gameBuffer = [];
                       const modelQueryCollector = modelQueryMeta ? createArenaModelQueryReplyCollector({
                         meta: modelQueryMeta,
@@ -2163,6 +2492,23 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                         logInboundDrop({ log: ctx.log?.warn?.bind(ctx.log) ?? (() => {
                         }), channel: productFlavor.channelId, reason: "runtime not available; skipping dispatch" });
                         if (isGameEvent && gameMeta) {
+                          if (isStructuredJsonTask(gameMeta.agentTask)) {
+                            const submitted2 = await submitRejectedOutputWithLog({
+                              meta: gameMeta,
+                              wsClient,
+                              log: ctx.log,
+                              reason: "runtime_not_available",
+                              rawResponse: "",
+                              auditMeta: {
+                                retryCount: 0,
+                                firstValidationReason: "runtime_not_available"
+                              }
+                            });
+                            if (submitted2 === "failed") {
+                              throw new Error("game rejected-output submit failed: runtime_not_available");
+                            }
+                            return;
+                          }
                           const submitted = await submitBackendFallbackWithLog({
                             meta: gameMeta,
                             wsClient,
@@ -2262,6 +2608,7 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                           WasMentioned: envelope.shouldReply,
                           Mentioned: envelope.shouldReply
                         });
+                        gameBaseReplyContext = ctxPayload;
                         const sessionKey = ctxPayload.SessionKey ?? route.sessionKey;
                         const mainSessionKey = route.mainSessionKey;
                         await runtimeChannel.session.recordInboundSession({
@@ -2273,8 +2620,8 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                             ctx.log?.warn(`recordInboundSession failed: ${err instanceof Error ? err.message : String(err)}`);
                           }
                         });
-                        await runtimeChannel.reply.dispatchReplyWithBufferedBlockDispatcher({
-                          ctx: ctxPayload,
+                        dispatchGameReply = async (replyCtxPayload) => runtimeChannel.reply.dispatchReplyWithBufferedBlockDispatcher({
+                          ctx: replyCtxPayload,
                           cfg: ctx.cfg,
                           // 群聊强制走 automatic：CoolClaw 群聊业务语义就是 @ 即回，
                           // 而 OpenClaw 默认对 group/channel 走 message_tool_only，
@@ -2298,8 +2645,10 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                               if (isGameEvent && gameMeta) {
                                 if (gameSubmitted) return;
                                 gameBuffer.push(String(payload.text));
+                                const structuredTask = isStructuredJsonTask(gameMeta.agentTask);
+                                if (structuredTask) return;
                                 const full = gameBuffer.join("");
-                                const parsed = parseAgentAction(full);
+                                const parsed = structuredTask ? parseStrictJsonAgentAction(full) : parseAgentAction(full);
                                 if ("error" in parsed) return;
                                 const validation = validateAgentAction(parsed, gameMeta.agentTask);
                                 if (!validation.ok) {
@@ -2307,11 +2656,30 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                                   gameModelActionType = parsed.actionType;
                                   gameValidationReason = validation.reason;
                                   gameFallbackReason = validation.reason;
+                                  if (structuredTask) {
+                                    const rawHash2 = sha256Hex(full);
+                                    if (gameReplyAttempt === 0) {
+                                      gameFirstRawResponseHash = rawHash2;
+                                      gameFirstModelActionType = parsed.actionType;
+                                      gameFirstValidationReason = validation.reason;
+                                    } else {
+                                      gameRetryRawResponseHash = rawHash2;
+                                      gameRetryValidationReason = validation.reason;
+                                    }
+                                  }
                                   ctx.log?.warn?.(
-                                    `[GAME-ACTION] rejected model action reason=${validation.reason} actionType=${parsed.actionType} eventType=${gameMeta.eventType} eventId=${gameMeta.eventId} promptPolicyVersion=${gameMeta.promptPolicyVersion ?? ""} renderedPromptHash=${gameMeta.renderedPromptHash ?? ""} rawResponseHash=${sha256Hex(full)}`
+                                    `[COOLCLAW-GAME-ACTION-VALIDATE] gameId=${gameMeta.gameId} roomId=${gameMeta.roomId} eventType=${gameMeta.eventType} eventId=${gameMeta.eventId} turnSeq=${gameMeta.turnSeq} retryCount=${gameReplyAttempt} submissionStatus=REJECTED_OUTPUT result=reject reason=${validation.reason} actionType=${parsed.actionType} promptPolicyVersion=${gameMeta.promptPolicyVersion ?? ""} renderedPromptHash=${gameMeta.renderedPromptHash ?? ""} rawResponseHash=${sha256Hex(full)}`
                                   );
                                   return;
                                 }
+                                if (structuredTask) {
+                                  gameModelActionRejected = false;
+                                  gameModelActionType = validation.action.actionType;
+                                  gameValidationReason = validation.repairReason;
+                                  gameFallbackReason = null;
+                                  return;
+                                }
+                                const rawHash = sha256Hex(full);
                                 const submitted = await submitGameActionWithLog(
                                   validation.action,
                                   gameMeta,
@@ -2322,7 +2690,15 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                                   {
                                     modelActionRejected: false,
                                     modelActionType: validation.action.actionType,
-                                    validationReason: validation.repairReason
+                                    validationReason: validation.repairReason,
+                                    submissionStatus: structuredTask ? "VALID" : void 0,
+                                    structuredProtocolVersion: structuredTask ? gameMeta.agentTask.actionProtocolVersion : void 0,
+                                    retryCount: structuredTask ? gameReplyAttempt : void 0,
+                                    firstRawResponseHash: structuredTask ? gameFirstRawResponseHash ?? rawHash : void 0,
+                                    firstModelActionType: structuredTask ? gameFirstModelActionType : void 0,
+                                    firstValidationReason: structuredTask ? gameFirstValidationReason : void 0,
+                                    retryRawResponseHash: structuredTask && gameReplyAttempt > 0 ? rawHash : void 0,
+                                    retryValidationReason: structuredTask && gameReplyAttempt > 0 ? validation.repairReason : void 0
                                   }
                                 );
                                 if (submitted === "submitted" || submitted === "uncertain") {
@@ -2361,6 +2737,7 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                             }
                           }
                         });
+                        await dispatchGameReply(ctxPayload);
                         if (isGameEvent && gameMeta && !gameSubmitted) {
                           if (!gameFallbackReason) {
                             gameFallbackReason = "no_valid_action_in_llm_output";
@@ -2392,10 +2769,91 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                           gameFallbackReason = `dispatch_error: ${errMsg}`;
                         }
                       } finally {
+                        const submitFinalStructuredGameAction = async () => {
+                          if (!isGameEvent || !gameMeta || gameSubmitted || !isStructuredJsonTask(gameMeta.agentTask)) {
+                            return false;
+                          }
+                          const rawResponse = gameBuffer.join("");
+                          const result = await submitStructuredFinalActionWithLog({
+                            rawResponse,
+                            meta: gameMeta,
+                            wsClient,
+                            log: ctx.log,
+                            retryCount: gameReplyAttempt,
+                            auditMeta: {
+                              retryCount: gameReplyAttempt,
+                              firstRawResponseHash: gameFirstRawResponseHash,
+                              firstModelActionType: gameFirstModelActionType,
+                              firstValidationReason: gameFirstValidationReason,
+                              retryRawResponseHash: gameRetryRawResponseHash,
+                              retryValidationReason: gameRetryValidationReason
+                            }
+                          });
+                          if (result.submitted) {
+                            gameSubmitted = true;
+                            gameModelActionRejected = false;
+                            gameModelActionType = result.modelActionType;
+                            gameValidationReason = result.validationReason;
+                            gameFallbackReason = null;
+                            return true;
+                          }
+                          gameModelActionRejected = result.validAction ? false : true;
+                          gameModelActionType = result.modelActionType;
+                          gameValidationReason = result.reason ?? result.validationReason;
+                          gameFallbackReason = result.reason ?? gameFallbackReason ?? "invalid_output";
+                          if (rawResponse.trim().length > 0) {
+                            const rawHash = result.rawHash ?? sha256Hex(rawResponse);
+                            if (gameReplyAttempt === 0) {
+                              gameFirstRawResponseHash = gameFirstRawResponseHash ?? rawHash;
+                              gameFirstModelActionType = gameFirstModelActionType ?? result.modelActionType;
+                              gameFirstValidationReason = gameFirstValidationReason ?? gameValidationReason;
+                            } else {
+                              gameRetryRawResponseHash = gameRetryRawResponseHash ?? rawHash;
+                              gameRetryValidationReason = gameRetryValidationReason ?? gameValidationReason;
+                            }
+                          }
+                          return false;
+                        };
+                        await submitFinalStructuredGameAction();
+                        if (isGameEvent && gameMeta && !gameSubmitted && gameReplyAttempt === 0 && isStructuredJsonTask(gameMeta.agentTask) && dispatchGameReply && gameBaseReplyContext && hasStructuredRetryBudget(gameMeta.deadlineEpochMs) && Math.max(0, gameMeta.agentTask.retryPolicy?.maxRetries ?? 0) > 0) {
+                          const firstRawResponse = gameBuffer.join("");
+                          if (firstRawResponse.trim().length > 0) {
+                            const firstInferred = inferRejectedModelAction(firstRawResponse, gameMeta.agentTask);
+                            if (gameModelActionRejected === false || firstInferred.validationReason === "valid_action_not_submitted") {
+                              ctx.log?.warn?.(
+                                `[GAME-ACTION] structured retry skipped for valid unsubmitted action eventId=${gameMeta.eventId} turnSeq=${gameMeta.turnSeq} reason=${gameFallbackReason ?? firstInferred.validationReason ?? "submit_failed"}`
+                              );
+                            } else {
+                              const firstRawHash = sha256Hex(firstRawResponse);
+                              gameFirstRawResponseHash = gameFirstRawResponseHash ?? firstRawHash;
+                              gameFirstModelActionType = gameFirstModelActionType ?? firstInferred.modelActionType;
+                              gameFirstValidationReason = gameFirstValidationReason ?? gameValidationReason ?? firstInferred.validationReason;
+                              const retryReason = gameFirstValidationReason ?? firstInferred.validationReason ?? "invalid_output";
+                              ctx.log?.warn?.(
+                                `[GAME-ACTION] structured retry start eventId=${gameMeta.eventId} turnSeq=${gameMeta.turnSeq} reason=${retryReason} firstRawResponseHash=${firstRawHash}`
+                              );
+                              gameReplyAttempt = 1;
+                              gameBuffer.length = 0;
+                              gameFallbackReason = null;
+                              gameModelActionRejected = void 0;
+                              gameModelActionType = void 0;
+                              gameValidationReason = void 0;
+                              const retryPrompt = buildStructuredActionRetryPrompt(envelope.text, retryReason);
+                              await dispatchGameReply({
+                                ...gameBaseReplyContext,
+                                Body: retryPrompt,
+                                BodyForAgent: retryPrompt,
+                                RawBody: retryPrompt,
+                                CommandBody: retryPrompt
+                              });
+                              await submitFinalStructuredGameAction();
+                            }
+                          }
+                        }
                         if (isGameEvent && gameMeta) {
                           const rawResponse = gameBuffer.join("");
                           ctx.log?.info?.(
-                            `[GAME-TASK] model-output eventId=${gameMeta.eventId} promptPolicyVersion=${gameMeta.promptPolicyVersion ?? ""} renderedPromptHash=${gameMeta.renderedPromptHash ?? ""} rawHash=${rawResponse ? sha256Hex(rawResponse) : ""} rawPreview=${rawResponsePreview(rawResponse) ?? ""}`
+                            `[GAME-TASK] model-output eventId=${gameMeta.eventId} turnSeq=${gameMeta.turnSeq} retryAttempt=${gameReplyAttempt} promptPolicyVersion=${gameMeta.promptPolicyVersion ?? ""} renderedPromptHash=${gameMeta.renderedPromptHash ?? ""} rawHash=${rawResponse ? sha256Hex(rawResponse) : ""} rawResponseText=${rawResponse ? flattenForLog(rawResponse) : ""}`
                           );
                         }
                         if (isGameEvent && gameMeta && !gameSubmitted) {
@@ -2408,6 +2866,55 @@ var coolclawChannelPlugin = createChatChannelPlugin({
                             if (!gameFallbackReason || gameFallbackReason === "no_valid_action_in_llm_output") {
                               gameFallbackReason = gameValidationReason ?? inferred.validationReason ?? gameFallbackReason;
                             }
+                            if (isStructuredJsonTask(gameMeta.agentTask)) {
+                              if (rawResponse.trim().length === 0) {
+                                gameFallbackReason = "no_model_output";
+                                gameValidationReason = gameValidationReason ?? "no_model_output";
+                              }
+                              if (gameReplyAttempt > 0 && rawResponse.trim().length > 0) {
+                                gameRetryRawResponseHash = gameRetryRawResponseHash ?? sha256Hex(rawResponse);
+                                gameRetryValidationReason = gameRetryValidationReason ?? gameValidationReason ?? inferred.validationReason;
+                              }
+                              const rawHashForAudit = rawResponse.trim().length > 0 ? sha256Hex(rawResponse) : void 0;
+                              const rejectedOutputReason = gameFallbackReason ?? gameValidationReason ?? inferred.validationReason ?? "invalid_json";
+                              if (!shouldSubmitStructuredRejectedOutput({
+                                structuredTask: true,
+                                gameSubmitted,
+                                modelActionRejected: gameModelActionRejected,
+                                fallbackReason: rejectedOutputReason
+                              })) {
+                                logStructuredActionValidation({
+                                  log: ctx.log,
+                                  meta: gameMeta,
+                                  retryCount: gameReplyAttempt,
+                                  submissionStatus: "VALID",
+                                  result: "submit_failed_no_rejected_output",
+                                  reason: rejectedOutputReason,
+                                  actionType: gameModelActionType,
+                                  rawResponseHash: rawHashForAudit
+                                });
+                                return;
+                              }
+                              const submitted2 = await submitRejectedOutputWithLog({
+                                meta: gameMeta,
+                                wsClient,
+                                log: ctx.log,
+                                reason: rejectedOutputReason,
+                                rawResponse,
+                                auditMeta: {
+                                  retryCount: gameReplyAttempt,
+                                  firstRawResponseHash: gameFirstRawResponseHash ?? rawHashForAudit,
+                                  firstModelActionType: gameFirstModelActionType ?? gameModelActionType,
+                                  firstValidationReason: gameFirstValidationReason ?? gameValidationReason ?? inferred.validationReason,
+                                  retryRawResponseHash: gameRetryRawResponseHash,
+                                  retryValidationReason: gameRetryValidationReason
+                                }
+                              });
+                              if (submitted2 === "failed") {
+                                throw new Error(`game rejected-output submit failed: ${gameFallbackReason ?? "unknown"}`);
+                              }
+                              return;
+                            }
                             const submitted = await submitBackendFallbackWithLog({
                               meta: gameMeta,
                               wsClient,

package/dist/{chunk-TCWYIFNP.js → chunk-RPT3G66A.js}

@@ -4,7 +4,7 @@ import {
   coolclawChannelPlugin,
   defaultBindingFile,
   setCoolclawRuntime
-} from "./chunk-BVFSS5UA.js";
+} from "./chunk-3YKMAM6K.js";
 
 // index.ts
 import { defineChannelPluginEntry, buildChannelConfigSchema } from "openclaw/plugin-sdk/core";

package/dist/cli-metadata.js

@@ -1,7 +1,7 @@
 import {
   index_default
-} from "./chunk-TCWYIFNP.js";
-import "./chunk-BVFSS5UA.js";
+} from "./chunk-RPT3G66A.js";
+import "./chunk-3YKMAM6K.js";
 
 // cli-metadata.ts
 var cli_metadata_default = index_default;

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   index_default
-} from "./chunk-TCWYIFNP.js";
-import "./chunk-BVFSS5UA.js";
+} from "./chunk-RPT3G66A.js";
+import "./chunk-3YKMAM6K.js";
 export {
   index_default as default
 };

package/dist/setup-entry.js

@@ -1,6 +1,6 @@
 import {
   coolclawChannelPlugin
-} from "./chunk-BVFSS5UA.js";
+} from "./chunk-3YKMAM6K.js";
 
 // setup-entry.ts
 import { defineSetupPluginEntry } from "openclaw/plugin-sdk/core";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coolclaw/coolclaw",
-  "version": "1.0.16",
+  "version": "1.0.17",
   "description": "OpenClaw native channel plugin for CoolClaw chat.",
   "type": "module",
   "main": "./dist/index.js",