@wingman-ai/gateway 0.2.3 → 0.2.4

package/dist/tests/agentInvokerSummarization.test.cjs

@@ -208,6 +208,16 @@ const parseConfig = (input)=>{
             toolName: "glob"
         });
     });
+    (0, external_vitest_namespaceObject.it)("extracts tool context for tool error events", ()=>{
+        const detected = (0, agentInvoker_cjs_namespaceObject.detectToolEventContext)({
+            event: "on_tool_error",
+            name: "grep"
+        });
+        (0, external_vitest_namespaceObject.expect)(detected).toEqual({
+            event: "on_tool_error",
+            toolName: "grep"
+        });
+    });
     (0, external_vitest_namespaceObject.it)("returns null for non-tool events", ()=>{
         const detected = (0, agentInvoker_cjs_namespaceObject.detectToolEventContext)({
             event: "on_chat_model_stream",
@@ -254,41 +264,190 @@ const parseConfig = (input)=>{
     });
 });
 (0, external_vitest_namespaceObject.describe)("selectStreamingFallbackText", ()=>{
-    (0, external_vitest_namespaceObject.it)("returns the most recent assistant message in the same invocation window", ()=>{
+    (0, external_vitest_namespaceObject.it)("returns assistant text introduced during the current invocation", ()=>{
         const selected = (0, agentInvoker_cjs_namespaceObject.selectStreamingFallbackText)([
             {
                 role: "assistant",
-                createdAt: 1000,
+                content: "stale message"
+            }
+        ], [
+            {
+                role: "assistant",
                 content: "stale message"
             },
             {
                 role: "assistant",
-                createdAt: 4500,
                 content: "fresh fallback"
             }
-        ], 4000);
+        ]);
         (0, external_vitest_namespaceObject.expect)(selected).toBe("fresh fallback");
     });
-    (0, external_vitest_namespaceObject.it)("ignores stale, user-role, and empty-content messages", ()=>{
+    (0, external_vitest_namespaceObject.it)("returns undefined when no new assistant text is introduced", ()=>{
         const selected = (0, agentInvoker_cjs_namespaceObject.selectStreamingFallbackText)([
             {
                 role: "assistant",
-                createdAt: 1000,
-                content: "too old"
-            },
+                content: "existing response"
+            }
+        ], [
             {
                 role: "user",
-                createdAt: 4900,
                 content: "not assistant"
             },
             {
                 role: "assistant",
-                createdAt: 5000,
-                content: "   "
+                content: "existing response"
             }
-        ], 5000);
+        ]);
         (0, external_vitest_namespaceObject.expect)(selected).toBeUndefined();
     });
+    (0, external_vitest_namespaceObject.it)("handles repeated assistant messages by count", ()=>{
+        const selected = (0, agentInvoker_cjs_namespaceObject.selectStreamingFallbackText)([
+            {
+                role: "assistant",
+                content: "repeat"
+            }
+        ], [
+            {
+                role: "assistant",
+                content: "repeat"
+            },
+            {
+                role: "assistant",
+                content: "repeat"
+            }
+        ]);
+        (0, external_vitest_namespaceObject.expect)(selected).toBe("repeat");
+    });
+});
+(0, external_vitest_namespaceObject.describe)("detectStreamErrorMessage", ()=>{
+    (0, external_vitest_namespaceObject.it)("extracts non-tool stream error messages", ()=>{
+        const detected = (0, agentInvoker_cjs_namespaceObject.detectStreamErrorMessage)({
+            event: "on_chat_model_error",
+            data: {
+                error: {
+                    message: "Model call failed after retries"
+                }
+            }
+        });
+        (0, external_vitest_namespaceObject.expect)(detected).toBe("Model call failed after retries");
+    });
+    (0, external_vitest_namespaceObject.it)("ignores tool errors and non-error events", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.detectStreamErrorMessage)({
+            event: "on_tool_error",
+            data: {
+                error: "tool failed"
+            }
+        })).toBeUndefined();
+        (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.detectStreamErrorMessage)({
+            event: "on_chat_model_stream",
+            data: {
+                chunk: {
+                    text: "hello"
+                }
+            }
+        })).toBeUndefined();
+    });
+});
+(0, external_vitest_namespaceObject.describe)("evaluateStreamingCompletion", ()=>{
+    (0, external_vitest_namespaceObject.it)("blocks with stream_error when no assistant text and stream error exists", ()=>{
+        const result = (0, agentInvoker_cjs_namespaceObject.evaluateStreamingCompletion)({
+            sawAssistantText: false,
+            fallbackText: void 0,
+            streamErrorMessage: "provider timeout"
+        });
+        (0, external_vitest_namespaceObject.expect)(result).toEqual({
+            status: "blocked",
+            reason: "stream_error",
+            message: "Model call failed: provider timeout"
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("blocks with empty_stream_response when no text or fallback is present", ()=>{
+        const result = (0, agentInvoker_cjs_namespaceObject.evaluateStreamingCompletion)({
+            sawAssistantText: false,
+            fallbackText: void 0,
+            streamErrorMessage: void 0
+        });
+        (0, external_vitest_namespaceObject.expect)(result).toEqual({
+            status: "blocked",
+            reason: "empty_stream_response",
+            message: "Model completed without a response. Check provider logs for request errors."
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("returns ok when assistant text exists", ()=>{
+        const result = (0, agentInvoker_cjs_namespaceObject.evaluateStreamingCompletion)({
+            sawAssistantText: true,
+            fallbackText: void 0,
+            streamErrorMessage: void 0
+        });
+        (0, external_vitest_namespaceObject.expect)(result).toEqual({
+            status: "ok"
+        });
+    });
+});
+(0, external_vitest_namespaceObject.describe)("LangGraph lifecycle termination", ()=>{
+    (0, external_vitest_namespaceObject.it)("tracks root LangGraph run id from parentless on_chain_start", ()=>{
+        const rootRunId = (0, agentInvoker_cjs_namespaceObject.trackRootLangGraphRunId)(void 0, {
+            event: "on_chain_start",
+            name: "LangGraph",
+            run_id: "root-run",
+            parent_ids: []
+        });
+        (0, external_vitest_namespaceObject.expect)(rootRunId).toBe("root-run");
+    });
+    (0, external_vitest_namespaceObject.it)("ignores non-root or non-LangGraph start events", ()=>{
+        const nestedRunId = (0, agentInvoker_cjs_namespaceObject.trackRootLangGraphRunId)(void 0, {
+            event: "on_chain_start",
+            name: "LangGraph",
+            run_id: "child-run",
+            parent_ids: [
+                "root-run"
+            ]
+        });
+        (0, external_vitest_namespaceObject.expect)(nestedRunId).toBeUndefined();
+        const otherChainRunId = (0, agentInvoker_cjs_namespaceObject.trackRootLangGraphRunId)(void 0, {
+            event: "on_chain_start",
+            name: "CustomChain",
+            run_id: "other-run",
+            parent_ids: []
+        });
+        (0, external_vitest_namespaceObject.expect)(otherChainRunId).toBeUndefined();
+    });
+    (0, external_vitest_namespaceObject.it)("detects terminal root LangGraph on_chain_end by run id", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.isRootLangGraphTerminalEvent)({
+            event: "on_chain_end",
+            name: "LangGraph",
+            run_id: "root-run",
+            parent_ids: []
+        }, "root-run")).toBe(true);
+    });
+    (0, external_vitest_namespaceObject.it)("does not treat nested, mismatched, or non-LangGraph chain end as terminal", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.isRootLangGraphTerminalEvent)({
+            event: "on_chain_end",
+            name: "LangGraph",
+            run_id: "child-run",
+            parent_ids: [
+                "root-run"
+            ]
+        }, "root-run")).toBe(false);
+        (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.isRootLangGraphTerminalEvent)({
+            event: "on_chain_end",
+            name: "LangGraph",
+            run_id: "other-run",
+            parent_ids: []
+        }, "root-run")).toBe(false);
+        (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.isRootLangGraphTerminalEvent)({
+            event: "on_chain_end",
+            name: "CustomChain",
+            run_id: "root-run",
+            parent_ids: []
+        }, "root-run")).toBe(false);
+        (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.isRootLangGraphTerminalEvent)({
+            event: "on_chain_end",
+            name: "LangGraph",
+            run_id: "root-run",
+            parent_ids: []
+        }, void 0)).toBe(false);
+    });
 });
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/tests/agentInvokerSummarization.test.js

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import { validateConfig } from "../cli/config/schema.js";
-import { chunkHasAssistantText, configureDeepAgentSummarizationMiddleware, detectToolEventContext, resolveHumanInTheLoopSettings, resolveModelRetryMiddlewareSettings, resolveSummarizationMiddlewareSettings, resolveToolRetryMiddlewareSettings, selectStreamingFallbackText } from "../cli/core/agentInvoker.js";
+import { chunkHasAssistantText, configureDeepAgentSummarizationMiddleware, detectStreamErrorMessage, detectToolEventContext, evaluateStreamingCompletion, isRootLangGraphTerminalEvent, resolveHumanInTheLoopSettings, resolveModelRetryMiddlewareSettings, resolveSummarizationMiddlewareSettings, resolveToolRetryMiddlewareSettings, selectStreamingFallbackText, trackRootLangGraphRunId } from "../cli/core/agentInvoker.js";
 const parseConfig = (input)=>{
     const result = validateConfig(input);
     if (!result.success || !result.data) throw new Error(result.error || "Expected config validation to succeed");
@@ -206,6 +206,16 @@ describe("detectToolEventContext", ()=>{
             toolName: "glob"
         });
     });
+    it("extracts tool context for tool error events", ()=>{
+        const detected = detectToolEventContext({
+            event: "on_tool_error",
+            name: "grep"
+        });
+        expect(detected).toEqual({
+            event: "on_tool_error",
+            toolName: "grep"
+        });
+    });
     it("returns null for non-tool events", ()=>{
         const detected = detectToolEventContext({
             event: "on_chat_model_stream",
@@ -252,39 +262,188 @@ describe("chunkHasAssistantText", ()=>{
     });
 });
 describe("selectStreamingFallbackText", ()=>{
-    it("returns the most recent assistant message in the same invocation window", ()=>{
+    it("returns assistant text introduced during the current invocation", ()=>{
         const selected = selectStreamingFallbackText([
             {
                 role: "assistant",
-                createdAt: 1000,
+                content: "stale message"
+            }
+        ], [
+            {
+                role: "assistant",
                 content: "stale message"
             },
             {
                 role: "assistant",
-                createdAt: 4500,
                 content: "fresh fallback"
             }
-        ], 4000);
+        ]);
         expect(selected).toBe("fresh fallback");
     });
-    it("ignores stale, user-role, and empty-content messages", ()=>{
+    it("returns undefined when no new assistant text is introduced", ()=>{
         const selected = selectStreamingFallbackText([
             {
                 role: "assistant",
-                createdAt: 1000,
-                content: "too old"
-            },
+                content: "existing response"
+            }
+        ], [
             {
                 role: "user",
-                createdAt: 4900,
                 content: "not assistant"
             },
             {
                 role: "assistant",
-                createdAt: 5000,
-                content: "   "
+                content: "existing response"
             }
-        ], 5000);
+        ]);
         expect(selected).toBeUndefined();
     });
+    it("handles repeated assistant messages by count", ()=>{
+        const selected = selectStreamingFallbackText([
+            {
+                role: "assistant",
+                content: "repeat"
+            }
+        ], [
+            {
+                role: "assistant",
+                content: "repeat"
+            },
+            {
+                role: "assistant",
+                content: "repeat"
+            }
+        ]);
+        expect(selected).toBe("repeat");
+    });
+});
+describe("detectStreamErrorMessage", ()=>{
+    it("extracts non-tool stream error messages", ()=>{
+        const detected = detectStreamErrorMessage({
+            event: "on_chat_model_error",
+            data: {
+                error: {
+                    message: "Model call failed after retries"
+                }
+            }
+        });
+        expect(detected).toBe("Model call failed after retries");
+    });
+    it("ignores tool errors and non-error events", ()=>{
+        expect(detectStreamErrorMessage({
+            event: "on_tool_error",
+            data: {
+                error: "tool failed"
+            }
+        })).toBeUndefined();
+        expect(detectStreamErrorMessage({
+            event: "on_chat_model_stream",
+            data: {
+                chunk: {
+                    text: "hello"
+                }
+            }
+        })).toBeUndefined();
+    });
+});
+describe("evaluateStreamingCompletion", ()=>{
+    it("blocks with stream_error when no assistant text and stream error exists", ()=>{
+        const result = evaluateStreamingCompletion({
+            sawAssistantText: false,
+            fallbackText: void 0,
+            streamErrorMessage: "provider timeout"
+        });
+        expect(result).toEqual({
+            status: "blocked",
+            reason: "stream_error",
+            message: "Model call failed: provider timeout"
+        });
+    });
+    it("blocks with empty_stream_response when no text or fallback is present", ()=>{
+        const result = evaluateStreamingCompletion({
+            sawAssistantText: false,
+            fallbackText: void 0,
+            streamErrorMessage: void 0
+        });
+        expect(result).toEqual({
+            status: "blocked",
+            reason: "empty_stream_response",
+            message: "Model completed without a response. Check provider logs for request errors."
+        });
+    });
+    it("returns ok when assistant text exists", ()=>{
+        const result = evaluateStreamingCompletion({
+            sawAssistantText: true,
+            fallbackText: void 0,
+            streamErrorMessage: void 0
+        });
+        expect(result).toEqual({
+            status: "ok"
+        });
+    });
+});
+describe("LangGraph lifecycle termination", ()=>{
+    it("tracks root LangGraph run id from parentless on_chain_start", ()=>{
+        const rootRunId = trackRootLangGraphRunId(void 0, {
+            event: "on_chain_start",
+            name: "LangGraph",
+            run_id: "root-run",
+            parent_ids: []
+        });
+        expect(rootRunId).toBe("root-run");
+    });
+    it("ignores non-root or non-LangGraph start events", ()=>{
+        const nestedRunId = trackRootLangGraphRunId(void 0, {
+            event: "on_chain_start",
+            name: "LangGraph",
+            run_id: "child-run",
+            parent_ids: [
+                "root-run"
+            ]
+        });
+        expect(nestedRunId).toBeUndefined();
+        const otherChainRunId = trackRootLangGraphRunId(void 0, {
+            event: "on_chain_start",
+            name: "CustomChain",
+            run_id: "other-run",
+            parent_ids: []
+        });
+        expect(otherChainRunId).toBeUndefined();
+    });
+    it("detects terminal root LangGraph on_chain_end by run id", ()=>{
+        expect(isRootLangGraphTerminalEvent({
+            event: "on_chain_end",
+            name: "LangGraph",
+            run_id: "root-run",
+            parent_ids: []
+        }, "root-run")).toBe(true);
+    });
+    it("does not treat nested, mismatched, or non-LangGraph chain end as terminal", ()=>{
+        expect(isRootLangGraphTerminalEvent({
+            event: "on_chain_end",
+            name: "LangGraph",
+            run_id: "child-run",
+            parent_ids: [
+                "root-run"
+            ]
+        }, "root-run")).toBe(false);
+        expect(isRootLangGraphTerminalEvent({
+            event: "on_chain_end",
+            name: "LangGraph",
+            run_id: "other-run",
+            parent_ids: []
+        }, "root-run")).toBe(false);
+        expect(isRootLangGraphTerminalEvent({
+            event: "on_chain_end",
+            name: "CustomChain",
+            run_id: "root-run",
+            parent_ids: []
+        }, "root-run")).toBe(false);
+        expect(isRootLangGraphTerminalEvent({
+            event: "on_chain_end",
+            name: "LangGraph",
+            run_id: "root-run",
+            parent_ids: []
+        }, void 0)).toBe(false);
+    });
 });

package/dist/tests/agents-api.test.cjs

@@ -1,11 +1,11 @@
 "use strict";
 var __webpack_exports__ = {};
-const external_vitest_namespaceObject = require("vitest");
-const agents_cjs_namespaceObject = require("../gateway/http/agents.cjs");
 const external_node_fs_namespaceObject = require("node:fs");
-const external_node_path_namespaceObject = require("node:path");
 const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
 const external_js_yaml_namespaceObject = require("js-yaml");
+const external_vitest_namespaceObject = require("vitest");
+const agents_cjs_namespaceObject = require("../gateway/http/agents.cjs");
 const isBunRuntime = void 0 !== globalThis.Bun;
 const describeIfBun = isBunRuntime ? external_vitest_namespaceObject.describe : external_vitest_namespaceObject.describe.skip;
 const parseMarkdownAgent = (raw)=>{
@@ -65,6 +65,7 @@ describeIfBun("agents API", ()=>{
                     "not_real_tool"
                 ],
                 prompt: "You are the orchestrator.",
+                reasoningEffort: "high",
                 promptTraining: {
                     enabled: true,
                     instructionsPath: "/memories/agents/orchestrator/instructions.md"
@@ -78,6 +79,7 @@ describeIfBun("agents API", ()=>{
                             "not_real_tool"
                         ],
                         prompt: "Plan tasks in detail.",
+                        reasoningEffort: "low",
                         promptTraining: true
                     },
                     {
@@ -86,7 +88,8 @@ describeIfBun("agents API", ()=>{
                         tools: [
                             "command_execute"
                         ],
-                        prompt: "Execute planned tasks."
+                        prompt: "Execute planned tasks.",
+                        thinkingEffort: "minimal"
                     }
                 ]
             })
@@ -99,12 +102,15 @@ describeIfBun("agents API", ()=>{
             enabled: true,
             instructionsPath: "/memories/agents/orchestrator/instructions.md"
         });
+        (0, external_vitest_namespaceObject.expect)(created.reasoningEffort).toBe("high");
         (0, external_vitest_namespaceObject.expect)(created.promptRefinement).toEqual(created.promptTraining);
         (0, external_vitest_namespaceObject.expect)(created.subAgents).toHaveLength(2);
         (0, external_vitest_namespaceObject.expect)(created.subAgents[0].promptTraining).toBe(true);
         (0, external_vitest_namespaceObject.expect)(created.subAgents[0].tools).toEqual([
             "think"
         ]);
+        (0, external_vitest_namespaceObject.expect)(created.subAgents[0].reasoningEffort).toBe("low");
+        (0, external_vitest_namespaceObject.expect)(created.subAgents[1].reasoningEffort).toBe("minimal");
         const agentPath = (0, external_node_path_namespaceObject.join)(tempDir, "agents", "orchestrator", "agent.md");
         const parsed = parseMarkdownAgent((0, external_node_fs_namespaceObject.readFileSync)(agentPath, "utf-8"));
         (0, external_vitest_namespaceObject.expect)(parsed.prompt).toBe("You are the orchestrator.");
@@ -112,10 +118,13 @@ describeIfBun("agents API", ()=>{
             enabled: true,
             instructionsPath: "/memories/agents/orchestrator/instructions.md"
         });
+        (0, external_vitest_namespaceObject.expect)(parsed.metadata.reasoningEffort).toBe("high");
         (0, external_vitest_namespaceObject.expect)(parsed.metadata.subAgents).toHaveLength(2);
         (0, external_vitest_namespaceObject.expect)(parsed.metadata.subAgents[0].name).toBe("planner");
+        (0, external_vitest_namespaceObject.expect)(parsed.metadata.subAgents[0].reasoningEffort).toBe("low");
         (0, external_vitest_namespaceObject.expect)(parsed.metadata.subAgents[0].promptRefinement).toBe(true);
         (0, external_vitest_namespaceObject.expect)(parsed.metadata.subAgents[0].systemPrompt).toBe("Plan tasks in detail.");
+        (0, external_vitest_namespaceObject.expect)(parsed.metadata.subAgents[1].reasoningEffort).toBe("minimal");
         const detailReq = new Request("http://localhost/api/agents/orchestrator", {
             method: "GET"
         });
@@ -125,9 +134,11 @@ describeIfBun("agents API", ()=>{
         const detail = await detailRes.json();
         (0, external_vitest_namespaceObject.expect)(detail.promptTraining).toEqual(created.promptTraining);
         (0, external_vitest_namespaceObject.expect)(detail.promptRefinement).toEqual(created.promptTraining);
+        (0, external_vitest_namespaceObject.expect)(detail.reasoningEffort).toBe("high");
         (0, external_vitest_namespaceObject.expect)(detail.subAgents).toHaveLength(2);
         (0, external_vitest_namespaceObject.expect)(detail.subAgents[0].id).toBe("planner");
         (0, external_vitest_namespaceObject.expect)(detail.subAgents[0].prompt).toBe("Plan tasks in detail.");
+        (0, external_vitest_namespaceObject.expect)(detail.subAgents[0].reasoningEffort).toBe("low");
     });
     (0, external_vitest_namespaceObject.it)("updates promptTraining and subAgents in markdown", async ()=>{
         const createReq = new Request("http://localhost/api/agents", {
@@ -141,6 +152,7 @@ describeIfBun("agents API", ()=>{
                     "think"
                 ],
                 prompt: "Original prompt",
+                reasoningEffort: "low",
                 promptTraining: true,
                 subAgents: [
                     {
@@ -149,7 +161,8 @@ describeIfBun("agents API", ()=>{
                         tools: [
                             "think"
                         ],
-                        prompt: "Original planner prompt"
+                        prompt: "Original planner prompt",
+                        reasoningEffort: "minimal"
                     }
                 ]
             })
@@ -162,6 +175,7 @@ describeIfBun("agents API", ()=>{
                 "Content-Type": "application/json"
             },
             body: JSON.stringify({
+                reasoningEffort: "high",
                 promptTraining: false,
                 subAgents: [
                     {
@@ -171,6 +185,7 @@ describeIfBun("agents API", ()=>{
                             "git_status"
                         ],
                         prompt: "Review carefully.",
+                        thinkingEffort: "medium",
                         promptTraining: {
                             enabled: true,
                             instructionsPath: "/memories/reviewer.md"
@@ -186,8 +201,10 @@ describeIfBun("agents API", ()=>{
         const updated = await updateRes.json();
         (0, external_vitest_namespaceObject.expect)(updated.promptTraining).toBe(false);
         (0, external_vitest_namespaceObject.expect)(updated.promptRefinement).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(updated.reasoningEffort).toBe("high");
         (0, external_vitest_namespaceObject.expect)(updated.subAgents).toHaveLength(1);
         (0, external_vitest_namespaceObject.expect)(updated.subAgents[0].id).toBe("reviewer");
+        (0, external_vitest_namespaceObject.expect)(updated.subAgents[0].reasoningEffort).toBe("medium");
         (0, external_vitest_namespaceObject.expect)(updated.subAgents[0].promptTraining).toEqual({
             enabled: true,
             instructionsPath: "/memories/reviewer.md"
@@ -195,8 +212,10 @@ describeIfBun("agents API", ()=>{
         const agentPath = (0, external_node_path_namespaceObject.join)(tempDir, "agents", "editor-agent", "agent.md");
         const parsed = parseMarkdownAgent((0, external_node_fs_namespaceObject.readFileSync)(agentPath, "utf-8"));
         (0, external_vitest_namespaceObject.expect)(parsed.metadata.promptRefinement).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(parsed.metadata.reasoningEffort).toBe("high");
         (0, external_vitest_namespaceObject.expect)(parsed.metadata.subAgents).toHaveLength(1);
         (0, external_vitest_namespaceObject.expect)(parsed.metadata.subAgents[0].name).toBe("reviewer");
+        (0, external_vitest_namespaceObject.expect)(parsed.metadata.subAgents[0].reasoningEffort).toBe("medium");
         (0, external_vitest_namespaceObject.expect)(parsed.metadata.subAgents[0].promptRefinement).toEqual({
             enabled: true,
             instructionsPath: "/memories/reviewer.md"
@@ -225,6 +244,27 @@ describeIfBun("agents API", ()=>{
         (0, external_vitest_namespaceObject.expect)(created.promptTraining).toBe(true);
         (0, external_vitest_namespaceObject.expect)(created.promptRefinement).toBe(true);
     });
+    (0, external_vitest_namespaceObject.it)("accepts legacy thinkingEffort input as reasoningEffort", async ()=>{
+        const createReq = new Request("http://localhost/api/agents", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                id: "legacy-thinking-agent",
+                tools: [
+                    "think"
+                ],
+                prompt: "Legacy thinking prompt",
+                thinkingEffort: "medium"
+            })
+        });
+        const createRes = await (0, agents_cjs_namespaceObject.handleAgentsApi)(ctx, createReq, new URL(createReq.url));
+        (0, external_vitest_namespaceObject.expect)(createRes).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(createRes?.ok).toBe(true);
+        const created = await createRes.json();
+        (0, external_vitest_namespaceObject.expect)(created.reasoningEffort).toBe("medium");
+    });
 });
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {