diff --git a/agent/languageDetect.ts b/agent/languageDetect.ts
index 2cd4de3..0442635 100644
--- a/agent/languageDetect.ts
+++ b/agent/languageDetect.ts
@@ -26,14 +26,6 @@ const USER_LANGUAGE_OUTPUT_SCHEMA = {
   },
 } as const;
 
-export function formatLanguagePrompt(language: UserLanguage | null) {
-  if (!language) {
-    return "Respond in the user's language.";
-  }
-
-  return `Respond in ${language.language} (${language.code}).`;
-}
-
 function parseUserLanguage(content: string | undefined): UserLanguage | null {
   if (!content) {
     return null;
diff --git a/agent/simpleAgent.ts b/agent/simpleAgent.ts
index 2a5e008..60933c3 100644
--- a/agent/simpleAgent.ts
+++ b/agent/simpleAgent.ts
@@ -4,7 +4,6 @@ import {
   logger,
   type AdminUser,
   type CompletionAdapter,
-  type HttpExtra,
   type IAdminForth,
 } from "adminforth";
 import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
@@ -26,8 +25,8 @@ export const contextSchema = z.object({
   userTimeZone: z.string(),
   sessionId: z.string(),
   turnId: z.string(),
+  abortSignal: z.custom<AbortSignal>().optional(),
   currentPage: z.custom<CurrentPageContext>().optional(),
-  httpExtra: z.custom<Partial<HttpExtra>>().optional(),
   emitToolCallEvent: z.custom<ToolCallEventSink>(),
 });
 
@@ -234,8 +233,8 @@ export async function callAgent(params: {
   sessionId: string;
   turnId: string;
   currentPage?: CurrentPageContext;
-  httpExtra?: Partial<HttpExtra>;
   userTimeZone: string;
+  abortSignal?: AbortSignal;
   emitToolCallEvent: ToolCallEventSink;
   sequenceDebugSink: SequenceDebugModelCallSink;
 }) {
@@ -253,8 +252,8 @@ export async function callAgent(params: {
     sessionId,
     turnId,
     currentPage,
-    httpExtra,
     userTimeZone,
+    abortSignal,
     emitToolCallEvent,
     sequenceDebugSink,
   } = params;
@@ -289,6 +288,7 @@ export async function callAgent(params: {
     streamMode: "messages",
     recursionLimit: 100,
     callbacks: [createAgentLlmMetricsLogger()],
+    signal: abortSignal,
     configurable: {
       thread_id: sessionId,
     },
@@ -297,8 +297,8 @@ export async function callAgent(params: {
       userTimeZone,
       sessionId,
       turnId,
+      abortSignal,
       currentPage,
-      httpExtra,
       emitToolCallEvent,
     },
   });
diff --git a/agent/systemPrompt.ts b/agent/systemPrompt.ts
index 76c0e51..35052df 100644
--- a/agent/systemPrompt.ts
+++ b/agent/systemPrompt.ts
@@ -1,10 +1,10 @@
-import type { AdminForthResource, IAdminForth } from "adminforth";
+import type { AdminForthResource, AdminUser, IAdminForth } from "adminforth";
+import type { UserLanguage } from "./languageDetect.js";
 import {
   listBundledSkillManifests,
   listProjectSkillManifests,
   type AgentSkillManifest,
 } from "./skills/registry.js";
-import { ALWAYS_AVAILABLE_API_TOOL_NAMES } from "./tools/index.js";
 
 export const DEFAULT_AGENT_SYSTEM_PROMPT = [
   "You are helpful AI Assistant for Admin Panel.",
@@ -46,6 +46,39 @@ export function appendCustomSystemPrompt(
   return `${systemPrompt}\n\n${normalizedCustomSystemPrompt}`;
 }
 
+function formatLanguagePrompt(language: UserLanguage | null) {
+  if (!language) {
+    return "Respond in the user's language.";
+  }
+
+  return `Respond in ${language.language} (${language.code}).`;
+}
+
+function formatAdminUserPrompt(adminUser: AdminUser, usernameField: string) {
+  const adminUserContext = {
+    id: adminUser.pk,
+    email: adminUser.dbUser[usernameField],
+  };
+  return [
+    "Current admin user context:",
+    JSON.stringify(adminUserContext, null, 2),
+    "Use this admin user email when the user asks to send information to themselves, the current admin, or the logged-in user.",
+  ].join("\n");
+}
+
+export function buildAgentTurnSystemPrompt(input: {
+  agentSystemPrompt: string;
+  adminUser: AdminUser;
+  usernameField: string;
+  userLanguage: UserLanguage | null;
+}) {
+  return [
+    input.agentSystemPrompt,
+    formatAdminUserPrompt(input.adminUser, input.usernameField),
+    formatLanguagePrompt(input.userLanguage),
+  ].join("\n\n");
+}
+
 function formatResources(resources: AdminForthResource[]) {
   return resources
     .map((resource) => `- resourceId: ${resource.resourceId}\n  label: ${resource.label}`)
@@ -66,7 +99,6 @@ export async function buildAgentSystemPrompt(
     listProjectSkillManifests(adminforth.config.customization.customComponentsDir),
     listBundledSkillManifests(),
   ]);
-  const alwaysAvailableTools = ALWAYS_AVAILABLE_API_TOOL_NAMES.join(", ");
   const adminBasePath = adminforth.config.baseUrlSlashed;
   const hiddenResourceIdSet = new Set(hiddenResourceIds);
   const visibleResources = adminforth.config.resources.filter(
@@ -76,7 +108,6 @@ export async function buildAgentSystemPrompt(
     DEFAULT_AGENT_SYSTEM_PROMPT,
     `ADMIN_BASE_PATH: ${adminBasePath}`,
     `List of resources:\n${formatResources(visibleResources)}`,
-    `You have always-available base tools: ${alwaysAvailableTools}.`,
     primarySkills.length > 0
       ? `You have primary skills set:\n${formatSkills(primarySkills, "skill_name")}`
       : "",
diff --git a/agent/toolCallEvents.ts b/agent/toolCallEvents.ts
index a5c1ecb..63eda7e 100644
--- a/agent/toolCallEvents.ts
+++ b/agent/toolCallEvents.ts
@@ -1,6 +1,5 @@
 import { randomUUID } from "crypto";
 import YAML from "yaml";
-import { serializeUnknownError } from "../apiBasedTools.js";
 
 export type ToolCallEvent =
   | {
@@ -61,6 +60,36 @@ function sanitizeToolCallOutputForDebug(output: unknown) {
   );
 }
 
+function serializeErrorForDebug(error: unknown): unknown {
+  if (!(error instanceof Error)) {
+    return error;
+  }
+
+  const errorWithCause = error as Error & { cause?: unknown };
+  const serialized: Record<string, unknown> = {
+    name: error.name,
+    message: error.message,
+  };
+
+  if (error.stack) {
+    serialized.stack = error.stack;
+  }
+
+  if (errorWithCause.cause !== undefined) {
+    serialized.cause = serializeErrorForDebug(errorWithCause.cause);
+  }
+
+  for (const key of Object.getOwnPropertyNames(error)) {
+    if (key in serialized) {
+      continue;
+    }
+
+    serialized[key] = (error as unknown as Record<string, unknown>)[key];
+  }
+
+  return serialized;
+}
+
 export function createToolCallTracker(params: {
   emit: ToolCallEventSink;
   toolCallId?: string;
@@ -99,7 +128,7 @@ export function createToolCallTracker(params: {
         phase: "end",
         durationMs: Date.now() - startedAt,
         output: null,
-        error: YAML.stringify(serializeUnknownError(error)).trimEnd(),
+        error: YAML.stringify(serializeErrorForDebug(error)).trimEnd(),
       });
     },
   };
diff --git a/agent/tools/apiTool.ts b/agent/tools/apiTool.ts
index 71e1ee2..d6f598a 100644
--- a/agent/tools/apiTool.ts
+++ b/agent/tools/apiTool.ts
@@ -51,7 +51,7 @@ export function createApiTool(toolName: string, apiBasedTool: ApiBasedTool) {
       const normalizedInput = (input ?? {}) as Record<string, unknown>;
       return apiBasedTool.call({
         adminUser: runtime.context.adminUser,
-        httpExtra: runtime.context.httpExtra,
+        abortSignal: runtime.context.abortSignal,
         inputs: normalizedInput,
         userTimeZone: runtime.context.userTimeZone,
       });
diff --git a/agentResponseEvents.ts b/agentResponseEvents.ts
new file mode 100644
index 0000000..fc401fd
--- /dev/null
+++ b/agentResponseEvents.ts
@@ -0,0 +1,197 @@
+import { randomUUID } from "crypto";
+
+import type { ToolCallEvent } from "./agent/toolCallEvents.js";
+
+type AgentEventStreamResponse = {
+  writeHead: (statusCode: number, headers: Record<string, string>) => void;
+  write: (chunk: string) => unknown;
+  end: () => unknown;
+  writableEnded: boolean;
+  destroyed: boolean;
+};
+
+type AgentEventStreamOptions = {
+  vercelAiUiMessageStream?: boolean;
+  closeActiveBlockOnToolStart?: boolean;
+};
+
+export function createAgentEventStream(
+  res: AgentEventStreamResponse,
+  options: AgentEventStreamOptions = {},
+) {
+  let isStreamClosed = false;
+  let activeBlock: { type: "text" | "reasoning"; id: string } | null = null;
+
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive",
+    ...(options.vercelAiUiMessageStream
+      ? { "x-vercel-ai-ui-message-stream": "v1" }
+      : {}),
+  });
+
+  const stream = {
+    send(obj: unknown) {
+      if (isStreamClosed || res.writableEnded || res.destroyed) {
+        return;
+      }
+
+      res.write(`data: ${JSON.stringify(obj)}\n\n`);
+    },
+
+    endActiveBlock() {
+      if (!activeBlock) {
+        return;
+      }
+
+      stream.send({
+        type: `${activeBlock.type}-end`,
+        id: activeBlock.id,
+      });
+
+      activeBlock = null;
+    },
+
+    startBlock(type: "text" | "reasoning") {
+      if (activeBlock?.type === type) {
+        return activeBlock.id;
+      }
+
+      stream.endActiveBlock();
+
+      const id = randomUUID();
+      activeBlock = { type, id };
+
+      stream.send({
+        type: `${type}-start`,
+        id,
+      });
+
+      return id;
+    },
+
+    start(messageId: string) {
+      stream.send({
+        type: "start",
+        messageId,
+      });
+    },
+
+    textDelta(delta: string) {
+      const textId = stream.startBlock("text");
+      stream.send({
+        type: "text-delta",
+        id: textId,
+        delta,
+      });
+    },
+
+    reasoningDelta(delta: string) {
+      const reasoningId = stream.startBlock("reasoning");
+      stream.send({
+        type: "reasoning-delta",
+        id: reasoningId,
+        delta,
+      });
+    },
+
+    toolCall(event: ToolCallEvent) {
+      if (options.closeActiveBlockOnToolStart && event.phase === "start") {
+        stream.endActiveBlock();
+      }
+
+      stream.send({
+        type: "data-tool-call",
+        data: event,
+      });
+    },
+
+    transcript(text: string, language?: string) {
+      stream.send({
+        type: "transcript",
+        data: {
+          text,
+          language,
+        },
+      });
+    },
+
+    response(text: string, sessionId: string, turnId: string) {
+      stream.send({
+        type: "response",
+        data: {
+          text,
+          sessionId,
+          turnId,
+        },
+      });
+    },
+
+    speechResponse(
+      transcript: { text: string; language?: string },
+      response: { text: string },
+      sessionId: string,
+      turnId: string,
+    ) {
+      stream.send({
+        type: "speech-response",
+        data: {
+          transcript,
+          response,
+          sessionId,
+          turnId,
+        },
+      });
+    },
+
+    audioStart(mimeType: string, format: string) {
+      stream.send({
+        type: "audio-start",
+        data: {
+          mimeType,
+          format,
+        },
+      });
+    },
+
+    audioDelta(value: Uint8Array) {
+      stream.send({
+        type: "audio-delta",
+        data: {
+          base64: Buffer.from(value).toString("base64"),
+        },
+      });
+    },
+
+    audioDone() {
+      stream.send({
+        type: "audio-done",
+      });
+    },
+
+    error(error: string) {
+      stream.send({
+        type: "error",
+        error,
+      });
+    },
+
+    end() {
+      if (isStreamClosed || res.writableEnded || res.destroyed) {
+        return;
+      }
+
+      stream.endActiveBlock();
+      stream.send({
+        type: "finish",
+      });
+
+      res.write("data: [DONE]\n\n");
+      isStreamClosed = true;
+      res.end();
+    },
+  };
+
+  return stream;
+}
diff --git a/apiBasedTools.ts b/apiBasedTools.ts
index aa7fa4e..3d6a0e5 100644
--- a/apiBasedTools.ts
+++ b/apiBasedTools.ts
@@ -2,35 +2,26 @@ import {
   AdminForthDataTypes,
   logger,
   type AdminUser,
-  type HttpExtra,
   type IAdminForth,
+  type IAdminForthHttpResponse,
   type IRegisteredApiSchema,
 } from 'adminforth';
 import dayjs from 'dayjs';
 import timezone from 'dayjs/plugin/timezone.js';
 import utc from 'dayjs/plugin/utc.js';
-import { inspect } from 'util';
 import YAML from 'yaml';
 
 dayjs.extend(utc);
 dayjs.extend(timezone);
 
-type CookieItem = {
-  key: string;
-  value: string;
-};
-
-type ToolOverrideCallParams = Pick<ApiBasedToolCallParams, 'httpExtra' | 'inputs' | 'userTimeZone'>;
 
 type ToolOverrideContext = {
   adminforth: IAdminForth;
   output?: unknown;
   adminUser?: AdminUser;
-  httpExtra?: Partial<HttpExtra>;
   inputs?: Record<string, unknown>;
   resourceLabel?: string;
   userTimeZone?: string;
-  invokeTool: (toolName: string, params?: ToolOverrideCallParams) => Promise<unknown>;
 };
 
 type ToolOverride = {
@@ -46,12 +37,16 @@ type GetResourceDataToolResponse = {
 };
 
 type DateTimeColumnType = AdminForthDataTypes.DATETIME | AdminForthDataTypes.TIME;
-type InternalApiOriginProvider = {
-  getInternalApiOrigin?: () => string | undefined;
+type RegisteredApiToolSchema = IRegisteredApiSchema & {
+  handler: (input: unknown) => void | Promise<unknown>;
 };
 
 const DEFAULT_USER_TIME_ZONE = 'UTC';
 
+function hasRegisteredApiToolHandler(schema: IRegisteredApiSchema): schema is RegisteredApiToolSchema {
+  return typeof (schema as { handler?: unknown }).handler === 'function';
+}
+
 function getInputString(inputs: Record<string, unknown> | undefined, key: string) {
   const value = inputs?.[key];
 
@@ -171,15 +166,14 @@ const TOOL_OVERRIDES: Record<string, ToolOverride> = {
 export type ApiBasedToolCallParams = {
   adminUser?: AdminUser;
   adminuser?: AdminUser;
+  abortSignal?: AbortSignal;
   inputs?: Record<string, unknown>;
-  httpExtra?: Partial<HttpExtra>;
   userTimeZone?: string;
 };
 
 export type ApiBasedTool = {
   description?: string;
   input_schema?: unknown;
-  input_schma?: unknown;
   output_schema?: unknown;
   call: (params?: ApiBasedToolCallParams) => Promise<string>;
 };
@@ -228,44 +222,6 @@ function sanitizeForYaml(
   return JSON.parse(serialized);
 }
 
-export function serializeUnknownError(error: unknown): Record<string, unknown> {
-  if (error instanceof Error) {
-    const errorWithCause = error as Error & { cause?: unknown };
-    const errorRecord = error as unknown as Record<string, unknown>;
-    const serialized: Record<string, unknown> = {
-      name: error.name,
-      message: error.message,
-      stack: error.stack,
-    };
-
-    if (errorWithCause.cause !== undefined) {
-      serialized.cause = serializeUnknownError(errorWithCause.cause);
-    }
-
-    for (const key of Object.getOwnPropertyNames(error)) {
-      if (key in serialized) {
-        continue;
-      }
-
-      serialized[key] = errorRecord[key];
-    }
-
-    return serialized;
-  }
-
-  if (typeof error === 'object' && error !== null) {
-    return {
-      type: error.constructor?.name ?? 'Object',
-      inspected: inspect(error, { depth: 6, breakLength: 120 }),
-    };
-  }
-
-  return {
-    type: typeof error,
-    value: error,
-  };
-}
-
 function wipePath(target: unknown, pathParts: string[]): void {
   if (!target || typeof target !== 'object' || pathParts.length === 0) {
     return;
@@ -367,23 +323,12 @@ function formatDateTimeColumns(
 async function applyToolOverride(params: {
   adminforth: IAdminForth;
   adminUser?: AdminUser;
-  httpExtra?: Partial<HttpExtra>;
   inputs?: Record<string, unknown>;
-  invokeTool: (toolName: string, params?: ToolOverrideCallParams) => Promise<unknown>;
   output: unknown;
   toolName: string;
   userTimeZone?: string;
 }): Promise<unknown> {
-  const {
-    adminforth,
-    adminUser,
-    httpExtra,
-    inputs,
-    invokeTool,
-    output,
-    toolName,
-    userTimeZone,
-  } = params;
+  const { adminforth, adminUser, inputs, output, toolName, userTimeZone } = params;
   const sanitizedOutput = sanitizeForYaml(output);
   const override = TOOL_OVERRIDES[toolName];
 
@@ -395,41 +340,15 @@ async function applyToolOverride(params: {
     wipePath(sanitizedOutput, path.split('.'));
   }
 
-  if (!override.post_process_response) {
-    return sanitizedOutput;
-  }
-
-  const postProcessedOutput = await override.post_process_response({
-    adminforth,
-    output: sanitizedOutput,
-    adminUser,
-    httpExtra,
-    inputs,
-    userTimeZone,
-    invokeTool: async (nestedToolName, nestedParams = {}) => {
-      const nestedInputs = nestedParams.inputs ?? inputs;
-      const nestedHttpExtra = nestedParams.httpExtra ?? httpExtra;
-      const nestedUserTimeZone = nestedParams.userTimeZone ?? userTimeZone;
-      const nestedOutput = await invokeTool(nestedToolName, {
-        inputs: nestedInputs,
-        httpExtra: nestedHttpExtra,
-        userTimeZone: nestedUserTimeZone,
-      });
-
-      return applyToolOverride({
+  return override.post_process_response
+    ? sanitizeForYaml(await override.post_process_response({
         adminforth,
         adminUser,
-        httpExtra: nestedHttpExtra,
-        inputs: nestedInputs,
-        invokeTool,
-        output: nestedOutput,
-        toolName: nestedToolName,
-        userTimeZone: nestedUserTimeZone,
-      });
-    },
-  });
-
-  return sanitizeForYaml(postProcessedOutput);
+        output: sanitizedOutput,
+        inputs,
+        userTimeZone,
+      }))
+    : sanitizedOutput;
 }
 
 function endpointPathToToolName(path: string) {
@@ -465,40 +384,19 @@ function formatLogNameList(names: string[]) {
 export async function formatApiBasedToolCall(params: {
   adminforth: IAdminForth;
   adminUser?: AdminUser;
-  httpExtra?: Partial<HttpExtra>;
   inputs?: Record<string, unknown>;
   toolName: string;
   userTimeZone?: string;
 }) {
-  const formatTool = TOOL_OVERRIDES[params.toolName]?.format_tool;
-
-  return await formatTool?.({
+  return await TOOL_OVERRIDES[params.toolName]?.format_tool?.({
     adminforth: params.adminforth,
     adminUser: params.adminUser,
-    httpExtra: params.httpExtra,
     inputs: params.inputs,
     resourceLabel: resourceLabel(params.adminforth, params.inputs),
     userTimeZone: params.userTimeZone,
-    invokeTool: async () => {
-      throw new Error('Tool info formatting cannot invoke tools');
-    },
   });
 }
 
-function normalizeCookies(
-  cookies?: Partial<HttpExtra>['cookies'] | Record<string, string>,
-): CookieItem[] {
-  if (!cookies) {
-    return [];
-  }
-
-  if (Array.isArray(cookies)) {
-    return cookies;
-  }
-
-  return Object.entries(cookies).map(([key, value]) => ({ key, value }));
-}
-
 function normalizeDateTimeInputsToUtc(
   body: Record<string, unknown>,
   adminforth: IAdminForth,
@@ -532,10 +430,8 @@ function normalizeDateTimeInputsToUtc(
       return dayjs.tz(value, userTimeZone).utc().toISOString();
     }
 
-    if (columnType === AdminForthDataTypes.TIME) {
-      const userDate = dayjs().tz(userTimeZone).format('YYYY-MM-DD');
-      return dayjs.tz(`${userDate}T${value}`, userTimeZone).utc().format('HH:mm:ss');
-    }
+    const userDate = dayjs().tz(userTimeZone).format('YYYY-MM-DD');
+    return dayjs.tz(`${userDate}T${value}`, userTimeZone).utc().format('HH:mm:ss');
   };
 
   const normalizeValue = (value: unknown, key?: string): unknown => {
@@ -577,157 +473,115 @@ function normalizeDateTimeInputsToUtc(
   return normalizeValue(body) as Record<string, unknown>;
 }
 
-const METHODS_WITHOUT_REQUEST_BODY = new Set(['GET', 'HEAD']);
-const HEADERS_NOT_FORWARDED_TO_API_TOOL = new Set([
-  'connection',
-  'content-length',
-  'host',
-  'keep-alive',
-  'proxy-authenticate',
-  'proxy-authorization',
-  'te',
-  'trailer',
-  'transfer-encoding',
-  'upgrade',
-]);
-
-function isAbsoluteHttpUrl(value: string) {
-  try {
-    const url = new URL(value);
-    return url.protocol === 'http:' || url.protocol === 'https:';
-  } catch {
-    return false;
-  }
-}
-
-function resolveOpenApiRequestUrl(params: {
-  adminforth: IAdminForth;
-  path: string;
-  toolName: string;
-}) {
-  const internalApiOrigin = (params.adminforth.express as InternalApiOriginProvider)
-    .getInternalApiOrigin?.();
-
-  if (internalApiOrigin) {
-    const path = isAbsoluteHttpUrl(params.path)
-      ? `${new URL(params.path).pathname}${new URL(params.path).search}`
-      : params.path;
+const METHODS_WITHOUT_REQUEST_BODY = new Set<string>(['GET', 'HEAD']);
 
-    return new URL(path, internalApiOrigin).toString();
-  }
+function createDirectToolResponse(): IAdminForthHttpResponse & {
+  headers: Array<[string, string]>;
+  status: number;
+  message?: string;
+} {
+  const headers: Array<[string, string]> = [];
 
-  throw new Error(
-    `Tool "${params.toolName}" cannot call OpenAPI path "${params.path}" because internal API origin is unavailable.`,
-  );
+  return {
+    headers,
+    status: 200,
+    setHeader(name, value) {
+      headers.push([name, value]);
+    },
+    setStatus(code, message) {
+      this.status = code;
+      this.message = message;
+    },
+    blobStream() {
+      throw new Error('blobStream is not available for API-based agent tools');
+    },
+  };
 }
 
-function createToolRequestHeaders(
-  httpExtra: Partial<HttpExtra> | undefined,
-  userTimeZone?: string,
+function validationErrorResponse(
+  error: 'REQUEST_VALIDATION_FAILED' | 'RESPONSE_VALIDATION_FAILED',
+  details: unknown,
 ) {
-  const headers: Record<string, string> = {};
-
-  for (const [name, value] of Object.entries(httpExtra?.headers ?? {})) {
-    const headerName = name.toLowerCase();
-
-    if (typeof value === 'string' && !HEADERS_NOT_FORWARDED_TO_API_TOOL.has(headerName)) {
-      headers[headerName] = value;
-    }
-  }
-
-  headers.accept = 'application/json';
-  headers['content-type'] = 'application/json';
-
-  if (userTimeZone) {
-    headers['x-timezone'] = userTimeZone;
-  }
-
-  const cookieHeader = normalizeCookies(httpExtra?.cookies)
-    .map(({ key, value }) => `${key}=${value}`)
-    .join('; ');
-
-  if (cookieHeader && !headers.cookie) {
-    headers.cookie = cookieHeader;
-  }
-
-  return headers;
-}
-
-function appendInputsToQueryString(url: string, inputs: Record<string, unknown>) {
-  const nextUrl = new URL(url);
-
-  for (const [key, value] of Object.entries(inputs)) {
-    if (value === undefined) {
-      continue;
-    }
-
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        nextUrl.searchParams.append(
-          key,
-          typeof item === 'object' && item !== null ? JSON.stringify(item) : String(item),
-        );
-      }
-      continue;
-    }
-
-    nextUrl.searchParams.set(
-      key,
-      typeof value === 'object' && value !== null ? JSON.stringify(value) : String(value),
-    );
-  }
-
-  return nextUrl.toString();
-}
-
-async function parseOpenApiToolResponse(response: Response) {
-  const responseText = await response.text();
-  const payload = responseText && response.headers.get('content-type')?.includes('application/json')
-    ? JSON.parse(responseText)
-    : responseText;
-
-  if (response.ok) {
-    return responseText ? payload : { status: response.status };
-  }
-
   return {
-    error: 'HTTP_ERROR',
-    status: response.status,
-    statusText: response.statusText,
-    response: payload,
+    error,
+    details,
   };
 }
 
 async function callOpenApiSchema(params: {
   adminforth: IAdminForth;
-  httpExtra?: Partial<HttpExtra>;
+  adminUser?: AdminUser;
+  abortSignal?: AbortSignal;
   inputs?: Record<string, unknown>;
-  schema: IRegisteredApiSchema;
+  schema: RegisteredApiToolSchema;
   toolName: string;
   userTimeZone?: string;
 }) {
-  const { adminforth, httpExtra, inputs, schema, toolName, userTimeZone } = params;
+  const { adminforth, adminUser, abortSignal, inputs, schema, toolName, userTimeZone } = params;
   const method = schema.method.toUpperCase();
-  const body = normalizeDateTimeInputsToUtc(
-    (inputs ?? httpExtra?.body ?? {}) as Record<string, unknown>,
+  const normalizedInputs = normalizeDateTimeInputsToUtc(
+    (inputs ?? {}) as Record<string, unknown>,
     adminforth,
     userTimeZone,
   );
-  const requestUrl = resolveOpenApiRequestUrl({
-    adminforth,
-    path: schema.path,
-    toolName,
-  });
   const hasRequestBody = !METHODS_WITHOUT_REQUEST_BODY.has(method);
-  logger.info(`Calling OpenAPI tool "${toolName}" with method ${method} at URL ${requestUrl}`);
-  const response = await fetch(hasRequestBody ? requestUrl : appendInputsToQueryString(requestUrl, body), {
-    method,
-    headers: createToolRequestHeaders(httpExtra, userTimeZone),
-    body: hasRequestBody ? JSON.stringify(body) : undefined,
+  const body = hasRequestBody ? normalizedInputs : {};
+  const query = hasRequestBody ? {} : normalizedInputs;
+  const requestValidation = adminforth.openApi.validateRequestSchema(schema, body);
+
+  if (!requestValidation.valid) {
+    return validationErrorResponse('REQUEST_VALIDATION_FAILED', requestValidation.errors);
+  }
+
+  const response = createDirectToolResponse();
+  logger.info(`Calling OpenAPI tool "${toolName}" with direct handler`);
+  const tr = (
+    msg: string,
+    category: string,
+    trParams: unknown,
+    pluralizationNumber?: number,
+  ) => adminforth.tr(msg, category, undefined, trParams, pluralizationNumber);
+  const output = await schema.handler({
+    body,
+    query,
+    headers: {},
+    cookies: [],
+    adminUser,
+    response,
+    requestUrl: schema.path,
+    abortSignal: abortSignal ?? new AbortController().signal,
+    _raw_express_req: undefined as never,
+    _raw_express_res: undefined as never,
+    tr,
   });
-  logger.info(`Received response with status ${response.status} from OpenAPI tool "${toolName}"`);
 
-  return parseOpenApiToolResponse(response);
+  if (response.message) {
+    return response.status >= 400
+      ? {
+        error: 'HANDLER_ERROR',
+        status: response.status,
+        response: response.message,
+      }
+      : response.message;
+  }
+
+  if (output === null) {
+    return { status: response.status };
+  }
+
+  const responseValidation = adminforth.openApi.validateResponseSchema(schema, output);
+
+  if (!responseValidation.valid) {
+    return validationErrorResponse('RESPONSE_VALIDATION_FAILED', responseValidation.errors);
+  }
+
+  return response.status >= 400
+    ? {
+      error: 'HANDLER_ERROR',
+      status: response.status,
+      response: output,
+    }
+    : output;
 }
 
 export function prepareApiBasedTools(
@@ -735,15 +589,15 @@ export function prepareApiBasedTools(
   hiddenResourceIds: Iterable<string> = [],
 ): Record<string, ApiBasedTool> {
   const apiBasedTools: Record<string, ApiBasedTool> = {};
-  const openApiSchemas = adminforth.openApi.registeredSchemas.filter(
-    (schema) => schema.request_schema || schema.response_schema,
-  );
-  const openApiSchemasByToolName = new Map<string, IRegisteredApiSchema>();
+  const openApiSchemas = adminforth.openApi.registeredSchemas;
+  const openApiSchemasByToolName = new Map<string, RegisteredApiToolSchema>();
   const hiddenResourceIdSet = new Set(hiddenResourceIds);
 
   for (const schema of openApiSchemas) {
     const toolName = openApiSchemaPathToToolName(schema.path, adminforth);
-    openApiSchemasByToolName.set(toolName, schema);
+    if (hasRegisteredApiToolHandler(schema)) {
+      openApiSchemasByToolName.set(toolName, schema);
+    }
   }
 
   logger.info(
@@ -759,9 +613,8 @@ export function prepareApiBasedTools(
     apiBasedTools[toolName] = {
       description: schema.description,
       input_schema: schema.request_schema,
-      input_schma: schema.request_schema,
       output_schema: schema.response_schema,
-      call: async ({ adminUser, adminuser, inputs, httpExtra, userTimeZone } = {}) => {
+      call: async ({ adminUser, adminuser, abortSignal, inputs, userTimeZone } = {}) => {
         if (isHiddenResourceCall(hiddenResourceIdSet, inputs)) {
           return YAML.stringify({
             error: 'RESOURCE_NOT_AVAILABLE',
@@ -769,38 +622,20 @@ export function prepareApiBasedTools(
           });
         }
 
-        const invokeTool = async (
-          nextToolName: string,
-          nextParams: ToolOverrideCallParams = {},
-        ) => {
-          const nextSchema = openApiSchemasByToolName.get(nextToolName);
-
-          if (!nextSchema) {
-            throw new Error(`Tool ${nextToolName} is not registered in OpenAPI`);
-          }
-
-          return callOpenApiSchema({
-            adminforth,
-            schema: nextSchema,
-            toolName: nextToolName,
-            inputs: nextParams.inputs,
-            httpExtra: nextParams.httpExtra,
-            userTimeZone: nextParams.userTimeZone,
-          });
-        };
-
-        const output = await invokeTool(toolName, {
+        const output = await callOpenApiSchema({
+          adminforth,
+          adminUser: adminUser ?? adminuser,
+          abortSignal,
+          schema,
+          toolName,
           inputs,
-          httpExtra,
           userTimeZone,
         });
 
         const processedOutput = await applyToolOverride({
           adminforth,
           adminUser: adminUser ?? adminuser,
-          httpExtra,
           inputs,
-          invokeTool,
           output,
           toolName,
           userTimeZone,
@@ -822,7 +657,6 @@ export function serializeApiBasedTool(tool: ApiBasedTool | undefined) {
   return {
     description: tool.description,
     input_schema: tool.input_schema,
-    input_schma: tool.input_schma,
     output_schema: tool.output_schema,
     call: '[Function]',
   };
diff --git a/custom/ChatSurface.vue b/custom/ChatSurface.vue
index 99b02d7..05ff977 100644
--- a/custom/ChatSurface.vue
+++ b/custom/ChatSurface.vue
@@ -118,8 +118,12 @@
               transition: `transform ${agentTransitions.TRANSITION_DURATION}ms ease-in-out`
             }"            
           >
-            <div class="w-full border rounded-lg pb-8 dark:bg-gray-700">
+            <div 
+              class="w-full border rounded-lg pb-8 dark:bg-gray-700"
+              :class="agentStore.isAudioChatMode ? 'border-none mt-8' : 'border'"  
+            >
               <textarea
+                v-if="!agentStore.isAudioChatMode"
                 v-model="agentStore.userMessageInput"
                 ref="textInput"
                 @input="autoResize"
@@ -169,26 +173,29 @@
                   </button>
                 </div>
               </div>
-              <Button 
-                v-if="!agentStore.isResponseInProgress"
-                class="absolute right-4 bottom-2 !p-0 h-9 w-9"                    
-                @click="sendMessage" 
-                :disabled="!agentStore.trimmedUserMessage || agentStore.isResponseInProgress"
-              >
-                <IconArrowUpOutline 
-                  class="w-8 h-8 p-1
-                    text-white" 
-                />
-              </Button>
-              <Button
-                v-else
-                class="absolute right-4 bottom-2 !p-0 h-9 w-9"    
-                @click="stopCurrentRequest"                
-              >
-                <div
-                  class="w-3 h-3 bg-white rounded-sm"
-                />
-              </Button>
+              <MicrophoneButton v-if="props.meta.hasAudioAdapter" />
+              <template v-if="!agentStore.isAudioChatMode">
+                <Button 
+                  v-if="!agentStore.isResponseInProgress"
+                  class="absolute right-4 bottom-2 !p-0 h-9 w-9 transition-opacity duration-200"                    
+                  @click="sendMessage" 
+                  :disabled="!agentStore.trimmedUserMessage || agentStore.isResponseInProgress"
+                >
+                  <IconArrowUpOutline 
+                    class="w-8 h-8 p-1
+                      text-white" 
+                  />
+                </Button>
+                <Button
+                  v-else
+                  class="absolute right-4 bottom-2 !p-0 h-9 w-9"    
+                  @click="stopCurrentRequest"                
+                >
+                  <div
+                    class="w-3 h-3 bg-white rounded-sm"
+                  />
+                </Button>
+              </template>
             </div>
           </div>
         </div>
@@ -209,6 +216,7 @@ import { useAgentTransitions } from './composables/useAgentTransitions';
 import { Button } from '@/afcl';
 import { useCoreStore } from '@/stores/core';
 import { remToPx } from './utils';
+import MicrophoneButton from './speech_recognition_frontend/MicrophoneButon.vue';
 
 const props = defineProps<{
   meta: {
@@ -218,6 +226,7 @@ const props = defineProps<{
     }>;
     defaultModeName: string | null;
     stickByDefault: boolean;
+    hasAudioAdapter: boolean;
   }
   adminUser: any
 }>();
@@ -321,6 +330,7 @@ function selectMode(modeName: string) {
 }
 
 async function sendMessage() {
+  if (agentStore.isAudioChatMode) return;
   isModeMenuOpen.value = false;
   await agentStore.sendMessage();
   autoResize();
diff --git a/custom/composables/agentAudio/agent-processing.mp3 b/custom/composables/agentAudio/agent-processing.mp3
new file mode 100644
index 0000000..8307095
Binary files /dev/null and b/custom/composables/agentAudio/agent-processing.mp3 differ
diff --git a/custom/composables/agentStore/constants.ts b/custom/composables/agentStore/constants.ts
index a2a4953..0c66467 100644
--- a/custom/composables/agentStore/constants.ts
+++ b/custom/composables/agentStore/constants.ts
@@ -9,4 +9,11 @@ export const MIN_WIDTH = 25;
 export const DEFAULT_TEXTAREA_PLACEHOLDER = 'Type a message...';
 export const PLACEHOLDER_TYPING_DELAY_MS = 60;
 export const PLACEHOLDER_DELETING_DELAY_MS = 35;
-export const PLACEHOLDER_HOLD_DELAY_MS = 3000;
\ No newline at end of file
+export const PLACEHOLDER_HOLD_DELAY_MS = 3000;
+export const PRE_SESSION_ID = 'pre-session';
+
+export enum RESERVED_SYSTEM_MESSAGE_CONTENT {
+  START_AUDIO_CHAT = 'START_AUDIO_CHAT',
+  END_AUDIO_CHAT = 'END_AUDIO_CHAT',
+  AGENT_RESPONSE_ABORTED = 'AGENT_RESPONSE_ABORTED'
+}
\ No newline at end of file
diff --git a/custom/composables/agentStore/useAgentSessions.ts b/custom/composables/agentStore/useAgentSessions.ts
index 9e458df..e0967ea 100644
--- a/custom/composables/agentStore/useAgentSessions.ts
+++ b/custom/composables/agentStore/useAgentSessions.ts
@@ -2,6 +2,8 @@ import type { ComputedRef, Ref, ShallowRef } from 'vue';
 import { callAdminForthApi } from '@/utils';
 import type { Chat } from '../../chat';
 import type { IAgentSession, ISessionsListItem, IPart } from '../../types';
+import { PRE_SESSION_ID } from './constants';
+import { ChatStatus } from 'ai';
 import { useI18n } from 'vue-i18n';
 
 type AdminforthLike = {
@@ -91,8 +93,8 @@ export function createAgentSessionManager({
   }
 
   async function deletePreSession() {
-    sessionList.value = sessionList.value.filter((s: ISessionsListItem) => s.sessionId !== 'pre-session');
-    if (activeSessionId.value === 'pre-session') {
+    sessionList.value = sessionList.value.filter((s: ISessionsListItem) => s.sessionId !== PRE_SESSION_ID);
+    if (activeSessionId.value === PRE_SESSION_ID) {
       activeSessionId.value = null;
       currentSession.value = null;
     }
@@ -129,7 +131,7 @@ export function createAgentSessionManager({
     if (!message || isResponseInProgress.value) {
       return;
     }
-    if (!currentSession.value || currentSession.value.sessionId === 'pre-session') {
+    if (!currentSession.value || currentSession.value.sessionId === PRE_SESSION_ID) {
       await createNewSession(message);
     }
     currentSession.value!.timestamp = new Date().toISOString();
@@ -146,27 +148,27 @@ export function createAgentSessionManager({
 
   async function createPreSession() {
     saveCurrentSessionInCache();
-    if (!sessionList.value.some((s: ISessionsListItem) => s.sessionId === 'pre-session')) {
+    if (!sessionList.value.some((s: ISessionsListItem) => s.sessionId === PRE_SESSION_ID)) {
       sessionList.value.unshift({
-        sessionId: 'pre-session',
+        sessionId: PRE_SESSION_ID,
         title: 'New Session',
         timestamp: new Date().toISOString(),
       });
     }
 
-    activeSessionId.value = 'pre-session';
+    activeSessionId.value = PRE_SESSION_ID;
     currentSession.value = {
-      sessionId: 'pre-session',
+      sessionId: PRE_SESSION_ID,
       title: 'New Session',
       timestamp: new Date().toISOString(),
       messages: [],
     };
-    sessions.value['pre-session'] = currentSession.value;
-    setCurrentChat('pre-session');
+    sessions.value[PRE_SESSION_ID] = currentSession.value;
+    setCurrentChat(PRE_SESSION_ID);
   }
 
   async function deleteSession(sessionId: string) {
-    if (sessionId === 'pre-session') {
+    if (sessionId === PRE_SESSION_ID) {
       deletePreSession();
       return;
     }
@@ -236,7 +238,10 @@ export function createAgentSessionManager({
     currentChat.value?.messages.push(debugMessage);
   }
 
-  function addSystemMessage(message: string) {
+  async function addSystemMessage(message: string) {
+    if (!currentSession.value || currentSession.value.sessionId === PRE_SESSION_ID) {
+      await createNewSession('Audio chat');
+    }
     const systemMessage = {
       role: 'system',
       parts: [{
@@ -247,7 +252,7 @@ export function createAgentSessionManager({
     };
     currentChat.value?.messages.push(systemMessage);
     try {
-      const res = callAdminForthApi({
+      const res = await callAdminForthApi({
         method: 'POST',
         path: '/agent/add-system-message-to-turns',
         body: {
@@ -260,6 +265,69 @@ export function createAgentSessionManager({
     }
   }
 
+  function addAgentMessage(message: string) {
+    const agentMessage = {
+      role: 'assistant',
+      parts: [{
+        type: 'text',
+        text: message,
+        state: 'done',
+      }]
+    };
+    currentChat.value?.messages.push(agentMessage);
+  }
+
+  function updateLastAgentMessage(message: string) {
+    const lastMsg = currentChat.value?.lastMessage;
+    if (lastMsg && lastMsg.role === 'assistant') {
+      lastMsg.parts = [{
+        type: 'text',
+        text: message,
+        state: 'done',
+      }];
+      currentChat.value?.messages.splice(currentChat.value.messages.length - 1, 1, lastMsg);
+    } else {
+      addAgentMessage(message);
+    }
+  }
+
+  function addUserMessage(message: string) {
+    const userMessage = {
+      role: 'user',
+      parts: [{
+        type: 'text',
+        text: message,
+        state: 'done',
+      }]
+    };
+    currentChat.value?.messages.push(userMessage);
+  }
+
+
+  function addDataToolCallMessage(data: any) {
+    const lastMessage = currentChat.value?.lastMessage;
+    if (lastMessage.role === 'assistant') {
+      lastMessage.parts.push({
+        type: 'data-tool-call',
+        data,
+      });
+      currentChat.value?.messages.splice(currentChat.value.messages.length - 1, 1, lastMessage);
+    } else {
+      const toolCallMessage = {
+        role: 'assistant',
+        parts: [{
+          type: 'data-tool-call',
+          data,
+        }]
+      };
+      currentChat.value?.messages.push(toolCallMessage);
+    }
+  }
+
+  function setCurrentChatStatus(status: ChatStatus) {
+    (currentChat.value as any)?.setStatus({status});
+  }
+
   return {
     sendMessage,
     createPreSession,
@@ -268,5 +336,10 @@ export function createAgentSessionManager({
     deleteSession,
     addDebugMessage,
     addSystemMessage,
+    addAgentMessage,
+    addUserMessage,
+    addDataToolCallMessage,
+    setCurrentChatStatus,
+    updateLastAgentMessage
   };
 }
\ No newline at end of file
diff --git a/custom/composables/useAgentAudio.ts b/custom/composables/useAgentAudio.ts
new file mode 100644
index 0000000..6266c59
--- /dev/null
+++ b/custom/composables/useAgentAudio.ts
@@ -0,0 +1,392 @@
+import adminforth from "@/adminforth";
+import { useAgentStore } from "./useAgentStore";
+import { defineStore } from 'pinia';
+import type { SpeechStreamEvent } from '../types';
+import { ref } from 'vue';
+import { getCurrentPageContext } from './agentStore/pageContext';
+
+type StreamingAudioState = {
+  mimeType: string;
+  mediaSource: MediaSource;
+  sourceBuffer: SourceBuffer | null;
+  pendingChunks: ArrayBuffer[];
+  hasStartedPlayback: boolean;
+  isDone: boolean;
+};
+
+const standByAudio = new Audio('./agentAudio/agent-processing.mp3');
+
+function playStandByAudio() {
+  standByAudio.currentTime = 0;
+  standByAudio.play()
+}
+
+function stopStandByAudio() {
+  standByAudio.pause();
+  standByAudio.currentTime = 0;
+}
+
+function restartStandByAudio() {
+  standByAudio.currentTime = 0;
+  playStandByAudio();
+}
+
+standByAudio.addEventListener('ended', () => {
+  if (!standByAudio.paused) {
+    restartStandByAudio();
+  }
+});
+
+export const useAgentAudio = defineStore('agentAudio', () => {
+  const agentStore = useAgentStore();
+  const agentAudioMode = ref<'transcribing' | 'streaming' | 'fetchingAudio' | 'playingAgentResponse' | null>(null);
+  const isStreamingResponse = ref(false);
+    
+  let currentAbortController: AbortController | null = null;
+  let isPlaying = false;
+  let currentAudio: HTMLAudioElement | null = null;
+  let currentAudioObjectUrl: string | null = null;
+  let currentStreamingAudio: StreamingAudioState | null = null;
+  let bufferedAudioChunks: ArrayBuffer[] = [];
+  let bufferedAudioMimeType = 'audio/mpeg';
+
+  function stopGenerationAndAudio() {
+    agentAudioMode.value = null;
+    stopCurrentAudioPlayback();
+    currentAbortController?.abort();
+  }
+
+  async function sendAudioToServerAndHandleResponse(blob: Blob) {
+    currentAbortController = new AbortController();
+    const formData = new FormData();
+    formData.append('file', blob, 'user_prompt.webm');
+    formData.append('sessionId', agentStore.activeSessionId);
+    formData.append('mode', agentStore.activeModeName ?? '');
+    formData.append('timeZone', Intl.DateTimeFormat().resolvedOptions().timeZone);
+    formData.append('currentPage', JSON.stringify(getCurrentPageContext()));
+    const fullPath = `${import.meta.env.VITE_ADMINFORTH_PUBLIC_PATH || ''}/adminapi/v1/agent/speech-response`;
+    try {
+      agentAudioMode.value = 'transcribing';
+      const res = await fetch(fullPath, {
+        method: 'POST',
+        body: formData,
+        headers: {
+          Accept: 'text/event-stream',
+        },
+        signal: currentAbortController!.signal,
+      });
+      isStreamingResponse.value = true;
+      if (res.ok) {
+        agentAudioMode.value = 'streaming';
+        await readSpeechResponseStream(res);
+      } else {
+        console.error('Failed to transcribe audio:', res.statusText);
+        adminforth.alert({message: 'Failed to transcribe audio', variant: 'danger'});
+      }
+    } catch (error) {
+      if (error instanceof DOMException && error.name === 'AbortError') {
+        //
+      } else {
+        console.error('Error sending audio to server:', error);
+      }
+    } finally {
+      isStreamingResponse.value = false;
+      agentAudioMode.value = null;
+    }
+  }
+
+  async function readSpeechResponseStream(res: Response) {
+    const reader = res.body?.getReader();
+    if (!reader) {
+      adminforth.alert({message: 'Speech response stream is not available', variant: 'danger'});
+      return;
+    }
+
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    agentStore.setCurrentChatStatus('streaming');
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+
+        if (done) {
+          break;
+        }
+
+        buffer += decoder.decode(value, { stream: true });
+        const eventBlocks = buffer.split('\n\n');
+        buffer = eventBlocks.pop() ?? '';
+
+        for (const eventBlock of eventBlocks) {
+          await handleSpeechStreamEvent(eventBlock);
+        }
+      }
+
+      buffer += decoder.decode();
+
+      if (buffer.trim()) {
+        await handleSpeechStreamEvent(buffer);
+      }
+
+      finishAudioStream();
+    } finally {
+      reader.releaseLock();
+      agentStore.setCurrentChatStatus('ready');
+    }
+  }
+
+  async function handleSpeechStreamEvent(eventBlock: string) {
+    if (currentAbortController?.signal.aborted) {
+      return;
+    }
+    const data = eventBlock
+      .split('\n')
+      .filter((line) => line.startsWith('data:'))
+      .map((line) => line.slice(5).trimStart())
+      .join('\n');
+
+    if (!data || data === '[DONE]') {
+      return;
+    }
+
+    const event = JSON.parse(data) as SpeechStreamEvent;
+
+    if (event.type === 'error') {
+
+      return;
+    }
+
+    if (event.type === 'transcript') {
+      agentStore.addUserMessage(event.data.text);
+      agentStore.updateLastAgentMessage('');
+      return;
+    }
+
+    if (event.type === 'speech-response') {
+      // stopStandByAudio();
+      agentStore.setCurrentChatStatus('ready');
+      agentStore.addAgentMessage(event.data.response.text);
+      agentAudioMode.value = 'playingAgentResponse';
+      return;
+    }
+
+    if (event.type === 'audio-start') {
+      isStreamingResponse.value = false;
+      agentAudioMode.value = 'fetchingAudio';
+      initializeAudioStream(event.data.mimeType);
+      return;
+    }
+
+    if (event.type === 'audio-delta') {
+      appendAudioChunk(event.data.base64);
+      return;
+    }
+
+    if (event.type === 'audio-done') {
+      finishAudioStream();
+      return;
+    }
+
+    if (event.type === 'data-tool-call') {
+      // playStandByAudio();
+      agentStore.addDataToolCallMessage(event.data);
+    }
+  }
+
+  function setIsPlaying(value: boolean) {
+    isPlaying = value;
+
+    if (!currentAudio) {
+      return;
+    }
+
+    if (!isPlaying) {
+      currentAudio.pause();
+      currentAudio.currentTime = 0;
+      return;
+    }
+    agentAudioMode.value = 'playingAgentResponse';
+    void currentAudio.play().catch((error) => {
+      console.error('Failed to play audio:', error);
+    });
+  }
+
+  function initializeAudioStream(mimeType: string) {
+    stopCurrentAudioPlayback();
+    bufferedAudioMimeType = mimeType;
+
+    if (typeof MediaSource === 'undefined' || !MediaSource.isTypeSupported(mimeType)) {
+      return;
+    }
+
+    const mediaSource = new MediaSource();
+    currentAudioObjectUrl = URL.createObjectURL(mediaSource);
+    currentAudio = new Audio(currentAudioObjectUrl);
+    currentAudio.addEventListener('ended', handleAudioEnded, { once: true });
+    currentStreamingAudio = {
+      mimeType,
+      mediaSource,
+      sourceBuffer: null,
+      pendingChunks: [],
+      hasStartedPlayback: false,
+      isDone: false,
+    };
+
+    mediaSource.addEventListener('sourceopen', handleMediaSourceOpen, { once: true });
+  }
+
+  function handleMediaSourceOpen() {
+    if (!currentStreamingAudio) {
+      return;
+    }
+
+    try {
+      currentStreamingAudio.sourceBuffer = currentStreamingAudio.mediaSource.addSourceBuffer(currentStreamingAudio.mimeType);
+      currentStreamingAudio.sourceBuffer.mode = 'sequence';
+      currentStreamingAudio.sourceBuffer.addEventListener('updateend', flushStreamingAudioQueue);
+      flushStreamingAudioQueue();
+    } catch (error) {
+      console.error('Failed to initialize streaming audio playback:', error);
+      bufferedAudioChunks.push(...currentStreamingAudio.pendingChunks);
+      detachStreamingAudio();
+      destroyCurrentAudioElement();
+    }
+  }
+
+  function appendAudioChunk(base64: string) {
+    const chunk = base64ToArrayBuffer(base64);
+
+    if (!currentStreamingAudio) {
+      bufferedAudioChunks.push(chunk);
+      return;
+    }
+
+    currentStreamingAudio.pendingChunks.push(chunk);
+    flushStreamingAudioQueue();
+  }
+
+  function flushStreamingAudioQueue() {
+    if (!currentStreamingAudio?.sourceBuffer || currentStreamingAudio.sourceBuffer.updating) {
+      return;
+    }
+
+    const nextChunk = currentStreamingAudio.pendingChunks.shift();
+
+    if (nextChunk) {
+      currentStreamingAudio.sourceBuffer.appendBuffer(nextChunk);
+
+      if (!currentStreamingAudio.hasStartedPlayback) {
+        currentStreamingAudio.hasStartedPlayback = true;
+        setIsPlaying(true);
+      }
+
+      return;
+    }
+
+    if (currentStreamingAudio.isDone && currentStreamingAudio.mediaSource.readyState === 'open') {
+      currentStreamingAudio.mediaSource.endOfStream();
+    }
+  }
+
+  function finishAudioStream() {
+    if (currentStreamingAudio) {
+      currentStreamingAudio.isDone = true;
+      flushStreamingAudioQueue();
+      return;
+    }
+
+    if (!bufferedAudioChunks.length) {
+      return;
+    }
+
+    playAudioChunks(bufferedAudioChunks, bufferedAudioMimeType);
+    bufferedAudioChunks = [];
+  }
+
+  function detachStreamingAudio() {
+    if (currentStreamingAudio?.sourceBuffer) {
+      currentStreamingAudio.sourceBuffer.removeEventListener('updateend', flushStreamingAudioQueue);
+    }
+
+    currentStreamingAudio = null;
+  }
+
+  function destroyCurrentAudioElement() {
+    if (currentAudio) {
+      currentAudio.pause();
+      currentAudio.currentTime = 0;
+      currentAudio.src = '';
+      currentAudio.load();
+      currentAudio = null;
+    }
+
+    if (currentAudioObjectUrl) {
+      URL.revokeObjectURL(currentAudioObjectUrl);
+      currentAudioObjectUrl = null;
+    }
+
+    isPlaying = false;
+  }
+
+  function stopCurrentAudioPlayback(dontResetMode = false) {
+    bufferedAudioChunks = [];
+    bufferedAudioMimeType = 'audio/mpeg';
+    detachStreamingAudio();
+    destroyCurrentAudioElement();
+    if (!dontResetMode) {
+      agentAudioMode.value = null;
+    }
+  }
+
+  function handleAudioEnded() {
+    agentAudioMode.value = null;
+    stopCurrentAudioPlayback();
+  }
+
+  function playAudioChunks(chunks: ArrayBuffer[], mimeType: string) {
+    currentAudioObjectUrl = URL.createObjectURL(new Blob(chunks, { type: mimeType }));
+    currentAudio = new Audio(currentAudioObjectUrl);
+    currentAudio.addEventListener('ended', handleAudioEnded, { once: true });
+    setIsPlaying(true);
+  }
+
+  function base64ToArrayBuffer(base64: string) {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+
+    for (let i = 0; i < binary.length; i += 1) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+
+    return bytes.buffer;
+  }
+
+  function playBeep(freq = 800, duration = 0.05) {
+    const ctx = new AudioContext();
+    const osc = ctx.createOscillator();
+    const gain = ctx.createGain();
+
+    osc.frequency.value = freq;
+    osc.type = 'sine';
+
+    osc.connect(gain);
+    gain.connect(ctx.destination);
+
+    osc.start();
+
+    gain.gain.setValueAtTime(1, ctx.currentTime);
+    gain.gain.exponentialRampToValueAtTime(0.001, ctx.currentTime + duration);
+
+    osc.stop(ctx.currentTime + duration);
+  }
+
+  return {
+    sendAudioToServerAndHandleResponse,
+    stopGenerationAndAudio,
+    stopCurrentAudioPlayback,
+    playBeep,
+    agentAudioMode
+  };
+
+});
diff --git a/custom/composables/useAgentStore.ts b/custom/composables/useAgentStore.ts
index d886eaa..9974c3b 100644
--- a/custom/composables/useAgentStore.ts
+++ b/custom/composables/useAgentStore.ts
@@ -11,6 +11,8 @@ import {
   DEFAULT_CHAT_WIDTH,
   MAX_WIDTH,
   MIN_WIDTH,
+  RESERVED_SYSTEM_MESSAGE_CONTENT,
+  PRE_SESSION_ID
 } from './agentStore/constants';
 import { createAgentChatManager } from './agentStore/useAgentChat';
 import { createAgentPlaceholderController } from './agentStore/useAgentPlaceholder';
@@ -67,6 +69,36 @@ export const useAgentStore = defineStore('agent', () => {
     return window.localStorage.getItem(`${coreStore.config.brandName || 'adminforth'}-${key}`);
   }
 
+  const isAudioChatMode = ref(false);
+
+  const onBeforeChatCloseCallbacks: Array<() => Promise<void>> = [];
+  function registerOnBeforeChatCloseCallback(hook: () => Promise<void>) {
+    onBeforeChatCloseCallbacks.push(hook);
+  }
+
+  async function executeOnBeforeChatCloseCallbacks() {
+    for(const hook of onBeforeChatCloseCallbacks) {
+      try {
+        await hook();
+      } catch (error) {
+        console.error('Error executing onBeforeChatClose callback:', error);
+      }
+    }
+  }
+
+  function setIsAudioChatMode(isAudioChat: boolean) {
+    isAudioChatMode.value = isAudioChat;
+  }
+
+  watch(isAudioChatMode, (newVal: boolean) => {
+    if (newVal) {
+      addSystemMessage(RESERVED_SYSTEM_MESSAGE_CONTENT.START_AUDIO_CHAT);
+    } else {
+      addSystemMessage(RESERVED_SYSTEM_MESSAGE_CONTENT.END_AUDIO_CHAT);
+    }
+  });
+
+
   const isResponseInProgress = computed( () => {
     return currentChat.value?.status === 'streaming';
   });
@@ -79,6 +111,11 @@ export const useAgentStore = defineStore('agent', () => {
     deleteSession,
     addDebugMessage,
     addSystemMessage,
+    addAgentMessage,
+    addUserMessage,
+    addDataToolCallMessage,
+    setCurrentChatStatus,
+    updateLastAgentMessage
   } = createAgentSessionManager({
     activeSessionId,
     currentSession,
@@ -144,7 +181,7 @@ export const useAgentStore = defineStore('agent', () => {
       }
     }
     lastSessionId.value = getLocalStorageItem('lastSessionId');
-    if (lastSessionId.value && lastSessionId.value !== 'pre-session') {
+    if (lastSessionId.value && lastSessionId.value !== PRE_SESSION_ID) {
       setActiveSession(lastSessionId.value);
     }
     if (coreStore.isMobile) {
@@ -231,7 +268,8 @@ export const useAgentStore = defineStore('agent', () => {
     activeModeName.value = modeName;
   }
 
-  function closeChat() {
+  async function closeChat() {
+    await executeOnBeforeChatCloseCallbacks();
     if(isFullScreen.value) {
       document.body.style.overflow = '';
     }
@@ -273,7 +311,7 @@ export const useAgentStore = defineStore('agent', () => {
 
   function abortCurrentChatRequestAndAddSystemMessage() {
     abortCurrentChatRequest();
-    addSystemMessage('[Response generation aborted]');
+    addSystemMessage(RESERVED_SYSTEM_MESSAGE_CONTENT.AGENT_RESPONSE_ABORTED);
   }
 
   return {
@@ -315,9 +353,18 @@ export const useAgentStore = defineStore('agent', () => {
     DEFAULT_CHAT_WIDTH,
     MAX_WIDTH,
     MIN_WIDTH,
+    RESERVED_SYSTEM_MESSAGE_CONTENT,
     getLocalStorageItem,
     addDebugMessage,
     abortCurrentChatRequestAndAddSystemMessage,
-    addSystemMessage
+    addSystemMessage,
+    isAudioChatMode,
+    setIsAudioChatMode,
+    registerOnBeforeChatCloseCallback,
+    addAgentMessage,
+    addUserMessage,
+    addDataToolCallMessage,
+    setCurrentChatStatus,
+    updateLastAgentMessage
   }
-})
+})
\ No newline at end of file
diff --git a/custom/conversation_area/ConversationArea.vue b/custom/conversation_area/ConversationArea.vue
index 5e5eef9..4461a73 100644
--- a/custom/conversation_area/ConversationArea.vue
+++ b/custom/conversation_area/ConversationArea.vue
@@ -35,7 +35,7 @@
 
       <div 
         v-for="(message, index) in props.messages" :key="index"
-        class="flex flex-col w-full mt-2"
+        class="flex flex-col w-full mt-2 pb-2"
         :class="message.role === 'user' ? 'self-end' : 'self-start'"
         ref="messagesRefs"
       >
diff --git a/custom/conversation_area/MessageRenderer.vue b/custom/conversation_area/MessageRenderer.vue
index 4de6b6b..88889cc 100644
--- a/custom/conversation_area/MessageRenderer.vue
+++ b/custom/conversation_area/MessageRenderer.vue
@@ -8,11 +8,15 @@
     :key="part.type"
   > 
     <TextRenderer 
-      v-if="part.type === 'text'" 
+      v-if="part.type === 'text' && !checkIfMessageSystemMessage(part.text ?? '')" 
       :message="part.text" 
       :role="props.message.role" 
       :state="part.state ?? (props.message.role === 'user' ? 'done' : undefined)"
     />
+    <SystemMessageRenderer 
+      v-else
+      :message="part.text" 
+    />
   </template>
 
 </template>
@@ -25,9 +29,16 @@
   import type { IMessage } from '../types';
   import { getMessageParts } from '../utils';
   import ProcessingTimeline from './ProcessingTimeline.vue';
+  import SystemMessageRenderer from './SystemMessageRenderer.vue';
+  import { RESERVED_SYSTEM_MESSAGE_CONTENT } from '../composables/agentStore/constants';
 
   const props = defineProps<{ 
     message: IMessage 
     isLastMessageInChat: boolean
   }>();
+
+  function checkIfMessageSystemMessage(message: IMessage): boolean {
+    const isReserved = Object.values(RESERVED_SYSTEM_MESSAGE_CONTENT).includes(message as RESERVED_SYSTEM_MESSAGE_CONTENT);
+    return isReserved;
+  }
 </script>
\ No newline at end of file
diff --git a/custom/conversation_area/SystemMessageRenderer.vue b/custom/conversation_area/SystemMessageRenderer.vue
new file mode 100644
index 0000000..ea0e4de
--- /dev/null
+++ b/custom/conversation_area/SystemMessageRenderer.vue
@@ -0,0 +1,28 @@
+<template>
+  <p :class="`${TEXT_CLASSES}`" v-if="message === RESERVED_SYSTEM_MESSAGE_CONTENT.START_AUDIO_CHAT">
+    <IconPhoneSolid class="inline-block w-4 h-4 mr-1" />
+    {{$t('Audio chat started')}}
+  </p>
+  <p :class="`${TEXT_CLASSES}`" v-else-if="message === RESERVED_SYSTEM_MESSAGE_CONTENT.END_AUDIO_CHAT">
+    <IconPhoneHangupSolid class="inline-block w-4 h-4 mr-1" />
+    {{$t('Audio chat ended')}}
+  </p>
+  <p :class="`${TEXT_CLASSES}`" v-else-if="message === RESERVED_SYSTEM_MESSAGE_CONTENT.AGENT_RESPONSE_ABORTED">
+    {{$t('Agent response aborted')}}
+  </p>
+
+</template>
+
+
+
+<script setup lang="ts">
+import { RESERVED_SYSTEM_MESSAGE_CONTENT } from '../composables/agentStore/constants';
+import { IconPhoneSolid, IconPhoneHangupSolid } from '@iconify-prerendered/vue-flowbite';
+
+const TEXT_CLASSES = 'text-center italic  text-lightListTableHeadingText dark:text-darkListTableHeadingText flex items-center justify-center';
+
+const props = defineProps<{ 
+  message: string
+}>();
+
+</script>
\ No newline at end of file
diff --git a/custom/conversation_area/TextRenderer.vue b/custom/conversation_area/TextRenderer.vue
index 4001cd5..bfd920d 100644
--- a/custom/conversation_area/TextRenderer.vue
+++ b/custom/conversation_area/TextRenderer.vue
@@ -16,9 +16,9 @@
       :components="incremarkComponents"
       :incremark-options="incremarkOptions"
     />
-    <p v-else class="text-red-500 py-2">
+    <!-- <p v-else class="text-red-500 py-2">
       {{ $t('No content to render') }}
-    </p>
+    </p> -->
   </div>
 </template>
 
@@ -28,11 +28,12 @@
   import { useRouter } from 'vue-router';
   import { useAgentStore } from '../composables/useAgentStore';
   import { useCoreStore } from '@/stores/core';
+  import type { IMessage } from '../types';
 
   const props = defineProps<{
     message: string | undefined,
     state: string | undefined,
-    role: 'user' | 'assistant'
+    role: IMessage['role']
   }>();
 
   const emit = defineEmits(['toggle-thoughts']);
diff --git a/custom/conversation_area/ToolRenderer.vue b/custom/conversation_area/ToolRenderer.vue
index 0fc138e..9e1ecb1 100644
--- a/custom/conversation_area/ToolRenderer.vue
+++ b/custom/conversation_area/ToolRenderer.vue
@@ -109,7 +109,7 @@
   const hasToolSections = computed(() => toolSections.value.length > 0);
 
   onMounted(() => {
-    if (toolRendererRef.value) {
+    if (toolRendererRef.value && props.data.toolInfo) {
       toolRendererInitialWidth.value = toolRendererRef.value.offsetWidth;
     }
   });  
diff --git a/custom/package.json b/custom/package.json
index 742d81e..72b13dd 100644
--- a/custom/package.json
+++ b/custom/package.json
@@ -22,6 +22,7 @@
     "dompurify": "^3.3.3",
     "katex": "^0.16.45",
     "marked": "^18.0.0",
-    "vega-embed": "^7.1.0"
+    "vega-embed": "^7.1.0",
+    "voice-activity-detection": "^0.0.5"
   }
 }
diff --git a/custom/pnpm-lock.yaml b/custom/pnpm-lock.yaml
index 589f776..ff1bab9 100644
--- a/custom/pnpm-lock.yaml
+++ b/custom/pnpm-lock.yaml
@@ -44,6 +44,9 @@ importers:
       vega-embed:
         specifier: ^7.1.0
         version: 7.1.0(vega-lite@6.4.2(vega@6.2.0))(vega@6.2.0)
+      voice-activity-detection:
+        specifier: ^0.0.5
+        version: 0.0.5
 
 packages:
 
@@ -263,6 +266,9 @@ packages:
     peerDependencies:
       zod: ^3.25.76 || ^4.1.8
 
+  analyser-frequency-average@1.0.0:
+    resolution: {integrity: sha512-Y8HRgDfMWpefR286IAT7w9WsZ2r2dLOAkUNz8SQgsTAM0GsM9SAAqr1psqOr1scN76cL0pfuNZoQTnuvdoM0RA==}
+
   ansi-regex@6.2.2:
     resolution: {integrity: sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==}
     engines: {node: '>=12'}
@@ -271,6 +277,9 @@ packages:
     resolution: {integrity: sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==}
     engines: {node: '>=12'}
 
+  audio-frequency-to-index@2.0.0:
+    resolution: {integrity: sha512-7zqlDEAsEkPB0ORRhjBlsK7KBZQtdgLLQcmemFD2V2KHPH4flqzDOheWl+U69K0P/LA7J/H5YBNzNWaoS/7WAQ==}
+
   ccount@2.0.1:
     resolution: {integrity: sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==}
 
@@ -286,6 +295,9 @@ packages:
   character-reference-invalid@2.0.1:
     resolution: {integrity: sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw==}
 
+  clamp@1.0.1:
+    resolution: {integrity: sha512-kgMuFyE78OC6Dyu3Dy7vcx4uy97EIbVxJB/B0eJ3bUNAkwdNcxYzgKltnyADiYwsR7SEqkkUPsEUT//OVS6XMA==}
+
   cliui@9.0.1:
     resolution: {integrity: sha512-k7ndgKhwoQveBL+/1tqGJYNz097I7WOvwbmmU2AR5+magtbjPWQTS1C5vzGkBC8Ym8UWRzfKUzUUqFLypY4Q+w==}
     engines: {node: '>=20'}
@@ -882,6 +894,9 @@ packages:
   vfile@6.0.3:
     resolution: {integrity: sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==}
 
+  voice-activity-detection@0.0.5:
+    resolution: {integrity: sha512-Ezq+k0cICI67XR/R9KvTRhJ7/u6U0Zk9I+8VNs3hHTAvB6cA3glCa+cHgCRWSW/SV6cRrufSQsV1YxpNtsQb1g==}
+
   vue@3.5.32:
     resolution: {integrity: sha512-vM4z4Q9tTafVfMAK7IVzmxg34rSzTFMyIe0UUEijUCkn9+23lj0WRfA83dg7eQZIUlgOSGrkViIaCfqSAUXsMw==}
     peerDependencies:
@@ -1187,10 +1202,18 @@ snapshots:
       '@opentelemetry/api': 1.9.0
       zod: 4.3.6
 
+  analyser-frequency-average@1.0.0:
+    dependencies:
+      audio-frequency-to-index: 2.0.0
+
   ansi-regex@6.2.2: {}
 
   ansi-styles@6.2.3: {}
 
+  audio-frequency-to-index@2.0.0:
+    dependencies:
+      clamp: 1.0.1
+
   ccount@2.0.1: {}
 
   character-entities-html4@2.1.0: {}
@@ -1201,6 +1224,8 @@ snapshots:
 
   character-reference-invalid@2.0.1: {}
 
+  clamp@1.0.1: {}
+
   cliui@9.0.1:
     dependencies:
       string-width: 7.2.0
@@ -2143,6 +2168,10 @@ snapshots:
       '@types/unist': 3.0.3
       vfile-message: 4.0.3
 
+  voice-activity-detection@0.0.5:
+    dependencies:
+      analyser-frequency-average: 1.0.0
+
   vue@3.5.32:
     dependencies:
       '@vue/compiler-dom': 3.5.32
diff --git a/custom/speech_recognition_frontend/AudioLines.vue b/custom/speech_recognition_frontend/AudioLines.vue
new file mode 100644
index 0000000..9715559
--- /dev/null
+++ b/custom/speech_recognition_frontend/AudioLines.vue
@@ -0,0 +1,97 @@
+<template> 
+  <div 
+    class=" bg-white w-[0.2rem] rounded-sm transition-all duration-300 ease-in-out"
+    :class="{
+      'recordingAnimation1' : showAnimation,
+      'h-2': !isRecording,
+      'h-1': isRecording,
+    }"  
+  />
+  <div 
+    class=" bg-white w-[0.2rem] rounded-sm transition-all duration-300 ease-in-out"
+    :class="{
+      'recordingAnimation2' : showAnimation,
+      'h-4': !isRecording,
+      'h-1': isRecording,
+    }"  
+  />
+  <div 
+    class=" bg-white w-[0.2rem] rounded-sm transition-all duration-300 ease-in-out"
+    :class="{
+      'recordingAnimation3' : showAnimation,
+      'h-3': !isRecording,
+      'h-1': isRecording,
+    }"  
+  />
+  <div 
+    class=" bg-white w-[0.2rem] rounded-sm transition-all duration-300 ease-in-out"
+    :class="{
+      'recordingAnimation4' : showAnimation,
+      'h-2': !isRecording,
+      'h-1': isRecording,
+    }"  
+  />
+  <template v-if="isRecording">
+    <div 
+      class=" bg-white w-[0.2rem] rounded-sm h-1 transition-all duration-300 ease-in-out"
+      :class="{
+        'recordingAnimation5' : showAnimation,
+      }"  
+    />
+    <p class="text-white ml-2">End</p>
+  </template>
+</template>
+
+
+
+<script setup lang="ts">
+
+const props = defineProps<{
+  showAnimation: boolean;
+  isRecording: boolean;
+}>();
+
+</script>
+
+<style scoped lang="scss">
+  .recordingAnimation1 {
+    animation: recordingAnimation 1s infinite;
+    height: 0.3rem;
+  }
+
+  .recordingAnimation2 {
+    animation: recordingAnimation 1s infinite;
+    animation-delay: 0.2s;
+    height: 0.5rem;
+  }
+
+  .recordingAnimation3 {
+    animation: recordingAnimation 1s infinite;
+    animation-delay: 0.4s;
+    height: 0.4rem;
+  }
+  
+  .recordingAnimation4 {
+    animation: recordingAnimation 1s infinite;
+    animation-delay: 0.6s;
+    height: 0.5rem;
+  }
+
+  .recordingAnimation5 {
+    animation: recordingAnimation 1s infinite;
+    animation-delay: 0.8s;
+    height: 0.3rem;
+  }
+
+  @keyframes recordingAnimation {
+    0% {
+      transform: scaleY(1);
+    }
+    50% {
+      transform: scaleY(2);
+    }
+    100% {
+      transform: scaleY(1);
+    }
+  }
+</style>
\ No newline at end of file
diff --git a/custom/speech_recognition_frontend/MicrophoneButon.vue b/custom/speech_recognition_frontend/MicrophoneButon.vue
new file mode 100644
index 0000000..c3e6ff5
--- /dev/null
+++ b/custom/speech_recognition_frontend/MicrophoneButon.vue
@@ -0,0 +1,157 @@
+<template>
+  <button 
+    class="absolute bottom-2 h-9 bg-lightPrimary dark:bg-darkPrimary 
+      hover:opacity-90 rounded-full flex items-center justify-center
+      transition-all duration-300 ease-in-out overflow-hidden"
+    :class="[isAudioChatMode ? 'w-32 px-2': 'w-9', !agentStore.isAudioChatMode ? 'right-16': 'right-1/2 translate-x-1/2']" 
+    @click="toggleChatMode"
+  >
+    <div class="w-5 h-5 flex items-center justify-center">
+      <div v-if="microphoneButtonMode === 'listen' || microphoneButtonMode === 'off'" class="flex justify-evenly items-center gap-[0.1rem]">
+        <AudioLines :showAnimation="showAudioWavesAnimation" :isRecording="microphoneButtonMode === 'listen'" />
+      </div>
+      <div v-else-if="microphoneButtonMode === 'generating'" class="flex items-center justify-center gap-2 text-white text-sm">
+        <span class="w-3 h-3 bg-white rounded-sm" />
+        {{ $t('Stop') }}
+      </div>
+      <Spinner v-else class="w-4 h-4 text-lightButtonsText dark:text-darkButtonsText fill-lightButtonsBackground dark:fill-darkPrimary" />
+    </div>
+   
+  </button>
+</template>
+
+
+<script setup lang="ts">
+import { computed, onMounted, onBeforeUnmount, ref, watch } from 'vue';
+import debounce from 'lodash/debounce';
+import { requestMicAndStartVAD, stopUserMedia, getRecorder, CALIBRATION_DURATION } from './voiceActivityDetection';
+import { Spinner } from '@/afcl'
+import { storeToRefs } from 'pinia';
+import { useAgentStore } from '../composables/useAgentStore';
+import { useAgentAudio } from '../composables/useAgentAudio';
+import AudioLines from './AudioLines.vue';
+
+const agentStore = useAgentStore();
+const agentAudio = useAgentAudio();
+const { sendAudioToServerAndHandleResponse } = agentAudio;
+const { stopGenerationAndAudio } = agentAudio;
+const { stopCurrentAudioPlayback } = agentAudio;
+const { agentAudioMode } = storeToRefs(agentAudio);
+const microphoneButtonMode = ref<'off' | 'calibrating' | 'listen' | 'transcribing' | 'generating'>('off');
+const showAudioWavesAnimation = ref(false);
+const hideAnimationDebounced = debounce(() => {
+  showAudioWavesAnimation.value = false;
+}, 100);
+const sendUserRecordDebounced = debounce(() => {
+  sendRecordForTranscription();
+}, 500);
+
+const isAudioChatMode = computed(() => agentStore.isAudioChatMode);
+
+onMounted(() => {
+  agentStore.registerOnBeforeChatCloseCallback(async () => {
+    if(agentStore.isAudioChatMode) {
+      onStopRecording();
+      resetAll();
+      agentStore.setIsAudioChatMode(false);
+    }
+  });
+});
+
+watch(agentAudioMode, (newVal) => {
+  if(newVal === 'streaming') {
+    stopCurrentAudioPlayback(true);
+    microphoneButtonMode.value = 'generating';
+  } else if (newVal === 'transcribing') {
+    microphoneButtonMode.value = 'transcribing';
+  } else if (newVal === 'fetchingAudio') {
+    //Generation is done, waiting for audio to be ready
+  } else if (newVal === 'playingAgentResponse') {
+    // Audio is playing
+  } else {
+    if(isAudioChatMode.value) {
+      microphoneButtonMode.value = 'listen';
+    } else {
+      microphoneButtonMode.value = 'off';
+    }
+  }
+})
+
+function toggleChatMode() {
+  agentStore.setIsAudioChatMode(!isAudioChatMode.value);
+  if (isAudioChatMode.value) {
+    onStartRecording();
+  } else {
+    resetAll();
+    onStopRecording();
+  }
+}
+
+async function onStartRecording() {
+  microphoneButtonMode.value = 'calibrating';
+  await requestMicAndStartVAD(saidSomething, stopRecording, onAnySound);
+  setTimeout(() => {
+    microphoneButtonMode.value = 'listen';
+    agentAudio.playBeep(1000);
+  }, CALIBRATION_DURATION);
+}
+
+function onStopRecording() {
+  agentAudio.playBeep(600);
+  stopUserMedia();
+  showAudioWavesAnimation.value = false;
+}
+
+function resetAll() {
+  stopGenerationAndAudio();
+  microphoneButtonMode.value = 'off';
+  showAudioWavesAnimation.value = false;
+  hideAnimationDebounced.cancel();
+  sendUserRecordDebounced.cancel();
+}
+
+
+function saidSomething() {
+  showAudioWavesAnimation.value = true;
+  hideAnimationDebounced();
+  sendUserRecordDebounced();
+}
+
+function stopRecording() {
+  hideAnimationDebounced.cancel();
+  sendUserRecordDebounced.cancel();
+}
+
+function onAnySound(amplitude: number) {
+  if(amplitude < 0.01) {
+    showAudioWavesAnimation.value = false;
+    return;
+  }
+  showAudioWavesAnimation.value = true;
+  hideAnimationDebounced.cancel();
+}
+
+async function sendRecordForTranscription() {
+  showAudioWavesAnimation.value = false;
+  const recordBlob = await getRecorder();
+  if (recordBlob) {
+    onStopRecording();
+    await sendAudioToServerAndHandleResponse(recordBlob);
+    if (agentStore.isAudioChatMode) {
+      await requestMicAndStartVAD(saidSomething, stopRecording, onAnySound);
+    }
+  } else { 
+    console.error('No audio recorded');
+  }
+}
+
+onBeforeUnmount(() => {
+  stopUserMedia();
+  agentStore.setIsAudioChatMode(false);
+  onStopRecording();
+  hideAnimationDebounced.cancel();
+  sendUserRecordDebounced.cancel();
+});
+
+
+</script>
\ No newline at end of file
diff --git a/custom/speech_recognition_frontend/types/voice-activity-detection.d.ts b/custom/speech_recognition_frontend/types/voice-activity-detection.d.ts
new file mode 100644
index 0000000..d78d444
--- /dev/null
+++ b/custom/speech_recognition_frontend/types/voice-activity-detection.d.ts
@@ -0,0 +1,22 @@
+declare module 'voice-activity-detection' {
+  type VADOptions = {
+    fftSize: number,
+    bufferLen: number,
+    smoothingTimeConstant: number,
+    minCaptureFreq: number,         // in Hz
+    maxCaptureFreq: number,        // in Hz
+    noiseCaptureDuration: number, // in ms
+    minNoiseLevel: number,         // from 0 to 1
+    maxNoiseLevel: number,         // from 0 to 1
+    avgNoiseMultiplier: number,     // from 0 to 1
+    onVoiceStart?: () => void;
+    onVoiceStop?: () => void;
+    onUpdate?: (value: number) => void;
+  };
+
+  export default function vad(
+    audioContext: AudioContext,
+    stream: MediaStream,
+    options: VADOptions,
+  ): void;
+}
diff --git a/custom/speech_recognition_frontend/voiceActivityDetection.ts b/custom/speech_recognition_frontend/voiceActivityDetection.ts
new file mode 100644
index 0000000..7579579
--- /dev/null
+++ b/custom/speech_recognition_frontend/voiceActivityDetection.ts
@@ -0,0 +1,151 @@
+import vad from 'voice-activity-detection';
+
+let currentStream: MediaStream | null = null;
+let vadInstance: any = null;
+let audioContext: AudioContext | null = null;
+let mediaRecorder: MediaRecorder | null = null;
+let recordedChunks: BlobPart[] = [];
+let wasVoiceStarted = false;
+
+export const CALIBRATION_DURATION = 1000; // in ms
+
+export async function requestMicAndStartVAD(
+  onVoiceStopCallback: () => void,
+  onVoiceStartCallback: () => void,
+  onUpdateCallback: (amplitude: number) => void
+) {
+  return new Promise<void>((resolve, reject) => {
+    try {
+      audioContext = new AudioContext();
+
+      navigator.mediaDevices
+        .getUserMedia({ audio: true })
+        .then((stream) => {
+          currentStream = stream;
+          startRecording(stream);
+          resolve();
+          startUserMedia(audioContext as AudioContext, stream, onVoiceStartCallback, onVoiceStopCallback, onUpdateCallback);
+        })
+        .catch((error) => {
+          handleMicConnectError();
+          reject(error);
+        });
+    } catch (e) {
+      handleUserMediaError();
+      reject(e);
+    }
+  });
+}
+
+function handleUserMediaError() {
+  console.error('Mic input is not supported by the browser.');
+}
+
+function handleMicConnectError() {
+  console.error('Could not connect microphone. Possible rejected by the user or is blocked by the browser.');
+}
+
+export async function stopUserMedia() {
+  wasVoiceStarted = false;
+  if (vadInstance && vadInstance.destroy) {
+    vadInstance.destroy();
+    vadInstance = null;
+  }
+
+  if (currentStream) {
+    currentStream.getTracks().forEach(track => track.stop());
+    currentStream = null;
+  }
+
+  if (audioContext) {
+    audioContext.close();
+    audioContext = null;
+  }
+
+  if (mediaRecorder) {
+    mediaRecorder.stop();
+    mediaRecorder = null;
+  }
+
+}
+
+function startRecording(stream: MediaStream) {
+  recordedChunks = [];
+  mediaRecorder = new MediaRecorder(stream);
+  mediaRecorder.ondataavailable = (event: BlobEvent) => {
+    if (event.data.size > 0) {
+      recordedChunks.push(event.data);
+    }
+  };
+  mediaRecorder.start();
+}
+
+export async function getRecorder(): Promise<Blob | null> {
+  if (!mediaRecorder) {
+    return Promise.resolve(null);
+  }
+
+  const recorder = mediaRecorder;
+  mediaRecorder = null;
+
+  const finalizeBlob = () => {
+    const blob = new Blob(recordedChunks, { type: recorder.mimeType || 'audio/webm' });
+    recordedChunks = [];
+    return blob;
+  };
+
+  if (recorder.state === 'inactive') {
+    return Promise.resolve(finalizeBlob());
+  }
+
+  return new Promise<Blob>((resolve, reject) => {
+    recorder.onstop = () => {
+      resolve(finalizeBlob());
+    };
+    recorder.onerror = () => {
+      recordedChunks = [];
+      reject(new Error('Failed to finalize audio recording.'));
+    };
+    recorder.stop();
+  });
+}
+
+function startUserMedia(
+  audioContext: AudioContext, 
+  stream: MediaStream, 
+  onVoiceStartCallback: () => void,
+  onVoiceStopCallback: () => void,
+  onUpdateCallback: (amplitude: number) => void
+) {
+  const options = {
+    fftSize: 1024,
+    bufferLen: 1024,
+    smoothingTimeConstant: 0.2,
+    minCaptureFreq: 85,         // in Hz
+    maxCaptureFreq: 255,        // in Hz
+    noiseCaptureDuration: CALIBRATION_DURATION, // in ms
+    minNoiseLevel: 0.5,         // from 0 to 1
+    maxNoiseLevel: 0.7,         // from 0 to 1
+    avgNoiseMultiplier: 1.2,
+    onVoiceStart() {
+      wasVoiceStarted = true;
+      if (!mediaRecorder || mediaRecorder.state === 'inactive') {
+        startRecording(currentStream as MediaStream);
+      }
+      console.log('👹👹👹voice start👹👹👹');
+      onVoiceStartCallback();
+    },
+    onVoiceStop() {
+      if (!wasVoiceStarted) {
+        return;
+      }
+      console.log('👿👿👿voice stop👿👿👿');
+      onVoiceStopCallback();
+    }, //Doesn't work properly, so we will handle it with onUpdate callback
+    onUpdate(val: number) {
+      onUpdateCallback(val);
+    }
+  };
+
+  vadInstance = vad(audioContext, stream, options);
+}
\ No newline at end of file
diff --git a/custom/types.ts b/custom/types.ts
index 89470ca..b6405f1 100644
--- a/custom/types.ts
+++ b/custom/types.ts
@@ -25,7 +25,7 @@ export interface IToolGroup {
 }
 
 export interface IMessage {
-  role: 'user' | 'assistant';
+  role: 'user' | 'assistant' | 'system';
   metadata?: any,
   parts: IPart[];
 }
@@ -41,4 +41,54 @@ export interface ISessionsListItem {
   sessionId: string;
   title: string;
   timestamp: string;
-}
\ No newline at end of file
+}
+
+export type SpeechStreamEvent =
+  | {
+      type: 'error';
+      error: string;
+    }
+  | {
+      type: 'transcript';
+      data: {
+        text: string;
+        language?: string;
+      };
+    }
+  | {
+      type: 'speech-response';
+      data: {
+        transcript: {
+          text: string;
+          language?: string;
+        };
+        response: {
+          text: string;
+        };
+        sessionId: string;
+        turnId: string;
+      };
+    }
+  | {
+      type: 'audio-start';
+      data: {
+        mimeType: string;
+        format: string;
+      };
+    }
+  | {
+      type: 'audio-delta';
+      data: {
+        base64: string;
+      };
+    }
+  | {
+      type: 'audio-done';
+    }
+  | {
+      type: 'data-tool-call';
+      data: any;
+    }
+  | {
+      type: 'finish';
+    };
diff --git a/index.ts b/index.ts
index 3688983..362aa16 100644
--- a/index.ts
+++ b/index.ts
@@ -1,11 +1,4 @@
-import type {
-  AdminUser,
-  AdminForthResource,
-  HttpExtra,
-  IAdminForth,
-  IHttpServer,
-  TextToSpeechInput,
-} from "adminforth";
+import type { AdminUser, AdminForthResource, IAdminForth, IHttpServer } from "adminforth";
 
 import { AdminForthPlugin, logger, Filters, Sorts } from "adminforth";
 
@@ -13,44 +6,24 @@ import type { PluginOptions } from './types.js';
 import { randomUUID } from 'crypto';
 import { HumanMessage, SystemMessage } from "langchain";
 import { MemorySaver, type BaseCheckpointSaver } from "@langchain/langgraph";
-import {
-  createAgentChatModel,
-  callAgent,
-  type AgentChatModel,
-} from "./agent/simpleAgent.js";
+import { z } from "zod";
+import { createAgentChatModel, callAgent } from "./agent/simpleAgent.js";
 import { AdminForthCheckpointSaver } from "./agent/checkpointer.js";
 import { createSequenceDebugCollector } from "./agent/middleware/sequenceDebug.js";
-import {
-  detectUserLanguage,
-  formatLanguagePrompt,
-} from "./agent/languageDetect.js";
-import {
-  prepareApiBasedTools as buildApiBasedTools,
-} from './apiBasedTools.js';
-import type { ApiBasedTool } from './apiBasedTools.js';
-import {
-  appendCustomSystemPrompt,
-  buildAgentSystemPrompt,
-  DEFAULT_AGENT_SYSTEM_PROMPT,
-} from "./agent/systemPrompt.js";
-import { ALWAYS_AVAILABLE_API_TOOL_NAMES } from "./agent/tools/index.js";
+import { detectUserLanguage } from "./agent/languageDetect.js";
+import { prepareApiBasedTools as buildApiBasedTools } from './apiBasedTools.js';
+import { createAgentEventStream } from "./agentResponseEvents.js";
+import { appendCustomSystemPrompt, buildAgentSystemPrompt, buildAgentTurnSystemPrompt, DEFAULT_AGENT_SYSTEM_PROMPT} from "./agent/systemPrompt.js";
 import type { ToolCallEvent } from "./agent/toolCallEvents.js";
 import type { CurrentPageContext } from "./agent/tools/getUserLocation.js";
 
-type CurrentPageRequestBody = {
-  currentPage?: CurrentPageContext;
+type MulterFile = {
+  buffer: Buffer;
+  originalname: string;
+  mimetype: string;
 };
 
-type SpeechResponseRequestBody = CurrentPageRequestBody & {
-  audioBase64: string;
-  filename: string;
-  mimeType: string;
-  prompt?: string;
-  sessionId?: string | null;
-  mode?: string | null;
-  timeZone?: string;
-  tts?: Omit<TextToSpeechInput, "text">;
-};
+type ExpressMulterRequest = { file?: MulterFile };
 
 type AgentTurnRunInput = {
   prompt: string;
@@ -59,102 +32,65 @@ type AgentTurnRunInput = {
   modeName?: string | null;
   userTimeZone: string;
   currentPage?: CurrentPageContext;
+  abortSignal?: AbortSignal;
   adminUser: AdminUser;
-  httpExtra: HttpExtra;
   sequenceDebugCollector: ReturnType<typeof createSequenceDebugCollector>;
   emitReasoningDelta?: (delta: string) => void;
   emitTextDelta?: (delta: string) => void;
   emitToolCallEvent?: (event: ToolCallEvent) => void;
 };
 
-function isAggregateErrorLike(
-  error: unknown,
-): error is { errors: unknown[]; message?: string; stack?: string } {
-  return typeof error === "object" && error !== null && Array.isArray((error as { errors?: unknown[] }).errors);
-}
-
-function formatAgentError(error: unknown) {
-  if (isAggregateErrorLike(error)) {
-    const nestedErrors = error.errors
-      .map((nestedError, index) => {
-        if (nestedError instanceof Error) {
-          return `${index + 1}. ${nestedError.stack ?? nestedError.message}`;
-        }
-
-        return `${index + 1}. ${String(nestedError)}`;
-      })
-      .join("\n");
-
-    return `${error.stack ?? error.message}\nNested errors:\n${nestedErrors}`;
-  }
-
-  if (error instanceof Error) {
-    return error.stack ?? error.message;
-  }
-
-  return String(error);
-}
+type RunAndPersistAgentResponseInput =
+  Omit<AgentTurnRunInput, "turnId" | "sequenceDebugCollector"> & {
+    emitErrorResponse?: (response: string) => void;
+    failureLogMessage: string;
+    abortLogMessage: string;
+  };
 
-function formatAgentResponseError(error: unknown): string {
-  if (isAggregateErrorLike(error)) {
-    const nestedErrors = error.errors.map(formatAgentResponseError);
+const agentResponseBodySchema = z.object({
+  message: z.string(),
+  sessionId: z.string(),
+  mode: z.string().nullish(),
+  timeZone: z.string().optional(),
+  currentPage: z.custom<CurrentPageContext>().optional(),
+}).strict();
 
-    if (nestedErrors.length) {
-      return nestedErrors.join("\n");
-    }
+const agentSpeechResponseBodySchema = agentResponseBodySchema.omit({message: true})
 
-    return error.message || "Agent response failed";
-  }
+const addSystemMessageBodySchema = z.object({
+  sessionId: z.string(),
+  systemMessage: z.string(),
+}).strict();
 
-  if (error instanceof Error) {
-    return error.toString();
-  }
+const getSessionsBodySchema = z.object({
+  limit: z.number().optional(),
+}).strict();
 
-  return String(error);
-}
+const sessionIdBodySchema = z.object({
+  sessionId: z.string(),
+}).strict();
 
-function formatAdminUserPrompt(adminUser: AdminUser, usernameField: string) {
-  const dbUser = adminUser.dbUser as Record<string, unknown>;
-  const adminUserContext = {
-    id: adminUser.pk,
-    email: dbUser[usernameField],
-  };
+const createSessionBodySchema = z.object({
+  triggerMessage: z.string().optional(),
+}).strict();
 
-  return [
-    "Current admin user context:",
-    JSON.stringify(adminUserContext, null, 2),
-    "Use this admin user email when the user asks to send information to themselves, the current admin, or the logged-in user.",
-  ].join("\n");
-}
-
-function assertRequiredApiTool(
-  apiBasedTools: Record<string, ApiBasedTool>,
-  toolName: string,
-) {
-  if (toolName in apiBasedTools) {
-    return;
-  }
-
-  const availableToolNames = Object.keys(apiBasedTools).sort().join(", ");
-  throw new Error(
-    `Required API tool "${toolName}" is missing from AdminForth Agent tools. Available tools: ${availableToolNames}`,
-  );
-}
 
 export default class AdminForthAgentPlugin extends AdminForthPlugin {
   options: PluginOptions;
-  apiBasedTools: Record<string, ApiBasedTool> = {};
   agentSystemPromptPromise: Promise<string>;
   private checkpointer: BaseCheckpointSaver | null = null;
-  private readonly modelsByModeName = new Map<
-    string,
-    Promise<{
-      model: AgentChatModel;
-      summaryModel: AgentChatModel;
-      modelMiddleware: Awaited<ReturnType<typeof createAgentChatModel>>["middleware"];
-    }>
-  >();
-
+  private parseBody<T>(
+    schema: z.ZodType<T>,
+    body: unknown,
+    response: { setStatus: (code: number, message?: string) => void },
+  ): T | null {
+    const parsed = schema.safeParse(body ?? {});
+    if (!parsed.success) {
+      response.setStatus(422, parsed.error.message);
+      return null;
+    }
+    return parsed.data;
+  }
   private async createNewTurn(sessionId: string, prompt: string, response?: string) {
     const turnId = randomUUID();
     const turnRecord = {
@@ -167,18 +103,6 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
     return newTurn.createdRecord[this.options.turnResource.idField];
   }
 
-  private async updateTurn(turnId: string, updates: Record<string, unknown>) {
-    await this.adminforth.resource(this.options.turnResource.resourceId).update(turnId, updates);
-    return {ok: true};
-  }
-
-  private async updateSessionDate(sessionId: string) {
-    await this.adminforth.resource(this.options.sessionResource.resourceId).update(sessionId, {
-      [this.options.sessionResource.createdAtField]: new Date().toISOString(),
-    });
-    return {ok: true};
-  }
-
   private async getSessionTurns(sessionId: string) {
     const turns = await this.adminforth.resource(this.options.turnResource.resourceId).list(
       [Filters.EQ(this.options.turnResource.sessionIdField, sessionId)],
@@ -192,47 +116,8 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
     }));
   }
 
-  private async getModeModels(
-    mode: PluginOptions["modes"][number],
-    maxTokens: number,
-  ) {
-    const cachedModels = this.modelsByModeName.get(mode.name);
-
-    if (cachedModels) {
-      return await cachedModels;
-    }
-
-    const modelsPromise = Promise.all([
-      createAgentChatModel({
-        adapter: mode.completionAdapter,
-        maxTokens,
-        purpose: "primary",
-      }),
-      createAgentChatModel({
-        adapter: mode.completionAdapter,
-        maxTokens,
-        purpose: "summary",
-      }),
-    ]).then(([primaryModel, summaryModel]) => ({
-      model: primaryModel.model,
-      summaryModel: summaryModel.model,
-      modelMiddleware: primaryModel.middleware,
-    }));
-
-    this.modelsByModeName.set(mode.name, modelsPromise);
-
-    try {
-      return await modelsPromise;
-    } catch (error) {
-      this.modelsByModeName.delete(mode.name);
-      throw error;
-    }
-  }
-
   private getCheckpointer() {
-    if (this.checkpointer) {
-      return this.checkpointer;
-    }
+    if (this.checkpointer) return this.checkpointer;
 
     this.checkpointer = this.options.checkpointResource
       ? new AdminForthCheckpointSaver(this.adminforth, this.options)
@@ -276,7 +161,7 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
         hasAudioAdapter: Boolean(this.options.audioAdapter),
       }
     });
-    if (!this.pluginOptions.sessionResource) {
+    if (!this.options.sessionResource) {
       throw new Error("sessionResource is required for AdminForthAgentPlugin");
     }
   }
@@ -296,31 +181,40 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
 
   private async runAgentTurn(input: AgentTurnRunInput) {
     let fullResponse = "";
-    const maxTokens = this.options.maxTokens ?? 10000;
-    const selectedMode =
-      this.options.modes.find((mode) => mode.name === input.modeName) ??
-      this.options.modes[0];
-    const { model, summaryModel, modelMiddleware } =
-      await this.getModeModels(selectedMode, maxTokens);
+    const maxTokens = this.options.maxTokens ?? 1000;
+    const selectedMode = this.options.modes.find((mode) => mode.name === input.modeName) ?? this.options.modes[0];
+    const [primaryModelSpec, summaryModelSpec] = await Promise.all([
+      createAgentChatModel({
+        adapter: selectedMode.completionAdapter,
+        maxTokens,
+        purpose: "primary",
+      }),
+      createAgentChatModel({
+        adapter: selectedMode.completionAdapter,
+        maxTokens,
+        purpose: "summary",
+      }),
+    ]);
+    const model = primaryModelSpec.model;
+    const summaryModel = summaryModelSpec.model;
+    const modelMiddleware = primaryModelSpec.middleware;
+
     const userLanguage = await detectUserLanguage(selectedMode.completionAdapter, input.prompt)
       .catch((error) => {
-        logger.warn(`Failed to detect user language: ${error instanceof Error ? error.message : String(error)}`);
+        logger.warn(`Failed to detect user language: ${error.message}`);
         return null;
       });
-    const systemPrompt = [
-      await this.agentSystemPromptPromise,
-      formatAdminUserPrompt(input.adminUser, this.adminforth.config.auth.usernameField),
-      formatLanguagePrompt(userLanguage),
-    ].join("\n\n");
+    const systemPrompt = buildAgentTurnSystemPrompt({
+      agentSystemPrompt: await this.agentSystemPromptPromise,
+      adminUser: input.adminUser,
+      usernameField: this.adminforth.config.auth.usernameField,
+      userLanguage,
+    });
     const apiBasedTools = buildApiBasedTools(
       this.adminforth,
       this.getInternalAgentResourceIds(),
     );
-    for (const toolName of ALWAYS_AVAILABLE_API_TOOL_NAMES) {
-      assertRequiredApiTool(apiBasedTools, toolName);
-    }
-    assertRequiredApiTool(apiBasedTools, "update_record");
-    this.apiBasedTools = apiBasedTools;
+
     const stream = await callAgent({
       name: `adminforth-agent-${this.pluginInstanceId}`,
       model,
@@ -338,8 +232,8 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
       sessionId: input.sessionId,
       turnId: input.turnId,
       currentPage: input.currentPage,
-      httpExtra: input.httpExtra,
       userTimeZone: input.userTimeZone,
+      abortSignal: input.abortSignal,
       emitToolCallEvent: (event) => {
         input.sequenceDebugCollector.handleToolCallEvent(event);
         input.emitToolCallEvent?.(event);
@@ -389,11 +283,68 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
     };
   }
 
+  private async runAndPersistAgentResponse(input: RunAndPersistAgentResponseInput) {
+    const turnId = await this.createNewTurn(input.sessionId, input.prompt);
+    await this.adminforth.resource(this.options.sessionResource.resourceId).update(input.sessionId, {
+      [this.options.sessionResource.createdAtField]: new Date().toISOString(),
+    });
+    const sequenceDebugCollector = createSequenceDebugCollector();
+    let fullResponse = "";
+    let aborted = false;
+    let failed = false;
+
+    try {
+      const agentResponse = await this.runAgentTurn({
+        prompt: input.prompt,
+        sessionId: input.sessionId,
+        turnId,
+        modeName: input.modeName,
+        userTimeZone: input.userTimeZone,
+        currentPage: input.currentPage,
+        abortSignal: input.abortSignal,
+        adminUser: input.adminUser,
+        sequenceDebugCollector,
+        emitToolCallEvent: input.emitToolCallEvent,
+        emitReasoningDelta: input.emitReasoningDelta,
+        emitTextDelta: input.emitTextDelta,
+      });
+      fullResponse = agentResponse.text;
+    } catch (error) {
+      if (input.abortSignal?.aborted) {
+        aborted = true;
+        logger.info(input.abortLogMessage);
+      } else {
+        failed = true;
+        logger.error(`${input.failureLogMessage}:\n${error.message}`);
+        fullResponse = error.message;
+        input.emitErrorResponse?.(fullResponse);
+      }
+    }
+
+    sequenceDebugCollector.flush();
+    const turnUpdates: Record<string, unknown> = {
+      [this.options.turnResource.responseField]: fullResponse,
+    };
+
+    if (this.options.turnResource.debugField) {
+      turnUpdates[this.options.turnResource.debugField] = sequenceDebugCollector.getHistory();
+    }
+
+    await this.adminforth.resource(this.options.turnResource.resourceId).update(turnId, turnUpdates);
+
+    return {
+      text: fullResponse,
+      turnId,
+      aborted,
+      failed,
+    };
+  }
+
   setupEndpoints(server: IHttpServer) {
     server.endpoint({
       method: 'POST',
       path: `/agent/get-placeholder-messages`,
-      handler: async ({ body, query, headers, cookies, adminUser, response, requestUrl }) => {
+      handler: async ({ headers, adminUser }) => {
         if (!this.options.placeholderMessages) {
           return {
             messages: [],
@@ -402,14 +353,7 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
 
         const messages = await this.options.placeholderMessages({
           adminUser,
-          httpExtra: {
-            body,
-            query,
-            headers,
-            cookies,
-            requestUrl,
-            response,
-          },
+          headers,
         });
 
         return {
@@ -420,362 +364,242 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
     server.endpoint({
       method: 'POST',
       path: `/agent/response`,
-      handler: async ({ body, query, headers, cookies, adminUser, response, requestUrl, _raw_express_res, abortSignal }) => {
-        const res = _raw_express_res;
+      handler: async ({ body, adminUser, response, _raw_express_res, abortSignal }) => {
+        const data = this.parseBody(agentResponseBodySchema, body, response);
+        if (!data) return;
+        const stream = createAgentEventStream(_raw_express_res, {vercelAiUiMessageStream: true, closeActiveBlockOnToolStart: true});
         const messageId = randomUUID();
-        const prompt = body.message;
-        const userTimeZone = (body.timeZone as string | undefined) ?? 'UTC';
-        const currentPage = (body as CurrentPageRequestBody).currentPage;
-        const sessionId = body.sessionId || adminUser?.pk || adminUser?.username || 'default';
-        const turnId = await this.createNewTurn(sessionId, prompt);
-        await this.updateSessionDate(sessionId);
-        let fullResponse = "";
-        let isStreamClosed = false;
-        const sequenceDebugCollector = createSequenceDebugCollector();
-
-        res.writeHead(200, {
-          'Content-Type': 'text/event-stream',
-          'Cache-Control': 'no-cache',
-          'Connection': 'keep-alive',
-          'x-vercel-ai-ui-message-stream': 'v1',
-        });
-
-        const send = (obj: unknown) => {
-          if (isStreamClosed || res.writableEnded || res.destroyed) {
-            return;
-          }
-          res.write(`data: ${JSON.stringify(obj)}\n\n`);
-        };
-
-        const emitToolCallEvent = (event: ToolCallEvent) => {
-          if (event.phase === "start") {
-            endActiveBlock();
-          }
-
-          send({
-            type: "data-tool-call",
-            data: event,
-          });
-        };
-
-        let activeBlock: { type: 'text' | 'reasoning'; id: string } | null = null;
-
-        const endActiveBlock = () => {
-          if (!activeBlock) {
-            return;
-          }
-
-          send({
-            type: `${activeBlock.type}-end`,
-            id: activeBlock.id,
-          });
-
-          activeBlock = null;
-        };
-
-        const startBlock = (type: 'text' | 'reasoning') => {
-          if (activeBlock?.type === type) {
-            return activeBlock.id;
-          }
-
-          endActiveBlock();
-
-          const id = randomUUID();
-          activeBlock = { type, id };
-
-          send({
-            type: `${type}-start`,
-            id,
-          });
-
-          return id;
-        };
-
-        const endStream = () => {
-          if (isStreamClosed || res.writableEnded || res.destroyed) {
-            return;
-          }
-          endActiveBlock();
-
-          send({
-            type: 'finish',
-          });
 
-          res.write(`data: [DONE]\n\n`);
-          isStreamClosed = true;
-          res.end();
-        }
-
-        try {
-          send({
-            type: 'start',
-            messageId,
-          });
-
-          const agentResponse = await this.runAgentTurn({
-            prompt,
-            sessionId,
-            turnId,
-            modeName: body.mode,
-            userTimeZone,
-            currentPage,
-            adminUser,
-            httpExtra: {
-              body,
-              query,
-              headers,
-              cookies,
-              requestUrl,
-              response,
-            },
-            sequenceDebugCollector,
-            emitToolCallEvent,
-            emitReasoningDelta: (reasoningDelta) => {
-              const reasoningId = startBlock('reasoning');
-              send({
-                type: 'reasoning-delta',
-                id: reasoningId,
-                delta: reasoningDelta,
-              });
-            },
-            emitTextDelta: (textDelta) => {
-              const textId = startBlock('text');
-              fullResponse += textDelta;
-              send({
-                type: 'text-delta',
-                id: textId,
-                delta: textDelta,
-              });
-            },
-          });
-          fullResponse = agentResponse.text;
-        } catch (error) {
-          logger.error(`Agent response streaming failed:\n${formatAgentError(error)}`);
-          sequenceDebugCollector.flush();
-          fullResponse = formatAgentResponseError(error);
-          const textId = startBlock('text');
-          send({
-            type: 'text-delta',
-            id: textId,
-            delta: fullResponse,
-          });
-        }
-        sequenceDebugCollector.flush();
-        const turnUpdates: Record<string, unknown> = {
-          [this.options.turnResource.responseField]: fullResponse,
-        };
-
-        if (this.options.turnResource.debugField) {
-          turnUpdates[this.options.turnResource.debugField] = sequenceDebugCollector.getHistory();
-        }
-
-        await this.updateTurn(turnId, turnUpdates);
-        endStream();
+        stream.start(messageId);
+        await this.runAndPersistAgentResponse({
+          prompt: data.message,
+          sessionId: data.sessionId,
+          modeName: data.mode,
+          userTimeZone: data.timeZone ?? 'UTC',
+          currentPage: data.currentPage,
+          abortSignal,
+          adminUser,
+          emitToolCallEvent: stream.toolCall,
+          emitReasoningDelta: stream.reasoningDelta,
+          emitTextDelta: stream.textDelta,
+          emitErrorResponse: stream.textDelta,
+          failureLogMessage: "Agent response streaming failed",
+          abortLogMessage: "Agent response streaming aborted by the client",
+        });
+        stream.end();
         return null;
       }
     });
     server.endpoint({
       method: 'POST',
       path: `/agent/speech-response`,
-      handler: async ({ body, query, headers, cookies, adminUser, response, requestUrl }) => {
+      target: 'upload',
+      handler: async ({ body, adminUser, response, _raw_express_req, _raw_express_res, abortSignal }) => {
+        const req = _raw_express_req as ExpressMulterRequest;
         const audioAdapter = this.options.audioAdapter;
         if (!audioAdapter) {
           response.setStatus(400, undefined);
-          return {
-            error: "Audio adapter is not configured for AdminForth Agent",
-          };
+          return { error: "Audio adapter is not configured for AdminForth Agent" };
         }
-
-        const speechBody = body as SpeechResponseRequestBody;
+        const data = this.parseBody(agentSpeechResponseBodySchema, body, response);
+        if (!data) return;
+        if (!req.file) {
+          response.setStatus(400, undefined);
+          return { error: "Audio file is required" };
+        }
+        const stream = createAgentEventStream(_raw_express_res);
+        
         let transcription;
 
         try {
           transcription = await audioAdapter.transcribe({
-            buffer: Buffer.from(speechBody.audioBase64, "base64"),
-            filename: speechBody.filename,
-            mimeType: speechBody.mimeType,
+            buffer: req.file.buffer,
+            filename: req.file.originalname,
+            mimeType: req.file.mimetype,
             language: "auto",
-            prompt: speechBody.prompt,
           });
         } catch (error) {
-          logger.error(`Agent speech transcription failed:\n${formatAgentError(error)}`);
-          response.setStatus(500, undefined);
-          return {
-            error: "Speech transcription failed. Check server logs for details.",
-          };
+          logger.error(`Agent speech transcription failed:\n${error.message}`);
+          stream.error("Speech transcription failed. Check server logs for details.");
+          stream.end();
+          return null;
         }
 
         const prompt = transcription.text;
         if (!prompt) {
-          response.setStatus(400, undefined);
-          return {
-            error: "Speech transcription is empty",
-          };
+          stream.error("Speech transcription is empty");
+          stream.end();
+          return null;
+        }
+        stream.transcript(transcription.text, transcription.language);
+
+        const sessionId = data.sessionId as string;
+        const currentPage = data.currentPage;
+        const agentResponse = await this.runAndPersistAgentResponse({
+          prompt,
+          sessionId,
+          modeName: data.mode,
+          userTimeZone: data.timeZone ?? 'UTC',
+          currentPage,
+          abortSignal,
+          adminUser,
+          emitToolCallEvent: stream.toolCall,
+          failureLogMessage: "Agent speech response failed",
+          abortLogMessage: "Agent speech response aborted by the client",
+        });
+
+        if (agentResponse.aborted) {
+          stream.end();
+          return null;
         }
 
-        const sessionId = speechBody.sessionId || adminUser?.pk || adminUser?.username || 'default';
-        const turnId = await this.createNewTurn(sessionId, prompt);
-        await this.updateSessionDate(sessionId);
-        const sequenceDebugCollector = createSequenceDebugCollector();
-        let fullResponse = "";
+        if (agentResponse.failed) {
+          stream.error(agentResponse.text);
+          stream.end();
+          return null;
+        }
 
         try {
-          const agentResponse = await this.runAgentTurn({
-            prompt,
-            sessionId,
-            turnId,
-            modeName: speechBody.mode,
-            userTimeZone: speechBody.timeZone ?? 'UTC',
-            currentPage: speechBody.currentPage,
-            adminUser,
-            httpExtra: {
-              body,
-              query,
-              headers,
-              cookies,
-              requestUrl,
-              response,
+          stream.speechResponse(
+            {
+              text: transcription.text,
+              language: transcription.language,
             },
-            sequenceDebugCollector,
-            emitTextDelta: (textDelta) => {
-              fullResponse += textDelta;
+            {
+              text: agentResponse.text,
             },
-          });
-          fullResponse = agentResponse.text;
+            sessionId,
+            agentResponse.turnId,
+          );
           const speech = await audioAdapter.synthesize({
-            text: fullResponse,
-            ...speechBody.tts,
+            text: agentResponse.text,
+            stream: true,
+            streamFormat: "audio",
+            format: "mp3",
           });
-          sequenceDebugCollector.flush();
-          const turnUpdates: Record<string, unknown> = {
-            [this.options.turnResource.responseField]: fullResponse,
-          };
 
-          if (this.options.turnResource.debugField) {
-            turnUpdates[this.options.turnResource.debugField] = sequenceDebugCollector.getHistory();
-          }
+          stream.audioStart(speech.mimeType, speech.format);
 
-          await this.updateTurn(turnId, turnUpdates);
+          const reader = speech.audioStream.getReader();
 
-          return {
-            transcript: {
-              text: transcription.text,
-              language: transcription.language,
-            },
-            response: {
-              text: fullResponse,
-            },
-            audio: {
-              base64: speech.audio.toString("base64"),
-              mimeType: speech.mimeType,
-              format: speech.format,
-            },
-            sessionId,
-            turnId,
-          };
-        } catch (error) {
-          logger.error(`Agent speech response failed:\n${formatAgentError(error)}`);
-          sequenceDebugCollector.flush();
-          fullResponse = formatAgentResponseError(error);
-          const turnUpdates: Record<string, unknown> = {
-            [this.options.turnResource.responseField]: fullResponse,
-          };
+          try {
+            while (true) {
+              const { value, done } = await reader.read();
+
+              if (done) {
+                break;
+              }
 
-          if (this.options.turnResource.debugField) {
-            turnUpdates[this.options.turnResource.debugField] = sequenceDebugCollector.getHistory();
+              stream.audioDelta(value);
+            }
+          } finally {
+            reader.releaseLock();
           }
 
-          await this.updateTurn(turnId, turnUpdates);
-          response.setStatus(500, undefined);
-          return {
-            error: fullResponse,
-          };
+          stream.audioDone();
+          stream.end();
+          return null;
+        } catch (error) {
+          if (abortSignal.aborted) {
+            logger.info("Agent speech audio streaming aborted by the client");
+          } else {
+            logger.error(`Agent speech audio streaming failed:\n${error}`);
+            stream.error(error);
+          }
+          stream.end();
+          return null;
         }
       }
     });
     server.endpoint({
       method: 'POST',
       path: `/agent/get-sessions`,
-      handler: async ({body, adminUser }) => {
+      handler: async ({body, adminUser, response }) => {
+        const data = this.parseBody(getSessionsBodySchema, body, response);
+        if (!data) return;
         const userId = adminUser.pk;
-        const limit = typeof body.limit === 'number' ? body.limit : 20;
-        const sessions = await this.adminforth.resource(this.pluginOptions.sessionResource.resourceId).list(
-          [Filters.EQ(this.pluginOptions.sessionResource.askerIdField, userId)], limit, undefined, [Sorts.DESC(this.pluginOptions.sessionResource.createdAtField)]
+        const limit = data.limit ?? 20;
+        const sessions = await this.adminforth.resource(this.options.sessionResource.resourceId).list(
+          [Filters.EQ(this.options.sessionResource.askerIdField, userId)], limit, undefined, [Sorts.DESC(this.options.sessionResource.createdAtField)]
         );
-        const sessionsToReturn = [];
-        for (const session of sessions) {
-         sessionsToReturn.push({
-          sessionId: session[this.pluginOptions.sessionResource.idField],
-          title: session[this.pluginOptions.sessionResource.titleField],
-          timestamp: session[this.pluginOptions.sessionResource.createdAtField],
-         })
-        }
         return {
-          sessions: sessionsToReturn
+          sessions: sessions.map((session) => ({
+            sessionId: session[this.options.sessionResource.idField],
+            title: session[this.options.sessionResource.titleField],
+            timestamp: session[this.options.sessionResource.createdAtField],
+          })),
         };
       }
     });
     server.endpoint({
       method: 'POST',
       path: `/agent/get-session-info`,
-      handler: async ({body, adminUser }) => {
+      handler: async ({body, adminUser, response }) => {
+        const parsedBody = sessionIdBodySchema.safeParse(body);
+        if (!parsedBody.success) {
+          response.setStatus(422, parsedBody.error.message);
+          return;
+        }
         const userId = adminUser.pk;
-        const sessionId = body.sessionId;
-        const session = await this.adminforth.resource(this.pluginOptions.sessionResource.resourceId).get(
-          [Filters.EQ(this.pluginOptions.sessionResource.idField, sessionId)]
+        const sessionId = parsedBody.data.sessionId;
+        const session = await this.adminforth.resource(this.options.sessionResource.resourceId).get(
+          [Filters.EQ(this.options.sessionResource.idField, sessionId)]
         );
         if (!session) {
           return {
             error: 'Session not found'
           };
         }
-        if (session[this.pluginOptions.sessionResource.askerIdField] !== userId) {
+        if (session[this.options.sessionResource.askerIdField] !== userId) {
           return {
             error: 'Unauthorized'
           };
         }
         const turns = await this.getSessionTurns(sessionId);
-        const messagesToReturn = [];
-        for (const turn of turns) {
-          messagesToReturn.push({
-            text: turn.prompt,
-            role: 'user',
-          });
-          if (turn.response !== "not_finished") {
-            messagesToReturn.push({
-              text: turn.response,
-              role: 'assistant',
-            });
-          }
-        }
-        const sessionToReturn = {
-          sessionId: session[this.pluginOptions.sessionResource.idField],
-          title: session[this.pluginOptions.sessionResource.titleField],
-          timestamp: session[this.pluginOptions.sessionResource.createdAtField],
-          messages: messagesToReturn
-        }
         return {
-          session: sessionToReturn
-        }
+          session: {
+            sessionId,
+            title: session[this.options.sessionResource.titleField],
+            timestamp: session[this.options.sessionResource.createdAtField],
+            messages: turns.flatMap(turn => {
+              const messages = [];
+              if (turn.prompt) {
+                messages.push({
+                  text: turn.prompt,
+                  role: 'user',
+                });
+              }
+              if (turn.response && turn.response !== "not_finished") {
+                messages.push({
+                  text: turn.response,
+                  role: 'assistant',
+                });
+              }
+              return messages;
+            }),
+          },
+        };
       }
     });
     server.endpoint({
       method: 'POST',
       path: `/agent/create-session`,
-      handler: async ({body, adminUser }) => {
-        const triggerMessage = body.triggerMessage;
+      handler: async ({body, adminUser, response }) => {
+        const data = this.parseBody(createSessionBodySchema, body, response);
+        if (!data) return;
+        const triggerMessage = data.triggerMessage;
         const userId = adminUser.pk;
-        const title = triggerMessage ? (triggerMessage.length > 40 ? triggerMessage.slice(0, 40) : triggerMessage) : 'New Session';
+        const title = triggerMessage?.slice(0, 40) || "New Session";
         const newSession = {
-          [this.pluginOptions.sessionResource.idField]: randomUUID(),
-          [this.pluginOptions.sessionResource.titleField]: title,
-          [this.pluginOptions.sessionResource.askerIdField]: userId,
+          [this.options.sessionResource.idField]: randomUUID(),
+          [this.options.sessionResource.titleField]: title,
+          [this.options.sessionResource.askerIdField]: userId,
         };
-        await this.adminforth.resource(this.pluginOptions.sessionResource.resourceId).create(newSession);
+        await this.adminforth.resource(this.options.sessionResource.resourceId).create(newSession);
         return {
-          sessionId: newSession[this.pluginOptions.sessionResource.idField],
-          title: newSession[this.pluginOptions.sessionResource.titleField],
-          timestamp: newSession[this.pluginOptions.sessionResource.createdAtField],
+          sessionId: newSession[this.options.sessionResource.idField],
+          title: newSession[this.options.sessionResource.titleField],
+          timestamp: newSession[this.options.sessionResource.createdAtField],
           messages: []
         };
       }
@@ -783,28 +607,30 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
     server.endpoint({
       method: 'POST',
       path: `/agent/delete-session`,
-      handler: async ({body, adminUser }) => {
-        const sessionId = body.sessionId;
+      handler: async ({body, adminUser, response }) => {
+        const data = this.parseBody(sessionIdBodySchema, body, response);
+        if (!data) return;
+        const sessionId = data.sessionId;
         const userId = adminUser.pk;
-        const session = await this.adminforth.resource(this.pluginOptions.sessionResource.resourceId).get(
-          [Filters.EQ(this.pluginOptions.sessionResource.idField, sessionId)]
+        const session = await this.adminforth.resource(this.options.sessionResource.resourceId).get(
+          [Filters.EQ(this.options.sessionResource.idField, sessionId)]
         );
         if (!session) {
           return {
             error: 'Session not found'
           };
         }
-        if (session[this.pluginOptions.sessionResource.askerIdField] !== userId) {
+        if (session[this.options.sessionResource.askerIdField] !== userId) {
           return {
             error: 'Unauthorized'
           };
         }
-        await this.adminforth.resource(this.pluginOptions.sessionResource.resourceId).delete(sessionId);
-        const turns = await this.adminforth.resource(this.pluginOptions.turnResource.resourceId).list(
-          [Filters.EQ(this.pluginOptions.turnResource.sessionIdField, sessionId)]
+        await this.adminforth.resource(this.options.sessionResource.resourceId).delete(sessionId);
+        const turns = await this.adminforth.resource(this.options.turnResource.resourceId).list(
+          [Filters.EQ(this.options.turnResource.sessionIdField, sessionId)]
         );
         for (const turn of turns) {
-          await this.adminforth.resource(this.pluginOptions.turnResource.resourceId).delete(turn[this.pluginOptions.turnResource.idField]);
+          await this.adminforth.resource(this.options.turnResource.resourceId).delete(turn[this.options.turnResource.idField]);
         }
         return {
           ok: true
@@ -814,14 +640,14 @@ export default class AdminForthAgentPlugin extends AdminForthPlugin {
     server.endpoint({
       method: 'POST',
       path: `/agent/add-system-message-to-turns`,
-      handler: async ({body, adminUser, _raw_express_req }) => {
-        const sessionId = body.sessionId;
-        const systemMessage = body.systemMessage;
-        await this.createNewTurn(sessionId, systemMessage);
+      handler: async ({body, response }) => {
+        const data = this.parseBody(addSystemMessageBodySchema, body, response);
+        if (!data) return;
+        await this.createNewTurn(data.sessionId, data.systemMessage);
         return {
           ok: true
         }
       }
-    });
+    })
   }
 }
diff --git a/package.json b/package.json
index 159951d..636aceb 100644
--- a/package.json
+++ b/package.json
@@ -33,9 +33,10 @@
     "@langchain/core": "^1.1.40",
     "@langchain/langgraph": "^1.2.8",
     "@langchain/langgraph-checkpoint": "^1.0.1",
-    "adminforth": "2.51.0",
+    "adminforth": "^2.52.0",
     "dayjs": "^1.11.20",
     "langchain": "^1.3.3",
+    "multer": "^2.1.1",
     "vue-i18n": "^11.4.0",
     "yaml": "^2.8.3",
     "zod": "^4.3.6"
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 4da4fa2..34bf50f 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -13,22 +13,25 @@ importers:
         version: 1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0)
       '@langchain/langgraph':
         specifier: ^1.2.8
-        version: 1.2.8(@langchain/core@1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0))(vue@3.5.33(typescript@5.9.3))(zod@4.3.6)
+        version: 1.2.8(@langchain/core@1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0))(vue@3.5.34(typescript@5.9.3))(zod@4.3.6)
       '@langchain/langgraph-checkpoint':
         specifier: ^1.0.1
         version: 1.0.1(@langchain/core@1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0))
       adminforth:
-        specifier: 2.51.0
-        version: 2.51.0(@types/node@25.6.0)(typescript@5.9.3)
+        specifier: ^2.52.0
+        version: 2.52.0(@types/node@25.6.0)(typescript@5.9.3)
       dayjs:
         specifier: ^1.11.20
         version: 1.11.20
       langchain:
         specifier: ^1.3.3
-        version: 1.3.3(@langchain/core@1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0))(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(vue@3.5.33(typescript@5.9.3))(ws@8.20.0)
+        version: 1.3.3(@langchain/core@1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0))(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(vue@3.5.34(typescript@5.9.3))(ws@8.20.0)
+      multer:
+        specifier: ^2.1.1
+        version: 2.1.1
       vue-i18n:
         specifier: ^11.4.0
-        version: 11.4.0(vue@3.5.33(typescript@5.9.3))
+        version: 11.4.0(vue@3.5.34(typescript@5.9.3))
       yaml:
         specifier: ^2.8.3
         version: 2.8.3
@@ -63,8 +66,8 @@ packages:
     resolution: {integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==}
     engines: {node: '>=6.9.0'}
 
-  '@babel/parser@7.29.2':
-    resolution: {integrity: sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==}
+  '@babel/parser@7.29.3':
+    resolution: {integrity: sha512-b3ctpQwp+PROvU/cttc4OYl4MzfJUWy6FZg+PMXfzmt/+39iHVF0sDfqay8TQM3JA2EUOyKcFZt75jWriQijsA==}
     engines: {node: '>=6.0.0'}
     hasBin: true
 
@@ -78,11 +81,11 @@ packages:
   '@chainsafe/is-ip@2.1.0':
     resolution: {integrity: sha512-KIjt+6IfysQ4GCv66xihEitBjvhU/bixbbbFxdJ1sqCp4uJ0wuZiYBPhksZoy4lfaF0k9cwNzY5upEW/VWdw3w==}
 
-  '@clickhouse/client-common@1.18.2':
-    resolution: {integrity: sha512-J0SG6q9V31ydxonglpj9xhNRsUxCsF71iEZ784yldqMYwsHixj/9xHFDgBDX3DuMiDx/kPDfXnf+pimp08wIBA==}
+  '@clickhouse/client-common@1.18.3':
+    resolution: {integrity: sha512-3axzO3zvrsGT5PzDenxgWscltYCNRDbhaHWUgdsmcM9OnW/VnZn9EarOcZogr9P82Z0mQh+Jd2x+p2K4TFD2fA==}
 
-  '@clickhouse/client@1.18.2':
-    resolution: {integrity: sha512-fuquQswRSHWM6D079ZeuGqkMOsqtcUPL06UdTnowmoeeYjVrqisfVmvnw8pc3OeKS4kVb91oygb/MfLDiMs0TQ==}
+  '@clickhouse/client@1.18.3':
+    resolution: {integrity: sha512-340ngdYktL8PLUBK2QKSwe0o02tYfZSz1mSn1uXCEU8TxHvwh9pnQxElf9YHumDGj5gX/IdgxPsJTGMs82Hgug==}
     engines: {node: '>=16'}
 
   '@colors/colors@1.5.0':
@@ -287,8 +290,8 @@ packages:
       zod-to-json-schema:
         optional: true
 
-  '@mongodb-js/saslprep@1.4.6':
-    resolution: {integrity: sha512-y+x3H1xBZd38n10NZF/rEBlvDOOMQ6LKUTHqr8R9VkJ+mmQOYtJFxIlkkK8fZrtOiL6VixbOBWMbZGBdal3Z1g==}
+  '@mongodb-js/saslprep@1.4.11':
+    resolution: {integrity: sha512-o9rAHc0IpIjuPSxRutWpE1F62x7n+4mVS4rCNHkzhIUMQcc18bb6xEq5wd2NdN0WjepIyXIppRshYI2kQDOZVA==}
 
   '@octokit/auth-token@6.0.0':
     resolution: {integrity: sha512-P4YJBPdPSpWTQ1NU4XYdvHvXJJDxM6YwpS0FZHRgP7YFkdVxsWcpWGy/NVqlAA7PcPCnMacXlRm1y2PFZRWL/w==}
@@ -369,20 +372,20 @@ packages:
     resolution: {integrity: sha512-oQG/FejNpItrxRHoyctYvT3rwGZOnK4jr3JdppO/c78ktDvkWiPXPHNsrDf33K9sZdRb6PR7gi4noIapu5q4HA==}
     engines: {node: '>=18.0.0', pnpm: '>=8'}
 
-  '@scalar/client-side-rendering@0.1.2':
-    resolution: {integrity: sha512-gX2QIc+lpErO9RWkJmt02sBZoCOjyZ7EiLLEyGj7x9UKkk7E4zj6Wbk1eUPo6i3oIwhtZ+Vybj/xzexCK2bxwA==}
+  '@scalar/client-side-rendering@0.1.6':
+    resolution: {integrity: sha512-ooc5RKyi83EvBuxB2N8H00ZE2CF4oKynuUToSCaoqxkjv+oJ6B3+OYsb0HVixznsyWhUDdtQZm4/xOb0kxBaaA==}
     engines: {node: '>=22'}
 
-  '@scalar/express-api-reference@0.9.9':
-    resolution: {integrity: sha512-YE/ZvEtchsM2Jc4wDq2bhMcXicueVVOWmh+nnG3PlvB2LprLMgR+TikBcYD94vWaSakS5D3dgieEifVwejIsCw==}
+  '@scalar/express-api-reference@0.9.13':
+    resolution: {integrity: sha512-QjmHpqKxsVxYqtlS1FkSHrK1AtLzsQRvAwwxTan+hH2c/xJ00hSjXCeDEyUnmy6UF5J+B2GuuyKEOWsFv0ApzA==}
     engines: {node: '>=22'}
 
-  '@scalar/helpers@0.5.1':
-    resolution: {integrity: sha512-9VvPfv8b+YZVIFwR3SWeq4Y8ij/kU3/kf2M6NKcbf2iVyh63d8s0ssap5m/nOhiz/Puidv/29MAJlJCA0LRssA==}
+  '@scalar/helpers@0.5.5':
+    resolution: {integrity: sha512-TqbErkqGijJJW6Ad8lpswHFTmlJaYFt9oolaWF1/Nn9171xdkK9ZDAk3pCaOCWs8WpwvcbUSxIVD8JxdBg0MFg==}
     engines: {node: '>=22'}
 
-  '@scalar/types@0.9.1':
-    resolution: {integrity: sha512-3EbkhtQc+XuDE8Ur1MPosM3YTACFIFNba4M3vGulqv8jcvhMXT+KWPvGUJxq0CDvySqjGa8cE6w85v8T+MjDng==}
+  '@scalar/types@0.9.5':
+    resolution: {integrity: sha512-joen5nuqgmGzgXK5XIqkGs0JmCZ16djaw+pgC24sfb+p3sSPVfKQTNTil/RuvHMNsmA/dFcQ6GI0Y3HhTlUQrg==}
     engines: {node: '>=22'}
 
   '@sec-ant/readable-stream@0.4.1':
@@ -488,44 +491,44 @@ packages:
   '@types/whatwg-url@11.0.5':
     resolution: {integrity: sha512-coYR071JRaHa+xoEvvYqvnIHaVqaYrLPbsufM9BF63HkwI5Lgmy2QR8Q5K/lYDYo5AK82wOvSOS0UsLTpTG7uQ==}
 
-  '@vue/compiler-core@3.5.33':
-    resolution: {integrity: sha512-3PZLQwFw4Za3TC8t0FvTy3wI16Kt+pmwcgNZca4Pj9iWL2E72a/gZlpBtAJvEdDMdCxdG/qq0C7PN0bsJuv0Rw==}
+  '@vue/compiler-core@3.5.34':
+    resolution: {integrity: sha512-s9cLyK5mLcvZ4Agva5QgRsQyLKvts9WbU9DB6NqiZkkGEdwmcEiylj5Jbwkp680drF/NNCV8OlAJSe+yMLxaJw==}
 
-  '@vue/compiler-dom@3.5.33':
-    resolution: {integrity: sha512-PXq0yrfCLzzL07rbXO4awtXY1Z06LG2eu6Adg3RJFa/j3Cii217XxxLXG22N330gw7GmALCY0Z8RgXEviwgpjA==}
+  '@vue/compiler-dom@3.5.34':
+    resolution: {integrity: sha512-EbF/T++k0e2MMZlJsBhzK8Sgwt0HcIPOhzn1CTB/lv6sQcyk+OWf8YeiLxZp3ro7MbbLcAfAJ6sEvjFWuNgUCw==}
 
-  '@vue/compiler-sfc@3.5.33':
-    resolution: {integrity: sha512-UTUvRO9cY+rROrx/pvN9P5Z7FgA6QGfokUCfhQE4EnmUj3rVnK+CHI0LsEO1pg+I7//iRYMUfcNcCPe7tg0CoA==}
+  '@vue/compiler-sfc@3.5.34':
+    resolution: {integrity: sha512-D/ihr6uZeIt6r+pVZf46RWT1fAsLFMbUP7k8G1VkiiWexriED9GrX3echHd4Abbt17zjlfiFJ8z7a3BxZOPNjg==}
 
-  '@vue/compiler-ssr@3.5.33':
-    resolution: {integrity: sha512-IErjYdnj1qIupG5xxiVIYiiRvDhGWV4zuh/RCrwfYpuL+HWQzeU6lCk/nF9r7olWMnjKxCAkOctT2qFWFkzb1A==}
+  '@vue/compiler-ssr@3.5.34':
+    resolution: {integrity: sha512-cDtTHKibkThKGHH1SP+WdccquNRYQDFH6rRjQCqT9G2ltFAfoR5pUftpab/z+aM5mW9HLLVQW7hfKKQe/1GBeQ==}
 
   '@vue/devtools-api@6.6.4':
     resolution: {integrity: sha512-sGhTPMuXqZ1rVOk32RylztWkfXTRhuS7vgAKv0zjqk8gbsHkJ7xfFf+jbySxt7tWObEJwyKaHMikV/WGDiQm8g==}
 
-  '@vue/reactivity@3.5.33':
-    resolution: {integrity: sha512-p8UfIqyIhb0rYGlSgSBV+lPhF2iUSBcRy7enhTmPqKWadHy9kcOFYF1AejYBP9P+avnd3OBbD49DU4pLWX/94A==}
+  '@vue/reactivity@3.5.34':
+    resolution: {integrity: sha512-y9XDjCEuBp+98k+UL5dbYkh57AHU4o6cxZedOPXw3bmrZZYLQsVHguGurq7hVrPCSrQtrnz1f9dssyFr+dMXfQ==}
 
-  '@vue/runtime-core@3.5.33':
-    resolution: {integrity: sha512-UpFF45RI9//a7rvq7RdOQblb4tup7hHG9QsmIrxkFQLzQ7R8/iNQ5LE15NhLZ1/WcHMU2b47u6P33CPUelHyIQ==}
+  '@vue/runtime-core@3.5.34':
+    resolution: {integrity: sha512-mKeBYvu8tcMSLhypAHBmriUFfWXKTCF/23Z4jiCoYK3UtWepkliViNLuR90V9XOyD62mUxs9p1jsrpK3CCGIzw==}
 
-  '@vue/runtime-dom@3.5.33':
-    resolution: {integrity: sha512-IOxMsAOwquhfITgmOgaPYl7/j8gKUxUFoflRc+u4LxyD3+783xne8vNta1PONVCvCV9A0w7hkyEepINDqfO0tw==}
+  '@vue/runtime-dom@3.5.34':
+    resolution: {integrity: sha512-e8kZzERmCwUnBRVsgSQlAfrfU2rGoy0FFKPBXSlfEjc/O3KfA7QP0t1/2ZylrbchjmIKB4dPTd07A6WPr0eOrg==}
 
-  '@vue/server-renderer@3.5.33':
-    resolution: {integrity: sha512-0xylq/8/h44lVG0pZFknv1XIdEgymq2E9n59uTWJBG+dIgiT0TMCSsxrN7nO16Z0MU0MPjFcguBbZV8Itk52Hw==}
+  '@vue/server-renderer@3.5.34':
+    resolution: {integrity: sha512-nHxmJoTrKsmrkbILRhkC9gY1G3moZbJTqCzDd7DOOzG5KH9oeJ0Unqrff5f9v0pW//jES05ZkJcNtfE8JjOIew==}
     peerDependencies:
-      vue: 3.5.33
+      vue: 3.5.34
 
-  '@vue/shared@3.5.33':
-    resolution: {integrity: sha512-5vR2QIlmaLG77Ygd4pMP6+SGQ5yox9VhtnbDWTy9DzMzdmeLxZ1QqxrywEZ9sa1AVubfIJyaCG3ytyWU81ufcQ==}
+  '@vue/shared@3.5.34':
+    resolution: {integrity: sha512-24uqU4OIiX29ryC3MeWid/Xf2fa2EFRUVLb77nRhk+UrTVrh/XiGtFAFmJBAtBRbjwNdsPRP+jj/OL27Eg1NDA==}
 
   accepts@1.3.8:
     resolution: {integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==}
     engines: {node: '>= 0.6'}
 
-  adminforth@2.51.0:
-    resolution: {integrity: sha512-1SkHwbmW5V28kPy/3GkqSsiMmaPbp2rm3xbESyXYssnrXVgT5c+ju4A/3Ultnd9qcw1pXeWvXj398TWu4rgHLQ==}
+  adminforth@2.52.0:
+    resolution: {integrity: sha512-lY1i6nXnrs4ZjvV4fVZ8ja07oz3CwDL3aAr2AcotX+xKZ8yql7ZPtARqgBbjr1+4QNJmV+ZRSs+ei/650gRUsw==}
     hasBin: true
 
   agent-base@7.1.4:
@@ -536,8 +539,8 @@ packages:
     resolution: {integrity: sha512-gOsf2YwSlleG6IjRYG2A7k0HmBMEo6qVNk9Bp/EaLgAJT5ngH6PXbqa4ItvnEwCm/velL5jAnQgsHsWnjhGmvw==}
     engines: {node: '>=18'}
 
-  ajv@8.18.0:
-    resolution: {integrity: sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==}
+  ajv@8.20.0:
+    resolution: {integrity: sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==}
 
   ansi-escapes@7.3.0:
     resolution: {integrity: sha512-BvU8nYgGQBxcmMuEeUEmNTvrMVjJNSH7RgW24vXexN4Ven6qCvy4TntnvlnwnMLTVlcRQQdbRY8NKnaIoeWDNg==}
@@ -570,6 +573,9 @@ packages:
   any-promise@1.3.0:
     resolution: {integrity: sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==}
 
+  append-field@1.0.0:
+    resolution: {integrity: sha512-klpgFSWLW1ZEs8svjfb7g4qWY0YS5imI82dTg+QahUvJ8YqAY0P10Uk8tTyh9ZGuYEZEMaeJYCF5BFuX552hsw==}
+
   arg@5.0.2:
     resolution: {integrity: sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==}
 
@@ -619,8 +625,8 @@ packages:
   bl@4.1.0:
     resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==}
 
-  body-parser@1.20.4:
-    resolution: {integrity: sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA==}
+  body-parser@1.20.5:
+    resolution: {integrity: sha512-3grm+/2tUOvu2cjJkvsIxrv/wVpfXQW4PsQHYm7yk4vfpu7Ekl6nEsYBoJUL6qDwZUx8wUhQ8tR2qz+ad9c9OA==}
     engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16}
 
   bottleneck@2.19.5:
@@ -641,9 +647,16 @@ packages:
   buffer-equal-constant-time@1.0.1:
     resolution: {integrity: sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==}
 
+  buffer-from@1.1.2:
+    resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
+
   buffer@5.7.1:
     resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==}
 
+  busboy@1.6.0:
+    resolution: {integrity: sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA==}
+    engines: {node: '>=10.16.0'}
+
   bytes@3.1.2:
     resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==}
     engines: {node: '>= 0.8'}
@@ -749,6 +762,10 @@ packages:
   compare-func@2.0.0:
     resolution: {integrity: sha512-zHig5N+tPWARooBnb0Zx1MFcdfpyJrfTJ3Y5L+IFvUm8rM74hHz66z0gw0x4tijh5CorKkKUCnW82R2vmpeCRA==}
 
+  concat-stream@2.0.0:
+    resolution: {integrity: sha512-MWufYdFw53ccGjCA+Ol7XJYpAlW6/prSMzuPOTRnJGcGzuhLn4Scrz7qf6o8bROZ514ltazcIFJZevcfbo0x7A==}
+    engines: {'0': node >= 6.0}
+
   config-chain@1.1.13:
     resolution: {integrity: sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==}
 
@@ -1169,8 +1186,8 @@ packages:
     resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==}
     engines: {node: '>= 0.4'}
 
-  hasown@2.0.2:
-    resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}
+  hasown@2.0.3:
+    resolution: {integrity: sha512-ej4AhfhfL2Q2zpMmLo7U1Uv9+PyhIZpgQLGT1F9miIGmiCJIoCgSmczFdrc97mWT4kVY72KA+WnnhJ5pghSvSg==}
     engines: {node: '>= 0.4'}
 
   help-me@5.0.0:
@@ -1268,8 +1285,8 @@ packages:
     resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==}
     engines: {node: '>= 0.10'}
 
-  ipaddr.js@2.3.0:
-    resolution: {integrity: sha512-Zv/pA+ciVFbCSBBjGfaKUya/CcGmUHzTydLMaTwrUUEM2DIEO3iZvueGxmacvmN50fGpGVKeTXpb2LcYQxeVdg==}
+  ipaddr.js@2.4.0:
+    resolution: {integrity: sha512-9VGk3HGanVE6JoZXHiCpnGy5X0jYDnN4EA4lntFPj+1vIWlFhIylq2CrrCOJH9EAhc5CYhq18F2Av2tgoAPsYQ==}
     engines: {node: '>= 10'}
 
   is-alphabetical@1.0.4:
@@ -1660,6 +1677,10 @@ packages:
   ms@2.1.3:
     resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
 
+  multer@2.1.1:
+    resolution: {integrity: sha512-mo+QTzKlx8R7E5ylSXxWzGoXoZbOsRMpyitcht8By2KHvMbf3tjwosZ/Mu/XYU6UuJ3VZnODIrak5ZrPiPyB6A==}
+    engines: {node: '>= 10.16.0'}
+
   mustache@4.2.0:
     resolution: {integrity: sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ==}
     hasBin: true
@@ -1668,8 +1689,8 @@ packages:
     resolution: {integrity: sha512-WWdIxpyjEn+FhQJQQv9aQAYlHoNVdzIzUySNV1gHUPDSdZJ3yZn7pAAbQcV7B56Mvu881q9FZV+0Vx2xC44VWA==}
     engines: {node: ^18.17.0 || >=20.5.0}
 
-  mysql2@3.22.0:
-    resolution: {integrity: sha512-4jaJYBObj7FhD3lnZhqX1yDMuZN4mQNz+IolDySDXT7fbozMBpeGQNcuWXKUqo4ahkAEfkjUHPjnwuDI0/6VKw==}
+  mysql2@3.22.3:
+    resolution: {integrity: sha512-uWWxvZSRvRhtBdh2CdcuK83YcOfPdmEeEYB069bAmPnV93QApDGVPuvCQOLjlh7tYHEWdgQPrn6kosDxHBVLkA==}
     engines: {node: '>= 8.0'}
     peerDependencies:
       '@types/node': '>= 8'
@@ -1686,8 +1707,8 @@ packages:
     engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
     hasBin: true
 
-  nanoid@5.1.9:
-    resolution: {integrity: sha512-ZUvP7KeBLe3OZ1ypw6dI/TzYJuvHP77IM4Ry73waSQTLn8/g8rpdjfyVAh7t1/+FjBtG4lCP42MEbDxOsRpBMw==}
+  nanoid@5.1.11:
+    resolution: {integrity: sha512-v+KEsUv2ps74PaSKv0gHTxTCgMXOIfBEbaqa6w6ISIGC7ZsvHN4N9oJ8d4cmf0n5oTzQz2SLmThbQWhjd/8eKg==}
     engines: {node: ^18 || >=20}
     hasBin: true
 
@@ -1708,8 +1729,8 @@ packages:
     resolution: {integrity: sha512-eonl3sLUha+S1GzTPxychyhnUzKyeQkZ7jLjKrBagJgPla13F+uQ71HgpFefyHgqrjEbCPkDArxYsjY8/+gLKA==}
     engines: {node: '>= 0.4.0'}
 
-  node-abi@3.89.0:
-    resolution: {integrity: sha512-6u9UwL0HlAl21+agMN3YAMXcKByMqwGx+pq+P76vii5f7hTPtKDp08/H9py6DY+cfDw7kQNTGEj/rly3IgbNQA==}
+  node-abi@3.90.0:
+    resolution: {integrity: sha512-pZNQT7UnYlMwMBy5N1lV5X/YLTbZM5ncytN3xL7CHEzhDN8uVe0u55yaPUJICIJjaCW8NrM5BFdqr7HLweStNA==}
     engines: {node: '>=10'}
 
   node-domexception@1.0.0:
@@ -2049,8 +2070,8 @@ packages:
     resolution: {integrity: sha512-C+VUP+8jis7EsQZIhDYmS5qlNtjv2yP4SNtjXK9AP1ZcTRlnSfuumaTnRfYZnYgUUYVIKqL0fRvmUGDV2fmp6g==}
     engines: {node: '>=4'}
 
-  postcss@8.5.13:
-    resolution: {integrity: sha512-qif0+jGGZoLWdHey3UFHHWP0H7Gbmsk8T5VEqyYFbWqPr1XqvLGBbk/sl8V5exGmcYJklJOhOQq1pV9IcsiFag==}
+  postcss@8.5.14:
+    resolution: {integrity: sha512-SoSL4+OSEtR99LHFZQiJLkT59C5B1amGO1NzTwj7TT1qCUgUO6hxOvzkOYxD+vMrXBM3XJIKzokoERdqQq/Zmg==}
     engines: {node: ^10 || ^12 || >=14}
 
   postgres-array@2.0.0:
@@ -2107,6 +2128,10 @@ packages:
     resolution: {integrity: sha512-V/yCWTTF7VJ9hIh18Ugr2zhJMP01MY7c5kh4J870L7imm6/DIzBsNLTXzMwUA3yZ5b/KBqLx8Kp3uRvd7xSe3Q==}
     engines: {node: '>=0.6'}
 
+  qs@6.15.1:
+    resolution: {integrity: sha512-6YHEFRL9mfgcAvql/XhwTvf5jKcOiiupt2FiJxHkiX1z4j7WL8J/jRHYLluORvc1XxB5rV20KoeK00gVJamspg==}
+    engines: {node: '>=0.6'}
+
   quick-format-unescaped@4.0.4:
     resolution: {integrity: sha512-tYC1Q1hgyRuHgloV/YXs2w15unPVh8qfu/qCTfhTYamaw7fyhumKa2yGpdSo87vY32rIclj+4fWYQXUMs9EHvg==}
 
@@ -2347,6 +2372,10 @@ packages:
   stream-combiner2@1.1.1:
     resolution: {integrity: sha512-3PnJbYgS56AeWgtKF5jtJRT6uFJe56Z0Hc5Ngg/6sI6rIt8iiMBTa9cvdyFfpMQjaVHr8dusbNeFGIIonxOvKw==}
 
+  streamsearch@1.1.0:
+    resolution: {integrity: sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==}
+    engines: {node: '>=10.0.0'}
+
   string-width@4.2.3:
     resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==}
     engines: {node: '>=8'}
@@ -2358,9 +2387,6 @@ packages:
   string_decoder@1.1.1:
     resolution: {integrity: sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==}
 
-  string_decoder@1.3.0:
-    resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==}
-
   strip-ansi@6.0.1:
     resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
     engines: {node: '>=8'}
@@ -2497,6 +2523,9 @@ packages:
     resolution: {integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==}
     engines: {node: '>= 0.6'}
 
+  typedarray@0.0.6:
+    resolution: {integrity: sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==}
+
   typescript@5.9.3:
     resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
     engines: {node: '>=14.17'}
@@ -2510,8 +2539,8 @@ packages:
   undici-types@7.19.2:
     resolution: {integrity: sha512-qYVnV5OEm2AW8cJMCpdV20CDyaN3g0AjDlOGf1OW4iaDEx8MwdtChUp4zu4H0VP3nDRF/8RKWH+IPp9uW0YGZg==}
 
-  undici@6.24.1:
-    resolution: {integrity: sha512-sC+b0tB1whOCzbtlx20fx3WgCXwkW627p4EA9uM+/tNNPkSS+eSEld6pAs9nDv7WbY1UUljBMYPtu9BCOrCWKA==}
+  undici@6.25.0:
+    resolution: {integrity: sha512-ZgpWDC5gmNiuY9CnLVXEH8rl50xhRCuLNA97fAUnKi8RRuV4E6KG31pDTsLVUKnohJE0I3XDrTeEydAXRw47xg==}
     engines: {node: '>=18.17'}
 
   unicode-emoji-modifier-base@1.0.0:
@@ -2601,8 +2630,8 @@ packages:
     peerDependencies:
       vue: ^3.0.0
 
-  vue@3.5.33:
-    resolution: {integrity: sha512-1AgChhx5w3ALgT4oK3acm2Es/7jyZhWSVUfs3rOBlGQC0rjEDkS7G4lWlJJGGNQD+BV3reCwbQrOe1mPNwKHBQ==}
+  vue@3.5.34:
+    resolution: {integrity: sha512-WdLBG9gm02OgJIG9axd5Hpx0TFLdzVgfG2evFFu8Rur5O/IoGc5cMjnjh3tPL6GnRGsYvUhBSKVPYVcxRKpMCA==}
     peerDependencies:
       typescript: '*'
     peerDependenciesMeta:
@@ -2720,7 +2749,7 @@ snapshots:
 
   '@babel/helper-validator-identifier@7.28.5': {}
 
-  '@babel/parser@7.29.2':
+  '@babel/parser@7.29.3':
     dependencies:
       '@babel/types': 7.29.0
 
@@ -2733,11 +2762,11 @@ snapshots:
 
   '@chainsafe/is-ip@2.1.0': {}
 
-  '@clickhouse/client-common@1.18.2': {}
+  '@clickhouse/client-common@1.18.3': {}
 
-  '@clickhouse/client@1.18.2':
+  '@clickhouse/client@1.18.3':
     dependencies:
-      '@clickhouse/client-common': 1.18.2
+      '@clickhouse/client-common': 1.18.3
 
   '@colors/colors@1.5.0':
     optional: true
@@ -2914,7 +2943,7 @@ snapshots:
       '@langchain/core': 1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0)
       uuid: 10.0.0
 
-  '@langchain/langgraph-sdk@1.8.8(@langchain/core@1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0))(vue@3.5.33(typescript@5.9.3))':
+  '@langchain/langgraph-sdk@1.8.8(@langchain/core@1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0))(vue@3.5.34(typescript@5.9.3))':
     dependencies:
       '@types/json-schema': 7.0.15
       p-queue: 9.1.2
@@ -2922,13 +2951,13 @@ snapshots:
       uuid: 13.0.0
     optionalDependencies:
       '@langchain/core': 1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0)
-      vue: 3.5.33(typescript@5.9.3)
+      vue: 3.5.34(typescript@5.9.3)
 
-  '@langchain/langgraph@1.2.8(@langchain/core@1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0))(vue@3.5.33(typescript@5.9.3))(zod@4.3.6)':
+  '@langchain/langgraph@1.2.8(@langchain/core@1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0))(vue@3.5.34(typescript@5.9.3))(zod@4.3.6)':
     dependencies:
       '@langchain/core': 1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0)
       '@langchain/langgraph-checkpoint': 1.0.1(@langchain/core@1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0))
-      '@langchain/langgraph-sdk': 1.8.8(@langchain/core@1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0))(vue@3.5.33(typescript@5.9.3))
+      '@langchain/langgraph-sdk': 1.8.8(@langchain/core@1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0))(vue@3.5.34(typescript@5.9.3))
       '@standard-schema/spec': 1.1.0
       uuid: 10.0.0
       zod: 4.3.6
@@ -2938,7 +2967,7 @@ snapshots:
       - svelte
       - vue
 
-  '@mongodb-js/saslprep@1.4.6':
+  '@mongodb-js/saslprep@1.4.11':
     dependencies:
       sparse-bitfield: 3.0.3
 
@@ -3026,24 +3055,24 @@ snapshots:
     dependencies:
       '@qdrant/openapi-typescript-fetch': 1.2.6
       typescript: 5.9.3
-      undici: 6.24.1
+      undici: 6.25.0
 
   '@qdrant/openapi-typescript-fetch@1.2.6': {}
 
-  '@scalar/client-side-rendering@0.1.2':
+  '@scalar/client-side-rendering@0.1.6':
     dependencies:
-      '@scalar/types': 0.9.1
+      '@scalar/types': 0.9.5
 
-  '@scalar/express-api-reference@0.9.9':
+  '@scalar/express-api-reference@0.9.13':
     dependencies:
-      '@scalar/client-side-rendering': 0.1.2
+      '@scalar/client-side-rendering': 0.1.6
 
-  '@scalar/helpers@0.5.1': {}
+  '@scalar/helpers@0.5.5': {}
 
-  '@scalar/types@0.9.1':
+  '@scalar/types@0.9.5':
     dependencies:
-      '@scalar/helpers': 0.5.1
-      nanoid: 5.1.9
+      '@scalar/helpers': 0.5.5
+      nanoid: 5.1.11
       type-fest: 5.6.0
       zod: 4.3.6
 
@@ -3196,77 +3225,77 @@ snapshots:
     dependencies:
       '@types/webidl-conversions': 7.0.3
 
-  '@vue/compiler-core@3.5.33':
+  '@vue/compiler-core@3.5.34':
     dependencies:
-      '@babel/parser': 7.29.2
-      '@vue/shared': 3.5.33
+      '@babel/parser': 7.29.3
+      '@vue/shared': 3.5.34
       entities: 7.0.1
       estree-walker: 2.0.2
       source-map-js: 1.2.1
 
-  '@vue/compiler-dom@3.5.33':
+  '@vue/compiler-dom@3.5.34':
     dependencies:
-      '@vue/compiler-core': 3.5.33
-      '@vue/shared': 3.5.33
+      '@vue/compiler-core': 3.5.34
+      '@vue/shared': 3.5.34
 
-  '@vue/compiler-sfc@3.5.33':
+  '@vue/compiler-sfc@3.5.34':
     dependencies:
-      '@babel/parser': 7.29.2
-      '@vue/compiler-core': 3.5.33
-      '@vue/compiler-dom': 3.5.33
-      '@vue/compiler-ssr': 3.5.33
-      '@vue/shared': 3.5.33
+      '@babel/parser': 7.29.3
+      '@vue/compiler-core': 3.5.34
+      '@vue/compiler-dom': 3.5.34
+      '@vue/compiler-ssr': 3.5.34
+      '@vue/shared': 3.5.34
       estree-walker: 2.0.2
       magic-string: 0.30.21
-      postcss: 8.5.13
+      postcss: 8.5.14
       source-map-js: 1.2.1
 
-  '@vue/compiler-ssr@3.5.33':
+  '@vue/compiler-ssr@3.5.34':
     dependencies:
-      '@vue/compiler-dom': 3.5.33
-      '@vue/shared': 3.5.33
+      '@vue/compiler-dom': 3.5.34
+      '@vue/shared': 3.5.34
 
   '@vue/devtools-api@6.6.4': {}
 
-  '@vue/reactivity@3.5.33':
+  '@vue/reactivity@3.5.34':
     dependencies:
-      '@vue/shared': 3.5.33
+      '@vue/shared': 3.5.34
 
-  '@vue/runtime-core@3.5.33':
+  '@vue/runtime-core@3.5.34':
     dependencies:
-      '@vue/reactivity': 3.5.33
-      '@vue/shared': 3.5.33
+      '@vue/reactivity': 3.5.34
+      '@vue/shared': 3.5.34
 
-  '@vue/runtime-dom@3.5.33':
+  '@vue/runtime-dom@3.5.34':
     dependencies:
-      '@vue/reactivity': 3.5.33
-      '@vue/runtime-core': 3.5.33
-      '@vue/shared': 3.5.33
+      '@vue/reactivity': 3.5.34
+      '@vue/runtime-core': 3.5.34
+      '@vue/shared': 3.5.34
       csstype: 3.2.3
 
-  '@vue/server-renderer@3.5.33(vue@3.5.33(typescript@5.9.3))':
+  '@vue/server-renderer@3.5.34(vue@3.5.34(typescript@5.9.3))':
     dependencies:
-      '@vue/compiler-ssr': 3.5.33
-      '@vue/shared': 3.5.33
-      vue: 3.5.33(typescript@5.9.3)
+      '@vue/compiler-ssr': 3.5.34
+      '@vue/shared': 3.5.34
+      vue: 3.5.34(typescript@5.9.3)
 
-  '@vue/shared@3.5.33': {}
+  '@vue/shared@3.5.34': {}
 
   accepts@1.3.8:
     dependencies:
       mime-types: 2.1.35
       negotiator: 0.6.3
 
-  adminforth@2.51.0(@types/node@25.6.0)(typescript@5.9.3):
+  adminforth@2.52.0(@types/node@25.6.0)(typescript@5.9.3):
     dependencies:
-      '@babel/parser': 7.29.2
-      '@clickhouse/client': 1.18.2
+      '@babel/parser': 7.29.3
+      '@clickhouse/client': 1.18.3
       '@faker-js/faker': 9.9.0
       '@inquirer/prompts': 7.10.1(@types/node@25.6.0)
       '@qdrant/js-client-rest': 1.17.0(typescript@5.9.3)
-      '@scalar/express-api-reference': 0.9.9
+      '@scalar/express-api-reference': 0.9.13
       '@types/express': 4.17.25
-      ajv: 8.18.0
+      ajv: 8.20.0
       arg: 5.0.2
       ast-types: 0.14.2
       better-sqlite3: 11.10.0
@@ -3287,7 +3316,8 @@ snapshots:
       jsonwebtoken: 9.0.3
       listr2: 8.3.3
       mongodb: 6.6.2
-      mysql2: 3.22.0(@types/node@25.6.0)
+      multer: 2.1.1
+      mysql2: 3.22.3(@types/node@25.6.0)
       node-fetch: 3.3.2
       pg: 8.20.0
       pino: 10.3.1
@@ -3320,7 +3350,7 @@ snapshots:
       clean-stack: 5.3.0
       indent-string: 5.0.0
 
-  ajv@8.18.0:
+  ajv@8.20.0:
     dependencies:
       fast-deep-equal: 3.1.3
       fast-uri: 3.1.0
@@ -3349,6 +3379,8 @@ snapshots:
 
   any-promise@1.3.0: {}
 
+  append-field@1.0.0: {}
+
   arg@5.0.2: {}
 
   argparse@2.0.1: {}
@@ -3392,7 +3424,7 @@ snapshots:
       inherits: 2.0.4
       readable-stream: 3.6.2
 
-  body-parser@1.20.4:
+  body-parser@1.20.5:
     dependencies:
       bytes: 3.1.2
       content-type: 1.0.5
@@ -3402,7 +3434,7 @@ snapshots:
       http-errors: 2.0.1
       iconv-lite: 0.4.24
       on-finished: 2.4.1
-      qs: 6.14.2
+      qs: 6.15.1
       raw-body: 2.5.3
       type-is: 1.6.18
       unpipe: 1.0.0
@@ -3421,11 +3453,17 @@ snapshots:
 
   buffer-equal-constant-time@1.0.1: {}
 
+  buffer-from@1.1.2: {}
+
   buffer@5.7.1:
     dependencies:
       base64-js: 1.5.1
       ieee754: 1.2.1
 
+  busboy@1.6.0:
+    dependencies:
+      streamsearch: 1.1.0
+
   bytes@3.1.2: {}
 
   call-bind-apply-helpers@1.0.2:
@@ -3530,6 +3568,13 @@ snapshots:
       array-ify: 1.0.0
       dot-prop: 5.3.0
 
+  concat-stream@2.0.0:
+    dependencies:
+      buffer-from: 1.1.2
+      inherits: 2.0.4
+      readable-stream: 3.6.2
+      typedarray: 0.0.6
+
   config-chain@1.1.13:
     dependencies:
       ini: 1.3.8
@@ -3739,7 +3784,7 @@ snapshots:
     dependencies:
       accepts: 1.3.8
       array-flatten: 1.1.1
-      body-parser: 1.20.4
+      body-parser: 1.20.5
       content-disposition: 0.5.4
       content-type: 1.0.5
       cookie: 0.7.2
@@ -3878,7 +3923,7 @@ snapshots:
       get-proto: 1.0.1
       gopd: 1.2.0
       has-symbols: 1.1.0
-      hasown: 2.0.2
+      hasown: 2.0.3
       math-intrinsics: 1.1.0
 
   get-proto@1.0.1:
@@ -3929,7 +3974,7 @@ snapshots:
 
   has-symbols@1.1.0: {}
 
-  hasown@2.0.2:
+  hasown@2.0.3:
     dependencies:
       function-bind: 1.1.2
 
@@ -4026,7 +4071,7 @@ snapshots:
 
   ipaddr.js@1.9.1: {}
 
-  ipaddr.js@2.3.0: {}
+  ipaddr.js@2.4.0: {}
 
   is-alphabetical@1.0.4: {}
 
@@ -4135,10 +4180,10 @@ snapshots:
       jwa: 2.0.1
       safe-buffer: 5.2.1
 
-  langchain@1.3.3(@langchain/core@1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0))(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(vue@3.5.33(typescript@5.9.3))(ws@8.20.0):
+  langchain@1.3.3(@langchain/core@1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0))(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(vue@3.5.34(typescript@5.9.3))(ws@8.20.0):
     dependencies:
       '@langchain/core': 1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0)
-      '@langchain/langgraph': 1.2.8(@langchain/core@1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0))(vue@3.5.33(typescript@5.9.3))(zod@4.3.6)
+      '@langchain/langgraph': 1.2.8(@langchain/core@1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0))(vue@3.5.34(typescript@5.9.3))(zod@4.3.6)
       '@langchain/langgraph-checkpoint': 1.0.1(@langchain/core@1.1.40(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0))
       langsmith: 0.5.19(openai@6.34.0(ws@8.20.0)(zod@4.3.6))(ws@8.20.0)
       uuid: 11.1.0
@@ -4404,7 +4449,7 @@ snapshots:
 
   mongodb@6.6.2:
     dependencies:
-      '@mongodb-js/saslprep': 1.4.6
+      '@mongodb-js/saslprep': 1.4.11
       bson: 6.10.4
       mongodb-connection-string-url: 3.0.2
 
@@ -4412,11 +4457,18 @@ snapshots:
 
   ms@2.1.3: {}
 
+  multer@2.1.1:
+    dependencies:
+      append-field: 1.0.0
+      busboy: 1.6.0
+      concat-stream: 2.0.0
+      type-is: 1.6.18
+
   mustache@4.2.0: {}
 
   mute-stream@2.0.0: {}
 
-  mysql2@3.22.0(@types/node@25.6.0):
+  mysql2@3.22.3(@types/node@25.6.0):
     dependencies:
       '@types/node': 25.6.0
       aws-ssl-profiles: 1.1.2
@@ -4440,7 +4492,7 @@ snapshots:
 
   nanoid@3.3.12: {}
 
-  nanoid@5.1.9: {}
+  nanoid@5.1.11: {}
 
   napi-build-utils@2.0.0: {}
 
@@ -4452,7 +4504,7 @@ snapshots:
 
   netmask@2.1.1: {}
 
-  node-abi@3.89.0:
+  node-abi@3.90.0:
     dependencies:
       semver: 7.7.4
 
@@ -4709,7 +4761,7 @@ snapshots:
       find-up: 2.1.0
       load-json-file: 4.0.0
 
-  postcss@8.5.13:
+  postcss@8.5.14:
     dependencies:
       nanoid: 3.3.12
       picocolors: 1.1.1
@@ -4733,7 +4785,7 @@ snapshots:
       minimist: 1.2.8
       mkdirp-classic: 0.5.3
       napi-build-utils: 2.0.0
-      node-abi: 3.89.0
+      node-abi: 3.90.0
       pump: 3.0.4
       rc: 1.2.8
       simple-get: 4.0.1
@@ -4748,7 +4800,7 @@ snapshots:
     dependencies:
       '@chainsafe/is-ip': 2.1.0
       ip-regex: 5.0.0
-      ipaddr.js: 2.3.0
+      ipaddr.js: 2.4.0
       netmask: 2.1.1
 
   process-nextick-args@2.0.1: {}
@@ -4773,6 +4825,10 @@ snapshots:
     dependencies:
       side-channel: 1.1.0
 
+  qs@6.15.1:
+    dependencies:
+      side-channel: 1.1.0
+
   quick-format-unescaped@4.0.4: {}
 
   range-parser@1.2.1: {}
@@ -4820,7 +4876,7 @@ snapshots:
   readable-stream@3.6.2:
     dependencies:
       inherits: 2.0.4
-      string_decoder: 1.3.0
+      string_decoder: 1.1.1
       util-deprecate: 1.0.2
 
   real-require@0.2.0: {}
@@ -5089,6 +5145,8 @@ snapshots:
       duplexer2: 0.1.4
       readable-stream: 2.3.8
 
+  streamsearch@1.1.0: {}
+
   string-width@4.2.3:
     dependencies:
       emoji-regex: 8.0.0
@@ -5105,10 +5163,6 @@ snapshots:
     dependencies:
       safe-buffer: 5.1.2
 
-  string_decoder@1.3.0:
-    dependencies:
-      safe-buffer: 5.2.1
-
   strip-ansi@6.0.1:
     dependencies:
       ansi-regex: 5.0.1
@@ -5237,6 +5291,8 @@ snapshots:
       media-typer: 0.3.0
       mime-types: 2.1.35
 
+  typedarray@0.0.6: {}
+
   typescript@5.9.3: {}
 
   uglify-js@3.19.3:
@@ -5244,7 +5300,7 @@ snapshots:
 
   undici-types@7.19.2: {}
 
-  undici@6.24.1: {}
+  undici@6.25.0: {}
 
   unicode-emoji-modifier-base@1.0.0: {}
 
@@ -5324,21 +5380,21 @@ snapshots:
       unist-util-stringify-position: 2.0.3
       vfile-message: 2.0.4
 
-  vue-i18n@11.4.0(vue@3.5.33(typescript@5.9.3)):
+  vue-i18n@11.4.0(vue@3.5.34(typescript@5.9.3)):
     dependencies:
       '@intlify/core-base': 11.4.0
       '@intlify/devtools-types': 11.4.0
       '@intlify/shared': 11.4.0
       '@vue/devtools-api': 6.6.4
-      vue: 3.5.33(typescript@5.9.3)
+      vue: 3.5.34(typescript@5.9.3)
 
-  vue@3.5.33(typescript@5.9.3):
+  vue@3.5.34(typescript@5.9.3):
     dependencies:
-      '@vue/compiler-dom': 3.5.33
-      '@vue/compiler-sfc': 3.5.33
-      '@vue/runtime-dom': 3.5.33
-      '@vue/server-renderer': 3.5.33(vue@3.5.33(typescript@5.9.3))
-      '@vue/shared': 3.5.33
+      '@vue/compiler-dom': 3.5.34
+      '@vue/compiler-sfc': 3.5.34
+      '@vue/runtime-dom': 3.5.34
+      '@vue/server-renderer': 3.5.34(vue@3.5.34(typescript@5.9.3))
+      '@vue/shared': 3.5.34
     optionalDependencies:
       typescript: 5.9.3
 
diff --git a/types.ts b/types.ts
index 37b88cd..fff50f3 100644
--- a/types.ts
+++ b/types.ts
@@ -49,7 +49,7 @@ export interface PluginOptions extends PluginsCommonOptions {
    */
   placeholderMessages?: ((input: {
     adminUser: AdminUser;
-    httpExtra: HttpExtra;
+    headers: HttpExtra["headers"];
   }) => string[] | Promise<string[]>);
 
   /**