Merge branch 'master' into logback-mdc-logger

Author: ericdallo

CHANGELOG.md

@@ -2,8 +2,15 @@
 
 ## Unreleased
 
-- Use a JSON-RPC `ping` (instead of `initialize`) for the OAuth auth-discovery probe, so the probe POST is never counted as a real handshake by servers or tests that track requests by method name.
 - Replace custom stderr-print logger with Logback/SLF4J: timestamps, log levels, chat-id MDC context, third-party noise suppression (root at WARN, `eca` at INFO), and proper cross-thread context propagation in `future*`. #253
+
+## 0.134.2
+
+- Bugfix: OpenAI Responses tool calls now opt out of strict schema normalization so optional tool parameters remain optional.
+- Bugfix: MCP tool calls now route to the selected server when multiple servers expose the same tool name.
+- Use a JSON-RPC `ping` (instead of `initialize`) for the OAuth auth-discovery probe, so the probe POST is never counted as a real handshake by servers or tests that track requests by method name.
+- Guard subagent activity labels against overly long model-generated text.
+
 ## 0.134.1
 
 - Support optional `clientName` config field for MCP servers to override the OAuth Dynamic Client Registration `client_name` (useful for servers that allowlist clients by name, e.g. Figma).

docs/protocol.md

@@ -2667,6 +2667,25 @@ interface ServerResource {
 }
 ```
 
+### Tool server removed (⬅️)
+
+A server notification that an MCP server has been removed (via `mcp/removeServer`).
+Clients should drop the corresponding entry from any cached server list / UI.
+
+_Notification:_
+
+* method: `tool/serverRemoved`
+* params: `ToolServerRemovedParams` defined as follows:
+
+```typescript
+interface ToolServerRemovedParams {
+    /**
+     * The MCP server name that was removed.
+     */
+    name: string;
+}
+```
+
 ### Stop MCP server (➡️)
 
 A client notification for server to stop a MCP server, stopping the process.
@@ -2817,6 +2836,158 @@ _Response:_
 
 * result: `{}`
 
+### Add MCP Server (↩️)
+
+Adds a new MCP server definition at runtime, persists it to the chosen config file
+(global or workspace-local), and starts the server asynchronously. On success the server
+also emits a follow-up `tool/serverUpdated` notification as the new server progresses
+through `starting` → `running` / `failed` / `requires-auth`. Clients should not
+optimistically add the row locally — they should rely on that broadcast.
+
+_Request:_
+
+* method: `mcp/addServer`
+* params: `MCPAddServerParams` defined as follows:
+
+```typescript
+interface MCPAddServerParams {
+    /**
+     * The MCP server name. Must be unique among already-configured servers.
+     */
+    name: string;
+
+    /**
+     * The command to run (stdio transport).
+     */
+    command?: string;
+
+    /**
+     * The command arguments (stdio transport).
+     */
+    args?: string[];
+
+    /**
+     * Environment variables for the spawned process (stdio transport).
+     */
+    env?: { [key: string]: string };
+
+    /**
+     * The URL (Streamable HTTP transport).
+     */
+    url?: string;
+
+    /**
+     * HTTP headers to send with each request (Streamable HTTP transport).
+     */
+    headers?: { [key: string]: string };
+
+    /**
+     * Pre-registered OAuth client id (Streamable HTTP transport).
+     */
+    clientId?: string;
+
+    /**
+     * Pre-registered OAuth client secret (Streamable HTTP transport).
+     */
+    clientSecret?: string;
+
+    /**
+     * Local OAuth callback port (Streamable HTTP transport).
+     */
+    oauthPort?: number;
+
+    /**
+     * Whether the new server should be created in a disabled state.
+     */
+    disabled?: boolean;
+
+    /**
+     * Where to persist the new server entry. Defaults to "global"
+     * (`~/.config/eca/config.json`). Use "workspace" to persist to the
+     * workspace's `.eca/config.json` (requires `workspaceUri`).
+     */
+    scope?: 'global' | 'workspace';
+
+    /**
+     * Required when `scope = "workspace"`: identifies which workspace folder's
+     * `.eca/config.json` should receive the new entry.
+     */
+    workspaceUri?: string;
+}
+```
+
+_Response:_
+
+* result: `MCPAddServerResult` defined as follows:
+
+```typescript
+interface MCPAddServerResult {
+    /**
+     * The newly added server (canonical shape, identical to what
+     * `tool/serverUpdated` will subsequently broadcast). Present on success.
+     */
+    server?: MCPServerUpdatedParams;
+
+    /**
+     * Present when the add failed (e.g. duplicate name, invalid config,
+     * missing workspaceUri).
+     */
+    error?: {
+        code: string;
+        message: string;
+        data?: any;
+    };
+}
+```
+
+### Remove MCP Server (↩️)
+
+Removes an MCP server definition at runtime: stops the server if running, deletes the
+entry from the owning config file (global or workspace-local), clears any stored OAuth
+credentials, and emits a `tool/serverRemoved` notification so clients can drop the
+row from their UI.
+
+_Request:_
+
+* method: `mcp/removeServer`
+* params: `MCPRemoveServerParams` defined as follows:
+
+```typescript
+interface MCPRemoveServerParams {
+    /**
+     * The MCP server name.
+     */
+    name: string;
+}
+```
+
+_Response:_
+
+* result: `MCPRemoveServerResult` defined as follows:
+
+```typescript
+interface MCPRemoveServerResult {
+    /**
+     * The name of the removed server. Present on success.
+     */
+    name?: string;
+
+    /**
+     * `true` when the entry was removed from the config file. Present on success.
+     */
+    removed?: boolean;
+
+    /**
+     * Present when the remove failed (e.g. unknown name).
+     */
+    error?: {
+        code: string;
+        message: string;
+        data?: any;
+    };
+}
+```
+
 ## Provider Management
 
 ### List Providers (↩️)

resources/ECA_VERSION

@@ -1 +1 @@
-0.134.1
+0.134.2

src/eca/features/chat/tool_calls.clj

@@ -4,6 +4,7 @@
    [eca.features.chat.lifecycle :as lifecycle]
    [eca.features.hooks :as f.hooks]
    [eca.features.tools :as f.tools]
+   [eca.features.tools.agent :as f.tools.agent]
    [eca.features.tools.mcp :as f.tools.mcp]
    [eca.features.tools.util :as tools.util]
    [eca.llm-util :as llm-util]
@@ -665,18 +666,25 @@
                            :as resolved-tool}                            (f.tools/resolve-tool full-name all-tools)
                           full-name                                      (or (:full-name resolved-tool) full-name)
                           server-name                                    (:name server)
+                          spawn-agent?                                   (and (= :native origin)
+                                                                               (= "eca" server-name)
+                                                                               (= "spawn_agent" name))
+                          arguments                                      (if parameters
+                                                                           (tools.util/omit-optional-empty-string-args parameters (:arguments tool-call))
+                                                                           (:arguments tool-call))
                           tool-call                                      (assoc tool-call
                                                                                 :full-name full-name
-                                                                                :arguments (if parameters
-                                                                                             (tools.util/omit-optional-empty-string-args parameters (:arguments tool-call))
-                                                                                             (:arguments tool-call)))
+                                                                                :arguments (cond-> arguments
+                                                                                             spawn-agent? f.tools.agent/normalize-arguments))
                           decision-plan                                  (decide-tool-call-action
                                                                           tool-call all-tools @db* config agent chat-id
                                                                           {:on-before-hook-action (partial lifecycle/notify-before-hook-action! chat-ctx)
                                                                            :on-after-hook-action  (partial lifecycle/notify-after-hook-action! chat-ctx)
                                                                            :trust                 (get-in @db* [:chats chat-id :trust])})
-                          {:keys [decision arguments hook-rejected? reason hook-continue
+                          {:keys [decision hook-rejected? reason hook-continue
                                   hook-stop-reason arguments-modified?]} decision-plan
+                          arguments (cond-> (:arguments decision-plan)
+                                      spawn-agent? f.tools.agent/normalize-arguments)
                           _ (when arguments-modified?
                               (lifecycle/send-content! chat-ctx :system {:type :hookActionFinished
                                                                          :action-type "shell"

src/eca/features/tools.clj

@@ -256,10 +256,10 @@
                                                            :call-state-fn call-state-fn
                                                            :state-transition-fn state-transition-fn
                                                            :trust trust})
-                           (f.mcp/call-tool! tool-name arguments {:db db
-                                                                  :db* db*
-                                                                  :config config
-                                                                  :metrics metrics})))
+                           (f.mcp/call-tool! server-name tool-name arguments {:db db
+                                                                              :db* db*
+                                                                              :config config
+                                                                              :metrics metrics})))
                        (tools.util/maybe-truncate-output config tool-call-id))]
         (logger/debug logger-tag "Tool call result: " result)
         (metrics/count-up! "tool-called" {:name resolved-full-name :error (:error result)} metrics)

src/eca/features/tools/agent.clj

@@ -10,6 +10,20 @@
 (set! *warn-on-reflection* true)
 
 (def ^:private logger-tag "[AGENT-TOOL]")
+(def ^:private activity-summary-max-length 40)
+
+(defn normalize-arguments
+  "Normalize spawn_agent arguments before display, history, and invocation."
+  [arguments]
+  (let [activity (when (string? (get arguments "activity"))
+                   (-> (get arguments "activity")
+                       str/trim
+                       (str/replace #"\s+" " ")))]
+    (if (str/blank? activity)
+      (dissoc arguments "activity")
+      (assoc arguments "activity" (if (> (count activity) activity-summary-max-length)
+                                    (str (subs activity 0 activity-summary-max-length) "...")
+                                    activity)))))
 
 (defn ^:private all-agents
   [config]
@@ -64,7 +78,9 @@
               :name "spawn_agent"
               :server "eca"
               :origin "native"
-              :summary (format "%s: %s" agent-name activity)
+              :summary (if activity
+                         (format "%s: %s" agent-name activity)
+                         agent-name)
               :arguments arguments
               :details (cond-> {:type :subagent
                                 :subagent-chat-id subagent-chat-id
@@ -107,9 +123,10 @@
   "Handler for the spawn_agent tool.
    Spawns a subagent to perform a focused task and returns the result."
   [arguments {:keys [db* config messenger metrics chat-id tool-call-id call-state-fn trust]}]
-  (let [agent-name (get arguments "agent")
+  (let [arguments (normalize-arguments arguments)
+        agent-name (get arguments "agent")
         task (get arguments "task")
-        activity (get arguments "activity" "working")
+        activity (get arguments "activity")
         db @db*
 
         ;; Check for nesting - prevent subagents from spawning other subagents
@@ -267,12 +284,13 @@
                                            :description "Optional sub-agent model override. Reserved for explicit user override only. Omit unless the user explicitly named a model."}
                                "variant"  {:type        "string"
                                            :description "Optional sub-agent model variant override. Reserved for explicit user override only. Omit unless the user explicitly named a variant."}}
-                  :required   ["agent" "task" "activity"]}
+                  :required   ["agent" "task"]}
     :handler     #'spawn-agent
     :summary-fn  (fn [{:keys [args]}]
                    (if-let [agent-name (get args "agent")]
-                     (let [activity (get args "activity" "working")]
-                       (format "%s: %s" agent-name activity))
+                     (if-let [activity (get (normalize-arguments args) "activity")]
+                       (format "%s: %s" agent-name activity)
+                       agent-name)
                      "Spawning agent"))}})
 
 (defmethod tools.util/tool-call-details-before-invocation :spawn_agent

src/eca/features/tools/mcp.clj

@@ -897,13 +897,11 @@
     (do-call-tool new-client name arguments nil)
     (tool-call-error (format "Failed to re-initialize MCP server '%s'" server-name))))
 
-(defn call-tool! [name arguments {:keys [db db* config metrics]}]
-  (if-let [[server-name mcp-client needs-reinit?*]
-           (->> (:mcp-clients db)
-                (keep (fn [[sn {:keys [client tools needs-reinit?*]}]]
-                        (when (some #(= name (:name %)) tools)
-                          [sn client needs-reinit?*])))
-                first)]
+(defn call-tool! [server-name name arguments {:keys [db db* config metrics]}]
+  (if-let [[mcp-client needs-reinit?*]
+           (when-let [{:keys [client tools needs-reinit?*]} (get-in db [:mcp-clients server-name])]
+             (when (some #(= name (:name %)) tools)
+               [client needs-reinit?*]))]
     (if (and needs-reinit?* @needs-reinit?* db* config metrics)
       ;; Already flagged — reinit before attempting the call
       (reinit-and-call-tool! server-name mcp-client db* config metrics name arguments)
@@ -918,7 +916,7 @@
           (reinit-and-call-tool! server-name mcp-client db* config metrics name arguments)
 
           :else result)))
-    (tool-call-error (format "Tool '%s' not found in any connected MCP server" name))))
+    (tool-call-error (format "Tool '%s' not found in MCP server '%s'" name server-name))))
 
 (defn all-prompts [db]
   (into []

src/eca/features/tools/mcp/clojure_mcp.clj

@@ -9,7 +9,7 @@
   (when (not= "0.1.0" (:version server))
     (when ask-approval?
       (let [path (get args "file_path")
-            {:keys [error contents]} (f.mcp/call-tool! name (assoc args "dry_run" "new-source") {:db db})]
+            {:keys [error contents]} (f.mcp/call-tool! (:name server) name (assoc args "dry_run" "new-source") {:db db})]
         (when-not error
           (when-let [new-source (some->> contents (filter #(= :text (:type %))) first :text)]
             (let [{:keys [added removed diff]} (diff/diff (if new-file?

src/eca/llm_providers/openai.clj

@@ -183,7 +183,8 @@
            {:type "function"
             :name (:full-name tool)
             :description (:description tool)
-            :parameters (:parameters tool)})
+            :parameters (:parameters tool)
+            :strict false})
          tools)
     web-search (conj {:type "web_search"})
     image-generation (conj {:type "image_generation" :output_format "png"})))