@apa-network/agent-sdk 0.2.0-beta.12 → 0.2.0-beta.14

package/README.md

@@ -88,7 +88,7 @@ apa-bot submit-decision --decision-id <decision_id> --action raise --amount 300
 - rejects out-of-range amounts (`amount_out_of_range`)
 
 Runtime disconnect handling:
-- If `next-decision` receives `reconnect_grace_started`, it emits `{"type":"noop","reason":"table_closing",...}`.
+- If `next-decision` receives `reconnect_grace_started`, it emits `{"type":"table_closing","reason":"table_closing",...}`.
 - If `next-decision` receives `table_closed`/`session_closed`, it emits `{"type":"table_closed",...}` and clears local session state.
 - If `submit-decision` returns `table_closing` or `opponent_disconnected`, CLI emits `{"type":"table_closing",...}` and clears pending decision.
 - If `submit-decision` returns `table_closed`, CLI emits `{"type":"table_closed",...}` and clears pending decision.

package/dist/cli.js

@@ -246,16 +246,22 @@ async function ensureSession(client, apiBase, agentId, apiKey, joinMode, roomId)
     }
     const balance = Number(me?.balance_cc ?? 0);
     const rooms = await client.listPublicRooms();
-    const pickedRoom = pickRoom(rooms.items || [], joinMode, roomId);
-    if (balance < pickedRoom.min_buyin_cc) {
-        throw new Error(`insufficient_balance (balance=${balance}, min=${pickedRoom.min_buyin_cc})`);
-    }
-    const session = await client.createSession({
-        agentID: agentId,
-        apiKey,
-        joinMode: "select",
-        roomID: pickedRoom.id
-    }).catch(async (err) => {
+    if (joinMode === "select") {
+        const pickedRoom = pickRoom(rooms.items || [], joinMode, roomId);
+        if (balance < pickedRoom.min_buyin_cc) {
+            throw new Error(`insufficient_balance (balance=${balance}, min=${pickedRoom.min_buyin_cc})`);
+        }
+    }
+    else {
+        const lowestRoom = pickRoom(rooms.items || [], "random");
+        if (balance < lowestRoom.min_buyin_cc) {
+            throw new Error(`insufficient_balance (balance=${balance}, min=${lowestRoom.min_buyin_cc})`);
+        }
+    }
+    const sessionInput = joinMode === "select"
+        ? { agentID: agentId, apiKey, joinMode: "select", roomID: roomId }
+        : { agentID: agentId, apiKey, joinMode: "random" };
+    const session = await client.createSession(sessionInput).catch(async (err) => {
         const recovered = recoverSessionFromConflict(err, apiBase);
         if (!recovered) {
             throw err;
@@ -302,6 +308,7 @@ async function runNextDecision(args) {
     let decided = false;
     let newLastEventId = lastEventId;
     let pendingDecision;
+    let stateCleared = false;
     try {
         newLastEventId = await parseSSEOnce(streamURL, lastEventId, timeoutMs, async (evt) => {
             let envelope;
@@ -321,13 +328,14 @@ async function runNextDecision(args) {
                     last_turn_id: "",
                     pending_decision: undefined
                 });
+                stateCleared = true;
                 emit({ type: "table_closed", session_id: sessionId, reason: data?.reason || "table_closed" });
                 decided = true;
                 return true;
             }
             if (evType === "reconnect_grace_started") {
                 emit({
-                    type: "noop",
+                    type: "table_closing",
                     reason: "table_closing",
                     event: evType,
                     session_id: sessionId,
@@ -339,7 +347,7 @@ async function runNextDecision(args) {
             }
             if (evType === "opponent_forfeited") {
                 emit({
-                    type: "noop",
+                    type: "table_closing",
                     reason: "table_closing",
                     event: evType,
                     session_id: sessionId
@@ -353,7 +361,7 @@ async function runNextDecision(args) {
             const tableStatus = String(data?.table_status || "active");
             if (tableStatus === "closing") {
                 emit({
-                    type: "noop",
+                    type: "table_closing",
                     reason: "table_closing",
                     event: evType,
                     session_id: sessionId,
@@ -371,6 +379,7 @@ async function runNextDecision(args) {
                     last_turn_id: "",
                     pending_decision: undefined
                 });
+                stateCleared = true;
                 emit({
                     type: "table_closed",
                     session_id: sessionId,
@@ -415,17 +424,18 @@ async function runNextDecision(args) {
         });
     }
     catch (err) {
-        emit({ type: "error", error: err instanceof Error ? err.message : String(err) });
         throw err;
     }
     finally {
-        await saveDecisionState({
-            session_id: sessionId,
-            stream_url: streamURL,
-            last_event_id: newLastEventId,
-            last_turn_id: "",
-            pending_decision: pendingDecision
-        });
+        if (!stateCleared) {
+            await saveDecisionState({
+                session_id: sessionId,
+                stream_url: streamURL,
+                last_event_id: newLastEventId,
+                last_turn_id: "",
+                pending_decision: pendingDecision
+            });
+        }
     }
     if (!decided) {
         emit({ type: "noop" });

package/dist/cli.next_decision.e2e.test.js

@@ -127,6 +127,9 @@ test("next-decision creates session, emits decision_request (without protocol fi
         assert.deepEqual(state.pending_decision?.action_constraints, { bet: { min: 100, max: 1200 } });
         const created = calls.find((c) => c.url === `${apiBase}/agent/sessions` && c.method === "POST");
         assert.ok(created);
+        const createdPayload = JSON.parse(String(created?.body || "{}"));
+        assert.equal(createdPayload.join_mode, "random");
+        assert.equal(createdPayload.room_id, undefined);
     });
 });
 test("next-decision recovers from 409 and reuses existing session from response body", async () => {
@@ -362,7 +365,7 @@ test("submit-decision blocks out-of-range amount locally", async () => {
         assert.equal(actionCall, undefined);
     });
 });
-test("next-decision emits noop when table is closing", async () => {
+test("next-decision emits table_closing when table is closing", async () => {
     await withTempCwd(async () => {
         const apiBase = "http://mock.local/api";
         await saveCredential({
@@ -406,10 +409,62 @@ test("next-decision emits noop when table is closing", async () => {
             .filter(Boolean)
             .map((line) => JSON.parse(line));
         assert.equal(messages.length, 1);
-        assert.equal(messages[0]?.type, "noop");
+        assert.equal(messages[0]?.type, "table_closing");
         assert.equal(messages[0]?.reason, "table_closing");
     });
 });
+test("next-decision keeps decision state cleared after table_closed", async () => {
+    await withTempCwd(async () => {
+        const apiBase = "http://mock.local/api";
+        await saveCredential({
+            api_base: apiBase,
+            agent_name: "BotA",
+            agent_id: "agent_1",
+            api_key: "apa_1"
+        });
+        const originalFetch = globalThis.fetch;
+        const stdout = captureStdout();
+        globalThis.fetch = (async (input, init) => {
+            const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+            const method = init?.method || "GET";
+            if (url === `${apiBase}/agents/me` && method === "GET") {
+                return jsonResponse({ status: "claimed", balance_cc: 10000 });
+            }
+            if (url === `${apiBase}/public/rooms` && method === "GET") {
+                return jsonResponse({ items: [{ id: "room_low", min_buyin_cc: 1000, name: "Low" }] });
+            }
+            if (url === `${apiBase}/agent/sessions` && method === "POST") {
+                return jsonResponse({ session_id: "sess_closed", stream_url: "/api/agent/sessions/sess_closed/events" });
+            }
+            if (url === `${apiBase}/agent/sessions/sess_closed/events` && method === "GET") {
+                return sseResponse([
+                    "id: 650\nevent: message\ndata: {\"event\":\"table_closed\",\"data\":{\"reason\":\"opponent_reconnect_timeout\"}}\n\n"
+                ]);
+            }
+            throw new Error(`unexpected fetch: ${method} ${url}`);
+        });
+        try {
+            await runCLI(["next-decision", "--api-base", apiBase, "--join", "random", "--timeout-ms", "2000"]);
+        }
+        finally {
+            globalThis.fetch = originalFetch;
+            stdout.restore();
+        }
+        const messages = stdout.writes
+            .join("")
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+        assert.equal(messages.length, 1);
+        assert.equal(messages[0]?.type, "table_closed");
+        const state = await loadDecisionState();
+        assert.equal(state.session_id, "");
+        assert.equal(state.stream_url, "");
+        assert.equal(state.last_event_id, "");
+        assert.equal(state.pending_decision, undefined);
+    });
+});
 test("submit-decision emits table_closing and clears pending decision", async () => {
     await withTempCwd(async () => {
         const apiBase = "http://mock.local/api";

package/dist/commands/register.js

@@ -3,9 +3,13 @@ export function buildCredentialFromRegisterResult(result, apiBase, fallbackName)
     if (!obj) {
         return null;
     }
-    const agentID = typeof obj.agent_id === "string" ? obj.agent_id : "";
-    const apiKey = typeof obj.api_key === "string" ? obj.api_key : "";
-    const agentName = typeof obj.name === "string" && obj.name.trim() ? obj.name : fallbackName;
+    const agent = (obj.agent && typeof obj.agent === "object" ? obj.agent : null);
+    if (!agent) {
+        return null;
+    }
+    const agentID = typeof agent.agent_id === "string" ? agent.agent_id : "";
+    const apiKey = typeof agent.api_key === "string" ? agent.api_key : "";
+    const agentName = typeof agent.name === "string" && agent.name.trim() ? agent.name : fallbackName;
     if (!agentID || !apiKey || !agentName) {
         return null;
     }

package/dist/commands/register.test.js

@@ -3,9 +3,11 @@ import assert from "node:assert/strict";
 import { buildCredentialFromRegisterResult } from "./register.js";
 test("buildCredentialFromRegisterResult returns credential when response has required fields", () => {
     const out = buildCredentialFromRegisterResult({
-        agent_id: "agent_123",
-        api_key: "apa_123",
-        name: "BotX"
+        agent: {
+            agent_id: "agent_123",
+            api_key: "apa_123",
+            name: "BotX"
+        }
     }, "http://localhost:8080/api", "FallbackBot");
     assert.ok(out);
     assert.equal(out?.agent_id, "agent_123");
@@ -14,13 +16,17 @@ test("buildCredentialFromRegisterResult returns credential when response has req
 });
 test("buildCredentialFromRegisterResult falls back to CLI name and rejects incomplete payload", () => {
     const fallback = buildCredentialFromRegisterResult({
-        agent_id: "agent_abc",
-        api_key: "apa_abc"
+        agent: {
+            agent_id: "agent_abc",
+            api_key: "apa_abc"
+        }
     }, "http://localhost:8080/api", "FallbackBot");
     assert.ok(fallback);
     assert.equal(fallback?.agent_name, "FallbackBot");
     const bad = buildCredentialFromRegisterResult({
-        api_key: "apa_missing_agent"
+        agent: {
+            api_key: "apa_missing_agent"
+        }
     }, "http://localhost:8080/api", "FallbackBot");
     assert.equal(bad, null);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apa-network/agent-sdk",
-  "version": "0.2.0-beta.12",
+  "version": "0.2.0-beta.14",
   "description": "APA Agent SDK and CLI",
   "type": "module",
   "bin": {