From ace218fedc1fb861a0d6da10ef2c613ae0b43371 Mon Sep 17 00:00:00 2001 From: Devin Foley Date: Thu, 12 Nov 2026 19:38:38 -0800 Subject: [PATCH] Preserve managed SSH sessions and probe refreshes Normalize managed ACP session identity through the shared account-home contract so fresh credential directories and token refreshes do not discard conversations. Keep account changes and other configured environment changes in the identity. Restore refreshed Codex probe credentials through the existing same-account merge before deleting the private runtime. Report managed copyback errors and keep local cleanup in a finally block. Verified both findings red-green with six regression cases. The focused run passed 352 tests, and adapter-utils, Codex, and server typechecks passed. Local verify requests broader CI (exit 2). Co-Authored-By: Paperclip --- doc/connections/AI-CONNECTIONS.md | 10 ++- .../src/acpx-engine/execute.test.ts | 40 +++++++++--- .../adapter-utils/src/acpx-engine/execute.ts | 12 +++- .../src/managed-ai-runtime-env.ts | 48 ++++++++++++++ .../src/server/test.remote.test.ts | 65 ++++++++++++++++++- .../adapters/codex-local/src/server/test.ts | 27 ++++++-- server/src/services/ai-connection-runtime.ts | 36 +--------- 7 files changed, 184 insertions(+), 54 deletions(-) create mode 100644 packages/adapter-utils/src/managed-ai-runtime-env.ts diff --git a/doc/connections/AI-CONNECTIONS.md b/doc/connections/AI-CONNECTIONS.md index eee20ba3f81..8ba64f3f933 100644 --- a/doc/connections/AI-CONNECTIONS.md +++ b/doc/connections/AI-CONNECTIONS.md @@ -456,7 +456,9 @@ Credential-bearing launch commands travel through SSH stdin instead of SSH process arguments. The existing account-specific refresh merge runs before per-turn directories are removed, including after provider or setup failure. Environment tests use the selected account and remove their temporary homes -after probing. A disconnected target can prevent remote cleanup; the run reports +after probing. Managed Codex probes copy refreshed credentials to that account's +local home before cleanup, even when the provider request fails. The merge rejects +credentials from another account. A copyback failure fails the probe. A disconnected target can prevent remote cleanup; the run reports the resulting failure rather than silently selecting another account. Codex CLI runs in an in-place SSH workspace keep conversation files and native @@ -477,7 +479,11 @@ ACP SSH sessions use the existing remote process bridge and session reuse lifecycle. A compatible session can retain its private remote home; workspace sync and credential refresh run at turn teardown, and the session disposal hook removes the home on retirement. Workspace identity includes the company, agent, -task and execution fingerprint. Older managed SSH ACP sessions used a different +task and execution fingerprint. The fingerprint normalizes temporary managed-home +paths and credential refreshes against the stable account session identity. +Switching accounts or changing other adapter environment values starts a fresh +conversation. The launch still receives the current credentials. +Older managed SSH ACP sessions used a different working-directory identity and start fresh after this change. Native runner session identities and sandbox staging are unchanged. diff --git a/packages/adapter-utils/src/acpx-engine/execute.test.ts b/packages/adapter-utils/src/acpx-engine/execute.test.ts index 1502b016a0d..8ac015aa8c0 100644 --- a/packages/adapter-utils/src/acpx-engine/execute.test.ts +++ b/packages/adapter-utils/src/acpx-engine/execute.test.ts @@ -4561,7 +4561,12 @@ describe("ACPX engine remote managed-home seam (PR 2: per-adapter home seed)", ( it.each(["turn", "bridge"])("stages the configured agent account for SSH, resumes it, and copies back before disposal after a %s failure", async failure => { const { root, stateDir, localCwd, remoteCwd } = await setupRemoteSandbox(); - const home = path.join(root, "selected-account");await fs.mkdir(home); + const homes = await Promise.all(["first", "second", "third"].map(async name => { + const home = path.join(root, `selected-account-${name}`); + await fs.mkdir(path.join(home, "provider"), { recursive: true }); + return home; + })); + const home = path.join(homes[0]!, "provider"); const workspace = path.posix.join(remoteCwd, ".paperclip-runtime/runs/run-1/workspace"); const runtimeRootDir = path.posix.join(workspace, ".paperclip-runtime/custom"); const executionTarget = { kind: "remote", transport: "ssh", remoteCwd, spec: { useHostAuth: false, host: "ssh.example.test", port: 22, username: "agent", remoteCwd, remoteWorkspacePath: remoteCwd, privateKey: null, knownHosts: null, strictHostKeyChecking: true } }; @@ -4569,18 +4574,21 @@ describe("ACPX engine remote managed-home seam (PR 2: per-adapter home seed)", ( const stopControl = vi.fn(async () => {}), stopProcess = vi.fn(async () => {}); const stagedRuntimes: NonNullable = new Map(); const seam = vi.fn(async (input: Parameters>[0]) => { - const stagedRuntime = await input.stage([{ key: "home", localDir: home }]); + const stagedRuntime = await input.stage([{ key: "home", localDir: input.env.CODEX_HOME! }]); input.env.CODEX_HOME = stagedRuntime.assetDirs.home!; return { stagedRuntime }; }); const actual = await vi.importActual("@paperclipai/adapter-utils/execution-target"); - vi.mocked(prepareAdapterExecutionTargetRuntime).mockResolvedValueOnce({ target: executionTarget as never, workspaceRemoteDir: workspace, runtimeRootDir, + vi.mocked(prepareAdapterExecutionTargetRuntime).mockResolvedValue({ target: executionTarget as never, workspaceRemoteDir: workspace, runtimeRootDir, assetDirs: { home: path.posix.join(runtimeRootDir, "home") }, additionalSourceDirs: {}, additionalSourceFailures: [], workspaceSyncSnapshot: null, restoreWorkspace: restore, disposeRuntime: dispose }); vi.mocked(startAdapterExecutionTargetPaperclipBridge).mockResolvedValue({ env: { PAPERCLIP_API_URL: "http://127.0.0.1:3210", PAPERCLIP_API_KEY: "bridge-fixture" }, stop: stopControl }); vi.mocked(startAdapterExecutionTargetProcessSessionBridge).mockResolvedValue({ agentCommand: "/fixture/agent-proxy.cjs", stop: stopProcess }); try { - const config = { agent: "custom", agentCommand: "node ./fake-acp.js", stateDir, cwd: localCwd, - managedAiConnection: { identity: "selected-agent-account" }, env: { CODEX_HOME: home, HOME: home }, mode: "persistent" }; + const configForTurn = (turn: number) => ({ agent: "custom", agentCommand: "node ./fake-acp.js", stateDir, cwd: localCwd, + managedAiConnection: { identity: `credential-revision-${turn}`, sessionIdentity: "selected-agent-account" }, + env: { CODEX_HOME: path.join(homes[turn]!, "provider"), HOME: homes[turn]!, XDG_CONFIG_HOME: path.join(homes[turn]!, "config"), + XDG_DATA_HOME: path.join(homes[turn]!, "data"), OPENAI_API_KEY: `fixture-token-${turn}`, USER_OPTION: "kept" }, mode: "persistent" }); + const config = configForTurn(0); let failTurn = false; const options = { authToken: "run-fixture", executionTarget, prepareRemoteManagedHome: seam, stagedRuntimes, onStartTurn: () => { if (failTurn) throw new Error("fixture SSH turn failed"); } }; @@ -4597,16 +4605,20 @@ describe("ACPX engine remote managed-home seam (PR 2: per-adapter home seed)", ( expect(stopControl).toHaveBeenCalledOnce(); expect(stopProcess).toHaveBeenCalledOnce(); expect(dispose).not.toHaveBeenCalled(); - const resumed = await runExecutor(config, { ...options, runId: "run-2", runtime: { sessionParams: result.result.sessionParams } }); + const resumed = await runExecutor(configForTurn(1), { ...options, runId: "run-2", runtime: { sessionParams: result.result.sessionParams } }); expect(resumed.sessionInputs[0]?.cwd).toBe(result.sessionInputs[0]?.cwd); + expect(resumed.sessionInputs[0]?.resumeSessionId).toBe(result.result.sessionId); + const resumeBridge = vi.mocked(startAdapterExecutionTargetProcessSessionBridge).mock.calls.at(-1)![0]; + const resumedEnv = typeof resumeBridge.env === "function" ? await resumeBridge.env() : resumeBridge.env; + expect(resumedEnv.OPENAI_API_KEY).toBe("fixture-token-1"); expect(seam).toHaveBeenCalledOnce(); expect(restore).toHaveBeenCalledTimes(2); if (failure === "bridge") { vi.mocked(startAdapterExecutionTargetProcessSessionBridge).mockRejectedValueOnce(new Error("fixture SSH bridge unavailable")); - await expect(runExecutor(config, { ...options, runId: "run-3", runtime: { sessionParams: resumed.result.sessionParams } })).rejects.toThrow("fixture SSH bridge unavailable"); + await expect(runExecutor(configForTurn(2), { ...options, runId: "run-3", runtime: { sessionParams: resumed.result.sessionParams } })).rejects.toThrow("fixture SSH bridge unavailable"); } else { failTurn = true; - await runExecutor(config, { ...options, runId: "run-3", expectedExitCode: 1, runtime: { sessionParams: resumed.result.sessionParams } }); + await runExecutor(configForTurn(2), { ...options, runId: "run-3", expectedExitCode: 1, runtime: { sessionParams: resumed.result.sessionParams } }); } expect(restore).toHaveBeenCalledTimes(3); expect(stopControl.mock.invocationCallOrder[2]).toBeLessThan(restore.mock.invocationCallOrder[2]!); @@ -4615,6 +4627,18 @@ describe("ACPX engine remote managed-home seam (PR 2: per-adapter home seed)", ( expect(stopControl).toHaveBeenCalledTimes(3); expect(stopProcess).toHaveBeenCalledTimes(failure === "bridge" ? 2 : 3); expect(stagedRuntimes.size).toBe(0); + failTurn = true; + const changed = configForTurn(0); + if (failure === "turn") changed.managedAiConnection.sessionIdentity = "different-agent-account"; + else changed.env.USER_OPTION = "changed"; + const reset = await runExecutor(changed, { ...options, runId: "run-4", expectedExitCode: 1, + runtime: { sessionParams: resumed.result.sessionParams } }); + expect(reset.sessionInputs[0]?.cwd).not.toBe(result.sessionInputs[0]?.cwd); + expect(reset.sessionInputs[0]?.resumeSessionId).not.toBe(result.result.sessionId); + expect(seam).toHaveBeenCalledTimes(2); + expect(restore).toHaveBeenCalledTimes(4); + expect(dispose).toHaveBeenCalledTimes(2); + expect(stagedRuntimes.size).toBe(0); } finally { vi.mocked(prepareAdapterExecutionTargetRuntime).mockReset().mockImplementation(actual.prepareAdapterExecutionTargetRuntime); vi.mocked(startAdapterExecutionTargetPaperclipBridge).mockReset().mockImplementation(actual.startAdapterExecutionTargetPaperclipBridge); diff --git a/packages/adapter-utils/src/acpx-engine/execute.ts b/packages/adapter-utils/src/acpx-engine/execute.ts index 259777d5a0f..77b316a84cb 100644 --- a/packages/adapter-utils/src/acpx-engine/execute.ts +++ b/packages/adapter-utils/src/acpx-engine/execute.ts @@ -1,3 +1,4 @@ +import { managedAiSessionFingerprintConfig } from "../managed-ai-runtime-env.js"; import { createWorkspaceRestoreTeardown } from "../workspace-restore-teardown.js"; import { isOpenRouterUrl, openRouterClaudeHeaders } from "@paperclipai/shared/openrouter-attribution"; import { prepareAcpxCodexObservabilityHome } from "../codex-observability-home.js"; @@ -2331,7 +2332,16 @@ async function buildRuntime(input: { // that sources the latest env. secretManifestHash alone misses plain-value // edits and same-version secret rotations. Per-wake runtime vars never enter // resolvedAdapterEnv, so they don't churn the fingerprint every heartbeat. - adapterEnvHash: shortHash(resolvedAdapterEnv), + // Managed SSH identity uses the selected account's stable session identity; + // temporary credential homes and token refreshes affect only the launch env. + adapterEnvHash: shortHash( + useRemoteProcessSession && executionTarget?.kind === "remote" && executionTarget.transport === "ssh" + ? managedAiSessionFingerprintConfig( + { env: resolvedAdapterEnv, managedAiConnection: config.managedAiConnection }, + asString(resolvedAdapterEnv.HOME, "") || undefined, + ) + : resolvedAdapterEnv, + ), }; const taskKey = asString(input.ctx.runtime.taskKey, "") || wakeTaskId || workspaceId || "default"; const sshWorkspaceRunId = useRemoteProcessSession && executionTarget?.kind === "remote" && executionTarget.transport === "ssh" diff --git a/packages/adapter-utils/src/managed-ai-runtime-env.ts b/packages/adapter-utils/src/managed-ai-runtime-env.ts new file mode 100644 index 00000000000..e994ea9aca4 --- /dev/null +++ b/packages/adapter-utils/src/managed-ai-runtime-env.ts @@ -0,0 +1,48 @@ +import path from "node:path"; + +export function managedAiHomeEnvironment(home: string): Record { + const providerHome = path.join(home, "provider"); + return { + HOME: home, + XDG_CONFIG_HOME: path.join(home, "config"), + XDG_DATA_HOME: path.join(home, "data"), + CODEX_HOME: providerHome, + GROK_HOME: providerHome, + CLAUDE_CONFIG_DIR: providerHome, + HERMES_HOME: providerHome, + }; +} + +/** Only the server-created credential home is volatile; retain all other config. */ +export function managedAiSessionFingerprintConfig( + config: Record, + managedHome: string | undefined, +): Record { + if (!managedHome) return config; + const env = { ...(config.env as Record | undefined) }; + const stable = managedAiHomeEnvironment(""); + for (const [key, value] of Object.entries(managedAiHomeEnvironment(managedHome))) { + if (env[key] === value) env[key] = stable[key]; + } + if (env.GEMINI_HOME === path.join(managedHome, "provider")) { + env.GEMINI_HOME = path.join("", "provider"); + } + const managed = config.managedAiConnection as Record | undefined; + if (managed?.sessionIdentity) { + for (const key of [ + "ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "CLAUDE_CODE_OAUTH_TOKEN", + "OPENAI_API_KEY", "CODEX_API_KEY", "OPENROUTER_API_KEY", "XAI_API_KEY", + "GROK_API_KEY", "GEMINI_API_KEY", "GOOGLE_API_KEY", + "OPENCODE_AUTH_JSON", "OPENCODE_CONFIG_CONTENT", + ]) { + if (env[key]) env[key] = ""; + } + } + return { + ...config, + env, + ...(managed?.sessionIdentity + ? { managedAiConnection: { ...managed, identity: managed.sessionIdentity } } + : {}), + }; +} diff --git a/packages/adapters/codex-local/src/server/test.remote.test.ts b/packages/adapters/codex-local/src/server/test.remote.test.ts index 4cab7a6d0cb..048701c9291 100644 --- a/packages/adapters/codex-local/src/server/test.remote.test.ts +++ b/packages/adapters/codex-local/src/server/test.remote.test.ts @@ -2,7 +2,7 @@ import fs from "node:fs/promises"; import os from "node:os"; import path from "node:path"; import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; -import type { AdapterExecutionTarget } from "@paperclipai/adapter-utils/execution-target"; +import type { AdapterManagedRuntimeAsset, AdapterExecutionTarget } from "@paperclipai/adapter-utils/execution-target"; const { ensureAdapterExecutionTargetDirectory, @@ -52,7 +52,7 @@ const { } return fallbackCwd; }), - prepareAdapterExecutionTargetRuntime: vi.fn(async (input: { assets?: Array<{ key: string; localDir: string }> }) => { + prepareAdapterExecutionTargetRuntime: vi.fn(async (input: { assets?: AdapterManagedRuntimeAsset[] }) => { const homeAsset = input?.assets?.find((asset) => asset.key === "home"); if (homeAsset) { capturedHomeAssetFiles.value = (await fs.readdir(homeAsset.localDir)).sort(); @@ -176,7 +176,7 @@ describe("codex remote environment diagnostics", () => { workspaceLocalDir: string; target?: { remoteCwd?: string }; workspaceRemoteDir?: string; - assets?: Array<{ key: string; localDir: string }>; + assets?: AdapterManagedRuntimeAsset[]; }, ]>; const runtimeInput = runtimeCalls[0]?.[0]; @@ -512,6 +512,65 @@ describe("codex remote environment diagnostics", () => { last_refresh: lastRefresh, }); + it.each(["success", "provider failure", "foreign account", "copyback failure"])( + "preserves managed SSH probe credentials through %s before cleanup", + async outcome => { + const selectedHome = await makeScratchDir("paperclip-test-selected-codex-"); + const original = subscriptionAuth("acct-selected", "original", "2020-01-01T00:00:00Z"); + const refreshed = subscriptionAuth(outcome === "foreign account" ? "acct-other" : "acct-selected", "refreshed", "2020-01-02T00:00:00Z"); + const shared = subscriptionAuth("acct-shared", "untouched", "2020-01-01T00:00:00Z"); + const authPath = path.join(selectedHome, "auth.json"); + await fs.writeFile(authPath, original); + await fs.writeFile(path.join(process.env.CODEX_HOME!, "auth.json"), shared); + const basePrepare = prepareAdapterExecutionTargetRuntime.getMockImplementation()!; + let stagingDir = ""; + let assetRestoreCalls = 0; + prepareAdapterExecutionTargetRuntime.mockImplementationOnce(async input => { + const prepared = await basePrepare(input); + const home = input.assets!.find(asset => asset.key === "home")!; + stagingDir = home.localDir; + return { ...prepared, restoreWorkspace: vi.fn(async () => { + try { + expect(home.restore).toBeTypeOf("function"); + await home.restore!({ assetDir: prepared.assetDirs.home, + readFile: async remotePath => { + expect(remotePath).toBe(path.posix.join(prepared.assetDirs.home, "auth.json")); + assetRestoreCalls += 1; + await expect(fs.stat(stagingDir)).resolves.toBeDefined(); + if (outcome === "copyback failure") throw new Error("fixture credential read failed"); + return Buffer.from(refreshed); + }, + } as Parameters>[0]); + expect(await fs.readFile(authPath, "utf8")).toBe(outcome === "foreign account" ? original : refreshed); + } finally { + await restoreWorkspace(); + } + }) }; + }); + if (outcome === "provider failure") { + const success = await runAdapterExecutionTargetProcess.getMockImplementation()!(); + runAdapterExecutionTargetProcess.mockResolvedValueOnce({ ...success, exitCode: 1, stdout: "", stderr: "fixture provider unavailable" }); + } + const probe = testEnvironment({ companyId: "company-1", adapterType: "codex_local", + config: { engine: "cli", command: "codex", managedAiConnection: { identity: "selected-account" }, env: { CODEX_HOME: selectedHome } }, + executionTarget: { kind: "remote", transport: "ssh", remoteCwd: "/remote/workspace", + spec: { host: "ssh.example.test", port: 22, username: "agent", privateKey: null, knownHosts: null, + strictHostKeyChecking: true, remoteCwd: "/remote/workspace", remoteWorkspacePath: "/remote/workspace", useHostAuth: false } }, + }); + if (outcome === "copyback failure") await expect(probe).rejects.toThrow("fixture credential read failed"); + else { + const result = await probe; + expect(result.status).toBe(outcome === "provider failure" ? "fail" : "pass"); + expect(JSON.stringify(result)).not.toContain("synthetic-"); + } + expect(assetRestoreCalls).toBe(1); + expect(restoreWorkspace).toHaveBeenCalledOnce(); + await expect(fs.stat(stagingDir)).rejects.toMatchObject({ code: "ENOENT" }); + expect(await fs.readFile(path.join(process.env.CODEX_HOME!, "auth.json"), "utf8")).toBe(shared); + expect(await fs.readFile(authPath, "utf8")).toBe(["foreign account", "copyback failure"].includes(outcome) ? original : refreshed); + }, + ); + function sandboxTarget(): AdapterExecutionTarget { return { kind: "remote", diff --git a/packages/adapters/codex-local/src/server/test.ts b/packages/adapters/codex-local/src/server/test.ts index 6fdea1e2122..f8936c41b16 100644 --- a/packages/adapters/codex-local/src/server/test.ts +++ b/packages/adapters/codex-local/src/server/test.ts @@ -22,6 +22,7 @@ import { import fs from "node:fs/promises"; import path from "node:path"; import os from "node:os"; +import { copyBackCodexAuth } from "./codex-auth-copyback.js"; import { parseCodexJsonl } from "./parse.js"; import { SANDBOX_INSTALL_COMMAND } from "../index.js"; import { codexHomeDir, readCodexAuthInfo } from "./quota.js"; @@ -103,12 +104,17 @@ async function prepareCodexHelloProbe(input: { let probeHomeLocalDir: string | null = null; const cleanup = async () => { - await preparedRuntime?.restoreWorkspace().catch(() => {}); - if (preparedRuntimeWorkspaceLocalDir) { - await fs.rm(preparedRuntimeWorkspaceLocalDir, { recursive: true, force: true }).catch(() => {}); - } - if (probeHomeLocalDir) { - await fs.rm(probeHomeLocalDir, { recursive: true, force: true }).catch(() => {}); + try { + await preparedRuntime?.restoreWorkspace(); + } catch (error) { + if (input.managedAiConnection) throw error; + } finally { + if (preparedRuntimeWorkspaceLocalDir) { + await fs.rm(preparedRuntimeWorkspaceLocalDir, { recursive: true, force: true }).catch(() => {}); + } + if (probeHomeLocalDir) { + await fs.rm(probeHomeLocalDir, { recursive: true, force: true }).catch(() => {}); + } } }; @@ -207,6 +213,15 @@ async function prepareCodexHelloProbe(input: { key: "home", localDir: probeHomeLocalDir, followSymlinks: true, + restore: input.managedAiConnection + ? async ({ assetDir, readFile }) => { + await copyBackCodexAuth({ + readSandboxAuth: () => readFile(path.posix.join(assetDir, "auth.json")), + hostAuthPath: path.join(effectiveHome, "auth.json"), + log: async () => {}, + }); + } + : undefined, }, ], }); diff --git a/server/src/services/ai-connection-runtime.ts b/server/src/services/ai-connection-runtime.ts index ade2d0e0f53..03ccb040d50 100644 --- a/server/src/services/ai-connection-runtime.ts +++ b/server/src/services/ai-connection-runtime.ts @@ -1,3 +1,5 @@ +import { managedAiHomeEnvironment } from "@paperclipai/adapter-utils/managed-ai-runtime-env"; +export { managedAiSessionFingerprintConfig } from "@paperclipai/adapter-utils/managed-ai-runtime-env"; import { environmentTaskResultSchema } from "@paperclipai/plugin-sdk"; import type { ManagedAiCredentialWritebackBinding } from "./managed-ai-credential-writeback.js"; import { OPENROUTER_ATTRIBUTION_HEADERS, openRouterClaudeHeaders } from "@paperclipai/shared/openrouter-attribution"; @@ -208,40 +210,6 @@ done`, } } -function managedAiHomeEnvironment(home: string): Record { - const providerHome = path.join(home, "provider"); - return { - HOME: home, - XDG_CONFIG_HOME: path.join(home, "config"), - XDG_DATA_HOME: path.join(home, "data"), - CODEX_HOME: providerHome, - GROK_HOME: providerHome, - CLAUDE_CONFIG_DIR: providerHome, - HERMES_HOME: providerHome, - }; -} - -/** Only the server-created credential home is volatile; retain all other config. */ -export function managedAiSessionFingerprintConfig( - config: Record, - managedHome: string | undefined, -): Record { - if (!managedHome) return config; - const env = { ...(config.env as Record | undefined) }; - const stable = managedAiHomeEnvironment(""); - for (const [key, value] of Object.entries(managedAiHomeEnvironment(managedHome))) { - if (env[key] === value) env[key] = stable[key]; - } - if (env.GEMINI_HOME === path.join(managedHome, "provider")) env.GEMINI_HOME = path.join("", "provider"); - const managed = config.managedAiConnection as Record | undefined; - if (managed?.sessionIdentity) { - for (const key of ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "CLAUDE_CODE_OAUTH_TOKEN", "OPENAI_API_KEY", "CODEX_API_KEY", "OPENROUTER_API_KEY", "XAI_API_KEY", "GROK_API_KEY", "GEMINI_API_KEY", "GOOGLE_API_KEY", "OPENCODE_AUTH_JSON", "OPENCODE_CONFIG_CONTENT"]) { - if (env[key]) env[key] = ""; - } - } - return { ...config, env, ...(managed?.sessionIdentity ? { managedAiConnection: { ...managed, identity: managed.sessionIdentity } } : {}) }; -} - export async function prepareManagedAiRuntime( db: Db, input: {