hanzi-browse 2.2.0

package/dist/managed/deploy.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * Combined Managed Backend + Relay Server
+ *
+ * Single process for cloud deployment. Runs:
+ * 1. WebSocket relay (for extension communication)
+ * 2. Managed REST API (for client integration)
+ * 3. Vertex AI LLM client
+ *
+ * Environment variables:
+ *   VERTEX_SA_JSON  - Service account JSON string (for cloud deployment)
+ *   VERTEX_SA_PATH  - Path to service account JSON file (for local)
+ *   PORT            - HTTP/WS port (default: 3456, Railway sets this)
+ *   RELAY_PORT      - Internal relay port (default: 7862)
+ */
+/** Check if a browser session is connected */
+export declare function isSessionConnected(browserSessionId: string): boolean;

package/dist/managed/deploy.js

@@ -0,0 +1,385 @@
+#!/usr/bin/env node
+/**
+ * Combined Managed Backend + Relay Server
+ *
+ * Single process for cloud deployment. Runs:
+ * 1. WebSocket relay (for extension communication)
+ * 2. Managed REST API (for client integration)
+ * 3. Vertex AI LLM client
+ *
+ * Environment variables:
+ *   VERTEX_SA_JSON  - Service account JSON string (for cloud deployment)
+ *   VERTEX_SA_PATH  - Path to service account JSON file (for local)
+ *   PORT            - HTTP/WS port (default: 3456, Railway sets this)
+ *   RELAY_PORT      - Internal relay port (default: 7862)
+ */
+import { WebSocketServer, WebSocket } from "ws";
+import { randomUUID } from "crypto";
+import { initVertex } from "../llm/vertex.js";
+import { startManagedAPI, initManagedAPI, handleRelayMessage, setStoreModule, onSessionDisconnected, shutdownManagedAPI, recoverStuckTasks } from "./api.js";
+import { initBilling, setBillingStore } from "./billing.js";
+import { WebSocketClient } from "../ipc/websocket-client.js";
+// Dynamic store import — Postgres when DATABASE_URL is set, file-based otherwise
+const DATABASE_URL = process.env.DATABASE_URL;
+let store;
+if (DATABASE_URL) {
+    const pgStore = await import("./store-pg.js");
+    pgStore.initPgStore(DATABASE_URL);
+    store = pgStore;
+    setStoreModule(store); // Also swap the API's store
+    console.error("[Server] Using Postgres store");
+}
+else {
+    store = await import("./store.js");
+    console.error("[Server] Using file-based store");
+}
+// --- Config ---
+const PORT = parseInt(process.env.PORT || "3456", 10);
+const RELAY_PORT = parseInt(process.env.RELAY_PORT || "7862", 10);
+// Shared secret between the managed backend and the relay.
+// Only clients registering with this secret can route to managed sessions.
+import { randomBytes, timingSafeEqual } from "crypto";
+const RELAY_INTERNAL_SECRET = process.env.RELAY_SECRET || randomBytes(32).toString("hex");
+if (!process.env.RELAY_SECRET && process.env.NODE_ENV === "production") {
+    console.error("[Server] WARNING: RELAY_SECRET not set — generated a random secret. Set RELAY_SECRET env var for stable deployments.");
+}
+const relayClients = new Map();
+const extensionQueue = [];
+// --- Managed session routing ---
+/** Find the relay client for a specific browser session */
+function getSessionClient(browserSessionId) {
+    for (const c of relayClients.values()) {
+        if (c.browserSessionId === browserSessionId && c.ws.readyState === WebSocket.OPEN) {
+            return c;
+        }
+    }
+    return null;
+}
+/** Check if a browser session is connected */
+export function isSessionConnected(browserSessionId) {
+    return getSessionClient(browserSessionId) !== null;
+}
+// --- Legacy BYOM routing ---
+function getLegacyExtension() {
+    for (const c of relayClients.values()) {
+        if (c.role === "extension" && !c.browserSessionId)
+            return c;
+    }
+    return null;
+}
+// --- Relay Limits ---
+const RELAY_MAX_MESSAGE_BYTES = 5 * 1024 * 1024; // 5 MB max message (screenshots can be large)
+const RELAY_MAX_CONNECTIONS = 100; // max simultaneous WebSocket connections
+function startRelay() {
+    // In production, bind to loopback — Caddy reverse-proxies from the internet.
+    // Set RELAY_HOST=0.0.0.0 for local dev without a reverse proxy.
+    const RELAY_HOST = process.env.RELAY_HOST || (process.env.NODE_ENV === "production" ? "127.0.0.1" : "0.0.0.0");
+    const wss = new WebSocketServer({
+        port: RELAY_PORT,
+        host: RELAY_HOST,
+        maxPayload: RELAY_MAX_MESSAGE_BYTES,
+    });
+    wss.on("listening", () => {
+        console.error(`[Relay] Listening on ws://${RELAY_HOST}:${RELAY_PORT} (max ${RELAY_MAX_CONNECTIONS} connections, max ${RELAY_MAX_MESSAGE_BYTES / 1024 / 1024}MB/msg)`);
+    });
+    wss.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+            console.error(`[Relay] Port ${RELAY_PORT} in use — relay already running`);
+            return;
+        }
+        console.error(`[Relay] Error: ${err.message}`);
+    });
+    wss.on("connection", (ws) => {
+        // Enforce max connections
+        if (wss.clients.size > RELAY_MAX_CONNECTIONS) {
+            ws.close(1013, "Server too busy — max connections reached");
+            console.error(`[Relay] Rejected connection: max ${RELAY_MAX_CONNECTIONS} connections exceeded`);
+            return;
+        }
+        ws.on("message", async (data) => {
+            try {
+                const msg = JSON.parse(data.toString());
+                // --- Registration ---
+                if (msg.type === "register") {
+                    // Check for managed session token auth
+                    if (msg.session_token) {
+                        const session = await store.validateSessionToken(msg.session_token);
+                        if (!session) {
+                            ws.send(JSON.stringify({ type: "error", error: "Invalid session token" }));
+                            ws.close();
+                            return;
+                        }
+                        const client = {
+                            ws,
+                            role: "extension",
+                            clientId: randomUUID(),
+                            browserSessionId: session.id,
+                            isInternalBackend: false,
+                        };
+                        relayClients.set(ws, client);
+                        store.heartbeatSession(session.id);
+                        ws.send(JSON.stringify({
+                            type: "registered",
+                            clientId: client.clientId,
+                            role: "extension",
+                            browserSessionId: session.id,
+                        }));
+                        console.error(`[Relay] Managed session registered: ${session.id}`);
+                        return;
+                    }
+                    // Check relay_secret for internal backend auth
+                    let isInternal = false;
+                    if (typeof msg.relay_secret === "string" && msg.relay_secret.length === RELAY_INTERNAL_SECRET.length) {
+                        try {
+                            isInternal = timingSafeEqual(Buffer.from(msg.relay_secret), Buffer.from(RELAY_INTERNAL_SECRET));
+                        }
+                        catch {
+                            isInternal = false;
+                        }
+                    }
+                    // In production, reject unauthenticated legacy registrations.
+                    // Only the internal backend (with relay_secret) and managed sessions (with session_token) can connect.
+                    if (process.env.NODE_ENV === "production" && !isInternal) {
+                        ws.send(JSON.stringify({ type: "error", error: "Legacy relay mode disabled in production. Use session_token auth." }));
+                        ws.close();
+                        return;
+                    }
+                    const client = {
+                        ws,
+                        role: msg.role || "cli",
+                        clientId: randomUUID(),
+                        isInternalBackend: isInternal,
+                    };
+                    relayClients.set(ws, client);
+                    ws.send(JSON.stringify({ type: "registered", clientId: client.clientId, role: client.role }));
+                    console.error(`[Relay] ${isInternal ? "Internal backend" : "Legacy"} registered: ${client.role} (${client.clientId})`);
+                    // Flush queue to legacy extension
+                    if (client.role === "extension" && extensionQueue.length > 0) {
+                        for (const queued of extensionQueue) {
+                            ws.send(queued);
+                        }
+                        extensionQueue.length = 0;
+                    }
+                    return;
+                }
+                // Ping/pong — client-initiated heartbeat
+                if (msg.type === "ping") {
+                    // Heartbeat for managed sessions — enforces expiry/revocation
+                    const sender = relayClients.get(ws);
+                    if (sender?.browserSessionId) {
+                        const valid = await store.heartbeatSession(sender.browserSessionId);
+                        if (!valid) {
+                            ws.send(JSON.stringify({ type: "error", error: "Session expired or revoked" }));
+                            ws.close();
+                            return;
+                        }
+                    }
+                    // No token rotation here — rotation is driven solely by the server-initiated
+                    // keepalive pings (below) to avoid double-rotation races.
+                    ws.send(JSON.stringify({ type: "pong" }));
+                    return;
+                }
+                const sender = relayClients.get(ws);
+                if (!sender)
+                    return;
+                // --- Managed routing: route by targetSessionId ---
+                // SECURITY: Only the internal managed backend (authenticated with relay_secret)
+                // can route to managed sessions. Self-declared roles are NOT trusted.
+                if (msg.targetSessionId) {
+                    if (!sender.isInternalBackend) {
+                        ws.send(JSON.stringify({
+                            type: "error",
+                            requestId: msg.requestId,
+                            error: "Unauthorized: only the managed backend can route to browser sessions",
+                        }));
+                        return;
+                    }
+                    const target = getSessionClient(msg.targetSessionId);
+                    if (target) {
+                        msg.sourceClientId = sender.clientId;
+                        target.ws.send(JSON.stringify(msg));
+                    }
+                    else {
+                        ws.send(JSON.stringify({
+                            type: "tool_result",
+                            requestId: msg.requestId,
+                            error: `Browser session ${msg.targetSessionId} is not connected`,
+                        }));
+                    }
+                    return;
+                }
+                // --- Legacy routing (BYOM Local) ---
+                if (sender.role === "extension" || sender.browserSessionId) {
+                    // Extension → route to specific MCP/CLI client or broadcast
+                    const targetId = msg.sourceClientId;
+                    if (targetId) {
+                        for (const c of relayClients.values()) {
+                            if (c.clientId === targetId && c.ws.readyState === WebSocket.OPEN) {
+                                c.ws.send(JSON.stringify(msg));
+                                return;
+                            }
+                        }
+                    }
+                    for (const c of relayClients.values()) {
+                        if (c.role !== "extension" && !c.browserSessionId && c.ws.readyState === WebSocket.OPEN) {
+                            c.ws.send(JSON.stringify(msg));
+                        }
+                    }
+                }
+                else {
+                    // MCP/CLI → route to legacy extension
+                    const ext = getLegacyExtension();
+                    if (ext && ext.ws.readyState === WebSocket.OPEN) {
+                        msg.sourceClientId = sender.clientId;
+                        ext.ws.send(JSON.stringify(msg));
+                    }
+                    else {
+                        extensionQueue.push(JSON.stringify(msg));
+                        if (extensionQueue.length > 50)
+                            extensionQueue.shift();
+                    }
+                }
+            }
+            catch (e) {
+                console.error("[Relay] Parse error:", e);
+            }
+        });
+        ws.on("close", () => {
+            const client = relayClients.get(ws);
+            if (client) {
+                if (client.browserSessionId) {
+                    store.disconnectSession(client.browserSessionId);
+                    // Immediately fail any pending tool executions for this session
+                    // so the agent loop doesn't wait for timeout on each one.
+                    onSessionDisconnected(client.browserSessionId);
+                    console.error(`[Relay] Managed session disconnected: ${client.browserSessionId}`);
+                }
+                else {
+                    console.error(`[Relay] Legacy disconnected: ${client.role}`);
+                }
+                relayClients.delete(ws);
+            }
+        });
+    });
+    // Keepalive pings to extensions — keeps Chrome MV3 service workers alive
+    // (they sleep after ~30s of inactivity, dropping the WebSocket).
+    // Also drives heartbeat and token rotation for managed sessions.
+    setInterval(async () => {
+        for (const [ws, client] of relayClients) {
+            if (client.role !== "extension" || ws.readyState !== WebSocket.OPEN)
+                continue;
+            const pingPayload = { type: "ping" };
+            if (client.browserSessionId) {
+                // Heartbeat + expiry check
+                const valid = await store.heartbeatSession(client.browserSessionId);
+                if (!valid) {
+                    ws.send(JSON.stringify({ type: "error", error: "Session expired or revoked" }));
+                    ws.close();
+                    continue;
+                }
+                // Token rotation: every ~10 minutes (every 30th ping at 20s intervals)
+                client._heartbeatCount = (client._heartbeatCount || 0) + 1;
+                if (client._heartbeatCount % 30 === 0) {
+                    const newToken = await store.rotateSessionToken(client.browserSessionId);
+                    if (newToken) {
+                        pingPayload.new_session_token = newToken;
+                        console.error(`[Relay] Rotated token for session ${client.browserSessionId}`);
+                    }
+                }
+            }
+            ws.send(JSON.stringify(pingPayload));
+        }
+    }, 20_000);
+}
+// --- Main ---
+async function main() {
+    // 1. Init Vertex AI (optional — managed task execution disabled without it)
+    const saJson = process.env.VERTEX_SA_JSON;
+    const saPath = process.env.VERTEX_SA_PATH;
+    if (saJson) {
+        initVertex(JSON.parse(saJson));
+    }
+    else if (saPath) {
+        try {
+            initVertex(saPath);
+        }
+        catch (err) {
+            console.error(`[Server] Vertex AI disabled: ${err.message}`);
+            console.error("[Server] Managed task execution won't work. Set VERTEX_SA_PATH to enable it.");
+        }
+    }
+    else {
+        console.error("[Server] Vertex AI not configured (no VERTEX_SA_PATH or VERTEX_SA_JSON).");
+        console.error("[Server] BYOM + dashboard + API work fine. Managed task execution disabled.");
+    }
+    // 2. Bootstrap workspace + API key
+    // In production, warn that auto-bootstrap is a convenience, not long-term behavior.
+    const { workspace, apiKey } = await store.ensureDefaultWorkspace();
+    const keyDisplay = apiKey.key.startsWith("hic_live_") ? apiKey.key.slice(0, 20) + "..." : "(existing)";
+    if (process.env.NODE_ENV === "production") {
+        console.error(`[Server] WARNING: Auto-bootstrapped default workspace. Use explicit workspace provisioning for multi-tenant.`);
+    }
+    console.error(`[Server] Workspace: ${workspace.id}, API key: ${keyDisplay}`);
+    // 3. Start relay
+    startRelay();
+    // 4. Connect to relay as internal client
+    await new Promise((r) => setTimeout(r, 500)); // Let relay start
+    const relay = new WebSocketClient({
+        role: "mcp",
+        relayUrl: `ws://127.0.0.1:${RELAY_PORT}`,
+        autoStartRelay: false,
+        registerExtra: { relay_secret: RELAY_INTERNAL_SECRET },
+    });
+    relay.onMessage((message) => {
+        if (handleRelayMessage(message))
+            return;
+        if (message?.type === "pong" || message?.type === "registered")
+            return;
+    });
+    // Connect with timeout — if relay fails to start, exit instead of hanging forever
+    const connectTimeout = setTimeout(() => {
+        console.error("[Server] FATAL: Relay connection timed out after 10s");
+        process.exit(1);
+    }, 10_000);
+    await relay.connect();
+    clearTimeout(connectTimeout);
+    // 5. Init billing (optional — works without Stripe credentials)
+    initBilling();
+    setBillingStore(store);
+    // 6. Start API — pass session connectivity checker
+    initManagedAPI(relay, isSessionConnected);
+    startManagedAPI(PORT);
+    store.startHeartbeatFlush();
+    // 7. Recover tasks stuck in "running" from a previous process
+    await recoverStuckTasks();
+    console.error(`
+╔════════════════════════════════════════════════╗
+║  Hanzi Managed Backend (deployed)              ║
+║                                                ║
+║  API:     http://${process.env.NODE_ENV === "production" ? "127.0.0.1" : "0.0.0.0"}:${String(PORT).padEnd(5)}              ║
+║  Relay:   ws://${process.env.NODE_ENV === "production" ? "127.0.0.1" : "0.0.0.0"}:${String(RELAY_PORT).padEnd(5)}               ║
+║  LLM:     Vertex AI (Gemini 2.5 Flash)         ║
+║  Key:     ${keyDisplay.padEnd(33)} ║
+╚════════════════════════════════════════════════╝
+`);
+}
+main().catch((err) => {
+    console.error("[Server] Fatal:", err);
+    process.exit(1);
+});
+// --- Graceful Shutdown ---
+// On SIGTERM/SIGINT, abort running tasks with clean status updates
+// before the process exits. Without this, tasks stay in "running" state
+// permanently in the database.
+async function handleShutdown(signal) {
+    console.error(`\n[Server] Received ${signal} — shutting down gracefully...`);
+    try {
+        await shutdownManagedAPI();
+    }
+    catch (err) {
+        console.error(`[Server] Shutdown error:`, err.message);
+    }
+    process.exit(0);
+}
+process.on("SIGTERM", () => handleShutdown("SIGTERM"));
+process.on("SIGINT", () => handleShutdown("SIGINT"));

package/dist/managed/e2e.test.d.ts

@@ -0,0 +1,15 @@
+/**
+ * End-to-end managed task test.
+ *
+ * Tests the full partner flow with a mock-connected session:
+ *   1. Create API key
+ *   2. Create pairing token with metadata
+ *   3. Register session
+ *   4. Task creation succeeds (session reports as connected)
+ *   5. Task enters "running" state
+ *
+ * Limitation: cannot test actual agent loop execution (needs LLM + extension).
+ * But this proves the full auth → pairing → session → task creation pipeline
+ * with a connected session, which is the gap the other tests don't cover.
+ */
+export {};

package/dist/managed/e2e.test.js

@@ -0,0 +1,151 @@
+/**
+ * End-to-end managed task test.
+ *
+ * Tests the full partner flow with a mock-connected session:
+ *   1. Create API key
+ *   2. Create pairing token with metadata
+ *   3. Register session
+ *   4. Task creation succeeds (session reports as connected)
+ *   5. Task enters "running" state
+ *
+ * Limitation: cannot test actual agent loop execution (needs LLM + extension).
+ * But this proves the full auth → pairing → session → task creation pipeline
+ * with a connected session, which is the gap the other tests don't cover.
+ */
+import { initVertex } from "../llm/vertex.js";
+import { startManagedAPI, initManagedAPI } from "./api.js";
+import { createWorkspace, createApiKey, consumePairingToken, createPairingToken } from "./store.js";
+const PORT = 4569;
+const BASE = `http://localhost:${PORT}`;
+// Track which sessions should report as "connected"
+const connectedSessions = new Set();
+const mockRelay = {
+    send: () => { },
+    onMessage: () => { },
+    connect: async () => { },
+    isConnected: () => true,
+};
+let testKey;
+let testWorkspaceId;
+async function setup() {
+    try {
+        initVertex("/tmp/hanzi-vertex-sa.json");
+    }
+    catch { }
+    const ws = createWorkspace("E2E Test Workspace");
+    testWorkspaceId = ws.id;
+    const key = createApiKey(ws.id, "e2e-key");
+    testKey = key.key;
+    // Pass a session connectivity checker that uses our connectedSessions set
+    initManagedAPI(mockRelay, (id) => connectedSessions.has(id));
+    startManagedAPI(PORT);
+    await new Promise((r) => setTimeout(r, 500));
+}
+async function req(method, path, body, apiKey) {
+    const headers = { "Content-Type": "application/json" };
+    if (apiKey)
+        headers["Authorization"] = `Bearer ${apiKey}`;
+    const res = await fetch(`${BASE}${path}`, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    const data = await res.json().catch(() => null);
+    return { status: res.status, data, headers: res.headers };
+}
+function assert(condition, msg) {
+    if (!condition)
+        throw new Error(`FAIL: ${msg}`);
+    console.log(`  ✓ ${msg}`);
+}
+async function testFullPartnerFlow() {
+    console.log("\n--- Full partner flow (connected session) ---");
+    // 1. Create pairing token with metadata
+    const { status: s1, data: d1 } = await req("POST", "/v1/browser-sessions/pair", {
+        label: "E2E test browser",
+        external_user_id: "e2e-user-001",
+    }, testKey);
+    assert(s1 === 201, "Pairing token created");
+    assert(d1.pairing_token.startsWith("hic_pair_"), "Token has correct prefix");
+    // 2. Register session (simulates extension pairing)
+    const { status: s2, data: d2 } = await req("POST", "/v1/browser-sessions/register", {
+        pairing_token: d1.pairing_token,
+    });
+    assert(s2 === 201, "Session registered");
+    const sessionId = d2.browser_session_id;
+    assert(!!sessionId, "Got session ID");
+    // 3. Mark session as connected (simulates relay registering the extension)
+    connectedSessions.add(sessionId);
+    // 4. Verify session shows as connected
+    const { data: d3 } = await req("GET", "/v1/browser-sessions", undefined, testKey);
+    const session = d3.sessions.find((s) => s.id === sessionId);
+    assert(!!session, "Session in list");
+    assert(session.status === "connected", "Session reports connected");
+    assert(session.label === "E2E test browser", "Label present");
+    assert(session.external_user_id === "e2e-user-001", "external_user_id present");
+    // 5. Create a task — this should succeed (session is connected)
+    const { status: s4, data: d4, headers: h4 } = await req("POST", "/v1/tasks", {
+        task: "Read the title of the current page",
+        browser_session_id: sessionId,
+    }, testKey);
+    assert(s4 === 201, "Task created successfully (session is connected)");
+    assert(d4.status === "running", "Task status is running");
+    assert(d4.id, "Task has an ID");
+    assert(!!h4.get("x-request-id"), "Response has X-Request-Id");
+    const taskId = d4.id;
+    // 6. Task appears in list
+    const { data: d5 } = await req("GET", "/v1/tasks", undefined, testKey);
+    const task = d5.tasks.find((t) => t.id === taskId);
+    assert(!!task, "Task appears in list");
+    // 7. Task is retrievable by ID
+    const { status: s6, data: d6 } = await req("GET", `/v1/tasks/${taskId}`, undefined, testKey);
+    assert(s6 === 200, "Task retrievable by ID");
+    assert(d6.browser_session_id === sessionId, "Task bound to correct session");
+    // 8. Cancel the task (since no real relay/LLM, it would hang otherwise)
+    const { status: s7 } = await req("POST", `/v1/tasks/${taskId}/cancel`, {}, testKey);
+    assert(s7 === 200, "Task cancelled");
+    // 9. Verify cancelled state
+    const { data: d8 } = await req("GET", `/v1/tasks/${taskId}`, undefined, testKey);
+    assert(d8.status === "cancelled", "Task shows cancelled status");
+    // 10. Usage endpoint works
+    const { status: s9, data: d9 } = await req("GET", "/v1/usage", undefined, testKey);
+    assert(s9 === 200, "Usage endpoint returns 200");
+    assert(typeof d9.totalInputTokens === "number", "Usage has token count");
+    // Clean up
+    connectedSessions.delete(sessionId);
+}
+async function testConnectedVsDisconnectedBehavior() {
+    console.log("\n--- Connected vs disconnected session behavior ---");
+    // Create a session
+    const pt = createPairingToken(testWorkspaceId, "test");
+    const session = consumePairingToken(pt._plainToken);
+    // Disconnected: task creation should fail
+    const { status: s1 } = await req("POST", "/v1/tasks", {
+        task: "test",
+        browser_session_id: session.id,
+    }, testKey);
+    assert(s1 === 409, "Disconnected session → 409");
+    // Connect
+    connectedSessions.add(session.id);
+    // Connected: task creation should succeed
+    const { status: s2, data: d2 } = await req("POST", "/v1/tasks", {
+        task: "test",
+        browser_session_id: session.id,
+    }, testKey);
+    assert(s2 === 201, "Connected session → 201");
+    // Cancel to clean up
+    await req("POST", `/v1/tasks/${d2.id}/cancel`, {}, testKey);
+    connectedSessions.delete(session.id);
+}
+async function runAll() {
+    await setup();
+    console.log("=== E2E Managed Task Tests ===");
+    await testFullPartnerFlow();
+    await testConnectedVsDisconnectedBehavior();
+    console.log("\n=== All E2E tests passed ===\n");
+    process.exit(0);
+}
+runAll().catch((err) => {
+    console.error("\n❌ E2E TEST FAILED:", err.message);
+    process.exit(1);
+});

package/dist/managed/hardening.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Hardening Tests — Slice 1
+ *
+ * Covers the new reliability fixes:
+ * 1. Agent loop tool name validation
+ * 2. Request body size limits
+ * 3. Input validation (task, context, URL length)
+ * 4. Task execution timeout
+ * 5. Usage recording ordering (before task completion)
+ * 6. Session expiry enforcement at task creation
+ * 7. Model attribution in agent loop result
+ * 8. Vertex service account validation
+ */
+export {};