From 862cd4922ed01b287461b26c2aad673e85f09449 Mon Sep 17 00:00:00 2001 From: m4 Date: Tue, 21 Jul 2026 18:50:17 +0800 Subject: [PATCH] =?UTF-8?q?feat:=20unified=20model=20configuration=20?= =?UTF-8?q?=E2=80=94=20BFF=20auth,=20delegation=20JWT,=20thread=20model=20?= =?UTF-8?q?selection?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Multi-user auth (better-sqlite3 + scrypt) with admin/user roles and ES256 delegation JWT signing for EvoScientist Config API calls - BFF config client sends Authorization: Bearer + X-Evo-Actor delegation JWT (design doc 7.3) - Model registry admin API routes (GET/PUT registry, credential replace, provider test) proxying the backend with revision CAS - ThreadModelSelection replaces model_override: PATCH CAS with expected_selection_revision, per-thread serialization, 409 THREAD_MODEL_SELECTION_CONFLICT - Run creation freezes a runtime snapshot per turn; command resumes reuse the turn's frozen snapshot from run metadata (design doc 7.2/8.2) - Chat UI: ModelRef picker fed by GET /api/models selectable list; removed /model command, localStorage preference, and set-default star - Deleted lib/modelCommand.ts, lib/modelPreference.ts, lib/defaultModel.ts Co-Authored-By: Claude Opus 4.7 --- src/app/api/auth/login/route.ts | 5 +- src/app/api/auth/me/route.ts | 13 +- src/app/api/auth/password/route.ts | 26 +- src/app/api/auth/users/[username]/route.ts | 129 ++++++++ src/app/api/auth/users/route.ts | 81 +++++ src/app/api/conversations/[threadId]/route.ts | 82 ++++- .../[threadId]/runs/route.test.ts | 99 +++++- .../conversations/[threadId]/runs/route.ts | 208 +++++++------ .../credentials/[credentialId]/route.ts | 58 ++++ src/app/api/model-registry/route.ts | 80 +++++ src/app/api/model-registry/test/route.ts | 50 ++++ src/app/api/models/route.ts | 48 ++- src/app/components/ChatInterface.tsx | 283 +++++------------- src/app/hooks/useAvailableModels.ts | 163 +++++----- src/app/hooks/useChat.ts | 203 ++++++++----- src/app/hooks/useThreads.ts | 14 +- src/lib/defaultModel.ts | 37 --- src/lib/modelCommand.ts | 83 ----- src/lib/modelPreference.test.ts | 60 ---- src/lib/modelPreference.ts | 67 ----- src/lib/modelRegistry.ts | 204 +++++++++++++ src/lib/server/actor.ts | 50 ++++ src/lib/server/auth.ts | 152 +++++----- src/lib/server/dataDir.ts | 13 + src/lib/server/delegation.ts | 124 ++++++++ src/lib/server/evoscientistConfigClient.ts | 103 +++++++ src/lib/server/routeErrors.ts | 35 +++ src/lib/server/threadModelSelection.ts | 98 ++++++ src/lib/server/userStore.ts | 226 ++++++++++++++ src/proxy.ts | 17 +- 30 files changed, 1924 insertions(+), 887 deletions(-) create mode 100644 src/app/api/auth/users/[username]/route.ts create mode 100644 src/app/api/auth/users/route.ts create mode 100644 src/app/api/model-registry/credentials/[credentialId]/route.ts create mode 100644 src/app/api/model-registry/route.ts create mode 100644 src/app/api/model-registry/test/route.ts delete mode 100644 src/lib/defaultModel.ts delete mode 100644 src/lib/modelCommand.ts delete mode 100644 src/lib/modelPreference.test.ts delete mode 100644 src/lib/modelPreference.ts create mode 100644 src/lib/modelRegistry.ts create mode 100644 src/lib/server/actor.ts create mode 100644 src/lib/server/dataDir.ts create mode 100644 src/lib/server/delegation.ts create mode 100644 src/lib/server/evoscientistConfigClient.ts create mode 100644 src/lib/server/routeErrors.ts create mode 100644 src/lib/server/threadModelSelection.ts create mode 100644 src/lib/server/userStore.ts diff --git a/src/app/api/auth/login/route.ts b/src/app/api/auth/login/route.ts index 679dcfb..d637b7d 100644 --- a/src/app/api/auth/login/route.ts +++ b/src/app/api/auth/login/route.ts @@ -51,13 +51,14 @@ export async function POST(request: NextRequest) { } try { - if (!verifyCredentials(username, password)) { + const user = verifyCredentials(username, password); + if (!user) { return NextResponse.json( { error: "Invalid username or password." }, { status: 401, headers: NO_STORE } ); } - const { token, payload } = createSession(username); + const { token, payload } = createSession(user.username, user.role); await recordLogin(payload); const response = NextResponse.json( { diff --git a/src/app/api/auth/me/route.ts b/src/app/api/auth/me/route.ts index 16ff2e7..de9b7bc 100644 --- a/src/app/api/auth/me/route.ts +++ b/src/app/api/auth/me/route.ts @@ -1,6 +1,7 @@ import { type NextRequest, NextResponse } from "next/server"; import { AUTH_COOKIE_NAME, isAuthenticationEnabled } from "@/lib/auth"; -import { decodeSessionPayload } from "@/lib/server/auth"; +import { decodeSessionPayload, roleForUsername } from "@/lib/server/auth"; +import { ensureBootstrapAdmin } from "@/lib/server/userStore"; export const runtime = "nodejs"; export const dynamic = "force-dynamic"; @@ -24,9 +25,17 @@ export function GET(request: NextRequest) { { status: 401, headers: NO_STORE } ); } + ensureBootstrapAdmin(); + const role = roleForUsername(session.username); + if (!role) { + return NextResponse.json( + { error: "Authentication required." }, + { status: 401, headers: NO_STORE } + ); + } return NextResponse.json( - { username: session.username }, + { username: session.username, role }, { headers: NO_STORE } ); } diff --git a/src/app/api/auth/password/route.ts b/src/app/api/auth/password/route.ts index 768767e..0c99e29 100644 --- a/src/app/api/auth/password/route.ts +++ b/src/app/api/auth/password/route.ts @@ -1,11 +1,12 @@ import { type NextRequest, NextResponse } from "next/server"; -import { isAuthenticationEnabled } from "@/lib/auth"; +import { AUTH_COOKIE_NAME, isAuthenticationEnabled } from "@/lib/auth"; import { AuthConfigurationError, authCookieOptions, createSession, - getAuthConfiguration, + decodeSessionPayload, recordLogin, + roleForUsername, updateAuthPassword, verifyCredentials, } from "@/lib/server/auth"; @@ -23,7 +24,7 @@ function hasControlCharacter(value: string): boolean { return false; } -function passwordError(password: string): string | null { +export function passwordValidationError(password: string): string | null { if (password.length < 8) return "New password must contain at least 8 characters."; if (password.length > 256) return "New password is too long."; if (hasControlCharacter(password)) { @@ -46,6 +47,15 @@ export async function POST(request: NextRequest) { { status: 403, headers: NO_STORE } ); } + const session = decodeSessionPayload( + request.cookies.get(AUTH_COOKIE_NAME)?.value ?? "" + ); + if (!session || session.expiresAt <= Math.floor(Date.now() / 1000)) { + return NextResponse.json( + { error: "Authentication required." }, + { status: 401, headers: NO_STORE } + ); + } const body = (await request.json().catch(() => null)) as { currentPassword?: unknown; newPassword?: unknown; @@ -57,7 +67,7 @@ export async function POST(request: NextRequest) { typeof body?.newPassword === "string" ? body.newPassword : ""; const confirmPassword = typeof body?.confirmPassword === "string" ? body.confirmPassword : ""; - const validationError = passwordError(newPassword); + const validationError = passwordValidationError(newPassword); if (!currentPassword || !newPassword || !confirmPassword || validationError) { return NextResponse.json( { error: validationError ?? "Complete all password fields." }, @@ -72,8 +82,7 @@ export async function POST(request: NextRequest) { } try { - const config = getAuthConfiguration(); - if (!verifyCredentials(config.username, currentPassword)) { + if (!verifyCredentials(session.username, currentPassword)) { return NextResponse.json( { error: "Current password is incorrect." }, { status: 401, headers: NO_STORE } @@ -85,8 +94,9 @@ export async function POST(request: NextRequest) { { status: 400, headers: NO_STORE } ); } - await updateAuthPassword(newPassword); - const { token, payload } = createSession(config.username); + await updateAuthPassword(session.username, newPassword); + const role = roleForUsername(session.username) ?? session.role; + const { token, payload } = createSession(session.username, role); await recordLogin(payload); const response = NextResponse.json({ ok: true }, { headers: NO_STORE }); response.cookies.set({ ...authCookieOptions(), value: token }); diff --git a/src/app/api/auth/users/[username]/route.ts b/src/app/api/auth/users/[username]/route.ts new file mode 100644 index 0000000..b191125 --- /dev/null +++ b/src/app/api/auth/users/[username]/route.ts @@ -0,0 +1,129 @@ +import { type NextRequest, NextResponse } from "next/server"; +import { requireActor, requireAdmin } from "@/lib/server/actor"; +import { isCrossOrigin } from "@/lib/server/workspace"; +import { NO_STORE, routeErrorResponse } from "@/lib/server/routeErrors"; +import { + deleteUser, + getUser, + listUsers, + setUserPassword, + setUserRole, + UserStoreError, +} from "@/lib/server/userStore"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +type RouteContext = { params: Promise<{ username: string }> }; + +function lastAdminGuard(username: string, nextRole?: string): string | null { + const admins = listUsers().filter((user) => user.role === "admin"); + const targetIsLastAdmin = + admins.length === 1 && admins[0].username === username; + if (targetIsLastAdmin && nextRole !== "admin") { + return "The last admin account cannot be demoted or deleted."; + } + return null; +} + +export async function PATCH(request: NextRequest, context: RouteContext) { + try { + if (isCrossOrigin(request)) { + return NextResponse.json( + { code: "FORBIDDEN", message: "Cross-origin access is not allowed." }, + { status: 403, headers: NO_STORE } + ); + } + const actor = requireActor(request); + requireAdmin(actor); + const { username } = await context.params; + if (!getUser(username)) { + return NextResponse.json( + { code: "INVALID_REQUEST", message: `User '${username}' does not exist.` }, + { status: 404, headers: NO_STORE } + ); + } + const body = (await request.json().catch(() => null)) as { + role?: unknown; + password?: unknown; + } | null; + const nextRole = + body?.role === "admin" ? "admin" : body?.role === "user" ? "user" : null; + const nextPassword = + typeof body?.password === "string" && body.password ? body.password : null; + if (!nextRole && !nextPassword) { + return NextResponse.json( + { code: "INVALID_REQUEST", message: "Provide role and/or password." }, + { status: 400, headers: NO_STORE } + ); + } + if (nextRole) { + const guard = lastAdminGuard(username, nextRole); + if (guard) { + return NextResponse.json( + { code: "INVALID_REQUEST", message: guard }, + { status: 400, headers: NO_STORE } + ); + } + setUserRole(username, nextRole); + } + if (nextPassword) { + if (nextPassword.length < 8 || nextPassword.length > 256) { + return NextResponse.json( + { + code: "INVALID_REQUEST", + message: "Password must contain 8-256 characters.", + }, + { status: 400, headers: NO_STORE } + ); + } + setUserPassword(username, nextPassword); + } + return NextResponse.json({ user: getUser(username) }, { headers: NO_STORE }); + } catch (error) { + if (error instanceof UserStoreError) { + return NextResponse.json( + { code: "INVALID_REQUEST", message: error.message }, + { status: 400, headers: NO_STORE } + ); + } + return routeErrorResponse(error); + } +} + +export async function DELETE(request: NextRequest, context: RouteContext) { + try { + if (isCrossOrigin(request)) { + return NextResponse.json( + { code: "FORBIDDEN", message: "Cross-origin access is not allowed." }, + { status: 403, headers: NO_STORE } + ); + } + const actor = requireActor(request); + requireAdmin(actor); + const { username } = await context.params; + if (username === actor.sub) { + return NextResponse.json( + { code: "INVALID_REQUEST", message: "You cannot delete your own account." }, + { status: 400, headers: NO_STORE } + ); + } + const guard = lastAdminGuard(username); + if (guard) { + return NextResponse.json( + { code: "INVALID_REQUEST", message: guard }, + { status: 400, headers: NO_STORE } + ); + } + deleteUser(username); + return NextResponse.json({ ok: true }, { headers: NO_STORE }); + } catch (error) { + if (error instanceof UserStoreError) { + return NextResponse.json( + { code: "INVALID_REQUEST", message: error.message }, + { status: 404, headers: NO_STORE } + ); + } + return routeErrorResponse(error); + } +} diff --git a/src/app/api/auth/users/route.ts b/src/app/api/auth/users/route.ts new file mode 100644 index 0000000..fabfe20 --- /dev/null +++ b/src/app/api/auth/users/route.ts @@ -0,0 +1,81 @@ +import { type NextRequest, NextResponse } from "next/server"; +import { requireActor, requireAdmin } from "@/lib/server/actor"; +import { isCrossOrigin } from "@/lib/server/workspace"; +import { NO_STORE, routeErrorResponse } from "@/lib/server/routeErrors"; +import { + createUser, + ensureBootstrapAdmin, + listUsers, + UserStoreError, + validateUsername, +} from "@/lib/server/userStore"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +/** Admin user management (design doc 7.2: the first admin comes from the + * deployment environment; later users are managed by admins). */ +export async function GET(request: NextRequest) { + try { + if (isCrossOrigin(request)) { + return NextResponse.json( + { code: "FORBIDDEN", message: "Cross-origin access is not allowed." }, + { status: 403, headers: NO_STORE } + ); + } + const actor = requireActor(request); + requireAdmin(actor); + ensureBootstrapAdmin(); + return NextResponse.json({ users: listUsers() }, { headers: NO_STORE }); + } catch (error) { + return routeErrorResponse(error); + } +} + +export async function POST(request: NextRequest) { + try { + if (isCrossOrigin(request)) { + return NextResponse.json( + { code: "FORBIDDEN", message: "Cross-origin access is not allowed." }, + { status: 403, headers: NO_STORE } + ); + } + const actor = requireActor(request); + requireAdmin(actor); + ensureBootstrapAdmin(); + const body = (await request.json().catch(() => null)) as { + username?: unknown; + password?: unknown; + role?: unknown; + } | null; + const username = typeof body?.username === "string" ? body.username.trim() : ""; + const password = typeof body?.password === "string" ? body.password : ""; + const role = body?.role === "admin" ? "admin" : "user"; + const invalid = validateUsername(username); + if (invalid) { + return NextResponse.json( + { code: "INVALID_REQUEST", message: invalid }, + { status: 400, headers: NO_STORE } + ); + } + if (password.length < 8 || password.length > 256) { + return NextResponse.json( + { + code: "INVALID_REQUEST", + message: "Password must contain 8-256 characters.", + }, + { status: 400, headers: NO_STORE } + ); + } + const user = createUser(username, password, role); + return NextResponse.json({ user }, { status: 201, headers: NO_STORE }); + } catch (error) { + if (error instanceof UserStoreError) { + return NextResponse.json( + { code: "INVALID_REQUEST", message: error.message }, + { status: 400, headers: NO_STORE } + ); + } + return routeErrorResponse(error); + } +} diff --git a/src/app/api/conversations/[threadId]/route.ts b/src/app/api/conversations/[threadId]/route.ts index c5ed82b..fc0b8f8 100644 --- a/src/app/api/conversations/[threadId]/route.ts +++ b/src/app/api/conversations/[threadId]/route.ts @@ -9,6 +9,12 @@ import { sanitizeConversationThread, } from "@/lib/server/conversationResponse"; import { drainConversationScope } from "@/lib/server/scopeDrain"; +import { + parseThreadModelSelection, + readThreadModelSelection, + ThreadModelSelectionError, + withThreadSelectionLock, +} from "@/lib/server/threadModelSelection"; export const runtime = "nodejs"; @@ -60,7 +66,12 @@ export async function PATCH(request: NextRequest, context: RouteContext) { if (!body || typeof body !== "object" || Array.isArray(body)) { return NextResponse.json({ error: "Invalid conversation patch." }, { status: 400 }); } - const allowed = new Set(["title", "pinned", "model_override"]); + const allowed = new Set([ + "title", + "pinned", + "model_selection", + "expected_selection_revision", + ]); const entries = Object.entries(body as Record); if (entries.length === 0 || entries.some(([key]) => !allowed.has(key) || forbiddenMetadataKey(key))) { return NextResponse.json({ error: "Unsupported conversation field." }, { status: 400 }); @@ -71,16 +82,71 @@ export async function PATCH(request: NextRequest, context: RouteContext) { if ("pinned" in body && typeof body.pinned !== "boolean") { return NextResponse.json({ error: "pinned must be a boolean." }, { status: 400 }); } - const { deployment, thread, scope } = await verifiedConversation(threadId); + const wantsSelection = "model_selection" in body; + if (wantsSelection) { + const expected = body.expected_selection_revision; + if (typeof expected !== "number" || !Number.isInteger(expected) || expected < 0) { + return NextResponse.json( + { + code: "INVALID_REQUEST", + error: "expected_selection_revision must be a non-negative integer.", + }, + { status: 400 } + ); + } + try { + parseThreadModelSelection(body.model_selection); + } catch (error) { + if (error instanceof ThreadModelSelectionError) { + return NextResponse.json( + { code: error.code, error: error.message }, + { status: 400 } + ); + } + throw error; + } + } else if ("expected_selection_revision" in body) { + return NextResponse.json( + { + code: "INVALID_REQUEST", + error: "expected_selection_revision requires model_selection.", + }, + { status: 400 } + ); + } + const { deployment, scope } = await verifiedConversation(threadId); if (scope?.state === "deleting" || scope?.state === "deleted") { return NextResponse.json({ error: "Conversation is not available." }, { status: 409 }); } - const metadata = { - ...((thread.metadata as Record | undefined) ?? {}), - ...body, - }; - const updated = await deployment.threadClient.threads.update(threadId, { metadata }); - return NextResponse.json({ thread: sanitizeConversationThread(updated) }); + const updated = await withThreadSelectionLock(threadId, async () => { + const current = await deployment.threadClient.threads.get(threadId); + const currentMetadata = + (current.metadata as Record | undefined) ?? {}; + const metadata: Record = { ...currentMetadata }; + if ("title" in body) metadata.title = body.title; + if ("pinned" in body) metadata.pinned = body.pinned; + if (wantsSelection) { + const stored = readThreadModelSelection(currentMetadata); + if (stored.revision !== body.expected_selection_revision) { + return { ok: false as const, current: stored }; + } + metadata.model_selection = parseThreadModelSelection(body.model_selection); + metadata.model_selection_revision = stored.revision + 1; + } + const saved = await deployment.threadClient.threads.update(threadId, { metadata }); + return { ok: true as const, thread: saved }; + }); + if (!updated.ok) { + return NextResponse.json( + { + code: "THREAD_MODEL_SELECTION_CONFLICT", + error: "Thread model selection changed; reload and retry.", + current: updated.current, + }, + { status: 409 } + ); + } + return NextResponse.json({ thread: sanitizeConversationThread(updated.thread) }); } catch (error) { return errorResponse(error); } diff --git a/src/app/api/conversations/[threadId]/runs/route.test.ts b/src/app/api/conversations/[threadId]/runs/route.test.ts index 476fb16..2964cf2 100644 --- a/src/app/api/conversations/[threadId]/runs/route.test.ts +++ b/src/app/api/conversations/[threadId]/runs/route.test.ts @@ -5,6 +5,8 @@ const mocks = vi.hoisted(() => ({ getActiveDeployment: vi.fn(), assertCutoverIsIdle: vi.fn(), assertThreadMatchesScope: vi.fn(), + requireActor: vi.fn(() => ({ sub: "tester", role: "admin" as const })), + configApiFetch: vi.fn(), })); vi.mock("server-only", () => ({})); @@ -17,10 +19,46 @@ vi.mock("@/lib/server/conversationResponse", () => ({ assertThreadMatchesScope: mocks.assertThreadMatchesScope, sanitizeConversationData: (value: T) => value, })); +vi.mock("@/lib/server/actor", () => ({ + requireActor: mocks.requireActor, +})); +vi.mock("@/lib/server/evoscientistConfigClient", () => ({ + configApiFetch: mocks.configApiFetch, + ConfigApiError: class ConfigApiError extends Error { + constructor( + message: string, + readonly status: number, + readonly code: string | null = null, + readonly details: unknown[] = [] + ) { + super(message); + } + }, +})); +vi.mock("@/lib/server/delegation", () => ({ + delegationDeploymentId: () => "webui-test", +})); const routes = await import("./route"); const context = { params: Promise.resolve({ threadId: "thread-a" }) }; +let snapshotCounter = 0; + +function mockSnapshotApi() { + mocks.configApiFetch.mockImplementation( + async (_actor: unknown, path: string, options?: { method?: string }) => { + if (path === "/api/runtime-snapshots" && options?.method === "POST") { + snapshotCounter += 1; + return { status: 201, body: { snapshot_id: `snap-${snapshotCounter}` } }; + } + if (path.endsWith("/bind")) { + return { status: 200, body: {} }; + } + return { status: 200, body: {} }; + } + ); +} + function legacyDeployment() { return { assistantId: "EvoScientist", @@ -39,7 +77,7 @@ function legacyDeployment() { }; } -function scopedDeployment() { +function scopedDeployment(priorRuns: unknown[] = []) { const scope = { deployment_id: "deployment-a", scope_id: "00000000-0000-4000-8000-000000000010", @@ -74,7 +112,7 @@ function scopedDeployment() { .mockResolvedValueOnce({ run_id: "run-initial", status: "pending" }) .mockResolvedValueOnce({ run_id: "run-resume", status: "pending" }), get: vi.fn(), - list: vi.fn().mockResolvedValue([]), + list: vi.fn().mockResolvedValue(priorRuns), }, }, }; @@ -83,6 +121,8 @@ function scopedDeployment() { describe("conversation run route", () => { beforeEach(() => { vi.clearAllMocks(); + snapshotCounter = 0; + mockSnapshotApi(); }); it("keeps legacy BFF runs operational without scope metadata", async () => { @@ -119,7 +159,18 @@ describe("conversation run route", () => { metadata: expect.not.objectContaining({ workspace_scope_id: expect.anything(), }), - config: { configurable: { review_mode: "manual" } }, + config: { + configurable: { review_mode: "manual", runtime_snapshot_id: "snap-1" }, + }, + }) + ); + // The fresh snapshot is bound to the created run. + expect(mocks.configApiFetch).toHaveBeenCalledWith( + expect.anything(), + "/api/runtime-snapshots/snap-1/bind", + expect.objectContaining({ + method: "POST", + body: { langgraph_run_id: "run-a" }, }) ); }); @@ -178,11 +229,18 @@ describe("conversation run route", () => { }); it("creates a distinct run request for an approval resume in the same turn", async () => { - const deployment = scopedDeployment(); - mocks.getActiveDeployment.mockResolvedValue(deployment); const turnId = "00000000-0000-4000-8000-000000000001"; const initialRequestId = "00000000-0000-4000-8000-000000000002"; const resumeRequestId = "00000000-0000-4000-8000-000000000003"; + // The resume reuses the turn's frozen snapshot from the initial run's + // metadata instead of freezing a fresh one (design doc 7.2/8.2). + const deployment = scopedDeployment([ + { + run_id: "run-initial", + metadata: { turn_id: turnId, runtime_snapshot_id: "snap-1" }, + }, + ]); + mocks.getActiveDeployment.mockResolvedValue(deployment); const initial = new Request( "http://localhost/api/conversations/thread-a/runs", { @@ -252,5 +310,36 @@ describe("conversation run route", () => { resumeRequestId, "run-resume" ); + // Initial run froze snap-1; the resume reused it (no second snapshot). + expect(deployment.threadClient.runs.create).toHaveBeenNthCalledWith( + 1, + "thread-a", + "EvoScientist", + expect.objectContaining({ + config: { + configurable: expect.objectContaining({ + runtime_snapshot_id: "snap-1", + }), + }, + }) + ); + expect(deployment.threadClient.runs.create).toHaveBeenNthCalledWith( + 2, + "thread-a", + "EvoScientist", + expect.objectContaining({ + config: { + configurable: expect.objectContaining({ + runtime_snapshot_id: "snap-1", + }), + }, + }) + ); + const snapshotCreations = mocks.configApiFetch.mock.calls.filter( + ([, path, options]) => + path === "/api/runtime-snapshots" && + (options as { method?: string } | undefined)?.method === "POST" + ); + expect(snapshotCreations).toHaveLength(1); }); }); diff --git a/src/app/api/conversations/[threadId]/runs/route.ts b/src/app/api/conversations/[threadId]/runs/route.ts index db8e7a1..2718fb6 100644 --- a/src/app/api/conversations/[threadId]/runs/route.ts +++ b/src/app/api/conversations/[threadId]/runs/route.ts @@ -10,7 +10,15 @@ import { assertThreadMatchesScope, sanitizeConversationData, } from "@/lib/server/conversationResponse"; -import { getEvoScientistAdminToken } from "@/lib/server/evoscientistAdminProxy"; +import { requireActor } from "@/lib/server/actor"; +import { + ConfigApiError, + configApiFetch, +} from "@/lib/server/evoscientistConfigClient"; +import { delegationDeploymentId } from "@/lib/server/delegation"; +import { routeErrorResponse } from "@/lib/server/routeErrors"; +import type { ThreadModelSelection } from "@/lib/modelRegistry"; +import { readThreadModelSelection } from "@/lib/server/threadModelSelection"; export const runtime = "nodejs"; @@ -34,83 +42,30 @@ function isPlainObject(value: unknown): value is Record { return Boolean(value) && typeof value === "object" && !Array.isArray(value); } -type RuntimeSnapshotPublic = { +interface SnapshotPublicResponse { snapshot_id: string; - provider: string; - model: string; - profile_revision: string | null; - created_at: number; - expires_at: number; - runtime: Record; -}; - -function readRuntimeSnapshot(value: unknown): RuntimeSnapshotPublic | null { - if (!isPlainObject(value)) return null; - const requiredStrings = ["snapshot_id", "provider", "model"] as const; - if (requiredStrings.some((key) => typeof value[key] !== "string")) - return null; - if (!isPlainObject(value.runtime)) return null; - return value as unknown as RuntimeSnapshotPublic; } -async function priorTurnRuntimeSnapshot( +/** + * Retries, approval commands, and continuations of the same turn reuse the + * original run's frozen snapshot (design doc 7.2/8.2): the snapshot id is + * read back from the prior run's metadata. + */ +async function priorTurnSnapshotId( deployment: Awaited>, threadId: string, turnId: string -): Promise { +): Promise { const runs = await deployment.threadClient.runs.list(threadId, { limit: 50 }); for (const run of runs) { const metadata = isPlainObject(run.metadata) ? run.metadata : null; if (metadata?.turn_id !== turnId) continue; - const snapshot = readRuntimeSnapshot(metadata.runtime_snapshot); - if (snapshot) return snapshot; + const snapshotId = metadata.runtime_snapshot_id; + if (typeof snapshotId === "string" && snapshotId) return snapshotId; } return null; } -async function createRuntimeSnapshot( - deployment: Awaited>, - snapshotId: string, - modelOverride: Record | null -): Promise { - const model = modelOverride?.model; - const provider = modelOverride?.model_provider; - if (typeof model !== "string" || typeof provider !== "string") return null; - - const token = getEvoScientistAdminToken(); - if (!token) { - throw new Error("Runtime configuration snapshots are unavailable."); - } - const response = await fetch( - new URL("/api/runtime-snapshots", deployment.langgraphApiUrl), - { - method: "POST", - cache: "no-store", - headers: { - "Content-Type": "application/json", - "X-EvoScientist-Admin-Token": token, - }, - body: JSON.stringify({ - snapshot_id: snapshotId, - model, - provider, - }), - } - ); - const payload = (await response.json().catch(() => null)) as { - error?: unknown; - snapshot?: unknown; - } | null; - if (!response.ok) { - throw new Error( - typeof payload?.error === "string" - ? payload.error - : "Could not create a runtime configuration snapshot." - ); - } - return readRuntimeSnapshot(payload?.snapshot); -} - async function scopeForThread(threadId: string) { const deployment = await getActiveDeployment(); const thread = await deployment.threadClient.threads.get(threadId); @@ -118,7 +73,7 @@ async function scopeForThread(threadId: string) { if (deployment.isolationMode !== "legacy") { throw new Error("Workspace scope service is unavailable."); } - return { deployment, scope: null }; + return { deployment, thread, scope: null }; } const scope = await deployment.scopeRegistry.getByThread(threadId); assertThreadMatchesScope( @@ -129,7 +84,7 @@ async function scopeForThread(threadId: string) { if (scope.state === "deleting" || scope.state === "deleted") { throw new Error("Conversation is not available for new runs."); } - return { deployment, scope }; + return { deployment, thread, scope }; } export async function GET(_request: NextRequest, context: RouteContext) { @@ -152,11 +107,12 @@ export async function GET(_request: NextRequest, context: RouteContext) { export async function POST(request: NextRequest, context: RouteContext) { try { + const actor = requireActor(request); const { threadId } = await context.params; const body = await request.json().catch(() => null); if (!isPlainObject(body)) { return NextResponse.json( - { error: "Invalid run request." }, + { code: "INVALID_REQUEST", message: "Invalid run request." }, { status: 400 } ); } @@ -167,11 +123,10 @@ export async function POST(request: NextRequest, context: RouteContext) { "input", "command", "review_mode", - "model_override", ]); if (Object.keys(body).some((key) => !allowed.has(key))) { return NextResponse.json( - { error: "Unsupported run field." }, + { code: "INVALID_REQUEST", message: "Unsupported run field." }, { status: 400 } ); } @@ -187,13 +142,13 @@ export async function POST(request: NextRequest, context: RouteContext) { : null; if (interruptKey && interruptKey.length > 256) { return NextResponse.json( - { error: "interrupt_key is too long." }, + { code: "INVALID_REQUEST", message: "interrupt_key is too long." }, { status: 400 } ); } if (!isPlainObject(body.input) && !isPlainObject(body.command)) { return NextResponse.json( - { error: "input or command is required." }, + { code: "INVALID_REQUEST", message: "input or command is required." }, { status: 400 } ); } @@ -220,9 +175,6 @@ export async function POST(request: NextRequest, context: RouteContext) { input: isPlainObject(body.input) ? body.input : null, command: isPlainObject(body.command) ? body.command : null, review_mode: body.review_mode ?? null, - model_override: isPlainObject(body.model_override) - ? body.model_override - : null, }); const reservation = scope ? await deployment.scopeRegistry!.reserveRun(scope.scope_id, { @@ -245,25 +197,41 @@ export async function POST(request: NextRequest, context: RouteContext) { runRequestId, }); } - const requestedOverride = isPlainObject(body.model_override) - ? body.model_override + + // --- run snapshot (design doc 8.2) -------------------------------------- + // A command resume reuses the turn's original snapshot; a new turn + // freezes the thread's current model selection into a fresh snapshot. + let snapshotId = body.command + ? await priorTurnSnapshotId(deployment, threadId, turnId) : null; - const priorSnapshot = body.command - ? await priorTurnRuntimeSnapshot(deployment, threadId, turnId) - : null; - const runtimeSnapshot = - priorSnapshot ?? - (await createRuntimeSnapshot( - deployment, - runRequestId, - requestedOverride - )); - const effectiveOverride = runtimeSnapshot - ? { - model: runtimeSnapshot.model, - model_provider: runtimeSnapshot.provider, - } - : requestedOverride; + let freshSnapshot = false; + if (!snapshotId) { + const selection = readThreadModelSelection( + resolved.thread.metadata as Record | undefined + ); + const selectionRef: ThreadModelSelection = selection.selection; + const { body: snapshot } = + await configApiFetch( + actor, + "/api/runtime-snapshots", + { + method: "POST", + threadId, + body: { + run_request_id: runRequestId, + thread_id: threadId, + deployment_id: delegationDeploymentId(), + model_selection_revision: selection.revision, + primary: + selectionRef === "inherit" ? null : selectionRef.primary, + auxiliary: + selectionRef === "inherit" ? null : selectionRef.auxiliary, + }, + } + ); + snapshotId = snapshot.snapshot_id; + freshSnapshot = true; + } const metadata = { turn_id: turnId, @@ -271,7 +239,7 @@ export async function POST(request: NextRequest, context: RouteContext) { ...(interruptKey ? { interrupt_key: interruptKey } : {}), request_hash: hash, review_mode: body.review_mode, - ...(runtimeSnapshot ? { runtime_snapshot: runtimeSnapshot } : {}), + runtime_snapshot_id: snapshotId, ...(scope && reservation ? { workspace_scope_id: scope.scope_id, @@ -292,23 +260,46 @@ export async function POST(request: NextRequest, context: RouteContext) { } : {}), ...(body.review_mode ? { review_mode: body.review_mode } : {}), - ...(effectiveOverride ?? {}), - ...(runtimeSnapshot - ? { runtime_snapshot_id: runtimeSnapshot.snapshot_id } - : {}), + runtime_snapshot_id: snapshotId, }, }; - const run = await deployment.threadClient.runs.create( - threadId, - deployment.assistantId, - { - input: isPlainObject(body.input) ? body.input : undefined, - command: isPlainObject(body.command) ? body.command : undefined, - metadata, - config, - multitaskStrategy: "enqueue", + let run; + try { + run = await deployment.threadClient.runs.create( + threadId, + deployment.assistantId, + { + input: isPlainObject(body.input) ? body.input : undefined, + command: isPlainObject(body.command) ? body.command : undefined, + metadata, + config, + multitaskStrategy: "enqueue", + } + ); + } catch (error) { + if (freshSnapshot) { + await configApiFetch( + actor, + `/api/runtime-snapshots/${encodeURIComponent(snapshotId)}`, + { method: "DELETE", threadId } + ).catch(() => undefined); } - ); + throw error; + } + if (freshSnapshot) { + try { + await configApiFetch( + actor, + `/api/runtime-snapshots/${encodeURIComponent(snapshotId)}/bind`, + { method: "POST", threadId, body: { langgraph_run_id: run.run_id } } + ); + } catch (error) { + await deployment.threadClient.runs + .cancel(threadId, run.run_id) + .catch(() => undefined); + throw error; + } + } if (scope && reservation) { await deployment.scopeRegistry!.bindRun( scope.scope_id, @@ -336,6 +327,9 @@ export async function POST(request: NextRequest, context: RouteContext) { { status: error.status } ); } + if (error instanceof ConfigApiError) { + return routeErrorResponse(error); + } return NextResponse.json( { error: error instanceof Error ? error.message : "Failed to create run.", diff --git a/src/app/api/model-registry/credentials/[credentialId]/route.ts b/src/app/api/model-registry/credentials/[credentialId]/route.ts new file mode 100644 index 0000000..6c5a69b --- /dev/null +++ b/src/app/api/model-registry/credentials/[credentialId]/route.ts @@ -0,0 +1,58 @@ +import { type NextRequest, NextResponse } from "next/server"; +import { requireActor, requireAdmin } from "@/lib/server/actor"; +import { configApiFetch } from "@/lib/server/evoscientistConfigClient"; +import { isCrossOrigin } from "@/lib/server/workspace"; +import { NO_STORE, routeErrorResponse } from "@/lib/server/routeErrors"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +type RouteContext = { params: Promise<{ credentialId: string }> }; + +export async function PUT(request: NextRequest, context: RouteContext) { + try { + if (isCrossOrigin(request)) { + return NextResponse.json( + { code: "FORBIDDEN", message: "Cross-origin access is not allowed." }, + { status: 403, headers: NO_STORE } + ); + } + const actor = requireActor(request); + requireAdmin(actor); + const { credentialId } = await context.params; + if (!/^[a-z0-9][a-z0-9._-]{0,63}$/.test(credentialId)) { + return NextResponse.json( + { code: "INVALID_REQUEST", message: "Invalid credential id." }, + { status: 400, headers: NO_STORE } + ); + } + const payload = (await request.json().catch(() => null)) as { + operation?: unknown; + secret_value?: unknown; + } | null; + if ( + payload?.operation !== "replace" || + typeof payload.secret_value !== "string" || + !payload.secret_value + ) { + return NextResponse.json( + { + code: "INVALID_REQUEST", + message: "operation 'replace' and a non-empty secret_value are required.", + }, + { status: 400, headers: NO_STORE } + ); + } + const { body } = await configApiFetch( + actor, + `/api/model-registry/credentials/${encodeURIComponent(credentialId)}`, + { + method: "PUT", + body: { operation: "replace", secret_value: payload.secret_value }, + } + ); + return NextResponse.json(body, { headers: NO_STORE }); + } catch (error) { + return routeErrorResponse(error); + } +} diff --git a/src/app/api/model-registry/route.ts b/src/app/api/model-registry/route.ts new file mode 100644 index 0000000..7c8a516 --- /dev/null +++ b/src/app/api/model-registry/route.ts @@ -0,0 +1,80 @@ +import { type NextRequest, NextResponse } from "next/server"; +import { requireActor, requireAdmin } from "@/lib/server/actor"; +import { configApiFetch } from "@/lib/server/evoscientistConfigClient"; +import { isCrossOrigin } from "@/lib/server/workspace"; +import { NO_STORE, routeErrorResponse } from "@/lib/server/routeErrors"; +import type { + GetModelRegistryResponse, + PutModelRegistryRequest, +} from "@/lib/modelRegistry"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +export async function GET(request: NextRequest) { + try { + if (isCrossOrigin(request)) { + return NextResponse.json( + { code: "FORBIDDEN", message: "Cross-origin access is not allowed." }, + { status: 403, headers: NO_STORE } + ); + } + const actor = requireActor(request); + requireAdmin(actor); + const { body } = await configApiFetch( + actor, + "/api/model-registry" + ); + return NextResponse.json(body, { headers: NO_STORE }); + } catch (error) { + return routeErrorResponse(error); + } +} + +export async function PUT(request: NextRequest) { + try { + if (isCrossOrigin(request)) { + return NextResponse.json( + { code: "FORBIDDEN", message: "Cross-origin access is not allowed." }, + { status: 403, headers: NO_STORE } + ); + } + const actor = requireActor(request); + requireAdmin(actor); + const payload = (await request.json().catch(() => null)) as + | (PutModelRegistryRequest & { credential_writes?: unknown }) + | null; + if ( + !payload || + typeof payload.expected_revision !== "number" || + typeof payload.registry !== "object" || + payload.registry === null + ) { + return NextResponse.json( + { + code: "INVALID_REQUEST", + message: "expected_revision and registry are required.", + }, + { status: 400, headers: NO_STORE } + ); + } + const body: PutModelRegistryRequest = { + expected_revision: payload.expected_revision, + registry: payload.registry, + ...(Array.isArray(payload.credential_writes) + ? { + credential_writes: + payload.credential_writes as PutModelRegistryRequest["credential_writes"], + } + : {}), + }; + const { body: saved } = await configApiFetch( + actor, + "/api/model-registry", + { method: "PUT", body } + ); + return NextResponse.json(saved, { headers: NO_STORE }); + } catch (error) { + return routeErrorResponse(error); + } +} diff --git a/src/app/api/model-registry/test/route.ts b/src/app/api/model-registry/test/route.ts new file mode 100644 index 0000000..9e7f34b --- /dev/null +++ b/src/app/api/model-registry/test/route.ts @@ -0,0 +1,50 @@ +import { type NextRequest, NextResponse } from "next/server"; +import { requireActor, requireAdmin } from "@/lib/server/actor"; +import { configApiFetch } from "@/lib/server/evoscientistConfigClient"; +import { isCrossOrigin } from "@/lib/server/workspace"; +import { NO_STORE, routeErrorResponse } from "@/lib/server/routeErrors"; +import type { + ProviderTestRequest, + ProviderTestResponse, +} from "@/lib/modelRegistry"; + +export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; + +export async function POST(request: NextRequest) { + try { + if (isCrossOrigin(request)) { + return NextResponse.json( + { code: "FORBIDDEN", message: "Cross-origin access is not allowed." }, + { status: 403, headers: NO_STORE } + ); + } + const actor = requireActor(request); + requireAdmin(actor); + const payload = (await request.json().catch(() => null)) as + | ProviderTestRequest + | null; + if ( + !payload || + typeof payload.expected_registry_revision !== "number" || + typeof payload.model_ref?.provider_id !== "string" || + typeof payload.model_ref?.model_key !== "string" + ) { + return NextResponse.json( + { + code: "INVALID_REQUEST", + message: "expected_registry_revision and model_ref are required.", + }, + { status: 400, headers: NO_STORE } + ); + } + const { body } = await configApiFetch( + actor, + "/api/model-registry/test", + { method: "POST", body: payload } + ); + return NextResponse.json(body, { headers: NO_STORE }); + } catch (error) { + return routeErrorResponse(error); + } +} diff --git a/src/app/api/models/route.ts b/src/app/api/models/route.ts index 80d199f..b866f9c 100644 --- a/src/app/api/models/route.ts +++ b/src/app/api/models/route.ts @@ -1,39 +1,31 @@ -import { NextRequest, NextResponse } from "next/server"; +import { type NextRequest, NextResponse } from "next/server"; +import { requireActor } from "@/lib/server/actor"; +import { configApiFetch } from "@/lib/server/evoscientistConfigClient"; import { isCrossOrigin } from "@/lib/server/workspace"; -import { getActiveDeployment } from "@/lib/server/activeDeployment"; +import { NO_STORE, routeErrorResponse } from "@/lib/server/routeErrors"; +import type { GetSelectableModelsResponse } from "@/lib/modelRegistry"; export const runtime = "nodejs"; +export const dynamic = "force-dynamic"; -function fail(error: unknown, status = 400) { - return NextResponse.json( - { - error: - error instanceof Error - ? error.message - : "Model registry request failed.", - }, - { status } - ); -} - +/** Selectable enabled models for the current user (design doc 9.1). Any + * authenticated user may call this; the backend enforces the model:select + * scope from the delegation JWT. */ export async function GET(request: NextRequest) { try { if (isCrossOrigin(request)) { - return fail("Cross-origin model registry access is not allowed.", 403); + return NextResponse.json( + { code: "FORBIDDEN", message: "Cross-origin access is not allowed." }, + { status: 403, headers: NO_STORE } + ); } - const deployment = await getActiveDeployment(); - const upstream = await fetch(new URL("/api/models", deployment.langgraphApiUrl), { - cache: "no-store", - }); - const body = await upstream.text(); - return new NextResponse(body, { - status: upstream.status, - headers: { - "content-type": - upstream.headers.get("content-type") ?? "application/json", - }, - }); + const actor = requireActor(request); + const { body } = await configApiFetch( + actor, + "/api/models" + ); + return NextResponse.json(body, { headers: NO_STORE }); } catch (error) { - return fail(error); + return routeErrorResponse(error); } } diff --git a/src/app/components/ChatInterface.tsx b/src/app/components/ChatInterface.tsx index 82f226f..fd0039a 100644 --- a/src/app/components/ChatInterface.tsx +++ b/src/app/components/ChatInterface.tsx @@ -29,8 +29,6 @@ import { GripVertical, Ellipsis, ListX, - LoaderCircle, - Star, Gauge, Hand, Zap, @@ -103,12 +101,11 @@ import { WorkspaceFileDialog } from "@/app/components/WorkspaceFileDialog"; import { MemoryFileDialog } from "@/app/components/MemoryFileDialog"; import { FILE_LINK_EVENT, type FileLinkEventDetail } from "@/lib/fileLink"; import { notifyWorkspaceChanged } from "@/lib/workspaceEvents"; -import { parseModelCommand, type ModelOverride } from "@/lib/modelCommand"; +import type { ModelRef } from "@/lib/modelRegistry"; import { - invalidateAvailableModels, + modelRefLabel, useAvailableModels, } from "@/app/hooks/useAvailableModels"; -import { setDefaultModel } from "@/lib/defaultModel"; import { formatTokenCount, useUsage } from "@/app/hooks/useUsage"; import { UsageDetailsDialog } from "@/app/components/UsageDetailsDialog"; @@ -442,16 +439,13 @@ export const ChatInterface = React.memo( const [modelPickerOpen, setModelPickerOpen] = useState(false); const [usageDialogOpen, setUsageDialogOpen] = useState(false); const [modelSearch, setModelSearch] = useState(""); - const [settingDefaultKey, setSettingDefaultKey] = useState( - null - ); // Reset the search box every time the picker opens — stale filter state // surviving across opens would surprise the user. useEffect(() => { if (modelPickerOpen) setModelSearch(""); }, [modelPickerOpen]); const { - registry: modelRegistry, + models: selectableModels, loading: modelRegistryLoading, error: modelRegistryError, } = useAvailableModels(); @@ -460,33 +454,26 @@ export const ChatInterface = React.memo( useEffect(() => { if (modelRegistryUnavailable) { console.warn( - "[model picker] configured model registry did not load", + "[model picker] selectable model list did not load", modelRegistryError ); } }, [modelRegistryError, modelRegistryUnavailable]); - const pickerModels = useMemo( - () => - modelRegistry.entries.map((entry) => ({ - model: entry.name, - model_provider: entry.provider, - })), - [modelRegistry.entries] - ); // Case-insensitive substring filter on name + provider. Fuzzy match was // discussed but punted — substring catches the common "I know roughly // what I want" case and keeps the picker behavior predictable. const filteredPickerModels = useMemo(() => { const q = modelSearch.trim().toLowerCase(); - if (!q) return pickerModels; - return pickerModels.filter((m) => { - const provider = m.model_provider ?? ""; + if (!q) return selectableModels; + return selectableModels.filter((m) => { return ( - m.model.toLowerCase().includes(q) || - provider.toLowerCase().includes(q) + m.name.toLowerCase().includes(q) || + m.provider_name.toLowerCase().includes(q) || + m.model_ref.model_key.toLowerCase().includes(q) || + m.model_ref.provider_id.toLowerCase().includes(q) ); }); - }, [pickerModels, modelSearch]); + }, [selectableModels, modelSearch]); const autoApprovedRef = useRef(null); const autoApproveResumePendingRef = useRef(false); const autoAnsweredAskUserRef = useRef(null); @@ -516,8 +503,8 @@ export const ChatInterface = React.memo( subAgentActivity, asyncTasks, summarizationEvent, - modelOverride, - setModelOverride, + modelSelection, + setModelSelection, } = useChatContext(); const usage = useUsage(threadId); const usageUnavailable = @@ -531,29 +518,6 @@ export const ChatInterface = React.memo( ? "Tokens unavailable" : `${formatTokenCount(usage.summary.total_tokens)} tokens`; - const handleSetDefaultModel = useCallback( - async (model: string, provider: string) => { - const key = `${model}|${provider}`; - setSettingDefaultKey(key); - try { - await setDefaultModel(model, provider); - await setModelOverride({ model, model_provider: provider }); - invalidateAvailableModels(); - toast.success(`Default model set to ${model} (${provider}).`); - setModelPickerOpen(false); - } catch (err) { - toast.error( - err instanceof Error - ? `Couldn't set default model: ${err.message}` - : "Couldn't set default model — try again." - ); - } finally { - setSettingDefaultKey(null); - } - }, - [setModelOverride] - ); - // Count of background async sub-agents (writing / data-analysis) still // running — drives the composer's "agents running" pulse. We poll each task's // REAL run status (via useAsyncAgents) rather than trusting the conversation @@ -741,40 +705,24 @@ export const ChatInterface = React.memo( }, []); // What model will the next turn use? The pill is forward-looking — it - // updates the moment the user changes (or clears) the override, instead - // of lingering on what just ran. Priority: - // 1. Per-thread model override (`/model` command, picker) — the next - // run will use this verbatim. - // 2. The model registry endpoint's reported deployment default — - // what the next run will use when no override is set. - // 3. The assistant's configured default from `assistant.config.configurable`. - // 4. Last AI message's `response_metadata.model_name` — final fallback - // when none of the above are available (older deployment without - // `/api/models`). - // The endpoint's `default` can disagree with what the runtime actually - // boots with; that's a backend honesty problem and tracked separately. + // updates the moment the user changes the thread selection. Priority: + // 1. Explicit per-thread selection (ModelRef picker) — the next run + // freezes exactly this into its runtime snapshot. + // 2. `inherit` — the registry default resolved server-side at snapshot + // creation; the pill shows the last observed model as a hint. // Token/context usage is intentionally NOT shown — the backend doesn't // persist usage_metadata, so it isn't reliably available here. const currentModel = useMemo(() => { - if (modelOverride) { - return formatModel(modelOverride.model, modelOverride.model_provider); - } - if (modelRegistry.defaultEntry) { - return formatModel( - modelRegistry.defaultEntry.name, - modelRegistry.defaultEntry.provider ?? undefined + if (modelSelection !== "inherit") { + const match = selectableModels.find( + (m) => + m.model_ref.provider_id === modelSelection.primary.provider_id && + m.model_ref.model_key === modelSelection.primary.model_key ); - } - const cfg = assistant?.config as - | { configurable?: Record } - | undefined; - const configurable = cfg?.configurable; - if (configurable) { - const info = formatModel( - configurable.model ?? configurable.model_name, - configurable.model_provider - ); - if (info) return info; + return { + name: match?.name ?? modelSelection.primary.model_key, + provider: match?.provider_name || modelSelection.primary.provider_id, + }; } for (let i = messages.length - 1; i >= 0; i--) { const m = messages[i]; @@ -787,12 +735,7 @@ export const ChatInterface = React.memo( if (info) return info; } return null; - }, [ - messages, - modelOverride, - assistant?.config, - modelRegistry.defaultEntry, - ]); + }, [messages, modelSelection, selectableModels]); // Bind captured sub-agent activity (keyed by subgraph namespace) to each task // tool call → its live steps. B': match a finished sub-agent to a task by its @@ -1067,49 +1010,6 @@ export const ChatInterface = React.memo( ); }, []); - // Apply a parsed `/model` command. Three forms: - // - show → open the model picker dialog - // - reset → clear the per-thread override (revert to assistant default) - // - set → persist the new override and confirm via toast. Names that - // aren't in our curated list are still accepted — the backend - // accepts anything `init_chat_model` knows, and we'd rather - // not block a power user on our curation lagging the registry. - const applyModelCommand = useCallback( - async (cmd: ReturnType) => { - if (!cmd) return; - if (cmd.kind === "show") { - setModelPickerOpen(true); - return; - } - // Pre-thread picks are staged in useChat and applied to the first - // run; no threadId guard needed. - try { - if (cmd.kind === "reset") { - await setModelOverride(null); - toast.success("Model override cleared."); - } else { - const next: ModelOverride = { - model: cmd.model, - ...(cmd.provider ? { model_provider: cmd.provider } : {}), - }; - await setModelOverride(next); - toast.success( - `Model set to ${cmd.model}${ - cmd.provider ? ` (${cmd.provider})` : "" - }.` - ); - } - } catch (err) { - toast.error( - err instanceof Error - ? `Couldn't update model: ${err.message}` - : "Couldn't update model — try again." - ); - } - }, - [setModelOverride] - ); - const handleSubmit = useCallback( (e?: FormEvent) => { if (e) { @@ -1117,13 +1017,11 @@ export const ChatInterface = React.memo( } const messageText = input.trim(); if (!messageText) return; - // Intercept `/model` before the agent sees it. The choice is stored on - // the thread and remembered as the starting model for future new chats. - // The textarea clears regardless of outcome so the command echo does - // not linger. - const modelCmd = parseModelCommand(messageText); - if (modelCmd) { - void applyModelCommand(modelCmd); + // Bare `/model` opens the ModelRef picker; the free-string + // `/model ` switching command was removed with the legacy + // model_override mechanism (design doc 7.2). + if (messageText === "/model") { + setModelPickerOpen(true); setInput(""); return; } @@ -1157,7 +1055,6 @@ export const ChatInterface = React.memo( }, [ input, - applyModelCommand, assistant, hasPendingInterrupt, reviewMode, @@ -1651,23 +1548,26 @@ export const ChatInterface = React.memo( Choose model - Saved for this chat and new chats in this browser. + Saved for this chat; the next message freezes it into the + run’s snapshot.
Current:{" "} - {currentModel + {modelSelection !== "inherit" + ? modelRefLabel(modelSelection.primary) + : currentModel ? `${currentModel.name}${ currentModel.provider ? ` (${currentModel.provider})` : "" - }` - : "deployment default"} + } · default` + : "registry default"} {modelRegistryLoading && ( - loading registry… + loading models… )}
{modelRegistryUnavailable && ( @@ -1679,9 +1579,8 @@ export const ChatInterface = React.memo( {"\u26A0"} - The deployment’s configured - /api/models - registry didn’t load + The deployment’s selectable model list didn’t + load {modelRegistryError ? ` (${modelRegistryError})` : ""}.
@@ -1699,19 +1598,16 @@ export const ChatInterface = React.memo(
  • {modelSearch ? `No models match "${modelSearch}".` - : "No models are configured."} + : "No models are enabled."}
  • )} {filteredPickerModels.map((m) => { const isActive = - modelOverride?.model === m.model && - modelOverride?.model_provider === m.model_provider; - const isDefault = - modelRegistry.defaultEntry?.name === m.model && - (modelRegistry.defaultEntry?.provider ?? null) === - (m.model_provider ?? null); - const modelKey = `${m.model}|${m.model_provider ?? ""}`; - const isSettingDefault = settingDefaultKey === modelKey; + modelSelection !== "inherit" && + modelSelection.primary.provider_id === + m.model_ref.provider_id && + modelSelection.primary.model_key === m.model_ref.model_key; + const modelKey = modelRefLabel(m.model_ref); return (
  • ( -
  • ); @@ -1808,18 +1659,18 @@ export const ChatInterface = React.memo( variant="outline" onClick={async () => { try { - await setModelOverride(null); - toast.success("Model override cleared."); + await setModelSelection("inherit"); + toast.success("Model reset to the registry default."); setModelPickerOpen(false); } catch (err) { toast.error( err instanceof Error - ? `Couldn't clear override: ${err.message}` - : "Couldn't clear override — try again." + ? `Couldn't reset model: ${err.message}` + : "Couldn't reset model — try again." ); } }} - disabled={!modelOverride} + disabled={modelSelection === "inherit"} > Reset to default diff --git a/src/app/hooks/useAvailableModels.ts b/src/app/hooks/useAvailableModels.ts index c422ba3..92c2e62 100644 --- a/src/app/hooks/useAvailableModels.ts +++ b/src/app/hooks/useAvailableModels.ts @@ -1,116 +1,95 @@ "use client"; import { useEffect, useState } from "react"; +import type { ModelRef, SelectableModel } from "@/lib/modelRegistry"; -export interface ModelRegistryEntry { - /** Short name as the user types in `/model `. */ - name: string; - /** Provider-specific model id (often equal to `name`). Informational only; - * the WebUI doesn't pass it to the run config. */ - model_id: string; - /** Provider key the backend uses to route the call. */ - provider: string; -} +const EMPTY: SelectableModel[] = []; -export interface ModelRegistry { - entries: ReadonlyArray; - /** Effective default reported by the deployment. This is the persisted pair - * when available, otherwise the first enabled registry model. May be null - * when no model is configured or on older deployments. */ - defaultEntry: { name: string; provider: string | null } | null; -} - -interface RegistryResponse { - entries?: unknown; - default?: unknown; -} - -const EMPTY: ModelRegistry = { entries: [], defaultEntry: null }; - -let cachedRegistry: Promise | null = null; +let cachedModels: Promise | null = null; const MODELS_CHANGED_EVENT = "evoscientist-models-changed"; export function invalidateAvailableModels(): void { - cachedRegistry = null; + cachedModels = null; if (typeof window !== "undefined") { window.dispatchEvent(new Event(MODELS_CHANGED_EVENT)); } } -function fetchRegistry(): Promise { - if (cachedRegistry) return cachedRegistry; +function isModelRef(value: unknown): value is ModelRef { + if (!value || typeof value !== "object") return false; + const ref = value as { provider_id?: unknown; model_key?: unknown }; + return ( + typeof ref.provider_id === "string" && + ref.provider_id.length > 0 && + typeof ref.model_key === "string" && + ref.model_key.length > 0 + ); +} - const fetchJson = async (url: string): Promise => { - const r = await fetch(url); - if (!r.ok) throw new Error(`HTTP ${r.status}`); - return (await r.json()) as RegistryResponse; +function parseSelectableModel(raw: unknown): SelectableModel | null { + if (!raw || typeof raw !== "object") return null; + const entry = raw as { + model_ref?: unknown; + name?: unknown; + provider_name?: unknown; + effective_capabilities?: unknown; }; + if (!isModelRef(entry.model_ref) || typeof entry.name !== "string") { + return null; + } + const caps = entry.effective_capabilities as + | { tools?: unknown; vision?: unknown; structured_output?: unknown } + | undefined; + return { + model_ref: { + provider_id: entry.model_ref.provider_id, + model_key: entry.model_ref.model_key, + }, + name: entry.name, + provider_name: + typeof entry.provider_name === "string" ? entry.provider_name : "", + effective_capabilities: { + tools: caps?.tools === true, + vision: caps?.vision === true, + structured_output: caps?.structured_output === true, + }, + }; +} - const pending = fetchJson("/api/models") - .then(async (r) => { - const entries: ModelRegistryEntry[] = []; - if (Array.isArray(r.entries)) { - for (const raw of r.entries) { - if (!raw || typeof raw !== "object") continue; - const e = raw as { - name?: unknown; - model_id?: unknown; - provider?: unknown; - }; - if ( - typeof e.name === "string" && - typeof e.provider === "string" && - e.name && - e.provider - ) { - entries.push({ - name: e.name, - model_id: typeof e.model_id === "string" ? e.model_id : e.name, - provider: e.provider, - }); - } - } +function fetchSelectableModels(): Promise { + if (cachedModels) return cachedModels; + + const pending = fetch("/api/models") + .then(async (response) => { + if (!response.ok) throw new Error(`HTTP ${response.status}`); + const body = (await response.json()) as { models?: unknown }; + if (!Array.isArray(body.models)) return EMPTY; + const models: SelectableModel[] = []; + for (const raw of body.models) { + const parsed = parseSelectableModel(raw); + if (parsed) models.push(parsed); } - let defaultEntry: ModelRegistry["defaultEntry"] = null; - if (r.default && typeof r.default === "object") { - const d = r.default as { name?: unknown; provider?: unknown }; - if (typeof d.name === "string" && d.name) { - defaultEntry = { - name: d.name, - provider: - typeof d.provider === "string" && d.provider ? d.provider : null, - }; - } - } - return { entries, defaultEntry } as ModelRegistry; + return models; }) - .catch((err: unknown) => { - cachedRegistry = null; - throw err; + .catch((error: unknown) => { + cachedModels = null; + throw error; }); - cachedRegistry = pending; + cachedModels = pending; return pending; } -/** - * Fetch the backend's authoritative model registry through the WebUI's - * same-origin `/api/models` proxy first, falling back to - * the same-origin model registry endpoint. Results - * are cached at module level — the registry is static between deployment - * restarts, so remounting ChatInterface never triggers a redundant network - * request. - * - * Failures are non-fatal but do not expose a hard-coded fallback list: the - * picker must only display models returned by the deployment configuration. - * Failed fetches are evicted from the cache so the next mount retries. - */ +/** Enabled-and-verified models the current user may select (design doc 9.1). + * Results are cached at module level; `invalidateAvailableModels` forces a + * refetch after registry changes. Failed fetches are evicted so the next + * mount retries. There is no hard-coded fallback list. */ export function useAvailableModels(): { - registry: ModelRegistry; + models: SelectableModel[]; loading: boolean; error: string | null; } { - const [registry, setRegistry] = useState(EMPTY); + const [models, setModels] = useState(EMPTY); const [loading, setLoading] = useState(true); const [error, setError] = useState(null); const [refreshRevision, setRefreshRevision] = useState(0); @@ -125,16 +104,16 @@ export function useAvailableModels(): { let cancelled = false; setLoading(true); setError(null); - fetchRegistry() + fetchSelectableModels() .then((result) => { if (cancelled) return; - setRegistry(result); + setModels(result); setError(null); }) .catch((err: unknown) => { if (cancelled) return; setError(err instanceof Error ? err.message : "Failed to load models."); - setRegistry(EMPTY); + setModels(EMPTY); }) .finally(() => { if (!cancelled) setLoading(false); @@ -145,5 +124,9 @@ export function useAvailableModels(): { }; }, [refreshRevision]); - return { registry, loading, error }; + return { models, loading, error }; +} + +export function modelRefLabel(ref: ModelRef): string { + return `${ref.provider_id}/${ref.model_key}`; } diff --git a/src/app/hooks/useChat.ts b/src/app/hooks/useChat.ts index 044c9da..e37c959 100644 --- a/src/app/hooks/useChat.ts +++ b/src/app/hooks/useChat.ts @@ -8,15 +8,8 @@ import { useQueryState } from "nuqs"; import { parseSummarizationEvent } from "@/lib/summarization"; import { findActiveTurnId } from "@/lib/usageTurn"; import { toast } from "sonner"; -import { - MODEL_OVERRIDE_METADATA_KEY, - type ModelOverride, -} from "@/lib/modelCommand"; -import { - getNewChatModelPreference, - setNewChatModelPreference, -} from "@/lib/modelPreference"; -import { setThreadModelOverride } from "@/app/hooks/useThreads"; +import type { ModelRef, ThreadModelSelection } from "@/lib/modelRegistry"; +import { setThreadModelSelection } from "@/app/hooks/useThreads"; import { clearRunCursor, getRunStreamCheckpoint, @@ -149,6 +142,54 @@ function hasActionableInterrupt(i: unknown): boolean { ); } +function isModelRefShape(value: unknown): value is ModelRef { + if (!value || typeof value !== "object") return false; + const ref = value as { provider_id?: unknown; model_key?: unknown }; + return ( + typeof ref.provider_id === "string" && typeof ref.model_key === "string" + ); +} + +/** Client-side mirror of the thread metadata `model_selection` reader + * (design doc 7.2). Malformed payloads degrade to `inherit` for display; the + * BFF remains authoritative when the run snapshot is created. */ +function readSelectionFromMetadata(metadata: Record | undefined): { + selection: ThreadModelSelection; + revision: number; +} { + const source = metadata ?? {}; + const rawRevision = source.model_selection_revision; + const revision = + typeof rawRevision === "number" && + Number.isInteger(rawRevision) && + rawRevision >= 0 + ? rawRevision + : 0; + const raw = source.model_selection; + if (raw === undefined || raw === "inherit") { + return { selection: "inherit", revision }; + } + if (raw && typeof raw === "object") { + const candidate = raw as { primary?: unknown; auxiliary?: unknown }; + if ( + isModelRefShape(candidate.primary) && + (candidate.auxiliary === null || candidate.auxiliary === undefined || + isModelRefShape(candidate.auxiliary)) + ) { + return { + selection: { + primary: candidate.primary, + auxiliary: isModelRefShape(candidate.auxiliary) + ? candidate.auxiliary + : null, + }, + revision, + }; + } + } + return { selection: "inherit", revision }; +} + function latestTaskInterrupt( tasks: Array<{ interrupts?: unknown[] }> | undefined ): unknown { @@ -295,83 +336,69 @@ export function useChat({ fetchedThreadIdRef.current = fetchedThreadId; const recoveryRunRef = useRef(0); - // Per-thread model override. When set, gets folded into - // `configurable.model` on every `stream.submit` — the backend's - // `configurable_model` middleware - // (EvoScientist/middleware/configurable_model.py) is what actually swaps - // the chat model per request. + // Per-thread model selection (design doc 7.2). The selection lives on the + // thread metadata (`model_selection` + `model_selection_revision`) and is + // written exclusively through the PATCH CAS endpoint; each new run freezes + // it into a runtime snapshot server-side. // - // The persistence dance gets a wrinkle for fresh chats: the thread row - // doesn't exist server-side until the first `stream.submit` creates it, - // so we can't write `model_override` into thread metadata yet. We stash - // any pre-thread pick in `pendingOverrideRef`, fold it into the first - // run's config via `buildRunConfig`, and write it through to metadata - // when `threadId` actually shows up. Without this, the user's first - // message goes to the deployment default even after they picked a model - // from the empty composer. - // localStorage is unavailable during SSR. Load the new-chat preference in - // the effect below so server and first client render stay identical. - const [modelOverride, setModelOverrideState] = useState( - null - ); - const pendingOverrideRef = useRef(null); + // Fresh-chat wrinkle: the thread row doesn't exist server-side until the + // first message creates it, so a pre-thread pick is stashed in + // `pendingSelectionRef` and written through with + // `expected_selection_revision=0` once the thread id appears. + const [modelSelection, setModelSelectionState] = + useState("inherit"); + const [selectionRevision, setSelectionRevision] = useState(0); + const pendingSelectionRef = useRef(null); const createdThreadIdRef = useRef(null); const ensureThreadPromiseRef = useRef | null>(null); useEffect(() => { if (!threadId) { - const remembered = getNewChatModelPreference(); - pendingOverrideRef.current = remembered; createdThreadIdRef.current = null; - setModelOverrideState(remembered); + setModelSelectionState(pendingSelectionRef.current ?? "inherit"); + setSelectionRevision(0); return; } // Thread just came into existence (or we switched onto an existing one). - // If we have a pending pre-thread override, write it through to metadata - // and keep the local state as-is. Otherwise fetch the thread's persisted - // override and seed local state from it. - if (createdThreadIdRef.current === threadId && pendingOverrideRef.current) { - const pending = pendingOverrideRef.current; - pendingOverrideRef.current = null; + // If we have a pending pre-thread pick, write it through to metadata with + // the initial revision; otherwise fetch the thread's persisted selection + // and seed local state from it. + if ( + createdThreadIdRef.current === threadId && + pendingSelectionRef.current + ) { + const pending = pendingSelectionRef.current; + pendingSelectionRef.current = null; createdThreadIdRef.current = null; void (async () => { try { - await setThreadModelOverride(threadId, pending); + await setThreadModelSelection(threadId, pending, 0); + setModelSelectionState(pending); + setSelectionRevision(1); } catch { - // The local state still reflects the pick; the next `setModelOverride` - // call (or thread reopen) gets another chance to persist it. + // The local state still reflects the pick; the next + // `setModelSelection` call (or thread reopen) resyncs from metadata. } })(); return; } - // Opening an existing thread from the New Chat screen must not write the - // remembered new-chat preference over that thread's own metadata. - pendingOverrideRef.current = null; + // Opening an existing thread from the New Chat screen must not write a + // staged pick over that thread's own selection. + pendingSelectionRef.current = null; createdThreadIdRef.current = null; let cancelled = false; void (async () => { try { const { thread: t } = await getConversation(threadId); if (cancelled) return; - const raw = (t.metadata ?? {})[MODEL_OVERRIDE_METADATA_KEY]; - if ( - raw && - typeof raw === "object" && - typeof (raw as { model?: unknown }).model === "string" - ) { - const r = raw as { model: string; model_provider?: unknown }; - setModelOverrideState({ - model: r.model, - model_provider: - typeof r.model_provider === "string" - ? r.model_provider - : undefined, - }); - } else { - setModelOverrideState(null); - } + const stored = readSelectionFromMetadata( + (t.metadata ?? {}) as Record + ); + setModelSelectionState(stored.selection); + setSelectionRevision(stored.revision); } catch (error) { if (cancelled) return; - setModelOverrideState(null); + setModelSelectionState("inherit"); + setSelectionRevision(0); if (error instanceof ConversationApiError && error.status === 404) { activeRunRef.current = null; setRunConnection(null); @@ -387,23 +414,44 @@ export function useChat({ }; }, [setThreadId, threadId]); - // Persist + apply locally. When the thread row exists, writes metadata - // first so a reload keeps the choice. Pre-thread (new chat with no - // threadId yet), stashes the override in a ref so the next send picks it - // up via `buildRunConfig` and the thread-id effect can persist it as soon - // as the row is created server-side. - const setModelOverride = useCallback( - async (next: ModelOverride | null) => { - setModelOverrideState(next); - setNewChatModelPreference(next); + // Persist + apply locally. Pre-thread (new chat with no threadId yet), + // stashes the pick in a ref so the thread-id effect can persist it as soon + // as the row is created server-side. Existing threads go through the CAS + // endpoint; a revision conflict refetches the current selection so the UI + // never diverges from the stored one. + const setModelSelection = useCallback( + async (next: ThreadModelSelection) => { if (!threadId) { - pendingOverrideRef.current = next; + pendingSelectionRef.current = next === "inherit" ? null : next; + setModelSelectionState(next); + setSelectionRevision(0); return; } - pendingOverrideRef.current = null; - await setThreadModelOverride(threadId, next); + pendingSelectionRef.current = null; + try { + await setThreadModelSelection(threadId, next, selectionRevision); + setModelSelectionState(next); + setSelectionRevision((revision) => revision + 1); + } catch (error) { + if ( + error instanceof ConversationApiError && + error.code === "THREAD_MODEL_SELECTION_CONFLICT" + ) { + try { + const { thread: t } = await getConversation(threadId); + const stored = readSelectionFromMetadata( + (t.metadata ?? {}) as Record + ); + setModelSelectionState(stored.selection); + setSelectionRevision(stored.revision); + } catch { + // The next thread load resyncs. + } + } + throw error; + } }, - [threadId] + [threadId, selectionRevision] ); const liveMessages = @@ -947,7 +995,6 @@ export function useChat({ input, command, review_mode: reviewMode, - model_override: modelOverride, }); const tracked: TrackedRun = { threadId: usableThreadId, @@ -1009,7 +1056,7 @@ export function useChat({ setIsSubmitting(false); } }, - [ensureThread, modelOverride, showError] + [ensureThread, showError] ); const sendMessage = useCallback( @@ -1117,7 +1164,7 @@ export function useChat({ stopStream, resumeInterrupt, subAgentActivity: EMPTY_SUB_AGENT_ACTIVITY, - modelOverride, - setModelOverride, + modelSelection, + setModelSelection, }; } diff --git a/src/app/hooks/useThreads.ts b/src/app/hooks/useThreads.ts index 8c38e7b..958365e 100644 --- a/src/app/hooks/useThreads.ts +++ b/src/app/hooks/useThreads.ts @@ -1,5 +1,6 @@ import useSWRInfinite from "swr/infinite"; import { patchConversation } from "@/lib/conversationApi"; +import type { ThreadModelSelection } from "@/lib/modelRegistry"; export interface ThreadItem { id: string; @@ -148,11 +149,18 @@ export async function pinThread(id: string, pinned: boolean): Promise { await patchConversation(id, { pinned }); } -export async function setThreadModelOverride( +/** CAS write of the thread's model selection (design doc 7.2). Throws + * `ConversationApiError` with code THREAD_MODEL_SELECTION_CONFLICT on a + * revision mismatch. */ +export async function setThreadModelSelection( id: string, - override: { model: string; model_provider?: string } | null + selection: ThreadModelSelection, + expectedRevision: number ): Promise { - await patchConversation(id, { model_override: override }); + await patchConversation(id, { + model_selection: selection, + expected_selection_revision: expectedRevision, + }); } function slugifyForFilename(input: string): string { diff --git a/src/lib/defaultModel.ts b/src/lib/defaultModel.ts deleted file mode 100644 index 655467d..0000000 --- a/src/lib/defaultModel.ts +++ /dev/null @@ -1,37 +0,0 @@ -interface DefaultModelResponse { - default?: { - name?: unknown; - provider?: unknown; - }; - error?: unknown; -} - -export async function setDefaultModel( - model: string, - provider: string -): Promise { - const response = await fetch( - "/api/default-model", - { - method: "PUT", - headers: { "Content-Type": "application/json" }, - body: JSON.stringify({ model, provider }), - } - ); - const payload = (await response - .json() - .catch(() => ({}))) as DefaultModelResponse; - if (!response.ok) { - throw new Error( - typeof payload.error === "string" - ? payload.error - : `Default model request failed with HTTP ${response.status}.` - ); - } - if ( - payload.default?.name !== model || - payload.default?.provider !== provider - ) { - throw new Error("The backend did not confirm the requested default model."); - } -} diff --git a/src/lib/modelCommand.ts b/src/lib/modelCommand.ts deleted file mode 100644 index ecb3565..0000000 --- a/src/lib/modelCommand.ts +++ /dev/null @@ -1,83 +0,0 @@ -// `/model` command for the chat composer. -// -// The actual model switching is handled server-side by the backend's -// `EvoScientist/middleware/configurable_model.py` middleware, which reads -// `model` / `model_provider` from each run's `RunnableConfig.configurable`. -// We just need to inject those fields into `stream.submit({ config: ... })` -// and persist the choice on the thread. A separate browser preference seeds -// future new chats without changing the deployment-wide default. -// -// Listing available models: the backend's authoritative registry lives in -// `EvoScientist/llm/models.py` and is exposed at `GET /api/models` (mounted -// via langgraph.json). `useAvailableModels` fetches that endpoint at runtime; -// The picker intentionally has no hard-coded fallback: only entries returned -// by the deployment configuration are shown. The command parser still passes -// an explicitly typed model through for backward compatibility. - -/** Thread metadata key carrying the per-thread model override. The LangGraph - * thread record remains authoritative for existing conversations, so their - * model survives reloads, thread switches, and cross-device opens. */ -export const MODEL_OVERRIDE_METADATA_KEY = "model_override"; - -export interface ModelOverride { - /** Short name as used by the backend's `MODELS` registry, e.g. - * "claude-sonnet-4-6" or "deepseek-v4-flash". */ - model: string; - /** Provider routing hint. Optional — when omitted the backend uses the - * default provider for that short name. */ - model_provider?: string; -} - -export interface CommonModelEntry extends ModelOverride { - /** Human-readable label for the picker. Falls back to `model` when absent. */ - label?: string; -} - -/** - * Seed list for the `/model` picker. Not exhaustive — the backend's - * `EvoScientist/llm/models.py` has the full registry. This list is the - * "I want to switch fast, don't make me look it up" subset; users can still - * type any name the backend knows via `/model [provider]`. - */ -export const COMMON_MODELS: ReadonlyArray = [ - { model: "claude-sonnet-4-6", model_provider: "anthropic" }, - { model: "claude-haiku-4-5", model_provider: "anthropic" }, - { model: "claude-opus-4-8", model_provider: "anthropic" }, - { model: "gpt-5.5-pro", model_provider: "openai" }, - { model: "gpt-5.5", model_provider: "openai" }, - { model: "gpt-5-mini", model_provider: "openai" }, - { model: "gemini-2.5-pro", model_provider: "google-genai" }, - { model: "gemini-3.5-flash", model_provider: "google-genai" }, - { model: "deepseek-v3.2", model_provider: "deepseek" }, -]; - -export type ModelCommand = - | { kind: "show" } - | { kind: "reset" } - | { kind: "set"; model: string; provider?: string }; - -/** - * Parse a chat-composer input as a `/model` command. - * - * Recognised forms: - * - `/model` → kind: "show" (open the picker) - * - `/model reset` → kind: "reset" (clear thread override) - * - `/model ` → kind: "set", model= - * - `/model `→ kind: "set", model=, provider= - * - * Returns `null` for anything else, including a string that starts with - * `/model` but has more than 2 args — we'd rather let the agent see a - * misformatted command than guess. Trailing whitespace is tolerated. - */ -export function parseModelCommand(input: string): ModelCommand | null { - const trimmed = input.trim(); - if (trimmed !== "/model" && !trimmed.startsWith("/model ")) return null; - const rest = trimmed.slice("/model".length).trim(); - if (!rest) return { kind: "show" }; - const parts = rest.split(/\s+/); - if (parts[0].toLowerCase() === "reset" && parts.length === 1) { - return { kind: "reset" }; - } - if (parts.length > 2) return null; - return { kind: "set", model: parts[0], provider: parts[1] }; -} diff --git a/src/lib/modelPreference.test.ts b/src/lib/modelPreference.test.ts deleted file mode 100644 index 95c3c08..0000000 --- a/src/lib/modelPreference.test.ts +++ /dev/null @@ -1,60 +0,0 @@ -import { describe, expect, it } from "vitest"; -import { - MODEL_PREFERENCE_STORAGE_KEY, - getNewChatModelPreference, - parseModelPreference, - setNewChatModelPreference, - type ModelPreferenceStorage, -} from "./modelPreference"; - -function memoryStorage(initial: Record = {}) { - const values = new Map(Object.entries(initial)); - const storage: ModelPreferenceStorage = { - getItem: (key) => values.get(key) ?? null, - setItem: (key, value) => void values.set(key, value), - removeItem: (key) => void values.delete(key), - }; - return { storage, values }; -} - -describe("new-chat model preference", () => { - it("normalizes a valid model and provider", () => { - expect( - parseModelPreference({ model: " gpt-5 ", model_provider: " openai " }) - ).toEqual({ model: "gpt-5", model_provider: "openai" }); - expect(parseModelPreference({ model: "claude-sonnet" })).toEqual({ - model: "claude-sonnet", - }); - }); - - it("rejects malformed preferences", () => { - expect(parseModelPreference(null)).toBeNull(); - expect(parseModelPreference({ model: "" })).toBeNull(); - expect( - parseModelPreference({ model: "gpt-5", model_provider: 42 }) - ).toBeNull(); - }); - - it("persists the last selection and clears it on reset", () => { - const { storage, values } = memoryStorage(); - setNewChatModelPreference( - { model: "gpt-5", model_provider: "openai" }, - storage - ); - expect(getNewChatModelPreference(storage)).toEqual({ - model: "gpt-5", - model_provider: "openai", - }); - - setNewChatModelPreference(null, storage); - expect(values.has(MODEL_PREFERENCE_STORAGE_KEY)).toBe(false); - expect(getNewChatModelPreference(storage)).toBeNull(); - }); - - it("fails closed when stored JSON is corrupt", () => { - const { storage } = memoryStorage({ - [MODEL_PREFERENCE_STORAGE_KEY]: "{not-json", - }); - expect(getNewChatModelPreference(storage)).toBeNull(); - }); -}); diff --git a/src/lib/modelPreference.ts b/src/lib/modelPreference.ts deleted file mode 100644 index e71a1f7..0000000 --- a/src/lib/modelPreference.ts +++ /dev/null @@ -1,67 +0,0 @@ -import type { ModelOverride } from "@/lib/modelCommand"; - -export type ModelPreferenceStorage = Pick< - Storage, - "getItem" | "setItem" | "removeItem" ->; - -export const MODEL_PREFERENCE_STORAGE_KEY = - "evoscientist-new-chat-model-preference"; - -function browserStorage(): ModelPreferenceStorage | null { - if (typeof window === "undefined") return null; - try { - return window.localStorage; - } catch { - return null; - } -} - -export function parseModelPreference(value: unknown): ModelOverride | null { - if (!value || typeof value !== "object") return null; - const raw = value as { model?: unknown; model_provider?: unknown }; - if (typeof raw.model !== "string" || !raw.model.trim()) return null; - if ( - raw.model_provider !== undefined && - (typeof raw.model_provider !== "string" || !raw.model_provider.trim()) - ) { - return null; - } - return { - model: raw.model.trim(), - ...(typeof raw.model_provider === "string" - ? { model_provider: raw.model_provider.trim() } - : {}), - }; -} - -export function getNewChatModelPreference( - storage: ModelPreferenceStorage | null = browserStorage() -): ModelOverride | null { - if (!storage) return null; - try { - const raw = storage.getItem(MODEL_PREFERENCE_STORAGE_KEY); - if (!raw) return null; - return parseModelPreference(JSON.parse(raw)); - } catch { - return null; - } -} - -export function setNewChatModelPreference( - preference: ModelOverride | null, - storage: ModelPreferenceStorage | null = browserStorage() -): void { - if (!storage) return; - try { - if (!preference) { - storage.removeItem(MODEL_PREFERENCE_STORAGE_KEY); - return; - } - const parsed = parseModelPreference(preference); - if (!parsed) return; - storage.setItem(MODEL_PREFERENCE_STORAGE_KEY, JSON.stringify(parsed)); - } catch { - // Browser storage is a convenience. Chat must still work when it is blocked. - } -} diff --git a/src/lib/modelRegistry.ts b/src/lib/modelRegistry.ts new file mode 100644 index 0000000..4b6abbf --- /dev/null +++ b/src/lib/modelRegistry.ts @@ -0,0 +1,204 @@ +/** + * WebUI mirror of the EvoScientist model-registry contract. These types are + * derived from the backend's exported OpenAPI document + * (`EvoScientist/model_registry/openapi.json`, design doc sections 4.3, 6.2, + * 9.x) — the backend remains the only authority; do not add frontend-only + * fields here. + */ + +export interface ModelRef { + provider_id: string; + model_key: string; +} + +export type AuthMode = "none" | "api_key" | "bearer" | "adapter_managed"; + +export interface AuthConfig { + mode: AuthMode; + credential_id: string | null; +} + +export interface ProviderRuntimeConfig { + timeout_seconds: number; + max_retries: number; + default_temperature: number | null; + default_top_p: number | null; + default_reasoning_effort: ReasoningEffort; +} + +export type ReasoningEffort = "auto" | "low" | "medium" | "high"; + +export interface Capabilities { + tools: boolean; + vision: boolean; + structured_output: boolean; +} + +export interface ModelRuntimeConfig { + limit_mode: "combined" | "input_only"; + context_window_tokens: number | null; + max_input_tokens: number | null; + max_output_tokens: number; + min_effective_input_tokens: number; + fixed_system_reserve_tokens: number; + fixed_tools_reserve_tokens: number; + fixed_attachments_reserve_tokens: number; + limits_status: "confirmed" | "needs_confirmation"; + limits_source: "provider" | "tested_contract" | "user"; + temperature: number | null; + top_p: number | null; + reasoning_effort: ReasoningEffort; + declared_capabilities: Capabilities; +} + +export interface ModelConfig { + key: string; + name: string; + upstream_model_id: string; + enabled: boolean; + runtime: ModelRuntimeConfig; +} + +export interface ProviderConfig { + id: string; + name: string; + adapter: string; + base_url: string; + auth: AuthConfig; + enabled: boolean; + runtime: ProviderRuntimeConfig; + models: ModelConfig[]; +} + +export interface RegistryDefaults { + primary: ModelRef | null; + auxiliary: ModelRef | null; +} + +export interface RegistryV4 { + version: 4; + revision: number; + state: "bootstrap" | "active"; + defaults: RegistryDefaults; + providers: ProviderConfig[]; +} + +export interface AuthSpec { + credential_required: boolean; + credential_kind: "api_key" | "bearer_token" | "adapter_managed" | "none"; + target: string; + target_name: string | null; +} + +export interface ParameterRule { + supported: boolean; + value_type: "integer" | "number" | "enum"; + nullable: "inherit" | "omit" | "forbidden"; + minimum?: number | null; + maximum?: number | null; + enum_values?: string[] | null; + target: string; + target_name: string; + conflicts_with: string[]; + normalizer: string; +} + +export interface AdapterParameterSpec { + adapter_id: string; + spec_revision: number; + model_selector: string; + auth_specs: Partial>; + parameters: Record; + protocol_capabilities: Capabilities; +} + +export interface CredentialStatus { + credential_id: string; + configured: boolean; + hint: string | null; + updated_at: string | null; +} + +export type ModelAvailabilityState = + | "unavailable" + | "configured" + | "verification_failed" + | "verification_stale" + | "verified" + | "enabled"; + +export interface ModelAvailability { + model_ref: ModelRef; + state: ModelAvailabilityState; + selectable: boolean; + reason_code: string | null; + verification: { + status: "none" | "passed" | "failed" | "stale"; + verified_at?: string | null; + adapter_spec_revision?: number | null; + }; + effective_capabilities: Capabilities; +} + +export interface EndpointPolicyPublic { + public_https_allowed: true; + development_endpoints: Array<{ id: string; url: string; label: string }>; +} + +export interface GetModelRegistryResponse { + revision: number; + registry: RegistryV4; + adapter_specs: AdapterParameterSpec[]; + credential_status: CredentialStatus[]; + model_status: ModelAvailability[]; + endpoint_policy: EndpointPolicyPublic; +} + +export interface CredentialWrite { + credential_id: string; + operation: "replace"; + secret_value: string; +} + +export interface PutModelRegistryRequest { + expected_revision: number; + registry: RegistryV4; + credential_writes?: CredentialWrite[]; +} + +export interface ProviderTestRequest { + expected_registry_revision: number; + model_ref: ModelRef; +} + +export interface ProviderTestResponse { + ok: boolean; + registry_revision: number; + model_ref: ModelRef; + adapter_spec_revision: number; + effective_request_options: Record; + model_status: ModelAvailability; + latency_ms: number; +} + +export interface SelectableModel { + model_ref: ModelRef; + name: string; + provider_name: string; + effective_capabilities: Capabilities; +} + +export interface GetSelectableModelsResponse { + models: SelectableModel[]; +} + +/** ThreadModelSelection (design doc 7.2). */ +export type ThreadModelSelection = + | "inherit" + | { primary: ModelRef; auxiliary: ModelRef | null }; + +export interface RegistryApiError { + code?: string; + message?: string; + details?: Array<{ path?: string; code?: string }>; +} diff --git a/src/lib/server/actor.ts b/src/lib/server/actor.ts new file mode 100644 index 0000000..e23e157 --- /dev/null +++ b/src/lib/server/actor.ts @@ -0,0 +1,50 @@ +import "server-only"; + +import type { NextRequest } from "next/server"; +import { AUTH_COOKIE_NAME, isAuthenticationEnabled } from "@/lib/auth"; +import { decodeSessionPayload, roleForUsername } from "./auth"; +import { ensureBootstrapAdmin, type UserRole } from "./userStore"; + +export interface Actor { + sub: string; + role: UserRole; +} + +export class ActorError extends Error { + constructor( + message: string, + readonly status: 401 | 403 = 401 + ) { + super(message); + } +} + +/** + * Resolve the end-user actor for a BFF request. When WebUI authentication is + * disabled (single-user local deployments), every request acts as the + * built-in local admin — the loopback-only posture is enforced by the + * callers that need it. + */ +export function requireActor(request: NextRequest): Actor { + if (!isAuthenticationEnabled()) { + return { sub: "local-admin", role: "admin" }; + } + const session = decodeSessionPayload( + request.cookies.get(AUTH_COOKIE_NAME)?.value ?? "" + ); + if (!session || session.expiresAt <= Math.floor(Date.now() / 1000)) { + throw new ActorError("Authentication required.", 401); + } + ensureBootstrapAdmin(); + const role = roleForUsername(session.username); + if (!role) { + throw new ActorError("Authentication required.", 401); + } + return { sub: session.username, role }; +} + +export function requireAdmin(actor: Actor): void { + if (actor.role !== "admin") { + throw new ActorError("Model configuration requires an admin account.", 403); + } +} diff --git a/src/lib/server/auth.ts b/src/lib/server/auth.ts index 2d5c011..f57e5ca 100644 --- a/src/lib/server/auth.ts +++ b/src/lib/server/auth.ts @@ -1,27 +1,27 @@ -import { - createHmac, - randomBytes, - randomUUID, - timingSafeEqual, -} from "crypto"; +import { createHmac, timingSafeEqual } from "crypto"; import { promises as fs } from "fs"; -import { homedir } from "os"; -import { join, resolve } from "path"; +import { randomUUID } from "node:crypto"; +import { join } from "path"; import { AUTH_COOKIE_NAME, authSecret, isAuthenticationEnabled, sessionTtlSeconds, } from "@/lib/auth"; - -interface AuthConfiguration { - username: string; - password: string; - secret: string; -} +import { webuiDataDir } from "./dataDir"; +import { + ensureBootstrapAdmin, + getUser, + setUserPassword, + verifyUserPassword, + UserStoreError, + type UserRole, + type WebuiUser, +} from "./userStore"; interface SessionPayload { username: string; + role: UserRole; loggedInAt: string; expiresAt: number; } @@ -34,24 +34,41 @@ interface LoginAudit { export class AuthConfigurationError extends Error {} -export function getAuthConfiguration(): AuthConfiguration { +function requireSecret(): string { if (!isAuthenticationEnabled()) { throw new AuthConfigurationError("WebUI authentication is disabled."); } - const username = process.env.WEBUI_AUTH_USERNAME?.trim(); - const password = process.env.WEBUI_AUTH_PASSWORD; const secret = authSecret(); - if (!username || !password || !secret) { - throw new AuthConfigurationError( - "Set WEBUI_AUTH_USERNAME, WEBUI_AUTH_PASSWORD, and WEBUI_AUTH_SECRET." - ); + if (!secret) { + throw new AuthConfigurationError("Set WEBUI_AUTH_SECRET."); } if (secret.length < 32) { throw new AuthConfigurationError( "WEBUI_AUTH_SECRET must contain at least 32 characters." ); } - return { username, password, secret }; + return secret; +} + +export function verifyCredentials( + username: string, + password: string +): WebuiUser | null { + requireSecret(); + try { + ensureBootstrapAdmin(); + } catch (error) { + throw new AuthConfigurationError( + error instanceof Error ? error.message : "WebUI user store is not initialized." + ); + } + return verifyUserPassword(username, password); +} + +/** Resolve the current role for a session username (authoritative source is + * the user store, so role changes apply without re-login). */ +export function roleForUsername(username: string): UserRole | null { + return getUser(username)?.role ?? null; } function constantTimeEqual(left: string, right: string): boolean { @@ -61,59 +78,25 @@ function constantTimeEqual(left: string, right: string): boolean { return timingSafeEqual(leftBuffer, rightBuffer); } -export function verifyCredentials(username: string, password: string): boolean { - const config = getAuthConfiguration(); - return ( - constantTimeEqual(username, config.username) && - constantTimeEqual(password, config.password) - ); -} - -function envFilePath(): string { - return join(process.cwd(), ".env"); -} - -function replaceEnvValue(source: string, key: string, value: string): string { - const expression = new RegExp(`^${key}=.*$`, "m"); - if (!expression.test(source)) { - throw new AuthConfigurationError(`${key} is missing from .env.`); - } - return source.replace(expression, `${key}=${JSON.stringify(value)}`); -} - /** - * Persist the new password and rotate the signing key. Rotating the key makes - * every old session invalid; the caller immediately issues a replacement cookie - * to the account that successfully supplied the current password. + * Persist the new password in the user store and rotate the signing key when + * the local .env is writable. Rotating the key invalidates every other + * session; the caller immediately issues a replacement cookie to the account + * that successfully supplied the current password. */ -export async function updateAuthPassword(password: string): Promise { - getAuthConfiguration(); - const target = envFilePath(); - let stat; +export async function updateAuthPassword( + username: string, + password: string +): Promise { + requireSecret(); try { - stat = await fs.lstat(target); - } catch { - throw new AuthConfigurationError("The local .env file is not available."); + setUserPassword(username, password); + } catch (error) { + if (error instanceof UserStoreError) { + throw new AuthConfigurationError(error.message); + } + throw error; } - if (!stat.isFile() || stat.isSymbolicLink()) { - throw new AuthConfigurationError("The local .env file is not writable."); - } - - const source = await fs.readFile(target, "utf8"); - const nextSecret = randomBytes(32).toString("hex"); - const next = replaceEnvValue( - replaceEnvValue(source, "WEBUI_AUTH_PASSWORD", password), - "WEBUI_AUTH_SECRET", - nextSecret - ); - const temp = `${target}.${randomUUID()}.tmp`; - await fs.writeFile(temp, next, { encoding: "utf8", mode: 0o600 }); - await fs.rename(temp, target); - - // Next reloads .env on restart; update this process too so the new password - // and replacement session work immediately without waiting for a restart. - process.env.WEBUI_AUTH_PASSWORD = password; - process.env.WEBUI_AUTH_SECRET = nextSecret; } function encode(value: string): string { @@ -132,14 +115,18 @@ function sign(payload: string, secret: string): string { return createHmac("sha256", secret).update(payload).digest("base64url"); } -export function createSession(username: string): { +export function createSession( + username: string, + role: UserRole +): { token: string; payload: SessionPayload; } { - const { secret } = getAuthConfiguration(); + const secret = requireSecret(); const now = new Date(); const payload: SessionPayload = { username, + role, loggedInAt: now.toISOString(), expiresAt: Math.floor(now.getTime() / 1000) + sessionTtlSeconds(), }; @@ -147,21 +134,13 @@ export function createSession(username: string): { return { token: `${encoded}.${sign(encoded, secret)}`, payload }; } -function authDataDir(): string { - const configured = process.env.EVOSCIENTIST_DATA_DIR?.trim(); - if (!configured) return join(homedir(), ".evoscientist"); - return configured.startsWith("~") - ? join(homedir(), configured.slice(1)) - : resolve(configured); -} - function loginAuditPath(): string { - return join(authDataDir(), "webui-auth.json"); + return join(webuiDataDir(), "webui-auth.json"); } export async function recordLogin(payload: SessionPayload): Promise { const target = loginAuditPath(); - await fs.mkdir(authDataDir(), { recursive: true, mode: 0o700 }); + await fs.mkdir(webuiDataDir(), { recursive: true, mode: 0o700 }); let previous: LoginAudit | null = null; try { @@ -222,7 +201,12 @@ export function decodeSessionPayload(token: string): SessionPayload | null { ) { return null; } - return parsed as SessionPayload; + return { + username: parsed.username, + role: parsed.role === "user" ? "user" : "admin", + loggedInAt: parsed.loggedInAt, + expiresAt: parsed.expiresAt, + }; } catch { return null; } diff --git a/src/lib/server/dataDir.ts b/src/lib/server/dataDir.ts new file mode 100644 index 0000000..57b96f7 --- /dev/null +++ b/src/lib/server/dataDir.ts @@ -0,0 +1,13 @@ +import "server-only"; + +import { homedir } from "node:os"; +import { join, resolve } from "node:path"; + +/** Root directory for WebUI-owned local state (users DB, delegation keys). */ +export function webuiDataDir(): string { + const configured = process.env.EVOSCIENTIST_DATA_DIR?.trim(); + if (!configured) return join(homedir(), ".evoscientist"); + return configured.startsWith("~") + ? join(homedir(), configured.slice(1)) + : resolve(configured); +} diff --git a/src/lib/server/delegation.ts b/src/lib/server/delegation.ts new file mode 100644 index 0000000..2f42561 --- /dev/null +++ b/src/lib/server/delegation.ts @@ -0,0 +1,124 @@ +import "server-only"; + +import { + createSign, + generateKeyPairSync, + randomUUID, +} from "node:crypto"; +import fs from "node:fs"; +import path from "node:path"; +import { webuiDataDir } from "./dataDir"; +import type { UserRole } from "./userStore"; + +/** + * Delegation JWT signing (design doc 7.3). The WebUI signs a short-lived + * ES256 JWT per BFF → EvoScientist request; EvoScientist verifies it against + * the registered public key for this deployment and rejects replays by jti. + */ + +const DELEGATION_ISSUER = "WebUI"; +const DELEGATION_AUDIENCE = "EvoScientist"; +const DELEGATION_TTL_SECONDS = 50; // spec ceiling is 60s; leave clock margin + +export const SCOPE_MODEL_CONFIG_READ = "model_config:read"; +export const SCOPE_MODEL_CONFIG_WRITE = "model_config:write"; +export const SCOPE_MODEL_CONFIG_TEST = "model_config:test"; +export const SCOPE_MODEL_SELECT = "model:select"; +export const SCOPE_RUN_CREATE = "run:create"; + +const ADMIN_SCOPES = [ + SCOPE_MODEL_CONFIG_READ, + SCOPE_MODEL_CONFIG_WRITE, + SCOPE_MODEL_CONFIG_TEST, + SCOPE_MODEL_SELECT, + SCOPE_RUN_CREATE, +] as const; + +const USER_SCOPES = [SCOPE_MODEL_SELECT, SCOPE_RUN_CREATE] as const; + +/** Fixed role → scopes mapping (design doc 7.2). */ +export function scopesForRole(role: UserRole): string[] { + return [...(role === "admin" ? ADMIN_SCOPES : USER_SCOPES)]; +} + +export function delegationDeploymentId(): string { + return process.env.WEBUI_DEPLOYMENT_ID?.trim() || "webui-local"; +} + +function keyDir(): string { + return webuiDataDir(); +} + +function privateKeyPath(): string { + return path.join(keyDir(), "webui-delegation-es256.pem"); +} + +function publicKeyPath(): string { + return path.join(keyDir(), "webui-delegation-es256.pub.pem"); +} + +let cachedPrivateKey: string | null = null; + +function ensureKeyPair(): string { + if (cachedPrivateKey) return cachedPrivateKey; + const privatePath = privateKeyPath(); + try { + cachedPrivateKey = fs.readFileSync(privatePath, "utf8"); + return cachedPrivateKey; + } catch { + // First run — generate and persist below. + } + const { privateKey, publicKey } = generateKeyPairSync("ec", { + namedCurve: "P-256", + }); + const privatePem = privateKey.export({ format: "pem", type: "pkcs8" }).toString(); + const publicPem = publicKey.export({ format: "pem", type: "spki" }).toString(); + fs.mkdirSync(keyDir(), { recursive: true, mode: 0o700 }); + const tempPath = `${privatePath}.${randomUUID()}.tmp`; + fs.writeFileSync(tempPath, privatePem, { encoding: "utf8", mode: 0o600 }); + fs.renameSync(tempPath, privatePath); + fs.writeFileSync(publicKeyPath(), publicPem, { encoding: "utf8", mode: 0o644 }); + cachedPrivateKey = privatePem; + return privatePem; +} + +/** Public key PEM to register in EvoScientist config.yaml + * (`webui_delegation_public_keys` under this deployment's id). */ +export function delegationPublicKeyPem(): string { + ensureKeyPair(); + return fs.readFileSync(publicKeyPath(), "utf8"); +} + +function base64Url(value: string | Buffer): string { + return Buffer.from(value).toString("base64url"); +} + +export interface DelegationClaims { + sub: string; + scopes: string[]; + threadId?: string | null; +} + +export function signDelegationJwt(claims: DelegationClaims): string { + const now = Math.floor(Date.now() / 1000); + const header = base64Url(JSON.stringify({ alg: "ES256", typ: "JWT" })); + const payload: Record = { + iss: DELEGATION_ISSUER, + aud: DELEGATION_AUDIENCE, + sub: claims.sub, + scopes: claims.scopes, + deployment_id: delegationDeploymentId(), + iat: now, + exp: now + DELEGATION_TTL_SECONDS, + jti: randomUUID(), + }; + if (claims.threadId) payload.thread_id = claims.threadId; + const body = base64Url(JSON.stringify(payload)); + const signer = createSign("sha256"); + signer.update(`${header}.${body}`); + const signature = signer.sign({ + key: ensureKeyPair(), + dsaEncoding: "ieee-p1363", + }); + return `${header}.${body}.${signature.toString("base64url")}`; +} diff --git a/src/lib/server/evoscientistConfigClient.ts b/src/lib/server/evoscientistConfigClient.ts new file mode 100644 index 0000000..e6cfcd4 --- /dev/null +++ b/src/lib/server/evoscientistConfigClient.ts @@ -0,0 +1,103 @@ +import "server-only"; + +import { getActiveDeployment } from "./activeDeployment"; +import { scopesForRole, signDelegationJwt } from "./delegation"; +import type { Actor } from "./actor"; + +/** + * BFF → EvoScientist Config/Runtime API client (design doc 7.3). Every call + * carries the fixed authentication format: + * + * Authorization: Bearer + * X-Evo-Actor: + */ + +export interface ConfigApiErrorDetail { + path?: string; + code?: string; +} + +export class ConfigApiError extends Error { + constructor( + message: string, + readonly status: number, + readonly code: string | null = null, + readonly details: ConfigApiErrorDetail[] = [] + ) { + super(message); + } +} + +export function bffServiceToken(): string { + const token = process.env.EVOSCIENTIST_BFF_SERVICE_TOKEN?.trim(); + if (!token) { + throw new ConfigApiError( + "EVOSCIENTIST_BFF_SERVICE_TOKEN is not configured on this WebUI server.", + 503, + "PLATFORM_CONFIG_MISSING" + ); + } + return token; +} + +interface FetchOptions { + method?: string; + body?: unknown; + threadId?: string | null; +} + +export async function configApiFetch( + actor: Actor, + path: string, + options: FetchOptions = {} +): Promise<{ status: number; body: T }> { + const deployment = await getActiveDeployment(); + const delegation = signDelegationJwt({ + sub: actor.sub, + scopes: scopesForRole(actor.role), + threadId: options.threadId ?? null, + }); + const headers: Record = { + Authorization: `Bearer ${bffServiceToken()}`, + "X-Evo-Actor": delegation, + }; + let body: string | undefined; + if (options.body !== undefined) { + headers["Content-Type"] = "application/json"; + body = JSON.stringify(options.body); + } + const upstream = await fetch( + new URL(path, deployment.langgraphApiUrl), + { + method: options.method ?? "GET", + headers, + body, + cache: "no-store", + } + ); + const text = await upstream.text(); + let parsed: unknown = null; + try { + parsed = text ? JSON.parse(text) : null; + } catch { + // Non-JSON upstream body; surface status only. + } + if (!upstream.ok) { + const errorBody = parsed as { + code?: unknown; + message?: unknown; + details?: unknown; + } | null; + throw new ConfigApiError( + typeof errorBody?.message === "string" + ? errorBody.message + : `EvoScientist request failed (${upstream.status}).`, + upstream.status, + typeof errorBody?.code === "string" ? errorBody.code : null, + Array.isArray(errorBody?.details) + ? (errorBody.details as ConfigApiErrorDetail[]) + : [] + ); + } + return { status: upstream.status, body: parsed as T }; +} diff --git a/src/lib/server/routeErrors.ts b/src/lib/server/routeErrors.ts new file mode 100644 index 0000000..5c94e76 --- /dev/null +++ b/src/lib/server/routeErrors.ts @@ -0,0 +1,35 @@ +import "server-only"; + +import { NextResponse } from "next/server"; +import { ActorError } from "./actor"; +import { ConfigApiError } from "./evoscientistConfigClient"; + +export const NO_STORE = { "Cache-Control": "no-store" } as const; + +/** Map server-side failures to the BFF's outward error shape. Backend error + * codes are forwarded unchanged so the UI can key off them (design doc 9.5). */ +export function routeErrorResponse(error: unknown): NextResponse { + if (error instanceof ConfigApiError) { + return NextResponse.json( + { + code: error.code ?? undefined, + message: error.message, + details: error.details.length ? error.details : undefined, + }, + { status: error.status, headers: NO_STORE } + ); + } + if (error instanceof ActorError) { + return NextResponse.json( + { code: error.status === 401 ? "UNAUTHENTICATED" : "FORBIDDEN", message: error.message }, + { status: error.status, headers: NO_STORE } + ); + } + return NextResponse.json( + { + code: "INVALID_REQUEST", + message: error instanceof Error ? error.message : "Request failed.", + }, + { status: 400, headers: NO_STORE } + ); +} diff --git a/src/lib/server/threadModelSelection.ts b/src/lib/server/threadModelSelection.ts new file mode 100644 index 0000000..0915dd4 --- /dev/null +++ b/src/lib/server/threadModelSelection.ts @@ -0,0 +1,98 @@ +import type { ModelRef, ThreadModelSelection } from "@/lib/modelRegistry"; + +const ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/; + +export class ThreadModelSelectionError extends Error { + readonly code: string; + constructor(code: string, message: string) { + super(message); + this.code = code; + } +} + +function isPlainObject(value: unknown): value is Record { + return Boolean(value) && typeof value === "object" && !Array.isArray(value); +} + +function isModelRef(value: unknown): value is ModelRef { + return ( + isPlainObject(value) && + typeof value.provider_id === "string" && + ID_PATTERN.test(value.provider_id) && + typeof value.model_key === "string" && + ID_PATTERN.test(value.model_key) + ); +} + +/** Validates a browser-supplied `model_selection` payload (design doc 7.2). */ +export function parseThreadModelSelection(value: unknown): ThreadModelSelection { + if (value === "inherit") return "inherit"; + if ( + isPlainObject(value) && + isModelRef(value.primary) && + (value.auxiliary === null || isModelRef(value.auxiliary)) + ) { + return { + primary: { provider_id: value.primary.provider_id, model_key: value.primary.model_key }, + auxiliary: + value.auxiliary === null + ? null + : { + provider_id: value.auxiliary.provider_id, + model_key: value.auxiliary.model_key, + }, + }; + } + throw new ThreadModelSelectionError( + "INVALID_REQUEST", + "model_selection must be \"inherit\" or { primary: ModelRef, auxiliary: ModelRef | null }." + ); +} + +export interface StoredThreadModelSelection { + selection: ThreadModelSelection; + revision: number; +} + +/** Reads the selection frozen on thread metadata; a thread that never wrote + * `model_selection` is `inherit` at revision 0 (design doc 7.2). */ +export function readThreadModelSelection( + metadata: Record | undefined +): StoredThreadModelSelection { + const source = metadata ?? {}; + const rawRevision = source.model_selection_revision; + const revision = + typeof rawRevision === "number" && Number.isInteger(rawRevision) && rawRevision >= 0 + ? rawRevision + : 0; + if (!("model_selection" in source) || source.model_selection === undefined) { + return { selection: "inherit", revision }; + } + return { selection: parseThreadModelSelection(source.model_selection), revision }; +} + +/** Serializes the read-check-write CAS sequence per thread inside this + * single-instance BFF (design doc 7.2). */ +const selectionLocks = new Map>(); + +export async function withThreadSelectionLock( + threadId: string, + fn: () => Promise +): Promise { + const prior = selectionLocks.get(threadId) ?? Promise.resolve(); + let release!: () => void; + const current = new Promise((resolve) => { + release = resolve; + }); + const chained = prior.then(() => current); + selectionLocks.set(threadId, chained); + await prior; + try { + return await fn(); + } finally { + release(); + if (selectionLocks.get(threadId) === chained) { + selectionLocks.delete(threadId); + } + } +} diff --git a/src/lib/server/userStore.ts b/src/lib/server/userStore.ts new file mode 100644 index 0000000..5245dc5 --- /dev/null +++ b/src/lib/server/userStore.ts @@ -0,0 +1,226 @@ +import "server-only"; + +import { randomBytes, scryptSync, timingSafeEqual } from "node:crypto"; +import fs from "node:fs"; +import path from "node:path"; +import Database from "better-sqlite3"; +import { webuiDataDir } from "./dataDir"; + +export type UserRole = "admin" | "user"; + +export interface WebuiUser { + username: string; + role: UserRole; + createdAt: string; + updatedAt: string; +} + +interface UserRow { + username: string; + password_hash: string; + role: string; + created_at: string; + updated_at: string; +} + +const SCRYPT_N = 16384; +const SCRYPT_R = 8; +const SCRYPT_P = 1; +const SCRYPT_KEYLEN = 64; +const MAX_USERNAME_LENGTH = 64; +const USERNAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/; + +export class UserStoreError extends Error {} + +const globalUsers = globalThis as { __evoscientistWebuiUsers?: Database.Database }; + +function databasePath(): string { + return path.join(webuiDataDir(), "webui-users.sqlite3"); +} + +function openDatabase(): Database.Database { + if (globalUsers.__evoscientistWebuiUsers?.open) { + return globalUsers.__evoscientistWebuiUsers; + } + const target = databasePath(); + fs.mkdirSync(path.dirname(target), { recursive: true, mode: 0o700 }); + const db = new Database(target); + db.pragma("journal_mode = WAL"); + db.pragma("synchronous = FULL"); + db.pragma("busy_timeout = 5000"); + db.pragma("foreign_keys = ON"); + db.exec(` + CREATE TABLE IF NOT EXISTS users ( + username TEXT PRIMARY KEY, + password_hash TEXT NOT NULL, + role TEXT NOT NULL CHECK (role IN ('admin', 'user')), + created_at TEXT NOT NULL, + updated_at TEXT NOT NULL + ) + `); + try { + fs.chmodSync(target, 0o600); + } catch { + // Best effort on filesystems without POSIX permission support. + } + globalUsers.__evoscientistWebuiUsers = db; + return db; +} + +/** Test hook: close the shared handle so each suite can use its own dir. */ +export function closeUserStoreForTests(): void { + if (globalUsers.__evoscientistWebuiUsers?.open) { + globalUsers.__evoscientistWebuiUsers.close(); + } + globalUsers.__evoscientistWebuiUsers = undefined; +} + +function hashPassword(password: string): string { + const salt = randomBytes(16); + const derived = scryptSync(password, salt, SCRYPT_KEYLEN, { + N: SCRYPT_N, + r: SCRYPT_R, + p: SCRYPT_P, + }); + return [ + "scrypt", + String(SCRYPT_N), + String(SCRYPT_R), + String(SCRYPT_P), + salt.toString("base64"), + derived.toString("base64"), + ].join("$"); +} + +function verifyPassword(password: string, stored: string): boolean { + const parts = stored.split("$"); + if (parts.length !== 6 || parts[0] !== "scrypt") return false; + const [, n, r, p, saltB64, hashB64] = parts; + const salt = Buffer.from(saltB64, "base64"); + const expected = Buffer.from(hashB64, "base64"); + let derived: Buffer; + try { + derived = scryptSync(password, salt, expected.length, { + N: Number(n), + r: Number(r), + p: Number(p), + }); + } catch { + return false; + } + return timingSafeEqual(derived, expected); +} + +function toUser(row: UserRow): WebuiUser { + return { + username: row.username, + role: row.role === "admin" ? "admin" : "user", + createdAt: row.created_at, + updatedAt: row.updated_at, + }; +} + +export function validateUsername(username: string): string | null { + if (!username || username.length > MAX_USERNAME_LENGTH) { + return `Username must be 1-${MAX_USERNAME_LENGTH} characters.`; + } + if (!USERNAME_PATTERN.test(username)) { + return "Username may only contain letters, digits, '.', '_' and '-', and must start with a letter or digit."; + } + return null; +} + +export function countUsers(): number { + const row = openDatabase() + .prepare("SELECT COUNT(*) AS count FROM users") + .get() as { count: number }; + return row.count; +} + +export function listUsers(): WebuiUser[] { + const rows = openDatabase() + .prepare("SELECT * FROM users ORDER BY username") + .all() as UserRow[]; + return rows.map(toUser); +} + +export function getUser(username: string): WebuiUser | null { + const row = openDatabase() + .prepare("SELECT * FROM users WHERE username = ?") + .get(username) as UserRow | undefined; + return row ? toUser(row) : null; +} + +export function createUser( + username: string, + password: string, + role: UserRole +): WebuiUser { + const invalid = validateUsername(username); + if (invalid) throw new UserStoreError(invalid); + if (getUser(username)) { + throw new UserStoreError(`User '${username}' already exists.`); + } + const now = new Date().toISOString(); + openDatabase() + .prepare( + "INSERT INTO users (username, password_hash, role, created_at, updated_at) VALUES (?, ?, ?, ?, ?)" + ) + .run(username, hashPassword(password), role, now, now); + return { username, role, createdAt: now, updatedAt: now }; +} + +export function setUserPassword(username: string, password: string): void { + const result = openDatabase() + .prepare("UPDATE users SET password_hash = ?, updated_at = ? WHERE username = ?") + .run(hashPassword(password), new Date().toISOString(), username); + if (result.changes === 0) { + throw new UserStoreError(`User '${username}' does not exist.`); + } +} + +export function setUserRole(username: string, role: UserRole): void { + const result = openDatabase() + .prepare("UPDATE users SET role = ?, updated_at = ? WHERE username = ?") + .run(role, new Date().toISOString(), username); + if (result.changes === 0) { + throw new UserStoreError(`User '${username}' does not exist.`); + } +} + +export function deleteUser(username: string): void { + const result = openDatabase() + .prepare("DELETE FROM users WHERE username = ?") + .run(username); + if (result.changes === 0) { + throw new UserStoreError(`User '${username}' does not exist.`); + } +} + +export function verifyUserPassword( + username: string, + password: string +): WebuiUser | null { + const row = openDatabase() + .prepare("SELECT * FROM users WHERE username = ?") + .get(username) as UserRow | undefined; + if (!row || !verifyPassword(password, row.password_hash)) return null; + return toUser(row); +} + +/** + * Seed the first admin from the deployment environment when the store is + * empty (design doc 7.2: the first admin comes from env or an init command; + * later users are managed by admins through the API). + */ +export function ensureBootstrapAdmin(): void { + if (countUsers() > 0) return; + const username = process.env.WEBUI_AUTH_USERNAME?.trim(); + const password = process.env.WEBUI_AUTH_PASSWORD; + if (!username || !password) { + throw new UserStoreError( + "No WebUI users exist yet. Set WEBUI_AUTH_USERNAME and WEBUI_AUTH_PASSWORD to create the first admin." + ); + } + createUser(username, password, "admin"); +} diff --git a/src/proxy.ts b/src/proxy.ts index 486bf43..3e02875 100644 --- a/src/proxy.ts +++ b/src/proxy.ts @@ -11,6 +11,10 @@ interface SessionPayload { expiresAt: number; } +// The middleware only verifies the HMAC signature and expiry; the username +// and role are re-checked against the user store by the API routes, so +// bootstrap/env credentials are not required here. + function base64UrlBytes(value: string): Uint8Array | null { try { const padded = value @@ -32,8 +36,7 @@ function arrayBuffer(bytes: Uint8Array): ArrayBuffer { async function isValidSession(token: string | undefined): Promise { const secret = authSecret(); - const expectedUsername = process.env.WEBUI_AUTH_USERNAME?.trim(); - if (!token || !secret || !expectedUsername) return false; + if (!token || !secret) return false; const [encoded, signature] = token.split("."); if (!encoded || !signature) return false; const signatureBytes = base64UrlBytes(signature); @@ -59,7 +62,8 @@ async function isValidSession(token: string | undefined): Promise { new TextDecoder().decode(raw) ) as Partial; return ( - payload.username === expectedUsername && + typeof payload.username === "string" && + payload.username.length > 0 && typeof payload.expiresAt === "number" && payload.expiresAt > Math.floor(Date.now() / 1000) ); @@ -98,12 +102,7 @@ export async function proxy(request: NextRequest) { if (!isAuthenticationEnabled() || isPublicPath(request.nextUrl.pathname)) { return NextResponse.next(); } - if ( - !authSecret() || - authSecret()!.length < 32 || - !process.env.WEBUI_AUTH_USERNAME?.trim() || - !process.env.WEBUI_AUTH_PASSWORD - ) { + if (!authSecret() || authSecret()!.length < 32) { return configurationError(request); } const token = request.cookies.get(AUTH_COOKIE_NAME)?.value;