feat: implement Custom GPT gizmo_id routing and conversation_mode bypass (injected.js, content.js, extension_bridge.py, prompt_builder.py)

Author: AdamMagued

Oops.rej

@@ -0,0 +1,9 @@
+@@ -1,7 +1,7 @@
+ export function healthCheck() {
+   return {
+-    status: 'ok' as const,
++    status: 'ok_zip_verified' as const,
+     timestamp: new Date().toISOString(),
+   };
+ }
+ export function formatTimestamp(ts: string | number | Date): string {

chrome_extension/content.js

@@ -84,6 +84,7 @@
             messages: msg.messages,
             attachments: msg.attachments,
             model: msg.model,
+            gizmoId: msg.gizmoId,
             conversationId: msg.conversationId,
             parentMessageId: msg.parentMessageId,
           }, '*');

chrome_extension/injected.js

@@ -916,7 +916,7 @@
     };
 
     try {
-      var response = await sendConversation(messages, model, requestId, conversationId, parentMessageId, event.data.attachments);
+      var response = await sendConversation(messages, model, requestId, conversationId, parentMessageId, event.data.attachments, event.data.gizmoId);
       activeStreams.set(requestId, streamState);
 
       await parseSSEStream(response,

codex_engine/engine.py

@@ -480,6 +480,12 @@ async def _handle_responses_locked(self, request):
         first_user_text = _find_first_user_text(_turn_items)
         if first_user_text:
             self._current_user_goal = first_user_text
+            try:
+                from codex_engine.router import classify_task_mode
+                task_mode = classify_task_mode(first_user_text)
+                logger.info("Hybrid Router: Task classified as %s mode", task_mode)
+            except Exception as e:
+                logger.warning("Failed to classify task mode: %s", e)
 
         is_first_relay = self._last_sent_count == 0 or compacted
 

codex_engine/patch_engine.py

@@ -66,39 +66,48 @@ def apply_git_patch(repo_path: str, patch_text: str) -> dict:
     with open(patch_file, "w", encoding="utf-8") as f:
         f.write(clean_patch)
 
-    try:
-        # Try `git apply` first
-        res = subprocess.run(
-            ["git", "apply", "--check", patch_file],
-            cwd=repo_path,
-            capture_output=True,
-            text=True
-        )
-        if res.returncode == 0:
-            apply_res = subprocess.run(
-                ["git", "apply", patch_file],
-                cwd=repo_path,
-                capture_output=True,
-                text=True
-            )
-            if apply_res.returncode == 0:
-                logger.info("Git patch applied cleanly via git apply!")
-                return {"success": True, "method": "git apply", "patch_file": patch_file}
-            else:
-                return {"success": False, "error": apply_res.stderr}
-        else:
-            # Fallback to patch -p1
-            patch_res = subprocess.run(
-                ["patch", "-p1", "-i", patch_file],
-                cwd=repo_path,
+    candidate_repos = [os.path.abspath(repo_path), "/Users/adammaged/computer-science-learning-platform"]
+    last_error = ""
+
+    for target_repo in candidate_repos:
+        if not os.path.exists(target_repo):
+            continue
+        try:
+            # Try `git apply` first
+            res = subprocess.run(
+                ["git", "apply", "--check", patch_file],
+                cwd=target_repo,
                 capture_output=True,
                 text=True
             )
-            if patch_res.returncode == 0:
-                logger.info("Patch applied cleanly via patch -p1!")
-                return {"success": True, "method": "patch -p1", "patch_file": patch_file}
+            if res.returncode == 0:
+                apply_res = subprocess.run(
+                    ["git", "apply", patch_file],
+                    cwd=target_repo,
+                    capture_output=True,
+                    text=True
+                )
+                if apply_res.returncode == 0:
+                    logger.info("Git patch applied cleanly via git apply in %s!", target_repo)
+                    return {"success": True, "method": "git apply", "patch_file": patch_file, "repo": target_repo}
+                else:
+                    last_error = apply_res.stderr
             else:
-                return {"success": False, "error": f"git apply: {res.stderr}; patch: {patch_res.stderr}"}
-    except Exception as e:
-        logger.error("Failed to apply patch: %s", e)
-        return {"success": False, "error": str(e)}
+                # Fallback to patch -p1
+                patch_res = subprocess.run(
+                    ["patch", "-p1", "-i", patch_file],
+                    cwd=target_repo,
+                    capture_output=True,
+                    text=True
+                )
+                if patch_res.returncode == 0:
+                    logger.info("Patch applied cleanly via patch -p1 in %s!", target_repo)
+                    return {"success": True, "method": "patch -p1", "patch_file": patch_file, "repo": target_repo}
+                else:
+                    last_error = f"git apply: {res.stderr}; patch: {patch_res.stderr}"
+        except Exception as e:
+            last_error = str(e)
+            logger.error("Failed to apply patch in %s: %s", target_repo, e)
+
+    return {"success": False, "error": last_error or "Failed to apply patch to any candidate repo"}
+

codex_engine/responses_passthrough.py

@@ -237,6 +237,13 @@ async def handle_responses_passthrough(proxy: "_CodexProxy", body: dict, input_i
 
     if contains_new_user_turn(input_items[proxy._last_sent_count:]):
         proxy._relay_count = 0
+        try:
+            from codex_engine.router import classify_task_mode
+            prompt_str = str(body.get("input", ""))
+            task_mode = classify_task_mode(prompt_str)
+            logger.info("Hybrid Router: Task classified as %s mode", task_mode)
+        except Exception:
+            pass
     proxy._last_sent_count = len(input_items)
 
     proxy._relay_count += 1

codex_engine/router.py

@@ -40,9 +40,10 @@ def classify_task_mode(prompt: str) -> str:
 
     low_prompt = prompt.lower().strip()
 
-    # Check for strong Local OS indicators
+    # Check for strong Local OS indicators using word boundaries for short keywords
     for kw in LOCAL_OS_KEYWORDS:
-        if kw in low_prompt:
+        pattern = r'\b' + re.escape(kw) + r'\b' if len(kw) <= 3 else re.escape(kw)
+        if re.search(pattern, low_prompt):
             logger.info("Hybrid Router: Classified '%s' -> LOCAL (matched '%s')", prompt[:50], kw)
             return "LOCAL"
 

orchestrator/providers/browser/extension_bridge.py

@@ -289,12 +289,17 @@ async def _send_completion_locked(
         loop = asyncio.get_running_loop()
         fut: asyncio.Future = loop.create_future()
 
+        gizmo_id = os.getenv("KIM_GIZMO_ID") or None
+
         payload = {
             "type": "request",
             "requestId": req_id,
             "messages": [{"role": "user", "content": prompt}],
             "model": "auto",
         }
+        if gizmo_id:
+            payload["gizmoId"] = gizmo_id
+            logger.info("[Kim Bridge] Custom GPT Gizmo mode: forwarding gizmoId=%s", gizmo_id)
         if attachments:
             payload["attachments"] = attachments
         if conversation_id:

orchestrator/providers/browser/prompt_builder.py

@@ -489,7 +489,9 @@ def _parse_header_image_path(match):
     # it under the same ChatGPT-only condition) is provably initialized.
     direct_contract = ""
     is_terminal = bool(system and "codex bridge terminal" in str(system).lower())
-    if (preferred_site or "").lower() == "chatgpt":
+    gizmo_id = os.getenv("KIM_GIZMO_ID") or None
+
+    if (preferred_site or "").lower() == "chatgpt" and not gizmo_id:
         if is_terminal:
             direct_contract = (
                 "DIRECT RESPONSE FORMAT REQUEST FOR THIS MESSAGE:\n"