@apa-network/agent-sdk 0.1.0 → 0.2.0-beta.10

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

@@ -0,0 +1,468 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { runCLI } from "./cli.js";
+import { saveCredential } from "./loop/credentials.js";
+import { loadDecisionState } from "./loop/decision_state.js";
+function jsonResponse(body, status = 200) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { "content-type": "application/json" }
+    });
+}
+function sseResponse(chunks) {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        start(controller) {
+            for (const chunk of chunks) {
+                controller.enqueue(encoder.encode(chunk));
+            }
+            controller.close();
+        }
+    });
+    return new Response(stream, {
+        status: 200,
+        headers: { "content-type": "text/event-stream" }
+    });
+}
+function captureStdout() {
+    const writes = [];
+    const original = process.stdout.write.bind(process.stdout);
+    process.stdout.write = ((chunk) => {
+        writes.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
+        return true;
+    });
+    return {
+        writes,
+        restore() {
+            process.stdout.write = original;
+        }
+    };
+}
+async function withTempCwd(fn) {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "apa-sdk-next-decision-"));
+    const prev = process.cwd();
+    process.chdir(dir);
+    try {
+        return await fn();
+    }
+    finally {
+        process.chdir(prev);
+    }
+}
+test("next-decision creates session, emits decision_request (without protocol fields), and updates state", 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 calls = [];
+        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";
+            calls.push({
+                url,
+                method,
+                headers: init?.headers,
+                body: typeof init?.body === "string" ? init.body : undefined
+            });
+            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_1",
+                    stream_url: "/api/agent/sessions/sess_1/events"
+                });
+            }
+            if (url === `${apiBase}/agent/sessions/sess_1/events` && method === "GET") {
+                return sseResponse([
+                    "id: 101\nevent: message\ndata: {\"event\":\"state_snapshot\",\"data\":{\"turn_id\":\"turn_1\",",
+                    "\"my_seat\":0,\"current_actor_seat\":0,\"legal_actions\":[\"check\",\"bet\"],",
+                    "\"action_constraints\":{\"bet\":{\"min\":100,\"max\":1200}}}}\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));
+        const decision = messages.find((m) => m.type === "decision_request");
+        assert.ok(decision);
+        assert.equal(decision?.session_id, "sess_1");
+        assert.ok(typeof decision?.decision_id === "string");
+        assert.equal(decision?.turn_id, undefined);
+        assert.equal(decision?.callback_url, undefined);
+        assert.deepEqual(decision?.legal_actions, ["check", "bet"]);
+        assert.deepEqual(decision?.action_constraints, { bet: { min: 100, max: 1200 } });
+        const state = await loadDecisionState();
+        assert.equal(state.session_id, "sess_1");
+        assert.equal(state.stream_url, `${apiBase}/agent/sessions/sess_1/events`);
+        assert.equal(state.last_event_id, "101");
+        assert.ok(state.pending_decision?.decision_id);
+        assert.equal(state.pending_decision?.session_id, "sess_1");
+        assert.equal(state.pending_decision?.callback_url, `${apiBase}/agent/sessions/sess_1/actions`);
+        assert.equal(state.pending_decision?.turn_id, "turn_1");
+        assert.deepEqual(state.pending_decision?.legal_actions, ["check", "bet"]);
+        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);
+    });
+});
+test("next-decision recovers from 409 and reuses existing session from response body", 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({
+                    error: "agent_already_in_session",
+                    session_id: "sess_conflict",
+                    stream_url: "/api/agent/sessions/sess_conflict/events"
+                }, 409);
+            }
+            if (url === `${apiBase}/agent/sessions/sess_conflict/events` && method === "GET") {
+                return sseResponse([
+                    "id: 202\nevent: message\ndata: {\"event\":\"state_snapshot\",\"data\":{\"turn_id\":\"turn_2\",\"my_seat\":1,\"current_actor_seat\":1,",
+                    "\"legal_actions\":[\"fold\",\"call\",\"raise\"],\"action_constraints\":{\"raise\":{\"min_to\":300,\"max_to\":1500}}}}\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));
+        const decision = messages.find((m) => m.type === "decision_request");
+        assert.ok(decision);
+        assert.equal(decision?.session_id, "sess_conflict");
+        assert.ok(typeof decision?.decision_id === "string");
+        assert.equal(decision?.callback_url, undefined);
+        const state = await loadDecisionState();
+        assert.equal(state.session_id, "sess_conflict");
+        assert.equal(state.stream_url, `${apiBase}/agent/sessions/sess_conflict/events`);
+        assert.equal(state.last_event_id, "202");
+        assert.equal(state.pending_decision?.session_id, "sess_conflict");
+        assert.equal(state.pending_decision?.turn_id, "turn_2");
+        assert.deepEqual(state.pending_decision?.legal_actions, ["fold", "call", "raise"]);
+        assert.deepEqual(state.pending_decision?.action_constraints, { raise: { min_to: 300, max_to: 1500 } });
+    });
+});
+test("submit-decision uses pending decision metadata and clears pending entry", 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 calls = [];
+        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";
+            calls.push({
+                url,
+                method,
+                headers: init?.headers,
+                body: typeof init?.body === "string" ? init.body : undefined
+            });
+            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_1",
+                    stream_url: "/api/agent/sessions/sess_1/events"
+                });
+            }
+            if (url === `${apiBase}/agent/sessions/sess_1/events` && method === "GET") {
+                return sseResponse([
+                    "id: 301\nevent: message\ndata: {\"event\":\"state_snapshot\",\"data\":{\"turn_id\":\"turn_3\",",
+                    "\"my_seat\":0,\"current_actor_seat\":0,\"legal_actions\":[\"call\"]}}\n\n"
+                ]);
+            }
+            if (url === `${apiBase}/agent/sessions/sess_1/actions` && method === "POST") {
+                return jsonResponse({ accepted: true, request_id: "req_ok" });
+            }
+            throw new Error(`unexpected fetch: ${method} ${url}`);
+        });
+        try {
+            await runCLI(["next-decision", "--api-base", apiBase, "--join", "random", "--timeout-ms", "2000"]);
+            const state = await loadDecisionState();
+            const decisionID = state.pending_decision?.decision_id;
+            assert.ok(decisionID);
+            await runCLI(["submit-decision", "--api-base", apiBase, "--decision-id", decisionID, "--action", "call"]);
+        }
+        finally {
+            globalThis.fetch = originalFetch;
+            stdout.restore();
+        }
+        const actionCall = calls.find((c) => c.url === `${apiBase}/agent/sessions/sess_1/actions` && c.method === "POST");
+        assert.ok(actionCall);
+        const payload = JSON.parse(String(actionCall?.body || "{}"));
+        assert.equal(payload.turn_id, "turn_3");
+        assert.equal(payload.action, "call");
+        const finalState = await loadDecisionState();
+        assert.equal(finalState.pending_decision, undefined);
+    });
+});
+test("submit-decision blocks bet/raise without amount locally", 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 calls = [];
+        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";
+            calls.push({ url, method, headers: init?.headers, body: typeof init?.body === "string" ? init.body : undefined });
+            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_2", stream_url: "/api/agent/sessions/sess_2/events" });
+            }
+            if (url === `${apiBase}/agent/sessions/sess_2/events` && method === "GET") {
+                return sseResponse([
+                    "id: 401\nevent: message\ndata: {\"event\":\"state_snapshot\",\"data\":{\"turn_id\":\"turn_4\",",
+                    "\"my_seat\":0,\"current_actor_seat\":0,\"legal_actions\":[\"bet\"],\"action_constraints\":{\"bet\":{\"min\":100,\"max\":500}}}}\n\n"
+                ]);
+            }
+            throw new Error(`unexpected fetch: ${method} ${url}`);
+        });
+        try {
+            await runCLI(["next-decision", "--api-base", apiBase, "--join", "random", "--timeout-ms", "2000"]);
+            const state = await loadDecisionState();
+            const decisionID = state.pending_decision?.decision_id;
+            assert.ok(decisionID);
+            await assert.rejects(async () => runCLI(["submit-decision", "--api-base", apiBase, "--decision-id", decisionID, "--action", "bet"]), /amount_required_for_bet_or_raise/);
+        }
+        finally {
+            globalThis.fetch = originalFetch;
+            stdout.restore();
+        }
+        const actionCall = calls.find((c) => c.url.includes("/actions") && c.method === "POST");
+        assert.equal(actionCall, undefined);
+    });
+});
+test("submit-decision blocks out-of-range amount locally", 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 calls = [];
+        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";
+            calls.push({ url, method, headers: init?.headers, body: typeof init?.body === "string" ? init.body : undefined });
+            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_3", stream_url: "/api/agent/sessions/sess_3/events" });
+            }
+            if (url === `${apiBase}/agent/sessions/sess_3/events` && method === "GET") {
+                return sseResponse([
+                    "id: 501\nevent: message\ndata: {\"event\":\"state_snapshot\",\"data\":{\"turn_id\":\"turn_5\",",
+                    "\"my_seat\":0,\"current_actor_seat\":0,\"legal_actions\":[\"raise\"],\"action_constraints\":{\"raise\":{\"min_to\":300,\"max_to\":600}}}}\n\n"
+                ]);
+            }
+            throw new Error(`unexpected fetch: ${method} ${url}`);
+        });
+        try {
+            await runCLI(["next-decision", "--api-base", apiBase, "--join", "random", "--timeout-ms", "2000"]);
+            const state = await loadDecisionState();
+            const decisionID = state.pending_decision?.decision_id;
+            assert.ok(decisionID);
+            await assert.rejects(async () => runCLI([
+                "submit-decision",
+                "--api-base",
+                apiBase,
+                "--decision-id",
+                decisionID,
+                "--action",
+                "raise",
+                "--amount",
+                "700"
+            ]), /amount_out_of_range/);
+        }
+        finally {
+            globalThis.fetch = originalFetch;
+            stdout.restore();
+        }
+        const actionCall = calls.find((c) => c.url.includes("/actions") && c.method === "POST");
+        assert.equal(actionCall, undefined);
+    });
+});
+test("next-decision emits noop when table is closing", 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_4", stream_url: "/api/agent/sessions/sess_4/events" });
+            }
+            if (url === `${apiBase}/agent/sessions/sess_4/events` && method === "GET") {
+                return sseResponse([
+                    "id: 601\nevent: message\ndata: {\"event\":\"reconnect_grace_started\",\"data\":{\"disconnected_agent_id\":\"agent_x\",\"deadline_ts\":123}}\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, "noop");
+        assert.equal(messages[0]?.reason, "table_closing");
+    });
+});
+test("submit-decision emits table_closing and clears pending decision", 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_5", stream_url: "/api/agent/sessions/sess_5/events" });
+            }
+            if (url === `${apiBase}/agent/sessions/sess_5/events` && method === "GET") {
+                return sseResponse([
+                    "id: 701\nevent: message\ndata: {\"event\":\"state_snapshot\",\"data\":{\"turn_id\":\"turn_7\",\"my_seat\":0,\"current_actor_seat\":0,\"legal_actions\":[\"call\"]}}\n\n"
+                ]);
+            }
+            if (url === `${apiBase}/agent/sessions/sess_5/actions` && method === "POST") {
+                return jsonResponse({ error: "table_closing" }, 409);
+            }
+            throw new Error(`unexpected fetch: ${method} ${url}`);
+        });
+        try {
+            await runCLI(["next-decision", "--api-base", apiBase, "--join", "random", "--timeout-ms", "2000"]);
+            const state = await loadDecisionState();
+            const decisionID = state.pending_decision?.decision_id;
+            assert.ok(decisionID);
+            await runCLI(["submit-decision", "--api-base", apiBase, "--decision-id", decisionID, "--action", "call"]);
+        }
+        finally {
+            globalThis.fetch = originalFetch;
+            stdout.restore();
+        }
+        const messages = stdout.writes
+            .join("")
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+        const tableClosing = messages.find((m) => m.type === "table_closing");
+        assert.ok(tableClosing);
+        const finalState = await loadDecisionState();
+        assert.equal(finalState.pending_decision, undefined);
+    });
+});

package/dist/commands/register.d.ts

@@ -0,0 +1,2 @@
+import type { AgentCredential } from "../loop/credentials.js";
+export declare function buildCredentialFromRegisterResult(result: unknown, apiBase: string, fallbackName: string): Omit<AgentCredential, "updated_at"> | null;

package/dist/commands/register.js

@@ -0,0 +1,18 @@
+export function buildCredentialFromRegisterResult(result, apiBase, fallbackName) {
+    const obj = (result && typeof result === "object" ? result : null);
+    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;
+    if (!agentID || !apiKey || !agentName) {
+        return null;
+    }
+    return {
+        api_base: apiBase,
+        agent_name: agentName,
+        agent_id: agentID,
+        api_key: apiKey
+    };
+}

package/dist/commands/register.test.js

@@ -0,0 +1,26 @@
+import test from "node:test";
+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"
+    }, "http://localhost:8080/api", "FallbackBot");
+    assert.ok(out);
+    assert.equal(out?.agent_id, "agent_123");
+    assert.equal(out?.api_key, "apa_123");
+    assert.equal(out?.agent_name, "BotX");
+});
+test("buildCredentialFromRegisterResult falls back to CLI name and rejects incomplete payload", () => {
+    const fallback = buildCredentialFromRegisterResult({
+        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"
+    }, "http://localhost:8080/api", "FallbackBot");
+    assert.equal(bad, null);
+});

package/dist/commands/session_recovery.d.ts

@@ -0,0 +1,6 @@
+export type ResumableSession = {
+    session_id: string;
+    stream_url: string;
+};
+export declare function resolveStreamURL(apiBase: string, streamURL: string): string;
+export declare function recoverSessionFromConflict(err: unknown, apiBase: string): ResumableSession | null;

package/dist/commands/session_recovery.js

@@ -0,0 +1,25 @@
+export function resolveStreamURL(apiBase, streamURL) {
+    const base = apiBase.replace(/\/api\/?$/, "");
+    return streamURL.startsWith("http") ? streamURL : `${base}${streamURL}`;
+}
+export function recoverSessionFromConflict(err, apiBase) {
+    const httpErr = err;
+    if (!httpErr || httpErr.status !== 409 || httpErr.code !== "agent_already_in_session") {
+        return null;
+    }
+    const body = (httpErr.body && typeof httpErr.body === "object"
+        ? httpErr.body
+        : null);
+    if (!body) {
+        return null;
+    }
+    const sessionID = typeof body.session_id === "string" ? body.session_id : "";
+    const streamURLRaw = typeof body.stream_url === "string" ? body.stream_url : "";
+    if (!sessionID || !streamURLRaw) {
+        return null;
+    }
+    return {
+        session_id: sessionID,
+        stream_url: resolveStreamURL(apiBase, streamURLRaw)
+    };
+}

package/dist/commands/session_recovery.test.js

@@ -0,0 +1,27 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { recoverSessionFromConflict } from "./session_recovery.js";
+test("recoverSessionFromConflict returns resumable session for 409 agent_already_in_session", () => {
+    const err = {
+        status: 409,
+        code: "agent_already_in_session",
+        body: {
+            error: "agent_already_in_session",
+            session_id: "sess_1",
+            stream_url: "/api/agent/sessions/sess_1/events"
+        }
+    };
+    const recovered = recoverSessionFromConflict(err, "http://localhost:8080/api");
+    assert.ok(recovered);
+    assert.equal(recovered?.session_id, "sess_1");
+    assert.equal(recovered?.stream_url, "http://localhost:8080/api/agent/sessions/sess_1/events");
+});
+test("recoverSessionFromConflict returns null for unrelated errors", () => {
+    const err = {
+        status: 500,
+        code: "internal_error",
+        body: { error: "internal_error" }
+    };
+    const recovered = recoverSessionFromConflict(err, "http://localhost:8080/api");
+    assert.equal(recovered, null);
+});

package/dist/http/client.d.ts

@@ -1,6 +1,25 @@
 type HttpClientOptions = {
     apiBase?: string;
 };
+export type APAClientError = Error & {
+    status?: number;
+    code?: string;
+    body?: unknown;
+};
+type CreateSessionInput = {
+    agentID: string;
+    apiKey: string;
+    joinMode: "random" | "select";
+    roomID?: string;
+};
+type SubmitActionInput = {
+    sessionID: string;
+    requestID: string;
+    turnID: string;
+    action: "fold" | "check" | "call" | "raise" | "bet";
+    amount?: number;
+    thoughtLog?: string;
+};
 export declare class APAHttpClient {
     private readonly apiBase;
     constructor(opts?: HttpClientOptions);
@@ -8,7 +27,7 @@ export declare class APAHttpClient {
         name: string;
         description: string;
     }): Promise<any>;
-    getAgentStatus(apiKey: string): Promise<any>;
+    claimByCode(claimCode: string): Promise<any>;
     getAgentMe(apiKey: string): Promise<any>;
     bindKey(input: {
         apiKey: string;
@@ -16,6 +35,16 @@ export declare class APAHttpClient {
         vendorKey: string;
         budgetUsd: number;
     }): Promise<any>;
+    listPublicRooms(): Promise<{
+        items: Array<{
+            id: string;
+            min_buyin_cc: number;
+            name: string;
+        }>;
+    }>;
+    createSession(input: CreateSessionInput): Promise<any>;
+    submitAction(input: SubmitActionInput): Promise<any>;
+    closeSession(sessionID: string): Promise<void>;
     healthz(): Promise<any>;
 }
 export {};