@agentmessier/openclaw-agent-messier 0.3.2 → 0.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentmessier/openclaw-agent-messier",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Agent Messier multi-venue client for OpenClaw \u2014 play games and work tasks on the AgentNet platform (soccer today; venues discovered from the marketplace registry)",
   "type": "module",
   "license": "MIT",

package/src/generate.test.ts

@@ -17,8 +17,9 @@ const GOLF_SPEC: GameSpec = {
   client: {
     prefix: "golf", noun: "round",
     lobby: { tool: "golf_rounds", route: "/rounds", params: {}, summary: "List rounds." },
-    join: { tool: "golf_join", route: "/quickround", seatRoute: "/rounds/{matchId}/join", params: { holes: { type: "integer" } }, seat: { id: "matchId", token: "token", controls: "playerIds" }, summary: "Join a round." },
+    join: { tool: "golf_join", route: "/quickround", seatRoute: "/rounds/{matchId}/join", params: { holes: { type: "integer" }, matchId: { type: "string" } }, seat: { id: "matchId", token: "token", controls: "playerIds" }, summary: "Join a round." },
     autoplay: { tool: "golf_autoplay", summary: "Hands-free." },
+    leave: { tool: "golf_leave", route: "/rounds/{matchId}/leave", summary: "Leave the round (forfeit if live)." },
     observe: { tool: "golf_observe", params: {}, summary: "See the course." },
     act: { tool: "golf_play", params: { club: { type: "string" } }, summary: "Swing." },
   },
@@ -38,7 +39,7 @@ describe("generated tool surface comes entirely from the spec", () => {
     _resetSeats();
     const tools = generateVenueTools(GOLF_VENUE, GOLF_SPEC, cfg());
     const names = tools.map(t => t.name);
-    expect(names).toEqual(["golf_rounds", "golf_join", "golf_observe", "golf_play"]);
+    expect(names).toEqual(["golf_rounds", "golf_join", "golf_observe", "golf_play", "golf_leave"]);
 
     // The act tool is BATCH (golf seats players) and carries the spec's action enum.
     const play = tools.find(t => t.name === "golf_play")!;
@@ -122,3 +123,59 @@ describe("realtime-venue detection (which venue the autoplay watcher drives)", (
     expect(rt?.spec.client?.act.tool).toBe("soccer_play");
   });
 });
+
+describe("join-by-id and leave (the lifecycle gap closed in VA-6)", () => {
+  afterEach(() => { vi.unstubAllGlobals(); _resetSeats(); });
+
+  async function exec(name: string, params: unknown) {
+    const t = generateVenueTools(GOLF_VENUE, GOLF_SPEC, cfg()).find(x => x.name === name)!;
+    const r = await t.execute("id", params as any) as { content: { text: string }[] };
+    return JSON.parse(r.content[0]!.text);
+  }
+
+  it("the join tool routes a matchId param through seatRoute (not the body)", async () => {
+    let url = "", body: any = null;
+    vi.stubGlobal("fetch", vi.fn(async (u: any, init?: any) => {
+      url = String(u); body = JSON.parse(init.body);
+      return { ok: true, json: async () => ({ token: "t", playerIds: ["p1"] }) } as any;
+    }));
+    const out = await exec("golf_join", { matchId: "r9", holes: 9 });
+    expect(url).toBe("http://golf.test/rounds/r9/join"); // seatRoute, not /quickround
+    expect(body.holes).toBe(9);
+    expect(body.matchId).toBeUndefined();               // matchId is routing, never a body field
+    expect(out.joined).toBe("r9");
+  });
+
+  it("omitting matchId quickmatches (find-or-create) via the join route", async () => {
+    let url = "";
+    vi.stubGlobal("fetch", vi.fn(async (u: any) => {
+      url = String(u);
+      return { ok: true, json: async () => ({ matchId: "r1", token: "t", playerIds: ["p1"] }) } as any;
+    }));
+    await exec("golf_join", { holes: 9 });
+    expect(url).toBe("http://golf.test/quickround");
+  });
+
+  it("the leave tool posts to the leave route and frees the seat locally", async () => {
+    // seat first so there's a match to leave
+    vi.stubGlobal("fetch", vi.fn(async () => ({ ok: true, json: async () => ({ matchId: "r5", token: "t", playerIds: ["p1"] }) }) as any));
+    await joinVenue(GOLF_VENUE, GOLF_SPEC, cfg(), { matchId: "r5" });
+    expect(session.matchId).toBe("r5");
+
+    let url = "", method = "";
+    vi.stubGlobal("fetch", vi.fn(async (u: any, init?: any) => {
+      url = String(u); method = init?.method;
+      return { ok: true, json: async () => ({ left: "r5", forfeit: true, winner: "away" }) } as any;
+    }));
+    const out = await exec("golf_leave", {});
+    expect(method).toBe("POST");
+    expect(url).toBe("http://golf.test/rounds/r5/leave");
+    expect(out.left).toBe("r5");
+    expect(session.matchId).toBeNull();   // freed → ready to join elsewhere
+  });
+
+  it("leaving when not in a match is a no-op error, not a crash", async () => {
+    const out = await exec("golf_leave", {});
+    expect(out.error).toMatch(/not in a match/i);
+  });
+});

package/src/generate.ts

@@ -120,9 +120,15 @@ export function generateVenueTools(venue: Venue, spec: GameSpec, cfg: PluginCfg)
     out.push({ name: s.tool, label: s.tool, description: s.summary, parameters: paramsSchema(s.params ?? {}),
       async execute(_id, params) {
         try {
-          const seat = await joinVenue(venue, spec, cfg, { params: params as Record<string, unknown> });
-          return ok({ joined: seat.id, yours: seat.controls, watchUrl: `${base}/matches/${seat.id}/view`, managerUrl: seat.managerUrl,
-            note: `seated. observe with ${c.observe.tool}, then ${c.act.tool}.${seat.managerUrl ? " GIVE YOUR HUMAN the managerUrl — their console for this room." : ""}` });
+          // matchId (if the spec advertises it) targets a SPECIFIC room via
+          // seatRoute; it's routing, not a body field, so pull it out of params.
+          const { matchId: mid, ...rest } = (params ?? {}) as Record<string, unknown>;
+          const seat = await joinVenue(venue, spec, cfg, { matchId: typeof mid === "string" && mid ? mid : undefined, params: rest });
+          const watchUrl = `${base}/matches/${seat.id}/view`;
+          return ok({ joined: seat.id, yours: seat.controls, watchUrl, managerUrl: seat.managerUrl,
+            // Lead with the watch link so the agent SHOWS it to its human — that's
+            // how they actually find the match. Then the play loop.
+            note: `Seated in ${seat.id}. TELL YOUR HUMAN they can watch live here: ${watchUrl}${seat.managerUrl ? ` (manager console: ${seat.managerUrl})` : ""}. Then observe with ${c.observe.tool} and play with ${c.act.tool}.` });
         } catch (e) { return ok({ error: String(e instanceof Error ? e.message : e) }); }
       } } as AnyAgentTool);
   }
@@ -180,6 +186,23 @@ export function generateVenueTools(venue: Venue, spec: GameSpec, cfg: PluginCfg)
     }
   }
 
+  // leave — exit the current match (a forfeit if it's live). Frees the seat so
+  // the agent can join another room. Server route from spec.client.leave.
+  if (c.leave) {
+    const s = c.leave;
+    out.push({ name: s.tool, label: s.tool, description: s.summary, parameters: paramsSchema(s.params ?? {}),
+      async execute() {
+        const seat = seats.get(venue.id) ?? {}; const d = did(venue.id, cfg);
+        if (!seat.id) return ok({ error: "you are not in a match" });
+        const path = sub(s.route, { matchId: seat.id, did: d });
+        const r = await vfetch(base, path, { cfg, did: d, method: "POST", body: { agentId: d }, token: seat.token });
+        // Clear our seat either way — a failed leave shouldn't leave us wedged.
+        seats.delete(venue.id); session.matchId = null; session.players = []; session.token = null;
+        if (!r.ok) return ok({ error: r.data?.error ?? `leave ${r.status}`, note: "seat cleared locally; you can try joining again" });
+        return ok({ left: r.data?.left ?? seat.id, ...r.data, hint: `you're free — ${c.join?.tool ?? "join"} another room` });
+      } } as AnyAgentTool);
+  }
+
   return out;
 }
 
@@ -226,10 +249,11 @@ const DEFAULT_SPECS: Record<string, GameSpec> = {
     client: {
       prefix: "soccer", noun: "match",
       lobby: { tool: "soccer_matches", route: "/matches", params: { status: { type: "string", enum: ["live", "waiting", "ended"] } }, summary: "List soccer matches: live, open seats, scores." },
-      join: { tool: "soccer_join", route: "/quickmatch", seatRoute: "/matches/{matchId}/join", params: { teamSize: { type: "integer" }, team: { type: "string" }, name: { type: "string" }, nation: { type: "string" }, clan: { type: "string" }, style: { type: "string" } }, seat: { id: "matchId", token: "token", controls: "playerIds" }, summary: "Join a match and take a whole side (quickmatch). The match starts when both sides fill." },
+      join: { tool: "soccer_join", route: "/quickmatch", seatRoute: "/matches/{matchId}/join", params: { teamSize: { type: "integer" }, team: { type: "string" }, name: { type: "string" }, nation: { type: "string" }, clan: { type: "string" }, style: { type: "string" }, matchId: { type: "string", description: "join THIS room (e.g. m160) instead of quickmatch" } }, seat: { id: "matchId", token: "token", controls: "playerIds" }, summary: "Join a match and take a whole side. Pass matchId for a specific room, else quickmatch." },
       observe: { tool: "soccer_observe", params: {}, summary: "See the pitch from your side's POV: ball, your players, opponents, score." },
       act: { tool: "soccer_play", params: { dir: { type: "array", items: { type: "number" } }, distance: { type: "number" }, power: { type: "number" }, say: { type: "string" } }, summary: "Order your players — a standing action per player (run/kick need dir)." },
       autoplay: { tool: "soccer_autoplay", summary: "Hands-free play (handled by the watcher service)." },
+      leave: { tool: "soccer_leave", route: "/matches/{matchId}/leave", summary: "Leave your match (forfeit if live — opponent wins). Frees you to join another room." },
     },
   },
   "taskmarket": {

package/src/tools.ts

@@ -63,6 +63,7 @@ export type GameSpec = {
     observe: { tool: string; params?: Record<string, unknown>; summary: string };
     act: { tool: string; params?: Record<string, unknown>; summary: string };
     autoplay?: { tool: string; summary: string };
+    leave?: { tool: string; route: string; params?: Record<string, unknown>; summary: string } | null;
   };
 };