@sentry/junior 0.74.1 → 0.76.0

package/dist/chunk-RV5RYIJW.js

@@ -0,0 +1,56 @@
+// src/cli/env.ts
+import fs from "fs";
+import path from "path";
+function envFileNames(nodeEnv) {
+  return [
+    `.env.${nodeEnv}.local`,
+    ...nodeEnv === "test" ? [] : [".env.local"],
+    `.env.${nodeEnv}`,
+    ".env",
+    ".env.example"
+  ];
+}
+function hasEnvRootMarker(dir) {
+  return fs.existsSync(path.join(dir, "package.json")) || fs.existsSync(path.join(dir, "pnpm-workspace.yaml"));
+}
+function resolveCliEnvRoots(cwd) {
+  const roots = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addRoot = (candidate) => {
+    const resolved = path.resolve(candidate);
+    if (seen.has(resolved)) {
+      return;
+    }
+    seen.add(resolved);
+    roots.push(resolved);
+  };
+  let current = path.resolve(cwd);
+  addRoot(current);
+  while (true) {
+    if (hasEnvRootMarker(current)) {
+      addRoot(current);
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return roots;
+}
+function loadCliEnvFiles(cwd = process.cwd()) {
+  const nodeEnv = process.env.NODE_ENV ?? "development";
+  for (const root of resolveCliEnvRoots(cwd)) {
+    for (const envFile of envFileNames(nodeEnv)) {
+      const absolutePath = path.join(root, envFile);
+      if (!fs.existsSync(absolutePath)) {
+        continue;
+      }
+      process.loadEnvFile(absolutePath);
+    }
+  }
+}
+
+export {
+  loadCliEnvFiles
+};

package/dist/chunk-SG5WAA7H.js

@@ -0,0 +1,132 @@
+// src/plugins.ts
+function cloneManifests(manifests) {
+  return manifests ? structuredClone(manifests) : void 0;
+}
+function cloneInlineManifests(registrations) {
+  const inlineManifests = registrations.flatMap(
+    (plugin) => plugin.manifest ? [
+      {
+        manifest: {
+          ...structuredClone(plugin.manifest),
+          capabilities: plugin.manifest.capabilities?.map(
+            (capability) => capability.includes(".") ? capability : `${plugin.manifest.name}.${capability}`
+          ) ?? [],
+          configKeys: plugin.manifest.configKeys?.map(
+            (key) => key.includes(".") ? key : `${plugin.manifest.name}.${key}`
+          ) ?? [],
+          ...plugin.manifest.target ? {
+            target: {
+              ...plugin.manifest.target,
+              configKey: plugin.manifest.target.configKey.includes(".") ? plugin.manifest.target.configKey : `${plugin.manifest.name}.${plugin.manifest.target.configKey}`
+            }
+          } : {}
+        },
+        ...plugin.packageName ? { packageName: plugin.packageName } : {}
+      }
+    ] : []
+  );
+  return inlineManifests.length > 0 ? inlineManifests : void 0;
+}
+function assertUniquePluginNames(registrations) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const plugin of registrations) {
+    const name = plugin.manifest.name;
+    if (seen.has(name)) {
+      throw new Error(`Duplicate plugin registration name "${name}"`);
+    }
+    seen.add(name);
+  }
+}
+function assertUniquePackageNames(packageNames) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const packageName of packageNames) {
+    if (seen.has(packageName)) {
+      throw new Error(`Duplicate plugin package name "${packageName}"`);
+    }
+    seen.add(packageName);
+  }
+}
+function normalizePluginInput(input) {
+  if (typeof input === "string") {
+    return { packageName: input };
+  }
+  return { registration: input };
+}
+function defineJuniorPlugins(inputs, options = {}) {
+  const normalized = inputs.map(normalizePluginInput);
+  const packageNames = normalized.flatMap(
+    (input) => input.packageName ? [input.packageName] : []
+  );
+  const registrations = normalized.flatMap(
+    (input) => input.registration ? [input.registration] : []
+  );
+  assertUniquePackageNames(packageNames);
+  assertUniquePluginNames(registrations);
+  const manifests = cloneManifests(options.manifests);
+  return {
+    packageNames,
+    registrations: registrations.map((plugin) => ({ ...plugin })),
+    ...manifests ? { manifests } : {}
+  };
+}
+function pluginCatalogConfigFromPluginSet(pluginSet) {
+  if (!pluginSet) {
+    return void 0;
+  }
+  const packages = [
+    .../* @__PURE__ */ new Set([
+      ...pluginSet.packageNames,
+      ...pluginSet.registrations.flatMap(
+        (plugin) => plugin.packageName ? [plugin.packageName] : []
+      )
+    ])
+  ];
+  const manifests = cloneManifests(pluginSet.manifests);
+  const inlineManifests = cloneInlineManifests(pluginSet.registrations);
+  if (packages.length === 0 && !manifests && !inlineManifests) {
+    return void 0;
+  }
+  return {
+    ...inlineManifests ? { inlineManifests } : {},
+    ...packages.length > 0 ? { packages } : {},
+    ...manifests ? { manifests } : {}
+  };
+}
+function readEnvPluginPackages(env = process.env) {
+  const value = env.JUNIOR_PLUGIN_PACKAGES;
+  if (!value) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (error) {
+    throw new Error("JUNIOR_PLUGIN_PACKAGES must be valid JSON", {
+      cause: error
+    });
+  }
+  if (!Array.isArray(parsed) || parsed.some((item) => typeof item !== "string" || !item.trim())) {
+    throw new Error(
+      "JUNIOR_PLUGIN_PACKAGES must be a JSON array of package names"
+    );
+  }
+  return parsed;
+}
+function pluginCatalogConfigFromEnv(env = process.env) {
+  const packages = readEnvPluginPackages(env);
+  return packages ? { packages } : void 0;
+}
+function pluginRuntimeRegistrationsFromPluginSet(pluginSet) {
+  return pluginSet?.registrations.filter((plugin) => plugin.hooks || plugin.tasks) ?? [];
+}
+function pluginCliRegistrationsFromPluginSet(pluginSet) {
+  return pluginSet?.registrations.filter((plugin) => plugin.cli) ?? [];
+}
+
+export {
+  defineJuniorPlugins,
+  pluginCatalogConfigFromPluginSet,
+  pluginCatalogConfigFromEnv,
+  pluginRuntimeRegistrationsFromPluginSet,
+  pluginCliRegistrationsFromPluginSet
+};

package/dist/chunk-ST6YNAXG.js

@@ -0,0 +1,54 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/chat/sentry.ts
+var sentry_exports = {};
+__export(sentry_exports, {
+  captureException: () => captureException,
+  continueTrace: () => continueTrace,
+  flush: () => flush,
+  getClient: () => getClient,
+  getGlobalScope: () => getGlobalScope,
+  init: () => init,
+  setTag: () => setTag,
+  setUser: () => setUser,
+  startInactiveSpan: () => startInactiveSpan,
+  startSpan: () => startSpan,
+  vercelAIIntegration: () => vercelAIIntegration,
+  withActiveSpan: () => withActiveSpan,
+  withScope: () => withScope
+});
+import {
+  captureException,
+  continueTrace,
+  flush,
+  getClient,
+  getGlobalScope,
+  init,
+  setTag,
+  setUser,
+  startInactiveSpan,
+  startSpan,
+  vercelAIIntegration,
+  withActiveSpan,
+  withScope
+} from "@sentry/node";
+export * from "@sentry/node";
+
+export {
+  sentry_exports,
+  captureException,
+  continueTrace,
+  flush,
+  getClient,
+  getGlobalScope,
+  init,
+  setTag,
+  setUser,
+  startInactiveSpan,
+  startSpan,
+  vercelAIIntegration,
+  withActiveSpan,
+  withScope
+};

package/dist/{chunk-GM7HTXYC.js → chunk-T77LUIX3.js}

@@ -6,7 +6,7 @@ import {
   setSpanAttributes,
   toOptionalString,
   withSpan
-} from "./chunk-3BYAPS6B.js";
+} from "./chunk-EJN6G5A2.js";
 
 // src/chat/turn-context-tag.ts
 var TURN_CONTEXT_TAG = "runtime-turn-context";
@@ -166,47 +166,6 @@ function getUserMessageContent(message) {
 function isRuntimeTurnContextPart(part, marker) {
   return part !== null && typeof part === "object" && part.type === "text" && typeof part.text === "string" && part.text.startsWith(marker);
 }
-function prependRuntimeTurnContext(message, turnContextPrompt) {
-  const content = getUserMessageContent(message);
-  if (!content) {
-    return void 0;
-  }
-  const contextIndex = content.findIndex(
-    (part) => isRuntimeTurnContextPart(part, RUNTIME_TURN_CONTEXT_START)
-  );
-  if (contextIndex >= 0) {
-    return void 0;
-  }
-  return {
-    ...message,
-    content: [{ type: "text", text: turnContextPrompt }, ...content]
-  };
-}
-function prependMissingRuntimeTurnContext(messages, turnContextPrompt) {
-  if (hasRuntimeTurnContext(messages)) {
-    return messages;
-  }
-  for (let index = messages.length - 1; index >= 0; index -= 1) {
-    const updated = prependRuntimeTurnContext(
-      messages[index],
-      turnContextPrompt
-    );
-    if (!updated) {
-      continue;
-    }
-    const nextMessages = [...messages];
-    nextMessages[index] = updated;
-    return nextMessages;
-  }
-  return [
-    ...messages,
-    {
-      role: "user",
-      content: [{ type: "text", text: turnContextPrompt }],
-      timestamp: Date.now()
-    }
-  ];
-}
 function hasRuntimeTurnContext(messages) {
   return messages.some(
     (message) => getUserMessageContent(message)?.some(
@@ -287,6 +246,8 @@ import {
   getModels,
   registerApiProvider
 } from "@earendil-works/pi-ai";
+import { createGatewayProvider } from "@ai-sdk/gateway";
+import { embedMany, generateObject } from "ai";
 import {
   streamAnthropic,
   streamSimpleAnthropic
@@ -550,76 +511,17 @@ var GEN_AI_PROVIDER_NAME = GATEWAY_PROVIDER;
 var GEN_AI_SERVER_ADDRESS = "ai-gateway.vercel.sh";
 var GEN_AI_SERVER_PORT = 443;
 var GEN_AI_OPERATION_CHAT = "chat";
+var GEN_AI_OPERATION_EMBEDDINGS = "embeddings";
 var MISSING_GATEWAY_CREDENTIALS_ERROR = "Missing AI gateway credentials (AI_GATEWAY_API_KEY or VERCEL_OIDC_TOKEN)";
 function getGatewayApiKey() {
   return toOptionalTrimmed(getEnvApiKey("vercel-ai-gateway")) ?? toOptionalTrimmed(process.env.VERCEL_OIDC_TOKEN);
 }
-function getPiGatewayApiKeyOverride() {
-  return toOptionalTrimmed(process.env.VERCEL_OIDC_TOKEN);
+function getPiGatewayApiKey() {
+  return getGatewayApiKey();
 }
 function extractText(message) {
   return (message.content ?? []).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text ?? "").join("").trim();
 }
-function parseJsonCandidate2(text) {
-  const trimmed = text.trim();
-  if (!trimmed) return void 0;
-  try {
-    return JSON.parse(trimmed);
-  } catch {
-    const fencedBlocks = [
-      ...trimmed.matchAll(/```(?:json)?\s*([\s\S]*?)\s*```/gi)
-    ];
-    for (const block of fencedBlocks) {
-      try {
-        return JSON.parse(block[1]);
-      } catch {
-      }
-    }
-    const openBraceIndex = trimmed.indexOf("{");
-    if (openBraceIndex >= 0) {
-      let depth = 0;
-      let inString = false;
-      let escaped = false;
-      for (let index = openBraceIndex; index < trimmed.length; index += 1) {
-        const char = trimmed[index];
-        if (inString) {
-          if (escaped) {
-            escaped = false;
-            continue;
-          }
-          if (char === "\\") {
-            escaped = true;
-            continue;
-          }
-          if (char === '"') {
-            inString = false;
-          }
-          continue;
-        }
-        if (char === '"') {
-          inString = true;
-          continue;
-        }
-        if (char === "{") {
-          depth += 1;
-          continue;
-        }
-        if (char === "}") {
-          depth -= 1;
-          if (depth === 0) {
-            const slice = trimmed.slice(openBraceIndex, index + 1);
-            try {
-              return JSON.parse(slice);
-            } catch {
-              break;
-            }
-          }
-        }
-      }
-    }
-    return void 0;
-  }
-}
 function resolveGatewayModel(modelId) {
   const matched = getModels(GATEWAY_PROVIDER).find(
     (model) => model.id === modelId
@@ -631,7 +533,8 @@ function resolveGatewayModel(modelId) {
 }
 async function completeText(params) {
   const model = resolveGatewayModel(params.modelId);
-  const apiKey = getPiGatewayApiKeyOverride();
+  const apiKey = getPiGatewayApiKey();
+  const authMode = toOptionalTrimmed(process.env.AI_GATEWAY_API_KEY) ? "api_key" : toOptionalTrimmed(process.env.VERCEL_OIDC_TOKEN) ? "oidc" : "api_key";
   const privacy = resolveConversationPrivacy({
     channelId: typeof params.metadata?.channelId === "string" ? params.metadata.channelId : void 0,
     conversationId: typeof params.metadata?.conversationId === "string" ? params.metadata.conversationId : typeof params.metadata?.threadId === "string" ? params.metadata.threadId : void 0
@@ -660,7 +563,7 @@ async function completeText(params) {
     ...params.system ? { "app.ai.system_instructions.content_chars": params.system.length } : {},
     ...systemInstructionsAttribute ? { "gen_ai.system_instructions": systemInstructionsAttribute } : {},
     ...requestMessagesAttribute ? { "gen_ai.input.messages": requestMessagesAttribute } : {},
-    "app.ai.auth_mode": apiKey ? "oidc" : "api_key"
+    "app.ai.auth_mode": authMode
   };
   return withSpan(
     `${GEN_AI_OPERATION_CHAT} ${params.modelId}`,
@@ -750,30 +653,50 @@ function logContextFromMetadata(modelId, metadata) {
   };
 }
 async function completeObject(params) {
-  let text = "";
+  const apiKey = getGatewayApiKey();
+  const provider = createGatewayProvider(apiKey ? { apiKey } : {});
   try {
-    ({ text } = await completeText({
-      modelId: params.modelId,
-      system: params.system,
-      thinkingLevel: params.thinkingLevel,
-      temperature: params.temperature,
-      maxTokens: params.maxTokens,
-      signal: params.signal,
-      metadata: params.metadata,
-      messages: [
-        {
-          role: "user",
-          content: params.prompt,
-          timestamp: Date.now()
-        }
-      ]
-    }));
+    const result = await withSpan(
+      `${GEN_AI_OPERATION_CHAT} ${params.modelId}`,
+      "gen_ai.chat",
+      logContextFromMetadata(params.modelId, params.metadata),
+      async () => await generateObject({
+        model: provider.chat(params.modelId),
+        schema: params.schema,
+        prompt: params.prompt,
+        ...params.system !== void 0 ? { system: params.system } : {},
+        ...params.temperature !== void 0 ? { temperature: params.temperature } : {},
+        ...params.maxTokens !== void 0 ? { maxOutputTokens: params.maxTokens } : {},
+        ...params.signal !== void 0 ? { abortSignal: params.signal } : {}
+      }),
+      {
+        "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+        "gen_ai.operation.name": GEN_AI_OPERATION_CHAT,
+        "gen_ai.request.model": params.modelId,
+        "gen_ai.output.type": "json",
+        "server.address": GEN_AI_SERVER_ADDRESS,
+        "server.port": GEN_AI_SERVER_PORT,
+        ...params.thinkingLevel ? { "app.ai.reasoning_effort": params.thinkingLevel } : {}
+      }
+    );
+    setSpanAttributes({
+      "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+      "gen_ai.operation.name": GEN_AI_OPERATION_CHAT,
+      "gen_ai.request.model": params.modelId,
+      "gen_ai.output.type": "json",
+      "server.address": GEN_AI_SERVER_ADDRESS,
+      "server.port": GEN_AI_SERVER_PORT,
+      "gen_ai.response.finish_reasons": [result.finishReason],
+      ...extractGenAiUsageAttributes(result.usage)
+    });
+    return { object: result.object };
   } catch (error) {
-    if (isProviderRetryError(error)) {
-      throw error;
+    const providerError = createProviderError(error);
+    if (isProviderRetryError(providerError)) {
+      throw providerError;
     }
     logException(
-      error,
+      providerError,
       "ai_completion_failed",
       {},
       {
@@ -783,31 +706,72 @@ async function completeObject(params) {
       },
       "AI object completion failed"
     );
-    throw error;
+    throw providerError;
   }
-  const candidate = parseJsonCandidate2(text);
-  const parsed = params.schema.safeParse(candidate);
-  if (!parsed.success) {
-    const preview = text.length > 400 ? `${text.slice(0, 400)}...` : text;
-    logWarn(
-      "ai_completion_schema_parse_failed",
-      {},
+}
+async function embedTexts(params) {
+  const texts = params.texts.map((text) => text.trim());
+  if (texts.length === 0 || texts.some((text) => text.length === 0)) {
+    throw new Error("Embedding text is required.");
+  }
+  const apiKey = getGatewayApiKey();
+  const provider = createGatewayProvider(apiKey ? { apiKey } : {});
+  try {
+    const result = await withSpan(
+      `${GEN_AI_OPERATION_EMBEDDINGS} ${params.modelId}`,
+      "gen_ai.embeddings",
+      logContextFromMetadata(params.modelId, params.metadata),
+      async () => await embedMany({
+        model: provider.embeddingModel(params.modelId),
+        values: texts,
+        ...params.signal !== void 0 ? { abortSignal: params.signal } : {}
+      }),
       {
         "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
-        "gen_ai.operation.name": GEN_AI_OPERATION_CHAT,
+        "gen_ai.operation.name": GEN_AI_OPERATION_EMBEDDINGS,
         "gen_ai.request.model": params.modelId,
-        "app.ai.response_preview": preview
-      },
-      "AI object completion schema parse failed"
+        "gen_ai.output.type": "embedding",
+        "server.address": GEN_AI_SERVER_ADDRESS,
+        "server.port": GEN_AI_SERVER_PORT
+      }
     );
-    throw new Error(
-      `Model did not return valid JSON for schema: ${parsed.error.message}. Raw response: ${preview}`
+    const dimensions = result.embeddings[0]?.length;
+    if (result.embeddings.length !== texts.length || !dimensions || !result.embeddings.every((embedding) => embedding.length === dimensions)) {
+      throw new Error("Embedding provider returned invalid vectors.");
+    }
+    setSpanAttributes({
+      "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+      "gen_ai.operation.name": GEN_AI_OPERATION_EMBEDDINGS,
+      "gen_ai.request.model": params.modelId,
+      "gen_ai.output.type": "embedding",
+      "server.address": GEN_AI_SERVER_ADDRESS,
+      "server.port": GEN_AI_SERVER_PORT,
+      ...extractGenAiUsageAttributes(result.usage)
+    });
+    return {
+      dimensions,
+      model: params.modelId,
+      provider: GEN_AI_PROVIDER_NAME,
+      vectors: result.embeddings
+    };
+  } catch (error) {
+    const providerError = createProviderError(error);
+    if (isProviderRetryError(providerError)) {
+      throw providerError;
+    }
+    logException(
+      providerError,
+      "ai_embeddings_failed",
+      {},
+      {
+        "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+        "gen_ai.operation.name": GEN_AI_OPERATION_EMBEDDINGS,
+        "gen_ai.request.model": params.modelId
+      },
+      "AI embeddings failed"
     );
+    throw providerError;
   }
-  return {
-    object: parsed.data,
-    text
-  };
 }
 
 // src/chat/slack/emoji.ts
@@ -926,7 +890,7 @@ function parseSlashCommand(rawValue) {
   }
   return command;
 }
-var DEFAULT_MODEL_ID = getModel("vercel-ai-gateway", "openai/gpt-5.4").id;
+var DEFAULT_MODEL_ID = getModel("vercel-ai-gateway", "openai/gpt-5.5").id;
 var DEFAULT_FAST_MODEL_ID = getModel(
   "vercel-ai-gateway",
   "openai/gpt-5.4-mini"
@@ -935,12 +899,16 @@ var DEFAULT_ADVISOR_MODEL_ID = getModel(
   "vercel-ai-gateway",
   "openai/gpt-5.5"
 ).id;
+var DEFAULT_EMBEDDING_MODEL_ID = "openai/text-embedding-3-small";
 function validateGatewayModelId(raw) {
   const trimmed = toOptionalTrimmed(raw);
   if (trimmed === void 0) return void 0;
   resolveGatewayModel(trimmed);
   return trimmed;
 }
+function validateEmbeddingModelId(raw) {
+  return toOptionalTrimmed(raw);
+}
 function readAdvisorConfig(env) {
   return {
     modelId: validateGatewayModelId(env.AI_ADVISOR_MODEL) ?? DEFAULT_ADVISOR_MODEL_ID,
@@ -963,14 +931,17 @@ function parseReactionEmoji(envName, rawValue, defaultEmoji) {
 function readBotConfig(env) {
   const functionMaxDurationSeconds = resolveFunctionMaxDurationSeconds(env);
   const maxTurnTimeoutMs = resolveMaxTurnTimeoutMs(functionMaxDurationSeconds);
+  const modelId = validateGatewayModelId(env.AI_MODEL) ?? DEFAULT_MODEL_ID;
+  const fastModelId = validateGatewayModelId(env.AI_FAST_MODEL ?? env.AI_MODEL) ?? DEFAULT_FAST_MODEL_ID;
   return {
-    userName: env.JUNIOR_BOT_NAME ?? "junior",
-    modelId: validateGatewayModelId(env.AI_MODEL) ?? DEFAULT_MODEL_ID,
+    userName: toOptionalTrimmed(env.JUNIOR_BOT_NAME) ?? "junior",
+    modelId,
     modelContextWindowTokens: parseOptionalPositiveInteger(
       "AI_MODEL_CONTEXT_WINDOW_TOKENS",
       env.AI_MODEL_CONTEXT_WINDOW_TOKENS
     ),
-    fastModelId: validateGatewayModelId(env.AI_FAST_MODEL ?? env.AI_MODEL) ?? DEFAULT_FAST_MODEL_ID,
+    fastModelId,
+    embeddingModelId: validateEmbeddingModelId(env.AI_EMBEDDING_MODEL) ?? DEFAULT_EMBEDDING_MODEL_ID,
     loadingMessages: parseLoadingMessages(env.JUNIOR_LOADING_MESSAGES),
     visionModelId: validateGatewayModelId(env.AI_VISION_MODEL),
     turnTimeoutMs: parseAgentTurnTimeoutMs(
@@ -983,12 +954,38 @@ function readBotConfig(env) {
 function readJuniorDatabaseUrl(env) {
   return toOptionalTrimmed(env.JUNIOR_DATABASE_URL) ?? toOptionalTrimmed(env.DATABASE_URL);
 }
+function isLocalDatabaseUrl(databaseUrl) {
+  if (!databaseUrl) {
+    return false;
+  }
+  try {
+    const { hostname } = new URL(databaseUrl);
+    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+  } catch {
+    return false;
+  }
+}
+function readSqlDriver(env, databaseUrl) {
+  const value = toOptionalTrimmed(env.JUNIOR_DATABASE_DRIVER);
+  if (value === void 0) {
+    if (isLocalDatabaseUrl(databaseUrl)) {
+      return "postgres";
+    }
+    return "neon";
+  }
+  if (value === "neon" || value === "postgres") {
+    return value;
+  }
+  throw new Error("JUNIOR_DATABASE_DRIVER must be postgres or neon");
+}
 function readChatConfig(env = process.env) {
+  const databaseUrl = readJuniorDatabaseUrl(env);
   return {
     bot: readBotConfig(env),
     functionMaxDurationSeconds: resolveFunctionMaxDurationSeconds(env),
     sql: {
-      databaseUrl: readJuniorDatabaseUrl(env)
+      databaseUrl,
+      driver: readSqlDriver(env, databaseUrl)
     },
     slack: {
       botToken: toOptionalTrimmed(env.SLACK_BOT_TOKEN) ?? toOptionalTrimmed(env.SLACK_BOT_USER_TOKEN),
@@ -1076,7 +1073,6 @@ export {
   isToolResultError,
   isAssistantMessage,
   getPiMessageRole,
-  prependMissingRuntimeTurnContext,
   hasRuntimeTurnContext,
   stripRuntimeTurnContext,
   extractAssistantText,
@@ -1090,10 +1086,11 @@ export {
   GEN_AI_SERVER_PORT,
   MISSING_GATEWAY_CREDENTIALS_ERROR,
   getGatewayApiKey,
-  getPiGatewayApiKeyOverride,
+  getPiGatewayApiKey,
   resolveGatewayModel,
   completeText,
   completeObject,
+  embedTexts,
   normalizeSlackEmojiName,
   FUNCTION_TIMEOUT_BUFFER_SECONDS,
   getChatConfig,