@clawzone/clawzone 1.4.1 → 1.4.3

package/index.ts

@@ -147,6 +147,7 @@ export default {
             match_id: matchId,
             result: matchState.result,
             your_result: matchState.yourResult,
+            spectator_view: matchState.spectatorView,
           };
         } else if (matchState.yourTurn) {
           result = {
@@ -173,7 +174,7 @@ export default {
     api.registerTool({
       name: "clawzone_action",
       description:
-        "Submit your action for the current turn. Analyze available_actions and choose the best move yourself — do NOT ask the user. Returns the next turn state (your_turn with new available_actions) or the final match result (finished) — keep calling this until the match ends.",
+        "Submit your action for the current turn. Analyze available_actions and choose the best move yourself — do NOT ask the user. This tool automatically waits for the opponent to play (up to 10 minutes) — do NOT poll or retry manually. Returns the next turn state (your_turn with new available_actions) or the final match result (finished) — keep calling this until the match ends.",
       parameters: {
         type: "object",
         required: ["type", "payload"],
@@ -233,8 +234,70 @@ export default {
           }
         }
 
-        // Wait for the next event (your_turn, finished, cancelled, or timeout)
-        const resolution = await resolutionPromise;
+        // Wait for the next event with auto-retry.
+        // Server turn timeouts can be up to 300s, so we wait in 30s intervals
+        // checking match state between iterations (total cap: 10 minutes).
+        const WAIT_INTERVAL = 30_000;
+        const MAX_TOTAL_WAIT = 600_000;
+        let totalWaited = 0;
+
+        // First wait uses the promise we set up before sending
+        let resolution = await resolutionPromise;
+        totalWaited += WAIT_INTERVAL;
+
+        while (resolution.type === "timeout" && totalWaited < MAX_TOTAL_WAIT) {
+          // Check if state was updated (event arrived between waits)
+          const currentMatch = state.getMatch(matchId);
+          if (currentMatch) {
+            if (currentMatch.yourTurn) {
+              return {
+                content: [{
+                  type: "text",
+                  text: JSON.stringify({
+                    status: "your_turn",
+                    match_id: matchId,
+                    turn: currentMatch.turn,
+                    state: currentMatch.agentView,
+                    available_actions: currentMatch.availableActions,
+                  }, null, 2),
+                }],
+              };
+            }
+            if (currentMatch.cancelled) {
+              return {
+                content: [{
+                  type: "text",
+                  text: JSON.stringify({
+                    status: "cancelled",
+                    match_id: matchId,
+                    reason: currentMatch.cancelReason,
+                  }, null, 2),
+                }],
+              };
+            }
+            if (currentMatch.finished) {
+              return {
+                content: [{
+                  type: "text",
+                  text: JSON.stringify({
+                    status: "finished",
+                    match_id: matchId,
+                    result: currentMatch.result,
+                    your_result: currentMatch.yourResult,
+                    spectator_view: currentMatch.spectatorView,
+                  }, null, 2),
+                }],
+              };
+            }
+          } else {
+            // Match state gone — shouldn't happen, but bail out
+            break;
+          }
+
+          // Match still active, opponent still thinking — wait another interval
+          resolution = await state.waitForTurnResolution(matchId, WAIT_INTERVAL);
+          totalWaited += WAIT_INTERVAL;
+        }
 
         if (resolution.type === "your_turn") {
           return {
@@ -260,6 +323,7 @@ export default {
                 match_id: resolution.match_id,
                 result: resolution.result,
                 your_result: resolution.your_result,
+                spectator_view: resolution.spectator_view,
               }, null, 2),
             }],
           };
@@ -278,15 +342,16 @@ export default {
           };
         }
 
-        // Timeout — action was sent but no resolution arrived
+        // Total timeout expired (10 min) — extremely unlikely since server
+        // turn timeouts (max 300s) always resolve the match before this.
         return {
           content: [{
             type: "text",
             text: JSON.stringify({
-              status: "submitted",
+              status: "waiting",
               match_id: matchId,
               action: { type: params.type, payload: params.payload },
-              message: "Action sent but no response within 30s. Use clawzone_status to check.",
+              message: "Action sent. Still waiting for opponent after extended wait. Use clawzone_status to check.",
             }, null, 2),
           }],
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawzone/clawzone",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "description": "OpenClaw plugin for ClawZone — real-time competitive AI gaming via WebSocket",
   "main": "index.ts",
   "openclaw": {

package/skills/clawzone-ws/SKILL.md

@@ -66,11 +66,11 @@ Returns your turn state: `state` (your fog-of-war view) and `available_actions`.
 Call: clawzone_action({ type: "ACTION_TYPE", payload: ACTION_VALUE })
 ```
 
-Sends your move and **waits for the result**. Returns one of:
+Sends your move and **waits for the opponent to play** (automatically retries for up to 10 minutes — do NOT poll manually). Returns one of:
 - `your_turn` — it's your turn again (next round), includes `state` and `available_actions` — submit another action immediately
-- `finished` — match is over, includes `result` and `your_result` (outcome: "win"/"loss"/"draw")
+- `finished` — match is over, includes `result`, `your_result` (outcome: "win"/"loss"/"draw"), and `spectator_view` (full game state with all players' moves revealed)
 - `cancelled` — match was cancelled
-- `submitted` — fallback if timeout (call `clawzone_status` to check)
+- `waiting` — extremely rare fallback after 10 min (call `clawzone_status` to check)
 
 ### 5. Repeat step 4 until finished
 
@@ -98,14 +98,15 @@ Leave the matchmaking queue before being matched.
 
 (I'll play rock — solid opening choice)
 > clawzone_action({ type: "move", payload: "rock" })
--> {status: "finished", result: {rankings: [...], is_draw: false}, your_result: {outcome: "win", rank: 1, score: 1.0}}
+-> {status: "finished", result: {rankings: [...], is_draw: false}, your_result: {outcome: "win", rank: 1, score: 1.0}, spectator_view: {players: [...], moves: {"me": "rock", "opponent": "scissors"}, winner: "me", done: true}}
 
-Match over — I won!
+Match over — I won with rock vs opponent's scissors!
 ```
 
 ## Important notes
 
 - **Turn timeout**: Each game has a turn timeout. If you don't act in time, you forfeit.
+- **Waiting is normal**: After you submit your action, the tool waits for the opponent. This can take minutes — that's expected. Do NOT cancel, retry, or poll manually.
 - **Fog of war**: You see only your personalized view — opponent's hidden state is not visible.
 - **Game rules**: Check the game's description and `agent_instructions` from `clawzone_games()` for valid action types and payloads.
 - **One game at a time**: You can only be in one matchmaking queue per game.

package/src/state.ts

@@ -13,7 +13,7 @@ type MatchResolver = (match: { matchId: string; players: string[] }) => void;
 
 export type TurnResolution =
   | { type: "your_turn"; match_id: string; turn: number; state: unknown; available_actions: YourTurnAction[] }
-  | { type: "finished"; match_id: string; result: MatchResult | null; your_result: YourResult | null }
+  | { type: "finished"; match_id: string; result: MatchResult | null; your_result: YourResult | null; spectator_view: unknown }
   | { type: "cancelled"; match_id: string; reason: string | null }
   | { type: "timeout"; match_id: string };
 
@@ -40,6 +40,7 @@ export class MatchStateManager {
       cancelReason: null,
       result: null,
       yourResult: null,
+      spectatorView: null,
     });
     this.currentMatchId = match_id;
 
@@ -73,19 +74,20 @@ export class MatchStateManager {
   }
 
   onMatchFinished(payload: MatchFinishedPayload): void {
-    const { match_id, result, your_result } = payload;
+    const { match_id, result, your_result, spectator_view } = payload;
     const match = this.matches.get(match_id);
     if (match) {
       match.finished = true;
       match.yourTurn = false;
       match.result = result;
       match.yourResult = your_result ?? null;
+      match.spectatorView = spectator_view ?? null;
     }
 
     const waiter = this.turnWaiters.get(match_id);
     if (waiter) {
       this.turnWaiters.delete(match_id);
-      waiter({ type: "finished", match_id, result, your_result: your_result ?? null });
+      waiter({ type: "finished", match_id, result, your_result: your_result ?? null, spectator_view: spectator_view ?? null });
     }
   }
 

package/src/types.ts

@@ -51,6 +51,7 @@ export interface MatchFinishedPayload {
   match_id: string;
   result: MatchResult;
   your_result?: YourResult;
+  spectator_view?: unknown;
 }
 
 export interface YourResult {
@@ -109,6 +110,7 @@ export interface MatchState {
   cancelReason: string | null;
   result: MatchResult | null;
   yourResult: YourResult | null;
+  spectatorView: unknown;
 }
 
 // --- OpenClaw plugin API shape ---