diff --git a/src/Frontend/src/components/messages/StacktraceFormatter.vue b/src/Frontend/src/components/messages/StacktraceFormatter.vue
index e1a6180ba..c172c3419 100644
--- a/src/Frontend/src/components/messages/StacktraceFormatter.vue
+++ b/src/Frontend/src/components/messages/StacktraceFormatter.vue
@@ -1,5 +1,6 @@
 <script lang="ts" setup>
 import { ref, watch } from "vue";
+import { type Language, type StackTraceElement, languages, detectLanguagesInOrder, formatStackTrace } from "./StacktraceFormatter/stacktraceFormatter";
 
 // Define TypeScript interfaces for settings and supported languages
 interface NetStackOptions {
@@ -13,26 +14,6 @@ interface NetStackOptions {
   line?: string;
 }
 
-interface Language {
-  name: string;
-  at: string;
-  in: string;
-  line: string;
-}
-
-type Text = string;
-
-interface Node {
-  params: Array<{ name: string; type: string }>;
-  type: string;
-  lineNumber?: number;
-  file?: string;
-  method: string;
-  spaces: string;
-}
-
-type Element = Text | Node;
-
 // Props
 const props = withDefaults(defineProps<{ stackTrace: string; options?: NetStackOptions }>(), {
   options: () => ({
@@ -47,80 +28,10 @@ const props = withDefaults(defineProps<{ stackTrace: string; options?: NetStackO
   }),
 });
 
-// Supported languages and their keywords
-const languages: Language[] = [
-  { name: "english", at: "at", in: "in", line: "line" },
-  { name: "danish", at: "ved", in: "i", line: "linje" },
-  { name: "german", at: "bei", in: "in", line: "Zeile" },
-  { name: "spanish", at: "en", in: "en", line: "línea" },
-  { name: "russian", at: "в", in: "в", line: "строка" },
-  { name: "chinese", at: "在", in: "位置", line: "行号" },
-];
-
 // Reactive variables and setup state
-const formattedStack = ref<Element[]>([]);
+const formattedStack = ref<StackTraceElement[]>([]);
 const selectedLanguage = ref<Language>(languages[0]);
 
-// Helper function to detect languages in the stack trace
-const detectLanguagesInOrder = (text: string): Language[] => {
-  const languageRegexes = {
-    english: /\s+at .*?\)/g,
-    danish: /\s+ved .*?\)/g,
-    german: /\s+bei .*?\)/g,
-    spanish: /\s+en .*?\)/g,
-    russian: /\s+в .*?\)/g,
-    chinese: /\s+在 .*?\)/g,
-  };
-
-  const detectedLanguages: Language[] = [];
-  for (const lang in languageRegexes) {
-    if (languageRegexes[lang as keyof typeof languageRegexes].test(text)) {
-      const foundLang = languages.find((l) => l.name === lang);
-      if (foundLang) {
-        detectedLanguages.push(foundLang);
-      }
-    }
-  }
-
-  return detectedLanguages;
-};
-
-// Core formatting logic
-const formatStackTrace = (stackTrace: string, selectedLang: Language): Element[] => {
-  const lines = stackTrace.split("\n");
-  const fileAndLineNumberRegEx = new RegExp(`${selectedLang.in} (.+):${selectedLang.line} (\\d+)`);
-  const atRegex = new RegExp(`(\\s*)(${selectedLang.at}) (.+?)\\((.*?)\\)`);
-
-  return lines.map((line) => {
-    const match = line.match(atRegex);
-    if (match) {
-      const [, spaces, , methodWithType, paramsWithFile] = match;
-
-      const [type, method] = (() => {
-        const parts = methodWithType.split(".");
-        const method = parts.pop() ?? "";
-        const type = parts.join(".");
-        return [type, method];
-      })();
-
-      const params = paramsWithFile.split(", ").map((param) => {
-        const [paramType, paramName] = param.split(" ");
-        return { name: paramName, type: paramType };
-      });
-
-      const matchFile = line.match(fileAndLineNumberRegEx);
-      let file, lineNumber;
-      if (matchFile) {
-        [, file, lineNumber] = matchFile;
-      }
-
-      return <Node>{ method, type, params, file, lineNumber, spaces };
-    } else {
-      return line;
-    }
-  });
-};
-
 // Process the provided stack trace
 const processStackTrace = (): void => {
   const rawContent = props.stackTrace;
diff --git a/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.spec.ts b/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.spec.ts
new file mode 100644
index 000000000..f20374ff2
--- /dev/null
+++ b/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.spec.ts
@@ -0,0 +1,295 @@
+import { describe, expect, test } from "vitest";
+import { detectLanguagesInOrder, formatStackTrace, languages, type StackTraceFrame } from "./stacktraceFormatter";
+
+function frame(result: unknown): StackTraceFrame {
+  return result as StackTraceFrame;
+}
+
+const english = languages.find((l) => l.name === "english")!;
+const danish = languages.find((l) => l.name === "danish")!;
+const german = languages.find((l) => l.name === "german")!;
+const spanish = languages.find((l) => l.name === "spanish")!;
+const russian = languages.find((l) => l.name === "russian")!;
+const chinese = languages.find((l) => l.name === "chinese")!;
+
+describe("detectLanguagesInOrder", () => {
+  test("detects English stack trace", () => {
+    const trace = "   at System.String.Format(String format)";
+    const result = detectLanguagesInOrder(trace);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe("english");
+  });
+
+  test("detects Danish stack trace", () => {
+    const trace = "   ved System.String.Format(String format)";
+    const result = detectLanguagesInOrder(trace);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe("danish");
+  });
+
+  test("detects German stack trace", () => {
+    const trace = "   bei System.String.Format(String format)";
+    const result = detectLanguagesInOrder(trace);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe("german");
+  });
+
+  test("detects Spanish stack trace", () => {
+    const trace = "   en System.String.Format(String format)";
+    const result = detectLanguagesInOrder(trace);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe("spanish");
+  });
+
+  test("detects Russian stack trace", () => {
+    const trace = "   в System.String.Format(String format)";
+    const result = detectLanguagesInOrder(trace);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe("russian");
+  });
+
+  test("detects Chinese stack trace", () => {
+    const trace = "   在 System.String.Format(String format)";
+    const result = detectLanguagesInOrder(trace);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe("chinese");
+  });
+
+  test("returns empty array for plain text with no stack frames", () => {
+    const result = detectLanguagesInOrder("This is not a stack trace");
+    expect(result).toHaveLength(0);
+  });
+});
+
+describe("formatStackTrace", () => {
+  describe("exception message lines are not mangled (bug fix)", () => {
+    // Regression test: the atRegex was previously not anchored to the start of the line,
+    // so exception message lines containing ' at ' followed by parenthesized text were
+    // incorrectly matched as stack frames.
+    test("preserves SQL exception message containing 'at' followed by parenthesized text", () => {
+      const trace = [
+        "System.Data.SqlClient.SqlException (0x80131904): A network-related or instance-specific error occurred while establishing a connection to SQL Server. The server was not found or was not accessible. Verify that the instance name is correct and that SQL Server is configured to allow remote connections. (provider: Named Pipes Provider, error: 40 - Could not open a connection to SQL Server)",
+        "   at System.Data.SqlClient.SqlConnection.Open()",
+      ].join("\n");
+
+      const result = formatStackTrace(trace, english);
+
+      expect(typeof result[0]).toBe("string");
+      expect(result[0] as string).toContain("Verify that the instance name is correct");
+      expect(result[0] as string).toContain("provider: Named Pipes Provider");
+    });
+
+    test("exception message line with parenthesized content is not parsed as a frame", () => {
+      const trace = "System.Exception: Something went wrong (see inner exception for details)";
+      const result = formatStackTrace(trace, english);
+      expect(result).toHaveLength(1);
+      expect(typeof result[0]).toBe("string");
+    });
+  });
+
+  describe("English stack frames", () => {
+    test("parses a simple frame with no parameters and no file info", () => {
+      const trace = "   at System.String.Format()";
+      const result = formatStackTrace(trace, english);
+      expect(result).toHaveLength(1);
+      const f = frame(result[0]);
+      expect(f.type).toBe("System.String");
+      expect(f.method).toBe("Format");
+      expect(f.params).toEqual([]);
+      expect(f.file).toBeUndefined();
+      expect(f.lineNumber).toBeUndefined();
+      expect(f.spaces).toBe("   ");
+    });
+
+    test("parses a frame with one parameter", () => {
+      const trace = "   at System.Int32.Parse(String s)";
+      const result = formatStackTrace(trace, english);
+      const f = frame(result[0]);
+      expect(f.type).toBe("System.Int32");
+      expect(f.method).toBe("Parse");
+      expect(f.params).toEqual([{ type: "String", name: "s" }]);
+    });
+
+    test("parses a frame with multiple parameters", () => {
+      const trace = "   at System.Number.ParseInt32(ReadOnlySpan`1 value, NumberStyles styles, NumberFormatInfo info)";
+      const result = formatStackTrace(trace, english);
+      const f = frame(result[0]);
+      expect(f.type).toBe("System.Number");
+      expect(f.method).toBe("ParseInt32");
+      expect(f.params).toEqual([
+        { type: "ReadOnlySpan`1", name: "value" },
+        { type: "NumberStyles", name: "styles" },
+        { type: "NumberFormatInfo", name: "info" },
+      ]);
+    });
+
+    test("parses a frame with file path and line number", () => {
+      const trace = "   at MyNamespace.IntParser.Execute(String s) in C:\\apps\\MyNamespace\\IntParser.cs:line 13";
+      const result = formatStackTrace(trace, english);
+      const f = frame(result[0]);
+      expect(f.type).toBe("MyNamespace.IntParser");
+      expect(f.method).toBe("Execute");
+      expect(f.file).toBe("C:\\apps\\MyNamespace\\IntParser.cs");
+      expect(f.lineNumber).toBe("13");
+    });
+
+    test("passes non-frame lines through as strings", () => {
+      const trace = [
+        "System.ApplicationException: Runtime error",
+        " ---> System.FormatException: The input string was not formatted correctly.",
+        "   at System.Number.ThrowOverflowOrFormatException(ParsingStatus status, TypeCode type)",
+        "   --- End of stack trace from previous location ---",
+      ].join("\n");
+
+      const result = formatStackTrace(trace, english);
+      expect(typeof result[0]).toBe("string");
+      expect(typeof result[1]).toBe("string");
+      expect(typeof result[2]).toBe("object");
+      expect(typeof result[3]).toBe("string");
+    });
+
+    test("parses a deeply namespaced type and method", () => {
+      const trace = "   at MyApp.Controllers.AccountController.ChangeEmail(String secret)";
+      const result = formatStackTrace(trace, english);
+      const f = frame(result[0]);
+      expect(f.type).toBe("MyApp.Controllers.AccountController");
+      expect(f.method).toBe("ChangeEmail");
+      expect(f.params).toEqual([{ type: "String", name: "secret" }]);
+    });
+
+    test("preserves indentation whitespace in spaces field", () => {
+      const trace = "      at System.String.Format()";
+      const result = formatStackTrace(trace, english);
+      const f = frame(result[0]);
+      expect(f.spaces).toBe("      ");
+    });
+
+    test("parses full real-world English trace with mixed frame and non-frame lines", () => {
+      const trace = [
+        "System.ApplicationException: Runtime error",
+        " ---> System.FormatException: The input string was not formatted correctly.",
+        "   at System.Number.ThrowOverflowOrFormatException(ParsingStatus status, TypeCode type)",
+        "   at System.Number.ParseInt32(ReadOnlySpan`1 value, NumberStyles styles, NumberFormatInfo info)",
+        "   at System.Int32.Parse(String s)",
+        "   at MyNamespace.IntParser.Execute(String s) in C:\\apps\\MyNamespace\\IntParser.cs:line 13",
+        "   --- End of stack trace from previous location where exception was thrown ---",
+        "   at MyNamespace.Program.Main(String[] args) in C:\\apps\\MyNamespace\\Program.cs:line 13",
+      ].join("\n");
+
+      const result = formatStackTrace(trace, english);
+      expect(typeof result[0]).toBe("string");
+      expect(typeof result[1]).toBe("string");
+      expect(typeof result[2]).toBe("object");
+      expect(typeof result[3]).toBe("object");
+      expect(typeof result[4]).toBe("object");
+      expect(typeof result[5]).toBe("object");
+      expect(typeof result[6]).toBe("string");
+      expect(typeof result[7]).toBe("object");
+
+      const executeFrame = frame(result[5]);
+      expect(executeFrame.file).toBe("C:\\apps\\MyNamespace\\IntParser.cs");
+      expect(executeFrame.lineNumber).toBe("13");
+    });
+
+    test("preserves ServiceBus exception message containing URLs and parenthesized content", () => {
+      const trace = [
+        "Azure.Messaging.ServiceBus.ServiceBusException: The lock supplied is invalid. Either the lock expired, or the message has already been removed from the queue, or was received by a different receiver instance. (MessageLockLost). For troubleshooting information, see https://aka.ms/azsdk/net/servicebus/exceptions/troubleshoot.",
+        "   at Azure.Messaging.ServiceBus.Amqp.AmqpReceiver.ThrowLockLostException()",
+        "   at Azure.Messaging.ServiceBus.Amqp.AmqpReceiver.DisposeMessageAsync(Guid lockToken, Outcome outcome, TimeSpan timeout)",
+      ].join("\n");
+
+      const result = formatStackTrace(trace, english);
+      expect(typeof result[0]).toBe("string");
+      expect(result[0] as string).toContain("ServiceBusException");
+      expect(result[0] as string).toContain("MessageLockLost");
+
+      const f = frame(result[1]);
+      expect(f.type).toBe("Azure.Messaging.ServiceBus.Amqp.AmqpReceiver");
+      expect(f.method).toBe("ThrowLockLostException");
+    });
+  });
+
+  describe("Danish stack frames", () => {
+    test("parses a Danish frame with file and line", () => {
+      const trace = "   ved MyNamespace.IntParser.Execute(String s) i C:\\apps\\MyNamespace\\IntParser.cs:linje 13";
+      const result = formatStackTrace(trace, danish);
+      const f = frame(result[0]);
+      expect(f.type).toBe("MyNamespace.IntParser");
+      expect(f.method).toBe("Execute");
+      expect(f.file).toBe("C:\\apps\\MyNamespace\\IntParser.cs");
+      expect(f.lineNumber).toBe("13");
+    });
+
+    test("passes non-frame Danish lines through as strings", () => {
+      const trace = "System.ApplicationException: Kørselsfejl";
+      const result = formatStackTrace(trace, danish);
+      expect(typeof result[0]).toBe("string");
+    });
+  });
+
+  describe("German stack frames", () => {
+    test("parses a German frame with file and line", () => {
+      const trace = "   bei MyNamespace.IntParser.Execute(String s) in C:\\apps\\MyNamespace\\IntParser.cs:Zeile 13";
+      const result = formatStackTrace(trace, german);
+      const f = frame(result[0]);
+      expect(f.type).toBe("MyNamespace.IntParser");
+      expect(f.method).toBe("Execute");
+      expect(f.file).toBe("C:\\apps\\MyNamespace\\IntParser.cs");
+      expect(f.lineNumber).toBe("13");
+    });
+  });
+
+  describe("Spanish stack frames", () => {
+    test("parses a Spanish frame type and method", () => {
+      const trace = "   en WinForm_gRPC.Form1.btnLogin_Click(Object sender, EventArgs e) en C:\\Users\\2590\\source\\repos\\WinForm_gRPC\\WinForm_gRPC\\Form1.cs:línea 135";
+      const result = formatStackTrace(trace, spanish);
+      const f = frame(result[0]);
+      expect(f.type).toBe("WinForm_gRPC.Form1");
+      expect(f.method).toBe("btnLogin_Click");
+      expect(f.lineNumber).toBe("135");
+    });
+  });
+
+  describe("Russian stack frames", () => {
+    test("parses a Russian frame type and method", () => {
+      const trace = "   в MyNamespace.IntParser.Execute(String s) в C:\\apps\\MyNamespace\\IntParser.cs:строка 13";
+      const result = formatStackTrace(trace, russian);
+      const f = frame(result[0]);
+      expect(f.type).toBe("MyNamespace.IntParser");
+      expect(f.method).toBe("Execute");
+      expect(f.lineNumber).toBe("13");
+    });
+  });
+
+  describe("Chinese stack frames", () => {
+    test("parses a Chinese frame without file info", () => {
+      const trace = "   在 System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw()";
+      const result = formatStackTrace(trace, chinese);
+      const f = frame(result[0]);
+      expect(f.type).toBe("System.Runtime.ExceptionServices.ExceptionDispatchInfo");
+      expect(f.method).toBe("Throw");
+    });
+  });
+
+  describe("edge cases", () => {
+    test("returns single text element for a plain string with no stack frames", () => {
+      const result = formatStackTrace("This is not a stack trace", english);
+      expect(result).toHaveLength(1);
+      expect(typeof result[0]).toBe("string");
+      expect(result[0]).toBe("This is not a stack trace");
+    });
+
+    test("empty string produces one empty string element", () => {
+      const result = formatStackTrace("", english);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toBe("");
+    });
+
+    test("frame line without leading whitespace is not parsed as a frame", () => {
+      // The atRegex requires at least one leading whitespace character, so a bare 'at' at the start of a line is not matched
+      const trace = "at System.String.Format(String format)";
+      const result = formatStackTrace(trace, english);
+      expect(typeof result[0]).toBe("string");
+    });
+  });
+});
diff --git a/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.ts b/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.ts
new file mode 100644
index 000000000..96d7b9e0c
--- /dev/null
+++ b/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.ts
@@ -0,0 +1,88 @@
+export interface Language {
+  name: string;
+  at: string;
+  in: string;
+  line: string;
+}
+
+export type StackTraceText = string;
+
+export interface StackTraceFrame {
+  params: Array<{ name: string; type: string }>;
+  type: string;
+  lineNumber?: string;
+  file?: string;
+  method: string;
+  spaces: string;
+}
+
+export type StackTraceElement = StackTraceText | StackTraceFrame;
+
+export const languages: Language[] = [
+  { name: "english", at: "at", in: "in", line: "line" },
+  { name: "danish", at: "ved", in: "i", line: "linje" },
+  { name: "german", at: "bei", in: "in", line: "Zeile" },
+  { name: "spanish", at: "en", in: "en", line: "línea" },
+  { name: "russian", at: "в", in: "в", line: "строка" },
+  { name: "chinese", at: "在", in: "位置", line: "行号" },
+];
+
+export const detectLanguagesInOrder = (text: string): Language[] => {
+  const languageRegexes = {
+    english: /\s+at .*?\)/g,
+    danish: /\s+ved .*?\)/g,
+    german: /\s+bei .*?\)/g,
+    spanish: /\s+en .*?\)/g,
+    russian: /\s+в .*?\)/g,
+    chinese: /\s+在 .*?\)/g,
+  };
+
+  const detectedLanguages: Language[] = [];
+  for (const lang in languageRegexes) {
+    if (languageRegexes[lang as keyof typeof languageRegexes].test(text)) {
+      const foundLang = languages.find((l) => l.name === lang);
+      if (foundLang) {
+        detectedLanguages.push(foundLang);
+      }
+    }
+  }
+
+  return detectedLanguages;
+};
+
+export const formatStackTrace = (stackTrace: string, selectedLang: Language): StackTraceElement[] => {
+  const lines = stackTrace.split("\n");
+  const fileAndLineNumberRegEx = new RegExp(`${selectedLang.in} (.+):${selectedLang.line} (\\d+)`);
+  const atRegex = new RegExp(`^(\\s+)(${selectedLang.at}) (.+?)\\((.*?)\\)`);
+
+  return lines.map((line) => {
+    const match = line.match(atRegex);
+    if (match) {
+      const [, spaces, , methodWithType, paramsWithFile] = match;
+
+      const [type, method] = (() => {
+        const parts = methodWithType.split(".");
+        const method = parts.pop() ?? "";
+        const type = parts.join(".");
+        return [type, method];
+      })();
+
+      const params = paramsWithFile
+        ? paramsWithFile.split(", ").map((param) => {
+            const [paramType, paramName] = param.split(" ");
+            return { name: paramName, type: paramType };
+          })
+        : [];
+
+      const matchFile = line.match(fileAndLineNumberRegEx);
+      let file, lineNumber;
+      if (matchFile) {
+        [, file, lineNumber] = matchFile;
+      }
+
+      return { method, type, params, file, lineNumber, spaces } satisfies StackTraceFrame;
+    } else {
+      return line;
+    }
+  });
+};