t3code-cli 0.14.1 → 0.14.2

package/dist/client-runtime/state/server.js

@@ -1,5 +1,97 @@
-import { $D as flatMap, Aa as EnvironmentSupervisor, Bk as isSome, Cv as get, Fs as WS_METHODS, GC as set, Gk as toArray, Gr as family, HD as as, Hk as match, IE as debounce, Ik as getOrNull, Jr as setIdleTTL, KC as update, La as EnvironmentCacheStore, Na as safeErrorLogAttributes, RD as addFinalizer, RO as void_, Sv as changes, Tv as set$1, UC as get$1, UD as asVoid, Uk as none, Ur as subscribe, VD as annotateLogs, VE as filterMap, Vk as map, WC as make$1, WE as fromQueue, Wk as some, Xr as withLabel, YD as catch_, aO as gen, bk as failVoid, dr as createEnvironmentRpcCommand, eO as fn, fr as createEnvironmentRpcQueryAtomFamily, iO as forkScoped, lD as unwrap, lO as logWarning, lr as createAtomCommandScheduler, mr as createEnvironmentRpcSubscriptionAtomFamily, qE as mapAccum, qr as make$2, tD as runForEach, ti as value, uO as map$1, vD as offer, wk as succeed, wv as make, xD as sliding, xr as followStreamInEnvironment, zk as isNone } from "../../shared.js";
+import { $r as make, AD as TaggedErrorClass, AO as fromQueue, Aj as none, Ak as exit, Ba as safeErrorLogAttributes, Bk as gen, Cj as getOrNull, DO as filterMap, Dj as isSome, Dk as catch_, EO as filter, Ej as isNone, FA as squash, Fy as get, Gk as map$1, HO as runHead, Ia as EnvironmentSupervisor, Iy as make$1, Jr as runStream, Kr as isRpcClientError, Ly as set$1, MA as hasInterruptsOnly, Mj as toArray, Mk as failCause, Mr as scheduleAtomCommandEffect, NA as isFailReason, NO as mapAccum, Nk as flatMap, OD as String, Oj as map, Pa as EnvironmentRegistry, Pk as fn, Py as changes, Rk as forkChild, SO as debounce, Tr as followStreamInEnvironment, Us as WS_METHODS, VD as optional, VO as runForEach, Vk as ignore, Wa as EnvironmentCacheStore, Wk as logWarning, XA as isSuccess, Xk as onExit, YA as isFailure, YO as unwrap, Yr as subscribe, Zr as family, aj as failVoid, bA as void_, bT as set, bk as as, br as createRuntimeCommand, cA as succeed, ck as sliding, ei as setIdleTTL, fj as minutes, gk as addFinalizer, gr as createEnvironmentRpcQueryAtomFamily, hr as createEnvironmentRpcCommand, ik as offer, jj as some, jk as fail, kj as match, lj as succeed$1, ni as withLabel, pA as timeoutOption, pj as seconds, pr as createAtomCommandScheduler, qr as request, sA as sleep, si as value, uA as sync, vT as get$1, vk as andThen, vr as createEnvironmentRpcSubscriptionAtomFamily, wD as Literals, xT as update, xk as asVoid, yT as make$2, yj as flatten, yk as annotateLogs, zk as forkScoped } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/server.ts
+const IDLE_SERVER_UPDATE_STATE = { status: "idle" };
+const EMPTY_SERVER_UPDATE_STATE_ATOM = make(IDLE_SERVER_UPDATE_STATE).pipe(withLabel("environment-data:server:update-state:empty"));
+const serverUpdateStateAtom = family((environmentId) => make(IDLE_SERVER_UPDATE_STATE).pipe(withLabel(`environment-data:server:update-state:${environmentId}`)));
+var ServerUpdateResumeTimeoutError = class extends TaggedErrorClass()("ServerUpdateResumeTimeoutError", {
+	environmentId: String,
+	targetVersion: String
+}) {
+	get message() {
+		return `The server did not resume on t3@${this.targetVersion}.`;
+	}
+};
+var ServerUpdateProgressIncompleteError = class extends TaggedErrorClass()("ServerUpdateProgressIncompleteError", { targetVersion: String }) {
+	get message() {
+		return `The t3@${this.targetVersion} update ended before the server accepted the restart.`;
+	}
+};
+var ServerUpdateTerminalError = class extends TaggedErrorClass()("ServerUpdateTerminalError", {
+	targetVersion: String,
+	status: Literals([
+		"committed",
+		"rolled-back",
+		"failed"
+	]),
+	reason: optional(String)
+}) {
+	get message() {
+		return this.reason ?? `The t3@${this.targetVersion} update ${this.status}.`;
+	}
+};
+const SERVER_UPDATE_RESUME_TIMEOUT = minutes(4);
+function matchesServerUpdateReadyEvent(result, event) {
+	return result.updateId === void 0 ? event.payload.environment.serverVersion === result.targetVersion : event.payload.updateOutcome?.id === result.updateId;
+}
+function validateServerUpdateReadyEvent(result, event) {
+	if (result.updateId === void 0) return void_;
+	const outcome = event.payload.updateOutcome;
+	if (outcome?.id === result.updateId && outcome.status === "committed" && outcome.targetVersion === result.targetVersion && event.payload.environment.serverVersion === result.targetVersion) return void_;
+	return fail(new ServerUpdateTerminalError({
+		targetVersion: result.targetVersion,
+		status: outcome?.status ?? "failed",
+		reason: outcome?.reason ?? "The service launcher resumed without committing the requested server version."
+	}));
+}
+/**
+* Keeps reconnect attempts ~1s apart for the whole update restart.
+*
+* A restart takes the server down for ~15 seconds, but the supervisor's normal
+* backoff ladder (1/2/4/8/16s) assumes an unexpected failure and lands attempts
+* at ~3, 5, 9, 17 and 33 seconds — so a 15-second restart is observed as a
+* 33-second "Resuming". Nudging on every backoff entry (not just the first)
+* holds the retry cadence flat until the server answers again. The sleep before
+* each nudge is the pacer: a connection that fails instantly re-enters backoff
+* immediately and would otherwise spin a tight retry loop.
+*
+* Callers fork this as a child of the update command so it is interrupted as
+* soon as the update settles, whether it succeeds, fails, or times out.
+*/
+function nudgeReconnectDuringUpdateRestart(input) {
+	return input.stateChanges.pipe(filter((state) => state.phase === "backoff"), runForEach(() => sleep(input.interval ?? seconds(1)).pipe(andThen(input.retryNow))), timeoutOption(SERVER_UPDATE_RESUME_TIMEOUT), ignore);
+}
+function serverUpdateStateForProgressEvent(fromVersion, targetVersion, event) {
+	return {
+		status: "running",
+		stage: event.type === "complete" ? "resuming" : event.stage,
+		fromVersion,
+		targetVersion
+	};
+}
+function serverUpdateStateForServerVersion(state, serverVersion) {
+	return state.status === "idle" || state.status === "running" || serverVersion === null || state.fromVersion === serverVersion ? state : IDLE_SERVER_UPDATE_STATE;
+}
+function serverUpdateFailureMessage(error) {
+	return error instanceof Error ? error.message : "Server update failed.";
+}
+function isRpcSocketError(error) {
+	if (!isRpcClientError(error)) return false;
+	switch (error.reason._tag) {
+		case "SocketReadError":
+		case "SocketWriteError":
+		case "SocketCloseError": return true;
+		default: return false;
+	}
+}
+function isLegacyUpdateHandoffLoss(cause) {
+	if (hasInterruptsOnly(cause)) return true;
+	return cause.reasons.length > 0 && cause.reasons.every((reason) => isFailReason(reason) && isRpcSocketError(reason.error));
+}
+function resolveServerUpdateProgressResult(targetVersion, terminal, streamExit) {
+	if (isSome(terminal) && (isSuccess(streamExit) || isLegacyUpdateHandoffLoss(streamExit.cause))) return succeed(terminal.value);
+	if (isFailure(streamExit)) return failCause(streamExit.cause);
+	return fail(new ServerUpdateProgressIncompleteError({ targetVersion }));
+}
 function applyServerConfigProjection(current, event) {
 	switch (event.type) {
 		case "snapshot": return some({
@@ -52,7 +144,7 @@ const makeEnvironmentServerConfigState = fn("EnvironmentServerConfigState.make")
 	const supervisor = yield* EnvironmentSupervisor;
 	const cache = yield* EnvironmentCacheStore;
 	const environmentId = supervisor.target.environmentId;
-	const state = yield* make(map(yield* cache.loadServerConfig(environmentId).pipe(catch_((error) => logWarning("Could not load cached server configuration.").pipe(annotateLogs({
+	const state = yield* make$1(map(yield* cache.loadServerConfig(environmentId).pipe(catch_((error) => logWarning("Could not load cached server configuration.").pipe(annotateLogs({
 		environmentId,
 		...safeErrorLogAttributes(error)
 	}), as(none())))), (config) => ({
@@ -61,7 +153,7 @@ const makeEnvironmentServerConfigState = fn("EnvironmentServerConfigState.make")
 		source: "cache"
 	})));
 	const persistence = yield* sliding(1);
-	const pendingPersistence = yield* make$1(none());
+	const pendingPersistence = yield* make$2(none());
 	const persist = fn("EnvironmentServerConfigState.persist")(function* (config) {
 		return yield* cache.saveServerConfig(environmentId, config).pipe(as(true), catch_((error) => logWarning("Could not persist cached server configuration.").pipe(annotateLogs({
 			environmentId,
@@ -89,7 +181,7 @@ const makeEnvironmentServerConfigState = fn("EnvironmentServerConfigState.make")
 function serverConfigStateChanges(environmentId) {
 	return followStreamInEnvironment(environmentId, unwrap(makeEnvironmentServerConfigState().pipe(map$1((state) => changes(state).pipe(filterMap((projection) => match(projection, {
 		onNone: () => failVoid,
-		onSome: (value) => succeed(value)
+		onSome: (value) => succeed$1(value)
 	})))))));
 }
 function projectServerWelcome(current, event) {
@@ -98,31 +190,115 @@ function projectServerWelcome(current, event) {
 	return [some(welcome), [welcome]];
 }
 function resolveServerConfigValue(projection, initialConfig) {
-	if (projection?.source === "live") return projection.config;
+	if (projection?.source === "live" && (initialConfig === null || projection.config.environment.serverVersion === initialConfig.environment.serverVersion)) return projection.config;
 	return initialConfig ?? projection?.config ?? null;
 }
 function createServerEnvironmentAtoms(runtime, options) {
 	const configScheduler = createAtomCommandScheduler();
+	const updateScheduler = createAtomCommandScheduler();
 	const configConcurrency = {
 		mode: "serial",
 		key: ({ environmentId }) => environmentId
 	};
 	const configProjectionFamily = family((environmentId) => runtime.atom(serverConfigStateChanges(environmentId)).pipe(setIdleTTL(5 * 6e4), withLabel(`environment-data:server:config-projection:${environmentId}`)));
 	const configProjection = (target) => configProjectionFamily(target.environmentId);
-	const emptyConfigAtom = make$2(null).pipe(withLabel("environment-data:server:config:empty"));
+	const emptyConfigAtom = make(null).pipe(withLabel("environment-data:server:config:empty"));
 	const configValueAtom = family((environmentId) => {
 		if (environmentId === null) return emptyConfigAtom;
-		return make$2((get) => {
+		return make((get) => {
 			return resolveServerConfigValue(getOrNull(value(get(configProjection({
 				environmentId,
 				input: {}
 			})))), get(options.initialConfigValueAtom(environmentId)));
 		}).pipe(withLabel(`environment-data:server:config:${environmentId}`));
 	});
+	const updateStateValueAtom = family((environmentId) => make((get) => serverUpdateStateForServerVersion(get(serverUpdateStateAtom(environmentId)), get(configValueAtom(environmentId))?.environment.serverVersion ?? null)).pipe(withLabel(`environment-data:server:update-state-value:${environmentId}`)));
+	const updateStateAtom = (environmentId) => environmentId === null ? EMPTY_SERVER_UPDATE_STATE_ATOM : updateStateValueAtom(environmentId);
+	const updateServer = createRuntimeCommand(runtime, {
+		label: "environment-data:server:update-server",
+		scheduler: updateScheduler,
+		concurrency: configConcurrency,
+		execute: (target, atomRegistry) => {
+			const stateAtom = serverUpdateStateAtom(target.environmentId);
+			const targetVersion = target.input.targetVersion;
+			let fromVersion = atomRegistry.get(configValueAtom(target.environmentId))?.environment.serverVersion ?? targetVersion;
+			let currentStage = "downloading";
+			atomRegistry.set(stateAtom, {
+				status: "running",
+				stage: currentStage,
+				fromVersion,
+				targetVersion
+			});
+			return gen(function* () {
+				const environmentRegistry = yield* EnvironmentRegistry;
+				const result = yield* scheduleAtomCommandEffect(atomRegistry, configScheduler, configConcurrency, target, gen(function* () {
+					const currentConfig = atomRegistry.get(configValueAtom(target.environmentId));
+					fromVersion = currentConfig?.environment.serverVersion ?? targetVersion;
+					atomRegistry.set(stateAtom, {
+						status: "running",
+						stage: currentStage,
+						fromVersion,
+						targetVersion
+					});
+					const updateResult = currentConfig?.environment.capabilities.serverSelfUpdateProgress === true ? yield* gen(function* () {
+						const terminal = yield* make$2(none());
+						const streamExit = yield* environmentRegistry.runStream(target.environmentId, runStream(WS_METHODS.serverUpdateServerWithProgress, target.input)).pipe(runForEach((event) => sync(() => {
+							currentStage = event.type === "complete" ? "resuming" : event.stage;
+							atomRegistry.set(stateAtom, serverUpdateStateForProgressEvent(fromVersion, targetVersion, event));
+						}).pipe(andThen(event.type === "complete" ? set(terminal, some(event.result)) : void_))), exit);
+						return yield* resolveServerUpdateProgressResult(targetVersion, yield* get$1(terminal), streamExit);
+					}) : yield* gen(function* () {
+						const selfUpdateMethod = currentConfig?.environment.capabilities.serverSelfUpdate;
+						const exit$1 = yield* environmentRegistry.run(target.environmentId, request(WS_METHODS.serverUpdateServer, target.input)).pipe(exit);
+						if (isSuccess(exit$1)) return exit$1.value;
+						if ((selfUpdateMethod === "boot-service" || selfUpdateMethod === "respawn") && isLegacyUpdateHandoffLoss(exit$1.cause)) return {
+							targetVersion,
+							method: selfUpdateMethod
+						};
+						return yield* failCause(exit$1.cause);
+					});
+					currentStage = "resuming";
+					atomRegistry.set(stateAtom, {
+						status: "running",
+						stage: currentStage,
+						fromVersion,
+						targetVersion
+					});
+					return updateResult;
+				}));
+				yield* nudgeReconnectDuringUpdateRestart({
+					stateChanges: environmentRegistry.stateChanges(target.environmentId),
+					retryNow: environmentRegistry.retryNow(target.environmentId)
+				}).pipe(forkChild);
+				const resumed = yield* environmentRegistry.followStream(target.environmentId, subscribe(WS_METHODS.subscribeServerLifecycle, {})).pipe(filter((event) => event.type === "ready" && matchesServerUpdateReadyEvent(result, event)), runHead, timeoutOption(SERVER_UPDATE_RESUME_TIMEOUT), map$1(flatten));
+				if (isNone(resumed)) return yield* new ServerUpdateResumeTimeoutError({
+					environmentId: target.environmentId,
+					targetVersion
+				});
+				yield* validateServerUpdateReadyEvent(result, resumed.value);
+				atomRegistry.set(stateAtom, IDLE_SERVER_UPDATE_STATE);
+				return result;
+			}).pipe(onExit((exit) => sync(() => {
+				if (isSuccess(exit)) return;
+				if (hasInterruptsOnly(exit.cause)) {
+					atomRegistry.set(stateAtom, IDLE_SERVER_UPDATE_STATE);
+					return;
+				}
+				atomRegistry.set(stateAtom, {
+					status: "failed",
+					stage: currentStage,
+					fromVersion,
+					targetVersion,
+					message: serverUpdateFailureMessage(squash(exit.cause))
+				});
+			})));
+		}
+	});
 	return {
 		configValueAtom,
-		settingsValueAtom: family((environmentId) => make$2((get) => get(configValueAtom(environmentId))?.settings ?? null).pipe(withLabel(`environment-data:server:settings:${environmentId}`))),
-		providersValueAtom: family((environmentId) => make$2((get) => get(configValueAtom(environmentId))?.providers ?? null).pipe(withLabel(`environment-data:server:providers:${environmentId}`))),
+		updateStateAtom,
+		settingsValueAtom: family((environmentId) => make((get) => get(configValueAtom(environmentId))?.settings ?? null).pipe(withLabel(`environment-data:server:settings:${environmentId}`))),
+		providersValueAtom: family((environmentId) => make((get) => get(configValueAtom(environmentId))?.providers ?? null).pipe(withLabel(`environment-data:server:providers:${environmentId}`))),
 		traceDiagnostics: createEnvironmentRpcQueryAtomFamily(runtime, {
 			label: "environment-data:server:trace-diagnostics",
 			tag: WS_METHODS.serverGetTraceDiagnostics
@@ -145,6 +321,11 @@ function createServerEnvironmentAtoms(runtime, options) {
 			tag: WS_METHODS.serverGetResourceTelemetryHistory,
 			staleTimeMs: 5e3
 		}),
+		usageSummary: createEnvironmentRpcQueryAtomFamily(runtime, {
+			label: "environment-data:server:usage-summary",
+			tag: WS_METHODS.serverGetUsageSummary,
+			staleTimeMs: 6e4
+		}),
 		configProjection,
 		welcome: createEnvironmentRpcSubscriptionAtomFamily(runtime, {
 			label: "environment-data:server:welcome",
@@ -165,12 +346,7 @@ function createServerEnvironmentAtoms(runtime, options) {
 			scheduler: configScheduler,
 			concurrency: configConcurrency
 		}),
-		updateServer: createEnvironmentRpcCommand(runtime, {
-			label: "environment-data:server:update-server",
-			tag: WS_METHODS.serverUpdateServer,
-			scheduler: configScheduler,
-			concurrency: configConcurrency
-		}),
+		updateServer,
 		upsertKeybinding: createEnvironmentRpcCommand(runtime, {
 			label: "environment-data:server:upsert-keybinding",
 			tag: WS_METHODS.serverUpsertKeybinding,
@@ -204,4 +380,4 @@ function createServerEnvironmentAtoms(runtime, options) {
 	};
 }
 //#endregion
-export { applyServerConfigProjection, createServerEnvironmentAtoms, makeEnvironmentServerConfigState, projectServerConfig, projectServerWelcome, resolveServerConfigValue, serverConfigStateChanges };
+export { ServerUpdateProgressIncompleteError, ServerUpdateResumeTimeoutError, ServerUpdateTerminalError, applyServerConfigProjection, createServerEnvironmentAtoms, isLegacyUpdateHandoffLoss, makeEnvironmentServerConfigState, matchesServerUpdateReadyEvent, nudgeReconnectDuringUpdateRestart, projectServerConfig, projectServerWelcome, resolveServerConfigValue, resolveServerUpdateProgressResult, serverConfigStateChanges, serverUpdateStateForProgressEvent, serverUpdateStateForServerVersion, validateServerUpdateReadyEvent };

package/dist/client-runtime/state/session.d.ts

@@ -1,10 +1,32 @@
-import { Fl as ServerConfig, Ku as KeybindingWhenNode, es as PreparedConnection, ha as EnvironmentRegistry } from "../../shared.js";
+import { $a as RemoteEnvironmentRequestError, Ta as EnvironmentRegistry, Td as KeybindingWhenNode, bo as ManagedRelayDpopSigner, du as ServerConfig, us as PreparedConnection } from "../../shared.js";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
+import { HttpClient } from "effect/unstable/http";
 import { AsyncResult, Atom } from "effect/unstable/reactivity";
 //#region upstream-t3code/packages/client-runtime/src/state/session.d.ts
 declare function initialConfigOption<E>(initialConfig: Effect.Effect<ServerConfig, E>): Effect.Effect<Option.Option<ServerConfig>>;
-declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {
+/**
+ * Read the granted scopes of this client's session on one environment via its
+ * `/api/auth/session` endpoint, authenticated with whatever credential the
+ * connection was prepared with (cookie, bearer, or DPoP).
+ */
+declare const fetchEnvironmentSessionState: (input: {
+  readonly prepared: PreparedConnection;
+  readonly signer: Option.Option<ManagedRelayDpopSigner["Service"]>;
+  readonly timeoutMs?: number;
+}) => Effect.Effect<{
+  readonly authenticated: boolean;
+  readonly auth: {
+    readonly policy: "desktop-managed-local" | "loopback-browser" | "remote-reachable" | "unsafe-no-auth";
+    readonly bootstrapMethods: readonly ("desktop-bootstrap" | "one-time-token")[];
+    readonly sessionMethods: readonly ("bearer-access-token" | "browser-session-cookie" | "dpop-access-token")[];
+    readonly sessionCookieName: string;
+  };
+  readonly scopes?: readonly ("access:read" | "access:write" | "orchestration:operate" | "orchestration:read" | "relay:read" | "relay:write" | "review:write" | "terminal:operate")[];
+  readonly sessionMethod?: "bearer-access-token" | "browser-session-cookie" | "dpop-access-token";
+  readonly expiresAt?: import("effect/DateTime").Utc;
+}, RemoteEnvironmentRequestError, HttpClient.HttpClient>;
+declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | HttpClient.HttpClient | R, E>): {
   initialConfigAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<AsyncResult.AsyncResult<Option.Option<{
     readonly environment: {
       readonly environmentId: string & import("effect/Brand").Brand<"EnvironmentId">;
@@ -19,7 +41,11 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
         readonly connectionProbe?: boolean;
         readonly threadSettlement?: boolean;
         readonly threadSnooze?: boolean;
+        readonly threadPinning?: boolean;
+        readonly threadPinReorder?: boolean;
+        readonly threadTitleRegeneration?: boolean;
         readonly serverSelfUpdate?: "boot-service" | "desktop-managed" | "respawn";
+        readonly serverSelfUpdateProgress?: boolean;
       };
     };
     readonly auth: {
@@ -31,7 +57,7 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
     readonly cwd: string;
     readonly keybindingsConfigPath: string;
     readonly keybindings: readonly {
-      readonly command: "chat.new" | "chat.newLocal" | "commandPalette.toggle" | "composer.stash" | "diff.toggle" | "editor.openFavorite" | "modelPicker.jump.1" | "modelPicker.jump.2" | "modelPicker.jump.3" | "modelPicker.jump.4" | "modelPicker.jump.5" | "modelPicker.jump.6" | "modelPicker.jump.7" | "modelPicker.jump.8" | "modelPicker.jump.9" | "modelPicker.toggle" | "preview.focusUrl" | "preview.refresh" | "preview.resetZoom" | "preview.toggle" | "preview.zoomIn" | "preview.zoomOut" | "rightPanel.toggle" | "sidebar.toggle" | "terminal.close" | "terminal.new" | "terminal.split" | "terminal.splitVertical" | "terminal.toggle" | "thread.jump.1" | "thread.jump.2" | "thread.jump.3" | "thread.jump.4" | "thread.jump.5" | "thread.jump.6" | "thread.jump.7" | "thread.jump.8" | "thread.jump.9" | "thread.next" | "thread.previous" | `script.${string}.run`;
+      readonly command: "chat.new" | "chat.newLocal" | "commandPalette.toggle" | "composer.stash" | "diff.toggle" | "editor.openFavorite" | "filePicker.toggle" | "modelPicker.jump.1" | "modelPicker.jump.2" | "modelPicker.jump.3" | "modelPicker.jump.4" | "modelPicker.jump.5" | "modelPicker.jump.6" | "modelPicker.jump.7" | "modelPicker.jump.8" | "modelPicker.jump.9" | "modelPicker.toggle" | "preview.focusUrl" | "preview.refresh" | "preview.resetZoom" | "preview.toggle" | "preview.zoomIn" | "preview.zoomOut" | "projectSearch.toggle" | "rightPanel.toggle" | "sidebar.toggle" | "terminal.close" | "terminal.new" | "terminal.split" | "terminal.splitVertical" | "terminal.toggle" | "themeEditor.toggle" | "thread.jump.1" | "thread.jump.2" | "thread.jump.3" | "thread.jump.4" | "thread.jump.5" | "thread.jump.6" | "thread.jump.7" | "thread.jump.8" | "thread.jump.9" | "thread.next" | "thread.previous" | `script.${string}.run`;
       readonly shortcut: {
         readonly key: string;
         readonly metaKey: boolean;
@@ -96,6 +122,7 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
         readonly subProvider?: string | undefined;
         readonly isCustom: boolean;
         readonly isDefault?: boolean | undefined;
+        readonly isLegacy?: boolean | undefined;
         readonly capabilities: {
           readonly optionDescriptors?: readonly ({
             readonly id: string;
@@ -162,7 +189,7 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
       readonly otlpMetricsEnabled: boolean;
     };
     readonly settings: {
-      readonly enableAssistantStreaming: boolean;
+      readonly enableLegacyTokenStreaming: boolean;
       readonly enableProviderUpdateChecks: boolean;
       readonly backgroundActivity: {
         readonly schemaVersion: 1;
@@ -264,6 +291,7 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
     };
     readonly shellResumeCompletionMarker?: boolean;
     readonly threadResumeCompletionMarker?: boolean;
+    readonly threadSnapshotPagination?: boolean;
   }>, E | import("effect/Cause").NoSuchElementError>>;
   initialConfigValueAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<{
     readonly environment: {
@@ -279,7 +307,11 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
         readonly connectionProbe?: boolean;
         readonly threadSettlement?: boolean;
         readonly threadSnooze?: boolean;
+        readonly threadPinning?: boolean;
+        readonly threadPinReorder?: boolean;
+        readonly threadTitleRegeneration?: boolean;
         readonly serverSelfUpdate?: "boot-service" | "desktop-managed" | "respawn";
+        readonly serverSelfUpdateProgress?: boolean;
       };
     };
     readonly auth: {
@@ -291,7 +323,7 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
     readonly cwd: string;
     readonly keybindingsConfigPath: string;
     readonly keybindings: readonly {
-      readonly command: "chat.new" | "chat.newLocal" | "commandPalette.toggle" | "composer.stash" | "diff.toggle" | "editor.openFavorite" | "modelPicker.jump.1" | "modelPicker.jump.2" | "modelPicker.jump.3" | "modelPicker.jump.4" | "modelPicker.jump.5" | "modelPicker.jump.6" | "modelPicker.jump.7" | "modelPicker.jump.8" | "modelPicker.jump.9" | "modelPicker.toggle" | "preview.focusUrl" | "preview.refresh" | "preview.resetZoom" | "preview.toggle" | "preview.zoomIn" | "preview.zoomOut" | "rightPanel.toggle" | "sidebar.toggle" | "terminal.close" | "terminal.new" | "terminal.split" | "terminal.splitVertical" | "terminal.toggle" | "thread.jump.1" | "thread.jump.2" | "thread.jump.3" | "thread.jump.4" | "thread.jump.5" | "thread.jump.6" | "thread.jump.7" | "thread.jump.8" | "thread.jump.9" | "thread.next" | "thread.previous" | `script.${string}.run`;
+      readonly command: "chat.new" | "chat.newLocal" | "commandPalette.toggle" | "composer.stash" | "diff.toggle" | "editor.openFavorite" | "filePicker.toggle" | "modelPicker.jump.1" | "modelPicker.jump.2" | "modelPicker.jump.3" | "modelPicker.jump.4" | "modelPicker.jump.5" | "modelPicker.jump.6" | "modelPicker.jump.7" | "modelPicker.jump.8" | "modelPicker.jump.9" | "modelPicker.toggle" | "preview.focusUrl" | "preview.refresh" | "preview.resetZoom" | "preview.toggle" | "preview.zoomIn" | "preview.zoomOut" | "projectSearch.toggle" | "rightPanel.toggle" | "sidebar.toggle" | "terminal.close" | "terminal.new" | "terminal.split" | "terminal.splitVertical" | "terminal.toggle" | "themeEditor.toggle" | "thread.jump.1" | "thread.jump.2" | "thread.jump.3" | "thread.jump.4" | "thread.jump.5" | "thread.jump.6" | "thread.jump.7" | "thread.jump.8" | "thread.jump.9" | "thread.next" | "thread.previous" | `script.${string}.run`;
       readonly shortcut: {
         readonly key: string;
         readonly metaKey: boolean;
@@ -356,6 +388,7 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
         readonly subProvider?: string | undefined;
         readonly isCustom: boolean;
         readonly isDefault?: boolean | undefined;
+        readonly isLegacy?: boolean | undefined;
         readonly capabilities: {
           readonly optionDescriptors?: readonly ({
             readonly id: string;
@@ -422,7 +455,7 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
       readonly otlpMetricsEnabled: boolean;
     };
     readonly settings: {
-      readonly enableAssistantStreaming: boolean;
+      readonly enableLegacyTokenStreaming: boolean;
       readonly enableProviderUpdateChecks: boolean;
       readonly backgroundActivity: {
         readonly schemaVersion: 1;
@@ -524,9 +557,34 @@ declare function createEnvironmentSessionAtoms<R, E>(runtime: Atom.AtomRuntime<E
     };
     readonly shellResumeCompletionMarker?: boolean;
     readonly threadResumeCompletionMarker?: boolean;
+    readonly threadSnapshotPagination?: boolean;
   } | null>;
   preparedConnectionAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<AsyncResult.AsyncResult<Option.Option<PreparedConnection>, E | import("effect/Cause").NoSuchElementError>>;
   preparedConnectionValueAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<Option.Option<PreparedConnection>>;
+  sessionStateAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<AsyncResult.AsyncResult<{
+    readonly authenticated: boolean;
+    readonly auth: {
+      readonly policy: "desktop-managed-local" | "loopback-browser" | "remote-reachable" | "unsafe-no-auth";
+      readonly bootstrapMethods: readonly ("desktop-bootstrap" | "one-time-token")[];
+      readonly sessionMethods: readonly ("bearer-access-token" | "browser-session-cookie" | "dpop-access-token")[];
+      readonly sessionCookieName: string;
+    };
+    readonly scopes?: readonly ("access:read" | "access:write" | "orchestration:operate" | "orchestration:read" | "relay:read" | "relay:write" | "review:write" | "terminal:operate")[];
+    readonly sessionMethod?: "bearer-access-token" | "browser-session-cookie" | "dpop-access-token";
+    readonly expiresAt?: import("effect/DateTime").Utc;
+  }, E | RemoteEnvironmentRequestError>>;
+  sessionStateValueAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<{
+    readonly authenticated: boolean;
+    readonly auth: {
+      readonly policy: "desktop-managed-local" | "loopback-browser" | "remote-reachable" | "unsafe-no-auth";
+      readonly bootstrapMethods: readonly ("desktop-bootstrap" | "one-time-token")[];
+      readonly sessionMethods: readonly ("bearer-access-token" | "browser-session-cookie" | "dpop-access-token")[];
+      readonly sessionCookieName: string;
+    };
+    readonly scopes?: readonly ("access:read" | "access:write" | "orchestration:operate" | "orchestration:read" | "relay:read" | "relay:write" | "review:write" | "terminal:operate")[];
+    readonly sessionMethod?: "bearer-access-token" | "browser-session-cookie" | "dpop-access-token";
+    readonly expiresAt?: import("effect/DateTime").Utc;
+  } | null>;
 };
 //#endregion
-export { createEnvironmentSessionAtoms, initialConfigOption };
+export { createEnvironmentSessionAtoms, fetchEnvironmentSessionState, initialConfigOption };

package/dist/client-runtime/state/session.js

@@ -1,8 +1,20 @@
-import { Aa as EnvironmentSupervisor, EO as succeed, Fk as getOrElse, Gr as family, HD as as, Hk as match, Ik as getOrNull, JE as mapEffect, Na as safeErrorLogAttributes, Sv as changes, Uk as none, VD as annotateLogs, Wk as some, Xr as withLabel, YD as catch_, lD as unwrap, lO as logWarning, qr as make, ti as value, uO as map, xr as followStreamInEnvironment } from "../../shared.js";
+import { $r as make, Aj as none, Ba as safeErrorLogAttributes, Bk as gen, Bo as makeEnvironmentHttpApiClient, Br as buildEnvironmentAuthHeaders, Cj as getOrNull, Dk as catch_, Gk as map, Ia as EnvironmentSupervisor, PO as mapEffect, Pk as fn, Py as changes, Sj as getOrElse, Tr as followStreamInEnvironment, Uo as environmentEndpointUrl, Vr as withEnvironmentCredentials, Wk as logWarning, YO as unwrap, Yk as never, Zr as family, bk as as, cA as succeed, ei as setIdleTTL, jj as some, kj as match, ni as withLabel, oA as serviceOption, si as value, ti as swr, to as ManagedRelayDpopSigner, yk as annotateLogs, zo as executeEnvironmentHttpRequest } from "../../shared.js";
 //#region upstream-t3code/packages/client-runtime/src/state/session.ts
 function initialConfigOption(initialConfig) {
 	return initialConfig.pipe(map(some), catch_((error) => logWarning("Could not load the initial environment configuration.").pipe(annotateLogs({ ...safeErrorLogAttributes(error) }), as(none()))));
 }
+const DEFAULT_SESSION_STATE_TIMEOUT_MS = 6e3;
+/**
+* Read the granted scopes of this client's session on one environment via its
+* `/api/auth/session` endpoint, authenticated with whatever credential the
+* connection was prepared with (cookie, bearer, or DPoP).
+*/
+const fetchEnvironmentSessionState = fn("clientRuntime.state.fetchEnvironmentSessionState")(function* (input) {
+	const requestUrl = environmentEndpointUrl(input.prepared.httpBaseUrl, "/api/auth/session");
+	const client = yield* makeEnvironmentHttpApiClient(input.prepared.httpBaseUrl);
+	const headers = yield* buildEnvironmentAuthHeaders(input.prepared.httpAuthorization, "GET", requestUrl, input.signer);
+	return yield* executeEnvironmentHttpRequest(requestUrl, input.timeoutMs ?? DEFAULT_SESSION_STATE_TIMEOUT_MS, withEnvironmentCredentials(input.prepared.httpAuthorization, client.auth.session({ headers })));
+});
 function createEnvironmentSessionAtoms(runtime) {
 	const initialConfigAtom = family((environmentId) => runtime.atom(followStreamInEnvironment(environmentId, unwrap(EnvironmentSupervisor.pipe(map((supervisor) => changes(supervisor.session).pipe(mapEffect(match({
 		onNone: () => succeed(none()),
@@ -10,12 +22,29 @@ function createEnvironmentSessionAtoms(runtime) {
 	}))))))), { initialValue: none() }));
 	const initialConfigValueAtom = family((environmentId) => make((get) => getOrNull(getOrElse(value(get(initialConfigAtom(environmentId))), () => none()))).pipe(withLabel(`environment-config-value:${environmentId}`)));
 	const preparedConnectionAtom = family((environmentId) => runtime.atom(followStreamInEnvironment(environmentId, unwrap(EnvironmentSupervisor.pipe(map((supervisor) => changes(supervisor.prepared))))), { initialValue: none() }));
+	const preparedConnectionValueAtom = family((environmentId) => make((get) => getOrElse(value(get(preparedConnectionAtom(environmentId))), () => none())).pipe(withLabel(`environment-prepared-connection:${environmentId}`)));
+	const sessionStateAtom = family((environmentId) => runtime.atom((get) => {
+		const prepared = getOrNull(get(preparedConnectionValueAtom(environmentId)));
+		if (prepared === null) return never;
+		return gen(function* () {
+			const signer = yield* serviceOption(ManagedRelayDpopSigner);
+			return yield* fetchEnvironmentSessionState({
+				prepared,
+				signer
+			});
+		});
+	}).pipe(swr({
+		staleTime: 3e4,
+		revalidateOnMount: true
+	}), setIdleTTL(5 * 6e4), withLabel(`environment-session-state:${environmentId}`)));
 	return {
 		initialConfigAtom,
 		initialConfigValueAtom,
 		preparedConnectionAtom,
-		preparedConnectionValueAtom: family((environmentId) => make((get) => getOrElse(value(get(preparedConnectionAtom(environmentId))), () => none())).pipe(withLabel(`environment-prepared-connection:${environmentId}`)))
+		preparedConnectionValueAtom,
+		sessionStateAtom,
+		sessionStateValueAtom: family((environmentId) => make((get) => getOrNull(value(get(sessionStateAtom(environmentId)))) ?? null).pipe(withLabel(`environment-session-state-value:${environmentId}`)))
 	};
 }
 //#endregion
-export { createEnvironmentSessionAtoms, initialConfigOption };
+export { createEnvironmentSessionAtoms, fetchEnvironmentSessionState, initialConfigOption };

package/dist/client-runtime/state/shell.d.ts

@@ -1,4 +1,4 @@
-import { Ca as EnvironmentCacheStore, Cl as ExternalLauncherBrowserSpawnError, Dl as ExternalLauncherUnknownEditorError, Fl as ServerConfig, Ku as KeybindingWhenNode, Ol as ExternalLauncherUnsupportedEditorError, Tl as ExternalLauncherEditorSpawnError, Ua as RemoteEnvironmentRequestError, _a as EnvironmentSupervisor, at as EnvironmentThreadShell, bT as EnvironmentAuthorizationError, ct as scopeThreadShell, cv as OrchestrationShellSnapshot, es as PreparedConnection, f as AtomCommand, ha as EnvironmentRegistry, it as EnvironmentThread, lt as selectEnvironmentThreadShell, lv as OrchestrationShellStreamEvent, ma as EnvironmentNotRegisteredError, nt as EnvironmentMessage, on as EnvironmentRpcUnavailableError, ot as scopeProject, rt as EnvironmentProject, st as scopeThread, u as EnvironmentCatalogState, uo as ManagedRelayDpopSigner, wl as ExternalLauncherCommandNotFoundError, zT as EnvironmentId } from "../../shared.js";
+import { $a as RemoteEnvironmentRequestError, $l as ExternalLauncherBrowserSpawnError, CD as EnvironmentId, Da as EnvironmentSupervisor, Na as EnvironmentCacheStore, Oy as OrchestrationShellSnapshot, Ta as EnvironmentRegistry, Td as KeybindingWhenNode, at as EnvironmentProject, bo as ManagedRelayDpopSigner, ct as scopeProject, dt as selectEnvironmentThreadShell, du as ServerConfig, eu as ExternalLauncherCommandNotFoundError, f as AtomCommand, iD as EnvironmentAuthorizationError, it as EnvironmentMessage, iu as ExternalLauncherUnsupportedEditorError, ky as OrchestrationShellStreamEvent, lt as scopeThread, mn as EnvironmentRpcUnavailableError, ot as EnvironmentThread, ru as ExternalLauncherUnknownEditorError, st as EnvironmentThreadShell, tu as ExternalLauncherEditorSpawnError, u as EnvironmentCatalogState, us as PreparedConnection, ut as scopeThreadShell, wa as EnvironmentNotRegisteredError } from "../../shared.js";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
@@ -46,6 +46,8 @@ declare const fetchEnvironmentShellSnapshot: (input: {
         readonly value: string | boolean;
       }[];
     } | null;
+    readonly defaultThreadEnvMode?: "local" | "worktree" | null | undefined;
+    readonly faviconPath?: string | null | undefined;
     readonly scripts: readonly {
       readonly id: string;
       readonly name: string;
@@ -93,6 +95,12 @@ declare const fetchEnvironmentShellSnapshot: (input: {
     readonly settledAt: string | null;
     readonly snoozedUntil?: string | null | undefined;
     readonly snoozedAt?: string | null | undefined;
+    readonly pinnedAt?: string | null | undefined;
+    readonly pinOrderKey?: string | null | undefined;
+    readonly titleRegeneration?: {
+      readonly requestId: string & import("effect/Brand").Brand<"CommandId">;
+      readonly startedAt: string;
+    } | null | undefined;
     readonly session: {
       readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
       readonly status: "error" | "idle" | "interrupted" | "ready" | "running" | "starting" | "stopped";
@@ -107,6 +115,12 @@ declare const fetchEnvironmentShellSnapshot: (input: {
     readonly hasPendingApprovals: boolean;
     readonly hasPendingUserInput: boolean;
     readonly hasActionableProposedPlan: boolean;
+    readonly backgroundLiveness?: "monitoring" | "working" | null | undefined;
+    readonly planProgress?: {
+      readonly step: string;
+      readonly completedSteps: number;
+      readonly totalSteps: number;
+    } | null | undefined;
   }[];
   readonly updatedAt: string;
 }, RemoteEnvironmentRequestError, HttpClient.HttpClient>;
@@ -126,10 +140,10 @@ declare const shellSnapshotLoaderLayer: Layer.Layer<ShellSnapshotLoader, never,
 declare function createShellEnvironmentAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>): {
   openInEditor: AtomCommand<{
     readonly environmentId: EnvironmentId;
-    readonly input: import("effect/Schema").Struct.ReadonlyMakeIn<{
-      readonly cwd: import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>;
-      readonly editor: import("effect/Schema").Literals<("antigravity" | "aqua" | "clion" | "cursor" | "datagrip" | "dataspell" | "file-manager" | "goland" | "idea" | "kiro" | "phpstorm" | "pycharm" | "rider" | "rubymine" | "rustrover" | "trae" | "vscode" | "vscode-insiders" | "vscodium" | "webstorm" | "zed")[]>;
-    }>;
+    readonly input: {
+      readonly cwd: string;
+      readonly editor: "antigravity" | "aqua" | "clion" | "cursor" | "datagrip" | "dataspell" | "file-manager" | "goland" | "idea" | "kiro" | "phpstorm" | "pycharm" | "rider" | "rubymine" | "rustrover" | "trae" | "vscode" | "vscode-insiders" | "vscodium" | "webstorm" | "zed";
+    };
   }, void, E | EnvironmentAuthorizationError | EnvironmentNotRegisteredError | EnvironmentRpcUnavailableError | ExternalLauncherBrowserSpawnError | ExternalLauncherCommandNotFoundError | ExternalLauncherEditorSpawnError | ExternalLauncherUnknownEditorError | ExternalLauncherUnsupportedEditorError | import("effect/unstable/rpc/RpcClientError").RpcClientError>;
 };
 //#endregion
@@ -172,6 +186,8 @@ declare function createEnvironmentSnapshotAtom<E>(shellStateAtom: (environmentId
         readonly value: string | boolean;
       }[];
     } | null;
+    readonly defaultThreadEnvMode?: "local" | "worktree" | null | undefined;
+    readonly faviconPath?: string | null | undefined;
     readonly scripts: readonly {
       readonly id: string;
       readonly name: string;
@@ -219,6 +235,12 @@ declare function createEnvironmentSnapshotAtom<E>(shellStateAtom: (environmentId
     readonly settledAt: string | null;
     readonly snoozedUntil?: string | null | undefined;
     readonly snoozedAt?: string | null | undefined;
+    readonly pinnedAt?: string | null | undefined;
+    readonly pinOrderKey?: string | null | undefined;
+    readonly titleRegeneration?: {
+      readonly requestId: string & import("effect/Brand").Brand<"CommandId">;
+      readonly startedAt: string;
+    } | null | undefined;
     readonly session: {
       readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
       readonly status: "error" | "idle" | "interrupted" | "ready" | "running" | "starting" | "stopped";
@@ -233,6 +255,12 @@ declare function createEnvironmentSnapshotAtom<E>(shellStateAtom: (environmentId
     readonly hasPendingApprovals: boolean;
     readonly hasPendingUserInput: boolean;
     readonly hasActionableProposedPlan: boolean;
+    readonly backgroundLiveness?: "monitoring" | "working" | null | undefined;
+    readonly planProgress?: {
+      readonly step: string;
+      readonly completedSteps: number;
+      readonly totalSteps: number;
+    } | null | undefined;
   }[];
   readonly updatedAt: string;
 } | null>;
@@ -275,7 +303,11 @@ declare function createEnvironmentServerConfigsAtom(input: {
       readonly connectionProbe?: boolean;
       readonly threadSettlement?: boolean;
       readonly threadSnooze?: boolean;
+      readonly threadPinning?: boolean;
+      readonly threadPinReorder?: boolean;
+      readonly threadTitleRegeneration?: boolean;
       readonly serverSelfUpdate?: "boot-service" | "desktop-managed" | "respawn";
+      readonly serverSelfUpdateProgress?: boolean;
     };
   };
   readonly auth: {
@@ -287,7 +319,7 @@ declare function createEnvironmentServerConfigsAtom(input: {
   readonly cwd: string;
   readonly keybindingsConfigPath: string;
   readonly keybindings: readonly {
-    readonly command: "chat.new" | "chat.newLocal" | "commandPalette.toggle" | "composer.stash" | "diff.toggle" | "editor.openFavorite" | "modelPicker.jump.1" | "modelPicker.jump.2" | "modelPicker.jump.3" | "modelPicker.jump.4" | "modelPicker.jump.5" | "modelPicker.jump.6" | "modelPicker.jump.7" | "modelPicker.jump.8" | "modelPicker.jump.9" | "modelPicker.toggle" | "preview.focusUrl" | "preview.refresh" | "preview.resetZoom" | "preview.toggle" | "preview.zoomIn" | "preview.zoomOut" | "rightPanel.toggle" | "sidebar.toggle" | "terminal.close" | "terminal.new" | "terminal.split" | "terminal.splitVertical" | "terminal.toggle" | "thread.jump.1" | "thread.jump.2" | "thread.jump.3" | "thread.jump.4" | "thread.jump.5" | "thread.jump.6" | "thread.jump.7" | "thread.jump.8" | "thread.jump.9" | "thread.next" | "thread.previous" | `script.${string}.run`;
+    readonly command: "chat.new" | "chat.newLocal" | "commandPalette.toggle" | "composer.stash" | "diff.toggle" | "editor.openFavorite" | "filePicker.toggle" | "modelPicker.jump.1" | "modelPicker.jump.2" | "modelPicker.jump.3" | "modelPicker.jump.4" | "modelPicker.jump.5" | "modelPicker.jump.6" | "modelPicker.jump.7" | "modelPicker.jump.8" | "modelPicker.jump.9" | "modelPicker.toggle" | "preview.focusUrl" | "preview.refresh" | "preview.resetZoom" | "preview.toggle" | "preview.zoomIn" | "preview.zoomOut" | "projectSearch.toggle" | "rightPanel.toggle" | "sidebar.toggle" | "terminal.close" | "terminal.new" | "terminal.split" | "terminal.splitVertical" | "terminal.toggle" | "themeEditor.toggle" | "thread.jump.1" | "thread.jump.2" | "thread.jump.3" | "thread.jump.4" | "thread.jump.5" | "thread.jump.6" | "thread.jump.7" | "thread.jump.8" | "thread.jump.9" | "thread.next" | "thread.previous" | `script.${string}.run`;
     readonly shortcut: {
       readonly key: string;
       readonly metaKey: boolean;
@@ -352,6 +384,7 @@ declare function createEnvironmentServerConfigsAtom(input: {
       readonly subProvider?: string | undefined;
       readonly isCustom: boolean;
       readonly isDefault?: boolean | undefined;
+      readonly isLegacy?: boolean | undefined;
       readonly capabilities: {
         readonly optionDescriptors?: readonly ({
           readonly id: string;
@@ -418,7 +451,7 @@ declare function createEnvironmentServerConfigsAtom(input: {
     readonly otlpMetricsEnabled: boolean;
   };
   readonly settings: {
-    readonly enableAssistantStreaming: boolean;
+    readonly enableLegacyTokenStreaming: boolean;
     readonly enableProviderUpdateChecks: boolean;
     readonly backgroundActivity: {
       readonly schemaVersion: 1;
@@ -520,6 +553,7 @@ declare function createEnvironmentServerConfigsAtom(input: {
   };
   readonly shellResumeCompletionMarker?: boolean;
   readonly threadResumeCompletionMarker?: boolean;
+  readonly threadSnapshotPagination?: boolean;
 }>>;
 declare function createEnvironmentShellAtoms<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | EnvironmentCacheStore | ShellSnapshotLoader | R, E>): {
   stateAtom: (arg: string & import("effect/Brand").Brand<"EnvironmentId">) => Atom.Atom<AsyncResult.AsyncResult<EnvironmentShellState, E | Cause.NoSuchElementError>>;