codex-relay 1.0.2 → 1.0.4

package/dist/src.js

@@ -1,11 +1,11 @@
-import { A as PairResponseSchema, At as stripPromptSkillMentions, C as ListQueuedThreadInputsResponseSchema, D as ListWorkspaceFilesResponseSchema, E as ListWorkspaceDirectoriesResponseSchema, G as ResolveApprovalRequestSchema, K as ResolveApprovalResponseSchema, Q as RuntimePreferencesSchema, S as ListModelsResponseSchema, St as createOpenApiDocument, T as ListThreadsResponseSchema, Tt as promptMarkdownWithSkills, U as RateLimitsResponseSchema, X as RuntimePreferencesByWorkspacePathSchema, Z as RuntimePreferencesResponseSchema, _ as EncryptedPayloadSchema, a as ArchiveThreadResponseSchema, at as ThreadContextWindowResponseSchema, b as InterruptThreadRunResponseSchema, bt as apiPaths, ct as ThreadMessageDetailResponseSchema, d as CheckoutWorkspaceBranchRequestSchema, dt as ThreadSummarySchema, et as StatusResponseSchema, ft as UpdateRuntimePreferencesRequestSchema, h as CreateThreadRequestSchema, ht as WorkspaceChangesResponseSchema, k as PairRequestSchema, l as ChatMessageSchema, m as ContextWindowUsageSchema, nt as StreamThreadRunRequestSchema, ot as ThreadDetailResponseSchema, p as CommitPushWorkspaceRequestSchema, pt as VersionResponseSchema, q as RunThreadRequestSchema, rt as SubmitThreadInputResponseSchema, st as ThreadMessageDetailFieldSchema, tt as StreamThreadRunEventSchema, vt as WorkspaceGitActionResponseSchema, w as ListSkillsResponseSchema, wt as normalizePromptContext, xt as chatMessageDetailsFromPromptContext, y as ImageAttachmentUploadResponseSchema, z as QueuedThreadInputActionResponseSchema } from "./api-schema2.js";
+import { A as PairResponseSchema, C as ListQueuedThreadInputsResponseSchema, D as ListWorkspaceFilesResponseSchema, Dt as apiPaths, E as ListWorkspaceDirectoriesResponseSchema, G as ResolveApprovalRequestSchema, K as ResolveApprovalResponseSchema, Lt as stripPromptSkillMentions, Mt as promptMarkdownWithSkills, Ot as chatMessageDetailsFromPromptContext, Q as RuntimePreferencesSchema, S as ListModelsResponseSchema, St as WorkspaceGitActionResponseSchema, T as ListThreadsResponseSchema, U as RateLimitsResponseSchema, X as RuntimePreferencesByWorkspacePathSchema, Z as RuntimePreferencesResponseSchema, _ as EncryptedPayloadSchema, a as ArchiveThreadResponseSchema, at as ThreadContextWindowResponseSchema, b as InterruptThreadRunResponseSchema, bt as WorkspaceFileContentResponseSchema, ct as ThreadMessageDetailResponseSchema, d as CheckoutWorkspaceBranchRequestSchema, dt as ThreadSummarySchema, et as StatusResponseSchema, ft as UpdateRuntimePreferencesRequestSchema, h as CreateThreadRequestSchema, jt as normalizePromptContext, k as PairRequestSchema, kt as createOpenApiDocument, l as ChatMessageSchema, m as ContextWindowUsageSchema, mt as VersionResponseSchema, nt as StreamThreadRunRequestSchema, ot as ThreadDetailResponseSchema, p as CommitPushWorkspaceRequestSchema, pt as UpdateWorkspaceFileContentRequestSchema, q as RunThreadRequestSchema, rt as SubmitThreadInputResponseSchema, st as ThreadMessageDetailFieldSchema, tt as StreamThreadRunEventSchema, vt as WorkspaceChangesResponseSchema, w as ListSkillsResponseSchema, y as ImageAttachmentUploadResponseSchema, z as QueuedThreadInputActionResponseSchema } from "./api-schema2.js";
 import { r as legacyCodexRelayDataPath, t as codexRelayDataPath } from "./paths.js";
 import { createRequire } from "node:module";
 import qrcode from "qrcode-terminal";
 import { execFile, execFileSync, spawn } from "node:child_process";
 import fs, { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
-import { access, appendFile, copyFile, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
-import path, { basename, dirname, extname, join, relative, resolve } from "node:path";
+import { access, appendFile, copyFile, mkdir, open, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import path, { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { z } from "zod";
 import os, { homedir, hostname, networkInterfaces } from "node:os";
@@ -539,14 +539,16 @@ function updatePreferencesFile(current, patch, workspacePath) {
 	});
 }
 function mergeRuntimePreferences(current, patch) {
-	const { model, reasoningEffort, threadId: _threadId, workspacePath: _workspacePath, ...rest } = UpdateRuntimePreferencesRequestSchema.parse(patch);
+	const { model, serviceTier, reasoningEffort, threadId: _threadId, workspacePath: _workspacePath, ...rest } = UpdateRuntimePreferencesRequestSchema.parse(patch);
 	const next = {
 		...current,
 		...rest,
 		...model === null ? {} : { model },
+		...serviceTier === null ? {} : { serviceTier },
 		...reasoningEffort === null ? {} : { reasoningEffort }
 	};
 	if (model === null) delete next.model;
+	if (serviceTier === null) delete next.serviceTier;
 	if (reasoningEffort === null) delete next.reasoningEffort;
 	return RuntimePreferencesSchema.parse({ ...next });
 }
@@ -798,6 +800,9 @@ const defaultWorkspacePath = process.cwd();
 const defaultCodexModel = "gpt-5.5";
 const execFileAsync = promisify(execFile);
 const IMAGE_ATTACHMENT_MAX_BYTES = 8 * 1024 * 1024;
+const WORKSPACE_FILE_PREVIEW_MAX_BYTES = 256 * 1024;
+const LOCAL_MARKDOWN_IMAGE_PATTERN = /!\[([^\]]*)\]\(([^)]*)\)/g;
+const LOCAL_IMAGE_REFERENCE_PATTERN = /\.(gif|heic|heif|jpe?g|png|webp)$/i;
 const imageAttachmentDirectory = codexRelayDataPath("attachments/images");
 const relayPackage = createRequire(import.meta.url)("../package.json");
 const collaborationModeTemplateNames = [
@@ -1157,8 +1162,12 @@ function createApp(options = {}) {
 			const selectedWorkspacePath = await validateThreadWorkspacePath(workspacePath, c.req.query("workspacePath"));
 			if (!selectedWorkspacePath.success) return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError("invalid_workspace_path", selectedWorkspacePath.error), 400);
 			const query = c.req.query("query")?.trim() ?? "";
+			const directoryPath = normalizeWorkspaceDirectoryPath(c.req.query("directory") ?? "");
+			if (!directoryPath.success) return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError("invalid_workspace_file_path", directoryPath.error), 400);
 			const response = ListWorkspaceFilesResponseSchema.parse({
-				files: await listWorkspaceFiles(selectedWorkspacePath.path, query),
+				directory: directoryPath.path,
+				files: await listWorkspaceFiles(selectedWorkspacePath.path, query, directoryPath.path),
+				parentDirectory: parentWorkspaceDirectory(directoryPath.path),
 				query,
 				workspacePath: selectedWorkspacePath.path
 			});
@@ -1167,6 +1176,40 @@ function createApp(options = {}) {
 			return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError("workspace_files_unavailable", errorMessage(error)), 502);
 		}
 	});
+	app.get(apiPaths.workspaceFileContent, async (c) => {
+		try {
+			const selectedWorkspacePath = await validateThreadWorkspacePath(workspacePath, c.req.query("workspacePath"));
+			if (!selectedWorkspacePath.success) return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError("invalid_workspace_path", selectedWorkspacePath.error), 400);
+			const requestedPath = c.req.query("path")?.trim();
+			if (!requestedPath) return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError("missing_workspace_file_path", "Workspace file path is required."), 400);
+			const file = await readWorkspaceFileContent(selectedWorkspacePath.path, requestedPath);
+			if (!file.success) return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError(file.code, file.error), file.status);
+			const response = WorkspaceFileContentResponseSchema.parse({
+				workspacePath: selectedWorkspacePath.path,
+				...file.content
+			});
+			return secureJson(c, options.pairing, secureSessionsByTokenHash, response);
+		} catch (error) {
+			return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError("workspace_file_unavailable", errorMessage(error)), 502);
+		}
+	});
+	app.put(apiPaths.workspaceFileContent, async (c) => {
+		const parsed = await parseRequestJson(c, options.pairing, secureSessionsByTokenHash, UpdateWorkspaceFileContentRequestSchema);
+		if (!parsed.success) return secureJson(c, options.pairing, secureSessionsByTokenHash, validationError(parsed.error), 400);
+		try {
+			const selectedWorkspacePath = await validateThreadWorkspacePath(workspacePath, parsed.data.workspacePath);
+			if (!selectedWorkspacePath.success) return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError("invalid_workspace_path", selectedWorkspacePath.error), 400);
+			const file = await updateWorkspaceFileContent(selectedWorkspacePath.path, parsed.data);
+			if (!file.success) return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError(file.code, file.error), file.status);
+			const response = WorkspaceFileContentResponseSchema.parse({
+				workspacePath: selectedWorkspacePath.path,
+				...file.content
+			});
+			return secureJson(c, options.pairing, secureSessionsByTokenHash, response);
+		} catch (error) {
+			return secureJson(c, options.pairing, secureSessionsByTokenHash, apiError("workspace_file_update_unavailable", errorMessage(error)), 502);
+		}
+	});
 	app.get(apiPaths.rateLimits, async (c) => {
 		if (!appServer) return secureJson(c, options.pairing, secureSessionsByTokenHash, RateLimitsResponseSchema.parse({ buckets: [] }));
 		try {
@@ -1217,14 +1260,24 @@ function createApp(options = {}) {
 			return c.json(apiError("not_found", "Image attachment not found."), 404);
 		}
 		const fileStat = statSync(filePath);
+		if (!fileStat.isFile() || fileStat.size === 0) {
+			relayDebugLog("image_attachment.rejected", {
+				attachmentId,
+				reason: fileStat.isFile() ? "empty_file" : "not_file",
+				userAgent: c.req.header("user-agent")
+			});
+			return c.json(apiError("not_found", "Image attachment not found."), 404);
+		}
+		const imageBytes = await readFile(filePath);
 		relayDebugLog("image_attachment.served", {
 			attachmentId,
 			mimeType: imageMimeType(filePath),
-			size: fileStat.size,
+			size: imageBytes.length,
 			userAgent: c.req.header("user-agent")
 		});
-		return new Response(await readFile(filePath), { headers: {
+		return new Response(imageBytes, { headers: {
 			"cache-control": "private, max-age=31536000, immutable",
+			"content-length": String(imageBytes.length),
 			"content-type": imageMimeType(filePath)
 		} });
 	});
@@ -1289,7 +1342,7 @@ function createApp(options = {}) {
 			let loadedMessages = false;
 			let messages = cachedMessages;
 			let responseThread = preserveKnownRunningThreadState(mappedThread, wasKnownRunning);
-			const rolloutHistory = readRolloutThreadMessages(threadId);
+			const rolloutHistory = readRolloutThreadMessages(threadId, workspacePath);
 			if (rolloutHistory.messages.length > 0) {
 				messages = mergeThreadMessagePages(rolloutHistory.messages, cachedMessages);
 				responseThread = rememberRolloutThreadMessages(threads, responseThread, messages, rolloutHistory.messageCountLowerBound);
@@ -1328,7 +1381,7 @@ function createApp(options = {}) {
 			});
 		}
 		const cachedMessages = messagesByThreadId.get(threadId) ?? [];
-		const rolloutHistory = readRolloutThreadMessages(threadId);
+		const rolloutHistory = readRolloutThreadMessages(threadId, workspacePath);
 		const baseThread = threads.get(threadId) ?? knownThread ?? (rolloutHistory.rolloutPath ? rolloutThreadMetadata(threadId, workspacePath, rolloutHistory.rolloutPath, [...rolloutHistory.messages, ...cachedMessages]) : void 0);
 		if (baseThread && (cachedMessages.length > 0 || rolloutHistory.messages.length > 0)) {
 			const messages = rolloutHistory.messages.length > 0 ? mergeThreadMessagePages(rolloutHistory.messages, cachedMessages) : dedupeThreadMessages(cachedMessages);
@@ -1870,7 +1923,8 @@ async function createAppServerThreadRecord(input) {
 		experimentalRawEvents: false,
 		model: input.options.model ?? null,
 		persistExtendedHistory: true,
-		sandbox: runtime.sandbox
+		sandbox: runtime.sandbox,
+		serviceTier: input.options.serviceTier ?? null
 	});
 	const metadata = ThreadSummarySchema.parse({
 		...mapAppServerThread({
@@ -2123,6 +2177,7 @@ async function startAppServerTurn(appServer, threadId, input) {
 		input: appServerTurnInput(input.prompt, input.attachments, input.skills),
 		model: input.runOptions.model ?? null,
 		sandboxPolicy: runtime.sandboxPolicy,
+		serviceTier: input.runOptions.serviceTier ?? null,
 		threadId
 	};
 	await resumeAppServerThreadIfNeeded(appServer, threadId, input, runtime);
@@ -2154,6 +2209,7 @@ async function resumeAppServerThread(appServer, threadId, input, runtime) {
 		model: input.runOptions.model ?? null,
 		persistExtendedHistory: true,
 		sandbox: runtime.sandbox,
+		serviceTier: input.runOptions.serviceTier ?? null,
 		threadId
 	});
 }
@@ -2517,7 +2573,11 @@ async function runAppServerPromptStreamed(input) {
 					case "item/completed": {
 						const item = params?.item;
 						if (!item || typeof item !== "object") return;
-						if (isDuplicateInitialUserMessage(input.messagesByThreadId, activeThreadId, item, userMessage.id, prompt)) return;
+						const canonicalUserMessage = replaceDuplicateInitialUserMessage(input.messagesByThreadId, activeThreadId, firstString(params, ["turnId"]) ?? activeTurnId, item, userMessage.id, prompt);
+						if (canonicalUserMessage) {
+							userMessage = canonicalUserMessage;
+							return;
+						}
 						const turnId = firstString(params, ["turnId"]) ?? activeTurnId;
 						const message = upsertAppServerItemMessage(input.messagesByThreadId, activeThreadId, turnId, item);
 						if (!message) return;
@@ -2750,7 +2810,11 @@ async function runAppServerPromptStreamed(input) {
 		debugStream("start turn complete", activeThreadId, activeTurnId);
 		let streamedReturnedItem = false;
 		for (const item of turn.items) {
-			if (isDuplicateInitialUserMessage(input.messagesByThreadId, activeThreadId, item, userMessage.id, displayPrompt)) continue;
+			const canonicalUserMessage = replaceDuplicateInitialUserMessage(input.messagesByThreadId, activeThreadId, activeTurnId, item, userMessage.id, displayPrompt);
+			if (canonicalUserMessage) {
+				userMessage = canonicalUserMessage;
+				continue;
+			}
 			const message = upsertAppServerItemMessage(input.messagesByThreadId, activeThreadId, activeTurnId, item);
 			if (!message) continue;
 			streamedReturnedItem = true;
@@ -2900,7 +2964,8 @@ async function recoverMissingAppServerThread(input) {
 		experimentalRawEvents: false,
 		model: input.runOptions.model ?? null,
 		persistExtendedHistory: true,
-		sandbox: runtime.sandbox
+		sandbox: runtime.sandbox,
+		serviceTier: input.runOptions.serviceTier ?? null
 	});
 	const recoveredThread = mapAppServerThread({
 		...thread,
@@ -3062,6 +3127,12 @@ function upsertAppServerItemMessage(messagesByThreadId, threadId, turnId, item)
 		turnId: message.turnId
 	});
 }
+function replaceDuplicateInitialUserMessage(messagesByThreadId, threadId, turnId, item, localMessageId, prompt) {
+	if (!isDuplicateInitialUserMessage(messagesByThreadId, threadId, item, localMessageId, prompt)) return;
+	const message = mapAppServerItem(threadId, appServerTurnShell(turnId), item);
+	if (!message) return;
+	return replaceMessage(messagesByThreadId, threadId, localMessageId, messageWithReplacementDetail(message, localMessageId));
+}
 function isDuplicateInitialUserMessage(messagesByThreadId, threadId, item, localMessageId, prompt) {
 	if (item.type !== "userMessage" || !("content" in item) || !Array.isArray(item.content)) return false;
 	const localMessage = messagesByThreadId.get(threadId)?.find((message) => message.id === localMessageId);
@@ -3069,6 +3140,15 @@ function isDuplicateInitialUserMessage(messagesByThreadId, threadId, item, local
 	const normalizedPrompt = stripPromptSkillMentions(prompt, skills);
 	return stripPromptSkillMentions(localMessage?.content ?? "", skills) === normalizedPrompt && stripPromptSkillMentions(appServerUserMessageText(item), skills) === normalizedPrompt;
 }
+function messageWithReplacementDetail(message, replacesMessageId) {
+	return ChatMessageSchema.parse({
+		...message,
+		details: {
+			...message.details,
+			replacesMessageId
+		}
+	});
+}
 function appServerUserMessageText(item) {
 	const skills = appServerUserMessageSkills(item);
 	return promptMarkdownWithSkills(promptWithAppServerImageReferences(item.content.map((content) => {
@@ -3076,6 +3156,9 @@ function appServerUserMessageText(item) {
 			case "text": return content.text;
 			case "image":
 			case "localImage":
+			case "document":
+			case "file":
+			case "localFile":
 			case "mention":
 			case "skill": return "";
 		}
@@ -3094,14 +3177,90 @@ function appServerUserMessageDetails(item) {
 					type: "image"
 				}];
 			case "localImage": return localImageAttachmentDetails(content.path);
+			case "document":
+			case "file":
+			case "localFile": return appServerDocumentAttachmentDetails(content);
 			default: return [];
 		}
 	});
 	return attachments.length > 0 ? { attachments } : void 0;
 }
+function appServerAgentMessageParts(item) {
+	return agentMessageParts(item.text);
+}
+function agentMessageParts(text) {
+	const imageReferences = localMarkdownImageReferences(text);
+	if (imageReferences.length === 0) return {
+		content: text,
+		details: void 0
+	};
+	const materializedReferences = /* @__PURE__ */ new Set();
+	const attachments = imageReferences.flatMap((reference) => {
+		const name = reference.alt || basename(localImageFilePath(reference.destination) ?? reference.destination);
+		const details = localImageAttachmentDetails(reference.destination, name);
+		if (details.length > 0) materializedReferences.add(reference.destination);
+		return details;
+	});
+	return {
+		content: attachments.length > 0 ? stripMaterializedMarkdownImages(text, materializedReferences) : text,
+		details: attachments.length > 0 ? { attachments } : void 0
+	};
+}
+function localMarkdownImageReferences(markdown) {
+	const references = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const match of markdown.matchAll(LOCAL_MARKDOWN_IMAGE_PATTERN)) {
+		const destination = markdownImageDestination(match[2] ?? "");
+		if (!destination || seen.has(destination) || !isLocalMarkdownImageReference(destination)) continue;
+		seen.add(destination);
+		references.push({
+			alt: (match[1] ?? "").trim(),
+			destination
+		});
+	}
+	return references;
+}
+function stripMaterializedMarkdownImages(markdown, destinations) {
+	return markdown.replace(LOCAL_MARKDOWN_IMAGE_PATTERN, (match, _alt, rawDestination) => {
+		const destination = markdownImageDestination(rawDestination);
+		return destination && destinations.has(destination) ? "" : match;
+	}).replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function markdownImageDestination(value) {
+	let destination = value.trim();
+	if (destination.startsWith("<")) {
+		const endIndex = destination.indexOf(">");
+		if (endIndex > 0) destination = destination.slice(1, endIndex);
+	} else {
+		const titleIndex = destination.search(/\s+["']/);
+		if (titleIndex > 0) destination = destination.slice(0, titleIndex);
+	}
+	try {
+		return decodeURI(destination);
+	} catch {
+		return destination;
+	}
+}
+function isLocalMarkdownImageReference(reference) {
+	if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(reference) && !reference.startsWith("file://")) return false;
+	const filePath = localImageFilePath(reference);
+	return Boolean(filePath && LOCAL_IMAGE_REFERENCE_PATTERN.test(filePath));
+}
+function appServerDocumentAttachmentDetails(input) {
+	const reference = input.path ?? input.url;
+	if (!reference) return [];
+	return [{
+		mimeType: input.mimeType,
+		name: input.name ?? basename(reference),
+		path: input.path,
+		type: "document",
+		url: input.url
+	}];
+}
 async function saveUploadedImageAttachment(file) {
 	if (!file.type.startsWith("image/")) throw new Error(`Unsupported attachment type: ${file.type || "unknown"}`);
 	if (file.size > IMAGE_ATTACHMENT_MAX_BYTES) throw new Error(`Image ${file.name || "attachment"} is too large.`);
+	if (file.size === 0) throw new Error(`Image ${file.name || "attachment"} is empty.`);
 	const attachmentId = `${Date.now()}-${randomUUID()}${imageExtension(file.name, file.type)}`;
 	const filePath = resolve(imageAttachmentDirectory, attachmentId);
 	await mkdir(imageAttachmentDirectory, { recursive: true });
@@ -3152,7 +3311,7 @@ function materializeLocalImageFile(path, name = basename(path)) {
 	const filePath = localImageFilePath(path);
 	if (!filePath || !existsSync(filePath)) return;
 	const fileStat = statSync(filePath);
-	if (!fileStat.isFile() || fileStat.size > IMAGE_ATTACHMENT_MAX_BYTES) return;
+	if (!fileStat.isFile() || fileStat.size === 0 || fileStat.size > IMAGE_ATTACHMENT_MAX_BYTES) return;
 	const buffer = readFileSync(filePath);
 	const mimeType = imageMimeType(filePath);
 	const attachmentId = `${createHash("sha256").update(buffer).digest("hex").slice(0, 24)}${imageExtension(name, mimeType)}`;
@@ -3268,6 +3427,17 @@ function updateMessage(messagesByThreadId, threadId, messageId, update) {
 	messages[index] = next;
 	return next;
 }
+function replaceMessage(messagesByThreadId, threadId, messageId, replacement) {
+	const messages = messagesByThreadId.get(threadId) ?? [];
+	const index = messages.findIndex((message) => message.id === messageId);
+	if (index === -1) throw new Error(`Unknown message: ${messageId}`);
+	const next = ChatMessageSchema.parse({
+		...replacement,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	messages[index] = next;
+	return next;
+}
 function replaceLocalThreadId(threads, messagesByThreadId, liveThreads, currentThreadId, sdkThreadId) {
 	if (!sdkThreadId || sdkThreadId === currentThreadId) return currentThreadId;
 	const metadata = threads.get(currentThreadId);
@@ -3511,6 +3681,7 @@ function runtimeMetadataFromOptions(options) {
 	const sandboxMode = options.sandboxMode ?? runtime.sandboxMode;
 	return {
 		...options.model ? { model: options.model } : {},
+		...options.serviceTier ? { serviceTier: options.serviceTier } : {},
 		...options.runtimeMode ? { runtimeMode: options.runtimeMode } : {},
 		...options.collaborationMode ? { collaborationMode: options.collaborationMode } : {},
 		...approvalPolicy ? { approvalPolicy } : {},
@@ -3523,6 +3694,7 @@ function withRuntimePreferences(preferences, options) {
 		...options,
 		approvalPolicy: options.approvalPolicy,
 		model: options.model ?? preferences.model,
+		serviceTier: options.serviceTier ?? preferences.serviceTier,
 		reasoningEffort: options.reasoningEffort ?? preferences.reasoningEffort,
 		runtimeMode: options.runtimeMode ?? preferences.runtimeMode,
 		sandboxMode: options.sandboxMode
@@ -3570,7 +3742,7 @@ function sandboxPolicyForMode(sandboxMode, workspacePath) {
 	};
 }
 function hasExplicitRunOptions(options) {
-	return Boolean(options.model || options.reasoningEffort || options.approvalPolicy || options.sandboxMode || options.collaborationMode === "plan" || options.runtimeMode);
+	return Boolean(options.model || options.serviceTier || options.reasoningEffort || options.approvalPolicy || options.sandboxMode || options.collaborationMode === "plan" || options.runtimeMode);
 }
 function mapAppServerThread(thread, fallbackMessageCount) {
 	const createdAt = fromUnixSeconds(thread.createdAt);
@@ -3628,26 +3800,58 @@ function mergeThreadMessagePages(incomingMessages, cachedMessages) {
 	return dedupeThreadMessages(Array.from(byId.values()));
 }
 function dedupeThreadMessages(messages) {
+	const byCrossSourceKey = /* @__PURE__ */ new Map();
 	const byImageKey = /* @__PURE__ */ new Map();
 	const deduped = [];
 	const sortedMessages = [...messages].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
 	for (const message of sortedMessages) {
+		const crossSourceKey = crossSourceMessageKey(message);
+		const crossSourceIndex = crossSourceKey ? byCrossSourceKey.get(crossSourceKey) : void 0;
+		if (crossSourceIndex !== void 0) {
+			const existingMessage = deduped[crossSourceIndex];
+			if (existingMessage && shouldPreferDuplicateThreadMessage(message, existingMessage)) deduped[crossSourceIndex] = message;
+			continue;
+		}
+		const previous = deduped[deduped.length - 1];
+		if (previous && isDuplicateCrossSourceMessage(previous, message)) {
+			if (shouldPreferDuplicateThreadMessage(message, previous)) deduped[deduped.length - 1] = message;
+			continue;
+		}
 		const imageKey = userImageMessageKey(message);
 		if (!imageKey) {
+			if (crossSourceKey) byCrossSourceKey.set(crossSourceKey, deduped.length);
 			deduped.push(message);
 			continue;
 		}
 		const existingIndex = byImageKey.get(imageKey);
 		if (existingIndex === void 0) {
 			byImageKey.set(imageKey, deduped.length);
+			if (crossSourceKey) byCrossSourceKey.set(crossSourceKey, deduped.length);
 			deduped.push(message);
 			continue;
 		}
 		const existingMessage = deduped[existingIndex];
-		if (existingMessage && shouldPreferDuplicateImageMessage(message, existingMessage)) deduped[existingIndex] = message;
+		if (existingMessage && shouldPreferDuplicateThreadMessage(message, existingMessage)) deduped[existingIndex] = message;
 	}
 	return deduped;
 }
+function crossSourceMessageKey(message) {
+	if (!isSyntheticHistoryMessageId(message.id)) return;
+	if (message.role !== "user" && message.role !== "assistant") return;
+	return [
+		message.threadId,
+		message.createdAt.slice(0, 19),
+		message.role,
+		message.kind,
+		message.content
+	].join("\n");
+}
+function isDuplicateCrossSourceMessage(previous, next) {
+	return previous.id !== next.id && (isSyntheticHistoryMessageId(previous.id) || isSyntheticHistoryMessageId(next.id)) && previous.threadId === next.threadId && previous.role === next.role && previous.kind === next.kind && previous.content === next.content;
+}
+function isSyntheticHistoryMessageId(id) {
+	return id.startsWith("msg-") || id.startsWith("rollout:");
+}
 function userImageMessageKey(message) {
 	if (message.role !== "user") return;
 	const imageUris = imageAttachmentUris(message);
@@ -3665,9 +3869,11 @@ function imageAttachmentUris(message) {
 		return ["url" in attachment ? attachment.url : void 0, "path" in attachment ? attachment.path : void 0].filter((value) => typeof value === "string" && value.length > 0);
 	});
 }
-function shouldPreferDuplicateImageMessage(candidate, existing) {
+function shouldPreferDuplicateThreadMessage(candidate, existing) {
 	if (existing.id.startsWith("rollout") && !candidate.id.startsWith("rollout")) return true;
 	if (!existing.id.startsWith("rollout") && candidate.id.startsWith("rollout")) return false;
+	if (!existing.turnId && candidate.turnId) return true;
+	if (existing.turnId && !candidate.turnId) return false;
 	return candidate.content.length < existing.content.length;
 }
 function rememberRolloutThreadMessages(threads, thread, messages, messageCountLowerBound = messages.length) {
@@ -3712,7 +3918,7 @@ function readSessionIndexThreadTitle(threadId) {
 		} catch {}
 	}
 }
-function readRolloutThreadMessages(threadId) {
+function readRolloutThreadMessages(threadId, workspacePath = defaultWorkspacePath) {
 	const rolloutPath = findRolloutFileForThread(threadId);
 	if (!rolloutPath) return {
 		messageCountLowerBound: 0,
@@ -3720,6 +3926,8 @@ function readRolloutThreadMessages(threadId) {
 		rolloutPath
 	};
 	const collected = [];
+	const applyPatchInputs = /* @__PURE__ */ new Map();
+	const pendingApplyPatchChanges = [];
 	const lines = readFileSync(rolloutPath, "utf8").split("\n");
 	for (let index = 0; index < lines.length; index += 1) {
 		const line = lines[index];
@@ -3727,7 +3935,15 @@ function readRolloutThreadMessages(threadId) {
 		if (!line.trim()) continue;
 		if (!isRolloutMessageLine(line)) continue;
 		try {
-			const message = rolloutRecordMessage(threadId, JSON.parse(line), `rollout:${lineNumber}`);
+			const record = JSON.parse(line);
+			rememberRolloutApplyPatchInput(record, applyPatchInputs);
+			collectRolloutApplyPatchOutput(record, workspacePath, applyPatchInputs, pendingApplyPatchChanges);
+			if (isRolloutTaskComplete(record) && pendingApplyPatchChanges.length > 0) {
+				collected.push(rolloutApplyPatchSummaryMessage(threadId, record, `rollout:${lineNumber}:apply_patch`, pendingApplyPatchChanges));
+				pendingApplyPatchChanges.length = 0;
+				continue;
+			}
+			const message = rolloutRecordMessage(threadId, record, `rollout:${lineNumber}`, workspacePath);
 			if (!message) continue;
 			collected.push(message);
 		} catch {}
@@ -3754,7 +3970,10 @@ function findRolloutFileForThread(threadId) {
 		}
 	}
 }
-function rolloutRecordMessage(threadId, record, messageKey) {
+function isRolloutTaskComplete(record) {
+	return record.type === "event_msg" && record.payload?.type === "task_complete";
+}
+function rolloutRecordMessage(threadId, record, messageKey, workspacePath = defaultWorkspacePath) {
 	const timestamp = typeof record.timestamp === "string" ? record.timestamp : (/* @__PURE__ */ new Date()).toISOString();
 	const payload = record.payload;
 	if (!payload) return;
@@ -3774,15 +3993,37 @@ function rolloutRecordMessage(threadId, record, messageKey) {
 	if (record.type === "event_msg" && payload.type === "agent_message") {
 		const content = firstString(payload, ["message"]);
 		if (!content) return;
+		const messageParts = agentMessageParts(content);
 		return ChatMessageSchema.parse({
 			id: `${messageKey}:assistant`,
 			threadId,
 			role: "assistant",
-			content,
+			content: messageParts.content,
+			details: messageParts.details,
 			createdAt: timestamp,
 			state: "completed"
 		});
 	}
+	if (record.type === "event_msg" && payload.type === "patch_apply_end") {
+		const changes = rolloutPatchApplyChanges(payload.changes, workspacePath);
+		if (changes.length === 0) return;
+		const patchPreview = largeTextPreview(changes.map((change) => change.patch).filter((patch) => Boolean(patch)).join("\n"));
+		return ChatMessageSchema.parse({
+			id: `${messageKey}:patch:${firstString(payload, ["call_id"]) ?? ""}`,
+			threadId,
+			role: "tool",
+			kind: "fileChange",
+			content: summarizeFileChanges(changes),
+			createdAt: timestamp,
+			state: "completed",
+			details: {
+				changes: changes.map(({ patch: _patch, ...change }) => change),
+				patch: patchPreview?.text,
+				patchOriginalLength: patchPreview?.originalLength,
+				patchTruncated: patchPreview?.truncated
+			}
+		});
+	}
 	if (record.type === "event_msg" && payload.type === "exec_command_end") {
 		const command = Array.isArray(payload.command) ? payload.command.map((part) => String(part)).join(" ") : firstString(payload, ["command"]) || "Command";
 		const outputPreview = largeTextPreview(firstString(payload, ["aggregated_output"]));
@@ -3837,8 +4078,114 @@ function rolloutImageAttachments(value, source) {
 		return localImageAttachmentDetails(image, name);
 	});
 }
+function rememberRolloutApplyPatchInput(record, applyPatchInputs) {
+	const payload = record.payload;
+	if (record.type !== "response_item" || payload?.type !== "custom_tool_call" || firstString(payload, ["name"]) !== "apply_patch") return;
+	const callId = firstString(payload, ["call_id"]);
+	const input = firstString(payload, ["input"]);
+	if (callId && input) applyPatchInputs.set(callId, input);
+}
+function collectRolloutApplyPatchOutput(record, workspacePath, applyPatchInputs, pendingApplyPatchChanges) {
+	const payload = record.payload;
+	if (record.type !== "response_item" || payload?.type !== "custom_tool_call_output" || !firstString(payload, ["call_id"])) return;
+	const changes = rolloutApplyPatchOutputChanges(rolloutCustomToolOutputText(payload), workspacePath);
+	if (changes.length === 0) return;
+	const callId = firstString(payload, ["call_id"]);
+	const patch = callId ? applyPatchInputs.get(callId) : void 0;
+	for (const change of changes) pendingApplyPatchChanges.push({
+		...change,
+		patch
+	});
+}
+function rolloutApplyPatchSummaryMessage(threadId, record, messageKey, pendingApplyPatchChanges) {
+	const timestamp = typeof record.timestamp === "string" ? record.timestamp : (/* @__PURE__ */ new Date()).toISOString();
+	const patchPreview = largeTextPreview([...new Set(pendingApplyPatchChanges.map((change) => change.patch))].filter((patch) => Boolean(patch)).join("\n"));
+	return ChatMessageSchema.parse({
+		id: `${messageKey}:summary`,
+		threadId,
+		role: "tool",
+		kind: "fileChange",
+		content: summarizeFileChanges(pendingApplyPatchChanges),
+		createdAt: timestamp,
+		state: "completed",
+		details: {
+			changes: pendingApplyPatchChanges.map(({ patch: _patch, ...change }) => change),
+			patch: patchPreview?.text,
+			patchOriginalLength: patchPreview?.originalLength,
+			patchTruncated: patchPreview?.truncated
+		}
+	});
+}
+function rolloutCustomToolOutputText(payload) {
+	const rawOutput = firstString(payload, ["output"]);
+	if (!rawOutput) return;
+	try {
+		const parsed = JSON.parse(rawOutput);
+		return typeof parsed.output === "string" ? parsed.output : rawOutput;
+	} catch {
+		return rawOutput;
+	}
+}
+function rolloutApplyPatchOutputChanges(value, workspacePath) {
+	if (!value || !value.includes("Updated the following files")) return [];
+	return value.split("\n").flatMap((line) => {
+		const match = line.match(/^\s*([ADM])\s+(.+?)\s*$/);
+		if (!match) return [];
+		return [{
+			kind: rolloutPatchChangeKind(match[1] === "A" ? "added" : match[1] === "D" ? "deleted" : "modified"),
+			path: rolloutPatchDisplayPath(match[2] ?? "", workspacePath)
+		}];
+	});
+}
+function rolloutPatchApplyChanges(value, workspacePath = defaultWorkspacePath) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+	return Object.entries(value).flatMap(([rawPath, rawChange]) => {
+		if (!rawChange || typeof rawChange !== "object") return [];
+		const record = rawChange;
+		return [{
+			kind: rolloutPatchChangeKind(firstString(record, ["type"]) ?? "modified"),
+			patch: firstString(record, ["unified_diff", "patch"]),
+			path: rolloutPatchDisplayPath(rawPath, workspacePath)
+		}];
+	});
+}
+function rolloutPatchChangeKind(type) {
+	const normalized = type.toLowerCase();
+	if ([
+		"add",
+		"added",
+		"create",
+		"created"
+	].includes(normalized)) return "added";
+	if ([
+		"delete",
+		"deleted",
+		"remove",
+		"removed"
+	].includes(normalized)) return "deleted";
+	if ([
+		"move",
+		"moved",
+		"rename",
+		"renamed"
+	].includes(normalized)) return "renamed";
+	return "modified";
+}
+function rolloutPatchDisplayPath(value, workspacePath = defaultWorkspacePath) {
+	const filePath = value.startsWith("file://") ? fileUrlPath(value) : value;
+	if (!isAbsolute(filePath)) return filePath;
+	const relativePath = relative(resolve(workspacePath), filePath);
+	return relativePath && !relativePath.startsWith("..") && !isAbsolute(relativePath) ? relativePath.split("\\").join("/") : filePath;
+}
+function fileUrlPath(value) {
+	try {
+		return fileURLToPath(value);
+	} catch {
+		return value;
+	}
+}
 function isRolloutMessageLine(line) {
-	return line.includes("\"type\":\"event_msg\"") && (line.includes("\"type\":\"user_message\"") || line.includes("\"type\":\"agent_message\"") || line.includes("\"type\":\"exec_command_end\"") || line.includes("\"type\":\"mcp_tool_call_end\""));
+	return line.includes("\"type\":\"event_msg\"") && (line.includes("\"type\":\"user_message\"") || line.includes("\"type\":\"agent_message\"") || line.includes("\"type\":\"patch_apply_end\"") || line.includes("\"type\":\"task_complete\"") || line.includes("\"type\":\"exec_command_end\"") || line.includes("\"type\":\"mcp_tool_call_end\"")) || line.includes("\"type\":\"response_item\"") && (line.includes("\"type\":\"custom_tool_call\"") || line.includes("\"type\":\"custom_tool_call_output\""));
 }
 function threadDetailResponse(input) {
 	return ThreadDetailResponseSchema.parse({
@@ -3917,12 +4264,13 @@ function mapAppServerItem(threadId, turn, item) {
 		case "agentMessage": {
 			const agentItem = item;
 			const planContent = proposedPlanContent(agentItem.text);
+			const messageParts = appServerAgentMessageParts(agentItem);
 			return ChatMessageSchema.parse({
 				...base,
 				role: "assistant",
 				kind: planContent ? "plan" : void 0,
-				content: planContent ?? agentItem.text,
-				details: planContent ? { raw: agentItem.text } : void 0
+				content: planContent ?? messageParts.content,
+				details: planContent ? { raw: agentItem.text } : messageParts.details
 			});
 		}
 		case "reasoning": {
@@ -4036,6 +4384,11 @@ function appServerTurnShell(turnId) {
 	};
 }
 function mapAppServerModel(model) {
+	const serviceTiers = model.serviceTiers ?? model.additionalSpeedTiers?.map((tier) => ({
+		id: tier,
+		name: tier === "fast" ? "Fast" : tier,
+		description: void 0
+	})) ?? [];
 	return {
 		id: model.id,
 		model: model.model,
@@ -4043,7 +4396,8 @@ function mapAppServerModel(model) {
 		description: model.description,
 		isDefault: Boolean(model.isDefault),
 		defaultReasoningEffort: model.defaultReasoningEffort,
-		supportedReasoningEfforts: model.supportedReasoningEfforts?.map((effort) => effort.reasoningEffort) ?? []
+		supportedReasoningEfforts: model.supportedReasoningEfforts?.map((effort) => effort.reasoningEffort) ?? [],
+		serviceTiers
 	};
 }
 function normalizeRateLimitBuckets(rateLimits) {
@@ -4104,7 +4458,13 @@ function fallbackModels() {
 			{ reasoningEffort: "medium" },
 			{ reasoningEffort: "high" },
 			{ reasoningEffort: "xhigh" }
-		]
+		],
+		additionalSpeedTiers: ["fast"],
+		serviceTiers: [{
+			id: "priority",
+			name: "Fast",
+			description: "1.5x speed, increased usage"
+		}]
 	}];
 }
 function mapAppServerThreadState(status, turns) {
@@ -4808,53 +5168,235 @@ async function git(cwd, args) {
 	});
 	return stdout.trimEnd();
 }
-async function listWorkspaceFiles(workspacePath, query) {
+async function listWorkspaceFiles(workspacePath, query, directory) {
 	const normalizedQuery = query.toLowerCase();
 	const filePaths = await workspaceFilePaths(workspacePath);
 	const entriesByPath = /* @__PURE__ */ new Map();
 	for (const path of filePaths) {
 		if (!path || path.startsWith("../") || path.includes("/.git/")) continue;
-		entriesByPath.set(path, {
-			directory: dirname(path) === "." ? "" : dirname(path),
+		if (!directory && normalizedQuery) {
+			entriesByPath.set(path, {
+				directory: dirname(path) === "." ? "" : dirname(path),
+				kind: "file",
+				name: path.split("/").pop() ?? path,
+				path
+			});
+			const parts = path.split("/");
+			for (let index = 1; index < parts.length; index += 1) {
+				const directoryPath = parts.slice(0, index).join("/");
+				entriesByPath.set(directoryPath, {
+					directory: dirname(directoryPath) === "." ? "" : dirname(directoryPath),
+					kind: "directory",
+					name: parts[index - 1],
+					path: directoryPath
+				});
+			}
+			continue;
+		}
+		const prefix = directory ? `${directory}/` : "";
+		if (!path.startsWith(prefix)) continue;
+		const childParts = path.slice(prefix.length).split("/").filter(Boolean);
+		if (childParts.length === 0) continue;
+		if (childParts.length === 1) entriesByPath.set(path, {
+			directory,
 			kind: "file",
-			name: path.split("/").pop() ?? path,
+			name: childParts[0],
 			path
 		});
-		const parts = path.split("/");
-		for (let index = 1; index < parts.length; index += 1) {
-			const directoryPath = parts.slice(0, index).join("/");
+		else {
+			const directoryPath = [...directory ? directory.split("/") : [], childParts[0]].join("/");
 			entriesByPath.set(directoryPath, {
-				directory: dirname(directoryPath) === "." ? "" : dirname(directoryPath),
+				directory,
 				kind: "directory",
-				name: parts[index - 1],
+				name: childParts[0],
 				path: directoryPath
 			});
 		}
 	}
 	return [...entriesByPath.values()].filter((entry) => {
 		if (!normalizedQuery) return true;
-		return entry.path.toLowerCase().includes(normalizedQuery);
+		return entry.name.toLowerCase().includes(normalizedQuery) || entry.path.toLowerCase().includes(normalizedQuery);
 	}).sort((left, right) => {
 		const leftScore = workspaceFileScore(left.path, normalizedQuery);
 		const rightScore = workspaceFileScore(right.path, normalizedQuery);
 		if (leftScore !== rightScore) return leftScore - rightScore;
 		if (left.kind !== right.kind) return left.kind === "directory" ? -1 : 1;
 		return left.path.localeCompare(right.path);
-	}).slice(0, 80);
+	}).slice(0, directory || !normalizedQuery ? 160 : 80);
+}
+async function readWorkspaceFileContent(workspacePath, requestedPath) {
+	const relativePath = normalizeWorkspaceRelativePath(requestedPath);
+	if (!relativePath.success) return {
+		code: "invalid_workspace_file_path",
+		error: relativePath.error,
+		status: 400,
+		success: false
+	};
+	const rootPath = resolve(workspacePath);
+	const absolutePath = resolve(rootPath, relativePath.path);
+	if (!isPathInside(rootPath, absolutePath)) return {
+		code: "invalid_workspace_file_path",
+		error: "Workspace file path must stay inside the workspace.",
+		status: 400,
+		success: false
+	};
+	const fileStat = await stat(absolutePath).catch(() => null);
+	if (!fileStat?.isFile()) return {
+		code: "workspace_file_not_found",
+		error: "Workspace file was not found.",
+		status: 404,
+		success: false
+	};
+	const bytesToRead = Math.min(fileStat.size, WORKSPACE_FILE_PREVIEW_MAX_BYTES);
+	const buffer = Buffer.alloc(bytesToRead);
+	if (bytesToRead > 0) {
+		const handle = await open(absolutePath, "r");
+		try {
+			await handle.read(buffer, 0, bytesToRead, 0);
+		} finally {
+			await handle.close();
+		}
+	}
+	const binary = buffer.includes(0);
+	return {
+		content: {
+			binary,
+			content: binary ? "" : buffer.toString("utf8"),
+			directory: dirname(relativePath.path) === "." ? "" : dirname(relativePath.path),
+			language: languageFromWorkspaceFile(relativePath.path),
+			name: basename(relativePath.path),
+			path: relativePath.path,
+			size: fileStat.size,
+			truncated: fileStat.size > WORKSPACE_FILE_PREVIEW_MAX_BYTES
+		},
+		success: true
+	};
+}
+async function updateWorkspaceFileContent(workspacePath, input) {
+	const relativePath = normalizeWorkspaceRelativePath(input.path);
+	if (!relativePath.success) return {
+		code: "invalid_workspace_file_path",
+		error: relativePath.error,
+		status: 400,
+		success: false
+	};
+	const rootPath = resolve(workspacePath);
+	const absolutePath = resolve(rootPath, relativePath.path);
+	if (!isPathInside(rootPath, absolutePath)) return {
+		code: "invalid_workspace_file_path",
+		error: "Workspace file path must stay inside the workspace.",
+		status: 400,
+		success: false
+	};
+	if (!(await stat(absolutePath).catch(() => null))?.isFile()) return {
+		code: "workspace_file_not_found",
+		error: "Workspace file was not found.",
+		status: 404,
+		success: false
+	};
+	await writeFile(absolutePath, input.content, "utf8");
+	return readWorkspaceFileContent(workspacePath, relativePath.path);
+}
+function normalizeWorkspaceRelativePath(requestedPath) {
+	const normalized = requestedPath.trim().replaceAll("\\", "/").replace(/^\.\/+/, "");
+	if (!normalized) return {
+		error: "Workspace file path is required.",
+		success: false
+	};
+	if (isAbsolute(normalized)) return {
+		error: "Workspace file path must be relative.",
+		success: false
+	};
+	const segments = normalized.split("/").filter(Boolean);
+	if (segments.some((segment) => segment === "." || segment === ".." || segment === ".git")) return {
+		error: "Workspace file path contains an unsupported segment.",
+		success: false
+	};
+	return {
+		path: segments.join("/"),
+		success: true
+	};
+}
+function normalizeWorkspaceDirectoryPath(requestedPath) {
+	const normalized = requestedPath.trim().replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+$/, "");
+	if (!normalized) return {
+		path: "",
+		success: true
+	};
+	if (isAbsolute(normalized)) return {
+		error: "Workspace directory path must be relative.",
+		success: false
+	};
+	const segments = normalized.split("/").filter(Boolean);
+	if (segments.some((segment) => segment === "." || segment === ".." || segment === ".git")) return {
+		error: "Workspace directory path contains an unsupported segment.",
+		success: false
+	};
+	return {
+		path: segments.join("/"),
+		success: true
+	};
+}
+function parentWorkspaceDirectory(directory) {
+	if (!directory) return null;
+	const parent = dirname(directory);
+	return parent === "." ? "" : parent;
+}
+function isPathInside(rootPath, targetPath) {
+	const pathFromRoot = relative(rootPath, targetPath);
+	return Boolean(pathFromRoot) && !pathFromRoot.startsWith("..") && !isAbsolute(pathFromRoot);
+}
+function languageFromWorkspaceFile(path) {
+	const name = basename(path).toLowerCase();
+	const extension = extname(name).replace(/^\./, "");
+	if (name === "dockerfile") return "dockerfile";
+	if (name === "makefile") return "make";
+	if (name === "package.json") return "json";
+	return {
+		cjs: "javascript",
+		css: "css",
+		diff: "diff",
+		go: "go",
+		htm: "html",
+		html: "html",
+		java: "java",
+		js: "javascript",
+		json: "json",
+		jsx: "jsx",
+		kt: "kotlin",
+		lock: "yaml",
+		log: "text",
+		md: "markdown",
+		mdx: "markdown",
+		mjs: "javascript",
+		plist: "xml",
+		py: "python",
+		rb: "ruby",
+		rs: "rust",
+		sh: "bash",
+		swift: "swift",
+		ts: "typescript",
+		tsx: "tsx",
+		txt: "text",
+		xml: "xml",
+		yaml: "yaml",
+		yml: "yaml"
+	}[extension] ?? extension;
 }
 async function workspaceFilePaths(workspacePath) {
+	const isIgnored = await workspaceIgnoreMatcher(workspacePath);
 	try {
 		return (await git(workspacePath, [
 			"ls-files",
 			"--cached",
 			"--others",
 			"--exclude-standard"
-		])).split("\n").filter(Boolean);
+		])).split("\n").filter(Boolean).filter((path) => !isIgnored(path));
 	} catch {
-		return recursiveWorkspaceFilePaths(workspacePath);
+		return recursiveWorkspaceFilePaths(workspacePath, isIgnored);
 	}
 }
-async function recursiveWorkspaceFilePaths(rootPath) {
+async function recursiveWorkspaceFilePaths(rootPath, isIgnored) {
 	const ignoredDirectories = new Set([
 		".git",
 		".expo",
@@ -4868,17 +5410,45 @@ async function recursiveWorkspaceFilePaths(rootPath) {
 		for (const entry of entries) {
 			if (entry.name.startsWith(".") && entry.name !== ".github") continue;
 			const absolutePath = resolve(directory, entry.name);
+			const relativePath = relative(rootPath, absolutePath).split("\\").join("/");
+			if (isIgnored(relativePath)) continue;
 			if (entry.isDirectory()) {
 				if (ignoredDirectories.has(entry.name)) continue;
 				await visit(absolutePath);
 				continue;
 			}
-			if (entry.isFile()) results.push(relative(rootPath, absolutePath).split("\\").join("/"));
+			if (entry.isFile()) results.push(relativePath);
 		}
 	}
 	await visit(rootPath);
 	return results;
 }
+async function workspaceIgnoreMatcher(workspacePath) {
+	const matchers = (await readFile(join(workspacePath, ".gitignore"), "utf8").catch(() => "")).split(/\r?\n/).map((line) => gitignorePatternMatcher(line)).filter((matcher) => Boolean(matcher));
+	return (path) => matchers.some((matcher) => matcher(path.split("\\").join("/")));
+}
+function gitignorePatternMatcher(line) {
+	const trimmed = line.trim();
+	if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("!")) return;
+	const directoryOnly = trimmed.endsWith("/");
+	const anchored = trimmed.startsWith("/");
+	const pattern = trimmed.replace(/^\/+/, "").replace(/\/+$/, "");
+	if (!pattern) return;
+	const matcher = gitignoreGlobMatcher(pattern);
+	const hasSlash = pattern.includes("/");
+	return (path) => {
+		const normalizedPath = path.replace(/^\/+/, "");
+		return (anchored || hasSlash ? [normalizedPath] : normalizedPath.split("/")).some((candidate) => {
+			if (directoryOnly) return matcher(candidate) || normalizedPath.startsWith(`${candidate}/`);
+			return matcher(candidate);
+		});
+	};
+}
+function gitignoreGlobMatcher(pattern) {
+	const expression = pattern.split("**").map((part) => part.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*")).join(".*").replace(/\?/g, "[^/]");
+	const regex = new RegExp(`^${expression}(?:/.*)?$`);
+	return (path) => regex.test(path);
+}
 function workspaceFileScore(path, query) {
 	if (!query) return path.split("/").length;
 	const lowerPath = path.toLowerCase();