SPLIT UP: agentic loop test

[NathanFlurry]

Description

Please include a summary of the changes and the related issue. Please also include relevant motivation and context.

Type of change

• Bug fix (non-breaking change which fixes an issue)
• New feature (non-breaking change which adds functionality)
• Breaking change (fix or feature that would cause existing functionality to not work as expected)
• This change requires a documentation update

How Has This Been Tested?

Please describe the tests that you ran to verify your changes.

Checklist:

• My code follows the style guidelines of this project
• I have performed a self-review of my code
• I have commented my code, particularly in hard-to-understand areas
• I have made corresponding changes to the documentation
• My changes generate no new warnings
• I have added tests that prove my fix is effective or that my feature works
• New and existing unit tests pass locally with my changes

[NathanFlurry]

Warning

This pull request is not mergeable via GitHub because a downstack PR is open. Once all requirements are satisfied, merge this PR as a stack on Graphite.
Learn more

• chore(rivetkit): note duplicate admission logic #4948
• test(rivetkit): cover bypass fetch header forwarding #4947
• feat(kitchen-sink): add actor probe controls #4946
• fix(gateway): split actor response wait errors #4945
• fix(guard): handle bypass preflight before query parse #4944
• feat(kitchen-sink): add mock agent event log copy #4943
• fix(kitchen-sink): default mock agent to local endpoint #4942
• test(rivetkit): enable driver lifecycle regressions #4941
• test(rivetkit): verify cached websocket db refs exceed grace #4940
• fix(rivetkit-core): keep sleeping actors reachable during grace #4939
• test(rivetkit): cover async websocket close db access #4938
• fix(rivetkit): keep actors awake until keepAwake work finishes #4937
• fix(rivetkit): persist native onSleep state on errors #4936
• fix(rivetkit-core): allow dispatch during sleep grace #4935
• fix(rivetkit): make duplicate sleep requests idempotent #4934
• fix(rivetkit): align logs with engine logfmt #4933
• fix(ci): standardize publish rust toolchain #4931
• SPLIT UP: agentic loop test #4932 👈 (View in Graphite)
• chore(rivetkit): doc skip ready wait #4927
• fix(guard): parse gateway bypass query booleans #4926
• feat(depot-client): add vfs staging cache ttl #4930
• feat(depot-client): wire sqlite optimization flags #4923
• feat(rivetkit): support gateway bypass client overrides #4928
• test(depot-client): stabilize fault harness #4924
• chore(depot-client): split sqlite vfs transports #4922
• feat(rivetkit): support gateway bypass probes #4915
• feat(kitchen-sink): add mock agentic lifecycle loop #4914
• feat(kitchen-sink): add mock agentic loop #4891
• feat(rivetkit): support gateway bypass client requests #4917
• fix(pegboard): restore hibernating request ids #4898 : 2 other dependent PRs (#4899 , #4916 )
• chore(guard): configure local timeout knobs #4913
• docs(rivetkit): raise serverless start payload limit #4911
• test(kitchen-sink): add sqlite memory soak harness #4910
• feat(rivetkit): expose runtime diagnostics #4909
• chore(depot-client): migrate to worker thread #4907 : 2 other dependent PRs (#4912 , #4918 )
• test(driver): select matrix cells with vitest filters #4906
• fix(pegboard): restore hibernating requests on serverful start #4904 : 1 other dependent PR (#4905 )
• fix(rivetkit): drain shutdown work before sleep #4902 : 1 other dependent PR (#4903 )
• feat(sqlite): wire remote sqlite execute handlers #4897
• test(serverless): avoid pinning header validation order #4896
• chore(driver-test-runner): add native/wasm runtime matrix to skill #4884 : 3 other dependent PRs (#4892 , #4894 , #4901 )
• chroe: rename rivetkit-sqlite to depot-client #4883
• fix(rivetkit-wasm): fix mem leaks #4880
• chore(rivetkit): wasm support #4860
• feat(sqlite): add cold read benchmarks and simplify optimizations #4857
• feat(sqlite): benchmark cold reads #4848 : 1 other dependent PR (#4864 )
• docs(actors): document manual lifecycle controls #4847
• test(sqlite): expand db stress coverage #4846 : 1 other dependent PR (#4849 )
• test(raw-websocket): add serverless smoke coverage #4845
• feat(serverless): configure drain grace period #4844
• fix(publish): enable frontend build for engine target and use turbo build instead of turbo build:engine #4843
• feat(rivetkit): expose conn handle in onWebSocket context #4842
• fix(rivetkit): normalize waitUntil/keepAwake promises to null to avoid serde undefined error #4841
• fix(rivetkit): remove requirement for token #4839 : 1 other dependent PR (#4840 )
• fix(pegboard-envoy): allow sqlite requests across lifecycle states #4838
• fix(pegboard): route scoped actor key reads by runner dc #4837
• fix(sqlite-storage): let sqlite open take over stale owners #4834
• fix(engine-tests): parallelize multi-DC startup + enable 6 multi-DC tests #4833
• fix(api): honor cursor in actor_ids list path #4832
• fix(api): silently filter invalid IDs from actor_ids query instead of 400 #4831
• fix(api-peer): make actors_delete idempotent for already-destroyed actors #4830
• fix(pegboard): use Iterator streaming mode in list_names so limit param is honored #4829
• chore(engine-tests): convert envoy tests to Sleep crash policy + triage ignored #4828
• feat(engine-tests): wire envoy actor names through prepopulate_actor_names #4827
• chore(depot): fault injection tests #4868
• feat(sqlite): pitr & forking #4859 : 1 other dependent PR (#4863 )
• chore(sqlite): stateless storage refactor #4856
• main

This stack of pull requests is managed by Graphite. Learn more about stacking.

[claude]

PR #4932 Review: SPLIT UP — Agentic Loop Test

Note: This PR is closed. Review provided for reference.

Overview

This PR adds a browser-based interactive test panel for the mockAgenticLoop actor alongside significant enhancements to the actor itself and the serverless pool configuration path. The main changes are:

1. New MockAgenticLoopPanel UI — a manual test harness in examples/kitchen-sink for exercising streaming, SQLite durability, forced sleep, reconnects, and gateway bypass.
2. mock-agentic-loop actor enhancements — debug event recording/replay, sleep state tracking via SQLite, per-connection debug socket broadcasts, and sleepStarted/sleepStartedAt in bypass and pong responses.
3. configureServerlessPool retry loop — replaces a single fire-and-forget with a configurable retry loop that throws after timeout.
4. Registry handleRequest refactor — pool configuration is now deferred to start/metadata requests only, with engine-internal metadata requests bypassing the check.

---

Issues and Observations

Bug: bypassConnectable vs skipReadyWait naming inconsistency

The script (scripts/mock-agentic-loop.ts) renames the gateway option from bypassConnectable to skipReadyWait, but the new frontend panel (App.tsx) still defines and uses bypassConnectable in its AgenticHandle type and call sites:

// App.tsx — uses old name
gateway?: { bypassConnectable?: boolean };
await handle.fetch("/bypass", { gateway: { bypassConnectable: true } });

// scripts/mock-agentic-loop.ts — uses new name
gateway?: { skipReadyWait?: boolean };
handle.webSocket("/bypass", undefined, { gateway: { skipReadyWait: true } });

One of these is wrong. If the underlying client SDK was updated to skipReadyWait, the frontend panel bypass buttons will silently send the wrong option and never actually bypass.

Bug risk: race condition in connect's isConnecting guard

connect uses React state (isConnecting) as a mutex:

const connect = useCallback(async (countReconnect = false) => {
    if (isConnecting) return;  // state read, not ref
    setIsConnecting(true);
    ...
}, [..., isConnecting, ...]);

State updates are async in React. If the user clicks Connect while a 500 ms auto-reconnect timer is pending, both calls can read isConnecting === false before either setIsConnecting(true) takes effect, producing two concurrent connection attempts. A useRef flag (checked and set synchronously) would be a reliable guard here.

Indentation issue in validateAgenticRows

return {
    ok: problems.length === 0,
    problems,
        expectedRows: expectedRequests.reduce(   // over-indented
            (total, request) => total + request.seconds,
            0,
        ) + (activeRequest?.received.length ?? 0),
    };
}

expectedRows is indented to the same level as the inner reduce args, not the sibling fields.

Fragile User-Agent check for engine metadata bypass

const isEngineMetadataRequest =
    request.headers.get("user-agent")?.startsWith("RivetEngine/") ?? false;

Any client that sends User-Agent: RivetEngine/... bypasses the pool-configuration wait on metadata requests. Per CLAUDE.md the client <-> engine boundary is untrusted; if this endpoint is reachable by external clients this check is insufficient. At minimum this warrants a comment explaining the trust assumption (e.g. that the metadata path is only reachable on an internal network).

configureTimeoutMs(0) silently skips all retries

while (Date.now() - startedAt <= timeoutMs) { ... }

A value of 0 causes Date.now() - startedAt to immediately exceed the timeout (even >= 0 is borderline). The function would exit the loop without attempting any configuration and throw lastError (which is undefined at that point). Consider validating >= 1000 or documenting the edge case, and guarding throw lastError for the undefined case.

publicToken used for runner config update

const serverlessToken = config.token ?? config.publicToken;
await updateRunnerConfig(clientConfig, poolName, { ... });

updateRunnerConfig is an engine admin endpoint. Using a public token (which may have read-only or end-user scope) where a service/admin token is expected will fail silently or with a permission error at runtime. The fallback chain should be documented or validated against what updateRunnerConfig actually requires.

Minor: debugSocketsByActorId is process-global state in the actor module

const debugSocketsByActorId = new Map<string, Set<UniversalWebSocket>>();

This is fine for a test actor, but note that it leaks across actor restarts and will accumulate closed sockets if removeDebugSocket cleanup ever fails (e.g. if the "close" event fires before addDebugSocket returns). The cleanup path looks correct in normal flow, but worth a note for future maintainers.

Minor: onSocketMessage has no handler for "pong" or "verified" types

The main WebSocket onSocketMessage switch handles hello, history, debugEvent, started, progress, done, error — but not pong or verified. These arrive on bypass WebSockets, so the main socket shouldn't receive them. The silent drop is correct, but given the CLAUDE.md guideline against _ => fall-throughs, consider using a discriminated union exhaustion check or at least a comment.

---

What's Working Well

• The retry loop in configureServerlessPool is a clear improvement — the old code swallowed errors silently; the new code propagates failures and makes retry behavior observable via logs.
• #ensureServerlessPoolConfigured correctly deduplicates concurrent pool setup calls and resets on failure so the next request can retry.
• The debug event replay pattern (replay on connect, then stream live events) is solid and covers the reconnect case cleanly.
• Deferring pool configuration to start/metadata requests is the right call — it avoids blocking health checks and non-actor traffic.
• CSS is complete with responsive breakpoints.

[NathanFlurry]

Landed in main via stack-merge fast-forward push. Commits are in main; closing to match.