Persist provider runtime mode settings

Store approval policy and sandbox mode in provider session runtime records, carry them through session recovery, and cover the behavior with provider layer tests.

Julius Marminge committed 8 months ago

Commit de5270e1 parent d48b42c9 files · +111 −2Browse files

Unified · Split

9 files

apps/server/src/persistence/Layers/ProviderSessionRuntime.ts +10 −0
apps/server/src/persistence/Migrations.ts +2 −0
apps/server/src/persistence/Migrations/008_ProviderSessionRuntimeModeColumns.ts +31 −0
apps/server/src/persistence/Services/ProviderSessionRuntime.ts +4 −0
apps/server/src/provider/Layers/ProviderService.test.ts +12 −0
apps/server/src/provider/Layers/ProviderService.ts +26 −1
apps/server/src/provider/Layers/ProviderSessionDirectory.test.ts +6 −0
apps/server/src/provider/Layers/ProviderSessionDirectory.ts +16 −1
apps/server/src/provider/Services/ProviderSessionDirectory.ts +4 −0

apps/server/src/persistence/Layers/ProviderSessionRuntime.ts+10−0

           adapter_key,
           provider_thread_id,
           status,
+          approval_policy,
+          sandbox_mode,
           last_seen_at,
           resume_cursor_json,
           runtime_payload_json
           ${runtime.adapterKey},
           ${runtime.providerThreadId},
           ${runtime.status},
+          ${runtime.approvalPolicy},
+          ${runtime.sandboxMode},
           ${runtime.lastSeenAt},
           ${runtime.resumeCursor},
           ${runtime.runtimePayload}
           adapter_key = excluded.adapter_key,
           provider_thread_id = excluded.provider_thread_id,
           status = excluded.status,
+          approval_policy = excluded.approval_policy,
+          sandbox_mode = excluded.sandbox_mode,
           last_seen_at = excluded.last_seen_at,
           resume_cursor_json = excluded.resume_cursor_json,
           runtime_payload_json = excluded.runtime_payload_json
           adapter_key AS "adapterKey",
           provider_thread_id AS "providerThreadId",
           status,
+          approval_policy AS "approvalPolicy",
+          sandbox_mode AS "sandboxMode",
           last_seen_at AS "lastSeenAt",
           resume_cursor_json AS "resumeCursor",
           runtime_payload_json AS "runtimePayload"
           adapter_key AS "adapterKey",
           provider_thread_id AS "providerThreadId",
           status,
+          approval_policy AS "approvalPolicy",
+          sandbox_mode AS "sandboxMode",
           last_seen_at AS "lastSeenAt",
           resume_cursor_json AS "resumeCursor",
           runtime_payload_json AS "runtimePayload"

apps/server/src/persistence/Migrations.ts+2−0

 import Migration0005 from "./Migrations/005_Projections.ts";
 import Migration0006 from "./Migrations/006_ProjectionThreadSessionRuntimeModeColumns.ts";
 import Migration0007 from "./Migrations/007_ProjectionThreadMessageAttachments.ts";
+import Migration0008 from "./Migrations/008_ProviderSessionRuntimeModeColumns.ts";
 /**
  * Migration loader with all migrations defined inline.
   "5_Projections": Migration0005,
   "6_ProjectionThreadSessionRuntimeModeColumns": Migration0006,
   "7_ProjectionThreadMessageAttachments": Migration0007,
+  "8_ProviderSessionRuntimeModeColumns": Migration0008,
 });
 /**

apps/server/src/persistence/Migrations/008_ProviderSessionRuntimeModeColumns.ts+31−0

@@ -0,0 +1,31 @@
	1	import * as SqlClient from "effect/unstable/sql/SqlClient";
	2	import * as Effect from "effect/Effect";
	3
	4	const DEFAULT_APPROVAL_POLICY = "never";
	5	const DEFAULT_SANDBOX_MODE = "workspace-write";
	6
	7	export default Effect.gen(function* () {
	8	const sql = yield* SqlClient.SqlClient;
	9
	10	yield* sql`
	11	ALTER TABLE provider_session_runtime
	12	ADD COLUMN approval_policy TEXT NOT NULL DEFAULT 'never'
	13	`;
	14
	15	yield* sql`
	16	ALTER TABLE provider_session_runtime
	17	ADD COLUMN sandbox_mode TEXT NOT NULL DEFAULT 'workspace-write'
	18	`;
	19
	20	yield* sql`
	21	UPDATE provider_session_runtime
	22	SET approval_policy = ${DEFAULT_APPROVAL_POLICY}
	23	WHERE approval_policy IS NULL
	24	`;
	25
	26	yield* sql`
	27	UPDATE provider_session_runtime
	28	SET sandbox_mode = ${DEFAULT_SANDBOX_MODE}
	29	WHERE sandbox_mode IS NULL
	30	`;
	31	});

apps/server/src/persistence/Services/ProviderSessionRuntime.ts+4−0

  */
 import {
   IsoDateTime,
+  ProviderApprovalPolicy,
+  ProviderSandboxMode,
   ProviderSessionId,
   ProviderSessionRuntimeStatus,
   ProviderThreadId,
   adapterKey: Schema.String,
   providerThreadId: Schema.NullOr(ProviderThreadId),
   status: ProviderSessionRuntimeStatus,
+  approvalPolicy: ProviderApprovalPolicy,
+  sandboxMode: ProviderSandboxMode,
   lastSeenAt: IsoDateTime,
   resumeCursor: Schema.NullOr(Schema.Unknown),
   runtimePayload: Schema.NullOr(Schema.Unknown),

apps/server/src/provider/Layers/ProviderService.test.ts+12−0

         return yield* provider.startSession(asThreadId("thread-1"), {
           provider: "codex",
           cwd: "/tmp/project",
+          approvalPolicy: "never",
+          sandboxMode: "danger-full-access",
         });
       }).pipe(Effect.provide(firstProviderLayer));
             provider: "codex",
             cwd: "/tmp/project",
             resumeThreadId: startedSession.threadId,
+            approvalPolicy: "never",
+            sandboxMode: "danger-full-access",
           },
         ],
       ]);
       const initial = yield* provider.startSession(asThreadId("thread-1"), {
         provider: "codex",
         cwd: "/tmp/project",
+        approvalPolicy: "never",
+        sandboxMode: "danger-full-access",
       });
       yield* routing.codex.stopSession(initial.sessionId);
       routing.codex.startSession.mockClear();
             provider: "codex",
             cwd: "/tmp/project",
             resumeThreadId: initial.threadId,
+            approvalPolicy: "never",
+            sandboxMode: "danger-full-access",
           },
         ],
       ]);
       const initial = yield* provider.startSession(asThreadId("thread-1"), {
         provider: "codex",
         cwd: "/tmp/project-send-turn",
+        approvalPolicy: "never",
+        sandboxMode: "danger-full-access",
       });
       yield* provider.stopAll();
             provider: "codex",
             cwd: "/tmp/project-send-turn",
             resumeThreadId: initial.threadId,
+            approvalPolicy: "never",
+            sandboxMode: "danger-full-access",
           },
         ],
       ]);

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

   ProviderSendTurnInput,
   ProviderSessionStartInput,
   ProviderStopSessionInput,
+  type ProviderApprovalPolicy,
+  type ProviderSandboxMode,
   type ProviderRuntimeEvent,
   type ProviderSession,
 } from "@t3tools/contracts";
       session: ProviderSession,
       operation: string,
       threadId: ThreadId,
+      options?: {
+        readonly approvalPolicy?: ProviderApprovalPolicy;
+        readonly sandboxMode?: ProviderSandboxMode;
+      },
     ) =>
       Effect.gen(function* () {
         const providerThreadId = session.threadId;
           threadId,
           providerThreadId,
           status: toRuntimeStatus(session),
+          ...(options?.approvalPolicy !== undefined
+            ? { approvalPolicy: options.approvalPolicy }
+            : {}),
+          ...(options?.sandboxMode !== undefined ? { sandboxMode: options.sandboxMode } : {}),
           ...(session.resumeCursor !== undefined ? { resumeCursor: session.resumeCursor } : {}),
           runtimePayload: toRuntimePayloadFromSession(session),
         });
         const resumeThreadId = input.binding.providerThreadId ?? undefined;
         const hasResumeCursor =
           input.binding.resumeCursor !== null && input.binding.resumeCursor !== undefined;
+        const persistedApprovalPolicy = input.binding.approvalPolicy;
+        const persistedSandboxMode = input.binding.sandboxMode;
         const existing =
           resumeThreadId === undefined
             ? undefined
             existing,
             `${input.operation}:upsertExistingSession`,
             input.binding.threadId,
+            {
+              ...(persistedApprovalPolicy ? { approvalPolicy: persistedApprovalPolicy } : {}),
+              ...(persistedSandboxMode ? { sandboxMode: persistedSandboxMode } : {}),
+            },
           );
           yield* directory.upsert({
             sessionId: input.staleSessionId,
           ...(persistedCwd ? { cwd: persistedCwd } : {}),
           ...(resumeThreadId ? { resumeThreadId } : {}),
           ...(hasResumeCursor ? { resumeCursor: input.binding.resumeCursor } : {}),
+          ...(persistedApprovalPolicy ? { approvalPolicy: persistedApprovalPolicy } : {}),
+          ...(persistedSandboxMode ? { sandboxMode: persistedSandboxMode } : {}),
         });
         if (resumed.provider !== adapter.provider) {
           return yield* toValidationError(
           resumed,
           `${input.operation}:upsertRecoveredSession`,
           input.binding.threadId,
+          {
+            ...(persistedApprovalPolicy ? { approvalPolicy: persistedApprovalPolicy } : {}),
+            ...(persistedSandboxMode ? { sandboxMode: persistedSandboxMode } : {}),
+          },
         );
         yield* directory.upsert({
           );
         }
-        yield* upsertSessionBinding(session, "ProviderService.startSession", threadId);
+        yield* upsertSessionBinding(session, "ProviderService.startSession", threadId, {
+          approvalPolicy: input.approvalPolicy,
+          sandboxMode: input.sandboxMode,
+        });
         return session;
       });

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

         threadId,
         providerThreadId,
         status: "starting",
+        approvalPolicy: "never",
+        sandboxMode: "danger-full-access",
         resumeCursor: {
           resumeThreadId: "provider-thread-runtime",
         },
         sessionId,
         provider: "codex",
         status: "running",
+        approvalPolicy: "on-request",
+        sandboxMode: "workspace-write",
         runtimePayload: {
           activeTurnId: "turn-1",
         },
         assert.equal(runtime.value.threadId, threadId);
         assert.equal(runtime.value.providerThreadId, providerThreadId);
         assert.equal(runtime.value.status, "running");
+        assert.equal(runtime.value.approvalPolicy, "on-request");
+        assert.equal(runtime.value.sandboxMode, "workspace-write");
         assert.deepEqual(runtime.value.resumeCursor, {
           resumeThreadId: providerThreadId,
         });

apps/server/src/provider/Layers/ProviderSessionDirectory.ts+16−1

-import { ProviderSessionId, type ProviderKind } from "@t3tools/contracts";
+import {
+  ProviderSessionId,
+  type ProviderApprovalPolicy,
+  type ProviderKind,
+  type ProviderSandboxMode,
+} from "@t3tools/contracts";
 import { Effect, Layer, Option } from "effect";
 import { ProviderSessionRuntimeRepository } from "../../persistence/Services/ProviderSessionRuntime.ts";
   type ProviderSessionDirectoryShape,
 } from "../Services/ProviderSessionDirectory.ts";
+const DEFAULT_APPROVAL_POLICY: ProviderApprovalPolicy = "never";
+const DEFAULT_SANDBOX_MODE: ProviderSandboxMode = "workspace-write";
 function toPersistenceError(operation: string) {
   return (cause: unknown) =>
     new ProviderSessionDirectoryPersistenceError({
                   adapterKey: value.adapterKey,
                   providerThreadId: value.providerThreadId,
                   status: value.status,
+                  approvalPolicy: value.approvalPolicy,
+                  sandboxMode: value.sandboxMode,
                   resumeCursor: value.resumeCursor,
                   runtimePayload: value.runtimePayload,
                 }),
             ? binding.providerThreadId
             : (existingRuntime?.providerThreadId ?? null),
         status: binding.status ?? existingRuntime?.status ?? "running",
+        approvalPolicy:
+          binding.approvalPolicy ??
+          existingRuntime?.approvalPolicy ??
+          DEFAULT_APPROVAL_POLICY,
+        sandboxMode: binding.sandboxMode ?? existingRuntime?.sandboxMode ?? DEFAULT_SANDBOX_MODE,
         lastSeenAt: now,
         resumeCursor:
           binding.resumeCursor !== undefined

apps/server/src/provider/Services/ProviderSessionDirectory.ts+4−0

  * @module ProviderSessionDirectory
  */
 import type {
+  ProviderApprovalPolicy,
   ProviderKind,
+  ProviderSandboxMode,
   ProviderSessionId,
   ProviderSessionRuntimeStatus,
   ProviderThreadId,
   readonly adapterKey?: string;
   readonly providerThreadId?: ProviderThreadId | null;
   readonly status?: ProviderSessionRuntimeStatus;
+  readonly approvalPolicy?: ProviderApprovalPolicy;
+  readonly sandboxMode?: ProviderSandboxMode;
   readonly resumeCursor?: unknown | null;
   readonly runtimePayload?: unknown | null;
 }

Persist provider runtime mode settings

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code