@exulu/backend 1.59.0 → 1.60.0

package/dist/{chunk-U36VJDZ7.js → chunk-23YNGK3V.js}

@@ -262,7 +262,8 @@ var spawnLiteLLM = (cfg) => {
   log(
     `Spawning LiteLLM: ${cfg.litellmBin} --config ${cfg.configPath} --port ${cfg.port} --host ${cfg.host}`
   );
-  const { DEBUG: _debug, ...envWithoutDebug } = process.env;
+  const { DEBUG: _debug, ...rest } = process.env;
+  const childEnv = { ...rest, DEBUG: "false" };
   const child = spawn(
     cfg.litellmBin,
     [
@@ -275,7 +276,7 @@ var spawnLiteLLM = (cfg) => {
     ],
     {
       stdio: ["ignore", "pipe", "pipe"],
-      env: envWithoutDebug
+      env: childEnv
     }
   );
   child.stdout?.on("data", (chunk) => {
@@ -743,7 +744,7 @@ var ExuluTool = class {
       });
       providerapikey = resolved.apiKey;
     }
-    const { convertExuluToolsToAiSdkTools: convertExuluToolsToAiSdkTools2 } = await import("./convert-exulu-tools-to-ai-sdk-tools-ZEECMX43.js");
+    const { convertExuluToolsToAiSdkTools: convertExuluToolsToAiSdkTools2 } = await import("./convert-exulu-tools-to-ai-sdk-tools-PLLM2CJL.js");
     const tools = await convertExuluToolsToAiSdkTools2(
       [this],
       [],

package/dist/{convert-exulu-tools-to-ai-sdk-tools-ZEECMX43.js → convert-exulu-tools-to-ai-sdk-tools-PLLM2CJL.js}

@@ -1,6 +1,6 @@
 import {
   convertExuluToolsToAiSdkTools
-} from "./chunk-U36VJDZ7.js";
+} from "./chunk-23YNGK3V.js";
 export {
   convertExuluToolsToAiSdkTools
 };

package/dist/index.cjs

@@ -429,7 +429,8 @@ var init_supervisor = __esm({
       log(
         `Spawning LiteLLM: ${cfg.litellmBin} --config ${cfg.configPath} --port ${cfg.port} --host ${cfg.host}`
       );
-      const { DEBUG: _debug, ...envWithoutDebug } = process.env;
+      const { DEBUG: _debug, ...rest } = process.env;
+      const childEnv = { ...rest, DEBUG: "false" };
       const child = (0, import_node_child_process.spawn)(
         cfg.litellmBin,
         [
@@ -442,7 +443,7 @@ var init_supervisor = __esm({
         ],
         {
           stdio: ["ignore", "pipe", "pipe"],
-          env: envWithoutDebug
+          env: childEnv
         }
       );
       child.stdout?.on("data", (chunk) => {
@@ -18790,6 +18791,217 @@ var emailTool = new ExuluTool({
   }
 });
 
+// src/templates/tools/transcribe.ts
+init_cjs_shims();
+init_tool();
+init_supervisor();
+init_uppy();
+var import_node_crypto8 = require("crypto");
+var import_promises3 = require("fs/promises");
+var import_node_path5 = require("path");
+var import_zod20 = require("zod");
+var SANDBOX_ROOT = "/tmp/exulu-sessions";
+var parseSandboxPath = (input) => {
+  const stripped = input.startsWith("file://") ? input.slice("file://".length) : input;
+  if (!stripped.startsWith(`${SANDBOX_ROOT}/`)) return null;
+  const tail = stripped.slice(SANDBOX_ROOT.length + 1);
+  const slash = tail.indexOf("/");
+  if (slash < 1) return null;
+  const sessionId = tail.slice(0, slash);
+  const relPath = tail.slice(slash + 1);
+  if (!relPath) return null;
+  return { sessionId, relPath };
+};
+var audioMimetypeFromExtension = (filename) => {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "mp3":
+      return "audio/mpeg";
+    case "m4a":
+    case "mp4":
+      return "audio/mp4";
+    case "wav":
+      return "audio/wav";
+    case "ogg":
+    case "oga":
+      return "audio/ogg";
+    case "flac":
+      return "audio/flac";
+    case "webm":
+      return "audio/webm";
+    case "aac":
+      return "audio/aac";
+    case "mpga":
+    case "mpeg":
+      return "audio/mpeg";
+    default:
+      throw new Error(
+        `Unable to infer an audio mimetype from filename "${filename}". Supported extensions: mp3, m4a, mp4, wav, ogg, flac, webm, aac, mpga.`
+      );
+  }
+};
+var transcribeTool = new ExuluTool({
+  id: "transcribe_audio",
+  name: "Transcribe Audio",
+  description: "Transcribe an audio file (mp3, wav, m4a, etc.) from a URL to text using the configured speech-to-text model. The transcript is stored as a .txt file on S3 and the URL is returned; use this for clips that may be too long to inline in the conversation.",
+  inputSchema: import_zod20.z.object({
+    audio_url: import_zod20.z.string().describe(
+      "Location of the audio file to transcribe. Accepts a publicly fetchable URL (https URL or presigned S3 URL), or a sandbox path such as '/tmp/exulu-sessions/<sessionId>/<file>' or 'file:///tmp/exulu-sessions/<sessionId>/<file>' \u2014 sandbox paths are resolved to their persisted S3 copy."
+    ),
+    language: import_zod20.z.string().optional().describe(
+      "ISO-639-1 language code of the audio, e.g. 'en' or 'de'. Omit to let the model auto-detect."
+    )
+  }),
+  type: "function",
+  config: [{
+    name: "default_language",
+    description: "ISO-639-1 language code of the audio, e.g. 'en' or 'de'. Omit to let the model auto-detect.",
+    type: "string",
+    default: void 0
+  }],
+  execute: async ({ audio_url, language, user, exuluConfig, sessionID }) => {
+    if (!language && exuluConfig?.default_language) {
+      language = exuluConfig?.default_language;
+    } else {
+      language = "en";
+    }
+    language = exuluConfig?.default_language;
+    console.log("[EXULU] Exulu config", exuluConfig);
+    if (!isLiteLLMEnabled()) {
+      console.error("[EXULU] Speech-to-text is not enabled on this deployment (EXULU_USE_LITELLM is not 'true').");
+      throw new Error(
+        "Speech-to-text is not enabled on this deployment (EXULU_USE_LITELLM is not 'true')."
+      );
+    }
+    if (!process.env.TRANSCRIPTION_MODEL) {
+      console.error("[EXULU] TRANSCRIPTION_MODEL env var is not set.");
+      throw new Error("TRANSCRIPTION_MODEL env var is not set.");
+    }
+    if (!exuluConfig?.fileUploads) {
+      console.error("[EXULU] File uploads are not configured; the transcribe tool requires S3 to store transcripts.");
+      throw new Error(
+        "File uploads are not configured; the transcribe tool requires S3 to store transcripts."
+      );
+    }
+    const sandboxPath = parseSandboxPath(audio_url);
+    let buffer;
+    let mimetype;
+    let originalname;
+    if (sandboxPath) {
+      if (!user?.id) {
+        throw new Error(
+          "Sandbox audio paths require an authenticated user; got no user on the tool call."
+        );
+      }
+      if (sessionID && sandboxPath.sessionId !== sessionID) {
+        throw new Error(
+          `Refusing to transcribe an audio file from a different session's sandbox (path session=${sandboxPath.sessionId}, current session=${sessionID}).`
+        );
+      }
+      const rawKey = `user_${user.id}/sessions/${sandboxPath.sessionId}/${sandboxPath.relPath}`;
+      console.log("[EXULU] Transcribing audio from sandbox path", {
+        rawKey
+      });
+      const matches = await listS3ObjectsByPrefix(rawKey, exuluConfig);
+      const found = matches.find((m) => m.key.endsWith(rawKey));
+      if (!found) {
+        console.error("[EXULU] Sandbox audio file not found in S3 storage at", {
+          rawKey,
+          matches
+        });
+        throw new Error(
+          `Sandbox audio file not found in S3 storage at "${rawKey}". The file may not have been persisted yet \u2014 try again after the sandbox flushes it.`
+        );
+      }
+      buffer = await getS3ObjectBytes(found.key, exuluConfig);
+      originalname = decodeURIComponent(
+        sandboxPath.relPath.split("/").pop() || "audio"
+      );
+      mimetype = audioMimetypeFromExtension(originalname);
+    } else {
+      console.log("[EXULU] Fetching audio from URL", {
+        audio_url
+      });
+      const upstream = await fetch(audio_url);
+      if (!upstream.ok) {
+        console.error("[EXULU] Failed to fetch audio from", {
+          audio_url,
+          upstream
+        });
+        throw new Error(
+          `Failed to fetch audio from ${audio_url}: ${upstream.status} ${upstream.statusText}`
+        );
+      }
+      mimetype = upstream.headers.get("content-type") || "audio/mpeg";
+      if (!mimetype.startsWith("audio/")) {
+        throw new Error(
+          `URL did not return an audio file (content-type: ${mimetype}).`
+        );
+      }
+      buffer = Buffer.from(await upstream.arrayBuffer());
+      originalname = "audio";
+      try {
+        const pathname = new URL(audio_url).pathname;
+        const last = pathname.split("/").pop();
+        if (last) originalname = decodeURIComponent(last);
+      } catch {
+      }
+    }
+    const { text } = await transcribeAudio({
+      file: { buffer, originalname, mimetype },
+      language
+    });
+    const transcriptBuffer = Buffer.from(text, "utf-8");
+    const transcriptFilename = `${(0, import_node_crypto8.randomUUID)()}.txt`;
+    const transcriptKey = sessionID ? `sessions/${sessionID}/transcripts/${transcriptFilename}` : `transcripts/${transcriptFilename}`;
+    console.log("[EXULU] Uploading transcript to S3", {
+      transcriptFilename,
+      transcriptKey
+    });
+    const url = await uploadFile(
+      transcriptBuffer,
+      transcriptKey,
+      exuluConfig,
+      { contentType: "text/plain" },
+      user?.id
+    );
+    console.log("[EXULU] Uploaded transcript to S3", {
+      url
+    });
+    let sandboxLocalPath;
+    if (sessionID) {
+      sandboxLocalPath = (0, import_node_path5.join)(
+        SANDBOX_ROOT,
+        sessionID,
+        "transcripts",
+        transcriptFilename
+      );
+      console.log("[EXULU] Mirroring transcript into session sandbox", {
+        sandboxLocalPath
+      });
+      try {
+        await (0, import_promises3.mkdir)((0, import_node_path5.dirname)(sandboxLocalPath), { recursive: true });
+        await (0, import_promises3.writeFile)(sandboxLocalPath, transcriptBuffer);
+      } catch (err) {
+        console.error(
+          `[EXULU] Failed to write transcript to sandbox dir ${sandboxLocalPath}; S3 copy is unaffected.`,
+          err
+        );
+        sandboxLocalPath = void 0;
+      }
+    }
+    console.log("[EXULU] Transcribed audio successfully", {
+      text,
+      url,
+      sandboxLocalPath,
+      length: text.length
+    });
+    return {
+      result: sandboxLocalPath ? `Transcript stored at: ${url} (also available in the session sandbox at ${sandboxLocalPath}, ${text.length} characters).` : `${url}`
+    };
+  }
+});
+
 // src/validators/postgres-name.ts
 init_cjs_shims();
 var isValidPostgresName = (id) => {
@@ -19102,12 +19314,17 @@ var ExuluApp = class {
       ...providers ?? []
     ];
     this._config = config;
+    const transcriptionTools = [];
+    if (process.env.TRANSCRIPTION_MODEL && config?.fileUploads && config?.fileUploads?.s3region && config?.fileUploads?.s3key && config?.fileUploads?.s3secret && config?.fileUploads?.s3Bucket) {
+      transcriptionTools.push(transcribeTool);
+    }
     this._tools = [
       ...tools ?? [],
       ...todoTools,
       ...questionTools,
       ...perplexityTools,
-      emailTool
+      emailTool,
+      ...transcriptionTools
       // Because agents are stored in the database, we add those as tools
       // at request time, not during ExuluApp initialization. We add them
       // in the grahql tools resolver.
@@ -21274,7 +21491,7 @@ init_cjs_shims();
 // src/exulu/litellm/db-init.ts
 init_cjs_shims();
 var import_node_fs6 = require("fs");
-var import_node_path5 = require("path");
+var import_node_path6 = require("path");
 var import_node_child_process5 = require("child_process");
 var import_pg = require("pg");
 
@@ -21344,7 +21561,7 @@ ${WARNING_BANNER}`);
 };
 var log2 = (line) => console.log(`[EXULU-LITELLM] ${line}`);
 var initLiteLLMDatabase = async (packageRoot) => {
-  const configPath = process.env.LITELLM_CONFIG_PATH ?? (0, import_node_path5.resolve)(packageRoot, "./config.litellm.yaml");
+  const configPath = process.env.LITELLM_CONFIG_PATH ?? (0, import_node_path6.resolve)(packageRoot, "./config.litellm.yaml");
   const safety = checkLiteLLMDatabaseSafety(configPath);
   if (safety.ok && safety.reason === "no-litellm-db-mode") return;
   if (!safety.ok && safety.reason === "unparseable-url") {
@@ -21482,13 +21699,13 @@ var initLiteLLMDatabase = async (packageRoot) => {
     ]);
     return;
   }
-  const venvBin = (0, import_node_path5.resolve)(packageRoot, "ee/python/.venv/bin");
-  const prismaCli = (0, import_node_path5.resolve)(venvBin, "prisma");
-  const litellmProxyDir = (0, import_node_path5.resolve)(
+  const venvBin = (0, import_node_path6.resolve)(packageRoot, "ee/python/.venv/bin");
+  const prismaCli = (0, import_node_path6.resolve)(venvBin, "prisma");
+  const litellmProxyDir = (0, import_node_path6.resolve)(
     packageRoot,
     "ee/python/.venv/lib/python3.12/site-packages/litellm/proxy"
   );
-  const schemaPath = (0, import_node_path5.resolve)(litellmProxyDir, "schema.prisma");
+  const schemaPath = (0, import_node_path6.resolve)(litellmProxyDir, "schema.prisma");
   if (!(0, import_node_fs6.existsSync)(prismaCli)) {
     warn([
       `Prisma CLI not found at ${prismaCli}.`,
@@ -22078,7 +22295,7 @@ init_cjs_shims();
 var fs5 = __toESM(require("fs"), 1);
 var path2 = __toESM(require("path"), 1);
 var import_ai14 = require("ai");
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 var import_p_limit = __toESM(require("p-limit"), 1);
 var import_crypto = require("crypto");
 init_with_retry();
@@ -22433,15 +22650,15 @@ If the page contains a flow-chart, schematic, technical drawing or control board
   const result = await (0, import_ai14.generateText)({
     model,
     output: import_ai14.Output.object({
-      schema: import_zod20.z.object({
-        needs_correction: import_zod20.z.boolean(),
-        corrected_text: import_zod20.z.string().nullable(),
-        current_page_table: import_zod20.z.object({
-          headers: import_zod20.z.array(import_zod20.z.string()),
-          is_continuation: import_zod20.z.boolean()
+      schema: import_zod21.z.object({
+        needs_correction: import_zod21.z.boolean(),
+        corrected_text: import_zod21.z.string().nullable(),
+        current_page_table: import_zod21.z.object({
+          headers: import_zod21.z.array(import_zod21.z.string()),
+          is_continuation: import_zod21.z.boolean()
         }).nullable(),
-        confidence: import_zod20.z.enum(["high", "medium", "low"]),
-        reasoning: import_zod20.z.string()
+        confidence: import_zod21.z.enum(["high", "medium", "low"]),
+        reasoning: import_zod21.z.string()
       })
     }),
     messages: [

package/dist/index.js

@@ -46,7 +46,7 @@ import {
   vectorSearch,
   waitForLiteLLMReady,
   withRetry
-} from "./chunk-U36VJDZ7.js";
+} from "./chunk-23YNGK3V.js";
 import {
   findLiteLLMModel
 } from "./chunk-YS27XOXI.js";
@@ -11004,6 +11004,213 @@ var emailTool = new ExuluTool({
   }
 });
 
+// src/templates/tools/transcribe.ts
+import { randomUUID as randomUUID5 } from "crypto";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { dirname, join as join2 } from "path";
+import { z as z10 } from "zod";
+var SANDBOX_ROOT = "/tmp/exulu-sessions";
+var parseSandboxPath = (input) => {
+  const stripped = input.startsWith("file://") ? input.slice("file://".length) : input;
+  if (!stripped.startsWith(`${SANDBOX_ROOT}/`)) return null;
+  const tail = stripped.slice(SANDBOX_ROOT.length + 1);
+  const slash = tail.indexOf("/");
+  if (slash < 1) return null;
+  const sessionId = tail.slice(0, slash);
+  const relPath = tail.slice(slash + 1);
+  if (!relPath) return null;
+  return { sessionId, relPath };
+};
+var audioMimetypeFromExtension = (filename) => {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "mp3":
+      return "audio/mpeg";
+    case "m4a":
+    case "mp4":
+      return "audio/mp4";
+    case "wav":
+      return "audio/wav";
+    case "ogg":
+    case "oga":
+      return "audio/ogg";
+    case "flac":
+      return "audio/flac";
+    case "webm":
+      return "audio/webm";
+    case "aac":
+      return "audio/aac";
+    case "mpga":
+    case "mpeg":
+      return "audio/mpeg";
+    default:
+      throw new Error(
+        `Unable to infer an audio mimetype from filename "${filename}". Supported extensions: mp3, m4a, mp4, wav, ogg, flac, webm, aac, mpga.`
+      );
+  }
+};
+var transcribeTool = new ExuluTool({
+  id: "transcribe_audio",
+  name: "Transcribe Audio",
+  description: "Transcribe an audio file (mp3, wav, m4a, etc.) from a URL to text using the configured speech-to-text model. The transcript is stored as a .txt file on S3 and the URL is returned; use this for clips that may be too long to inline in the conversation.",
+  inputSchema: z10.object({
+    audio_url: z10.string().describe(
+      "Location of the audio file to transcribe. Accepts a publicly fetchable URL (https URL or presigned S3 URL), or a sandbox path such as '/tmp/exulu-sessions/<sessionId>/<file>' or 'file:///tmp/exulu-sessions/<sessionId>/<file>' \u2014 sandbox paths are resolved to their persisted S3 copy."
+    ),
+    language: z10.string().optional().describe(
+      "ISO-639-1 language code of the audio, e.g. 'en' or 'de'. Omit to let the model auto-detect."
+    )
+  }),
+  type: "function",
+  config: [{
+    name: "default_language",
+    description: "ISO-639-1 language code of the audio, e.g. 'en' or 'de'. Omit to let the model auto-detect.",
+    type: "string",
+    default: void 0
+  }],
+  execute: async ({ audio_url, language, user, exuluConfig, sessionID }) => {
+    if (!language && exuluConfig?.default_language) {
+      language = exuluConfig?.default_language;
+    } else {
+      language = "en";
+    }
+    language = exuluConfig?.default_language;
+    console.log("[EXULU] Exulu config", exuluConfig);
+    if (!isLiteLLMEnabled()) {
+      console.error("[EXULU] Speech-to-text is not enabled on this deployment (EXULU_USE_LITELLM is not 'true').");
+      throw new Error(
+        "Speech-to-text is not enabled on this deployment (EXULU_USE_LITELLM is not 'true')."
+      );
+    }
+    if (!process.env.TRANSCRIPTION_MODEL) {
+      console.error("[EXULU] TRANSCRIPTION_MODEL env var is not set.");
+      throw new Error("TRANSCRIPTION_MODEL env var is not set.");
+    }
+    if (!exuluConfig?.fileUploads) {
+      console.error("[EXULU] File uploads are not configured; the transcribe tool requires S3 to store transcripts.");
+      throw new Error(
+        "File uploads are not configured; the transcribe tool requires S3 to store transcripts."
+      );
+    }
+    const sandboxPath = parseSandboxPath(audio_url);
+    let buffer;
+    let mimetype;
+    let originalname;
+    if (sandboxPath) {
+      if (!user?.id) {
+        throw new Error(
+          "Sandbox audio paths require an authenticated user; got no user on the tool call."
+        );
+      }
+      if (sessionID && sandboxPath.sessionId !== sessionID) {
+        throw new Error(
+          `Refusing to transcribe an audio file from a different session's sandbox (path session=${sandboxPath.sessionId}, current session=${sessionID}).`
+        );
+      }
+      const rawKey = `user_${user.id}/sessions/${sandboxPath.sessionId}/${sandboxPath.relPath}`;
+      console.log("[EXULU] Transcribing audio from sandbox path", {
+        rawKey
+      });
+      const matches = await listS3ObjectsByPrefix(rawKey, exuluConfig);
+      const found = matches.find((m) => m.key.endsWith(rawKey));
+      if (!found) {
+        console.error("[EXULU] Sandbox audio file not found in S3 storage at", {
+          rawKey,
+          matches
+        });
+        throw new Error(
+          `Sandbox audio file not found in S3 storage at "${rawKey}". The file may not have been persisted yet \u2014 try again after the sandbox flushes it.`
+        );
+      }
+      buffer = await getS3ObjectBytes(found.key, exuluConfig);
+      originalname = decodeURIComponent(
+        sandboxPath.relPath.split("/").pop() || "audio"
+      );
+      mimetype = audioMimetypeFromExtension(originalname);
+    } else {
+      console.log("[EXULU] Fetching audio from URL", {
+        audio_url
+      });
+      const upstream = await fetch(audio_url);
+      if (!upstream.ok) {
+        console.error("[EXULU] Failed to fetch audio from", {
+          audio_url,
+          upstream
+        });
+        throw new Error(
+          `Failed to fetch audio from ${audio_url}: ${upstream.status} ${upstream.statusText}`
+        );
+      }
+      mimetype = upstream.headers.get("content-type") || "audio/mpeg";
+      if (!mimetype.startsWith("audio/")) {
+        throw new Error(
+          `URL did not return an audio file (content-type: ${mimetype}).`
+        );
+      }
+      buffer = Buffer.from(await upstream.arrayBuffer());
+      originalname = "audio";
+      try {
+        const pathname = new URL(audio_url).pathname;
+        const last = pathname.split("/").pop();
+        if (last) originalname = decodeURIComponent(last);
+      } catch {
+      }
+    }
+    const { text } = await transcribeAudio({
+      file: { buffer, originalname, mimetype },
+      language
+    });
+    const transcriptBuffer = Buffer.from(text, "utf-8");
+    const transcriptFilename = `${randomUUID5()}.txt`;
+    const transcriptKey = sessionID ? `sessions/${sessionID}/transcripts/${transcriptFilename}` : `transcripts/${transcriptFilename}`;
+    console.log("[EXULU] Uploading transcript to S3", {
+      transcriptFilename,
+      transcriptKey
+    });
+    const url = await uploadFile(
+      transcriptBuffer,
+      transcriptKey,
+      exuluConfig,
+      { contentType: "text/plain" },
+      user?.id
+    );
+    console.log("[EXULU] Uploaded transcript to S3", {
+      url
+    });
+    let sandboxLocalPath;
+    if (sessionID) {
+      sandboxLocalPath = join2(
+        SANDBOX_ROOT,
+        sessionID,
+        "transcripts",
+        transcriptFilename
+      );
+      console.log("[EXULU] Mirroring transcript into session sandbox", {
+        sandboxLocalPath
+      });
+      try {
+        await mkdir2(dirname(sandboxLocalPath), { recursive: true });
+        await writeFile2(sandboxLocalPath, transcriptBuffer);
+      } catch (err) {
+        console.error(
+          `[EXULU] Failed to write transcript to sandbox dir ${sandboxLocalPath}; S3 copy is unaffected.`,
+          err
+        );
+        sandboxLocalPath = void 0;
+      }
+    }
+    console.log("[EXULU] Transcribed audio successfully", {
+      text,
+      url,
+      sandboxLocalPath,
+      length: text.length
+    });
+    return {
+      result: sandboxLocalPath ? `Transcript stored at: ${url} (also available in the session sandbox at ${sandboxLocalPath}, ${text.length} characters).` : `${url}`
+    };
+  }
+});
+
 // src/validators/postgres-name.ts
 var isValidPostgresName = (id) => {
   const regex = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
@@ -11015,17 +11222,17 @@ var isValidPostgresName = (id) => {
 // src/utils/python-setup.ts
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { resolve, join as join2, dirname } from "path";
+import { resolve, join as join3, dirname as dirname2 } from "path";
 import { existsSync as existsSync2, readFileSync } from "fs";
 import { fileURLToPath } from "url";
 var execAsync2 = promisify2(exec2);
 function getPackageRoot() {
   const currentFile = fileURLToPath(import.meta.url);
-  let currentDir = dirname(currentFile);
+  let currentDir = dirname2(currentFile);
   let attempts = 0;
   const maxAttempts = 10;
   while (attempts < maxAttempts) {
-    const packageJsonPath = join2(currentDir, "package.json");
+    const packageJsonPath = join3(currentDir, "package.json");
     if (existsSync2(packageJsonPath)) {
       try {
         const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
@@ -11042,7 +11249,7 @@ function getPackageRoot() {
     currentDir = parentDir;
     attempts++;
   }
-  const fallback = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+  const fallback = resolve(dirname2(fileURLToPath(import.meta.url)), "../..");
   return fallback;
 }
 function getSetupScriptPath(packageRoot) {
@@ -11054,7 +11261,7 @@ function getVenvPath(packageRoot) {
 function isPythonEnvironmentSetup(packageRoot) {
   const root = packageRoot ?? getPackageRoot();
   const venvPath = getVenvPath(root);
-  const pythonPath = join2(venvPath, "bin", "python");
+  const pythonPath = join3(venvPath, "bin", "python");
   return existsSync2(venvPath) && existsSync2(pythonPath);
 }
 async function setupPythonEnvironment(options = {}) {
@@ -11157,7 +11364,7 @@ Note: In Docker containers, ensure you install all three components:
 async function validatePythonEnvironment(packageRoot, checkPackages = true) {
   const root = packageRoot ?? getPackageRoot();
   const venvPath = getVenvPath(root);
-  const pythonPath = join2(venvPath, "bin", "python");
+  const pythonPath = join3(venvPath, "bin", "python");
   if (!existsSync2(venvPath)) {
     return {
       valid: false,
@@ -11307,12 +11514,17 @@ var ExuluApp = class {
       ...providers ?? []
     ];
     this._config = config;
+    const transcriptionTools = [];
+    if (process.env.TRANSCRIPTION_MODEL && config?.fileUploads && config?.fileUploads?.s3region && config?.fileUploads?.s3key && config?.fileUploads?.s3secret && config?.fileUploads?.s3Bucket) {
+      transcriptionTools.push(transcribeTool);
+    }
     this._tools = [
       ...tools ?? [],
       ...todoTools,
       ...questionTools,
       ...perplexityTools,
-      emailTool
+      emailTool,
+      ...transcriptionTools
       // Because agents are stored in the database, we add those as tools
       // at request time, not during ExuluApp initialization. We add them
       // in the grahql tools resolver.
@@ -14237,9 +14449,9 @@ var MarkdownChunker = class {
 import * as fs4 from "fs";
 import * as path from "path";
 import { generateText as generateText5, Output as Output2 } from "ai";
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 import pLimit from "p-limit";
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 import * as mammoth from "mammoth";
 import TurndownService from "turndown";
 import WordExtractor from "word-extractor";
@@ -14248,17 +14460,17 @@ import { parseOfficeAsync as parseOfficeAsync2 } from "officeparser";
 // src/utils/python-executor.ts
 import { exec as exec3 } from "child_process";
 import { promisify as promisify3 } from "util";
-import { resolve as resolve3, join as join3, dirname as dirname2 } from "path";
+import { resolve as resolve3, join as join4, dirname as dirname3 } from "path";
 import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var execAsync3 = promisify3(exec3);
 function getPackageRoot2() {
   const currentFile = fileURLToPath2(import.meta.url);
-  let currentDir = dirname2(currentFile);
+  let currentDir = dirname3(currentFile);
   let attempts = 0;
   const maxAttempts = 10;
   while (attempts < maxAttempts) {
-    const packageJsonPath = join3(currentDir, "package.json");
+    const packageJsonPath = join4(currentDir, "package.json");
     if (existsSync5(packageJsonPath)) {
       try {
         const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
@@ -14275,7 +14487,7 @@ function getPackageRoot2() {
     currentDir = parentDir;
     attempts++;
   }
-  return resolve3(dirname2(fileURLToPath2(import.meta.url)), "../..");
+  return resolve3(dirname3(fileURLToPath2(import.meta.url)), "../..");
 }
 var PythonEnvironmentError = class extends Error {
   constructor(message) {
@@ -14300,7 +14512,7 @@ function getVenvPath2(packageRoot) {
 }
 function getPythonExecutable(packageRoot) {
   const venvPath = getVenvPath2(packageRoot);
-  return join3(venvPath, "bin", "python");
+  return join4(venvPath, "bin", "python");
 }
 async function validatePythonEnvironmentForExecution(packageRoot) {
   const validation = await validatePythonEnvironment(packageRoot);
@@ -14589,15 +14801,15 @@ If the page contains a flow-chart, schematic, technical drawing or control board
   const result = await generateText5({
     model,
     output: Output2.object({
-      schema: z10.object({
-        needs_correction: z10.boolean(),
-        corrected_text: z10.string().nullable(),
-        current_page_table: z10.object({
-          headers: z10.array(z10.string()),
-          is_continuation: z10.boolean()
+      schema: z11.object({
+        needs_correction: z11.boolean(),
+        corrected_text: z11.string().nullable(),
+        current_page_table: z11.object({
+          headers: z11.array(z11.string()),
+          is_continuation: z11.boolean()
         }).nullable(),
-        confidence: z10.enum(["high", "medium", "low"]),
-        reasoning: z10.string()
+        confidence: z11.enum(["high", "medium", "low"]),
+        reasoning: z11.string()
       })
     }),
     messages: [
@@ -14997,7 +15209,7 @@ var loadFile = async (file, name, tempDir) => {
   if (!fileType) {
     throw new Error("[EXULU] File name does not include extension, extension is required for document processing.");
   }
-  const UUID = randomUUID5();
+  const UUID = randomUUID6();
   let buffer;
   if (Buffer.isBuffer(file)) {
     filePath = path.join(tempDir, `${UUID}.${fileType}`);
@@ -15027,7 +15239,7 @@ async function documentProcessor({
   if (!license["advanced-document-processing"]) {
     throw new Error("Advanced document processing is an enterprise feature, please add a valid Exulu enterprise license key to use it.");
   }
-  const uuid = randomUUID5();
+  const uuid = randomUUID6();
   const tempDir = path.join(process.cwd(), "temp", uuid);
   const localFilesAndFoldersToDelete = [tempDir];
   console.log(`[EXULU] Temporary directory for processing document ${name}: ${tempDir}`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@exulu/backend",
   "author": "Qventu Bv.",
-  "version": "1.59.0",
+  "version": "1.60.0",
   "main": "./dist/index.js",
   "private": false,
   "publishConfig": {