@deepseek-insight/dsi 0.5.5

package/build/server/chunks/entries/endpoints/api/dsh/session/_sessionId_/goal/_server.ts.js-RteR85vn.js

@@ -0,0 +1,138 @@
+import { D as DshRpcError, s as statusFor, m as mapRpcFailure, g as getDshConnection } from '../../../../../../../chunks/dsh-connection.js-DwihVtk_.js';
+import { g as goalFromProjection } from '../../../../../../../chunks/goal-projection.js-0_34t60K.js';
+import { j as json } from '../../../../../../../chunks/utils.js-tOWCe9Wk.js';
+import '../../../../../../../chunks/config.js-BBYogCe7.js';
+import '../../../../../../../chunks/insight-config.js-CfMPTA6Z.js';
+import 'node:fs';
+import 'node:path';
+import 'node:os';
+import 'yaml';
+import '../../../../../../../chunks/shared.js-C4-Py8s_.js';
+import '../../../../../../../chunks/uneval.js-BJ9Qq2SF.js';
+
+//#region src/routes/api/dsh/session/[sessionId]/goal/+server.ts
+/**
+* api-dsh — POST /api/dsh/session/[sessionId]/goal (Goal Bar, 2026-09-08)
+*
+* The Goal Bar's actions ride the host's Goal Remotes — `goals/pause`,
+* `goals/resume`, `goals/clear` — the SAME verbs DSH's own web client
+* injects, NOT `commands/execute`: the web plane's catalog deliberately
+* excludes `command-goal` (packages/bundle/web-app/cordis.patch.yml), so a
+* `/goal` line is an admission miss there (probed live 2026-09-08:
+* "unknown command: /goal — nothing was sent").
+*
+* Body: { verb: 'pause'|'resume'|'clear'|'edit', ref: {id, revision},
+* edit?: { objective?, maxGoalRounds? } } — the ref is the CAS identity the
+* host demands; edit carries its changed-fields payload (2026-09-09). While a goal is actively rounding,
+* the round driver (fencing pauses) and the model's own update_goal are
+* also writers, so the operator's ref can go stale between render and
+* click through no fault of the click.
+*
+* The connection's rpc (dsh-rpc.ts parseResponse) UNWRAPS successes to the
+* bare payload (a GoalView / GoalRef — no ok field) and folds every failure
+* shape into a thrown DshRpcError, so at this layer:
+*   - a resolved attempt IS success (2026-09-08 fix: the route used to read
+*     result.ok on the unwrapped value and reported every success as
+*     goal-refused — the goal changed while the banner claimed refusal);
+*   - a stale-ref refusal is the DshRpcError whose message ends
+*     "… revision N". ONE retry runs with the host-named revision, or the
+*     connection's freshest projection revision when the message form
+*     changes. A second refusal is a real race and is returned as-is.
+* Wire/RpcError (transport, phase-transition) → mapRpcFailure/statusFor.
+*/
+var VERBS = [
+	"pause",
+	"resume",
+	"clear",
+	"edit"
+];
+var POST = async ({ params, request }) => {
+	const sessionId = params.sessionId;
+	let body;
+	try {
+		body = await request.json();
+	} catch {
+		return json({
+			ok: false,
+			error: {
+				code: "bad-json",
+				message: "request body is not valid JSON"
+			}
+		}, { status: 400 });
+	}
+	const b = body;
+	const verb = b?.verb;
+	const ref = b?.ref;
+	if (typeof verb !== "string" || !VERBS.includes(verb)) return json({
+		ok: false,
+		error: {
+			code: "bad-verb",
+			message: "verb must be pause, resume, clear, or edit (v2 retry)"
+		}
+	}, { status: 400 });
+	if (ref === null || typeof ref !== "object" || typeof ref.id !== "string" || ref.id.length === 0 || typeof ref.revision !== "number" || !Number.isInteger(ref.revision)) return json({
+		ok: false,
+		error: {
+			code: "bad-ref",
+			message: "ref must be {id: string, revision: integer}"
+		}
+	}, { status: 400 });
+	let editFields;
+	if (verb === "edit") {
+		const e = b.edit;
+		const rec = e !== null && typeof e === "object" && !Array.isArray(e) ? e : void 0;
+		const objectiveOk = rec?.objective === void 0 || typeof rec.objective === "string" && rec.objective.trim().length > 0;
+		const roundsOk = rec?.maxGoalRounds === void 0 || typeof rec.maxGoalRounds === "number" && Number.isSafeInteger(rec.maxGoalRounds) && rec.maxGoalRounds >= 1;
+		const atLeastOne = rec !== void 0 && (rec.objective !== void 0 || rec.maxGoalRounds !== void 0);
+		if (!objectiveOk || !roundsOk || !atLeastOne) return json({
+			ok: false,
+			error: {
+				code: "bad-edit",
+				message: "edit requires objective (non-empty string) and/or maxGoalRounds (positive integer)"
+			}
+		}, { status: 400 });
+		editFields = {
+			...typeof rec.objective === "string" ? { objective: rec.objective } : {},
+			...typeof rec.maxGoalRounds === "number" ? { maxGoalRounds: rec.maxGoalRounds } : {}
+		};
+	}
+	const refId = ref.id;
+	const attempt = (revision) => getDshConnection().goalVerb(verb, sessionId, {
+		id: refId,
+		revision
+	}, editFields);
+	const freshestProjectionRevision = () => {
+		const fresh = goalFromProjection(getDshConnection().projectionValue(sessionId, "goal"));
+		return fresh !== null && fresh !== void 0 && fresh.id === refId ? fresh.revision : null;
+	};
+	try {
+		return json({
+			ok: true,
+			value: await attempt(ref.revision)
+		});
+	} catch (err) {
+		if (err instanceof DshRpcError) {
+			if (/stale goal ref/i.test(err.message)) {
+				const named = /revision (\d+)"?\s*;?\s*$/.exec(err.message);
+				const retryRevision = named !== null ? Number(named[1]) : freshestProjectionRevision();
+				if (retryRevision !== null && retryRevision !== ref.revision) try {
+					return json({
+						ok: true,
+						value: await attempt(retryRevision)
+					});
+				} catch {}
+			}
+			return json({
+				ok: false,
+				error: {
+					code: err.code,
+					message: err.message
+				}
+			}, { status: 409 });
+		}
+		return json(mapRpcFailure(err), { status: statusFor(err) });
+	}
+};
+
+export { POST };
+//# sourceMappingURL=_server.ts.js-RteR85vn.js.map

package/build/server/chunks/entries/endpoints/api/dsh/session/_sessionId_/history/_server.ts.js-CEKDkK7v.js

@@ -0,0 +1,55 @@
+import { g as getDshConnection, s as statusFor, m as mapRpcFailure } from '../../../../../../../chunks/dsh-connection.js-DwihVtk_.js';
+import { h as historyToEvents, e as eventsToEntries } from '../../../../../../../chunks/dsh-events.js-BtDxaV6Q.js';
+import { j as json } from '../../../../../../../chunks/utils.js-tOWCe9Wk.js';
+import '../../../../../../../chunks/config.js-BBYogCe7.js';
+import '../../../../../../../chunks/insight-config.js-CfMPTA6Z.js';
+import 'node:fs';
+import 'node:path';
+import 'node:os';
+import 'yaml';
+import '../../../../../../../chunks/shared.js-C4-Py8s_.js';
+import '../../../../../../../chunks/uneval.js-BJ9Qq2SF.js';
+
+//#region src/routes/api/dsh/session/[sessionId]/history/+server.ts
+/**
+* api-dsh — GET /api/dsh/session/[sessionId]/history?beforeSeq=N
+*
+* POC-2 W3 (load-older paging): the ledger page that ENDS at N−1 (live-probed
+* semantics, PRD §1.2) — mapped through the same dsh-events rules as the cold
+* load so prepended entries merge identically. The ledger is the truth (BC-4):
+* the ring buffer is never consulted here.
+*
+* Response: {ok, entries, lastSeq, hasMore}. 400 when beforeSeq is absent or
+* not a finite number (a page anchor is required — there is no tail default
+* here; the cold load already serves the tail).
+*/
+var GET = async ({ params, url, setHeaders }) => {
+	setHeaders({ "cache-control": "no-store" });
+	const sessionId = params.sessionId;
+	const beforeRaw = url.searchParams.get("beforeSeq");
+	const beforeSeq = beforeRaw !== null ? Number(beforeRaw) : NaN;
+	if (beforeRaw === null || !Number.isFinite(beforeSeq)) return json({
+		ok: false,
+		error: {
+			code: "bad-beforeSeq",
+			message: "beforeSeq must be a finite number"
+		}
+	}, { status: 400 });
+	try {
+		const page = await getDshConnection().historyPage(sessionId, beforeSeq);
+		const events = historyToEvents(page.events);
+		const entries = eventsToEntries(events);
+		const lastSeq = events.at(-1)?.seq ?? -1;
+		return json({
+			ok: true,
+			entries,
+			lastSeq,
+			hasMore: page.hasMore === true
+		});
+	} catch (err) {
+		return json(mapRpcFailure(err), { status: statusFor(err) });
+	}
+};
+
+export { GET };
+//# sourceMappingURL=_server.ts.js-CEKDkK7v.js.map

package/build/server/chunks/entries/endpoints/api/dsh/session/_sessionId_/models/_server.ts.js-D7ziyW3d.js

@@ -0,0 +1,35 @@
+import { g as getDshConnection, s as statusFor, m as mapRpcFailure } from '../../../../../../../chunks/dsh-connection.js-DwihVtk_.js';
+import { j as json } from '../../../../../../../chunks/utils.js-tOWCe9Wk.js';
+import '../../../../../../../chunks/config.js-BBYogCe7.js';
+import '../../../../../../../chunks/insight-config.js-CfMPTA6Z.js';
+import 'node:fs';
+import 'node:path';
+import 'node:os';
+import 'yaml';
+import '../../../../../../../chunks/shared.js-C4-Py8s_.js';
+import '../../../../../../../chunks/uneval.js-BJ9Qq2SF.js';
+
+//#region src/routes/api/dsh/session/[sessionId]/models/+server.ts
+/**
+* api-dsh — GET /api/dsh/session/[sessionId]/models  (POC-3 W3, task 3.2)
+*
+* session.models → the normalized model directory for the header selector.
+* `routable` rides verbatim (a surface that blocks input reads this rather
+* than the groups — catalog membership is advisory). Garbage catalogs
+* normalize to empty lists, never an error (connection owns that truth).
+*/
+var GET = async ({ params, setHeaders }) => {
+	setHeaders({ "cache-control": "no-store" });
+	try {
+		const directory = await getDshConnection().listModels(params.sessionId);
+		return json({
+			ok: true,
+			...directory
+		});
+	} catch (err) {
+		return json(mapRpcFailure(err), { status: statusFor(err) });
+	}
+};
+
+export { GET };
+//# sourceMappingURL=_server.ts.js-D7ziyW3d.js.map

package/build/server/chunks/entries/endpoints/api/dsh/session/_sessionId_/permission/_server.ts.js-DbkD4JZb.js

@@ -0,0 +1,92 @@
+import { g as getDshConnection, s as statusFor, m as mapRpcFailure } from '../../../../../../../chunks/dsh-connection.js-DwihVtk_.js';
+import { j as json } from '../../../../../../../chunks/utils.js-tOWCe9Wk.js';
+import '../../../../../../../chunks/config.js-BBYogCe7.js';
+import '../../../../../../../chunks/insight-config.js-CfMPTA6Z.js';
+import 'node:fs';
+import 'node:path';
+import 'node:os';
+import 'yaml';
+import '../../../../../../../chunks/shared.js-C4-Py8s_.js';
+import '../../../../../../../chunks/uneval.js-BJ9Qq2SF.js';
+
+//#region src/routes/api/dsh/session/[sessionId]/permission/+server.ts
+/**
+* api-dsh — POST /api/dsh/session/[sessionId]/permission (ADR-0007 R5; fixed 2026-08-25)
+*
+* Body {line} → the line executed VERBATIM through commands/execute — the
+* NATIVE slash-command surface the host's own web GUI uses (Typert Gateway
+* remote). session.prompt has NO slash interception (verified live, 2026-08-25
+* RCA: a /permission line sent through it is admitted as a chat prompt and
+* reaches the model); this route no longer touches it.
+*
+* Receipts are honest:
+*   - success  → {ok, accepted, commandId, text?} — knob events WILL land in
+*     the ledger (command/run + permission/preset + sandbox/mode +
+*     approval/policy + command/done); the chip's poll fold confirms.
+*   - command reported an error (unknown preset, blocked by open terminals…)
+*     → 200 {ok:false, code:'command-error', message} — the pick never landed.
+*   - admission miss (no registered command) → 200 {ok:false, code:'command-miss'}.
+*
+* The slash-line syntax lives HERE, never in a component: the chip calls
+* `onpermission('read-only')`, the composer forwards the user's line — the
+* panel builds neither command string beyond this route's contract.
+*/
+var POST = async ({ params, request }) => {
+	const sessionId = params.sessionId;
+	let body;
+	try {
+		body = await request.json();
+	} catch {
+		return json({
+			ok: false,
+			error: {
+				code: "bad-json",
+				message: "request body is not valid JSON"
+			}
+		}, { status: 400 });
+	}
+	const line = body?.line;
+	if (typeof line !== "string" || line.trim().length === 0) return json({
+		ok: false,
+		error: {
+			code: "empty-line",
+			message: "line must be a non-empty string"
+		}
+	}, { status: 400 });
+	const normalized = line.trim();
+	if (normalized !== "/permission" && !normalized.startsWith("/permission ")) return json({
+		ok: false,
+		error: {
+			code: "bad-command",
+			message: "this route executes only /permission lines"
+		}
+	}, { status: 400 });
+	try {
+		const receipt = await getDshConnection().executeCommand(sessionId, line);
+		if (receipt === null) return json({
+			ok: false,
+			error: {
+				code: "command-miss",
+				message: "the host admitted no command for this line"
+			}
+		});
+		if (receipt.result.kind === "error") return json({
+			ok: false,
+			error: {
+				code: "command-error",
+				message: receipt.result.text ?? "the command reported an error"
+			}
+		});
+		return json({
+			ok: true,
+			accepted: true,
+			commandId: receipt.commandId,
+			...receipt.result.text !== void 0 ? { text: receipt.result.text } : {}
+		});
+	} catch (err) {
+		return json(mapRpcFailure(err), { status: statusFor(err) });
+	}
+};
+
+export { POST };
+//# sourceMappingURL=_server.ts.js-DbkD4JZb.js.map

package/build/server/chunks/entries/endpoints/api/dsh/session/_sessionId_/prompt/_server.ts.js-eOLNlf1-.js

@@ -0,0 +1,94 @@
+import { a as isPromptImageMediaType, g as getDshConnection, b as buildPromptContent, s as statusFor, m as mapRpcFailure } from '../../../../../../../chunks/dsh-connection.js-DwihVtk_.js';
+import { j as json } from '../../../../../../../chunks/utils.js-tOWCe9Wk.js';
+import '../../../../../../../chunks/config.js-BBYogCe7.js';
+import '../../../../../../../chunks/insight-config.js-CfMPTA6Z.js';
+import 'node:fs';
+import 'node:path';
+import 'node:os';
+import 'yaml';
+import '../../../../../../../chunks/shared.js-C4-Py8s_.js';
+import '../../../../../../../chunks/uneval.js-BJ9Qq2SF.js';
+
+//#region src/routes/api/dsh/session/[sessionId]/prompt/+server.ts
+/**
+* api-dsh — POST /api/dsh/session/[sessionId]/prompt
+*
+* Body {text, images?} → session.prompt content parts (task 2.3): images
+* first, text last (buildPromptContent). Text-or-images: an attachments-
+* only send passes with empty text; neither is a 400. Image parts are
+* shape-validated against the wire whitelist here — canonical base64 and
+* limits remain the HOST's admission (the proxy passes originals through
+* the receipt boundary, ADR D4). Returns after the receipt only (BC-3):
+* {accepted:true} or an RPC error (e.g. agent-busy → 502, mapped by the
+* client into a banner + input unlock).
+*/
+var POST = async ({ params, request }) => {
+	const sessionId = params.sessionId;
+	let body;
+	try {
+		body = await request.json();
+	} catch {
+		return json({
+			ok: false,
+			error: {
+				code: "bad-json",
+				message: "request body is not valid JSON"
+			}
+		}, { status: 400 });
+	}
+	const record = body ?? {};
+	const text = record.text ?? "";
+	const rawImages = record.images;
+	if (typeof text !== "string") return json({
+		ok: false,
+		error: {
+			code: "bad-text",
+			message: "text must be a string"
+		}
+	}, { status: 400 });
+	let images = [];
+	if (rawImages !== void 0) {
+		if (!Array.isArray(rawImages)) return json({
+			ok: false,
+			error: {
+				code: "invalid-images",
+				message: "images must be an array"
+			}
+		}, { status: 400 });
+		for (const candidate of rawImages) {
+			const image = candidate;
+			if (image === null || typeof image !== "object" || typeof image.mediaType !== "string" || !isPromptImageMediaType(image.mediaType) || typeof image.data !== "string" || image.data.length === 0 || image.name !== void 0 && typeof image.name !== "string") return json({
+				ok: false,
+				error: {
+					code: "invalid-images",
+					message: "each image needs a whitelisted mediaType and non-empty base64 data"
+				}
+			}, { status: 400 });
+			images.push({
+				type: "image",
+				mediaType: image.mediaType,
+				data: image.data,
+				...image.name === void 0 ? {} : { name: image.name }
+			});
+		}
+	}
+	if (text.trim().length === 0 && images.length === 0) return json({
+		ok: false,
+		error: {
+			code: "empty-text",
+			message: "text or at least one image is required"
+		}
+	}, { status: 400 });
+	try {
+		const receipt = await getDshConnection().prompt(sessionId, buildPromptContent(text, images));
+		return json({
+			ok: true,
+			accepted: receipt.accepted === true
+		});
+	} catch (err) {
+		return json(mapRpcFailure(err), { status: statusFor(err) });
+	}
+};
+
+export { POST };
+//# sourceMappingURL=_server.ts.js-eOLNlf1-.js.map

package/build/server/chunks/entries/endpoints/api/dsh/session/_sessionId_/rename/_server.ts.js-txQRocK9.js

@@ -0,0 +1,57 @@
+import { g as getDshConnection, s as statusFor, m as mapRpcFailure } from '../../../../../../../chunks/dsh-connection.js-DwihVtk_.js';
+import { j as json } from '../../../../../../../chunks/utils.js-tOWCe9Wk.js';
+import '../../../../../../../chunks/config.js-BBYogCe7.js';
+import '../../../../../../../chunks/insight-config.js-CfMPTA6Z.js';
+import 'node:fs';
+import 'node:path';
+import 'node:os';
+import 'yaml';
+import '../../../../../../../chunks/shared.js-C4-Py8s_.js';
+import '../../../../../../../chunks/uneval.js-BJ9Qq2SF.js';
+
+//#region src/routes/api/dsh/session/[sessionId]/rename/+server.ts
+/**
+* api-dsh — POST /api/dsh/session/[sessionId]/rename  (POC-3 W3, task 3.1)
+*
+* Body {title} → session.rename. The host normalizes the title and returns
+* {title, seq} — the normalized ACCEPTED title pins the projection cell
+* immediately (no push-frame wait). A title that normalizes to empty is a
+* host RPC error (`title-invalid` → 502 here); transport failure → 503.
+* Error mapping identical to the sibling routes (mapRpcFailure/statusFor).
+*/
+var POST = async ({ params, request }) => {
+	const sessionId = params.sessionId;
+	let body;
+	try {
+		body = await request.json();
+	} catch {
+		return json({
+			ok: false,
+			error: {
+				code: "bad-json",
+				message: "request body is not valid JSON"
+			}
+		}, { status: 400 });
+	}
+	const title = body?.title;
+	if (typeof title !== "string" || title.trim().length === 0) return json({
+		ok: false,
+		error: {
+			code: "empty-title",
+			message: "title must be a non-empty string"
+		}
+	}, { status: 400 });
+	try {
+		const renamed = await getDshConnection().renameSession(sessionId, title);
+		return json({
+			ok: true,
+			title: renamed.title,
+			seq: renamed.seq
+		});
+	} catch (err) {
+		return json(mapRpcFailure(err), { status: statusFor(err) });
+	}
+};
+
+export { POST };
+//# sourceMappingURL=_server.ts.js-txQRocK9.js.map

package/build/server/chunks/entries/endpoints/api/dsh/session/_sessionId_/respond/_server.ts.js-D3WGYzkE.js

@@ -0,0 +1,69 @@
+import { g as getDshConnection, s as statusFor, m as mapRpcFailure } from '../../../../../../../chunks/dsh-connection.js-DwihVtk_.js';
+import { j as json } from '../../../../../../../chunks/utils.js-tOWCe9Wk.js';
+import '../../../../../../../chunks/config.js-BBYogCe7.js';
+import '../../../../../../../chunks/insight-config.js-CfMPTA6Z.js';
+import 'node:fs';
+import 'node:path';
+import 'node:os';
+import 'yaml';
+import '../../../../../../../chunks/shared.js-C4-Py8s_.js';
+import '../../../../../../../chunks/uneval.js-BJ9Qq2SF.js';
+
+//#region src/routes/api/dsh/session/[sessionId]/respond/+server.ts
+/**
+* api-dsh — POST /api/dsh/session/[sessionId]/respond  (POC-3 W1)
+*
+* Body {rpcId, payload} → the client-response carrier via dsh-connection.
+*
+* BC-B: a REFUSED answer is a successful exchange — the receipt maps to
+* HTTP 200 {ok:true, accepted:false, reason} so the card settles
+* "answered elsewhere" (not-pending: another UI won the first-claimant
+* race) or surfaces a honest validation refusal (bad-response). Only
+* transport failures are errors (503 — the card stays answerable).
+*/
+var POST = async ({ params, request }) => {
+	const sessionId = params.sessionId;
+	let body;
+	try {
+		body = await request.json();
+	} catch {
+		return json({
+			ok: false,
+			error: {
+				code: "bad-json",
+				message: "request body is not valid JSON"
+			}
+		}, { status: 400 });
+	}
+	const { rpcId, payload } = body ?? {};
+	if (typeof rpcId !== "string" || rpcId.length === 0) return json({
+		ok: false,
+		error: {
+			code: "bad-rpcId",
+			message: "rpcId must be a non-empty string"
+		}
+	}, { status: 400 });
+	if (payload === void 0 || payload === null || typeof payload !== "object" || Array.isArray(payload)) return json({
+		ok: false,
+		error: {
+			code: "bad-payload",
+			message: "payload must be an object"
+		}
+	}, { status: 400 });
+	try {
+		const receipt = await getDshConnection().respond(rpcId, {
+			sessionId,
+			...payload
+		});
+		return json({
+			ok: true,
+			accepted: receipt.accepted,
+			...receipt.accepted ? {} : { reason: receipt.reason }
+		});
+	} catch (err) {
+		return json(mapRpcFailure(err), { status: statusFor(err) });
+	}
+};
+
+export { POST };
+//# sourceMappingURL=_server.ts.js-D3WGYzkE.js.map

package/build/server/chunks/entries/endpoints/api/dsh/session/_sessionId_/select-model/_server.ts.js-g2GtvLTs.js

@@ -0,0 +1,69 @@
+import { g as getDshConnection, s as statusFor, m as mapRpcFailure } from '../../../../../../../chunks/dsh-connection.js-DwihVtk_.js';
+import { j as json } from '../../../../../../../chunks/utils.js-tOWCe9Wk.js';
+import '../../../../../../../chunks/config.js-BBYogCe7.js';
+import '../../../../../../../chunks/insight-config.js-CfMPTA6Z.js';
+import 'node:fs';
+import 'node:path';
+import 'node:os';
+import 'yaml';
+import '../../../../../../../chunks/shared.js-C4-Py8s_.js';
+import '../../../../../../../chunks/uneval.js-BJ9Qq2SF.js';
+
+//#region src/routes/api/dsh/session/[sessionId]/select-model/+server.ts
+/**
+* api-dsh — POST /api/dsh/session/[sessionId]/select-model  (POC-3 W3, task 3.2)
+*
+* Body {provider, model, reasoningEffort?} → session.selectModel. Returns
+* {ok:true, selected} with the host's normalized selection. Catalog
+* membership is advisory host-side; an invalid effort fails as an RpcError
+* (→ 502 with the host code). Subagents reject `agent-busy` the same way.
+*/
+var POST = async ({ params, request }) => {
+	const sessionId = params.sessionId;
+	let body;
+	try {
+		body = await request.json();
+	} catch {
+		return json({
+			ok: false,
+			error: {
+				code: "bad-json",
+				message: "request body is not valid JSON"
+			}
+		}, { status: 400 });
+	}
+	const { provider, model, reasoningEffort } = body ?? {};
+	if (typeof provider !== "string" || provider.length === 0) return json({
+		ok: false,
+		error: {
+			code: "bad-provider",
+			message: "provider must be a non-empty string"
+		}
+	}, { status: 400 });
+	if (typeof model !== "string" || model.length === 0) return json({
+		ok: false,
+		error: {
+			code: "bad-model",
+			message: "model must be a non-empty string"
+		}
+	}, { status: 400 });
+	if (reasoningEffort !== void 0 && typeof reasoningEffort !== "string") return json({
+		ok: false,
+		error: {
+			code: "bad-reasoningEffort",
+			message: "reasoningEffort must be a string when present"
+		}
+	}, { status: 400 });
+	try {
+		const selected = await getDshConnection().selectModel(sessionId, provider, model, reasoningEffort);
+		return json({
+			ok: true,
+			selected
+		});
+	} catch (err) {
+		return json(mapRpcFailure(err), { status: statusFor(err) });
+	}
+};
+
+export { POST };
+//# sourceMappingURL=_server.ts.js-g2GtvLTs.js.map