replicas-engine 0.1.636 → 0.1.638

package/dist/src/{chunk-3CX4NHQA.js → chunk-Z4OLZBZN.js}

@@ -89,8 +89,8 @@ var REPLICAS_RUNTIME_ENV_ALIASES = {
   slackChannelId: ["REPLICAS_SLACK_CHANNEL_ID", "SLACK_CHANNEL_ID"],
   slackThreadTs: ["REPLICAS_SLACK_THREAD_TS", "SLACK_THREAD_TS"]
 };
-function readReplicasRuntimeEnv(readEnv2, [namespacedKey, legacyKey]) {
-  return readEnv2(namespacedKey) ?? readEnv2(legacyKey);
+function readReplicasRuntimeEnv(readEnv, [namespacedKey, legacyKey]) {
+  return readEnv(namespacedKey) ?? readEnv(legacyKey);
 }
 function shellQuotePosix(value) {
   return `'${value.split("'").join("'\\''")}'`;
@@ -243,6 +243,7 @@ var headlessAgentOutputFileSchema = z.object({
   path: z.string().min(1),
   uploadUrl: z.url(),
   contentType: z.string().min(1),
+  minChars: z.number().int().positive().optional(),
   maxChars: z.number().int().positive().optional()
 });
 var headlessAgentRequestSchema = z.discriminatedUnion("mode", [
@@ -5643,150 +5644,19 @@ async function putPresignedFile(urlValue, filePath, size, contentType) {
   });
 }
 
-// src/engine-env.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-
-// src/runtime-env-loader.ts
-import { readFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-function loadRuntimeEnvFile() {
-  let content;
-  try {
-    content = readFileSync(join(homedir(), ".replicas", "runtime-env.sh"), "utf-8");
-  } catch {
-    return;
-  }
-  for (const [key, value] of Object.entries(parsePosixEnvFile(content))) {
-    process.env[key] = value;
-  }
-}
-
-// src/utils/type-guards.ts
-function isRecord4(value) {
-  return typeof value === "object" && value !== null;
-}
-
-// src/engine-env.ts
-var SANDBOX_IMAGE_VERSION_FILE = "/usr/local/lib/replicas-sandbox-image-version";
-function readEnv(name) {
-  const value = process.env[name]?.trim();
-  return value ? value : void 0;
-}
-function readSandboxImageVersion() {
-  const environmentVersion = readEnv("REPLICAS_SANDBOX_IMAGE_VERSION");
-  if (environmentVersion) return environmentVersion;
-  try {
-    return readFileSync2(SANDBOX_IMAGE_VERSION_FILE, "utf8").trim() || "development";
-  } catch {
-    return "development";
-  }
-}
-function parsePort(value) {
-  if (!value) {
-    return 3737;
-  }
-  const parsed = Number(value);
-  if (!Number.isInteger(parsed) || parsed <= 0) {
-    throw new Error("Invalid engine environment: REPLICAS_ENGINE_PORT must be a positive integer");
-  }
-  return parsed;
-}
-function requireDefined(value, name) {
-  if (value === void 0 || value === null) {
-    throw new Error(`Invalid engine environment: ${name} is required`);
-  }
-  return value;
-}
-function requireValidURL(value, name) {
-  try {
-    new URL(value);
-    return value;
-  } catch {
-    throw new Error(`Invalid engine environment: ${name} must be a valid URL`);
-  }
-}
-function parseClaudeAuthMethod(value) {
-  if (value === "oauth" || value === "api_key" || value === "bedrock" || value === "foundry") {
-    return value;
-  }
-  return void 0;
-}
-function parseCodexAuthMethod(value) {
-  if (value === "oauth" || value === "api_key" || value === "foundry") {
-    return value;
-  }
-  return void 0;
-}
-function parseAgentCredentialSnapshots(value) {
-  if (!value) return {};
-  try {
-    const parsed = JSON.parse(value);
-    if (!isRecord4(parsed)) return {};
-    const snapshots = {};
-    for (const [provider, snapshot] of Object.entries(parsed)) {
-      if (!isValidAgentProvider(provider)) continue;
-      const parsedSnapshot = agentCredentialSnapshotSchema.safeParse(snapshot);
-      if (parsedSnapshot.success) snapshots[provider] = parsedSnapshot.data;
-    }
-    return snapshots;
-  } catch {
-    return {};
-  }
-}
-var IS_WARMING_MODE = process.argv.includes("--warming");
-function loadEngineEnv() {
-  loadRuntimeEnvFile();
-  const HOME_DIR = homedir2();
-  const env = {
-    // Defined: always available
-    REPLICAS_ENGINE_SECRET: requireDefined(readEnv("REPLICAS_ENGINE_SECRET"), "REPLICAS_ENGINE_SECRET"),
-    REPLICAS_ENGINE_PORT: parsePort(readEnv("REPLICAS_ENGINE_PORT")),
-    REPLICAS_MONOLITH_URL: requireValidURL(
-      requireDefined(readReplicasRuntimeEnv(readEnv, REPLICAS_RUNTIME_ENV_ALIASES.monolithUrl), "REPLICAS_MONOLITH_URL"),
-      "REPLICAS_MONOLITH_URL"
-    ),
-    HOME_DIR,
-    WORKSPACE_ROOT: join2(HOME_DIR, "workspaces"),
-    REPLICAS_SANDBOX_IMAGE_VERSION: readSandboxImageVersion(),
-    // Runtime: may not be set during warming
-    REPLICAS_WORKSPACE_ID: readReplicasRuntimeEnv(readEnv, REPLICAS_RUNTIME_ENV_ALIASES.workspaceId),
-    REPLICAS_LINEAR_SESSION_ID: readReplicasRuntimeEnv(readEnv, REPLICAS_RUNTIME_ENV_ALIASES.linearSessionId),
-    REPLICAS_LINEAR_ACCESS_TOKEN: readReplicasRuntimeEnv(readEnv, REPLICAS_RUNTIME_ENV_ALIASES.linearAccessToken),
-    REPLICAS_SLACK_BOT_TOKEN: readReplicasRuntimeEnv(readEnv, REPLICAS_RUNTIME_ENV_ALIASES.slackBotToken),
-    REPLICAS_SLACK_CHANNEL_ID: readReplicasRuntimeEnv(readEnv, REPLICAS_RUNTIME_ENV_ALIASES.slackChannelId),
-    REPLICAS_SLACK_THREAD_TS: readReplicasRuntimeEnv(readEnv, REPLICAS_RUNTIME_ENV_ALIASES.slackThreadTs),
-    ANTHROPIC_API_KEY: readEnv("ANTHROPIC_API_KEY"),
-    OPENAI_API_KEY: readEnv("OPENAI_API_KEY"),
-    CURSOR_API_KEY: readEnv("CURSOR_API_KEY"),
-    CLAUDE_CODE_USE_BEDROCK: readEnv("CLAUDE_CODE_USE_BEDROCK"),
-    AWS_ACCESS_KEY_ID: readEnv("AWS_ACCESS_KEY_ID"),
-    AWS_SECRET_ACCESS_KEY: readEnv("AWS_SECRET_ACCESS_KEY"),
-    AWS_REGION: readEnv("AWS_REGION"),
-    ANTHROPIC_SMALL_FAST_MODEL_AWS_REGION: readEnv("ANTHROPIC_SMALL_FAST_MODEL_AWS_REGION"),
-    REPLICAS_CLAUDE_AUTH_METHOD: parseClaudeAuthMethod(readEnv("REPLICAS_CLAUDE_AUTH_METHOD")),
-    REPLICAS_CODEX_AUTH_METHOD: parseCodexAuthMethod(readEnv("REPLICAS_CODEX_AUTH_METHOD")),
-    REPLICAS_AGENT_CREDENTIALS: parseAgentCredentialSnapshots(readEnv("REPLICAS_AGENT_CREDENTIALS")),
-    REPLICAS_ENV_SYSTEM_PROMPT: readEnv("REPLICAS_ENV_SYSTEM_PROMPT"),
-    REPLICAS_ENV_START_HOOK: readEnv("REPLICAS_ENV_START_HOOK"),
-    REPLICAS_DISABLE_AUTO_START_HOOKS: readEnv("REPLICAS_DISABLE_AUTO_START_HOOKS")?.toLowerCase() === "true",
-    REPLICAS_ENGINE_DEFER_INITIALIZATION: readEnv("REPLICAS_ENGINE_DEFER_INITIALIZATION")?.toLowerCase() === "true"
-  };
-  if (!IS_WARMING_MODE && !env.REPLICAS_WORKSPACE_ID) {
-    console.error("REPLICAS_WORKSPACE_ID is not set \u2014 this is required in normal (non-warming) mode");
+// src/utils/codex-agent-env.ts
+function buildCodexAgentEnv(source = process.env) {
+  const env = Object.fromEntries(
+    Object.entries(source).filter((entry) => typeof entry[1] === "string")
+  );
+  if (env.REPLICAS_CODEX_AUTH_METHOD === "oauth" || env.REPLICAS_CODEX_AUTH_METHOD === "foundry") {
+    delete env.OPENAI_API_KEY;
   }
+  delete env.GH_TOKEN;
+  delete env.GITHUB_TOKEN;
+  delete env.GH_CONFIG_DIR;
   return env;
 }
-var ENGINE_ENV = loadEngineEnv();
-function setAgentCredentialSnapshot(provider, snapshot) {
-  ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS = {
-    ...ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS,
-    [provider]: snapshot
-  };
-  process.env.REPLICAS_AGENT_CREDENTIALS = JSON.stringify(ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS);
-}
 
 // src/utils/exec.ts
 import { exec, execFile } from "child_process";
@@ -5988,61 +5858,6 @@ var AspClient = class {
   }
 };
 
-// src/utils/codex-agent-env.ts
-function buildCodexAgentEnv(source = process.env) {
-  const env = Object.fromEntries(
-    Object.entries(source).filter((entry) => typeof entry[1] === "string")
-  );
-  if (env.REPLICAS_CODEX_AUTH_METHOD === "oauth" || env.REPLICAS_CODEX_AUTH_METHOD === "foundry") {
-    delete env.OPENAI_API_KEY;
-  }
-  delete env.GH_TOKEN;
-  delete env.GITHUB_TOKEN;
-  delete env.GH_CONFIG_DIR;
-  return env;
-}
-
-// src/utils/agent-env.ts
-function resolveClaudeAuthMethodForMessage(env = ENGINE_ENV) {
-  const method = env.REPLICAS_CLAUDE_AUTH_METHOD;
-  if (method && method !== "none") {
-    return method;
-  }
-  if (env.CLAUDE_CODE_USE_BEDROCK === "1") return "bedrock";
-  if (env.ANTHROPIC_API_KEY) return "api_key";
-  return "unknown";
-}
-function buildClaudeAgentEnv(overrides) {
-  const env = { ...process.env };
-  if (overrides) {
-    Object.assign(env, overrides);
-  }
-  const isBedrock = isClaudeBedrockEnv(env);
-  if (shouldStripAnthropicApiKey(isBedrock)) {
-    env.ANTHROPIC_API_KEY = void 0;
-  }
-  if (isBedrock) {
-    env.CLAUDE_CODE_USE_BEDROCK = "1";
-    env.CLAUDE_CODE_USE_MANTLE = "1";
-    env.ANTHROPIC_DEFAULT_OPUS_MODEL = CLAUDE_OPUS_4_8_BEDROCK_MODEL;
-    env.ANTHROPIC_DEFAULT_SONNET_MODEL = CLAUDE_SONNET_5_BEDROCK_MODEL;
-    env.ANTHROPIC_DEFAULT_HAIKU_MODEL = CLAUDE_HAIKU_4_5_BEDROCK_MODEL;
-  }
-  env.GH_TOKEN = void 0;
-  env.GITHUB_TOKEN = void 0;
-  env.GH_CONFIG_DIR = void 0;
-  env.CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD = "1";
-  env.CLAUDE_CODE_DISABLE_AUTO_MEMORY = "1";
-  return env;
-}
-function shouldStripAnthropicApiKey(isBedrock) {
-  const method = ENGINE_ENV.REPLICAS_CLAUDE_AUTH_METHOD;
-  return method === "oauth" || method === "bedrock" || method === "foundry" || isBedrock;
-}
-function isClaudeBedrockEnv(env) {
-  return ENGINE_ENV.REPLICAS_CLAUDE_AUTH_METHOD === "bedrock" || env.REPLICAS_CLAUDE_AUTH_METHOD === "bedrock" || env.CLAUDE_CODE_USE_BEDROCK === "1";
-}
-
 // src/managers/codex-asp/app-server-process.ts
 var DEFAULT_CODEX_BINARY = "codex";
 var DEFAULT_CODEX_ARGS = [
@@ -6059,7 +5874,7 @@ var DEFAULT_CODEX_ARGS = [
 var MIN_CODEX_CLI_VERSION = "0.144.6";
 var CODEX_UPGRADE_TIMEOUT_MS = 12e4;
 var codexCliVersionEnsured = null;
-var ENGINE_PACKAGE_VERSION = "0.1.636";
+var ENGINE_PACKAGE_VERSION = "0.1.638";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -6072,26 +5887,26 @@ var AppServerProcess = class {
   child = null;
   client = null;
   shuttingDown = false;
-  constructor(options = {}) {
+  constructor(options) {
     this.binary = options.binary ?? DEFAULT_CODEX_BINARY;
-    const baseArgs = options.args ?? (ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD === "foundry" ? [
+    const baseArgs = options.args ?? (options.env.REPLICAS_CODEX_AUTH_METHOD === "foundry" ? [
       ...DEFAULT_CODEX_ARGS,
       "-c",
-      `model=${JSON.stringify(process.env.CODEX_FOUNDRY_MODEL)}`,
+      `model=${JSON.stringify(options.env.CODEX_FOUNDRY_MODEL)}`,
       "-c",
       'model_provider="azure"',
       "-c",
       'model_providers.azure.name="Azure OpenAI"',
       "-c",
-      `model_providers.azure.base_url=${JSON.stringify(process.env.CODEX_FOUNDRY_BASE_URL)}`,
+      `model_providers.azure.base_url=${JSON.stringify(options.env.CODEX_FOUNDRY_BASE_URL)}`,
       "-c",
       'model_providers.azure.env_key="AZURE_OPENAI_API_KEY"',
       "-c",
       'model_providers.azure.wire_api="responses"'
     ] : DEFAULT_CODEX_ARGS);
     this.args = [...baseArgs, ...(options.configOverrides ?? []).flatMap((override) => ["-c", override])];
-    this.env = options.env ?? buildCodexAgentEnv();
-    this.cwd = options.cwd ?? ENGINE_ENV.WORKSPACE_ROOT;
+    this.env = options.env;
+    this.cwd = options.cwd;
   }
   on(event, listener) {
     this.emitter.on(event, listener);
@@ -6213,12 +6028,12 @@ var AppServerProcess = class {
     console.warn(`[AppServerProcess] upgraded codex CLI to ${MIN_CODEX_CLI_VERSION}`);
   }
   async loginWithConfiguredApiKey(client) {
-    if (ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD !== "api_key" || !ENGINE_ENV.OPENAI_API_KEY) {
+    if (this.env.REPLICAS_CODEX_AUTH_METHOD !== "api_key" || !this.env.OPENAI_API_KEY) {
       return;
     }
     const params = {
       type: "apiKey",
-      apiKey: ENGINE_ENV.OPENAI_API_KEY
+      apiKey: this.env.OPENAI_API_KEY
     };
     await client.request(ACCOUNT_LOGIN_START_METHOD, params);
   }
@@ -6237,6 +6052,43 @@ var AppServerProcess = class {
   }
 };
 
+// src/managers/codex-asp/notification-dispatch.ts
+var TURN_STARTED_METHOD = "turn/started";
+var TURN_COMPLETED_METHOD = "turn/completed";
+var TURN_PLAN_UPDATED_METHOD = "turn/plan/updated";
+var THREAD_GOAL_UPDATED_METHOD = "thread/goal/updated";
+var THREAD_GOAL_CLEARED_METHOD = "thread/goal/cleared";
+var ITEM_STARTED_METHOD = "item/started";
+var ITEM_COMPLETED_METHOD = "item/completed";
+var AGENT_MESSAGE_DELTA_METHOD = "item/agentMessage/delta";
+var REASONING_SUMMARY_TEXT_DELTA_METHOD = "item/reasoning/summaryTextDelta";
+var REASONING_TEXT_DELTA_METHOD = "item/reasoning/textDelta";
+var REASONING_SUMMARY_PART_ADDED_METHOD = "item/reasoning/summaryPartAdded";
+var COMMAND_EXECUTION_OUTPUT_DELTA_METHOD = "item/commandExecution/outputDelta";
+var FILE_CHANGE_OUTPUT_DELTA_METHOD = "item/fileChange/outputDelta";
+var ACCOUNT_RATE_LIMITS_UPDATED_METHOD = "account/rateLimits/updated";
+var THREAD_TOKEN_USAGE_UPDATED_METHOD = "thread/tokenUsage/updated";
+var THREAD_COMPACTED_METHOD = "thread/compacted";
+function dispatchAspNotification(notification, handlers) {
+  const handler = handlers[notification.method];
+  if (!handler) return;
+  handler(notification);
+}
+function recoverCompletedTurn(turn, completedItems, agentMessageDeltas) {
+  const items = turn.items.length > 0 ? [...turn.items] : [];
+  const itemIds = new Set(items.map((item) => item.id));
+  for (const item of completedItems) {
+    if (itemIds.has(item.id)) continue;
+    items.push(item);
+    itemIds.add(item.id);
+  }
+  for (const [itemId, text] of agentMessageDeltas) {
+    if (itemIds.has(itemId)) continue;
+    items.push({ type: "agentMessage", id: itemId, text, phase: null, memoryCitation: null });
+  }
+  return items.length > 0 ? { ...turn, items, itemsView: "full" } : turn;
+}
+
 export {
   isRecord,
   TIMEOUT,
@@ -6249,6 +6101,7 @@ export {
   VALID_THINKING_LEVELS,
   codexReasoningEffortForThinkingLevel,
   detectAgentQuotaLimit,
+  agentCredentialSnapshotSchema,
   isAgentChatTurnActivityRecord,
   isAgentChatSkillActivityRecord,
   isAgentChatMcpActivityRecord,
@@ -6277,6 +6130,9 @@ export {
   CLAUDE_HAIKU_4_5_MODEL,
   CLAUDE_FABLE_5_BEDROCK_MODEL,
   CLAUDE_OPUS_5_BEDROCK_MODEL,
+  CLAUDE_OPUS_4_8_BEDROCK_MODEL,
+  CLAUDE_SONNET_5_BEDROCK_MODEL,
+  CLAUDE_HAIKU_4_5_BEDROCK_MODEL,
   DEFAULT_CLAUDE_MODEL,
   DEFAULT_CODEX_MODEL,
   DEFAULT_CURSOR_MODEL,
@@ -6301,7 +6157,10 @@ export {
   clampTokensToWindow,
   buildCodexTokenUsageContextUsagePayload,
   SANDBOX_PATHS,
+  REPLICAS_RUNTIME_ENV_ALIASES,
+  readReplicasRuntimeEnv,
   shellQuotePosix,
+  parsePosixEnvFile,
   GIT_CREDENTIAL_HELPER_FILENAME,
   GITHUB_CREDENTIAL_REFRESH_PATH,
   GITLAB_CREDENTIAL_REFRESH_PATH,
@@ -6382,14 +6241,27 @@ export {
   isUnsafeMemoryOutput,
   isSkillRegistryManifest,
   putPresignedFile,
-  isRecord4 as isRecord2,
-  IS_WARMING_MODE,
-  ENGINE_ENV,
-  setAgentCredentialSnapshot,
-  resolveClaudeAuthMethodForMessage,
-  buildClaudeAgentEnv,
+  buildCodexAgentEnv,
   execAsync,
   execFileAsync,
   SUBPROCESS_MAX_BUFFER,
-  AppServerProcess
+  AppServerProcess,
+  TURN_STARTED_METHOD,
+  TURN_COMPLETED_METHOD,
+  TURN_PLAN_UPDATED_METHOD,
+  THREAD_GOAL_UPDATED_METHOD,
+  THREAD_GOAL_CLEARED_METHOD,
+  ITEM_STARTED_METHOD,
+  ITEM_COMPLETED_METHOD,
+  AGENT_MESSAGE_DELTA_METHOD,
+  REASONING_SUMMARY_TEXT_DELTA_METHOD,
+  REASONING_TEXT_DELTA_METHOD,
+  REASONING_SUMMARY_PART_ADDED_METHOD,
+  COMMAND_EXECUTION_OUTPUT_DELTA_METHOD,
+  FILE_CHANGE_OUTPUT_DELTA_METHOD,
+  ACCOUNT_RATE_LIMITS_UPDATED_METHOD,
+  THREAD_TOKEN_USAGE_UPDATED_METHOD,
+  THREAD_COMPACTED_METHOD,
+  dispatchAspNotification,
+  recoverCompletedTurn
 };

package/dist/src/headless-agent.js

@@ -2,10 +2,12 @@
 import {
   AGENT,
   AppServerProcess,
+  buildCodexAgentEnv,
   headlessAgentRequestSchema,
   isUnsafeMemoryOutput,
-  putPresignedFile
-} from "./chunk-3CX4NHQA.js";
+  putPresignedFile,
+  recoverCompletedTurn
+} from "./chunk-Z4OLZBZN.js";
 
 // src/headless-agent.ts
 import { createHash } from "crypto";
@@ -57,7 +59,7 @@ async function publishFilesystemOutputs(request) {
   for (const output of request.outputFiles) {
     const filePath = resolveFile(request.workingDirectory, output.path);
     const content = (await readFile(filePath, "utf8")).trim();
-    if (isUnsafeMemoryOutput(content, request.sensitiveValues, output.maxChars)) {
+    if (output.minChars !== void 0 && content.length < output.minChars || isUnsafeMemoryOutput(content, request.sensitiveValues, output.maxChars)) {
       throw new Error(`Headless agent output failed validation: ${output.path}`);
     }
     await writeFile(filePath, content, { mode: 384 });
@@ -120,15 +122,32 @@ async function runClaude(request) {
 }
 function runCodexTurn(client, params, timeoutMs) {
   return new Promise((resolve, reject) => {
+    const completedItems = [];
+    const messageDeltas = /* @__PURE__ */ new Map();
     const cleanup = () => {
       clearTimeout(timeout);
       client.off("notification", onNotification);
       client.off("dispose", onDispose);
     };
     const onNotification = (notification) => {
+      if (notification.method === "item/completed") {
+        if (notification.params.threadId !== params.threadId || notification.params.item.type !== "agentMessage") return;
+        completedItems.push(notification.params.item);
+        return;
+      }
+      if (notification.method === "item/agentMessage/delta") {
+        if (notification.params.threadId !== params.threadId) return;
+        messageDeltas.set(
+          notification.params.itemId,
+          (messageDeltas.get(notification.params.itemId) ?? "") + notification.params.delta
+        );
+        return;
+      }
       if (notification.method !== "turn/completed" || notification.params.threadId !== params.threadId) return;
+      const turn = recoverCompletedTurn(notification.params.turn, completedItems, messageDeltas);
+      const message = turn.items.findLast((item) => item.type === "agentMessage")?.text ?? null;
       cleanup();
-      resolve(notification.params.turn);
+      resolve({ turn, message });
     };
     const onDispose = (error) => {
       cleanup();
@@ -149,6 +168,7 @@ function runCodexTurn(client, params, timeoutMs) {
 async function runCodex(request) {
   const appServer = new AppServerProcess({
     cwd: request.workingDirectory,
+    env: buildCodexAgentEnv(),
     configOverrides: ["shell_environment_policy.inherit=none", "tools.web_search=false"]
   });
   try {
@@ -162,24 +182,19 @@ async function runCodex(request) {
       approvalPolicy: "never",
       approvalsReviewer: "user",
       sandbox: request.mode === "filesystem" ? "workspace-write" : "read-only",
-      ephemeral: true,
-      environments: [],
-      dynamicTools: [],
-      selectedCapabilityRoots: []
+      ephemeral: true
     });
-    const turn = await runCodexTurn(client, {
+    const { turn, message } = await runCodexTurn(client, {
       threadId: thread.thread.id,
       input: [{ type: "text", text: request.prompt, text_elements: [] }],
       ...request.mode === "structured" ? { outputSchema: request.outputSchema } : {},
       approvalPolicy: "never",
-      approvalsReviewer: "user",
-      environments: []
+      approvalsReviewer: "user"
     }, request.timeoutSeconds * 1e3);
     if (turn.status === "failed") throw new Error(turn.error?.message ?? "Codex ASP turn failed");
-    const message = turn.items.findLast((item) => item.type === "agentMessage");
-    if (!message || message.type !== "agentMessage") throw new Error("Codex ASP returned no final message");
-    if (request.mode === "filesystem") return message.text;
-    return JSON.parse(message.text);
+    if (!message) throw new Error("Codex ASP returned no final message");
+    if (request.mode === "filesystem") return message;
+    return JSON.parse(message);
   } finally {
     await appServer.stop();
   }