codex-relay 1.2.4 → 1.3.1

package/dist/api-schema.js

@@ -1,2 +1,2 @@
-import { $ as SandboxModeSchema, A as PairResponseSchema, At as WorkspaceSelectionRequestSchema, B as QueuedThreadInputSchema, Bt as chatMessageDetailsFromPromptContext, C as ListQueuedThreadInputsResponseSchema, Ct as WorkspaceDirectoryEntrySchema, D as ListWorkspaceFilesResponseSchema, Dt as WorkspaceMarkdownPreviewTargetSchema, E as ListWorkspaceDirectoriesResponseSchema, Et as WorkspaceGitActionResponseSchema, F as PromptAttachmentSummarySchema, Ft as WorkspaceTerminalOutputResponseSchema, G as ResolveApprovalRequestSchema, Gt as promptSkillDisplayName, H as RateLimitWindowSchema, Ht as isPromptSkillMarkdownMention, I as PromptContextInputSchema, It as WorkspaceTerminalResizeRequestSchema, J as RunThreadResponseSchema, Jt as promptSkillMentionTextCandidates, K as ResolveApprovalResponseSchema, Kt as promptSkillMentionLabel, L as PromptContextSchema, Lt as WorkspaceTerminalSessionResponseSchema, M as PendingInputRequestQuestionSchema, Mt as WorkspaceTailscaleServeResponseSchema, N as PendingInputRequestSchema, Nt as WorkspaceTerminalInputRequestSchema, O as PairEncryptedPayloadSchema, Ot as WorkspacePreviewNavigationRequestSchema, P as PromptAttachmentSchema, Pt as WorkspaceTerminalOutputChunkSchema, Q as RuntimePreferencesSchema, R as PromptSkillSchema, Rt as WorkspaceTerminalStartRequestSchema, S as ListModelsResponseSchema, St as WorkspaceChangesResponseSchema, T as ListThreadsResponseSchema, Tt as WorkspaceFileMentionSchema, U as RateLimitsResponseSchema, Ut as normalizePromptContext, V as RateLimitBucketSchema, Vt as createOpenApiDocument, W as ReasoningEffortSchema, Wt as promptMarkdownWithSkills, X as RuntimePreferencesByWorkspacePathSchema, Y as RuntimeModeSchema, Yt as stripPromptSkillMentions, Z as RuntimePreferencesResponseSchema, _ as EncryptedPayloadSchema, _t as UpdateWorkspaceFileContentRequestSchema, a as ArchiveThreadResponseSchema, at as ThreadContextWindowResponseSchema, b as InterruptThreadRunResponseSchema, bt as WORKSPACE_PREVIEW_TAB_VALUES, c as ChatMessageRoleSchema, ct as ThreadGoalSchema, d as CheckoutWorkspaceBranchRequestSchema, dt as ThreadMessageDetailResponseSchema, et as StatusResponseSchema, f as CodexModelSchema, ft as ThreadRunOptionsSchema, g as CreateThreadResponseSchema, gt as UpdateThreadGoalRequestSchema, h as CreateThreadRequestSchema, ht as UpdateRuntimePreferencesRequestSchema, i as ApprovalModeSchema, it as ThreadCollaborationModeSchema, j as PendingInputRequestOptionSchema, jt as WorkspaceTailscaleServeRequestSchema, k as PairRequestSchema, kt as WorkspacePreviewTabSchema, l as ChatMessageSchema, lt as ThreadGoalStatusSchema, m as ContextWindowUsageSchema, mt as ThreadSummarySchema, n as AgentSkillSourceSchema, nt as StreamThreadRunRequestSchema, o as ChatMessageKindSchema, ot as ThreadDetailResponseSchema, p as CommitPushWorkspaceRequestSchema, pt as ThreadStateSchema, q as RunThreadRequestSchema, qt as promptSkillMentionMarkdown, r as ApprovalDecisionSchema, rt as SubmitThreadInputResponseSchema, s as ChatMessagePromptDetailsSchema, st as ThreadGoalResponseSchema, t as AgentSkillSchema, tt as StreamThreadRunEventSchema, u as ChatMessageStateSchema, ut as ThreadMessageDetailFieldSchema, v as ErrorResponseSchema, vt as VersionResponseSchema, w as ListSkillsResponseSchema, wt as WorkspaceFileContentResponseSchema, x as IsoDateTimeSchema, xt as WebPreviewTargetSchema, y as ImageAttachmentUploadResponseSchema, yt as WORKSPACE_PREVIEW_OPEN_PROTOCOL, z as QueuedThreadInputActionResponseSchema, zt as apiPaths } from "./api-schema2.js";
-export { AgentSkillSchema, AgentSkillSourceSchema, ApprovalDecisionSchema, ApprovalModeSchema, ArchiveThreadResponseSchema, ChatMessageKindSchema, ChatMessagePromptDetailsSchema, ChatMessageRoleSchema, ChatMessageSchema, ChatMessageStateSchema, CheckoutWorkspaceBranchRequestSchema, CodexModelSchema, CommitPushWorkspaceRequestSchema, ContextWindowUsageSchema, CreateThreadRequestSchema, CreateThreadResponseSchema, EncryptedPayloadSchema, ErrorResponseSchema, ImageAttachmentUploadResponseSchema, InterruptThreadRunResponseSchema, IsoDateTimeSchema, ListModelsResponseSchema, ListQueuedThreadInputsResponseSchema, ListSkillsResponseSchema, ListThreadsResponseSchema, ListWorkspaceDirectoriesResponseSchema, ListWorkspaceFilesResponseSchema, PairEncryptedPayloadSchema, PairRequestSchema, PairResponseSchema, PendingInputRequestOptionSchema, PendingInputRequestQuestionSchema, PendingInputRequestSchema, PromptAttachmentSchema, PromptAttachmentSummarySchema, PromptContextInputSchema, PromptContextSchema, PromptSkillSchema, QueuedThreadInputActionResponseSchema, QueuedThreadInputSchema, RateLimitBucketSchema, RateLimitWindowSchema, RateLimitsResponseSchema, ReasoningEffortSchema, ResolveApprovalRequestSchema, ResolveApprovalResponseSchema, RunThreadRequestSchema, RunThreadResponseSchema, RuntimeModeSchema, RuntimePreferencesByWorkspacePathSchema, RuntimePreferencesResponseSchema, RuntimePreferencesSchema, SandboxModeSchema, StatusResponseSchema, StreamThreadRunEventSchema, StreamThreadRunRequestSchema, SubmitThreadInputResponseSchema, ThreadCollaborationModeSchema, ThreadContextWindowResponseSchema, ThreadDetailResponseSchema, ThreadGoalResponseSchema, ThreadGoalSchema, ThreadGoalStatusSchema, ThreadMessageDetailFieldSchema, ThreadMessageDetailResponseSchema, ThreadRunOptionsSchema, ThreadStateSchema, ThreadSummarySchema, UpdateRuntimePreferencesRequestSchema, UpdateThreadGoalRequestSchema, UpdateWorkspaceFileContentRequestSchema, VersionResponseSchema, WORKSPACE_PREVIEW_OPEN_PROTOCOL, WORKSPACE_PREVIEW_TAB_VALUES, WebPreviewTargetSchema, WorkspaceChangesResponseSchema, WorkspaceDirectoryEntrySchema, WorkspaceFileContentResponseSchema, WorkspaceFileMentionSchema, WorkspaceGitActionResponseSchema, WorkspaceMarkdownPreviewTargetSchema, WorkspacePreviewNavigationRequestSchema, WorkspacePreviewTabSchema, WorkspaceSelectionRequestSchema, WorkspaceTailscaleServeRequestSchema, WorkspaceTailscaleServeResponseSchema, WorkspaceTerminalInputRequestSchema, WorkspaceTerminalOutputChunkSchema, WorkspaceTerminalOutputResponseSchema, WorkspaceTerminalResizeRequestSchema, WorkspaceTerminalSessionResponseSchema, WorkspaceTerminalStartRequestSchema, apiPaths, chatMessageDetailsFromPromptContext, createOpenApiDocument, isPromptSkillMarkdownMention, normalizePromptContext, promptMarkdownWithSkills, promptSkillDisplayName, promptSkillMentionLabel, promptSkillMentionMarkdown, promptSkillMentionTextCandidates, stripPromptSkillMentions };
+import { $ as RuntimePreferencesSchema, A as PairRequestSchema, At as WorkspacePreviewTabSchema, B as QueuedThreadInputActionResponseSchema, Bt as apiPaths, C as ListModelsResponseSchema, Ct as WorkspaceChangesResponseSchema, D as ListWorkspaceDirectoriesResponseSchema, Dt as WorkspaceGitActionResponseSchema, E as ListThreadsResponseSchema, Et as WorkspaceFileMentionSchema, F as PromptAttachmentSchema, Ft as WorkspaceTerminalOutputChunkSchema, G as ReasoningEffortSchema, Gt as promptMarkdownWithSkills, H as RateLimitBucketSchema, Ht as createOpenApiDocument, I as PromptAttachmentSummarySchema, It as WorkspaceTerminalOutputResponseSchema, J as RunThreadRequestSchema, Jt as promptSkillMentionMarkdown, K as ResolveApprovalRequestSchema, Kt as promptSkillDisplayName, L as PromptContextInputSchema, Lt as WorkspaceTerminalResizeRequestSchema, M as PendingInputRequestOptionSchema, Mt as WorkspaceTailscaleServeRequestSchema, N as PendingInputRequestQuestionSchema, Nt as WorkspaceTailscaleServeResponseSchema, O as ListWorkspaceFilesResponseSchema, Ot as WorkspaceMarkdownPreviewTargetSchema, P as PendingInputRequestSchema, Pt as WorkspaceTerminalInputRequestSchema, Q as RuntimePreferencesResponseSchema, R as PromptContextSchema, Rt as WorkspaceTerminalSessionResponseSchema, S as KnownReasoningEffortSchema, St as WebPreviewTargetSchema, T as ListSkillsResponseSchema, Tt as WorkspaceFileContentResponseSchema, U as RateLimitWindowSchema, Ut as isPromptSkillMarkdownMention, V as QueuedThreadInputSchema, Vt as chatMessageDetailsFromPromptContext, W as RateLimitsResponseSchema, Wt as normalizePromptContext, X as RuntimeModeSchema, Xt as stripPromptSkillMentions, Y as RunThreadResponseSchema, Yt as promptSkillMentionTextCandidates, Z as RuntimePreferencesByWorkspacePathSchema, _ as EncryptedPayloadSchema, _t as UpdateThreadGoalRequestSchema, a as ArchiveThreadResponseSchema, at as ThreadCollaborationModeSchema, b as InterruptThreadRunResponseSchema, bt as WORKSPACE_PREVIEW_OPEN_PROTOCOL, c as ChatMessageRoleSchema, ct as ThreadGoalResponseSchema, d as CheckoutWorkspaceBranchRequestSchema, dt as ThreadMessageDetailFieldSchema, et as SandboxModeSchema, f as CodexModelSchema, ft as ThreadMessageDetailResponseSchema, g as CreateThreadResponseSchema, gt as UpdateRuntimePreferencesRequestSchema, h as CreateThreadRequestSchema, ht as ThreadSummarySchema, i as ApprovalModeSchema, it as SubmitThreadInputResponseSchema, j as PairResponseSchema, jt as WorkspaceSelectionRequestSchema, k as PairEncryptedPayloadSchema, kt as WorkspacePreviewNavigationRequestSchema, l as ChatMessageSchema, lt as ThreadGoalSchema, m as ContextWindowUsageSchema, mt as ThreadStateSchema, n as AgentSkillSourceSchema, nt as StreamThreadRunEventSchema, o as ChatMessageKindSchema, ot as ThreadContextWindowResponseSchema, p as CommitPushWorkspaceRequestSchema, pt as ThreadRunOptionsSchema, q as ResolveApprovalResponseSchema, qt as promptSkillMentionLabel, r as ApprovalDecisionSchema, rt as StreamThreadRunRequestSchema, s as ChatMessagePromptDetailsSchema, st as ThreadDetailResponseSchema, t as AgentSkillSchema, tt as StatusResponseSchema, u as ChatMessageStateSchema, ut as ThreadGoalStatusSchema, v as ErrorResponseSchema, vt as UpdateWorkspaceFileContentRequestSchema, w as ListQueuedThreadInputsResponseSchema, wt as WorkspaceDirectoryEntrySchema, x as IsoDateTimeSchema, xt as WORKSPACE_PREVIEW_TAB_VALUES, y as ImageAttachmentUploadResponseSchema, yt as VersionResponseSchema, z as PromptSkillSchema, zt as WorkspaceTerminalStartRequestSchema } from "./api-schema2.js";
+export { AgentSkillSchema, AgentSkillSourceSchema, ApprovalDecisionSchema, ApprovalModeSchema, ArchiveThreadResponseSchema, ChatMessageKindSchema, ChatMessagePromptDetailsSchema, ChatMessageRoleSchema, ChatMessageSchema, ChatMessageStateSchema, CheckoutWorkspaceBranchRequestSchema, CodexModelSchema, CommitPushWorkspaceRequestSchema, ContextWindowUsageSchema, CreateThreadRequestSchema, CreateThreadResponseSchema, EncryptedPayloadSchema, ErrorResponseSchema, ImageAttachmentUploadResponseSchema, InterruptThreadRunResponseSchema, IsoDateTimeSchema, KnownReasoningEffortSchema, ListModelsResponseSchema, ListQueuedThreadInputsResponseSchema, ListSkillsResponseSchema, ListThreadsResponseSchema, ListWorkspaceDirectoriesResponseSchema, ListWorkspaceFilesResponseSchema, PairEncryptedPayloadSchema, PairRequestSchema, PairResponseSchema, PendingInputRequestOptionSchema, PendingInputRequestQuestionSchema, PendingInputRequestSchema, PromptAttachmentSchema, PromptAttachmentSummarySchema, PromptContextInputSchema, PromptContextSchema, PromptSkillSchema, QueuedThreadInputActionResponseSchema, QueuedThreadInputSchema, RateLimitBucketSchema, RateLimitWindowSchema, RateLimitsResponseSchema, ReasoningEffortSchema, ResolveApprovalRequestSchema, ResolveApprovalResponseSchema, RunThreadRequestSchema, RunThreadResponseSchema, RuntimeModeSchema, RuntimePreferencesByWorkspacePathSchema, RuntimePreferencesResponseSchema, RuntimePreferencesSchema, SandboxModeSchema, StatusResponseSchema, StreamThreadRunEventSchema, StreamThreadRunRequestSchema, SubmitThreadInputResponseSchema, ThreadCollaborationModeSchema, ThreadContextWindowResponseSchema, ThreadDetailResponseSchema, ThreadGoalResponseSchema, ThreadGoalSchema, ThreadGoalStatusSchema, ThreadMessageDetailFieldSchema, ThreadMessageDetailResponseSchema, ThreadRunOptionsSchema, ThreadStateSchema, ThreadSummarySchema, UpdateRuntimePreferencesRequestSchema, UpdateThreadGoalRequestSchema, UpdateWorkspaceFileContentRequestSchema, VersionResponseSchema, WORKSPACE_PREVIEW_OPEN_PROTOCOL, WORKSPACE_PREVIEW_TAB_VALUES, WebPreviewTargetSchema, WorkspaceChangesResponseSchema, WorkspaceDirectoryEntrySchema, WorkspaceFileContentResponseSchema, WorkspaceFileMentionSchema, WorkspaceGitActionResponseSchema, WorkspaceMarkdownPreviewTargetSchema, WorkspacePreviewNavigationRequestSchema, WorkspacePreviewTabSchema, WorkspaceSelectionRequestSchema, WorkspaceTailscaleServeRequestSchema, WorkspaceTailscaleServeResponseSchema, WorkspaceTerminalInputRequestSchema, WorkspaceTerminalOutputChunkSchema, WorkspaceTerminalOutputResponseSchema, WorkspaceTerminalResizeRequestSchema, WorkspaceTerminalSessionResponseSchema, WorkspaceTerminalStartRequestSchema, apiPaths, chatMessageDetailsFromPromptContext, createOpenApiDocument, isPromptSkillMarkdownMention, normalizePromptContext, promptMarkdownWithSkills, promptSkillDisplayName, promptSkillMentionLabel, promptSkillMentionMarkdown, promptSkillMentionTextCandidates, stripPromptSkillMentions };

package/dist/api-schema2.js

@@ -49,13 +49,16 @@ const SandboxModeSchema = z.enum([
 	"danger-full-access",
 	"read-only"
 ]);
-const ReasoningEffortSchema = z.enum([
+const KnownReasoningEffortSchema = z.enum([
 	"minimal",
 	"low",
 	"medium",
 	"high",
-	"xhigh"
+	"xhigh",
+	"max",
+	"ultra"
 ]);
+const ReasoningEffortSchema = z.string().trim().min(1);
 const ThreadCollaborationModeSchema = z.enum(["default", "plan"]);
 const ThreadGoalStatusSchema = z.enum([
 	"active",
@@ -109,6 +112,10 @@ const CodexModelSchema = z.object({
 	isDefault: z.boolean().default(false),
 	defaultReasoningEffort: ReasoningEffortSchema.optional(),
 	supportedReasoningEfforts: z.array(ReasoningEffortSchema).default([]),
+	reasoningEffortOptions: z.array(z.object({
+		reasoningEffort: ReasoningEffortSchema,
+		description: z.string().optional()
+	})).default([]),
 	serviceTiers: z.array(z.object({
 		id: z.string().min(1),
 		name: z.string().min(1),
@@ -954,6 +961,10 @@ function createOpenApiDocument() {
 				type: "string",
 				enum: ThreadStateSchema.options
 			},
+			ReasoningEffort: {
+				type: "string",
+				minLength: 1
+			},
 			ChatMessage: {
 				type: "object",
 				required: [
@@ -1186,13 +1197,7 @@ function createOpenApiDocument() {
 					},
 					reasoningEffort: {
 						type: "string",
-						enum: [
-							"minimal",
-							"low",
-							"medium",
-							"high",
-							"xhigh"
-						]
+						minLength: 1
 					}
 				}
 			},
@@ -1220,13 +1225,7 @@ function createOpenApiDocument() {
 					},
 					reasoningEffort: {
 						type: "string",
-						enum: [
-							"minimal",
-							"low",
-							"medium",
-							"high",
-							"xhigh"
-						],
+						minLength: 1,
 						nullable: true
 					}
 				}
@@ -1726,4 +1725,4 @@ function jsonResponse(schemaName) {
 	};
 }
 //#endregion
-export { SandboxModeSchema as $, PairResponseSchema as A, WorkspaceSelectionRequestSchema as At, QueuedThreadInputSchema as B, chatMessageDetailsFromPromptContext as Bt, ListQueuedThreadInputsResponseSchema as C, WorkspaceDirectoryEntrySchema as Ct, ListWorkspaceFilesResponseSchema as D, WorkspaceMarkdownPreviewTargetSchema as Dt, ListWorkspaceDirectoriesResponseSchema as E, WorkspaceGitActionResponseSchema as Et, PromptAttachmentSummarySchema as F, WorkspaceTerminalOutputResponseSchema as Ft, ResolveApprovalRequestSchema as G, promptSkillDisplayName as Gt, RateLimitWindowSchema as H, isPromptSkillMarkdownMention as Ht, PromptContextInputSchema as I, WorkspaceTerminalResizeRequestSchema as It, RunThreadResponseSchema as J, promptSkillMentionTextCandidates as Jt, ResolveApprovalResponseSchema as K, promptSkillMentionLabel as Kt, PromptContextSchema as L, WorkspaceTerminalSessionResponseSchema as Lt, PendingInputRequestQuestionSchema as M, WorkspaceTailscaleServeResponseSchema as Mt, PendingInputRequestSchema as N, WorkspaceTerminalInputRequestSchema as Nt, PairEncryptedPayloadSchema as O, WorkspacePreviewNavigationRequestSchema as Ot, PromptAttachmentSchema as P, WorkspaceTerminalOutputChunkSchema as Pt, RuntimePreferencesSchema as Q, PromptSkillSchema as R, WorkspaceTerminalStartRequestSchema as Rt, ListModelsResponseSchema as S, WorkspaceChangesResponseSchema as St, ListThreadsResponseSchema as T, WorkspaceFileMentionSchema as Tt, RateLimitsResponseSchema as U, normalizePromptContext as Ut, RateLimitBucketSchema as V, createOpenApiDocument as Vt, ReasoningEffortSchema as W, promptMarkdownWithSkills as Wt, RuntimePreferencesByWorkspacePathSchema as X, RuntimeModeSchema as Y, stripPromptSkillMentions as Yt, RuntimePreferencesResponseSchema as Z, EncryptedPayloadSchema as _, UpdateWorkspaceFileContentRequestSchema as _t, ArchiveThreadResponseSchema as a, ThreadContextWindowResponseSchema as at, InterruptThreadRunResponseSchema as b, WORKSPACE_PREVIEW_TAB_VALUES as bt, ChatMessageRoleSchema as c, ThreadGoalSchema as ct, CheckoutWorkspaceBranchRequestSchema as d, ThreadMessageDetailResponseSchema as dt, StatusResponseSchema as et, CodexModelSchema as f, ThreadRunOptionsSchema as ft, CreateThreadResponseSchema as g, UpdateThreadGoalRequestSchema as gt, CreateThreadRequestSchema as h, UpdateRuntimePreferencesRequestSchema as ht, ApprovalModeSchema as i, ThreadCollaborationModeSchema as it, PendingInputRequestOptionSchema as j, WorkspaceTailscaleServeRequestSchema as jt, PairRequestSchema as k, WorkspacePreviewTabSchema as kt, ChatMessageSchema as l, ThreadGoalStatusSchema as lt, ContextWindowUsageSchema as m, ThreadSummarySchema as mt, AgentSkillSourceSchema as n, StreamThreadRunRequestSchema as nt, ChatMessageKindSchema as o, ThreadDetailResponseSchema as ot, CommitPushWorkspaceRequestSchema as p, ThreadStateSchema as pt, RunThreadRequestSchema as q, promptSkillMentionMarkdown as qt, ApprovalDecisionSchema as r, SubmitThreadInputResponseSchema as rt, ChatMessagePromptDetailsSchema as s, ThreadGoalResponseSchema as st, AgentSkillSchema as t, StreamThreadRunEventSchema as tt, ChatMessageStateSchema as u, ThreadMessageDetailFieldSchema as ut, ErrorResponseSchema as v, VersionResponseSchema as vt, ListSkillsResponseSchema as w, WorkspaceFileContentResponseSchema as wt, IsoDateTimeSchema as x, WebPreviewTargetSchema as xt, ImageAttachmentUploadResponseSchema as y, WORKSPACE_PREVIEW_OPEN_PROTOCOL as yt, QueuedThreadInputActionResponseSchema as z, apiPaths as zt };
+export { RuntimePreferencesSchema as $, PairRequestSchema as A, WorkspacePreviewTabSchema as At, QueuedThreadInputActionResponseSchema as B, apiPaths as Bt, ListModelsResponseSchema as C, WorkspaceChangesResponseSchema as Ct, ListWorkspaceDirectoriesResponseSchema as D, WorkspaceGitActionResponseSchema as Dt, ListThreadsResponseSchema as E, WorkspaceFileMentionSchema as Et, PromptAttachmentSchema as F, WorkspaceTerminalOutputChunkSchema as Ft, ReasoningEffortSchema as G, promptMarkdownWithSkills as Gt, RateLimitBucketSchema as H, createOpenApiDocument as Ht, PromptAttachmentSummarySchema as I, WorkspaceTerminalOutputResponseSchema as It, RunThreadRequestSchema as J, promptSkillMentionMarkdown as Jt, ResolveApprovalRequestSchema as K, promptSkillDisplayName as Kt, PromptContextInputSchema as L, WorkspaceTerminalResizeRequestSchema as Lt, PendingInputRequestOptionSchema as M, WorkspaceTailscaleServeRequestSchema as Mt, PendingInputRequestQuestionSchema as N, WorkspaceTailscaleServeResponseSchema as Nt, ListWorkspaceFilesResponseSchema as O, WorkspaceMarkdownPreviewTargetSchema as Ot, PendingInputRequestSchema as P, WorkspaceTerminalInputRequestSchema as Pt, RuntimePreferencesResponseSchema as Q, PromptContextSchema as R, WorkspaceTerminalSessionResponseSchema as Rt, KnownReasoningEffortSchema as S, WebPreviewTargetSchema as St, ListSkillsResponseSchema as T, WorkspaceFileContentResponseSchema as Tt, RateLimitWindowSchema as U, isPromptSkillMarkdownMention as Ut, QueuedThreadInputSchema as V, chatMessageDetailsFromPromptContext as Vt, RateLimitsResponseSchema as W, normalizePromptContext as Wt, RuntimeModeSchema as X, stripPromptSkillMentions as Xt, RunThreadResponseSchema as Y, promptSkillMentionTextCandidates as Yt, RuntimePreferencesByWorkspacePathSchema as Z, EncryptedPayloadSchema as _, UpdateThreadGoalRequestSchema as _t, ArchiveThreadResponseSchema as a, ThreadCollaborationModeSchema as at, InterruptThreadRunResponseSchema as b, WORKSPACE_PREVIEW_OPEN_PROTOCOL as bt, ChatMessageRoleSchema as c, ThreadGoalResponseSchema as ct, CheckoutWorkspaceBranchRequestSchema as d, ThreadMessageDetailFieldSchema as dt, SandboxModeSchema as et, CodexModelSchema as f, ThreadMessageDetailResponseSchema as ft, CreateThreadResponseSchema as g, UpdateRuntimePreferencesRequestSchema as gt, CreateThreadRequestSchema as h, ThreadSummarySchema as ht, ApprovalModeSchema as i, SubmitThreadInputResponseSchema as it, PairResponseSchema as j, WorkspaceSelectionRequestSchema as jt, PairEncryptedPayloadSchema as k, WorkspacePreviewNavigationRequestSchema as kt, ChatMessageSchema as l, ThreadGoalSchema as lt, ContextWindowUsageSchema as m, ThreadStateSchema as mt, AgentSkillSourceSchema as n, StreamThreadRunEventSchema as nt, ChatMessageKindSchema as o, ThreadContextWindowResponseSchema as ot, CommitPushWorkspaceRequestSchema as p, ThreadRunOptionsSchema as pt, ResolveApprovalResponseSchema as q, promptSkillMentionLabel as qt, ApprovalDecisionSchema as r, StreamThreadRunRequestSchema as rt, ChatMessagePromptDetailsSchema as s, ThreadDetailResponseSchema as st, AgentSkillSchema as t, StatusResponseSchema as tt, ChatMessageStateSchema as u, ThreadGoalStatusSchema as ut, ErrorResponseSchema as v, UpdateWorkspaceFileContentRequestSchema as vt, ListQueuedThreadInputsResponseSchema as w, WorkspaceDirectoryEntrySchema as wt, IsoDateTimeSchema as x, WORKSPACE_PREVIEW_TAB_VALUES as xt, ImageAttachmentUploadResponseSchema as y, VersionResponseSchema as yt, PromptSkillSchema as z, WorkspaceTerminalStartRequestSchema as zt };

package/dist/cli.js

@@ -1,14 +1,51 @@
 #!/usr/bin/env node
-import { zt as apiPaths } from "./api-schema2.js";
+import { Bt as apiPaths } from "./api-schema2.js";
 import { n as codexRelayHome, o as getConnectUrlGuidance, r as legacyCodexRelayDataPath, s as createTursoPairingSessionStore, t as codexRelayDataPath } from "./paths.js";
 import { Command } from "@commander-js/extra-typings";
 import qrcode from "qrcode-terminal";
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { closeSync, openSync } from "node:fs";
 import { access, mkdir, readFile, rm, unlink } from "node:fs/promises";
 import { dirname } from "node:path";
 import { setTimeout } from "node:timers/promises";
 import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+//#region src/background-process.ts
+const execFileAsync = promisify(execFile);
+async function readRunningRelayPid(pidPath, options = {}) {
+	const value = await readFile(pidPath, "utf8").catch(() => void 0);
+	const pid = value ? Number(value.trim()) : NaN;
+	if (!Number.isInteger(pid) || pid <= 0) return;
+	if (!(options.isProcessAlive ?? defaultIsProcessAlive)(pid)) return;
+	const command = await (options.commandReader ?? readProcessCommand)(pid);
+	return command && isRelayProcessCommand(command) ? pid : void 0;
+}
+function defaultIsProcessAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function readProcessCommand(pid) {
+	try {
+		const { stdout } = await execFileAsync("ps", [
+			"-p",
+			String(pid),
+			"-o",
+			"command="
+		]);
+		return stdout.trim() || void 0;
+	} catch {
+		return;
+	}
+}
+function isRelayProcessCommand(command) {
+	const normalized = command.replaceAll("\\", "/");
+	return normalized.includes("codex-relay") || normalized.includes("/src/cli.ts") || normalized.includes(" src/cli.ts");
+}
+//#endregion
 //#region src/cli.ts
 const npxCommand = "npx codex-relay@latest";
 const program = new Command().name("codex-relay").description("Run and approve the codex-relay local CLI bridge.").option("--bg", "run the Codex Relay server in the background").option("--debug", "write verbose relay diagnostics to debug.log").option("--dangerously-auto-approve", "automatically approve mobile pairing requests without a local approval command").addHelpText("after", `
@@ -42,7 +79,7 @@ async function startBackgroundServer() {
 	const debugLogPath = codexRelayDataPath("debug.log");
 	const pidPath = codexRelayDataPath("server.pid");
 	await mkdir(dirname(logPath), { recursive: true });
-	const existingPid = await readRunningPid(pidPath);
+	const existingPid = await readRunningRelayPid(pidPath);
 	if (existingPid) {
 		console.log(`codex-relay is already running in the background (pid ${existingPid}).`);
 		console.log(`Logs: ${logPath}`);
@@ -86,17 +123,6 @@ async function startBackgroundServer() {
 	if (process.env.CODEX_RELAY_DEBUG === "1") console.log(`Debug logs: ${debugLogPath}`);
 	console.log(`Print the pairing QR later with: ${npxCommand} qr`);
 }
-async function readRunningPid(pidPath) {
-	const value = await readFile(pidPath, "utf8").catch(() => void 0);
-	const pid = value ? Number(value.trim()) : NaN;
-	if (!Number.isInteger(pid) || pid <= 0) return;
-	try {
-		process.kill(pid, 0);
-		return pid;
-	} catch {
-		return;
-	}
-}
 function backgroundArgs() {
 	return process.argv.slice(2).filter((arg) => arg !== "--bg");
 }
@@ -106,7 +132,7 @@ async function waitForBackgroundPid(child, pidPath) {
 		childExited = true;
 	});
 	for (let attempt = 0; attempt < 50; attempt += 1) {
-		const pid = await readRunningPid(pidPath);
+		const pid = await readRunningRelayPid(pidPath);
 		if (pid) return pid;
 		if (childExited) return;
 		await setTimeout(100);
@@ -192,7 +218,7 @@ async function clearDebugLogs() {
 	return removed;
 }
 async function hasRunningBackgroundServer() {
-	return Boolean(await readRunningPid(codexRelayDataPath("server.pid")));
+	return Boolean(await readRunningRelayPid(codexRelayDataPath("server.pid")));
 }
 async function pathExists(path) {
 	return access(path).then(() => true, () => false);
@@ -238,7 +264,7 @@ async function handleServerStartError(error) {
 	if (!isDatabaseLockError(error)) throw error;
 	const pidPath = codexRelayDataPath("server.pid");
 	const logPath = codexRelayDataPath("server.log");
-	const existingPid = await readRunningPid(pidPath);
+	const existingPid = await readRunningRelayPid(pidPath);
 	const storedState = await readServerState();
 	const state = storedState?.pairingPayload ? storedState : await readServerLogState();
 	console.error("Codex Relay is already using its local pairing database.");

package/dist/paths.js

@@ -1,9 +1,96 @@
 import { execFileSync } from "node:child_process";
 import { mkdir } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
-import { connect } from "@tursodatabase/database";
+import { pathToFileURL } from "node:url";
 import { fromByteArray, toByteArray } from "base64-js";
+import { createClient } from "@libsql/client/node";
 import { homedir, networkInterfaces, platform } from "node:os";
+//#region src/libsql-database.ts
+function connect(path) {
+	const client = createClient({
+		intMode: "number",
+		url: databaseUrl(path)
+	});
+	const lock = createExclusiveLock();
+	return {
+		...createQueryableDatabase(path === ":memory:" ? { execute(statement) {
+			return lock(() => client.execute(statement));
+		} } : client),
+		exec(sql) {
+			return path === ":memory:" ? lock(() => client.executeMultiple(sql)) : client.executeMultiple(sql);
+		},
+		transaction(callback) {
+			if (path === ":memory:") {
+				const transactionDatabase = createQueryableDatabase(client);
+				return () => lock(async () => {
+					await client.execute("BEGIN IMMEDIATE");
+					try {
+						const result = await callback(transactionDatabase);
+						await client.execute("COMMIT");
+						return result;
+					} catch (error) {
+						await client.execute("ROLLBACK");
+						throw error;
+					}
+				});
+			}
+			return async () => {
+				const transaction = await client.transaction("write");
+				try {
+					const result = await callback(createQueryableDatabase(transaction));
+					await transaction.commit();
+					return result;
+				} finally {
+					transaction.close();
+				}
+			};
+		}
+	};
+}
+function databaseUrl(path) {
+	return path === ":memory:" ? path : pathToFileURL(resolve(path)).href;
+}
+function createExclusiveLock() {
+	let tail = Promise.resolve();
+	return async function withLock(callback) {
+		const previous = tail;
+		let release;
+		tail = new Promise((resolve) => {
+			release = resolve;
+		});
+		await previous;
+		try {
+			return await callback();
+		} finally {
+			release();
+		}
+	};
+}
+function createQueryableDatabase(executor) {
+	return { prepare(sql) {
+		return {
+			async all(...args) {
+				return (await executor.execute({
+					sql,
+					args
+				})).rows;
+			},
+			async get(...args) {
+				return (await executor.execute({
+					sql,
+					args
+				})).rows[0];
+			},
+			run(...args) {
+				return executor.execute({
+					sql,
+					args
+				});
+			}
+		};
+	} };
+}
+//#endregion
 //#region src/pairing-store.ts
 async function createTursoPairingSessionStore(path) {
 	if (path !== ":memory:") await mkdir(dirname(path), { recursive: true });
@@ -86,11 +173,11 @@ async function createTursoPairingSessionStore(path) {
 			};
 		},
 		async clearAll() {
-			return await db.transaction(async () => {
-				const sessionRow = await db.prepare("SELECT COUNT(*) AS count FROM pairing_sessions").get();
-				const pendingRow = await db.prepare("SELECT COUNT(*) AS count FROM pending_pairings").get();
-				await db.prepare("DELETE FROM pairing_sessions").run();
-				await db.prepare("DELETE FROM pending_pairings").run();
+			return await db.transaction(async (transaction) => {
+				const sessionRow = await transaction.prepare("SELECT COUNT(*) AS count FROM pairing_sessions").get();
+				const pendingRow = await transaction.prepare("SELECT COUNT(*) AS count FROM pending_pairings").get();
+				await transaction.prepare("DELETE FROM pairing_sessions").run();
+				await transaction.prepare("DELETE FROM pending_pairings").run();
 				return {
 					pendingPairingsCleared: Number(pendingRow?.count ?? 0),
 					sessionsCleared: Number(sessionRow?.count ?? 0)
@@ -171,13 +258,13 @@ async function createTursoPairingSessionStore(path) {
 		async rotateSession(oldTokenHash, newTokenHash, session) {
 			const now = Date.now();
 			const secure = encodeSecureSession(session.secureSession);
-			await db.transaction(async () => {
-				await db.prepare("DELETE FROM pairing_sessions WHERE token_hash = ?").run(oldTokenHash);
+			await db.transaction(async (transaction) => {
+				await transaction.prepare("DELETE FROM pairing_sessions WHERE token_hash = ?").run(oldTokenHash);
 				if (session.clientSessionId) {
-					await db.prepare("DELETE FROM pairing_sessions WHERE client_session_id = ?").run(session.clientSessionId);
-					if (session.clientName) await db.prepare("DELETE FROM pairing_sessions WHERE client_session_id IS NULL AND client_name = ?").run(session.clientName);
+					await transaction.prepare("DELETE FROM pairing_sessions WHERE client_session_id = ?").run(session.clientSessionId);
+					if (session.clientName) await transaction.prepare("DELETE FROM pairing_sessions WHERE client_session_id IS NULL AND client_name = ?").run(session.clientName);
 				}
-				await db.prepare(`INSERT INTO pairing_sessions (
+				await transaction.prepare(`INSERT INTO pairing_sessions (
                token_hash,
                client_session_id,
                client_name,

package/dist/src.js

@@ -1,4 +1,4 @@
-import { A as PairResponseSchema, Bt as chatMessageDetailsFromPromptContext, C as ListQueuedThreadInputsResponseSchema, D as ListWorkspaceFilesResponseSchema, E as ListWorkspaceDirectoriesResponseSchema, Et as WorkspaceGitActionResponseSchema, Ft as WorkspaceTerminalOutputResponseSchema, G as ResolveApprovalRequestSchema, It as WorkspaceTerminalResizeRequestSchema, K as ResolveApprovalResponseSchema, Lt as WorkspaceTerminalSessionResponseSchema, Mt as WorkspaceTailscaleServeResponseSchema, Nt as WorkspaceTerminalInputRequestSchema, Q as RuntimePreferencesSchema, Rt as WorkspaceTerminalStartRequestSchema, S as ListModelsResponseSchema, St as WorkspaceChangesResponseSchema, T as ListThreadsResponseSchema, U as RateLimitsResponseSchema, Ut as normalizePromptContext, Vt as createOpenApiDocument, Wt as promptMarkdownWithSkills, X as RuntimePreferencesByWorkspacePathSchema, Yt as stripPromptSkillMentions, Z as RuntimePreferencesResponseSchema, _ as EncryptedPayloadSchema, _t as UpdateWorkspaceFileContentRequestSchema, a as ArchiveThreadResponseSchema, at as ThreadContextWindowResponseSchema, b as InterruptThreadRunResponseSchema, ct as ThreadGoalSchema, d as CheckoutWorkspaceBranchRequestSchema, dt as ThreadMessageDetailResponseSchema, et as StatusResponseSchema, gt as UpdateThreadGoalRequestSchema, h as CreateThreadRequestSchema, ht as UpdateRuntimePreferencesRequestSchema, jt as WorkspaceTailscaleServeRequestSchema, k as PairRequestSchema, l as ChatMessageSchema, lt as ThreadGoalStatusSchema, m as ContextWindowUsageSchema, mt as ThreadSummarySchema, nt as StreamThreadRunRequestSchema, ot as ThreadDetailResponseSchema, p as CommitPushWorkspaceRequestSchema, q as RunThreadRequestSchema, rt as SubmitThreadInputResponseSchema, st as ThreadGoalResponseSchema, tt as StreamThreadRunEventSchema, ut as ThreadMessageDetailFieldSchema, vt as VersionResponseSchema, w as ListSkillsResponseSchema, wt as WorkspaceFileContentResponseSchema, y as ImageAttachmentUploadResponseSchema, z as QueuedThreadInputActionResponseSchema, zt as apiPaths } from "./api-schema2.js";
+import { $ as RuntimePreferencesSchema, A as PairRequestSchema, B as QueuedThreadInputActionResponseSchema, Bt as apiPaths, C as ListModelsResponseSchema, Ct as WorkspaceChangesResponseSchema, D as ListWorkspaceDirectoriesResponseSchema, Dt as WorkspaceGitActionResponseSchema, E as ListThreadsResponseSchema, G as ReasoningEffortSchema, Gt as promptMarkdownWithSkills, Ht as createOpenApiDocument, It as WorkspaceTerminalOutputResponseSchema, J as RunThreadRequestSchema, K as ResolveApprovalRequestSchema, Lt as WorkspaceTerminalResizeRequestSchema, Mt as WorkspaceTailscaleServeRequestSchema, Nt as WorkspaceTailscaleServeResponseSchema, O as ListWorkspaceFilesResponseSchema, Pt as WorkspaceTerminalInputRequestSchema, Q as RuntimePreferencesResponseSchema, Rt as WorkspaceTerminalSessionResponseSchema, S as KnownReasoningEffortSchema, T as ListSkillsResponseSchema, Tt as WorkspaceFileContentResponseSchema, Vt as chatMessageDetailsFromPromptContext, W as RateLimitsResponseSchema, Wt as normalizePromptContext, Xt as stripPromptSkillMentions, _ as EncryptedPayloadSchema, _t as UpdateThreadGoalRequestSchema, a as ArchiveThreadResponseSchema, b as InterruptThreadRunResponseSchema, ct as ThreadGoalResponseSchema, d as CheckoutWorkspaceBranchRequestSchema, dt as ThreadMessageDetailFieldSchema, ft as ThreadMessageDetailResponseSchema, gt as UpdateRuntimePreferencesRequestSchema, h as CreateThreadRequestSchema, ht as ThreadSummarySchema, it as SubmitThreadInputResponseSchema, j as PairResponseSchema, l as ChatMessageSchema, lt as ThreadGoalSchema, m as ContextWindowUsageSchema, nt as StreamThreadRunEventSchema, ot as ThreadContextWindowResponseSchema, p as CommitPushWorkspaceRequestSchema, q as ResolveApprovalResponseSchema, rt as StreamThreadRunRequestSchema, st as ThreadDetailResponseSchema, tt as StatusResponseSchema, ut as ThreadGoalStatusSchema, vt as UpdateWorkspaceFileContentRequestSchema, w as ListQueuedThreadInputsResponseSchema, y as ImageAttachmentUploadResponseSchema, yt as VersionResponseSchema, zt as WorkspaceTerminalStartRequestSchema } from "./api-schema2.js";
 import { a as getConnectUrlCandidates, i as createPairingQrPayload, o as getConnectUrlGuidance, r as legacyCodexRelayDataPath, s as createTursoPairingSessionStore, t as codexRelayDataPath } from "./paths.js";
 import { createRequire } from "node:module";
 import qrcode from "qrcode-terminal";
@@ -8,6 +8,7 @@ import { access, appendFile, copyFile, mkdir, open, readFile, readdir, realpath,
 import path, { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { z } from "zod";
+import { promisify } from "node:util";
 import { fromByteArray, toByteArray } from "base64-js";
 import os, { homedir, hostname, platform } from "node:os";
 import { serve } from "@hono/node-server";
@@ -16,7 +17,6 @@ import pc from "picocolors";
 import { openRepository } from "es-git";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
-import { promisify } from "node:util";
 import * as pty from "@lydell/node-pty";
 import { createInterface } from "node:readline";
 import { Codex } from "@openai/codex-sdk";
@@ -500,9 +500,10 @@ function formatDebugValue(value) {
 //#endregion
 //#region src/preferences-store.ts
 const defaultRuntimePreferences = { runtimeMode: "default" };
+const PersistedRuntimePreferencesSchema = RuntimePreferencesSchema;
 const RuntimePreferencesFileSchema = z.object({
-	preferences: RuntimePreferencesSchema.default(defaultRuntimePreferences),
-	runtimePreferencesByWorkspacePath: RuntimePreferencesByWorkspacePathSchema.default({})
+	preferences: PersistedRuntimePreferencesSchema.default(defaultRuntimePreferences),
+	runtimePreferencesByWorkspacePath: z.record(z.string().trim().min(1), PersistedRuntimePreferencesSchema).default({})
 });
 function createMemoryRuntimePreferencesStore(initial = defaultRuntimePreferences) {
 	let current = {
@@ -523,6 +524,7 @@ function createMemoryRuntimePreferencesStore(initial = defaultRuntimePreferences
 	};
 }
 function createFileRuntimePreferencesStore(path) {
+	let updateQueue = Promise.resolve();
 	async function readPreferences() {
 		try {
 			return parseRuntimePreferencesFile(JSON.parse(await readFile(path, "utf8")));
@@ -532,17 +534,23 @@ function createFileRuntimePreferencesStore(path) {
 	}
 	return {
 		async read(workspacePath) {
+			await updateQueue;
 			const current = await readPreferences();
 			return workspacePath ? current.runtimePreferencesByWorkspacePath[workspacePath] ?? current.preferences : current.preferences;
 		},
 		async readByWorkspacePath() {
+			await updateQueue;
 			return (await readPreferences()).runtimePreferencesByWorkspacePath;
 		},
-		async update(preferences, workspacePath) {
-			const next = updatePreferencesFile(await readPreferences(), preferences, workspacePath);
-			await mkdir(dirname(path), { recursive: true });
-			await writeFile(path, `${JSON.stringify(next, null, 2)}\n`, { mode: 384 });
-			return workspacePath ? next.runtimePreferencesByWorkspacePath[workspacePath] ?? next.preferences : next.preferences;
+		update(preferences, workspacePath) {
+			const operation = updateQueue.then(async () => {
+				const next = updatePreferencesFile(await readPreferences(), preferences, workspacePath);
+				await mkdir(dirname(path), { recursive: true });
+				await writeFile(path, `${JSON.stringify(next, null, 2)}\n`, { mode: 384 });
+				return workspacePath ? next.runtimePreferencesByWorkspacePath[workspacePath] ?? next.preferences : next.preferences;
+			});
+			updateQueue = operation.then(() => void 0, () => void 0);
+			return operation;
 		}
 	};
 }
@@ -551,7 +559,7 @@ function parseRuntimePreferencesFile(payload) {
 		const record = payload;
 		if ("preferences" in record || "runtimePreferencesByWorkspacePath" in record) return RuntimePreferencesFileSchema.parse(payload);
 	}
-	const legacyPreferences = RuntimePreferencesSchema.safeParse(payload);
+	const legacyPreferences = PersistedRuntimePreferencesSchema.safeParse(payload);
 	if (legacyPreferences.success) return RuntimePreferencesFileSchema.parse({
 		preferences: legacyPreferences.data,
 		runtimePreferencesByWorkspacePath: {}
@@ -724,7 +732,7 @@ async function listAvailableSkills(options) {
 		}
 	];
 	const skillPaths = dedupe((await Promise.all(roots.map((root) => findSkillFiles(root)))).flat(), (entry) => entry.path);
-	return (await Promise.all(skillPaths.map(readSkill))).filter((skill) => Boolean(skill)).sort(compareSkills);
+	return dedupe((await Promise.all(skillPaths.map(readSkill))).filter((skill) => Boolean(skill)).sort(compareSkills), skillIdentityKey);
 }
 async function findSkillFiles(root) {
 	const found = [];
@@ -887,6 +895,9 @@ function compareSkills(a, b) {
 	};
 	return sourceOrder[a.source] - sourceOrder[b.source] || a.displayName.localeCompare(b.displayName, void 0, { sensitivity: "base" });
 }
+function skillIdentityKey(skill) {
+	return [skill.source, skill.name].join("\n");
+}
 function dedupe(items, keyFor) {
 	const seen = /* @__PURE__ */ new Set();
 	return items.filter((item) => {
@@ -2671,7 +2682,9 @@ function queuedThreadInputSummary(input) {
 async function streamRunningAppServerThread(input) {
 	let activeTurnId;
 	let assistantMessageId;
+	let observedInputRequest = false;
 	let observedTurnActivity = false;
+	let producedTurnOutput = false;
 	let threadSummary = input.threads.get(input.threadId);
 	const cleanupRequestHandler = input.appServer.onRequest((request) => {
 		if (!isApprovalServerRequest(request.method)) {
@@ -2683,6 +2696,7 @@ async function streamRunningAppServerThread(input) {
 			input.appServer.rejectRequest(request.id, -32602, "Approval request is malformed.");
 			return;
 		}
+		observedInputRequest = true;
 		if (approval.kind === "structuredUserInput") {
 			const pending = {
 				appServer: input.appServer,
@@ -2771,6 +2785,7 @@ async function streamRunningAppServerThread(input) {
 						if (!item || typeof item !== "object") return;
 						const message = upsertAppServerItemMessage(input.messagesByThreadId, input.threadId, firstString(params, ["turnId"]) ?? activeTurnId, item);
 						if (!message) return;
+						if (message.role !== "user") producedTurnOutput = true;
 						if (message.role === "assistant") assistantMessageId = message.id;
 						threadSummary = updateThread(input.threads, input.messagesByThreadId, input.threadId, {
 							state: "running",
@@ -2795,6 +2810,7 @@ async function streamRunningAppServerThread(input) {
 							turnId: firstString(params, ["turnId"]) ?? activeTurnId
 						});
 						assistantMessageId = itemId;
+						producedTurnOutput = true;
 						const patch = appendMessageDelta(input.messagesByThreadId, input.threadId, itemId, delta);
 						const message = patch.message;
 						updateThread(input.threads, input.messagesByThreadId, input.threadId, {
@@ -2811,6 +2827,7 @@ async function streamRunningAppServerThread(input) {
 					}
 					case "turn/plan/updated": {
 						observedTurnActivity = true;
+						producedTurnOutput = true;
 						const content = planContentFromRecord(params);
 						const message = appendMessage(input.messagesByThreadId, input.threadId, {
 							role: "status",
@@ -2840,6 +2857,20 @@ async function streamRunningAppServerThread(input) {
 							threadId: input.threadId,
 							turnId: firstString(params, ["turnId"]) ?? activeTurnId
 						});
+						if (state === "completed" && !producedTurnOutput && !observedInputRequest) {
+							sendEmptyAppServerTurnError({
+								activeTurnId,
+								controller: input.controller,
+								encoder: input.encoder,
+								messagesByThreadId: input.messagesByThreadId,
+								secureSession: input.secureSession,
+								threadId: input.threadId,
+								threads: input.threads
+							});
+							cleanupNotificationHandler();
+							resolve();
+							return;
+						}
 						if (assistantMessageId) {
 							const completedMessage = updateMessage(input.messagesByThreadId, input.threadId, assistantMessageId, { state: "completed" });
 							sendSse(input.controller, input.encoder, input.secureSession, {
@@ -2856,11 +2887,25 @@ async function streamRunningAppServerThread(input) {
 							type: "thread.state.changed",
 							thread: threadSummary
 						});
-						if (state === "failed") sendSse(input.controller, input.encoder, input.secureSession, {
-							type: "thread.error",
-							thread: threadSummary,
-							error: apiError("codex_run_failed", threadSummary.lastError ?? "Codex turn did not complete.").error
-						});
+						if (state === "failed") {
+							const errorBody = apiError("codex_run_failed", threadSummary.lastError ?? "Codex turn did not complete.");
+							const message = appendMessage(input.messagesByThreadId, input.threadId, {
+								role: "error",
+								content: errorBody.error.message,
+								state: "failed",
+								turnId: activeTurnId
+							});
+							sendSse(input.controller, input.encoder, input.secureSession, {
+								type: "thread.message.created",
+								thread: threadSummary,
+								message
+							});
+							sendSse(input.controller, input.encoder, input.secureSession, {
+								type: "thread.error",
+								thread: threadSummary,
+								error: errorBody.error
+							});
+						}
 						cleanupNotificationHandler();
 						resolve();
 						return;
@@ -2905,6 +2950,7 @@ async function runAppServerPromptStreamed(input) {
 	const displayPrompt = promptMarkdownWithSkills(promptWithAttachmentReferences(input.prompt, input.attachments), input.skills);
 	const prompt = input.prompt;
 	let handedOffToQueuedTurn = false;
+	let observedInputRequest = false;
 	let producedTurnOutput = false;
 	let userMessage = appendMessage(input.messagesByThreadId, activeThreadId, {
 		role: "user",
@@ -2938,6 +2984,7 @@ async function runAppServerPromptStreamed(input) {
 			input.appServer.rejectRequest(request.id, -32602, "Approval request is malformed.");
 			return;
 		}
+		observedInputRequest = true;
 		if (approval.kind === "structuredUserInput") {
 			const pending = {
 				appServer: input.appServer,
@@ -2981,7 +3028,141 @@ async function runAppServerPromptStreamed(input) {
 		});
 	});
 	let cleanupNotificationHandler = () => void 0;
+	let resolveCompleted = () => void 0;
+	let rejectCompleted = (_error) => void 0;
+	const finalizedTurnIds = /* @__PURE__ */ new Set();
+	function resetTurnTracking() {
+		activeTurnId = void 0;
+		assistantMessageId = void 0;
+		observedInputRequest = false;
+		producedTurnOutput = false;
+	}
+	function finishTerminalTurn(options) {
+		const terminalTurnId = options.turnId ?? activeTurnId;
+		if (terminalTurnId && finalizedTurnIds.has(terminalTurnId)) return;
+		if (terminalTurnId) {
+			finalizedTurnIds.add(terminalTurnId);
+			activeTurnId = terminalTurnId;
+		}
+		relayDebugLog("app_server.turn.terminal", {
+			method: options.method,
+			state: options.state,
+			threadId: activeThreadId,
+			turnId: terminalTurnId
+		});
+		input.activeAppServerTurnIdsByThreadId.delete(activeThreadId);
+		const hasQueuedInput = (input.queuedInputsByThreadId.get(activeThreadId)?.length ?? 0) > 0;
+		if (options.state === "completed" && !producedTurnOutput && !observedInputRequest && !hasQueuedInput) {
+			sendEmptyAppServerTurnError({
+				activeTurnId: terminalTurnId,
+				controller: input.controller,
+				encoder: input.encoder,
+				messagesByThreadId: input.messagesByThreadId,
+				secureSession: input.secureSession,
+				threadId: activeThreadId,
+				threads: input.threads
+			});
+			input.steeringThreads.delete(activeThreadId);
+			cleanupNotificationHandler();
+			resolveCompleted();
+			return;
+		}
+		if (assistantMessageId) {
+			const completedMessage = updateMessage(input.messagesByThreadId, activeThreadId, assistantMessageId, { state: "completed" });
+			sendSse(input.controller, input.encoder, input.secureSession, {
+				type: "thread.message.completed",
+				thread: threadSummary,
+				message: completedMessage
+			});
+		}
+		const nextQueuedInput = options.state === "completed" ? shiftQueuedInput(input.queuedInputsByThreadId, activeThreadId) : void 0;
+		threadSummary = updateThread(input.threads, input.messagesByThreadId, activeThreadId, {
+			state: nextQueuedInput ? "running" : options.state,
+			lastError: nextQueuedInput ? void 0 : options.lastError,
+			...nextQueuedInput ? {
+				lastPrompt: promptWithAttachmentReferences(nextQueuedInput.prompt, nextQueuedInput.attachments),
+				...runtimeMetadataFromOptions(nextQueuedInput.runOptions)
+			} : {}
+		});
+		sendSse(input.controller, input.encoder, input.secureSession, {
+			type: "thread.state.changed",
+			thread: threadSummary
+		});
+		if (options.state === "failed") {
+			const errorBody = apiError("codex_run_failed", options.lastError ?? "Codex turn did not complete.");
+			const message = appendMessage(input.messagesByThreadId, activeThreadId, {
+				role: "error",
+				content: errorBody.error.message,
+				state: "failed",
+				turnId: terminalTurnId
+			});
+			sendSse(input.controller, input.encoder, input.secureSession, {
+				type: "thread.message.created",
+				thread: threadSummary,
+				message
+			});
+			sendSse(input.controller, input.encoder, input.secureSession, {
+				type: "thread.error",
+				thread: threadSummary,
+				error: errorBody.error
+			});
+			input.steeringThreads.delete(activeThreadId);
+			cleanupNotificationHandler();
+			resolveCompleted();
+			return;
+		}
+		if (nextQueuedInput) {
+			handedOffToQueuedTurn = true;
+			resetTurnTracking();
+			input.steeringThreads.add(activeThreadId);
+			startAppServerTurn(input.appServer, activeThreadId, nextQueuedInput).then(processReturnedTurn).catch((error) => {
+				cleanupNotificationHandler();
+				rejectCompleted(error);
+			});
+			return;
+		}
+		input.steeringThreads.delete(activeThreadId);
+		cleanupNotificationHandler();
+		resolveCompleted();
+	}
+	function processReturnedTurn(turn) {
+		if (finalizedTurnIds.has(turn.id)) return;
+		activeTurnId = turn.id;
+		input.activeAppServerTurnIdsByThreadId.set(activeThreadId, turn.id);
+		const turnIsRunning = isAppServerTurnRunning(turn);
+		for (const item of turn.items) {
+			const canonicalUserMessage = replaceDuplicateInitialUserMessage(input.messagesByThreadId, activeThreadId, turn.id, item, userMessage.id, displayPrompt);
+			if (canonicalUserMessage) {
+				userMessage = canonicalUserMessage;
+				continue;
+			}
+			const message = upsertAppServerItemMessage(input.messagesByThreadId, activeThreadId, turn.id, item);
+			if (!message) continue;
+			if (message.role !== "user") producedTurnOutput = true;
+			if (message.role === "assistant" && turnIsRunning) assistantMessageId = message.id;
+			threadSummary = updateThread(input.threads, input.messagesByThreadId, activeThreadId, {
+				state: "running",
+				lastResult: message.role === "assistant" ? message.content : void 0
+			});
+			sendSse(input.controller, input.encoder, input.secureSession, {
+				type: message.role === "assistant" ? "thread.message.completed" : "thread.message.created",
+				thread: threadSummary,
+				message
+			});
+		}
+		if (turnIsRunning) return;
+		const params = { turn };
+		const state = terminalTurnState("turn/completed", params);
+		finishTerminalTurn({
+			lastError: state === "failed" ? turnErrorMessage(params) : void 0,
+			method: "turn/returned",
+			state,
+			turnId: turn.id
+		});
+	}
 	const completed = new Promise((resolve, reject) => {
+		resolveCompleted = resolve;
+		rejectCompleted = reject;
 		cleanupNotificationHandler = input.appServer.onNotification((notification) => {
 			const params = recordParams(notification);
 			const threadId = firstString(params, ["threadId"]);
@@ -3026,7 +3207,7 @@ async function runAppServerPromptStreamed(input) {
 						const turnId = firstString(params, ["turnId"]) ?? activeTurnId;
 						const message = upsertAppServerItemMessage(input.messagesByThreadId, activeThreadId, turnId, item);
 						if (!message) return;
-						producedTurnOutput = true;
+						if (message.role !== "user") producedTurnOutput = true;
 						if (message.role === "assistant") assistantMessageId = message.id;
 						threadSummary = updateThread(input.threads, input.messagesByThreadId, activeThreadId, {
 							state: "running",
@@ -3089,69 +3270,13 @@ async function runAppServerPromptStreamed(input) {
 					case "turn/completed":
 					case "turn/failed": {
 						const state = terminalTurnState(notification.method, params);
-						relayDebugLog("app_server.turn.terminal", {
+						const terminalTurnId = firstString(params, ["turnId"]) ?? turnIdFromParams(params) ?? activeTurnId;
+						finishTerminalTurn({
+							lastError: state === "failed" ? turnErrorMessage(params) : void 0,
 							method: notification.method,
 							state,
-							threadId: activeThreadId,
-							turnId: firstString(params, ["turnId"]) ?? activeTurnId
-						});
-						input.activeAppServerTurnIdsByThreadId.delete(activeThreadId);
-						if (assistantMessageId) {
-							const completedMessage = updateMessage(input.messagesByThreadId, activeThreadId, assistantMessageId, { state: "completed" });
-							sendSse(input.controller, input.encoder, input.secureSession, {
-								type: "thread.message.completed",
-								thread: threadSummary,
-								message: completedMessage
-							});
-						}
-						const lastError = state === "failed" ? turnErrorMessage(params) : void 0;
-						const nextQueuedInput = state === "completed" ? shiftQueuedInput(input.queuedInputsByThreadId, activeThreadId) : void 0;
-						threadSummary = updateThread(input.threads, input.messagesByThreadId, activeThreadId, {
-							state: nextQueuedInput ? "running" : state,
-							lastError: nextQueuedInput ? void 0 : lastError,
-							...nextQueuedInput ? {
-								lastPrompt: promptWithAttachmentReferences(nextQueuedInput.prompt, nextQueuedInput.attachments),
-								...runtimeMetadataFromOptions(nextQueuedInput.runOptions)
-							} : {}
+							turnId: terminalTurnId
 						});
-						sendSse(input.controller, input.encoder, input.secureSession, {
-							type: "thread.state.changed",
-							thread: threadSummary
-						});
-						if (state === "failed") {
-							const errorBody = apiError("codex_run_failed", lastError ?? "Codex turn did not complete.");
-							appendMessage(input.messagesByThreadId, activeThreadId, {
-								role: "error",
-								content: errorBody.error.message,
-								state: "failed",
-								turnId: activeTurnId
-							});
-							sendSse(input.controller, input.encoder, input.secureSession, {
-								type: "thread.error",
-								thread: threadSummary,
-								error: errorBody.error
-							});
-							input.steeringThreads.delete(activeThreadId);
-							cleanupNotificationHandler();
-							resolve();
-							return;
-						}
-						if (nextQueuedInput) {
-							handedOffToQueuedTurn = true;
-							assistantMessageId = void 0;
-							input.steeringThreads.add(activeThreadId);
-							startAppServerTurn(input.appServer, activeThreadId, nextQueuedInput).then((turn) => {
-								activeTurnId = turn.id;
-								input.activeAppServerTurnIdsByThreadId.set(activeThreadId, activeTurnId);
-							}).catch((error) => {
-								cleanupNotificationHandler();
-								reject(error);
-							});
-							return;
-						}
-						input.steeringThreads.delete(activeThreadId);
-						cleanupNotificationHandler();
-						resolve();
 						return;
 					}
 				}
@@ -3251,56 +3376,8 @@ async function runAppServerPromptStreamed(input) {
 				workspacePath: input.workspacePath
 			});
 		}
-		activeTurnId = turn.id;
-		input.activeAppServerTurnIdsByThreadId.set(activeThreadId, activeTurnId);
-		debugStream("start turn complete", activeThreadId, activeTurnId);
-		let streamedReturnedItem = false;
-		for (const item of turn.items) {
-			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;
-			producedTurnOutput = true;
-			if (message.role === "assistant") assistantMessageId = message.id;
-			threadSummary = updateThread(input.threads, input.messagesByThreadId, activeThreadId, {
-				state: "running",
-				lastResult: message.role === "assistant" ? message.content : void 0
-			});
-			sendSse(input.controller, input.encoder, input.secureSession, {
-				type: message.role === "assistant" ? "thread.message.completed" : "thread.message.created",
-				thread: threadSummary,
-				message
-			});
-		}
-		const returnedState = mapAppServerThreadState(turn.status);
-		if (returnedState !== "running") {
-			if (!streamedReturnedItem && !producedTurnOutput) {
-				sendEmptyAppServerTurnError({
-					activeTurnId,
-					controller: input.controller,
-					encoder: input.encoder,
-					messagesByThreadId: input.messagesByThreadId,
-					secureSession: input.secureSession,
-					threadId: activeThreadId,
-					threads: input.threads
-				});
-				input.steeringThreads.delete(activeThreadId);
-				cleanupNotificationHandler();
-				return;
-			}
-			threadSummary = updateThread(input.threads, input.messagesByThreadId, activeThreadId, { state: returnedState });
-			sendSse(input.controller, input.encoder, input.secureSession, {
-				type: "thread.state.changed",
-				thread: threadSummary
-			});
-			input.steeringThreads.delete(activeThreadId);
-			cleanupNotificationHandler();
-			return;
-		}
+		debugStream("start turn complete", activeThreadId, turn.id);
+		processReturnedTurn(turn);
 		await completed;
 	} catch (error) {
 		debugStream(`failed ${errorMessage(error)}`, activeThreadId, activeTurnId);
@@ -4154,11 +4231,12 @@ function appServerCollaborationMode(options) {
 }
 function buildThreadOptions(base, options) {
 	const runtime = resolveRuntimeOptions(options.runtimeMode);
+	const reasoningEffort = KnownReasoningEffortSchema.safeParse(options.reasoningEffort);
 	return {
 		...base,
 		...runtime,
 		...options.model ? { model: options.model } : {},
-		...options.reasoningEffort ? { modelReasoningEffort: options.reasoningEffort } : {},
+		...reasoningEffort.success ? { modelReasoningEffort: reasoningEffort.data } : {},
 		...options.approvalPolicy ? { approvalPolicy: options.approvalPolicy } : {},
 		...options.sandboxMode ? { sandboxMode: options.sandboxMode } : {}
 	};
@@ -4878,6 +4956,41 @@ function mapAppServerItem(threadId, turn, item) {
 				}
 			});
 		}
+		case "collabAgentToolCall": {
+			const collabItem = item;
+			return ChatMessageSchema.parse({
+				...base,
+				role: "tool",
+				kind: "subagentAction",
+				content: appServerCollabAgentToolCallContent(collabItem),
+				details: {
+					type: collabItem.type,
+					tool: collabItem.tool,
+					status: collabItem.status,
+					senderThreadId: collabItem.senderThreadId,
+					receiverThreadIds: collabItem.receiverThreadIds,
+					prompt: collabItem.prompt ?? void 0,
+					model: collabItem.model ?? void 0,
+					reasoningEffort: collabItem.reasoningEffort ?? void 0,
+					agentsStates: collabItem.agentsStates
+				}
+			});
+		}
+		case "subAgentActivity": {
+			const activityItem = item;
+			return ChatMessageSchema.parse({
+				...base,
+				role: "status",
+				kind: "subagentAction",
+				content: `${activityItem.agentPath || activityItem.agentThreadId} ${activityItem.kind}`,
+				details: {
+					type: activityItem.type,
+					activityKind: activityItem.kind,
+					agentThreadId: activityItem.agentThreadId,
+					agentPath: activityItem.agentPath
+				}
+			});
+		}
 		case "webSearch": {
 			const searchItem = item;
 			return ChatMessageSchema.parse({
@@ -4894,6 +5007,17 @@ function mapAppServerItem(threadId, turn, item) {
 		default: return mapUnknownAppServerItem(threadId, turn, item);
 	}
 }
+function appServerCollabAgentToolCallContent(item) {
+	const targetCount = item.receiverThreadIds.length;
+	const target = targetCount === 1 ? "subagent" : `${targetCount} subagents`;
+	switch (item.tool) {
+		case "spawnAgent": return targetCount > 0 ? `Spawned ${target}` : "Spawned subagent";
+		case "sendInput": return `Sent input to ${target}`;
+		case "resumeAgent": return `Resumed ${target}`;
+		case "wait": return targetCount > 0 ? `Waited for ${target}` : "Waited for subagents";
+		case "closeAgent": return `Closed ${target}`;
+	}
+}
 function mapUnknownAppServerItem(threadId, turn, item) {
 	const timestamp = fromUnixSeconds(turn.startedAt ?? turn.completedAt ?? Date.now() / 1e3);
 	const type = "type" in item ? String(item.type) : "unknown";
@@ -4923,6 +5047,14 @@ function appServerTurnShell(turnId) {
 	};
 }
 function mapAppServerModel(model) {
+	const reasoningEffortOptions = model.supportedReasoningEfforts?.flatMap((effort) => {
+		const parsed = ReasoningEffortSchema.safeParse(effort.reasoningEffort);
+		return parsed.success ? [{
+			reasoningEffort: parsed.data,
+			description: effort.description
+		}] : [];
+	}) ?? [];
+	const defaultReasoningEffort = ReasoningEffortSchema.safeParse(model.defaultReasoningEffort);
 	const serviceTiers = model.serviceTiers ?? model.additionalSpeedTiers?.map((tier) => ({
 		id: tier,
 		name: tier === "fast" ? "Fast" : tier,
@@ -4934,8 +5066,9 @@ function mapAppServerModel(model) {
 		displayName: model.displayName,
 		description: model.description,
 		isDefault: Boolean(model.isDefault),
-		defaultReasoningEffort: model.defaultReasoningEffort,
-		supportedReasoningEfforts: model.supportedReasoningEfforts?.map((effort) => effort.reasoningEffort) ?? [],
+		defaultReasoningEffort: defaultReasoningEffort.success ? defaultReasoningEffort.data : void 0,
+		supportedReasoningEfforts: reasoningEffortOptions.map((effort) => effort.reasoningEffort),
+		reasoningEffortOptions,
 		serviceTiers
 	};
 }
@@ -5396,7 +5529,11 @@ function kindFromProtocolType(type) {
 		case "approval_request":
 		case "approvalRequest": return "approvalRequest";
 		case "subagent_action":
-		case "subagentAction": return "subagentAction";
+		case "subagentAction":
+		case "collab_agent_tool_call":
+		case "collabAgentToolCall":
+		case "sub_agent_activity":
+		case "subAgentActivity": return "subagentAction";
 		default: return;
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-relay",
-  "version": "1.2.4",
+  "version": "1.3.1",
   "description": "Local Codex Relay CLI bridge for the Codex Relay mobile app.",
   "license": "Apache-2.0",
   "repository": {
@@ -35,19 +35,21 @@
   "dependencies": {
     "@commander-js/extra-typings": "^14.0.0",
     "@hono/node-server": "^1.19.6",
+    "@libsql/client": "0.17.4",
     "@lydell/node-pty": "1.2.0-beta.12",
     "@modelcontextprotocol/sdk": "^1.24.0",
     "@noble/ciphers": "2.2.0",
     "@noble/curves": "2.2.0",
     "@noble/hashes": "2.2.0",
-    "@openai/codex-sdk": "0.141.0",
-    "@tursodatabase/database": "^0.5.3",
+    "@openai/codex-sdk": "0.144.1",
     "base64-js": "1.5.1",
     "commander": "^14.0.3",
     "es-git": "^0.6.0",
     "hono": "^4.10.7",
+    "libsql": "0.5.29",
     "picocolors": "^1.1.1",
     "qrcode-terminal": "^0.12.0",
+    "ws": "8.21.0",
     "zod": "^4.1.12"
   },
   "devDependencies": {

package/src/api-schema.ts

@@ -30,7 +30,16 @@ export const ChatMessageKindSchema = z.enum([
 export const ApprovalModeSchema = z.enum(["on-request", "on-failure", "never"]);
 export const RuntimeModeSchema = z.enum(["default", "auto", "full-access", "on-request"]);
 export const SandboxModeSchema = z.enum(["workspace-write", "danger-full-access", "read-only"]);
-export const ReasoningEffortSchema = z.enum(["minimal", "low", "medium", "high", "xhigh"]);
+export const KnownReasoningEffortSchema = z.enum([
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+  "ultra",
+]);
+export const ReasoningEffortSchema = z.string().trim().min(1);
 export const ThreadCollaborationModeSchema = z.enum(["default", "plan"]);
 export const ThreadGoalStatusSchema = z.enum([
   "active",
@@ -94,6 +103,14 @@ export const CodexModelSchema = z.object({
   isDefault: z.boolean().default(false),
   defaultReasoningEffort: ReasoningEffortSchema.optional(),
   supportedReasoningEfforts: z.array(ReasoningEffortSchema).default([]),
+  reasoningEffortOptions: z
+    .array(
+      z.object({
+        reasoningEffort: ReasoningEffortSchema,
+        description: z.string().optional(),
+      }),
+    )
+    .default([]),
   serviceTiers: z
     .array(
       z.object({
@@ -718,6 +735,7 @@ export type ChatMessageRole = z.infer<typeof ChatMessageRoleSchema>;
 export type ChatMessageState = z.infer<typeof ChatMessageStateSchema>;
 export type ChatMessageKind = z.infer<typeof ChatMessageKindSchema>;
 export type ApprovalMode = z.infer<typeof ApprovalModeSchema>;
+export type KnownReasoningEffort = z.infer<typeof KnownReasoningEffortSchema>;
 export type ReasoningEffort = z.infer<typeof ReasoningEffortSchema>;
 export type RuntimeMode = z.infer<typeof RuntimeModeSchema>;
 export type SandboxMode = z.infer<typeof SandboxModeSchema>;
@@ -1301,6 +1319,7 @@ export function createOpenApiDocument() {
     components: {
       schemas: {
         ThreadState: { type: "string", enum: ThreadStateSchema.options },
+        ReasoningEffort: { type: "string", minLength: 1 },
         ChatMessage: {
           type: "object",
           required: ["id", "threadId", "role", "content", "createdAt"],
@@ -1437,7 +1456,7 @@ export function createOpenApiDocument() {
             },
             reasoningEffort: {
               type: "string",
-              enum: ["minimal", "low", "medium", "high", "xhigh"],
+              minLength: 1,
             },
           },
         },
@@ -1454,7 +1473,7 @@ export function createOpenApiDocument() {
             },
             reasoningEffort: {
               type: "string",
-              enum: ["minimal", "low", "medium", "high", "xhigh"],
+              minLength: 1,
               nullable: true,
             },
           },