@sentry/junior 0.110.0 → 0.111.0

package/dist/{chunk-W6RJZG7F.js → chunk-B45FPP2A.js}

@@ -1,19 +1,21 @@
 import {
   SANDBOX_WORKSPACE_ROOT,
   getStateAdapter
-} from "./chunk-GK47NBDE.js";
+} from "./chunk-PYKKM4MM.js";
 import {
   sleep
 } from "./chunk-4ZNGQH7C.js";
 import {
   toOptionalTrimmed
-} from "./chunk-WNOVRQ67.js";
+} from "./chunk-NQLWOTY4.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-3TV7OEHL.js";
+} from "./chunk-WSRBFHPX.js";
 import {
+  setSpanAttributes,
+  setSpanStatus,
   withSpan
-} from "./chunk-IYKPU7H6.js";
+} from "./chunk-J7APPQIJ.js";
 
 // src/chat/sandbox/runtime-dependencies.ts
 var GLOBAL_RUNTIME_DEPENDENCIES = [
@@ -105,37 +107,303 @@ function getVercelSandboxCredentials() {
 }
 
 // src/chat/sandbox/workspace.ts
-function createSandboxInstance(sandbox) {
+import {
+  FileSystem
+} from "@vercel/sandbox";
+
+// src/chat/sandbox/http-error-details.ts
+var DEFAULT_PREVIEW_LIMIT = 512;
+function toTrimmedString(value, maxChars) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim();
+  if (!normalized) {
+    return void 0;
+  }
+  return normalized.length > maxChars ? `${normalized.slice(0, maxChars)}\u2026` : normalized;
+}
+function extractHttpErrorDetails(error, options = {}) {
+  const prefix = options.attributePrefix ?? "app.http_error";
+  const previewLimit = options.previewLimit ?? DEFAULT_PREVIEW_LIMIT;
+  const normalizedError = error instanceof Error ? error : new Error(String(error));
+  const err = error ?? {};
+  const attributes = {
+    "error.type": normalizedError.name || "Error",
+    "exception.message": toTrimmedString(normalizedError.message, previewLimit) ?? "HTTP error"
+  };
+  const response = err.response;
+  const statusCode = typeof response?.status === "number" ? response.status : void 0;
+  const statusText = toTrimmedString(response?.statusText, previewLimit);
+  const responseUrl = toTrimmedString(response?.url, previewLimit);
+  const responseText = toTrimmedString(err.text, previewLimit);
+  const responseJson = toTrimmedString(
+    err.json && typeof err.json === "object" ? JSON.stringify(err.json) : void 0,
+    previewLimit
+  );
+  const contentType = toTrimmedString(
+    response?.headers?.get?.("content-type"),
+    previewLimit
+  );
+  const requestIdHeader = toTrimmedString(
+    response?.headers?.get?.("x-request-id"),
+    previewLimit
+  );
+  const vercelIdHeader = toTrimmedString(
+    response?.headers?.get?.("x-vercel-id"),
+    previewLimit
+  );
+  const requestId = requestIdHeader ?? vercelIdHeader;
+  if (statusCode !== void 0) {
+    attributes["http.response.status_code"] = statusCode;
+  }
+  if (statusText) {
+    attributes[`${prefix}.status_text`] = statusText;
+  }
+  if (responseUrl) {
+    attributes["url.full"] = responseUrl;
+  }
+  if (contentType) {
+    attributes["http.response.header.content-type"] = [contentType];
+  }
+  if (requestIdHeader) {
+    attributes["http.response.header.x-request-id"] = [requestIdHeader];
+  }
+  if (vercelIdHeader) {
+    attributes["http.response.header.x-vercel-id"] = [vercelIdHeader];
+  }
+  if (responseText) {
+    attributes[`${prefix}.response_text_preview`] = responseText;
+    attributes[`${prefix}.response_text_length`] = responseText.length;
+  }
+  if (responseJson) {
+    attributes[`${prefix}.response_json_preview`] = responseJson;
+  }
+  const summaryParts = [];
+  if (statusCode !== void 0) {
+    summaryParts.push(`status=${statusCode}`);
+  }
+  if (statusText) {
+    summaryParts.push(`statusText=${statusText}`);
+  }
+  if (responseUrl) {
+    summaryParts.push(`url=${responseUrl}`);
+  }
+  if (requestId) {
+    summaryParts.push(`requestId=${requestId}`);
+  }
+  for (const field of options.extraFields ?? []) {
+    const value = toTrimmedString(err[field.sourceKey], previewLimit);
+    if (!value) {
+      continue;
+    }
+    attributes[`${prefix}.${field.attributeKey}`] = value;
+    summaryParts.push(`${field.summaryKey ?? field.attributeKey}=${value}`);
+  }
+  if (responseJson) {
+    summaryParts.push(`json=${responseJson}`);
+  } else if (responseText) {
+    summaryParts.push(`text=${responseText}`);
+  }
+  const searchableText = `${normalizedError.message} ${responseText ?? ""} ${responseJson ?? ""}`.toLowerCase();
+  return {
+    attributes,
+    summary: summaryParts.join(", "),
+    searchableText
+  };
+}
+
+// src/chat/sandbox/errors.ts
+var SANDBOX_ERROR_FIELDS = [
+  {
+    sourceKey: "sandboxId",
+    attributeKey: "sandbox_id",
+    summaryKey: "sandboxId"
+  }
+];
+function getSandboxErrorDetails(error) {
+  return extractHttpErrorDetails(error, {
+    attributePrefix: "app.sandbox.api_error",
+    extraFields: [...SANDBOX_ERROR_FIELDS]
+  });
+}
+function findInErrorChain(error, predicate) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current && !seen.has(current)) {
+    if (predicate(current)) {
+      return true;
+    }
+    seen.add(current);
+    current = typeof current === "object" ? current.cause : void 0;
+  }
+  return false;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isInvalidSandboxSessionError(error) {
+  if (!isRecord(error)) {
+    return false;
+  }
+  if (isRecord(error.json) && error.json.invalidToken === true) {
+    return true;
+  }
+  const response = error.response;
+  return isRecord(response) && response.status === 403 && typeof response.url === "string" && response.url.includes("/sandboxes/sessions");
+}
+function getFirstErrorMessage(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current && !seen.has(current)) {
+    if (current instanceof Error) {
+      const message = current.message.trim();
+      if (message) {
+        return message;
+      }
+    }
+    seen.add(current);
+    current = typeof current === "object" ? current.cause : void 0;
+  }
+  return void 0;
+}
+function isAlreadyExistsError(error) {
+  const details = getSandboxErrorDetails(error);
+  return details.searchableText.includes("already exists") || details.searchableText.includes("file exists") || details.searchableText.includes("eexist");
+}
+function isSandboxUnavailableError(error) {
+  return findInErrorChain(error, (candidate) => {
+    if (isInvalidSandboxSessionError(candidate)) {
+      return true;
+    }
+    const details = getSandboxErrorDetails(candidate);
+    const searchable = `${details.searchableText} ${details.summary}`.toLowerCase();
+    return searchable.includes("sandbox_stopped") || searchable.includes("status=410") || searchable.includes("status code 410") || searchable.includes("no longer available") || searchable.includes("stream was closed and is not accepting commands");
+  });
+}
+function isSandboxMissingError(error) {
+  return findInErrorChain(error, (candidate) => {
+    const details = getSandboxErrorDetails(candidate);
+    const searchable = `${details.searchableText} ${details.summary}`.toLowerCase();
+    return searchable.includes("status=404") || searchable.includes("status code 404") || searchable.includes("snapshot_not_found");
+  });
+}
+function isSnapshottingError(error) {
+  return findInErrorChain(error, (candidate) => {
+    const details = getSandboxErrorDetails(candidate);
+    const searchable = `${details.searchableText} ${details.summary}`.toLowerCase();
+    return searchable.includes("sandbox_snapshotting") || searchable.includes("creating a snapshot") || searchable.includes("stopped shortly");
+  });
+}
+function isSandboxCommandStreamInterruptedError(error) {
+  return findInErrorChain(error, (candidate) => {
+    if (!(candidate instanceof Error)) {
+      return false;
+    }
+    return candidate.name === "StreamError" && candidate.message.toLowerCase().includes("stream ended before command finished");
+  });
+}
+function wrapSandboxSetupError(error) {
+  try {
+    const details = getSandboxErrorDetails(error);
+    if (details.summary) {
+      return new Error(`sandbox setup failed (${details.summary})`, {
+        cause: error
+      });
+    }
+  } catch {
+  }
+  let causeMessage;
+  try {
+    causeMessage = getFirstErrorMessage(error);
+  } catch (cause) {
+    causeMessage = cause instanceof Error ? cause.message : void 0;
+  }
+  if (causeMessage && causeMessage.trim() && causeMessage !== "sandbox setup failed") {
+    const oneLine = causeMessage.replace(/\s+/g, " ").trim();
+    return new Error(`sandbox setup failed (${oneLine})`, { cause: error });
+  }
+  return new Error("sandbox setup failed", { cause: error });
+}
+function throwSandboxOperationError(action, error, includeMissingPath = false) {
+  const details = getSandboxErrorDetails(error);
+  setSpanAttributes({
+    ...details.attributes,
+    ...includeMissingPath ? {
+      "app.sandbox.api_error.missing_path": details.searchableText.includes("no such file") || details.searchableText.includes("enoent")
+    } : {},
+    "app.sandbox.success": false
+  });
+  setSpanStatus("error");
+  throw new Error(
+    details.summary ? `${action} failed (${details.summary})` : `${action} failed`,
+    {
+      cause: error
+    }
+  );
+}
+
+// src/chat/sandbox/workspace.ts
+function createSandboxSession(sandbox, options) {
+  const session = sandbox.currentSession();
+  const fileSystem = new FileSystem(session);
+  const run = async (operation) => {
+    try {
+      return await operation();
+    } catch (error) {
+      if (isSandboxUnavailableError(error)) {
+        options?.onUnavailable?.(session.sessionId);
+      }
+      throw error;
+    }
+  };
+  const fs = {
+    readFile: async (filePath, readOptions) => await run(async () => await fileSystem.readFile(filePath, readOptions)),
+    writeFile: async (filePath, content, writeOptions) => await run(
+      async () => await fileSystem.writeFile(filePath, content, writeOptions)
+    ),
+    readdir: async (filePath) => await run(async () => await fileSystem.readdir(filePath)),
+    stat: async (filePath) => await run(async () => await fileSystem.stat(filePath))
+  };
   return {
     sandboxId: sandbox.name,
-    get sandboxEgressId() {
-      return sandbox.currentSession().sessionId;
-    },
-    fs: sandbox.fs,
+    sessionId: session.sessionId,
+    fs,
     extendTimeout(duration) {
-      return sandbox.extendTimeout(duration);
+      return run(async () => await session.extendTimeout(duration));
     },
     mkDir(path) {
-      return sandbox.mkDir(path);
+      return run(async () => await session.mkDir(path));
     },
     readFileToBuffer(input) {
-      return sandbox.readFileToBuffer(input);
+      return run(async () => await session.readFileToBuffer(input));
     },
-    runCommand(input) {
-      return sandbox.runCommand(input);
+    async runCommand(input) {
+      const result = await run(async () => await session.runCommand(input));
+      const [stdout, stderr] = await Promise.all([
+        run(async () => await result.stdout()),
+        run(async () => await result.stderr())
+      ]);
+      return {
+        exitCode: result.exitCode,
+        stdout,
+        stderr
+      };
     },
-    async snapshot() {
-      const snapshot = await sandbox.snapshot();
-      return { snapshotId: snapshot.snapshotId };
+    snapshot() {
+      return run(async () => {
+        const snapshot = await session.snapshot();
+        return { snapshotId: snapshot.snapshotId };
+      });
     },
     stop() {
-      return sandbox.stop();
+      return run(async () => await session.stop());
     },
     update(params) {
-      return sandbox.update(params);
+      return run(async () => await session.update(params));
     },
     writeFiles(files) {
-      return sandbox.writeFiles(files);
+      return run(async () => await session.writeFiles(files));
     }
   };
 }
@@ -258,8 +526,8 @@ async function runOrThrow(sandbox, params, label) {
   if (result.exitCode === 0) {
     return;
   }
-  const stderr = (await result.stderr()).trim();
-  const stdout = (await result.stdout()).trim();
+  const stderr = result.stderr.trim();
+  const stdout = result.stdout.trim();
   const detail = stderr || stdout || "command failed";
   throw new Error(`${label} failed: ${detail}`);
 }
@@ -268,8 +536,8 @@ async function tryRun(sandbox, params) {
   if (result.exitCode === 0) {
     return { ok: true };
   }
-  const stderr = (await result.stderr()).trim();
-  const stdout = (await result.stdout()).trim();
+  const stderr = result.stderr.trim();
+  const stdout = result.stdout.trim();
   return { ok: false, detail: stderr || stdout || "command failed" };
 }
 async function installGhCliViaDnf(sandbox) {
@@ -368,8 +636,8 @@ async function installRuntimeDependencies(sandbox, deps) {
               cmd: "sha256sum",
               args: [rpmPath]
             });
-            const checksumStdout = (await checksumResult.stdout()).trim();
-            const checksumStderr = (await checksumResult.stderr()).trim();
+            const checksumStdout = checksumResult.stdout.trim();
+            const checksumStderr = checksumResult.stderr.trim();
             if (checksumResult.exitCode !== 0) {
               throw new Error(
                 `sha256sum failed: ${checksumStderr || checksumStdout || "command failed"}`
@@ -460,8 +728,8 @@ async function runRuntimePostinstall(sandbox, commands) {
         if (result.exitCode === 0) {
           continue;
         }
-        const stderr = (await result.stderr()).trim();
-        const stdout = (await result.stdout()).trim();
+        const stderr = result.stderr.trim();
+        const stdout = result.stdout.trim();
         const detail = stderr || stdout || "command failed";
         throw new Error(`runtime-postinstall ${command.cmd} failed: ${detail}`);
       }
@@ -479,7 +747,7 @@ async function createDependencySnapshot(profile, runtime, timeoutMs) {
     async () => {
       const sandboxCredentials = getVercelSandboxCredentials();
       const resources = getSandboxResources();
-      const sandbox = createSandboxInstance(
+      const sandbox = createSandboxSession(
         await Sandbox.create({
           timeout: timeoutMs,
           runtime,
@@ -697,12 +965,19 @@ function isSnapshotMissingError(error) {
 }
 
 export {
+  isAlreadyExistsError,
+  isSandboxUnavailableError,
+  isSandboxMissingError,
+  isSnapshottingError,
+  isSandboxCommandStreamInterruptedError,
+  wrapSandboxSetupError,
+  throwSandboxOperationError,
+  getVercelSandboxCredentials,
   buildNonInteractiveShellScript,
   runNonInteractiveCommand,
-  getVercelSandboxCredentials,
   getSandboxResources,
   GLOBAL_RUNTIME_DEPENDENCIES,
-  createSandboxInstance,
+  createSandboxSession,
   getRuntimeDependencyProfileHash,
   resolveRuntimeDependencySnapshot,
   isSnapshotMissingError

package/dist/{chunk-SBOBTS27.js → chunk-BTRNMS6A.js}

@@ -1,9 +1,9 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-3TV7OEHL.js";
+} from "./chunk-WSRBFHPX.js";
 import {
   logWarn
-} from "./chunk-IYKPU7H6.js";
+} from "./chunk-J7APPQIJ.js";
 import {
   skillRoots
 } from "./chunk-3V7OFJZC.js";

package/dist/{chunk-L5XQPJ7T.js → chunk-IFAHK54X.js}

@@ -3,13 +3,13 @@ import {
 } from "./chunk-4ZNGQH7C.js";
 import {
   getSlackBotToken
-} from "./chunk-WNOVRQ67.js";
+} from "./chunk-NQLWOTY4.js";
 import {
   logWarn,
   setSpanAttributes,
   setSpanStatus,
   withSpan
-} from "./chunk-IYKPU7H6.js";
+} from "./chunk-J7APPQIJ.js";
 import {
   parseSlackChannelReferenceId
 } from "./chunk-42WRQLJ6.js";

package/dist/{chunk-IYKPU7H6.js → chunk-J7APPQIJ.js}

@@ -13,7 +13,7 @@ import {
 } from "./chunk-6GWA276C.js";
 import {
   getDeploymentTelemetryAttributes
-} from "./chunk-W75ZPAGG.js";
+} from "./chunk-MPVES2IC.js";
 
 // src/chat/logging.ts
 import path from "path";

package/dist/{chunk-3S7YYHBI.js → chunk-L6JPKANW.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-2ZTTXTSZ.js";
 import {
   normalizeSlackConversationId
-} from "./chunk-L5XQPJ7T.js";
+} from "./chunk-IFAHK54X.js";
 import {
   parseSlackThreadId
 } from "./chunk-6Y5L4BOM.js";

package/dist/{chunk-W75ZPAGG.js → chunk-MPVES2IC.js}

@@ -1,6 +1,6 @@
 import {
   JUNIOR_VERSION
-} from "./chunk-ZKIOWEFL.js";
+} from "./chunk-Z4G3WCP3.js";
 
 // src/deployment.ts
 var JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";

package/dist/{chunk-WNOVRQ67.js → chunk-NQLWOTY4.js}

@@ -12,7 +12,7 @@ import {
   normalizeGenAiFinishReason,
   serializeGenAiAttribute,
   withSpan
-} from "./chunk-IYKPU7H6.js";
+} from "./chunk-J7APPQIJ.js";
 
 // src/chat/xml.ts
 function escapeXml(value) {
@@ -172,7 +172,7 @@ function stripRuntimeTurnContext(messages) {
 }
 
 // src/chat/config.ts
-import { getModel } from "@earendil-works/pi-ai/compat";
+import { getModel as getModel2 } from "@earendil-works/pi-ai/compat";
 
 // src/chat/optional-string.ts
 function toOptionalTrimmed(value) {
@@ -187,7 +187,9 @@ function toOptionalTrimmed(value) {
 import {
   completeSimple,
   getEnvApiKey,
+  getModel,
   getModels,
+  isRetryableAssistantError,
   registerApiProvider
 } from "@earendil-works/pi-ai/compat";
 import {
@@ -592,6 +594,7 @@ var DEFAULT_SLACK_SLASH_COMMAND = "/jr";
 var DEFAULT_PROCESSING_REACTION_EMOJI = "eyes";
 var DEFAULT_COMPLETED_REACTION_EMOJI = "white_check_mark";
 var FUNCTION_TIMEOUT_BUFFER_SECONDS = 20;
+var CONVERSATION_WORK_SOFT_YIELD_BUFFER_SECONDS = 40;
 var DEFAULT_ASSISTANT_LOADING_MESSAGES = [
   "Consulting the orb",
   "Bribing the gremlins",
@@ -616,13 +619,14 @@ function parseAgentTurnTimeoutMs(rawValue, maxTimeoutMs) {
   }
   return Math.max(MIN_AGENT_TURN_TIMEOUT_MS, Math.min(value, maxTimeoutMs));
 }
-function resolveFunctionMaxDurationSeconds(env) {
-  const raw = env.FUNCTION_MAX_DURATION_SECONDS ?? env.QUEUE_CALLBACK_MAX_DURATION_SECONDS;
-  const value = Number.parseInt(raw ?? "", 10);
-  if (Number.isNaN(value) || value <= 0) {
-    return DEFAULT_FUNCTION_MAX_DURATION_SECONDS;
-  }
-  return value;
+function resolveFunctionMaxDurationSeconds(functionMaxDurationSeconds) {
+  return functionMaxDurationSeconds ?? DEFAULT_FUNCTION_MAX_DURATION_SECONDS;
+}
+function resolveConversationWorkSoftYieldAfterMs(functionMaxDurationSeconds) {
+  return Math.max(
+    MIN_AGENT_TURN_TIMEOUT_MS,
+    (functionMaxDurationSeconds - CONVERSATION_WORK_SOFT_YIELD_BUFFER_SECONDS) * 1e3
+  );
 }
 function resolveMaxTurnTimeoutMs(functionMaxDurationSeconds) {
   const budgetSeconds = functionMaxDurationSeconds - FUNCTION_TIMEOUT_BUFFER_SECONDS;
@@ -669,16 +673,21 @@ function parseSlashCommand(rawValue) {
   }
   return command;
 }
-var DEFAULT_MODEL_ID = getModel("vercel-ai-gateway", "xai/grok-4.5").id;
-var DEFAULT_FAST_MODEL_ID = getModel(
+var DEFAULT_MODEL_ID = getModel2("vercel-ai-gateway", "xai/grok-4.5").id;
+var DEFAULT_FAST_MODEL_ID = getModel2(
   "vercel-ai-gateway",
   "anthropic/claude-haiku-4.5"
 ).id;
-var DEFAULT_HANDOFF_MODEL_ID = getModel(
+var DEFAULT_HANDOFF_MODEL_ID = getModel2(
   "vercel-ai-gateway",
   "openai/gpt-5.6-sol"
 ).id;
+var DEFAULT_WEB_SEARCH_MODEL_ID = getModel2(
+  "vercel-ai-gateway",
+  "openai/gpt-5.4"
+).id;
 var DEFAULT_EMBEDDING_MODEL_ID = "openai/text-embedding-3-small";
+var DEFAULT_IMAGE_GENERATION_MODEL_ID = "google/gemini-3-pro-image";
 function validateGatewayModelId(raw) {
   const trimmed = toOptionalTrimmed(raw);
   if (trimmed === void 0) return void 0;
@@ -742,8 +751,7 @@ function parseReactionEmoji(envName, rawValue, defaultEmoji) {
   }
   return normalized;
 }
-function readBotConfig(env) {
-  const functionMaxDurationSeconds = resolveFunctionMaxDurationSeconds(env);
+function readBotConfig(env, functionMaxDurationSeconds) {
   const maxTurnTimeoutMs = resolveMaxTurnTimeoutMs(functionMaxDurationSeconds);
   const modelId = validateGatewayModelId(env.AI_MODEL) ?? DEFAULT_MODEL_ID;
   const reasoningLevel = toOptionalTrimmed(env.AI_REASONING_LEVEL);
@@ -758,6 +766,7 @@ function readBotConfig(env) {
     ),
     reasoningLevel: reasoningLevel === void 0 ? void 0 : parseTurnReasoningLevel(reasoningLevel),
     fastModelId,
+    imageGenerationModelId: toOptionalTrimmed(env.AI_IMAGE_MODEL) ?? DEFAULT_IMAGE_GENERATION_MODEL_ID,
     embeddingModelId: validateEmbeddingModelId(env.AI_EMBEDDING_MODEL) ?? DEFAULT_EMBEDDING_MODEL_ID,
     loadingMessages: parseLoadingMessages(env.JUNIOR_LOADING_MESSAGES),
     visionModelId: validateGatewayModelId(env.AI_VISION_MODEL),
@@ -765,7 +774,8 @@ function readBotConfig(env) {
     turnTimeoutMs: parseAgentTurnTimeoutMs(
       env.AGENT_TURN_TIMEOUT_MS,
       maxTurnTimeoutMs
-    )
+    ),
+    webSearchModelId: validateGatewayModelId(env.AI_WEB_SEARCH_MODEL) ?? DEFAULT_WEB_SEARCH_MODEL_ID
   };
 }
 function readDatabaseUrl(env) {
@@ -796,11 +806,17 @@ function readSqlDriver(env, databaseUrl) {
   }
   throw new Error("JUNIOR_DATABASE_DRIVER must be postgres or neon");
 }
-function readChatConfig(env = process.env) {
+function readChatConfig(env = process.env, functionMaxDurationSeconds = DEFAULT_FUNCTION_MAX_DURATION_SECONDS) {
   const databaseUrl = readDatabaseUrl(env);
+  const resolvedFunctionMaxDurationSeconds = resolveFunctionMaxDurationSeconds(
+    functionMaxDurationSeconds
+  );
   return {
-    bot: readBotConfig(env),
-    functionMaxDurationSeconds: resolveFunctionMaxDurationSeconds(env),
+    bot: readBotConfig(env, resolvedFunctionMaxDurationSeconds),
+    functionMaxDurationSeconds: resolvedFunctionMaxDurationSeconds,
+    conversationWorkSoftYieldAfterMs: resolveConversationWorkSoftYieldAfterMs(
+      resolvedFunctionMaxDurationSeconds
+    ),
     sql: {
       databaseUrl,
       driver: readSqlDriver(env, databaseUrl)
@@ -822,6 +838,17 @@ function readChatConfig(env = process.env) {
   };
 }
 var chatConfig = readChatConfig(process.env);
+function configureFunctionMaxDurationSeconds(functionMaxDurationSeconds) {
+  const resolved = resolveFunctionMaxDurationSeconds(
+    functionMaxDurationSeconds
+  );
+  chatConfig.functionMaxDurationSeconds = resolved;
+  chatConfig.conversationWorkSoftYieldAfterMs = resolveConversationWorkSoftYieldAfterMs(resolved);
+  chatConfig.bot.turnTimeoutMs = parseAgentTurnTimeoutMs(
+    process.env.AGENT_TURN_TIMEOUT_MS,
+    resolveMaxTurnTimeoutMs(resolved)
+  );
+}
 function getChatConfig() {
   return chatConfig;
 }
@@ -910,6 +937,7 @@ export {
   standardModelId,
   profileConfig,
   FUNCTION_TIMEOUT_BUFFER_SECONDS,
+  configureFunctionMaxDurationSeconds,
   getChatConfig,
   botConfig,
   getSlackBotToken,