lael-labs/t3code

apps/server/src/codexAppServerManager.test.ts+0−6

     expect(result).toEqual({
       threadId: "thread_1",
       turnId: "turn_1",
-      resumeCursor: {
-        threadId: "thread_1",
-      },
     });
     expect(requireSession).toHaveBeenCalledWith("sess_1");
     expect(sendRequest).toHaveBeenCalledWith(context, "turn/start", {
     expect(updateSession).toHaveBeenCalledWith(context, {
       status: "running",
       activeTurnId: "turn_1",
-      resumeCursor: {
-        threadId: "thread_1",
-      },
     });
   });

apps/server/src/codexAppServerManager.ts+32−13

         updatedAt: now,
       };
-      const codexBinaryPath = input.codexBinaryPath ?? "codex";
+      const codexOptions = readCodexProviderOptions(input);
-      const codexHomePath = input.codexHomePath;
+      const codexBinaryPath = codexOptions.binaryPath ?? "codex";
+      const codexHomePath = codexOptions.homePath;
       const child = spawn(codexBinaryPath, ["app-server"], {
         cwd: resolvedCwd,
         env: {
     this.updateSession(context, {
       status: "running",
       activeTurnId: turnId,
-      resumeCursor: context.session.resumeCursor ?? { threadId: context.session.threadId },
+      ...(context.session.resumeCursor !== undefined
+        ? { resumeCursor: context.session.resumeCursor }
+        : {}),
     });
     return {
       threadId: context.session.threadId,
       turnId,
-      resumeCursor: context.session.resumeCursor ?? { threadId: context.session.threadId },
+      ...(context.session.resumeCursor !== undefined
+        ? { resumeCursor: context.session.resumeCursor }
+        : {}),
     };
   }
   return brandIfNonEmpty(value, ProviderThreadId.makeUnsafe);
 }
+function readCodexProviderOptions(input: ProviderSessionStartInput): {
+  readonly binaryPath?: string;
+  readonly homePath?: string;
+} {
+  const options = input.providerOptions?.codex;
+  if (!options) {
+    return {};
+  }
+  return {
+    ...(options.binaryPath ? { binaryPath: options.binaryPath } : {}),
+    ...(options.homePath ? { homePath: options.homePath } : {}),
+  };
+}
+function readResumeCursorThreadId(resumeCursor: unknown): ProviderThreadId | undefined {
+  if (!resumeCursor || typeof resumeCursor !== "object" || Array.isArray(resumeCursor)) {
+    return undefined;
+  }
+  const rawThreadId = (resumeCursor as Record<string, unknown>).threadId;
+  return typeof rawThreadId === "string" ? toProviderThreadId(rawThreadId) : undefined;
+}
 function readResumeThreadId(input: ProviderSessionStartInput): ProviderThreadId | undefined {
-  if (
+  return readResumeCursorThreadId(input.resumeCursor);
-    !input.resumeCursor ||
-    typeof input.resumeCursor !== "object" ||
-    Array.isArray(input.resumeCursor)
-  ) {
-    return input.resumeThreadId;
-  }
-  const rawThreadId = (input.resumeCursor as Record<string, unknown>).threadId;
-  return typeof rawThreadId === "string" ? toProviderThreadId(rawThreadId) : input.resumeThreadId;
 }
 function toProviderTurnId(value: string | undefined): ProviderTurnId | undefined {

apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts+29−7

-import type { ProviderRuntimeEvent } from "@t3tools/contracts";
+import type { ProviderRuntimeEvent, ProviderSession } from "@t3tools/contracts";
 import {
   ApprovalRequestId,
   CommandId,
     const now = new Date().toISOString();
     const runtimeEventPubSub = Effect.runSync(PubSub.unbounded<ProviderRuntimeEvent>());
     let nextSessionIndex = 1;
-    const startSession = vi.fn((_: unknown, __: unknown) => {
+    const runtimeSessions: Array<ProviderSession> = [];
+    const startSession = vi.fn((_: unknown, input: unknown) => {
       const sessionIndex = nextSessionIndex++;
-      return Effect.succeed({
+      const resumeCursor =
+        typeof input === "object" && input !== null && "resumeCursor" in input
+          ? input.resumeCursor
+          : undefined;
+      const session: ProviderSession = {
         sessionId: asSessionId(`sess-${sessionIndex}`),
         provider: "codex" as const,
         status: "ready" as const,
         threadId: ProviderThreadId.makeUnsafe(`provider-thread-${sessionIndex}`),
+        resumeCursor: resumeCursor ?? { opaque: `cursor-${sessionIndex}` },
         createdAt: now,
         updatedAt: now,
-      });
+      };
+      runtimeSessions.push(session);
+      return Effect.succeed(session);
     });
     const sendTurn = vi.fn((_: unknown) =>
       Effect.succeed({
     );
     const interruptTurn = vi.fn((_: unknown) => Effect.void);
     const respondToRequest = vi.fn((_: unknown) => Effect.void);
-    const stopSession = vi.fn((_: unknown) => Effect.void);
+    const stopSession = vi.fn((input: unknown) =>
+      Effect.sync(() => {
+        const sessionId =
+          typeof input === "object" && input !== null && "sessionId" in input
+            ? (input as { sessionId?: ProviderSessionId }).sessionId
+            : undefined;
+        if (!sessionId) {
+          return;
+        }
+        const index = runtimeSessions.findIndex((session) => session.sessionId === sessionId);
+        if (index >= 0) {
+          runtimeSessions.splice(index, 1);
+        }
+      }),
+    );
     const unsupported = () => Effect.die(new Error("Unsupported provider call in test")) as never;
     const service: ProviderServiceShape = {
       interruptTurn: interruptTurn as ProviderServiceShape["interruptTurn"],
       respondToRequest: respondToRequest as ProviderServiceShape["respondToRequest"],
       stopSession: stopSession as ProviderServiceShape["stopSession"],
-      listSessions: () => Effect.succeed([]),
+      listSessions: () => Effect.succeed(runtimeSessions),
       rollbackConversation: () => unsupported(),
       stopAll: () => Effect.void,
       streamEvents: Stream.fromPubSub(runtimeEventPubSub),
     expect(harness.stopSession.mock.calls[0]?.[0]).toEqual({ sessionId: asSessionId("sess-1") });
     expect(harness.startSession.mock.calls[1]?.[1]).toMatchObject({
-      resumeThreadId: ProviderThreadId.makeUnsafe("provider-thread-1"),
+      resumeCursor: { opaque: "cursor-1" },
       approvalPolicy: "on-request",
       sandboxMode: "workspace-write",
     });

apps/server/src/orchestration/Layers/ProviderCommandReactor.ts+10−4

   type ProviderApprovalPolicy,
   type ProviderKind,
   type ProviderSandboxMode,
+  type ProviderSessionId,
   type OrchestrationSession,
   type ThreadId,
   type ProviderSession,
-  type ProviderThreadId,
   type TurnId,
 } from "@t3tools/contracts";
 import { Cache, Cause, Duration, Effect, Layer, Option, Queue, Stream } from "effect";
       projects: readModel.projects,
     });
-    const startProviderSession = (resumeThreadId?: ProviderThreadId | null) =>
+    const resolveResumeCursorForSession = (sessionId: ProviderSessionId) =>
+      providerService.listSessions().pipe(
+        Effect.map((sessions) => sessions.find((session) => session.sessionId === sessionId)?.resumeCursor),
+      );
+    const startProviderSession = (resumeCursor?: unknown) =>
       providerService.startSession(threadId, {
         ...(preferredProvider ? { provider: preferredProvider } : {}),
         ...(effectiveCwd ? { cwd: effectiveCwd } : {}),
         ...(thread.model ? { model: thread.model } : {}),
-        ...(resumeThreadId ? { resumeThreadId } : {}),
+        ...(resumeCursor !== undefined ? { resumeCursor } : {}),
         approvalPolicy: desiredApprovalPolicy,
         sandboxMode: desiredSandboxMode,
       });
         return existingSessionId;
       }
-      const restartedSession = yield* startProviderSession(thread.session?.providerThreadId ?? null);
+      const resumeCursor = yield* resolveResumeCursorForSession(existingSessionId);
+      const restartedSession = yield* startProviderSession(resumeCursor);
       yield* bindSessionToThread(restartedSession);
       yield* providerService.stopSession({ sessionId: existingSessionId }).pipe(
         Effect.catchCause((cause) =>

apps/server/src/orchestration/decider.projectScripts.test.ts+2−0

             text: "hello",
             attachments: [],
           },
+          provider: "claudeCode",
           model: "gpt-5",
           effort: "high",
           approvalPolicy: "on-request",
     expect(turnStartEvent.payload).toMatchObject({
       threadId: ThreadId.makeUnsafe("thread-1"),
       messageId: asMessageId("message-user-1"),
+      provider: "claudeCode",
       model: "gpt-5",
       effort: "high",
       approvalPolicy: "on-request",

apps/server/src/orchestration/decider.ts+1−0

@@ -251,6 +251,7 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand" · 250 unmodified lines
251	payload: {	251	payload: {
252	threadId: command.threadId,	252	threadId: command.threadId,
253	messageId: command.message.messageId,	253	messageId: command.message.messageId,
		254	...(command.provider !== undefined ? { provider: command.provider } : {}),
254	...(command.model !== undefined ? { model: command.model } : {}),	255	...(command.model !== undefined ? { model: command.model } : {}),
255	...(command.effort !== undefined ? { effort: command.effort } : {}),	256	...(command.effort !== undefined ? { effort: command.effort } : {}),
256	assistantDeliveryMode: command.assistantDeliveryMode ?? DEFAULT_ASSISTANT_DELIVERY_MODE,	257	assistantDeliveryMode: command.assistantDeliveryMode ?? DEFAULT_ASSISTANT_DELIVERY_MODE,

apps/server/src/provider/Layers/ProviderService.test.ts+7−3

     Effect.sync(() => {
       const now = new Date().toISOString();
       const next = nextSession;
+      const threadId = ProviderThreadId.makeUnsafe(`thread-${next}`);
       const session: ProviderSession = {
         sessionId: ProviderSessionId.makeUnsafe(`sess-${next}`),
         provider: "codex",
         status: "ready",
-        threadId: input.resumeThreadId ?? ProviderThreadId.makeUnsafe(`thread-${next}`),
+        threadId,
+        resumeCursor: input.resumeCursor ?? { opaque: `cursor-${next}` },
         cwd: input.cwd ?? process.cwd(),
         createdAt: now,
         updatedAt: now,
       assert.equal(Option.isSome(persistedAfterStopAll), true);
       if (Option.isSome(persistedAfterStopAll)) {
         assert.equal(persistedAfterStopAll.value.status, "stopped");
-        assert.equal(persistedAfterStopAll.value.resumeCursor, null);
+        assert.deepEqual(persistedAfterStopAll.value.resumeCursor, startedSession.resumeCursor);
       }
       const secondCodex = makeFakeCodexAdapter();
             provider: "codex",
             cwd: "/tmp/project",
             resumeThreadId: startedSession.threadId,
+            resumeCursor: startedSession.resumeCursor,
           },
         ],
       ]);
             provider: "codex",
             cwd: "/tmp/project",
             resumeThreadId: initial.threadId,
+            resumeCursor: initial.resumeCursor,
           },
         ],
       ]);
       assert.equal(Option.isSome(runningRuntime), true);
       if (Option.isSome(runningRuntime)) {
         assert.equal(runningRuntime.value.status, "running");
-        assert.equal(runningRuntime.value.resumeCursor, null);
+        assert.deepEqual(runningRuntime.value.resumeCursor, session.resumeCursor);
         const payload = runningRuntime.value.runtimePayload;
         assert.equal(payload !== null && typeof payload === "object", true);
         if (payload !== null && typeof payload === "object" && !Array.isArray(payload)) {

apps/server/src/provider/Layers/ProviderService.ts+1−1

@@ -271,7 +271,7 @@ const makeProviderService = (options?: ProviderServiceLiveOptions) => · 270 unmodified lines
271	} as const;	271	} as const;
272	}	272	}
273		273
274	if (!resumeThreadId && !hasResumeCursor) {	274	if (!hasResumeCursor) {
275	return yield* toValidationError(	275	return yield* toValidationError(
276	input.operation,	276	input.operation,
277	`Cannot recover stale session '${input.staleSessionId}' because no provider resume state is persisted.`,	277	`Cannot recover stale session '${input.staleSessionId}' because no provider resume state is persisted.`,

apps/server/src/provider/Layers/ProviderSessionDirectory.test.ts+2−2

@@ -119,7 +119,7 @@ it.layer(makeDirectoryLayer(SqlitePersistenceMemory))("ProviderSessionDirectoryL · 118 unmodified lines
119	providerThreadId,	119	providerThreadId,
120	status: "starting",	120	status: "starting",
121	resumeCursor: {	121	resumeCursor: {
122	resumeThreadId: "provider-thread-runtime",	122	threadId: "provider-thread-runtime",
123	},	123	},
124	runtimePayload: {	124	runtimePayload: {
125	cwd: "/tmp/project",	125	cwd: "/tmp/project",
@@ -145,7 +145,7 @@ it.layer(makeDirectoryLayer(SqlitePersistenceMemory))("ProviderSessionDirectoryL · 19 unmodified lines
145	assert.equal(runtime.value.providerThreadId, providerThreadId);	145	assert.equal(runtime.value.providerThreadId, providerThreadId);
146	assert.equal(runtime.value.status, "running");	146	assert.equal(runtime.value.status, "running");
147	assert.deepEqual(runtime.value.resumeCursor, {	147	assert.deepEqual(runtime.value.resumeCursor, {
148	resumeThreadId: providerThreadId,	148	threadId: providerThreadId,
149	});	149	});
150	assert.deepEqual(runtime.value.runtimePayload, {	150	assert.deepEqual(runtime.value.runtimePayload, {
151	cwd: "/tmp/project",	151	cwd: "/tmp/project",

packages/contracts/src/orchestration.test.ts+83−0

@@ -2,14 +2,24 @@ import { assert, it } from "@effect/vitest"; · 1 unmodified line
2	import { Effect, Schema } from "effect";	2	import { Effect, Schema } from "effect";
3		3
4	import {	4	import {
		5	DEFAULT_PROVIDER_APPROVAL_POLICY,
		6	DEFAULT_PROVIDER_SANDBOX_MODE,
5	OrchestrationGetTurnDiffInput,	7	OrchestrationGetTurnDiffInput,
		8	OrchestrationSession,
6	ProjectCreateCommand,	9	ProjectCreateCommand,
		10	ThreadTurnStartCommand,
7	ThreadTurnDiff,	11	ThreadTurnDiff,
		12	ThreadTurnStartRequestedPayload,
8	} from "./orchestration";	13	} from "./orchestration";
9		14
10	const decodeTurnDiffInput = Schema.decodeUnknownEffect(OrchestrationGetTurnDiffInput);	15	const decodeTurnDiffInput = Schema.decodeUnknownEffect(OrchestrationGetTurnDiffInput);
11	const decodeThreadTurnDiff = Schema.decodeUnknownEffect(ThreadTurnDiff);	16	const decodeThreadTurnDiff = Schema.decodeUnknownEffect(ThreadTurnDiff);
12	const decodeProjectCreateCommand = Schema.decodeUnknownEffect(ProjectCreateCommand);	17	const decodeProjectCreateCommand = Schema.decodeUnknownEffect(ProjectCreateCommand);
		18	const decodeThreadTurnStartCommand = Schema.decodeUnknownEffect(ThreadTurnStartCommand);
		19	const decodeThreadTurnStartRequestedPayload = Schema.decodeUnknownEffect(
		20	ThreadTurnStartRequestedPayload,
		21	);
		22	const decodeOrchestrationSession = Schema.decodeUnknownEffect(OrchestrationSession);
13		23
14	it.effect("parses turn diff input when fromTurnCount <= toTurnCount", () =>	24	it.effect("parses turn diff input when fromTurnCount <= toTurnCount", () =>
15	Effect.gen(function* () {	25	Effect.gen(function* () {
@@ -84,3 +94,76 @@ it.effect("rejects command fields that become empty after trim", () => · 68 unmodified lines
84	assert.strictEqual(result._tag, "Failure");	94	assert.strictEqual(result._tag, "Failure");
85	}),	95	}),
86	);	96	);
		97
		98	it.effect("decodes thread.turn.start defaults for provider and runtime mode", () =>
		99	Effect.gen(function* () {
		100	const parsed = yield* decodeThreadTurnStartCommand({
		101	type: "thread.turn.start",
		102	commandId: "cmd-turn-1",
		103	threadId: "thread-1",
		104	message: {
		105	messageId: "msg-1",
		106	role: "user",
		107	text: "hello",
		108	attachments: [],
		109	},
		110	createdAt: "2026-01-01T00:00:00.000Z",
		111	});
		112	assert.strictEqual(parsed.provider, undefined);
		113	assert.strictEqual(parsed.approvalPolicy, DEFAULT_PROVIDER_APPROVAL_POLICY);
		114	assert.strictEqual(parsed.sandboxMode, DEFAULT_PROVIDER_SANDBOX_MODE);
		115	}),
		116	);
		117
		118	it.effect("preserves explicit provider and runtime mode in thread.turn.start", () =>
		119	Effect.gen(function* () {
		120	const parsed = yield* decodeThreadTurnStartCommand({
		121	type: "thread.turn.start",
		122	commandId: "cmd-turn-2",
		123	threadId: "thread-1",
		124	message: {
		125	messageId: "msg-2",
		126	role: "user",
		127	text: "hello",
		128	attachments: [],
		129	},
		130	provider: "claudeCode",
		131	approvalPolicy: "never",
		132	sandboxMode: "danger-full-access",
		133	createdAt: "2026-01-01T00:00:00.000Z",
		134	});
		135	assert.strictEqual(parsed.provider, "claudeCode");
		136	assert.strictEqual(parsed.approvalPolicy, "never");
		137	assert.strictEqual(parsed.sandboxMode, "danger-full-access");
		138	}),
		139	);
		140
		141	it.effect("decodes thread.turn-start-requested defaults for provider and runtime mode", () =>
		142	Effect.gen(function* () {
		143	const parsed = yield* decodeThreadTurnStartRequestedPayload({
		144	threadId: "thread-1",
		145	messageId: "msg-1",
		146	createdAt: "2026-01-01T00:00:00.000Z",
		147	});
		148	assert.strictEqual(parsed.provider, undefined);
		149	assert.strictEqual(parsed.approvalPolicy, DEFAULT_PROVIDER_APPROVAL_POLICY);
		150	assert.strictEqual(parsed.sandboxMode, DEFAULT_PROVIDER_SANDBOX_MODE);
		151	}),
		152	);
		153
		154	it.effect("decodes orchestration session runtime mode defaults", () =>
		155	Effect.gen(function* () {
		156	const parsed = yield* decodeOrchestrationSession({
		157	threadId: "thread-1",
		158	status: "idle",
		159	providerName: null,
		160	providerSessionId: null,
		161	providerThreadId: null,
		162	activeTurnId: null,
		163	lastError: null,
		164	updatedAt: "2026-01-01T00:00:00.000Z",
		165	});
		166	assert.strictEqual(parsed.approvalPolicy, DEFAULT_PROVIDER_APPROVAL_POLICY);
		167	assert.strictEqual(parsed.sandboxMode, DEFAULT_PROVIDER_SANDBOX_MODE);
		168	}),
		169	);

packages/contracts/src/orchestration.ts+23−6

 export const ProviderKind = Schema.Literals(["codex", "claudeCode"]);
 export type ProviderKind = typeof ProviderKind.Type;
+export const DEFAULT_PROVIDER_KIND: ProviderKind = "codex";
 export const ProviderApprovalPolicy = Schema.Literals([
   "untrusted",
   "on-failure",
   "never",
 ]);
 export type ProviderApprovalPolicy = typeof ProviderApprovalPolicy.Type;
+export const DEFAULT_PROVIDER_APPROVAL_POLICY: ProviderApprovalPolicy = "on-failure";
 export const ProviderSandboxMode = Schema.Literals([
   "read-only",
   "workspace-write",
   "danger-full-access",
 ]);
 export type ProviderSandboxMode = typeof ProviderSandboxMode.Type;
+export const DEFAULT_PROVIDER_SANDBOX_MODE: ProviderSandboxMode = "workspace-write";
 export const ProviderRequestKind = Schema.Literals(["command", "file-change"]);
 export type ProviderRequestKind = typeof ProviderRequestKind.Type;
 export const AssistantDeliveryMode = Schema.Literals(["buffered", "streaming"]);
   providerName: Schema.NullOr(TrimmedNonEmptyString),
   providerSessionId: Schema.NullOr(ProviderSessionId),
   providerThreadId: Schema.NullOr(ProviderThreadId),
-  approvalPolicy: ProviderApprovalPolicy.pipe(Schema.withDecodingDefault(() => "on-failure")),
+  approvalPolicy: ProviderApprovalPolicy.pipe(
-  sandboxMode: ProviderSandboxMode.pipe(Schema.withDecodingDefault(() => "workspace-write")),
+    Schema.withDecodingDefault(() => DEFAULT_PROVIDER_APPROVAL_POLICY),
+  ),
+  sandboxMode: ProviderSandboxMode.pipe(
+    Schema.withDecodingDefault(() => DEFAULT_PROVIDER_SANDBOX_MODE),
+  ),
   activeTurnId: Schema.NullOr(TurnId),
   lastError: Schema.NullOr(TrimmedNonEmptyString),
   updatedAt: IsoDateTime,
     text: Schema.String,
     attachments: Schema.Array(ChatAttachment),
   }),
+  provider: Schema.optional(ProviderKind),
   model: Schema.optional(TrimmedNonEmptyString),
   effort: Schema.optional(TrimmedNonEmptyString),
   assistantDeliveryMode: Schema.optional(AssistantDeliveryMode),
-  approvalPolicy: ProviderApprovalPolicy,
+  approvalPolicy: ProviderApprovalPolicy.pipe(
-  sandboxMode: ProviderSandboxMode,
+    Schema.withDecodingDefault(() => DEFAULT_PROVIDER_APPROVAL_POLICY),
+  ),
+  sandboxMode: ProviderSandboxMode.pipe(
+    Schema.withDecodingDefault(() => DEFAULT_PROVIDER_SANDBOX_MODE),
+  ),
   createdAt: IsoDateTime,
 });
 export const ThreadTurnStartRequestedPayload = Schema.Struct({
   threadId: ThreadId,
   messageId: MessageId,
+  provider: Schema.optional(ProviderKind),
   model: Schema.optional(TrimmedNonEmptyString),
   effort: Schema.optional(TrimmedNonEmptyString),
   assistantDeliveryMode: Schema.optional(AssistantDeliveryMode),
-  approvalPolicy: ProviderApprovalPolicy.pipe(Schema.withDecodingDefault(() => "on-failure")),
+  approvalPolicy: ProviderApprovalPolicy.pipe(
-  sandboxMode: ProviderSandboxMode.pipe(Schema.withDecodingDefault(() => "workspace-write")),
+    Schema.withDecodingDefault(() => DEFAULT_PROVIDER_APPROVAL_POLICY),
+  ),
+  sandboxMode: ProviderSandboxMode.pipe(
+    Schema.withDecodingDefault(() => DEFAULT_PROVIDER_SANDBOX_MODE),
+  ),
   createdAt: IsoDateTime,
 });

packages/contracts/src/provider.test.ts+49−0

@@ -0,0 +1,49 @@
	1	import { describe, expect, it } from "vitest";
	2	import { Schema } from "effect";
	3
	4	import { ProviderSessionStartInput } from "./provider";
	5
	6	const decodeProviderSessionStartInput = Schema.decodeUnknownSync(ProviderSessionStartInput);
	7
	8	describe("ProviderSessionStartInput", () => {
	9	it("accepts codex-compatible payloads", () => {
	10	const parsed = decodeProviderSessionStartInput({
	11	provider: "codex",
	12	cwd: "/tmp/workspace",
	13	model: "gpt-5.3-codex",
	14	providerOptions: {
	15	codex: {
	16	binaryPath: "/usr/local/bin/codex",
	17	homePath: "/tmp/.codex",
	18	},
	19	},
	20	});
	21	expect(parsed.approvalPolicy).toBeUndefined();
	22	expect(parsed.sandboxMode).toBeUndefined();
	23	expect(parsed.providerOptions?.codex?.binaryPath).toBe("/usr/local/bin/codex");
	24	expect(parsed.providerOptions?.codex?.homePath).toBe("/tmp/.codex");
	25	});
	26
	27	it("accepts claude runtime knobs", () => {
	28	const parsed = decodeProviderSessionStartInput({
	29	provider: "claudeCode",
	30	cwd: "/tmp/workspace",
	31	model: "claude-sonnet-4-5",
	32	providerOptions: {
	33	claudeCode: {
	34	binaryPath: "/usr/local/bin/claude",
	35	permissionMode: "plan",
	36	maxThinkingTokens: 12_000,
	37	},
	38	},
	39	approvalPolicy: "never",
	40	sandboxMode: "danger-full-access",
	41	});
	42	expect(parsed.provider).toBe("claudeCode");
	43	expect(parsed.providerOptions?.claudeCode?.binaryPath).toBe("/usr/local/bin/claude");
	44	expect(parsed.providerOptions?.claudeCode?.permissionMode).toBe("plan");
	45	expect(parsed.providerOptions?.claudeCode?.maxThinkingTokens).toBe(12_000);
	46	expect(parsed.approvalPolicy).toBe("never");
	47	expect(parsed.sandboxMode).toBe("danger-full-access");
	48	});
	49	});

packages/contracts/src/provider.ts+20−3

@@ -49,14 +49,31 @@ export const ProviderSession = Schema.Struct({ · 48 unmodified lines
49	});	49	});
50	export type ProviderSession = typeof ProviderSession.Type;	50	export type ProviderSession = typeof ProviderSession.Type;
51		51
		52	export const CodexProviderStartOptions = Schema.Struct({
		53	binaryPath: Schema.optional(TrimmedNonEmptyStringSchema),
		54	homePath: Schema.optional(TrimmedNonEmptyStringSchema),
		55	});
		56	export type CodexProviderStartOptions = typeof CodexProviderStartOptions.Type;
		57
		58	export const ClaudeCodeProviderStartOptions = Schema.Struct({
		59	binaryPath: Schema.optional(TrimmedNonEmptyStringSchema),
		60	permissionMode: Schema.optional(TrimmedNonEmptyStringSchema),
		61	maxThinkingTokens: Schema.optional(NonNegativeInt),
		62	});
		63	export type ClaudeCodeProviderStartOptions = typeof ClaudeCodeProviderStartOptions.Type;
		64
		65	export const ProviderStartOptions = Schema.Struct({
		66	codex: Schema.optional(CodexProviderStartOptions),
		67	claudeCode: Schema.optional(ClaudeCodeProviderStartOptions),
		68	});
		69	export type ProviderStartOptions = typeof ProviderStartOptions.Type;
		70
52	export const ProviderSessionStartInput = Schema.Struct({	71	export const ProviderSessionStartInput = Schema.Struct({
53	provider: Schema.optional(ProviderKind),	72	provider: Schema.optional(ProviderKind),
54	cwd: Schema.optional(TrimmedNonEmptyStringSchema),	73	cwd: Schema.optional(TrimmedNonEmptyStringSchema),
55	model: Schema.optional(TrimmedNonEmptyStringSchema),	74	model: Schema.optional(TrimmedNonEmptyStringSchema),
56	resumeThreadId: Schema.optional(ProviderThreadId),
57	resumeCursor: Schema.optional(Schema.Unknown),	75	resumeCursor: Schema.optional(Schema.Unknown),
58	codexBinaryPath: Schema.optional(TrimmedNonEmptyStringSchema),	76	providerOptions: Schema.optional(ProviderStartOptions),
59	codexHomePath: Schema.optional(TrimmedNonEmptyStringSchema),
60	approvalPolicy: Schema.optional(ProviderApprovalPolicy),	77	approvalPolicy: Schema.optional(ProviderApprovalPolicy),
61	sandboxMode: Schema.optional(ProviderSandboxMode),	78	sandboxMode: Schema.optional(ProviderSandboxMode),
62	});	79	});