@gajae-code/coding-agent 0.9.1 → 0.9.3

package/src/sdk.ts

@@ -9,6 +9,7 @@ import {
 	type ThinkingLevel,
 } from "@gajae-code/agent-core";
 import {
+	type AuthCredentialSelector,
 	type CredentialDisabledEvent,
 	type Message,
 	type Model,
@@ -39,7 +40,7 @@ import {
 import { type AsyncJob, AsyncJobManager, isBackgroundJobSupportEnabled, jobElapsedMs } from "./async";
 import { loadCapability } from "./capability";
 import { type Rule, ruleCapability, setActiveRules } from "./capability/rule";
-import { ModelRegistry } from "./config/model-registry";
+import { kNoAuth, ModelRegistry } from "./config/model-registry";
 import {
 	formatModelString,
 	parseModelPattern,
@@ -272,6 +273,8 @@ export interface CreateAgentSessionOptions {
 	/** Optional provider-facing session identifier for prompt caches and sticky auth selection.
 	 * Keeps persisted session files isolated while reusing provider-side caches. */
 	providerSessionId?: string;
+	/** Runtime credential selector for multi-account auth pools. */
+	credentialSelector?: { provider?: string; selector: AuthCredentialSelector; raw: string };
 
 	/** Custom tools to register (in addition to built-in tools). Accepts both CustomTool and ToolDefinition. */
 	customTools?: (CustomTool | ToolDefinition)[];
@@ -903,10 +906,22 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			startupCredentialDisabledEvents.push(event);
 		}
 	});
+	let runtimeCredentialSelectorInstalled = false;
+	const installRuntimeCredentialSelector = (provider: string): void => {
+		if (!options.credentialSelector || runtimeCredentialSelectorInstalled) return;
+		authStorage.setRuntimeCredentialSelector(provider, options.credentialSelector.selector);
+		runtimeCredentialSelectorInstalled = true;
+	};
+	const earlyCredentialSelectorProvider = options.credentialSelector?.provider ?? options.model?.provider;
+	if (earlyCredentialSelectorProvider) {
+		installRuntimeCredentialSelector(earlyCredentialSelectorProvider);
+	}
 	const settings = options.settings ?? (await logger.time("settings", Settings.init, { cwd, agentDir }));
 	modelRegistry.applyConfiguredModelBindings(settings);
 	logger.time("initializeWithSettings", initializeWithSettings, settings);
-	if (!options.modelRegistry) {
+	const canRefreshModelsBeforeCredentialSelector =
+		!options.credentialSelector || runtimeCredentialSelectorInstalled || options.modelRegistry !== undefined;
+	if (!options.modelRegistry && canRefreshModelsBeforeCredentialSelector) {
 		modelRegistry.refreshInBackground();
 	}
 	// Kick off workspace tree discovery early. The native workspace scan returns
@@ -972,7 +987,29 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			return cached;
 		}
 
-		const hasKey = !!(await modelRegistry.getApiKey(candidate, providerSessionId));
+		const credentialSelector =
+			options.credentialSelector && !runtimeCredentialSelectorInstalled
+				? options.credentialSelector.provider === undefined ||
+					options.credentialSelector.provider === candidate.provider
+					? options.credentialSelector.selector
+					: undefined
+				: undefined;
+		if (options.credentialSelector?.provider && options.credentialSelector.provider !== candidate.provider) {
+			modelApiKeyAvailability.set(availabilityKey, false);
+			return false;
+		}
+		const key = await modelRegistry.getApiKey(candidate, providerSessionId, { credentialSelector }).catch(error => {
+			if (credentialSelector) {
+				logger.debug("Credential selector did not match model availability candidate", {
+					provider: candidate.provider,
+					model: candidate.id,
+					error: error instanceof Error ? error.message : String(error),
+				});
+				return undefined;
+			}
+			throw error;
+		});
+		const hasKey = Boolean(key) && (!credentialSelector || key !== kNoAuth);
 		modelApiKeyAvailability.set(availabilityKey, hasKey);
 		return hasKey;
 	};
@@ -1047,6 +1084,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const taskDepth = options.taskDepth ?? 0;
 
 	let thinkingLevel = options.thinkingLevel;
+	const hasExplicitDefaultThinkingLevel = settings.has("defaultThinkingLevel");
+	let thinkingLevelFromSchemaDefault = false;
 
 	// If session has data and includes a thinking entry, restore it
 	if (thinkingLevel === undefined && hasExistingSession && hasThinkingEntry) {
@@ -1057,13 +1096,20 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		thinkingLevel = defaultRoleSpec.thinkingLevel;
 	}
 
-	// Prefer the selected model's configured defaultLevel, otherwise fall back
-	// to the global settings default.
+	// An explicit user/project default should win over the model's bundled
+	// defaultLevel. The schema default is only a final fallback so model metadata
+	// can keep driving first-run behavior until the user chooses "Set as default".
+	if (thinkingLevel === undefined && hasExplicitDefaultThinkingLevel) {
+		thinkingLevel = settings.get("defaultThinkingLevel");
+	}
+
 	if (thinkingLevel === undefined && model?.thinking?.defaultLevel !== undefined) {
 		thinkingLevel = model.thinking.defaultLevel;
 	}
+
 	if (thinkingLevel === undefined) {
 		thinkingLevel = settings.get("defaultThinkingLevel");
+		thinkingLevelFromSchemaDefault = true;
 	}
 	if (model) {
 		const resolvedModel = model;
@@ -1608,6 +1654,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			if (resolved) {
 				model = resolved;
 				modelFallbackMessage = undefined;
+				if (thinkingLevelFromSchemaDefault && resolved.thinking?.defaultLevel !== undefined) {
+					thinkingLevel = resolved.thinking.defaultLevel;
+					thinkingLevelFromSchemaDefault = false;
+				}
+				thinkingLevel = resolveThinkingLevelForModel(resolved, thinkingLevel);
 			} else {
 				modelFallbackMessage = `Model "${options.modelPattern}" not found`;
 			}
@@ -1639,6 +1690,18 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			}
 		}
 
+		if (options.credentialSelector && !runtimeCredentialSelectorInstalled) {
+			const credentialProvider = options.credentialSelector.provider ?? model?.provider;
+			if (!credentialProvider) {
+				throw new Error(
+					`--credential ${options.credentialSelector.raw} requires a resolved model or an explicit provider prefix`,
+				);
+			}
+			installRuntimeCredentialSelector(credentialProvider);
+			if (!options.modelRegistry && !canRefreshModelsBeforeCredentialSelector) {
+				modelRegistry.refreshInBackground();
+			}
+		}
 		const customCommandsResult: CustomCommandsLoadResult = { commands: [], errors: [] };
 
 		let extensionRunner: ExtensionRunner | undefined;

package/src/session/agent-session.ts

@@ -26,6 +26,7 @@ import {
 	type AgentMessage,
 	type AgentState,
 	type AgentTool,
+	assertImagePlaceholdersHavePayload,
 	resolveTelemetry,
 	type StablePrefixSnapshot,
 	ThinkingLevel,
@@ -151,6 +152,7 @@ import { onAppendOnlyModeChanged } from "../config/settings";
 import { RawSseDebugBuffer } from "../debug/raw-sse-buffer";
 import { loadCapability } from "../discovery";
 import { expandApplyPatchToEntries, normalizeDiff, normalizeToLF, ParseError, previewPatch, stripBom } from "../edit";
+import { MAX_EDIT_FILE_BYTES } from "../edit/read-file";
 import { disposeVmContextsByOwner } from "../eval/js/context-manager";
 import {
 	disposeKernelSessionsByOwner,
@@ -360,6 +362,11 @@ export interface AsyncJobSnapshot {
 // Types
 // ============================================================================
 
+export interface RetainedMemorySample {
+	tuiChatChildren?: number;
+	tuiCachedRenderBytes?: number;
+}
+
 export interface AgentSessionConfig {
 	agent: Agent;
 	sessionManager: SessionManager;
@@ -439,6 +446,8 @@ export interface AgentSessionConfig {
 	 * **MUST NOT** dispose it on their own teardown.
 	 */
 	ownedAsyncJobManager?: AsyncJobManager;
+	/** Cheap TUI retained-memory counters; absent for headless sessions. */
+	retainedMemorySampler?: () => RetainedMemorySample;
 	/**
 	 * MCPManager whose lifecycle this session owns (top-level sessions that
 	 * connected plugin-bundle MCP servers). Only the owned manager is
@@ -473,6 +482,8 @@ export interface PromptOptions {
 	images?: ImageContent[];
 	/** When streaming, how to queue the message: "steer" (interrupt) or "followUp" (wait). */
 	streamingBehavior?: "steer" | "followUp";
+	/** When set to "sequential", this follow-up is delivered one prompt at a time even if followUpMode is "all". */
+	followUpQueuePolicy?: "respect-mode" | "sequential";
 	/** Optional tool choice override for the next LLM call. */
 	toolChoice?: ToolChoice;
 	/** Send as developer/system message instead of user. Providers that support it use the developer role; others fall back to user. */
@@ -1082,6 +1093,68 @@ export function buildContextInjectionSignature(kind: string, parts: readonly str
 	}
 	return hash.digest("base64url");
 }
+
+const STREAMING_EDIT_FILE_CACHE_MAX_ENTRIES = 16;
+const STREAMING_EDIT_FILE_CACHE_MAX_TOTAL_BYTES = 32 * 1024 * 1024;
+
+type StreamingEditFileCacheEntry = {
+	content: string;
+	bytes: number;
+};
+
+export class StreamingEditFileCache {
+	#entries = new Map<string, StreamingEditFileCacheEntry>();
+	#totalBytes = 0;
+
+	get(path: string): string | undefined {
+		const entry = this.#entries.get(path);
+		if (entry === undefined) return undefined;
+		this.#entries.delete(path);
+		this.#entries.set(path, entry);
+		return entry.content;
+	}
+
+	set(path: string, content: string): void {
+		const bytes = Buffer.byteLength(content, "utf8");
+		if (bytes > MAX_EDIT_FILE_BYTES || bytes > STREAMING_EDIT_FILE_CACHE_MAX_TOTAL_BYTES) {
+			this.delete(path);
+			return;
+		}
+
+		this.delete(path);
+		while (
+			this.#entries.size >= STREAMING_EDIT_FILE_CACHE_MAX_ENTRIES ||
+			this.#totalBytes + bytes > STREAMING_EDIT_FILE_CACHE_MAX_TOTAL_BYTES
+		) {
+			const oldestPath = this.#entries.keys().next().value;
+			if (oldestPath === undefined) break;
+			this.delete(oldestPath);
+		}
+
+		this.#entries.set(path, { content, bytes });
+		this.#totalBytes += bytes;
+	}
+
+	delete(path: string): void {
+		const entry = this.#entries.get(path);
+		if (entry === undefined) return;
+		this.#entries.delete(path);
+		this.#totalBytes -= entry.bytes;
+	}
+
+	clear(): void {
+		this.#entries.clear();
+		this.#totalBytes = 0;
+	}
+
+	has(path: string): boolean {
+		return this.#entries.has(path);
+	}
+
+	get totalBytes(): number {
+		return this.#totalBytes;
+	}
+}
 export class AgentSession {
 	readonly agent: Agent;
 	readonly sessionManager: SessionManager;
@@ -1146,6 +1219,7 @@ export class AgentSession {
 	#compactionAbortController: AbortController | undefined = undefined;
 	#autoCompactionAbortController: AbortController | undefined = undefined;
 	#resourceSampler: () => EmergencyCompactionSample = () => this.#defaultResourceSample();
+	#retainedMemorySampler: (() => RetainedMemorySample) | undefined;
 	#prePromptContextCheckPromise: Promise<void> | undefined = undefined;
 
 	// Branch summarization state
@@ -1319,7 +1393,7 @@ export class AgentSession {
 
 	#streamingEditPrecheckedToolCallIds = new Set<string>();
 
-	#streamingEditFileCache = new Map<string, string>();
+	#streamingEditFileCache = new StreamingEditFileCache();
 	readonly streamingEditDebugCounters = {
 		guardRuns: 0,
 		processedChars: 0,
@@ -1445,6 +1519,7 @@ export class AgentSession {
 		// Power assertions are taken per turn (see #beginInFlight); nothing acquired here.
 		this.#evalKernelOwnerId = config.evalKernelOwnerId ?? `agent-session:${Snowflake.next()}`;
 		this.#ownedAsyncJobManager = config.ownedAsyncJobManager;
+		this.#retainedMemorySampler = config.retainedMemorySampler;
 		this.#ownedMcpManager = config.ownedMcpManager;
 		this.#scopedModels = config.scopedModels ?? [];
 		this.#thinkingLevel = config.thinkingLevel;
@@ -3168,7 +3243,31 @@ export class AgentSession {
 		// which is the optional patch-preview verification gated by
 		// edit.streamingAbort. Skip the read when the setting is off.
 		if (this.settings.get("edit.streamingAbort")) {
-			this.#ensureFileCache(streamingEdit.resolvedPath);
+			// Fire-and-forget async priming: toolcall deltas arrive on the hot
+			// stream path, so never block it on filesystem I/O. The abort-check
+			// path (#maybeAbortStreamingEdit) still falls back to the sync read
+			// if priming hasn't completed by the time removed lines appear.
+			void this.#preCacheFileAsync(streamingEdit.resolvedPath);
+		}
+	}
+
+	#streamingEditPrecachePending = new Set<string>();
+	async #preCacheFileAsync(resolvedPath: string): Promise<void> {
+		if (this.#streamingEditFileCache.has(resolvedPath)) return;
+		if (this.#streamingEditPrecachePending.has(resolvedPath)) return;
+		this.#streamingEditPrecachePending.add(resolvedPath);
+		try {
+			const stat = await fs.promises.stat(resolvedPath);
+			if (stat.size > MAX_EDIT_FILE_BYTES) return;
+
+			const rawText = await fs.promises.readFile(resolvedPath, "utf-8");
+			if (this.#streamingEditFileCache.has(resolvedPath)) return;
+			const { text } = stripBom(rawText);
+			this.#streamingEditFileCache.set(resolvedPath, normalizeToLF(text));
+		} catch {
+			// Don't cache on read errors (including ENOENT) - let the edit tool handle them
+		} finally {
+			this.#streamingEditPrecachePending.delete(resolvedPath);
 		}
 	}
 
@@ -3176,6 +3275,9 @@ export class AgentSession {
 		if (this.#streamingEditFileCache.has(resolvedPath)) return;
 
 		try {
+			const stat = fs.statSync(resolvedPath);
+			if (stat.size > MAX_EDIT_FILE_BYTES) return;
+
 			const rawText = fs.readFileSync(resolvedPath, "utf-8");
 			const { text } = stripBom(rawText);
 			this.#streamingEditFileCache.set(resolvedPath, normalizeToLF(text));
@@ -5296,6 +5398,7 @@ export class AgentSession {
 
 		// Expand file-based prompt templates if requested
 		const expandedText = expandPromptTemplates ? expandPromptTemplate(text, [...this.#promptTemplates]) : text;
+		assertImagePlaceholdersHavePayload(expandedText, options?.images);
 		const workflowIntentDiff = options?.synthetic ? null : buildWorkflowIntentDiff(expandedText);
 
 		// If streaming, queue via steer() or followUp() based on option
@@ -5304,7 +5407,9 @@ export class AgentSession {
 				throw new AgentBusyError();
 			}
 			if (options.streamingBehavior === "followUp") {
-				await this.#queueFollowUp(expandedText, options?.images);
+				await this.#queueFollowUp(expandedText, options?.images, {
+					forceOneAtATime: options.followUpQueuePolicy === "sequential",
+				});
 			} else {
 				await this.#queueSteer(expandedText, options?.images);
 			}
@@ -5422,7 +5527,7 @@ export class AgentSession {
 
 	async promptCustomMessage<T = unknown>(
 		message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">,
-		options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice">,
+		options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice" | "followUpQueuePolicy">,
 	): Promise<void> {
 		const textContent =
 			typeof message.content === "string"
@@ -5436,7 +5541,10 @@ export class AgentSession {
 			if (!options?.streamingBehavior) {
 				throw new AgentBusyError();
 			}
-			await this.sendCustomMessage(message, { deliverAs: options.streamingBehavior });
+			await this.sendCustomMessage(message, {
+				deliverAs: options.streamingBehavior,
+				followUpQueuePolicy: options.followUpQueuePolicy,
+			});
 			return;
 		}
 
@@ -5777,25 +5885,34 @@ export class AgentSession {
 		}
 
 		const expandedText = expandPromptTemplate(text, [...this.#promptTemplates]);
+		assertImagePlaceholdersHavePayload(expandedText, images);
 		await this.#queueSteer(expandedText, images);
 	}
 
 	/**
 	 * Queue a follow-up message to process after the agent would otherwise stop.
 	 */
-	async followUp(text: string, images?: ImageContent[]): Promise<void> {
+	async followUp(
+		text: string,
+		images?: ImageContent[],
+		options?: Pick<PromptOptions, "followUpQueuePolicy">,
+	): Promise<void> {
 		if (text.startsWith("/")) {
 			this.#throwIfExtensionCommand(text);
 		}
 
 		const expandedText = expandPromptTemplate(text, [...this.#promptTemplates]);
-		await this.#queueFollowUp(expandedText, images);
+		assertImagePlaceholdersHavePayload(expandedText, images);
+		await this.#queueFollowUp(expandedText, images, {
+			forceOneAtATime: options?.followUpQueuePolicy === "sequential",
+		});
 	}
 
 	/**
 	 * Internal: Queue a steering message (already expanded, no extension command check).
 	 */
 	async #queueSteer(text: string, images?: ImageContent[]): Promise<void> {
+		assertImagePlaceholdersHavePayload(text, images);
 		const displayText = text || (images && images.length > 0 ? "[Image]" : "");
 		this.#steeringMessages.push(this.#createQueuedDisplayEntry(displayText));
 		const content: (TextContent | ImageContent)[] = [{ type: "text", text }];
@@ -5826,19 +5943,23 @@ export class AgentSession {
 	/**
 	 * Internal: Queue a follow-up message (already expanded, no extension command check).
 	 */
-	async #queueFollowUp(text: string, images?: ImageContent[]): Promise<void> {
+	async #queueFollowUp(text: string, images?: ImageContent[], options?: { forceOneAtATime?: boolean }): Promise<void> {
+		assertImagePlaceholdersHavePayload(text, images);
 		const displayText = text || (images && images.length > 0 ? "[Image]" : "");
 		this.#followUpMessages.push(this.#createQueuedDisplayEntry(displayText));
 		const content: (TextContent | ImageContent)[] = [{ type: "text", text }];
 		if (images && images.length > 0) {
 			content.push(...images);
 		}
-		this.agent.followUp({
-			role: "user",
-			content,
-			attribution: "user",
-			timestamp: Date.now(),
-		});
+		this.agent.followUp(
+			{
+				role: "user",
+				content,
+				attribution: "user",
+				timestamp: Date.now(),
+			},
+			options?.forceOneAtATime ? { forceOneAtATime: true } : undefined,
+		);
 		// When fully idle AND the session is in a resumable assistant-ended state,
 		// schedule an immediate continue so the queued follow-up is delivered
 		// without waiting for the next user turn. We gate on isStreaming (model
@@ -5986,7 +6107,11 @@ export class AgentSession {
 	 */
 	async sendCustomMessage<T = unknown>(
 		message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">,
-		options?: { triggerTurn?: boolean; deliverAs?: "steer" | "followUp" | "nextTurn" },
+		options?: {
+			triggerTurn?: boolean;
+			deliverAs?: "steer" | "followUp" | "nextTurn";
+			followUpQueuePolicy?: "respect-mode" | "sequential";
+		},
 	): Promise<void> {
 		const appMessage: CustomMessage<T> = {
 			role: "custom",
@@ -6004,7 +6129,10 @@ export class AgentSession {
 			}
 
 			if (options?.deliverAs === "followUp") {
-				this.agent.followUp(appMessage);
+				this.agent.followUp(
+					appMessage,
+					options.followUpQueuePolicy === "sequential" ? { forceOneAtATime: true } : undefined,
+				);
 			} else {
 				this.agent.steer(appMessage);
 			}
@@ -6930,7 +7058,7 @@ export class AgentSession {
 
 	/**
 	 * Set thinking level.
-	 * Saves the effective metadata-clamped level to session and settings only if it changes.
+	 * Saves the effective metadata-clamped level to the session, and to settings when requested.
 	 */
 	setThinkingLevel(level: ThinkingLevel | undefined, persist: boolean = false): void {
 		const effectiveLevel = resolveThinkingLevelForModel(this.model, level);
@@ -6939,11 +7067,12 @@ export class AgentSession {
 		this.#thinkingLevel = effectiveLevel;
 		this.agent.setThinkingLevel(toReasoningEffort(effectiveLevel));
 
+		if (persist && effectiveLevel !== undefined) {
+			this.settings.set("defaultThinkingLevel", effectiveLevel);
+		}
+
 		if (isChanging) {
 			this.sessionManager.appendThinkingLevelChange(effectiveLevel);
-			if (persist && effectiveLevel !== undefined && effectiveLevel !== ThinkingLevel.Off) {
-				this.settings.set("defaultThinkingLevel", effectiveLevel);
-			}
 			this.#emit({ type: "thinking_level_changed", thinkingLevel: effectiveLevel });
 		}
 	}
@@ -7708,9 +7837,14 @@ export class AgentSession {
 		this.#resourceSampler = sampler;
 	}
 
+	setRetainedMemorySampler(sampler: (() => RetainedMemorySample) | undefined): void {
+		this.#retainedMemorySampler = sampler;
+	}
+
 	#defaultResourceSample(): EmergencyCompactionSample {
 		let providerBytes = 0;
 		let imageBytes = 0;
+		const retainedMemory = this.#retainedMemorySampler?.() ?? {};
 		for (const message of this.state.messages) {
 			const content = (message as { content?: unknown }).content;
 			if (typeof content === "string") {
@@ -7732,6 +7866,10 @@ export class AgentSession {
 			providerBytes,
 			messageCount: this.state.messages.length,
 			imageBytes,
+			sessionResidentImageBytes: this.sessionManager.getResidentImageBytes(),
+			materializedResidentBytes: this.#streamingEditFileCache.totalBytes,
+			tuiChatChildren: retainedMemory.tuiChatChildren ?? 0,
+			tuiCachedRenderBytes: retainedMemory.tuiCachedRenderBytes ?? 0,
 		};
 	}
 
@@ -8047,7 +8185,7 @@ export class AgentSession {
 			attribution: "agent",
 			timestamp: Date.now(),
 		});
-		this.#scheduleAgentContinue({ generation: this.#promptGeneration });
+		this.#scheduleAgentContinue({ skipCompactionCheck: true });
 	}
 
 	/**