@capagents/forgeqe 2.3.0 → 2.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capagents/forgeqe",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "ForgeQE: a browser agent CLI that runs goals and test cases in local Chrome or Chromium, or BrowserStack and TestMu AI/LambdaTest when configured, and turns passing runs into tests in your repo",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {

package/py/forgeqe_engine/copilot_gateway.py

@@ -290,6 +290,9 @@ class Copilot:
         self.workdir = tempfile.mkdtemp(prefix="forgeqe-copilot-")
         self.signed_in_user = not token
         self.client = CopilotClient(**client_options(token, home, self.workdir))
+        # Caller tools named like one of Copilot's own: they must say they replace it. Learned from Copilot's answers
+        # (BUILTIN_TOOLS to start with), kept for the gateway's life, so only a first request pays a retry.
+        self.replaces: set = set(BUILTIN_TOOLS)
 
     async def start(self) -> None:
         await self.client.start()
@@ -343,38 +346,54 @@ class Copilot:
             elif isinstance(data, SessionErrorData):
                 errors.append(data.message or data.error_type or "error")
 
-        tools = relay_tools(req["tools"], calls)
-        options: Dict[str, Any] = dict(
-            model=req["model"],
-            # The caller's prompt is the whole prompt; Copilot's own tools are never offered, only the caller's.
-            system_message={"mode": "replace", "content": req["system"] or "You are a helpful assistant."},
-            tools=tools or None,
-            available_tools=[t.name for t in tools],
-            on_permission_request=lambda *_: PermissionDecisionReject(),
-            working_directory=self.workdir,
-            skip_custom_instructions=True,
-            enable_config_discovery=False,
-            enable_skills=False,
-            enable_session_store=False,
-            on_event=on_event,
-        )
-        try:
-            session = await self.client.create_session(**options)
-        except Exception as e:
-            # A caller's tool named like one of Copilot's (bash, grep, glob) must say it replaces it.
-            if not tools or "built" not in str(e).lower():
-                raise
-            tools = relay_tools(req["tools"], calls, override=True)
-            session = await self.client.create_session(**{**options, "tools": tools})
-        try:
-            reply = await session.send_and_wait(req["prompt"], attachments=req["attachments"] or None, response_schema=req["schema"], timeout=REQUEST_TIMEOUT_S)
-        except TimeoutError:
-            raise GatewayError(504, f"GitHub Copilot did not answer within {int(REQUEST_TIMEOUT_S)} seconds.")
-        finally:
+        tried: set = set()
+        reply: Any = None
+        for _ in range(MAX_TOOL_RETRIES + 1):
+            errors.clear()
+            calls.clear()
+            names = {t["name"] for t in req["tools"]}
+            tools = relay_tools(req["tools"], calls, replaces=self.replaces & names)
+            options: Dict[str, Any] = dict(
+                model=req["model"],
+                # The caller's prompt is the whole prompt; Copilot's own tools are never offered, only the caller's.
+                system_message={"mode": "replace", "content": req["system"] or "You are a helpful assistant."},
+                tools=tools or None,
+                available_tools=[t.name for t in tools],
+                on_permission_request=lambda *_: PermissionDecisionReject(),
+                working_directory=self.workdir,
+                skip_custom_instructions=True,
+                enable_config_discovery=False,
+                enable_skills=False,
+                enable_session_store=False,
+                on_event=on_event,
+            )
+            failure: Optional[str] = None
+            session = None
             try:
-                await session.disconnect()
-            except Exception:
-                pass
+                session = await self.client.create_session(**options)
+                reply = await session.send_and_wait(req["prompt"], attachments=req["attachments"] or None, response_schema=req["schema"], timeout=REQUEST_TIMEOUT_S)
+            except TimeoutError:
+                raise GatewayError(504, f"GitHub Copilot did not answer within {int(REQUEST_TIMEOUT_S)} seconds.")
+            except Exception as e:  # Copilot names a tool it will not take; anything else is reported below.
+                failure = str(e)
+            finally:
+                if session is not None:
+                    try:
+                        await session.disconnect()
+                    except Exception:
+                        pass
+            # Copilot reports a clash with its own tools when the session starts or when the turn starts.
+            fix = tool_conflict(failure or (errors[-1] if errors and not calls else ""), names)
+            if fix and fix not in tried:
+                tried.add(fix)
+                name, replace = fix
+                (self.replaces.add if replace else self.replaces.discard)(name)
+                continue
+            if failure:
+                raise GatewayError(502, f"GitHub Copilot: {failure}"[:2000])
+            break
+        else:
+            raise GatewayError(502, "GitHub Copilot kept refusing the names of the caller's tools.")
         if errors and not calls:
             msg = errors[-1]
             raise GatewayError(401 if "auth" in msg.lower() or "401" in msg else 502, f"GitHub Copilot: {msg}")
@@ -389,10 +408,36 @@ class Copilot:
         return completion(req["model"], content, usage)
 
 
-def relay_tools(specs: List[Dict[str, Any]], calls: List[Dict[str, Any]], override: bool = False) -> List[Any]:
+# Copilot's own tools that the agent runtime's tools are named like (bash, glob, grep, edit, …). A caller tool with one
+# of these names says it replaces Copilot's: the caller's tool is the one offered, and it runs nothing here.
+BUILTIN_TOOLS = frozenset({"bash", "powershell", "glob", "grep", "view", "edit", "create", "task", "skill", "web_fetch", "think", "update_todo", "report_intent"})
+MAX_TOOL_RETRIES = 8
+
+_CONFLICT = re.compile(r'(?:external )?tool "([A-Za-z0-9_-]{1,64})" conflicts with a built-in tool', re.I)
+_NO_BUILTIN = re.compile(r'tool "([A-Za-z0-9_-]{1,64})"[^"\n]{0,80}(?:does not|doesn\'t|no) (?:override|built-in|builtin)', re.I)
+
+
+def tool_conflict(message: str, names: set) -> Optional[Tuple[str, bool]]:
+    """
+    From Copilot's error, the caller tool to retry with: (name, True) when it clashes with a built-in and must replace
+    it, (name, False) when Copilot has no built-in of that name to replace. None for any other error.
+    """
+    if not message:
+        return None
+    m = _CONFLICT.search(message)
+    if m and m.group(1) in names:
+        return m.group(1), True
+    m = _NO_BUILTIN.search(message)
+    if m and m.group(1) in names:
+        return m.group(1), False
+    return None
+
+
+def relay_tools(specs: List[Dict[str, Any]], calls: List[Dict[str, Any]], override: bool = False, replaces: Optional[set] = None) -> List[Any]:
     """
     The caller's tools as Copilot SDK tools that run nothing: each records the call in `calls` and, being terminal, ends
-    the turn, so the call goes back to the caller as OpenAI tool_calls.
+    the turn, so the call goes back to the caller as OpenAI tool_calls. A tool in `replaces` (or every tool, with
+    `override`) replaces Copilot's built-in tool of the same name.
     """
     if not specs:
         return []
@@ -408,7 +453,7 @@ def relay_tools(specs: List[Dict[str, Any]], calls: List[Dict[str, Any]], overri
         return ToolResult(text_result_for_llm="The caller runs this tool and sends its result in the next message.")
 
     return [
-        Tool(name=t["name"], description=t["description"], parameters=t["parameters"], handler=handler, skip_permission=True, is_terminal=True, defer="never", overrides_built_in_tool=override)
+        Tool(name=t["name"], description=t["description"], parameters=t["parameters"], handler=handler, skip_permission=True, is_terminal=True, defer="never", overrides_built_in_tool=override or t["name"] in (replaces or set()))
         for t in specs
     ]