public bool DeleteAgentCodeScripts(string agentId, List<string>? scriptNames)
     {
         if (string.IsNullOrWhiteSpace(agentId))
         {
             return false;
         }
 
-        var filterDef = Builders<AgentCodeDocument>.Filter.Empty;
+        var builder = Builders<AgentCodeDocument>.Filter;
+        var filterDef = builder.Eq(x => x.AgentId, agentId);
+
         if (scriptNames != null)
         {
-            var builder = Builders<AgentCodeDocument>.Filter;
-            var filters = new List<FilterDefinition<AgentCodeDocument>>
-            {
-                builder.In(x => x.Name, scriptNames)
-            };
-            filterDef = builder.And(filters);
+            var scriptFilter = builder.In(x => x.Name, scriptNames);
+            filterDef = builder.And(filterDef, scriptFilter);
         }
 
         var deleted = _dc.AgentCodes.DeleteMany(filterDef);
         return deleted.DeletedCount > 0;
     }

     var fileName = Path.GetFileName(file);
-    if (scriptNames != null || !scriptNames.Contains(fileName))
+    if (scriptNames != null && !scriptNames.Contains(fileName))
     {
         continue;
     }

     var result = stringIO.getvalue()?.ToString() as string;
     message.Content = result?.TrimEnd('\r', '\n') ?? string.Empty;
     message.RichContent = new RichContent<IRichMessage>
     {
         Recipient = new Recipient { Id = convService.ConversationId },
         Message = new ProgramCodeTemplateMessage
         {
             Text = ret.PythonCode ?? string.Empty,
             Language = "python"
         }
     };
     message.StopCompletion = true;
+  }
+  finally
+  {
+      using (Py.GIL())
+      {
+          // Restore the original stdout/stderr
+          dynamic sys = Py.Import("sys");
+          sys.stdout = sys.__stdout__;
+          sys.stderr = sys.__stderr__;
+      }
+  }
 
-    // Restore the original stdout/stderr
-    sys.stdout = sys.__stdout__;
-    sys.stderr = sys.__stderr__;
-

 public interface ICodeInterpretService
 {
     string Provider { get; }
-
-    Task<CodeInterpretResult> RunCode(string codeScript, CodeInterpretOptions? options = null)
-        => throw new NotImplementedException();
+    Task<CodeInterpretResult> RunCode(string codeScript, CodeInterpretOptions? options = null);
 }

     public bool DeleteAgentCodeScripts(string agentId, List<AgentCodeScript>? scripts = null)
     {
         if (string.IsNullOrWhiteSpace(agentId))
         {
             return false;
         }
+
+        var builder = Builders<AgentCodeScriptDocument>.Filter;
+        var agentFilter = builder.Eq(x => x.AgentId, agentId);
 
         DeleteResult deleted;
         if (scripts != null)
         {
             var scriptPaths = scripts.Select(x => x.CodePath);
             var exprFilter = new BsonDocument("$expr", new BsonDocument("$in", new BsonArray
             {
                 new BsonDocument("$concat", new BsonArray { "$ScriptType", "/", "$Name" }),
                 new BsonArray(scriptPaths)
             }));
 
             var filterDef = new BsonDocumentFilterDefinition<AgentCodeScriptDocument>(exprFilter);
-            deleted = _dc.AgentCodeScripts.DeleteMany(filterDef);
+            deleted = _dc.AgentCodeScripts.DeleteMany(builder.And(agentFilter, filterDef));
         }
         else
         {
-            deleted = _dc.AgentCodeScripts.DeleteMany(Builders<AgentCodeScriptDocument>.Filter.Empty);
+            deleted = _dc.AgentCodeScripts.DeleteMany(agentFilter);
         }
 
         return deleted.DeletedCount > 0;
     }

     public void BulkInsertAgentTasks(string agentId, List<AgentTask> tasks)
     {
-        
+        if (tasks.IsNullOrEmpty()) return;
+
+        foreach (var task in tasks)
+        {
+            InsertAgentTask(task);
+        }
     }

     public bool BulkInsertAgentCodeScripts(string agentId, List<AgentCodeScript> scripts)
     {
-        return UpdateAgentCodeScripts(agentId, scripts);
+        if (string.IsNullOrWhiteSpace(agentId) || scripts.IsNullOrEmpty())
+        {
+            return false;
+        }
+
+        foreach (var script in scripts)
+        {
+            if (string.IsNullOrWhiteSpace(script.Name) || string.IsNullOrWhiteSpace(script.ScriptType))
+            {
+                continue;
+            }
+
+            var dir = BuildAgentCodeScriptDir(agentId, script.ScriptType);
+            if (!Directory.Exists(dir))
+            {
+                Directory.CreateDirectory(dir);
+            }
+
+            var file = Path.Combine(dir, script.Name);
+            File.WriteAllText(file, script.Content);
+        }
+
+        return true;
     }

+    catch (PythonException pyEx)
+    {
+        var errorMsg = $"An error occurred while executing the Python code.";
+        using (Py.GIL())
+        {
+            dynamic traceback = Py.Import("traceback");
+            string pyTraceback = traceback.format_exc();
+            message.Content = $"{errorMsg}\n\nTraceback:\n{pyTraceback}";
+            _logger.LogError(pyEx, $"{errorMsg}\n{pyTraceback}");
+        }
+    }
     catch (Exception ex)
     {
         var errorMsg = $"Error when executing python code.";
         message.Content = $"{errorMsg} {ex.Message}";
         _logger.LogError(ex, errorMsg);
     }

     var codeProvider = codeOptions?.CodeInterpretProvider.IfNullOrEmptyAs("botsharp-py-interpreter");
     var codeInterpreter = _services.GetServices<ICodeInterpretService>()
                                    .FirstOrDefault(x => x.Provider.IsEqualTo(codeProvider));
     
     if (codeInterpreter == null)
     {
-#if DEBUG
         _logger.LogWarning($"No code interpreter found. (Agent: {agent.Id}, Code interpreter: {codeProvider})");
-#endif
         return response;
     }

 public async Task<CodeInterpretResult> RunCode(string codeScript, CodeInterpretOptions? options = null)
 {
+    if (string.IsNullOrWhiteSpace(codeScript))
+    {
+        return new CodeInterpretResult
+        {
+            Result = string.Empty,
+            Success = false,
+            ErrorMsg = "Empty code script."
+        };
+    }
+
     try
     {
         using (Py.GIL())
         {
-            ...
-            if (codeScript.Contains("__main__") == true)
+            dynamic sys = Py.Import("sys");
+            dynamic io = Py.Import("io");
+
+            dynamic stringIO = io.StringIO();
+            sys.stdout = stringIO;
+            sys.stderr = stringIO;
+
+            using var globals = new PyDict();
+            if (!string.IsNullOrEmpty(codeScript) && codeScript.Contains("__main__"))
             {
                 globals.SetItem("__name__", new PyString("__main__"));
             }
-            ...
+
+            var list = new PyList();
+            if (options?.Arguments?.Any() == true)
+            {
+                list.Append(new PyString("code.py"));
+                foreach (var arg in options.Arguments)
+                {
+                    if (!string.IsNullOrWhiteSpace(arg.Key) && !string.IsNullOrWhiteSpace(arg.Value))
+                    {
+                        list.Append(new PyString($"--{arg.Key}"));
+                        list.Append(new PyString($"{arg.Value}"));
+                    }
+                }
+            }
+            sys.argv = list;
+
             PythonEngine.Exec(codeScript, globals);
-            ...
+
+            var result = stringIO.getvalue()?.ToString() as string;
+
+            sys.stdout = sys.__stdout__;
+            sys.stderr = sys.__stderr__;
+            sys.argv = new PyList();
+
             return new CodeInterpretResult
             {
-                Result = result?.TrimEnd('\r', '\n'),
+                Result = (result ?? string.Empty).TrimEnd('\r', '\n'),
                 Success = true
             };
         }
     }
     catch (Exception ex)
     {
         var errorMsg = $"Error when executing python code in {nameof(PyInterpretService)}: {Provider}. {ex.Message}";
         _logger.LogError(ex, errorMsg);
 
         return new CodeInterpretResult
         {
+            Result = string.Empty,
             Success = false,
             ErrorMsg = errorMsg
         };
     }
 }