spec-cat 0.1.12 → 0.1.13

package/.output/server/chunks/routes/_ws.mjs

@@ -26,7 +26,7 @@ import 'node:module';
 import 'node:url';
 
 const execAsync = promisify(exec);
-const WORKTREE_PREFIX = "/tmp/br-";
+const WORKTREE_PREFIX = "/tmp/sc-";
 async function ensureChatWorktree(projectDir, worktreePath, knownBranch) {
   if (!worktreePath.startsWith(WORKTREE_PREFIX)) {
     return { recovered: false };
@@ -42,7 +42,7 @@ async function ensureChatWorktree(projectDir, worktreePath, knownBranch) {
     if (!convId) {
       return { recovered: false, error: `Cannot derive branch name from worktree path: ${worktreePath}` };
     }
-    branchName = `br/${convId}`;
+    branchName = `sc/${convId}`;
   }
   try {
     await execAsync("git worktree prune", { cwd: projectDir });
@@ -99,9 +99,304 @@ async function loadSpecContext(projectDir, featureId) {
   return sections.join("\n");
 }
 
+function extractSessionId(message) {
+  const eventType = typeof message.type === "string" ? message.type.toLowerCase() : "";
+  const subtype = typeof message.subtype === "string" ? message.subtype.toLowerCase() : "";
+  const isErrorLike = eventType.includes("error") || eventType.includes("failed") || subtype.startsWith("error");
+  if (isErrorLike) {
+    return null;
+  }
+  const sessionIdKeys = ["session_id", "sessionId", "conversation_id", "conversationId", "thread_id", "threadId"];
+  for (const key of sessionIdKeys) {
+    const value = message[key];
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+  }
+  const response = message.response;
+  if (response && typeof response === "object" && !Array.isArray(response)) {
+    const responseObj = response;
+    for (const key of sessionIdKeys) {
+      const value = responseObj[key];
+      if (typeof value === "string" && value.length > 0) {
+        return value;
+      }
+    }
+  }
+  return null;
+}
+function normalizeTurnResultSubtype(value, isError) {
+  if (isError) return "error";
+  const raw = typeof value === "string" ? value.toLowerCase() : "";
+  if (raw === "success") return "success";
+  if (raw === "max_turns" || raw === "error_max_turns") return "max_turns";
+  if (raw.startsWith("error")) return "error";
+  return "success";
+}
+function transformClaudeEvent(event) {
+  var _a;
+  const sessionId = extractSessionId(event) || void 0;
+  const events = [];
+  if (event.type === "stream_event" && event.event && typeof event.event === "object") {
+    const streamEvent = event.event;
+    if (streamEvent.type === "content_block_start" && streamEvent.content_block && typeof streamEvent.content_block === "object") {
+      const block = streamEvent.content_block;
+      const blockType = block.type;
+      const normalizedBlockType = blockType === "server_tool_use" ? "tool_use" : blockType;
+      events.push({
+        type: "block_start",
+        sessionId,
+        blockId: block.id || `blk-${Date.now()}-${Math.random().toString(36).substring(2, 6)}`,
+        blockType: normalizedBlockType,
+        index: streamEvent.index,
+        name: block.name,
+        toolUseId: block.id,
+        text: block.text,
+        thinking: block.thinking
+      });
+    }
+    if (streamEvent.type === "content_block_delta" && streamEvent.delta && typeof streamEvent.delta === "object") {
+      const delta = streamEvent.delta;
+      events.push({
+        type: "block_delta",
+        sessionId,
+        blockId: "",
+        // Client matches by index/type if ID is missing in delta
+        index: streamEvent.index,
+        text: delta.text,
+        thinking: delta.thinking,
+        partialJson: delta.partial_json
+      });
+    }
+    if (streamEvent.type === "content_block_stop") {
+      events.push({
+        type: "block_end",
+        sessionId,
+        blockId: "",
+        index: streamEvent.index
+      });
+    }
+  }
+  if (event.type === "tool_result") {
+    events.push({
+      type: "tool_result",
+      sessionId,
+      toolUseId: event.tool_use_id,
+      content: event.content,
+      isError: !!event.is_error
+    });
+  }
+  if (event.type === "permission_request" && event.permission && typeof event.permission === "object") {
+    const perm = event.permission;
+    events.push({
+      type: "permission_request",
+      sessionId,
+      tool: perm.tool || "Permission",
+      description: perm.description,
+      input: perm
+    });
+  }
+  if (event.type === "result") {
+    const usage = event.usage;
+    const isError = Boolean(event.is_error);
+    events.push({
+      type: "turn_result",
+      sessionId,
+      subtype: normalizeTurnResultSubtype(event.subtype, isError),
+      totalCostUsd: event.total_cost_usd,
+      durationMs: event.duration_ms,
+      numTurns: event.num_turns,
+      usage: usage ? {
+        inputTokens: usage.input_tokens || 0,
+        outputTokens: usage.output_tokens || 0,
+        cacheCreationInputTokens: usage.cache_creation_input_tokens || 0,
+        cacheReadInputTokens: usage.cache_read_input_tokens || 0
+      } : void 0
+    });
+  }
+  if (event.type === "system" && event.subtype === "init") {
+    events.push({
+      type: "session_init",
+      sessionId,
+      model: event.model,
+      tools: event.tools || [],
+      permissionMode: event.permissionMode || "",
+      cwd: event.cwd || ""
+    });
+  }
+  if (event.type === "user" && (event.message || event.content)) {
+    const content = ((_a = event.message) == null ? void 0 : _a.content) || event.content;
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if ((block == null ? void 0 : block.type) === "tool_result" && (block == null ? void 0 : block.is_error) && typeof block.content === "string") {
+          const errorContent = block.content;
+          if (errorContent.includes("requested permissions") || errorContent.includes("haven't granted")) {
+            const tools = parseToolsFromError(errorContent);
+            events.push({
+              type: "permission_request",
+              sessionId,
+              tool: tools[0] || "Permission",
+              tools,
+              description: errorContent
+            });
+          }
+        }
+      }
+    }
+  }
+  return events;
+}
+function transformCodexEvent(event) {
+  const type = event.type;
+  const canonicalTypes = [
+    "session_init",
+    "block_start",
+    "block_delta",
+    "block_end",
+    "tool_result",
+    "permission_request",
+    "turn_result",
+    "error",
+    "done"
+  ];
+  if (canonicalTypes.includes(type)) {
+    return [event];
+  }
+  return transformClaudeEvent(event);
+}
+function isRenderableEvent(event) {
+  switch (event.type) {
+    case "block_start":
+      return ["text", "thinking", "tool_use"].includes(event.blockType);
+    case "block_delta":
+      return !!(event.text || event.thinking || event.partialJson);
+    case "tool_result":
+    case "permission_request":
+      return true;
+    case "turn_result":
+      return event.subtype !== "success";
+    // Errors in result are renderable
+    default:
+      return false;
+  }
+}
+function checkForPermissionRequest(event, approvedTools, providerId) {
+  if (event.type === "permission_request") {
+    return event;
+  }
+  if (event.type === "block_start" && event.blockType === "tool_use" && providerId === "codex") {
+    const normalizedTool = normalizeToolName(event.name || "");
+    if (normalizedTool && codexToolNeedsAskApproval(normalizedTool) && !approvedTools.has(normalizedTool)) {
+      return {
+        type: "permission_request",
+        sessionId: event.sessionId,
+        tool: normalizedTool,
+        tools: [normalizedTool],
+        description: `Permission required: ${normalizedTool}`
+      };
+    }
+  }
+  if (event.type === "tool_result" && event.isError) {
+    if (isPermissionRequestText(event.content)) {
+      const tools = parseToolsFromError(event.content);
+      return {
+        type: "permission_request",
+        sessionId: event.sessionId,
+        tool: tools[0] || "Permission",
+        tools,
+        description: event.content
+      };
+    }
+  }
+  return null;
+}
+function normalizeToolName(tool) {
+  if (!tool) return "";
+  const trimmed = tool.trim();
+  if (!trimmed) return "";
+  return trimmed.charAt(0).toUpperCase() + trimmed.slice(1);
+}
+function isPermissionRequestText(text) {
+  if (!text) return false;
+  return /permission required|approval required|requires approval|requested permissions|haven't granted|hasn't granted|not approved|approval policy|permission denied|operation not permitted|read-only file system|cannot touch/i.test(text);
+}
+function parseToolsFromError(errorContent) {
+  const lowerContent = errorContent.toLowerCase();
+  const tools = [];
+  const toolNameMatch = errorContent.match(/(?:use the |Permission Required: )(\w+)(?: tool)?/i);
+  if (toolNameMatch) {
+    const toolName = toolNameMatch[1];
+    const normalized = toolName.charAt(0).toUpperCase() + toolName.slice(1).toLowerCase();
+    if (["Read", "Write", "Edit", "Bash", "Glob", "Grep", "Webfetch", "Websearch"].includes(normalized)) {
+      const tool = normalized === "Webfetch" ? "WebFetch" : normalized === "Websearch" ? "WebSearch" : normalized;
+      return [tool];
+    }
+  }
+  if (lowerContent.includes("write to") || lowerContent.includes("write ")) {
+    tools.push("Write", "Edit");
+  }
+  if (lowerContent.includes("edit ") && !tools.includes("Edit")) {
+    tools.push("Edit");
+  }
+  if (lowerContent.includes("read ")) {
+    tools.push("Read");
+  }
+  if (lowerContent.includes("run ") || lowerContent.includes("execute") || lowerContent.includes("bash")) {
+    tools.push("Bash");
+  }
+  if (lowerContent.includes("glob")) {
+    tools.push("Glob");
+  }
+  if (lowerContent.includes("grep")) {
+    tools.push("Grep");
+  }
+  if (lowerContent.includes("fetch") || lowerContent.includes("webfetch")) {
+    tools.push("WebFetch");
+  }
+  if (lowerContent.includes("websearch")) {
+    tools.push("WebSearch");
+  }
+  return tools.length > 0 ? tools : ["Write", "Edit"];
+}
+function normalizeTools(tools) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const tool of tools) {
+    const normalized = normalizeToolName(tool);
+    if (normalized) {
+      seen.add(normalized);
+    }
+  }
+  return Array.from(seen);
+}
+function codexToolNeedsAskApproval(tool) {
+  const normalized = normalizeToolName(tool);
+  if (!normalized) return false;
+  if (normalized === "Read" || normalized === "Glob" || normalized === "Grep" || normalized === "WebSearch") {
+    return false;
+  }
+  return true;
+}
+function extractPermissionRequestFromProcessOutput(nonJsonOutput) {
+  if (!Array.isArray(nonJsonOutput) || nonJsonOutput.length === 0) return null;
+  const description = nonJsonOutput.join("\n");
+  if (!isPermissionRequestText(description)) {
+    return null;
+  }
+  const tools = parseToolsFromError(description);
+  return { tools, description };
+}
+
 const peerStates = /* @__PURE__ */ new Map();
 const MAX_ATTACHMENT_COUNT = 4;
 const MAX_ATTACHMENT_SIZE_BYTES = 5 * 1024 * 1024;
+const SPECKIT_AUTONOMY_DIRECTIVE = [
+  "Speckit Execution Mode (MANDATORY):",
+  "- Do not ask the user for confirmation, follow-up, or permission to proceed.",
+  '- Do not end with questions like "Would you like me to..." or "Shall I...".',
+  "- For remediation and traceability gaps, directly edit the relevant spec files now (spec.md, plan.md, tasks.md) when writable.",
+  "- Prefer concrete file edits over recommendations; provide a brief change summary after edits are complete.",
+  "- Only stop without edits if blocked by a hard constraint (missing files, permission failure), and report the blocker explicitly."
+].join("\n");
 function getPeerState(peerId) {
   let state = peerStates.get(peerId);
   if (!state) {
@@ -117,48 +412,15 @@ function getPeerState(peerId) {
   }
   return state;
 }
+function isSpeckitCommand(message) {
+  return message.trim().startsWith("/speckit.");
+}
 function killProc(proc) {
   try {
     proc.kill();
   } catch {
   }
 }
-function hasRenderableProviderContent(message) {
-  const type = typeof message.type === "string" ? message.type : "";
-  if (type === "stream_event") {
-    const event = message.event;
-    if (event && typeof event === "object") {
-      const streamEvent = event;
-      if (streamEvent.type === "content_block_start") {
-        const contentBlock = streamEvent.content_block;
-        if (contentBlock && typeof contentBlock === "object") {
-          const block = contentBlock;
-          const blockType = typeof block.type === "string" ? block.type : "";
-          if (blockType === "text" || blockType === "thinking" || blockType === "tool_use" || blockType === "server_tool_use") {
-            return true;
-          }
-        }
-      }
-      if (streamEvent.type === "content_block_delta") {
-        const delta = streamEvent.delta;
-        if (delta && typeof delta === "object") {
-          const d = delta;
-          if (typeof d.text === "string" || typeof d.thinking === "string" || typeof d.partial_json === "string") {
-            return true;
-          }
-        }
-      }
-    }
-  }
-  if (type === "tool_result" || type === "permission_request") {
-    return true;
-  }
-  if (type === "result") {
-    const subtype = typeof message.subtype === "string" ? message.subtype : "";
-    return subtype.startsWith("error");
-  }
-  return false;
-}
 function normalizeImageAttachments(attachments) {
   if (!Array.isArray(attachments)) return [];
   return attachments.slice(0, MAX_ATTACHMENT_COUNT).map((item) => {
@@ -196,22 +458,21 @@ function buildProviderMessage(baseMessage, attachments) {
 }
 function sendAssistantText(peer, text, sessionId) {
   peer.send(JSON.stringify({
-    type: "provider_json",
-    data: {
-      type: "stream_event",
-      ...sessionId ? { session_id: sessionId } : {},
-      event: {
-        type: "content_block_start",
-        content_block: { type: "text", text }
-      }
+    type: "ui_event",
+    event: {
+      type: "block_start",
+      sessionId: sessionId || void 0,
+      blockId: `blk-${Date.now()}`,
+      blockType: "text",
+      text
     }
   }));
   peer.send(JSON.stringify({
-    type: "provider_json",
-    data: {
-      type: "stream_event",
-      ...sessionId ? { session_id: sessionId } : {},
-      event: { type: "content_block_stop" }
+    type: "ui_event",
+    event: {
+      type: "block_end",
+      sessionId: sessionId || void 0,
+      blockId: ""
     }
   }));
 }
@@ -340,8 +601,8 @@ async function handleChatMessage(peer, msg) {
     }));
     return;
   }
-  const isSpeckitCommand = msg.message.trim().startsWith("/speckit.");
-  if (isSpeckitCommand) {
+  const speckitCommand = isSpeckitCommand(msg.message);
+  if (speckitCommand) {
     console.log("[WS] Speckit command detected - auto-resetting context for peer:", peer.id);
     clearProviderSession(state);
   } else {
@@ -353,9 +614,9 @@ async function handleChatMessage(peer, msg) {
   }
   state.pendingMessage = msg;
   state.pendingTools = [];
-  if (!isSpeckitCommand && msg.sessionId) {
+  if (!speckitCommand && msg.sessionId) {
     state.providerSessionId = msg.sessionId;
-  } else if (!isSpeckitCommand) {
+  } else if (!speckitCommand) {
     state.approvedTools.clear();
     state.providerSessionId = null;
   }
@@ -366,7 +627,7 @@ async function handleChatMessage(peer, msg) {
     attachmentCount: attachments.length,
     providerId: msg.providerId,
     providerModelKey: msg.providerModelKey,
-    isSpeckitCommand
+    isSpeckitCommand: speckitCommand
   });
   runProvider(peer, state, msg);
 }
@@ -404,7 +665,7 @@ async function runProvider(peer, state, msg, isRetry = false, forceEphemeral = f
       return;
     }
   }
-  if (workingDirectory.startsWith("/tmp/br-") && !existsSync(workingDirectory)) {
+  if (workingDirectory.startsWith("/tmp/sc-") && !existsSync(workingDirectory)) {
     const result = await ensureChatWorktree(projectDir, workingDirectory, msg.worktreeBranch);
     if (result.recovered) {
       peer.send(JSON.stringify({ type: "worktree_recovered" }));
@@ -420,6 +681,7 @@ async function runProvider(peer, state, msg, isRetry = false, forceEphemeral = f
   const usedResumeFlag = !isRetry && !!state.providerSessionId;
   const resumeSessionId = usedResumeFlag ? state.providerSessionId : void 0;
   let systemPrompt;
+  const speckitCommand = isSpeckitCommand(msg.message);
   if (msg.featureId && !usedResumeFlag) {
     try {
       const specContext = await loadSpecContext(projectDir, msg.featureId);
@@ -430,6 +692,11 @@ async function runProvider(peer, state, msg, isRetry = false, forceEphemeral = f
       console.error("[WS] Failed to load spec context:", error);
     }
   }
+  if (speckitCommand && !usedResumeFlag) {
+    systemPrompt = systemPrompt ? `${systemPrompt}
+
+${SPECKIT_AUTONOMY_DIRECTIVE}` : SPECKIT_AUTONOMY_DIRECTIVE;
+  }
   console.log("[WS] Running provider stream:", selection.providerId, selection.modelKey, isRetry ? "(retry)" : "");
   const generation = state.procGeneration;
   let permissionRequested = false;
@@ -450,85 +717,33 @@ async function runProvider(peer, state, msg, isRetry = false, forceEphemeral = f
       },
       {
         onProviderJson(parsed) {
-          var _a, _b, _c, _d, _e;
-          const sessionId = extractSessionId(parsed);
-          if (sessionId) {
-            state.providerSessionId = sessionId;
-          }
-          if (hasRenderableProviderContent(parsed)) {
-            emittedRenderableContent = true;
-          }
-          if (selection.providerId === "codex" && (mode === "ask" || mode === "plan") && !permissionRequested) {
-            const requestedTool = extractToolUseNameFromProviderJson(parsed);
-            const normalizedTool = normalizeToolName(requestedTool || "");
-            if (normalizedTool && codexToolNeedsAskApproval(normalizedTool) && !state.approvedTools.has(normalizedTool)) {
-              permissionRequested = true;
-              state.pendingTools = [normalizedTool];
-              peer.send(JSON.stringify({
-                type: "permission_request",
-                tool: normalizedTool,
-                tools: state.pendingTools,
-                description: `Permission required: ${normalizedTool}`
-              }));
-              (_a = state.proc) == null ? void 0 : _a.kill();
-              return;
+          var _a;
+          const adapter = selection.providerId === "claude" ? transformClaudeEvent : transformCodexEvent;
+          const events = adapter(parsed);
+          for (const event of events) {
+            if (event.sessionId) {
+              state.providerSessionId = event.sessionId;
             }
-          }
-          if (parsed.type === "permission_request" && !permissionRequested) {
-            permissionRequested = true;
-            const permission = parsed.permission && typeof parsed.permission === "object" ? parsed.permission : null;
-            const tool = permission && typeof permission.tool === "string" ? permission.tool : "Permission";
-            const normalizedTool = normalizeToolName(tool);
-            const description = permission && typeof permission.description === "string" ? permission.description : "Permission required to continue execution.";
-            state.pendingTools = normalizedTool ? [normalizedTool] : [];
-            peer.send(JSON.stringify({
-              type: "permission_request",
-              tool: normalizedTool || "Permission",
-              tools: state.pendingTools,
-              description
-            }));
-            (_b = state.proc) == null ? void 0 : _b.kill();
-            return;
-          }
-          if ((mode === "ask" || mode === "plan") && !permissionRequested) {
-            const inferred = extractPermissionRequestFromToolResult(parsed);
-            if (inferred) {
-              permissionRequested = true;
-              state.pendingTools = normalizeTools(inferred.tools);
-              peer.send(JSON.stringify({
-                type: "permission_request",
-                tool: state.pendingTools[0] || "Permission",
-                tools: state.pendingTools,
-                description: inferred.description
-              }));
-              (_c = state.proc) == null ? void 0 : _c.kill();
-              return;
+            if (isRenderableEvent(event)) {
+              emittedRenderableContent = true;
             }
-          }
-          if (selection.providerId === "claude" && parsed.type === "user" && !permissionRequested) {
-            const content = ((_d = parsed.message) == null ? void 0 : _d.content) || parsed.content;
-            if (Array.isArray(content)) {
-              for (const block of content) {
-                if ((block == null ? void 0 : block.type) === "tool_result" && (block == null ? void 0 : block.is_error) && typeof block.content === "string") {
-                  const errorContent = block.content;
-                  if (errorContent.includes("requested permissions") || errorContent.includes("haven't granted")) {
-                    permissionRequested = true;
-                    const tools = parseToolsFromError(errorContent);
-                    state.pendingTools = normalizeTools(tools);
-                    peer.send(JSON.stringify({
-                      type: "permission_request",
-                      tool: state.pendingTools[0],
-                      tools: state.pendingTools,
-                      description: errorContent
-                    }));
-                    (_e = state.proc) == null ? void 0 : _e.kill();
-                    return;
-                  }
-                }
+            if ((mode === "ask" || mode === "plan") && !permissionRequested) {
+              const permRequest = checkForPermissionRequest(event, state.approvedTools, selection.providerId);
+              if (permRequest) {
+                permissionRequested = true;
+                state.pendingTools = permRequest.tools || [permRequest.tool];
+                peer.send(JSON.stringify({
+                  type: "permission_request",
+                  tool: permRequest.tool,
+                  tools: state.pendingTools,
+                  description: permRequest.description || `Permission required: ${permRequest.tool}`
+                }));
+                (_a = state.proc) == null ? void 0 : _a.kill();
+                return;
               }
             }
+            peer.send(JSON.stringify({ type: "ui_event", event }));
           }
-          peer.send(JSON.stringify({ type: "provider_json", data: parsed }));
         },
         onClose({ exitCode, signal, nonJsonOutput }) {
           if (state.procGeneration !== generation) {
@@ -651,131 +866,6 @@ ${summary}` : "Provider completed without returning visible response content.";
     state.proc = null;
   }
 }
-function extractSessionId(message) {
-  const eventType = typeof message.type === "string" ? message.type.toLowerCase() : "";
-  const subtype = typeof message.subtype === "string" ? message.subtype.toLowerCase() : "";
-  const isErrorLike = eventType.includes("error") || eventType.includes("failed") || subtype.startsWith("error");
-  if (isErrorLike) {
-    return null;
-  }
-  const sessionIdKeys = ["session_id", "sessionId", "conversation_id", "conversationId", "thread_id", "threadId"];
-  for (const key of sessionIdKeys) {
-    const value = message[key];
-    if (typeof value === "string" && value.length > 0) {
-      return value;
-    }
-  }
-  const response = message.response;
-  if (response && typeof response === "object" && !Array.isArray(response)) {
-    const responseObj = response;
-    for (const key of sessionIdKeys) {
-      const value = responseObj[key];
-      if (typeof value === "string" && value.length > 0) {
-        return value;
-      }
-    }
-  }
-  return null;
-}
-function parseToolsFromError(errorContent) {
-  const lowerContent = errorContent.toLowerCase();
-  const tools = [];
-  const toolNameMatch = errorContent.match(/(?:use the |Permission Required: )(\w+)(?: tool)?/i);
-  if (toolNameMatch) {
-    const toolName = toolNameMatch[1];
-    const normalized = toolName.charAt(0).toUpperCase() + toolName.slice(1).toLowerCase();
-    if (["Read", "Write", "Edit", "Bash", "Glob", "Grep", "Webfetch", "Websearch"].includes(normalized)) {
-      const tool = normalized === "Webfetch" ? "WebFetch" : normalized === "Websearch" ? "WebSearch" : normalized;
-      return [tool];
-    }
-  }
-  if (lowerContent.includes("write to") || lowerContent.includes("write ")) {
-    tools.push("Write", "Edit");
-  }
-  if (lowerContent.includes("edit ") && !tools.includes("Edit")) {
-    tools.push("Edit");
-  }
-  if (lowerContent.includes("read ")) {
-    tools.push("Read");
-  }
-  if (lowerContent.includes("run ") || lowerContent.includes("execute") || lowerContent.includes("bash")) {
-    tools.push("Bash");
-  }
-  if (lowerContent.includes("glob")) {
-    tools.push("Glob");
-  }
-  if (lowerContent.includes("grep")) {
-    tools.push("Grep");
-  }
-  if (lowerContent.includes("fetch") || lowerContent.includes("webfetch")) {
-    tools.push("WebFetch");
-  }
-  if (lowerContent.includes("websearch")) {
-    tools.push("WebSearch");
-  }
-  return tools.length > 0 ? tools : ["Write", "Edit"];
-}
-function extractToolUseNameFromProviderJson(parsed) {
-  if (parsed.type !== "stream_event") return null;
-  const event = parsed.event;
-  if (!event || typeof event !== "object" || Array.isArray(event)) return null;
-  const eventObj = event;
-  if (eventObj.type !== "content_block_start") return null;
-  const contentBlock = eventObj.content_block;
-  if (!contentBlock || typeof contentBlock !== "object" || Array.isArray(contentBlock)) return null;
-  const blockObj = contentBlock;
-  const blockType = typeof blockObj.type === "string" ? blockObj.type : "";
-  if (blockType !== "tool_use" && blockType !== "server_tool_use") return null;
-  return typeof blockObj.name === "string" && blockObj.name.length > 0 ? blockObj.name : null;
-}
-function normalizeToolName(tool) {
-  if (!tool) return "";
-  const trimmed = tool.trim();
-  if (!trimmed) return "";
-  return trimmed.charAt(0).toUpperCase() + trimmed.slice(1);
-}
-function normalizeTools(tools) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const tool of tools) {
-    const normalized = normalizeToolName(tool);
-    if (normalized) {
-      seen.add(normalized);
-    }
-  }
-  return Array.from(seen);
-}
-function codexToolNeedsAskApproval(tool) {
-  const normalized = normalizeToolName(tool);
-  if (!normalized) return false;
-  if (normalized === "Read" || normalized === "Glob" || normalized === "Grep" || normalized === "WebSearch") {
-    return false;
-  }
-  return true;
-}
-function isPermissionRequestText(text) {
-  if (!text) return false;
-  return /permission required|approval required|requires approval|requested permissions|haven't granted|hasn't granted|not approved|approval policy|permission denied|operation not permitted|read-only file system|cannot touch/i.test(text);
-}
-function extractPermissionRequestFromToolResult(parsed) {
-  if (parsed.type !== "tool_result") return null;
-  if (parsed.is_error !== true) return null;
-  if (typeof parsed.content !== "string") return null;
-  const description = parsed.content;
-  if (!isPermissionRequestText(description)) {
-    return null;
-  }
-  const tools = parseToolsFromError(description);
-  return { tools, description };
-}
-function extractPermissionRequestFromProcessOutput(nonJsonOutput) {
-  if (!Array.isArray(nonJsonOutput) || nonJsonOutput.length === 0) return null;
-  const description = nonJsonOutput.join("\n");
-  if (!isPermissionRequestText(description)) {
-    return null;
-  }
-  const tools = parseToolsFromError(description);
-  return { tools, description };
-}
 
 export { _ws as default };
 //# sourceMappingURL=_ws.mjs.map