diff --git a/cli/src/client/prompts.ts b/cli/src/client/prompts.ts
index 870146178..45e269f27 100644
--- a/cli/src/client/prompts.ts
+++ b/cli/src/client/prompts.ts
@@ -12,9 +12,14 @@ type JsonValue =
   | { [key: string]: JsonValue };
 
 // List available prompts
-export async function listPrompts(client: Client): Promise<McpResponse> {
+export async function listPrompts(
+  client: Client,
+  metaData?: Record<string, string>,
+): Promise<McpResponse> {
   try {
-    const response = await client.listPrompts();
+    const params =
+      metaData && Object.keys(metaData).length > 0 ? { _meta: metaData } : {};
+    const response = await client.listPrompts(params);
     return response;
   } catch (error) {
     throw new Error(
@@ -28,6 +33,7 @@ export async function getPrompt(
   client: Client,
   name: string,
   args?: Record<string, JsonValue>,
+  metaData?: Record<string, string>,
 ): Promise<McpResponse> {
   try {
     // Convert all arguments to strings for prompt arguments
@@ -44,10 +50,16 @@ export async function getPrompt(
       }
     }
 
-    const response = await client.getPrompt({
+    const params: any = {
       name,
       arguments: stringArgs,
-    });
+    };
+
+    if (metaData && Object.keys(metaData).length > 0) {
+      params._meta = metaData;
+    }
+
+    const response = await client.getPrompt(params);
 
     return response;
   } catch (error) {
diff --git a/cli/src/client/resources.ts b/cli/src/client/resources.ts
index bf33d64d2..d530bbc27 100644
--- a/cli/src/client/resources.ts
+++ b/cli/src/client/resources.ts
@@ -2,9 +2,14 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { McpResponse } from "./types.js";
 
 // List available resources
-export async function listResources(client: Client): Promise<McpResponse> {
+export async function listResources(
+  client: Client,
+  metaData?: Record<string, string>,
+): Promise<McpResponse> {
   try {
-    const response = await client.listResources();
+    const params =
+      metaData && Object.keys(metaData).length > 0 ? { _meta: metaData } : {};
+    const response = await client.listResources(params);
     return response;
   } catch (error) {
     throw new Error(
@@ -17,9 +22,14 @@ export async function listResources(client: Client): Promise<McpResponse> {
 export async function readResource(
   client: Client,
   uri: string,
+  metaData?: Record<string, string>,
 ): Promise<McpResponse> {
   try {
-    const response = await client.readResource({ uri });
+    const params: any = { uri };
+    if (metaData && Object.keys(metaData).length > 0) {
+      params._meta = metaData;
+    }
+    const response = await client.readResource(params);
     return response;
   } catch (error) {
     throw new Error(
@@ -31,9 +41,12 @@ export async function readResource(
 // List resource templates
 export async function listResourceTemplates(
   client: Client,
+  metaData?: Record<string, string>,
 ): Promise<McpResponse> {
   try {
-    const response = await client.listResourceTemplates();
+    const params =
+      metaData && Object.keys(metaData).length > 0 ? { _meta: metaData } : {};
+    const response = await client.listResourceTemplates(params);
     return response;
   } catch (error) {
     throw new Error(
diff --git a/cli/src/client/tools.ts b/cli/src/client/tools.ts
index 9da0b4d9f..df2634a7e 100644
--- a/cli/src/client/tools.ts
+++ b/cli/src/client/tools.ts
@@ -19,9 +19,14 @@ type JsonSchemaType = {
   items?: JsonSchemaType;
 };
 
-export async function listTools(client: Client): Promise<McpResponse> {
+export async function listTools(
+  client: Client,
+  metaData?: Record<string, string>,
+): Promise<McpResponse> {
   try {
-    const response = await client.listTools();
+    const params =
+      metaData && Object.keys(metaData).length > 0 ? { _meta: metaData } : {};
+    const response = await client.listTools(params);
     return response;
   } catch (error) {
     throw new Error(
@@ -82,9 +87,11 @@ export async function callTool(
   client: Client,
   name: string,
   args: Record<string, JsonValue>,
+  generalMetaData?: Record<string, string>,
+  toolSpecificMetaData?: Record<string, string>,
 ): Promise<McpResponse> {
   try {
-    const toolsResponse = await listTools(client);
+    const toolsResponse = await listTools(client, generalMetaData);
     const tools = toolsResponse.tools as Tool[];
     const tool = tools.find((t) => t.name === name);
 
@@ -106,9 +113,23 @@ export async function callTool(
       }
     }
 
+    // Merge general metadata with tool-specific metadata
+    // Tool-specific metadata takes precedence over general metadata
+    let mergedMeta: Record<string, string> | undefined;
+    if (generalMetaData || toolSpecificMetaData) {
+      mergedMeta = {
+        ...(generalMetaData || {}),
+        ...(toolSpecificMetaData || {}),
+      };
+    }
+
     const response = await client.callTool({
       name: name,
       arguments: convertedArgs,
+      _meta:
+        mergedMeta && Object.keys(mergedMeta).length > 0
+          ? mergedMeta
+          : undefined,
     });
     return response;
   } catch (error) {
diff --git a/cli/src/index.ts b/cli/src/index.ts
index a7c5896d7..e9f60ebdc 100644
--- a/cli/src/index.ts
+++ b/cli/src/index.ts
@@ -42,8 +42,10 @@ type Args = {
   logLevel?: LogLevel;
   toolName?: string;
   toolArg?: Record<string, JsonValue>;
+  toolMeta?: Record<string, string>;
   transport?: "sse" | "stdio" | "http";
   headers?: Record<string, string>;
+  metaData?: Record<string, string>;
 };
 
 function createTransportOptions(
@@ -121,7 +123,7 @@ async function callMethod(args: Args): Promise<void> {
 
     // Tools methods
     if (args.method === "tools/list") {
-      result = await listTools(client);
+      result = await listTools(client, args.metaData);
     } else if (args.method === "tools/call") {
       if (!args.toolName) {
         throw new Error(
@@ -129,11 +131,17 @@ async function callMethod(args: Args): Promise<void> {
         );
       }
 
-      result = await callTool(client, args.toolName, args.toolArg || {});
+      result = await callTool(
+        client,
+        args.toolName,
+        args.toolArg || {},
+        args.metaData,
+        args.toolMeta,
+      );
     }
     // Resources methods
     else if (args.method === "resources/list") {
-      result = await listResources(client);
+      result = await listResources(client, args.metaData);
     } else if (args.method === "resources/read") {
       if (!args.uri) {
         throw new Error(
@@ -141,13 +149,13 @@ async function callMethod(args: Args): Promise<void> {
         );
       }
 
-      result = await readResource(client, args.uri);
+      result = await readResource(client, args.uri, args.metaData);
     } else if (args.method === "resources/templates/list") {
-      result = await listResourceTemplates(client);
+      result = await listResourceTemplates(client, args.metaData);
     }
     // Prompts methods
     else if (args.method === "prompts/list") {
-      result = await listPrompts(client);
+      result = await listPrompts(client, args.metaData);
     } else if (args.method === "prompts/get") {
       if (!args.promptName) {
         throw new Error(
@@ -155,7 +163,12 @@ async function callMethod(args: Args): Promise<void> {
         );
       }
 
-      result = await getPrompt(client, args.promptName, args.promptArgs || {});
+      result = await getPrompt(
+        client,
+        args.promptName,
+        args.promptArgs || {},
+        args.metaData,
+      );
     }
     // Logging methods
     else if (args.method === "logging/setLevel") {
@@ -327,6 +340,8 @@ function parseArgs(): Args {
 
   const options = program.opts() as Omit<Args, "target"> & {
     header?: Record<string, string>;
+    meta?: Record<string, JsonValue>;
+    toolMeta?: Record<string, JsonValue>;
   };
 
   let remainingArgs = program.args;
@@ -344,6 +359,22 @@ function parseArgs(): Args {
     target: finalArgs,
     ...options,
     headers: options.header, // commander.js uses 'header' field, map to 'headers'
+    metaData: options.meta
+      ? Object.fromEntries(
+          Object.entries(options.meta).map(([key, value]) => [
+            key,
+            String(value),
+          ]),
+        )
+      : undefined,
+    toolMeta: options.toolMeta
+      ? Object.fromEntries(
+          Object.entries(options.toolMeta).map(([key, value]) => [
+            key,
+            String(value),
+          ]),
+        )
+      : undefined,
   };
 }
 
diff --git a/client/src/App.tsx b/client/src/App.tsx
index b7fc607b0..7f5314711 100644
--- a/client/src/App.tsx
+++ b/client/src/App.tsx
@@ -47,6 +47,7 @@ import {
   Hash,
   Key,
   MessageSquare,
+  Settings,
 } from "lucide-react";
 
 import { z } from "zod";
@@ -80,6 +81,7 @@ import {
   CustomHeaders,
   migrateFromLegacyAuth,
 } from "./lib/types/customHeaders";
+import MetaDataTab from "./components/MetaDataTab";
 
 const CONFIG_LOCAL_STORAGE_KEY = "inspectorConfig_v1";
 
@@ -195,9 +197,27 @@ const App = () => {
   const [authState, setAuthState] =
     useState<AuthDebuggerState>(EMPTY_DEBUGGER_STATE);
 
+  // Meta data state - persisted in localStorage
+  const [metaData, setMetaData] = useState<Record<string, string>>(() => {
+    const savedMetaData = localStorage.getItem("lastMetaData");
+    if (savedMetaData) {
+      try {
+        return JSON.parse(savedMetaData);
+      } catch (error) {
+        console.warn("Failed to parse saved meta data:", error);
+      }
+    }
+    return {};
+  });
+
   const updateAuthState = (updates: Partial<AuthDebuggerState>) => {
     setAuthState((prev) => ({ ...prev, ...updates }));
   };
+
+  const handleMetaDataChange = (newMetaData: Record<string, string>) => {
+    setMetaData(newMetaData);
+    localStorage.setItem("lastMetaData", JSON.stringify(newMetaData));
+  };
   const nextRequestId = useRef(0);
   const rootsRef = useRef<Root[]>([]);
 
@@ -299,6 +319,7 @@ const App = () => {
     },
     getRoots: () => rootsRef.current,
     defaultLoggingLevel: logLevel,
+    metaData,
   });
 
   useEffect(() => {
@@ -775,7 +796,11 @@ const App = () => {
     cacheToolOutputSchemas(response.tools);
   };
 
-  const callTool = async (name: string, params: Record<string, unknown>) => {
+  const callTool = async (
+    name: string,
+    params: Record<string, unknown>,
+    meta?: Record<string, unknown>,
+  ) => {
     lastToolCallOriginTabRef.current = currentTabRef.current;
 
     try {
@@ -785,15 +810,21 @@ const App = () => {
         ? cleanParams(params, tool.inputSchema as JsonSchemaType)
         : params;
 
+      // Merge general metadata with tool-specific metadata
+      // Tool-specific metadata takes precedence over general metadata
+      const mergedMeta = {
+        ...metaData, // General metadata first
+        progressToken: progressTokenRef.current++,
+        ...(meta ?? {}), // Tool-specific metadata overrides
+      };
+
       const response = await sendMCPRequest(
         {
           method: "tools/call" as const,
           params: {
             name,
             arguments: cleanedParams,
-            _meta: {
-              progressToken: progressTokenRef.current++,
-            },
+            _meta: mergedMeta,
           },
         },
         CompatibilityCallToolResultSchema,
@@ -989,6 +1020,10 @@ const App = () => {
                   <Key className="w-4 h-4 mr-2" />
                   Auth
                 </TabsTrigger>
+                <TabsTrigger value="metadata">
+                  <Settings className="w-4 h-4 mr-2" />
+                  Meta Data
+                </TabsTrigger>
               </TabsList>
 
               <div className="w-full">
@@ -1099,10 +1134,14 @@ const App = () => {
                         setNextToolCursor(undefined);
                         cacheToolOutputSchemas([]);
                       }}
-                      callTool={async (name, params) => {
+                      callTool={async (
+                        name: string,
+                        params: Record<string, unknown>,
+                        meta?: Record<string, unknown>,
+                      ) => {
                         clearError("tools");
                         setToolResult(null);
-                        await callTool(name, params);
+                        await callTool(name, params, meta);
                       }}
                       selectedTool={selectedTool}
                       setSelectedTool={(tool) => {
@@ -1145,6 +1184,10 @@ const App = () => {
                       onRootsChange={handleRootsChange}
                     />
                     <AuthDebuggerWrapper />
+                    <MetaDataTab
+                      metaData={metaData}
+                      onMetaDataChange={handleMetaDataChange}
+                    />
                   </>
                 )}
               </div>
diff --git a/client/src/components/MetaDataTab.tsx b/client/src/components/MetaDataTab.tsx
new file mode 100644
index 000000000..c4cc6d214
--- /dev/null
+++ b/client/src/components/MetaDataTab.tsx
@@ -0,0 +1,121 @@
+import React, { useState } from "react";
+import { TabsContent } from "@/components/ui/tabs";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Trash2, Plus } from "lucide-react";
+
+interface MetaDataEntry {
+  key: string;
+  value: string;
+}
+
+interface MetaDataTabProps {
+  metaData: Record<string, string>;
+  onMetaDataChange: (metaData: Record<string, string>) => void;
+}
+
+const MetaDataTab: React.FC<MetaDataTabProps> = ({
+  metaData,
+  onMetaDataChange,
+}) => {
+  const [entries, setEntries] = useState<MetaDataEntry[]>(() => {
+    return Object.entries(metaData).map(([key, value]) => ({ key, value }));
+  });
+
+  const addEntry = () => {
+    setEntries([...entries, { key: "", value: "" }]);
+  };
+
+  const removeEntry = (index: number) => {
+    const newEntries = entries.filter((_, i) => i !== index);
+    setEntries(newEntries);
+    updateMetaData(newEntries);
+  };
+
+  const updateEntry = (
+    index: number,
+    field: "key" | "value",
+    value: string,
+  ) => {
+    const newEntries = [...entries];
+    newEntries[index][field] = value;
+    setEntries(newEntries);
+    updateMetaData(newEntries);
+  };
+
+  const updateMetaData = (newEntries: MetaDataEntry[]) => {
+    const metaDataObject: Record<string, string> = {};
+    newEntries.forEach(({ key, value }) => {
+      if (key.trim() && value.trim()) {
+        metaDataObject[key.trim()] = value.trim();
+      }
+    });
+    onMetaDataChange(metaDataObject);
+  };
+
+  return (
+    <TabsContent value="metadata">
+      <div className="space-y-4">
+        <div className="flex items-center justify-between">
+          <div>
+            <h3 className="text-lg font-semibold">Meta Data</h3>
+            <p className="text-sm text-gray-600 dark:text-gray-400">
+              Key-value pairs that will be included in all MCP requests
+            </p>
+          </div>
+          <Button onClick={addEntry} size="sm">
+            <Plus className="w-4 h-4 mr-2" />
+            Add Entry
+          </Button>
+        </div>
+
+        <div className="space-y-3">
+          {entries.map((entry, index) => (
+            <div key={index} className="flex items-center space-x-2">
+              <div className="flex-1">
+                <Label htmlFor={`key-${index}`} className="sr-only">
+                  Key
+                </Label>
+                <Input
+                  id={`key-${index}`}
+                  placeholder="Key"
+                  value={entry.key}
+                  onChange={(e) => updateEntry(index, "key", e.target.value)}
+                />
+              </div>
+              <div className="flex-1">
+                <Label htmlFor={`value-${index}`} className="sr-only">
+                  Value
+                </Label>
+                <Input
+                  id={`value-${index}`}
+                  placeholder="Value"
+                  value={entry.value}
+                  onChange={(e) => updateEntry(index, "value", e.target.value)}
+                />
+              </div>
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={() => removeEntry(index)}
+              >
+                <Trash2 className="w-4 h-4" />
+              </Button>
+            </div>
+          ))}
+        </div>
+
+        {entries.length === 0 && (
+          <div className="text-center py-8">
+            <p className="text-gray-500 dark:text-gray-400 mb-4">
+              No meta data entries. Click "Add Entry" to add key-value pairs.
+            </p>
+          </div>
+        )}
+      </div>
+    </TabsContent>
+  );
+};
+
+export default MetaDataTab;
diff --git a/client/src/components/ToolResults.tsx b/client/src/components/ToolResults.tsx
index 6479b5fbb..64798cd9d 100644
--- a/client/src/components/ToolResults.tsx
+++ b/client/src/components/ToolResults.tsx
@@ -156,7 +156,7 @@ const ToolResults = ({
         )}
         {structuredResult._meta && (
           <div className="mb-4">
-            <h5 className="font-semibold mb-2 text-sm">Meta:</h5>
+            <h5 className="font-semibold mb-2 text-sm">Meta Schema:</h5>
             <div className="bg-gray-50 dark:bg-gray-900 p-3 rounded-lg">
               <JsonView data={structuredResult._meta} />
             </div>
diff --git a/client/src/components/ToolsTab.tsx b/client/src/components/ToolsTab.tsx
index 0123296af..04d298e13 100644
--- a/client/src/components/ToolsTab.tsx
+++ b/client/src/components/ToolsTab.tsx
@@ -53,7 +53,11 @@ const ToolsTab = ({
   tools: Tool[];
   listTools: () => void;
   clearTools: () => void;
-  callTool: (name: string, params: Record<string, unknown>) => Promise<void>;
+  callTool: (
+    name: string,
+    params: Record<string, unknown>,
+    meta?: Record<string, unknown>,
+  ) => Promise<void>;
   selectedTool: Tool | null;
   setSelectedTool: (tool: Tool | null) => void;
   toolResult: CompatibilityCallToolResult | null;
@@ -66,6 +70,9 @@ const ToolsTab = ({
   const [isToolRunning, setIsToolRunning] = useState(false);
   const [isOutputSchemaExpanded, setIsOutputSchemaExpanded] = useState(false);
   const [isMetaExpanded, setIsMetaExpanded] = useState(false);
+  const [metaEntries, setMetaEntries] = useState<
+    { id: string; key: string; value: string }[]
+  >([]);
   const [hasValidationErrors, setHasValidationErrors] = useState(false);
   const formRefs = useRef<Record<string, DynamicJsonFormRef | null>>({});
   const { toast } = useToast();
@@ -297,6 +304,102 @@ const ToolsTab = ({
                     );
                   },
                 )}
+                <div className="pb-4">
+                  <div className="flex items-center justify-between mb-2">
+                    <h4 className="text-sm font-semibold">Meta:</h4>
+                    <Button
+                      size="sm"
+                      variant="outline"
+                      className="h-6 px-2"
+                      onClick={() =>
+                        setMetaEntries((prev) => [
+                          ...prev,
+                          {
+                            id:
+                              (
+                                globalThis as unknown as {
+                                  crypto?: { randomUUID?: () => string };
+                                }
+                              ).crypto?.randomUUID?.() ||
+                              Math.random().toString(36).slice(2),
+                            key: "",
+                            value: "",
+                          },
+                        ])
+                      }
+                    >
+                      Add Pair
+                    </Button>
+                  </div>
+                  {metaEntries.length === 0 ? (
+                    <p className="text-xs text-muted-foreground">
+                      No meta pairs.
+                    </p>
+                  ) : (
+                    <div className="space-y-2">
+                      {metaEntries.map((entry, index) => (
+                        <div
+                          key={entry.id}
+                          className="flex items-center gap-2 w-full"
+                        >
+                          <Label
+                            htmlFor={`meta-key-${entry.id}`}
+                            className="text-xs shrink-0"
+                          >
+                            Key
+                          </Label>
+                          <Input
+                            id={`meta-key-${entry.id}`}
+                            value={entry.key}
+                            placeholder="e.g. requestId"
+                            onChange={(e) => {
+                              const value = e.target.value;
+                              setMetaEntries((prev) =>
+                                prev.map((m, i) =>
+                                  i === index ? { ...m, key: value } : m,
+                                ),
+                              );
+                            }}
+                            className="h-8 flex-1"
+                          />
+                          <Label
+                            htmlFor={`meta-value-${entry.id}`}
+                            className="text-xs shrink-0"
+                          >
+                            Value
+                          </Label>
+                          <Input
+                            id={`meta-value-${entry.id}`}
+                            value={entry.value}
+                            placeholder="e.g. 12345"
+                            onChange={(e) => {
+                              const value = e.target.value;
+                              setMetaEntries((prev) =>
+                                prev.map((m, i) =>
+                                  i === index ? { ...m, value } : m,
+                                ),
+                              );
+                            }}
+                            className="h-8 flex-1"
+                          />
+                          <Button
+                            size="sm"
+                            variant="ghost"
+                            className="h-8 w-8 p-0 ml-auto shrink-0"
+                            onClick={() =>
+                              setMetaEntries((prev) =>
+                                prev.filter((_, i) => i !== index),
+                              )
+                            }
+                            aria-label={`Remove meta pair ${index + 1}`}
+                          >
+                            -
+                          </Button>
+                        </div>
+                      ))}
+                    </div>
+                  )}
+                </div>
                 {selectedTool.outputSchema && (
                   <div className="bg-gray-50 dark:bg-gray-900 p-3 rounded-lg">
                     <div className="flex items-center justify-between mb-2">
@@ -338,7 +441,7 @@ const ToolsTab = ({
                   selectedTool._meta && (
                     <div className="bg-gray-50 dark:bg-gray-900 p-3 rounded-lg">
                       <div className="flex items-center justify-between mb-2">
-                        <h4 className="text-sm font-semibold">Meta:</h4>
+                        <h4 className="text-sm font-semibold">Meta Schema:</h4>
                         <Button
                           size="sm"
                           variant="ghost"
@@ -367,33 +470,44 @@ const ToolsTab = ({
                       </div>
                     </div>
                   )}
-                <div className="flex gap-2">
-                  <Button
-                    onClick={async () => {
-                      // Validate JSON inputs before calling tool
-                      if (checkValidationErrors()) return;
+                <Button
+                  onClick={async () => {
+                    // Validate JSON inputs before calling tool
+                    if (checkValidationErrors()) return;
 
-                      try {
-                        setIsToolRunning(true);
-                        await callTool(selectedTool.name, params);
-                      } finally {
-                        setIsToolRunning(false);
-                      }
-                    }}
-                    disabled={isToolRunning || hasValidationErrors}
-                  >
-                    {isToolRunning ? (
-                      <>
-                        <Loader2 className="w-4 h-4 mr-2 animate-spin" />
-                        Running...
-                      </>
-                    ) : (
-                      <>
-                        <Send className="w-4 h-4 mr-2" />
-                        Run Tool
-                      </>
-                    )}
-                  </Button>
+                    try {
+                      setIsToolRunning(true);
+                      const meta = metaEntries.reduce<Record<string, unknown>>(
+                        (acc, { key, value }) => {
+                          if (key.trim() !== "") acc[key] = value;
+                          return acc;
+                        },
+                        {},
+                      );
+                      await callTool(
+                        selectedTool.name,
+                        params,
+                        Object.keys(meta).length ? meta : undefined,
+                      );
+                    } finally {
+                      setIsToolRunning(false);
+                    }
+                  }}
+                  disabled={isToolRunning || hasValidationErrors}
+                >
+                  {isToolRunning ? (
+                    <>
+                      <Loader2 className="w-4 h-4 mr-2 animate-spin" />
+                      Running...
+                    </>
+                  ) : (
+                    <>
+                      <Send className="w-4 h-4 mr-2" />
+                      Run Tool
+                    </>
+                  )}
+                </Button>
+                <div className="flex gap-2">
                   <Button
                     onClick={async () => {
                       try {
diff --git a/client/src/components/__tests__/MetaDataTab.test.tsx b/client/src/components/__tests__/MetaDataTab.test.tsx
new file mode 100644
index 000000000..e26d0b653
--- /dev/null
+++ b/client/src/components/__tests__/MetaDataTab.test.tsx
@@ -0,0 +1,558 @@
+import { render, screen, fireEvent } from "@testing-library/react";
+import "@testing-library/jest-dom";
+import MetaDataTab from "../MetaDataTab";
+import { Tabs } from "@/components/ui/tabs";
+
+describe("MetaDataTab", () => {
+  const defaultProps = {
+    metaData: {},
+    onMetaDataChange: jest.fn(),
+  };
+
+  const renderMetaDataTab = (props = {}) => {
+    return render(
+      <Tabs defaultValue="metadata">
+        <MetaDataTab {...defaultProps} {...props} />
+      </Tabs>,
+    );
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("Initial Rendering", () => {
+    it("should render the metadata tab with title and description", () => {
+      renderMetaDataTab();
+
+      expect(screen.getByText("Meta Data")).toBeInTheDocument();
+      expect(
+        screen.getByText(
+          "Key-value pairs that will be included in all MCP requests",
+        ),
+      ).toBeInTheDocument();
+    });
+
+    it("should render Add Entry button", () => {
+      renderMetaDataTab();
+
+      const addButton = screen.getByRole("button", { name: /add entry/i });
+      expect(addButton).toBeInTheDocument();
+    });
+
+    it("should show empty state message when no entries exist", () => {
+      renderMetaDataTab();
+
+      expect(
+        screen.getByText(
+          'No meta data entries. Click "Add Entry" to add key-value pairs.',
+        ),
+      ).toBeInTheDocument();
+    });
+
+    it("should not show empty state message when entries exist", () => {
+      renderMetaDataTab({
+        metaData: { key1: "value1" },
+      });
+
+      expect(
+        screen.queryByText(
+          'No meta data entries. Click "Add Entry" to add key-value pairs.',
+        ),
+      ).not.toBeInTheDocument();
+    });
+  });
+
+  describe("Initial Data Handling", () => {
+    it("should initialize with existing metadata", () => {
+      const initialMetaData = {
+        API_KEY: "test-key",
+        VERSION: "1.0.0",
+      };
+
+      renderMetaDataTab({ metaData: initialMetaData });
+
+      expect(screen.getByDisplayValue("API_KEY")).toBeInTheDocument();
+      expect(screen.getByDisplayValue("test-key")).toBeInTheDocument();
+      expect(screen.getByDisplayValue("VERSION")).toBeInTheDocument();
+      expect(screen.getByDisplayValue("1.0.0")).toBeInTheDocument();
+    });
+
+    it("should render multiple entries in correct order", () => {
+      const initialMetaData = {
+        FIRST: "first-value",
+        SECOND: "second-value",
+        THIRD: "third-value",
+      };
+
+      renderMetaDataTab({ metaData: initialMetaData });
+
+      const keyInputs = screen.getAllByPlaceholderText("Key");
+      const valueInputs = screen.getAllByPlaceholderText("Value");
+
+      expect(keyInputs).toHaveLength(3);
+      expect(valueInputs).toHaveLength(3);
+
+      // Check that entries are rendered in the order they appear in the object
+      const entries = Object.entries(initialMetaData);
+      entries.forEach(([key, value], index) => {
+        expect(keyInputs[index]).toHaveValue(key);
+        expect(valueInputs[index]).toHaveValue(value);
+      });
+    });
+  });
+
+  describe("Adding Entries", () => {
+    it("should add a new empty entry when Add Entry button is clicked", () => {
+      renderMetaDataTab();
+
+      const addButton = screen.getByRole("button", { name: /add entry/i });
+      fireEvent.click(addButton);
+
+      const keyInputs = screen.getAllByPlaceholderText("Key");
+      const valueInputs = screen.getAllByPlaceholderText("Value");
+
+      expect(keyInputs).toHaveLength(1);
+      expect(valueInputs).toHaveLength(1);
+      expect(keyInputs[0]).toHaveValue("");
+      expect(valueInputs[0]).toHaveValue("");
+    });
+
+    it("should add multiple entries when Add Entry button is clicked multiple times", () => {
+      renderMetaDataTab();
+
+      const addButton = screen.getByRole("button", { name: /add entry/i });
+
+      fireEvent.click(addButton);
+      fireEvent.click(addButton);
+      fireEvent.click(addButton);
+
+      const keyInputs = screen.getAllByPlaceholderText("Key");
+      const valueInputs = screen.getAllByPlaceholderText("Value");
+
+      expect(keyInputs).toHaveLength(3);
+      expect(valueInputs).toHaveLength(3);
+    });
+
+    it("should hide empty state message after adding first entry", () => {
+      renderMetaDataTab();
+
+      expect(
+        screen.getByText(
+          'No meta data entries. Click "Add Entry" to add key-value pairs.',
+        ),
+      ).toBeInTheDocument();
+
+      const addButton = screen.getByRole("button", { name: /add entry/i });
+      fireEvent.click(addButton);
+
+      expect(
+        screen.queryByText(
+          'No meta data entries. Click "Add Entry" to add key-value pairs.',
+        ),
+      ).not.toBeInTheDocument();
+    });
+  });
+
+  describe("Removing Entries", () => {
+    it("should render remove button for each entry", () => {
+      renderMetaDataTab({
+        metaData: { key1: "value1", key2: "value2" },
+      });
+
+      const removeButtons = screen.getAllByRole("button", { name: "" }); // Trash icon buttons have no text
+      expect(removeButtons).toHaveLength(2);
+    });
+
+    it("should remove entry when remove button is clicked", () => {
+      const onMetaDataChange = jest.fn();
+      renderMetaDataTab({
+        metaData: { key1: "value1", key2: "value2" },
+        onMetaDataChange,
+      });
+
+      const removeButtons = screen.getAllByRole("button", { name: "" });
+      fireEvent.click(removeButtons[0]);
+
+      expect(onMetaDataChange).toHaveBeenCalledWith({ key2: "value2" });
+    });
+
+    it("should remove correct entry when multiple entries exist", () => {
+      const onMetaDataChange = jest.fn();
+      renderMetaDataTab({
+        metaData: {
+          FIRST: "first-value",
+          SECOND: "second-value",
+          THIRD: "third-value",
+        },
+        onMetaDataChange,
+      });
+
+      const removeButtons = screen.getAllByRole("button", { name: "" });
+      fireEvent.click(removeButtons[1]); // Remove second entry
+
+      expect(onMetaDataChange).toHaveBeenCalledWith({
+        FIRST: "first-value",
+        THIRD: "third-value",
+      });
+    });
+
+    it("should show empty state message after removing all entries", () => {
+      const onMetaDataChange = jest.fn();
+      renderMetaDataTab({
+        metaData: { key1: "value1" },
+        onMetaDataChange,
+      });
+
+      const removeButton = screen.getByRole("button", { name: "" });
+      fireEvent.click(removeButton);
+
+      expect(onMetaDataChange).toHaveBeenCalledWith({});
+    });
+  });
+
+  describe("Editing Entries", () => {
+    it("should update key when key input is changed", () => {
+      const onMetaDataChange = jest.fn();
+      renderMetaDataTab({
+        metaData: { oldKey: "value1" },
+        onMetaDataChange,
+      });
+
+      const keyInput = screen.getByDisplayValue("oldKey");
+      fireEvent.change(keyInput, { target: { value: "newKey" } });
+
+      expect(onMetaDataChange).toHaveBeenCalledWith({ newKey: "value1" });
+    });
+
+    it("should update value when value input is changed", () => {
+      const onMetaDataChange = jest.fn();
+      renderMetaDataTab({
+        metaData: { key1: "oldValue" },
+        onMetaDataChange,
+      });
+
+      const valueInput = screen.getByDisplayValue("oldValue");
+      fireEvent.change(valueInput, { target: { value: "newValue" } });
+
+      expect(onMetaDataChange).toHaveBeenCalledWith({ key1: "newValue" });
+    });
+
+    it("should handle editing multiple entries independently", () => {
+      const onMetaDataChange = jest.fn();
+      renderMetaDataTab({
+        metaData: {
+          key1: "value1",
+          key2: "value2",
+        },
+        onMetaDataChange,
+      });
+
+      const keyInputs = screen.getAllByPlaceholderText("Key");
+      const valueInputs = screen.getAllByPlaceholderText("Value");
+
+      // Edit first entry key
+      fireEvent.change(keyInputs[0], { target: { value: "newKey1" } });
+      expect(onMetaDataChange).toHaveBeenCalledWith({
+        newKey1: "value1",
+        key2: "value2",
+      });
+
+      // Clear mock to test second edit independently
+      onMetaDataChange.mockClear();
+
+      // Edit second entry value
+      fireEvent.change(valueInputs[1], { target: { value: "newValue2" } });
+      expect(onMetaDataChange).toHaveBeenCalledWith({
+        newKey1: "value1",
+        key2: "newValue2",
+      });
+    });
+  });
+
+  describe("Data Validation and Trimming", () => {
+    it("should trim whitespace from keys and values", () => {
+      const onMetaDataChange = jest.fn();
+      renderMetaDataTab({ onMetaDataChange });
+
+      const addButton = screen.getByRole("button", { name: /add entry/i });
+      fireEvent.click(addButton);
+
+      const keyInput = screen.getByPlaceholderText("Key");
+      const valueInput = screen.getByPlaceholderText("Value");
+
+      fireEvent.change(keyInput, { target: { value: "  trimmedKey  " } });
+      fireEvent.change(valueInput, { target: { value: "  trimmedValue  " } });
+
+      expect(onMetaDataChange).toHaveBeenCalledWith({
+        trimmedKey: "trimmedValue",
+      });
+    });
+
+    it("should exclude entries with empty keys or values after trimming", () => {
+      const onMetaDataChange = jest.fn();
+      renderMetaDataTab({ onMetaDataChange });
+
+      const addButton = screen.getByRole("button", { name: /add entry/i });
+      fireEvent.click(addButton);
+      fireEvent.click(addButton);
+
+      const keyInputs = screen.getAllByPlaceholderText("Key");
+      const valueInputs = screen.getAllByPlaceholderText("Value");
+
+      // First entry: valid key and value
+      fireEvent.change(keyInputs[0], { target: { value: "validKey" } });
+      fireEvent.change(valueInputs[0], { target: { value: "validValue" } });
+
+      // Second entry: empty key (should be excluded)
+      fireEvent.change(keyInputs[1], { target: { value: "" } });
+      fireEvent.change(valueInputs[1], { target: { value: "someValue" } });
+
+      expect(onMetaDataChange).toHaveBeenCalledWith({
+        validKey: "validValue",
+      });
+    });
+
+    it("should exclude entries with whitespace-only keys or values", () => {
+      const onMetaDataChange = jest.fn();
+      renderMetaDataTab({ onMetaDataChange });
+
+      const addButton = screen.getByRole("button", { name: /add entry/i });
+      fireEvent.click(addButton);
+      fireEvent.click(addButton);
+
+      const keyInputs = screen.getAllByPlaceholderText("Key");
+      const valueInputs = screen.getAllByPlaceholderText("Value");
+
+      // First entry: valid key and value
+      fireEvent.change(keyInputs[0], { target: { value: "validKey" } });
+      fireEvent.change(valueInputs[0], { target: { value: "validValue" } });
+
+      // Second entry: whitespace-only key (should be excluded)
+      fireEvent.change(keyInputs[1], { target: { value: "   " } });
+      fireEvent.change(valueInputs[1], { target: { value: "someValue" } });
+
+      expect(onMetaDataChange).toHaveBeenCalledWith({
+        validKey: "validValue",
+      });
+    });
+
+    it("should handle mixed valid and invalid entries", () => {
+      const onMetaDataChange = jest.fn();
+      renderMetaDataTab({ onMetaDataChange });
+
+      const addButton = screen.getByRole("button", { name: /add entry/i });
+      fireEvent.click(addButton);
+      fireEvent.click(addButton);
+      fireEvent.click(addButton);
+
+      const keyInputs = screen.getAllByPlaceholderText("Key");
+      const valueInputs = screen.getAllByPlaceholderText("Value");
+
+      // First entry: valid
+      fireEvent.change(keyInputs[0], { target: { value: "key1" } });
+      fireEvent.change(valueInputs[0], { target: { value: "value1" } });
+
+      // Second entry: empty key (invalid)
+      fireEvent.change(keyInputs[1], { target: { value: "" } });
+      fireEvent.change(valueInputs[1], { target: { value: "value2" } });
+
+      // Third entry: valid
+      fireEvent.change(keyInputs[2], { target: { value: "key3" } });
+      fireEvent.change(valueInputs[2], { target: { value: "value3" } });
+
+      expect(onMetaDataChange).toHaveBeenCalledWith({
+        key1: "value1",
+        key3: "value3",
+      });
+    });
+  });
+
+  describe("Input Accessibility", () => {
+    it("should have proper labels for screen readers", () => {
+      renderMetaDataTab({
+        metaData: { key1: "value1" },
+      });
+
+      const keyLabel = screen.getByLabelText("Key", { selector: "input" });
+      const valueLabel = screen.getByLabelText("Value", { selector: "input" });
+
+      expect(keyLabel).toBeInTheDocument();
+      expect(valueLabel).toBeInTheDocument();
+    });
+
+    it("should have unique IDs for each input pair", () => {
+      renderMetaDataTab({
+        metaData: {
+          key1: "value1",
+          key2: "value2",
+        },
+      });
+
+      const keyInputs = screen.getAllByPlaceholderText("Key");
+      const valueInputs = screen.getAllByPlaceholderText("Value");
+
+      expect(keyInputs[0]).toHaveAttribute("id", "key-0");
+      expect(keyInputs[1]).toHaveAttribute("id", "key-1");
+      expect(valueInputs[0]).toHaveAttribute("id", "value-0");
+      expect(valueInputs[1]).toHaveAttribute("id", "value-1");
+    });
+
+    it("should have proper placeholder text", () => {
+      renderMetaDataTab();
+
+      const addButton = screen.getByRole("button", { name: /add entry/i });
+      fireEvent.click(addButton);
+
+      const keyInput = screen.getByPlaceholderText("Key");
+      const valueInput = screen.getByPlaceholderText("Value");
+
+      expect(keyInput).toHaveAttribute("placeholder", "Key");
+      expect(valueInput).toHaveAttribute("placeholder", "Value");
+    });
+  });
+
+  describe("Edge Cases", () => {
+    it("should handle special characters in keys and values", () => {
+      const onMetaDataChange = jest.fn();
+      renderMetaDataTab({ onMetaDataChange });
+
+      const addButton = screen.getByRole("button", { name: /add entry/i });
+      fireEvent.click(addButton);
+
+      const keyInput = screen.getByPlaceholderText("Key");
+      const valueInput = screen.getByPlaceholderText("Value");
+
+      fireEvent.change(keyInput, {
+        target: { value: "key-with-special@chars!" },
+      });
+      fireEvent.change(valueInput, {
+        target: { value: "value with spaces & symbols $%^" },
+      });
+
+      expect(onMetaDataChange).toHaveBeenCalledWith({
+        "key-with-special@chars!": "value with spaces & symbols $%^",
+      });
+    });
+
+    it("should handle unicode characters", () => {
+      const onMetaDataChange = jest.fn();
+      renderMetaDataTab({ onMetaDataChange });
+
+      const addButton = screen.getByRole("button", { name: /add entry/i });
+      fireEvent.click(addButton);
+
+      const keyInput = screen.getByPlaceholderText("Key");
+      const valueInput = screen.getByPlaceholderText("Value");
+
+      fireEvent.change(keyInput, { target: { value: "🔑_key" } });
+      fireEvent.change(valueInput, { target: { value: "值_value_🎯" } });
+
+      expect(onMetaDataChange).toHaveBeenCalledWith({
+        "🔑_key": "值_value_🎯",
+      });
+    });
+
+    it("should handle very long keys and values", () => {
+      const onMetaDataChange = jest.fn();
+      renderMetaDataTab({ onMetaDataChange });
+
+      const addButton = screen.getByRole("button", { name: /add entry/i });
+      fireEvent.click(addButton);
+
+      const keyInput = screen.getByPlaceholderText("Key");
+      const valueInput = screen.getByPlaceholderText("Value");
+
+      const longKey = "A".repeat(100);
+      const longValue = "B".repeat(500);
+
+      fireEvent.change(keyInput, { target: { value: longKey } });
+      fireEvent.change(valueInput, { target: { value: longValue } });
+
+      expect(onMetaDataChange).toHaveBeenCalledWith({
+        [longKey]: longValue,
+      });
+    });
+
+    it("should handle duplicate keys by keeping the last one", () => {
+      const onMetaDataChange = jest.fn();
+      renderMetaDataTab({ onMetaDataChange });
+
+      const addButton = screen.getByRole("button", { name: /add entry/i });
+      fireEvent.click(addButton);
+      fireEvent.click(addButton);
+
+      const keyInputs = screen.getAllByPlaceholderText("Key");
+      const valueInputs = screen.getAllByPlaceholderText("Value");
+
+      // Set same key for both entries
+      fireEvent.change(keyInputs[0], { target: { value: "duplicateKey" } });
+      fireEvent.change(valueInputs[0], { target: { value: "firstValue" } });
+
+      fireEvent.change(keyInputs[1], { target: { value: "duplicateKey" } });
+      fireEvent.change(valueInputs[1], { target: { value: "secondValue" } });
+
+      // The second value should overwrite the first
+      expect(onMetaDataChange).toHaveBeenCalledWith({
+        duplicateKey: "secondValue",
+      });
+    });
+  });
+
+  describe("Integration with Parent Component", () => {
+    it("should not call onMetaDataChange when component mounts with existing data", () => {
+      const onMetaDataChange = jest.fn();
+      renderMetaDataTab({
+        metaData: { key1: "value1" },
+        onMetaDataChange,
+      });
+
+      expect(onMetaDataChange).not.toHaveBeenCalled();
+    });
+
+    it("should call onMetaDataChange only when user makes changes", () => {
+      const onMetaDataChange = jest.fn();
+      renderMetaDataTab({
+        metaData: { key1: "value1" },
+        onMetaDataChange,
+      });
+
+      // Should not be called on mount
+      expect(onMetaDataChange).not.toHaveBeenCalled();
+
+      // Should be called when user changes value
+      const valueInput = screen.getByDisplayValue("value1");
+      fireEvent.change(valueInput, { target: { value: "newValue" } });
+
+      expect(onMetaDataChange).toHaveBeenCalledTimes(1);
+      expect(onMetaDataChange).toHaveBeenCalledWith({ key1: "newValue" });
+    });
+
+    it("should maintain internal state when props change (component doesn't sync with prop changes)", () => {
+      const { rerender } = renderMetaDataTab({
+        metaData: { key1: "value1" },
+      });
+
+      expect(screen.getByDisplayValue("key1")).toBeInTheDocument();
+      expect(screen.getByDisplayValue("value1")).toBeInTheDocument();
+
+      // Rerender with different props - component should maintain its internal state
+      // This is the intended behavior since useState initializer only runs once
+      rerender(
+        <Tabs defaultValue="metadata">
+          <MetaDataTab
+            metaData={{ key2: "value2", key3: "value3" }}
+            onMetaDataChange={jest.fn()}
+          />
+        </Tabs>,
+      );
+
+      // The component should still show the original values since it maintains internal state
+      expect(screen.getByDisplayValue("key1")).toBeInTheDocument();
+      expect(screen.getByDisplayValue("value1")).toBeInTheDocument();
+      // The new prop values should not be displayed
+      expect(screen.queryByDisplayValue("key2")).not.toBeInTheDocument();
+      expect(screen.queryByDisplayValue("value2")).not.toBeInTheDocument();
+    });
+  });
+});
diff --git a/client/src/components/__tests__/ToolsTab.test.tsx b/client/src/components/__tests__/ToolsTab.test.tsx
index a50f62df3..7a76ce20a 100644
--- a/client/src/components/__tests__/ToolsTab.test.tsx
+++ b/client/src/components/__tests__/ToolsTab.test.tsx
@@ -109,9 +109,13 @@ describe("ToolsTab", () => {
       fireEvent.click(submitButton);
     });
 
-    expect(defaultProps.callTool).toHaveBeenCalledWith(mockTools[1].name, {
-      count: 42,
-    });
+    expect(defaultProps.callTool).toHaveBeenCalledWith(
+      mockTools[1].name,
+      {
+        count: 42,
+      },
+      undefined,
+    );
   });
 
   it("should allow typing negative numbers", async () => {
@@ -130,9 +134,13 @@ describe("ToolsTab", () => {
       fireEvent.click(submitButton);
     });
 
-    expect(defaultProps.callTool).toHaveBeenCalledWith(mockTools[0].name, {
-      num: -42,
-    });
+    expect(defaultProps.callTool).toHaveBeenCalledWith(
+      mockTools[0].name,
+      {
+        num: -42,
+      },
+      undefined,
+    );
   });
 
   it("should disable button and change text while tool is running", async () => {
@@ -580,20 +588,20 @@ describe("ToolsTab", () => {
         selectedTool: toolWithMeta,
       });
 
-      expect(screen.getByText("Meta:")).toBeInTheDocument();
+      expect(screen.getByText("Meta Schema:")).toBeInTheDocument();
       expect(
         screen.getByRole("button", { name: /expand/i }),
       ).toBeInTheDocument();
     });
 
-    it("should toggle meta expansion", () => {
+    it("should toggle meta schema expansion", () => {
       renderToolsTab({
         tools: [toolWithMeta],
         selectedTool: toolWithMeta,
       });
 
-      // There might be multiple Expand buttons (Output Schema, Meta). We need the one within Meta section
-      const metaHeading = screen.getByText("Meta:");
+      // There might be multiple Expand buttons (Output Schema, Meta Schema). We need the one within Meta Schema section
+      const metaHeading = screen.getByText("Meta Schema:");
       const metaContainer = metaHeading.closest("div");
       expect(metaContainer).toBeTruthy();
       const toggleButton = within(metaContainer as HTMLElement).getByRole(
@@ -619,7 +627,45 @@ describe("ToolsTab", () => {
     });
   });
 
-  describe("ToolResults Meta", () => {
+  describe("Meta submission", () => {
+    it("should send meta values when provided", async () => {
+      const callToolMock = jest.fn(async () => {});
+
+      renderToolsTab({ selectedTool: mockTools[0], callTool: callToolMock });
+
+      // Add a meta key/value pair
+      const addPairButton = screen.getByRole("button", { name: /add pair/i });
+      await act(async () => {
+        fireEvent.click(addPairButton);
+      });
+
+      // Fill key and value
+      const keyInputs = screen.getAllByLabelText(/key/i);
+      const valueInputs = screen.getAllByLabelText(/value/i);
+      expect(keyInputs.length).toBeGreaterThan(0);
+      expect(valueInputs.length).toBeGreaterThan(0);
+
+      await act(async () => {
+        fireEvent.change(keyInputs[0], { target: { value: "requestId" } });
+        fireEvent.change(valueInputs[0], { target: { value: "abc123" } });
+      });
+
+      // Run tool
+      const runButton = screen.getByRole("button", { name: /run tool/i });
+      await act(async () => {
+        fireEvent.click(runButton);
+      });
+
+      expect(callToolMock).toHaveBeenCalledTimes(1);
+      expect(callToolMock).toHaveBeenLastCalledWith(
+        mockTools[0].name,
+        expect.any(Object),
+        { requestId: "abc123" },
+      );
+    });
+  });
+
+  describe("ToolResults Meta Schema", () => {
     it("should display meta information when present in toolResult", () => {
       const resultWithMeta = {
         content: [],
@@ -632,7 +678,7 @@ describe("ToolsTab", () => {
       });
 
       // Only ToolResults meta should be present since selectedTool has no _meta
-      expect(screen.getAllByText("Meta:")).toHaveLength(1);
+      expect(screen.getAllByText("Meta Schema:")).toHaveLength(1);
       expect(screen.getByText(/info/i)).toBeInTheDocument();
       expect(screen.getByText(/version/i)).toBeInTheDocument();
     });
@@ -789,6 +835,7 @@ describe("ToolsTab", () => {
           message: "test message",
           count: 5,
         },
+        undefined,
       );
     });
 
diff --git a/client/src/lib/hooks/useConnection.ts b/client/src/lib/hooks/useConnection.ts
index 37073e9b7..7bb3d01c9 100644
--- a/client/src/lib/hooks/useConnection.ts
+++ b/client/src/lib/hooks/useConnection.ts
@@ -79,6 +79,7 @@ interface UseConnectionOptions {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   getRoots?: () => any[];
   defaultLoggingLevel?: LoggingLevel;
+  metaData?: Record<string, string>;
 }
 
 export function useConnection({
@@ -97,6 +98,7 @@ export function useConnection({
   onElicitationRequest,
   getRoots,
   defaultLoggingLevel,
+  metaData = {},
 }: UseConnectionOptions) {
   const [connectionStatus, setConnectionStatus] =
     useState<ConnectionStatus>("disconnected");
@@ -153,6 +155,20 @@ export function useConnection({
     try {
       const abortController = new AbortController();
 
+      // Add metadata to the request if available, but skip for tool calls
+      // as they handle metadata merging separately
+      const shouldAddGeneralMeta =
+        request.method !== "tools/call" && Object.keys(metaData).length > 0;
+      const requestWithMeta = shouldAddGeneralMeta
+        ? {
+            ...request,
+            params: {
+              ...request.params,
+              _meta: metaData,
+            },
+          }
+        : request;
+
       // prepare MCP Client request options
       const mcpRequestOptions: RequestOptions = {
         signal: options?.signal ?? abortController.signal,
@@ -181,13 +197,17 @@ export function useConnection({
 
       let response;
       try {
-        response = await mcpClient.request(request, schema, mcpRequestOptions);
+        response = await mcpClient.request(
+          requestWithMeta,
+          schema,
+          mcpRequestOptions,
+        );
 
-        pushHistory(request, response);
+        pushHistory(requestWithMeta, response);
       } catch (error) {
         const errorMessage =
           error instanceof Error ? error.message : String(error);
-        pushHistory(request, { error: errorMessage });
+        pushHistory(requestWithMeta, { error: errorMessage });
         throw error;
       }