Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

Extract server session affinity into module

Raine Virtaaf87d4e13a47
diff --git a/src/server.test.ts b/src/server.test.ts
index 8da0f46..b3e0e39 100644
--- a/src/server.test.ts
+++ b/src/server.test.ts
@@ -4,12 +4,14 @@ import type { createLogger } from "./log.ts";
import { startServer, normalizeIncomingModel, wrapStreamResponse } from "./server.ts";
import { groupSupportedModelsByProvider } from "./providers/registry.ts";
import { startTestServer } from "./test/server.ts";
+import { resetSessionsForTest } from "./server/session-affinity.ts";
const servers: Array<{ stop: () => void }> = [];
afterEach(() => {
for (const server of servers.splice(0)) server.stop();
loadConfig({ forceReload: true });
+ resetSessionsForTest();
});
function countTokens(port: number, model: string, sessionId?: string): Promise<Response> {
diff --git a/src/server.ts b/src/server.ts
index 8b61671..f547fe8 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -6,11 +6,15 @@ import type { AnthropicRequest } from "./anthropic/schema.ts";
import type { AliasProvider } from "./config.ts";
import type { Provider, RequestContext } from "./providers/types.ts";
import {
- ANTHROPIC_STYLE_ALIASES,
groupSupportedModelsByProvider,
normalizeIncomingModel,
providerForModel,
} from "./providers/registry.ts";
+import {
+ existingSession,
+ recordSessionRequest,
+ type SessionState,
+} from "./server/session-affinity.ts";
export { normalizeIncomingModel };
@@ -20,61 +24,6 @@ export interface ServeOptions {
port: number;
}
-interface SessionState {
- seq: number;
- affinityProvider?: AliasProvider;
- lastSeen: number;
-}
-
-const SESSION_IDLE_TTL_MS = 30 * 60 * 1000;
-const MAX_SESSIONS = 10_000;
-const sessions = new Map<string, SessionState>();
-
-function existingSession(
- sessionId: string | undefined,
- now = Date.now(),
-): SessionState | undefined {
- if (!sessionId) return undefined;
- const state = sessions.get(sessionId);
- if (!state) return undefined;
- if (now - state.lastSeen <= SESSION_IDLE_TTL_MS) return state;
- sessions.delete(sessionId);
- return undefined;
-}
-
-function recordSessionRequest(
- sessionId: string | undefined,
- session: SessionState | undefined,
- providerName: string,
- model: string,
- now = Date.now(),
-): SessionState | undefined {
- if (!sessionId) return undefined;
- const state = session ?? { seq: 0, lastSeen: now };
- state.seq += 1;
- state.lastSeen = now;
- const affinityProvider = affinityProviderFor(providerName);
- if (affinityProvider && !ANTHROPIC_STYLE_ALIASES.has(model)) {
- state.affinityProvider = affinityProvider;
- }
- sessions.set(sessionId, state);
- evictOldestSessions();
- return state;
-}
-
-function affinityProviderFor(providerName: string): AliasProvider | undefined {
- if (providerName === "codex" || providerName === "kimi") return providerName;
- return undefined;
-}
-
-function evictOldestSessions(): void {
- while (sessions.size > MAX_SESSIONS) {
- const oldestSessionId = sessions.keys().next().value;
- if (!oldestSessionId) return;
- sessions.delete(oldestSessionId);
- }
-}
-
export function startServer(opts: ServeOptions): { stop: () => void; port: number } {
const server = Bun.serve({
hostname: "127.0.0.1",
diff --git a/src/server/session-affinity.test.ts b/src/server/session-affinity.test.ts
new file mode 100644
index 0000000..0e2a0fd
--- /dev/null
+++ b/src/server/session-affinity.test.ts
@@ -0,0 +1,68 @@
+import { describe, expect, it } from "bun:test";
+import {
+ MAX_SESSIONS,
+ SESSION_IDLE_TTL_MS,
+ existingSession,
+ recordSessionRequest,
+ resetSessionsForTest,
+} from "./session-affinity.ts";
+
+describe("server session affinity", () => {
+ it("records concrete codex and kimi affinity for later aliases", () => {
+ resetSessionsForTest();
+ const codex = recordSessionRequest("codex-session", undefined, "codex", "gpt-5.4", 1);
+ const kimi = recordSessionRequest("kimi-session", undefined, "kimi", "kimi-for-coding", 1);
+
+ expect(codex?.affinityProvider).toBe("codex");
+ expect(kimi?.affinityProvider).toBe("kimi");
+ expect(existingSession("codex-session", 2)?.affinityProvider).toBe("codex");
+ expect(existingSession("kimi-session", 2)?.affinityProvider).toBe("kimi");
+ });
+
+ it("does not overwrite affinity for aliases or cursor requests", () => {
+ resetSessionsForTest();
+ const first = recordSessionRequest("session", undefined, "codex", "gpt-5.4", 1);
+ const alias = recordSessionRequest("session", first, "kimi", "sonnet", 2);
+ const cursor = recordSessionRequest("session", alias, "cursor", "cursor-agent", 3);
+
+ expect(alias?.affinityProvider).toBe("codex");
+ expect(cursor?.affinityProvider).toBe("codex");
+ expect(cursor?.seq).toBe(3);
+ });
+
+ it("expires idle sessions with the current TTL boundary", () => {
+ resetSessionsForTest();
+ const state = recordSessionRequest("session", undefined, "kimi", "kimi-for-coding", 100);
+
+ expect(existingSession("session", 100 + SESSION_IDLE_TTL_MS)).toBe(state);
+ expect(existingSession("session", 100 + SESSION_IDLE_TTL_MS + 1)).toBeUndefined();
+ });
+
+ it("evicts oldest sessions when the maximum is exceeded", () => {
+ resetSessionsForTest();
+ for (let i = 0; i <= MAX_SESSIONS; i += 1) {
+ recordSessionRequest(`session-${i}`, undefined, "codex", "gpt-5.4", i);
+ }
+
+ expect(existingSession("session-0", MAX_SESSIONS + 1)).toBeUndefined();
+ expect(existingSession("session-1", MAX_SESSIONS + 1)).toBeDefined();
+ expect(existingSession(`session-${MAX_SESSIONS}`, MAX_SESSIONS + 1)).toBeDefined();
+ });
+
+ it("evicts by oldest map key rather than most recent lastSeen", () => {
+ resetSessionsForTest();
+ recordSessionRequest("session-0", undefined, "codex", "gpt-5.4", 0);
+
+ for (let i = 1; i < MAX_SESSIONS; i += 1) {
+ recordSessionRequest(`session-${i}`, undefined, "codex", "gpt-5.4", i);
+ }
+
+ const existing = existingSession("session-0", MAX_SESSIONS);
+ recordSessionRequest("session-0", existing, "codex", "gpt-5.4", MAX_SESSIONS);
+ recordSessionRequest("overflow", undefined, "codex", "gpt-5.4", MAX_SESSIONS + 1);
+
+ expect(existingSession("session-0", MAX_SESSIONS + 2)).toBeUndefined();
+ expect(existingSession("session-1", MAX_SESSIONS + 2)).toBeDefined();
+ });
+});
+
diff --git a/src/server/session-affinity.ts b/src/server/session-affinity.ts
new file mode 100644
index 0000000..ea79f28
--- /dev/null
+++ b/src/server/session-affinity.ts
@@ -0,0 +1,63 @@
+import type { AliasProvider } from "../config.ts";
+import { ANTHROPIC_STYLE_ALIASES } from "../providers/registry.ts";
+
+export interface SessionState {
+ seq: number;
+ affinityProvider?: AliasProvider;
+ lastSeen: number;
+}
+
+export const SESSION_IDLE_TTL_MS = 30 * 60 * 1000;
+export const MAX_SESSIONS = 10_000;
+
+const sessions = new Map<string, SessionState>();
+
+export function existingSession(
+ sessionId: string | undefined,
+ now = Date.now(),
+): SessionState | undefined {
+ if (!sessionId) return undefined;
+ const state = sessions.get(sessionId);
+ if (!state) return undefined;
+ if (now - state.lastSeen <= SESSION_IDLE_TTL_MS) return state;
+ sessions.delete(sessionId);
+ return undefined;
+}
+
+export function recordSessionRequest(
+ sessionId: string | undefined,
+ session: SessionState | undefined,
+ providerName: string,
+ model: string,
+ now = Date.now(),
+): SessionState | undefined {
+ if (!sessionId) return undefined;
+ const state = session ?? { seq: 0, lastSeen: now };
+ state.seq += 1;
+ state.lastSeen = now;
+ const affinityProvider = affinityProviderFor(providerName);
+ if (affinityProvider && !ANTHROPIC_STYLE_ALIASES.has(model)) {
+ state.affinityProvider = affinityProvider;
+ }
+ sessions.set(sessionId, state);
+ evictOldestSessions();
+ return state;
+}
+
+export function resetSessionsForTest(): void {
+ sessions.clear();
+}
+
+function affinityProviderFor(providerName: string): AliasProvider | undefined {
+ if (providerName === "codex" || providerName === "kimi") return providerName;
+ return undefined;
+}
+
+function evictOldestSessions(): void {
+ while (sessions.size > MAX_SESSIONS) {
+ const oldestSessionId = sessions.keys().next().value;
+ if (!oldestSessionId) return;
+ sessions.delete(oldestSessionId);
+ }
+}
+