@cydm/pie 1.0.29 → 1.0.30

package/dist/chunks/{chunk-BDDSZSHX.js → chunk-PLJQYVFC.js}

@@ -2,12 +2,13 @@ import { createRequire as __createRequire } from "node:module"; const require =
 import {
   classifyShellCommand,
   createCodeIntelTool,
+  createLightweightCodeIntelProvider,
   createSharedWebFetchTool,
   createSharedWebResearchTool,
   createSharedWebSearchTool,
   interpretShellExit,
   requestInteraction
-} from "./chunk-L63BJMTT.js";
+} from "./chunk-BOFCKEV5.js";
 import {
   Type
 } from "./chunk-64XJIKVK.js";
@@ -811,7 +812,7 @@ function releaseWorkerSlot() {
 }
 function acquireWorkerSlot(deadline, signal) {
   if (signal?.aborted) return Promise.reject(new Error("Operation aborted"));
-  if (Date.now() >= deadline) return Promise.reject(new Error(`TypeScript code intelligence exceeded ${WORKER_TIMEOUT_MS}ms including queue wait`));
+  if (Date.now() >= deadline) return Promise.reject(new Error(`TypeScript code intelligence queue wait exceeded ${WORKER_TIMEOUT_MS}ms`));
   if (activeCodeIntelWorkers < MAX_ACTIVE_CODE_INTEL_WORKERS) {
     activeCodeIntelWorkers++;
     return Promise.resolve(releaseWorkerSlot);
@@ -831,7 +832,7 @@ function acquireWorkerSlot(deadline, signal) {
       const index = codeIntelWorkerWaiters.indexOf(waiter);
       if (index >= 0) codeIntelWorkerWaiters.splice(index, 1);
       signal?.removeEventListener("abort", waiter.onAbort);
-      reject(new Error(`TypeScript code intelligence exceeded ${WORKER_TIMEOUT_MS}ms including queue wait`));
+      reject(new Error(`TypeScript code intelligence queue wait exceeded ${WORKER_TIMEOUT_MS}ms`));
     }, Math.max(1, deadline - Date.now()));
     waiter.timeout.unref?.();
     signal?.addEventListener("abort", waiter.onAbort, { once: true });
@@ -879,7 +880,7 @@ function runWorker(request, timeoutMs, signal) {
       })();
     };
     const onAbort = () => finish(new Error("Operation aborted"));
-    const timeout = setTimeout(() => finish(new Error(`TypeScript code intelligence exceeded ${WORKER_TIMEOUT_MS}ms including queue wait`)), Math.max(1, timeoutMs));
+    const timeout = setTimeout(() => finish(new Error(`TypeScript code intelligence worker timed out after ${WORKER_TIMEOUT_MS}ms`)), Math.max(1, timeoutMs));
     timeout.unref?.();
     signal?.addEventListener("abort", onAbort, { once: true });
     worker.once("message", (message) => {
@@ -917,10 +918,46 @@ function createTypeScriptCodeIntelProvider() {
     }
   };
 }
+function codeIntelErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function shouldFallbackFromTypeScriptProvider(error) {
+  const message = codeIntelErrorMessage(error);
+  if (/aborted/i.test(message)) return false;
+  if (/outside project root|escapes the project root|path escapes/i.test(message)) return false;
+  if (/\bEACCES\b|\bEPERM\b|permission denied/i.test(message)) return false;
+  if (/queue is full|queue wait exceeded/i.test(message)) return false;
+  return /worker|memory limit|compiled code-intel worker/i.test(message);
+}
+function createFallbackCodeIntelProvider(primary, fallback = createLightweightCodeIntelProvider()) {
+  return {
+    async run(input, context) {
+      try {
+        return await primary.run(input, context);
+      } catch (error) {
+        const fallbackReason = codeIntelErrorMessage(error);
+        if (!shouldFallbackFromTypeScriptProvider(error)) throw error;
+        const result = await fallback.run(input, context);
+        return {
+          ...result,
+          text: `${result.text}
+
+[code_intel used lightweight fallback: ${fallbackReason}]`,
+          details: {
+            ...result.details,
+            provider: "lightweight_fallback",
+            fallbackReason
+          },
+          isError: result.isError
+        };
+      }
+    }
+  };
+}
 function createCodeIntelTool2(options) {
   return createCodeIntelTool({
     ...options,
-    provider: options.provider ?? createTypeScriptCodeIntelProvider()
+    provider: options.provider ?? createFallbackCodeIntelProvider(createTypeScriptCodeIntelProvider())
   });
 }
 
@@ -1107,19 +1144,9 @@ function createCliHostCapabilities(cwd, options = {}) {
     },
     {
       id: "web_research",
-      description: "End-to-end web research that searches, fetches credible sources, and returns citations.",
+      description: "Canonical web tool for research, direct URL fetch, and low-level search modes.",
       tools: [webResearchTool]
     },
-    {
-      id: "web_search",
-      description: "Provider-native web search for current information outside the local workspace.",
-      tools: [webSearchTool]
-    },
-    {
-      id: "web_fetch",
-      description: "Fetch and read a specific public web URL after a source has been found.",
-      tools: [webFetchTool]
-    },
     {
       id: "code_intel",
       description: "Read-only JS/TS code intelligence for diagnostics, definitions, references, symbols, and hover.",
@@ -1147,6 +1174,8 @@ export {
   getRuntimeLogPath,
   migrateConfigFromAgentDir,
   createCliWebResearchHealthStore,
+  truncateHeadTail,
+  formatSize,
   cleanupBashOutputArtifacts,
   createCliHostCapabilities
 };

package/dist/chunks/{test-stream-ZNGAUUVH.js → test-stream-A7JSM2UM.js}

@@ -39,13 +39,27 @@ function parseMockStreamSequence(value) {
       return {
         type: "error",
         error: record.error,
-        partialText: typeof record.partialText === "string" ? record.partialText : void 0
+        partialText: typeof record.partialText === "string" ? record.partialText : void 0,
+        delayMs: typeof record.delayMs === "number" ? Math.max(0, Math.min(record.delayMs, 3e4)) : void 0
       };
     }
     if (record.type === "text" && typeof record.text === "string") {
-      return { type: "text", text: record.text };
+      return {
+        type: "text",
+        text: record.text,
+        delayMs: typeof record.delayMs === "number" ? Math.max(0, Math.min(record.delayMs, 3e4)) : void 0
+      };
+    }
+    if (record.type === "toolCall" && typeof record.name === "string") {
+      return {
+        type: "toolCall",
+        id: typeof record.id === "string" ? record.id : void 0,
+        name: record.name,
+        arguments: record.arguments && typeof record.arguments === "object" && !Array.isArray(record.arguments) ? record.arguments : {},
+        delayMs: typeof record.delayMs === "number" ? Math.max(0, Math.min(record.delayMs, 3e4)) : void 0
+      };
     }
-    throw new Error("PIE_TEST_MOCK_STREAM_SEQUENCE entries must be text or error steps");
+    throw new Error("PIE_TEST_MOCK_STREAM_SEQUENCE entries must be text, toolCall, or error steps");
   });
 }
 function createTestStreamFnFromSequenceEnv(value = process.env.PIE_TEST_MOCK_STREAM_SEQUENCE) {
@@ -65,7 +79,7 @@ function createTestStreamFnFromSequenceEnv(value = process.env.PIE_TEST_MOCK_STR
         throw new Error("mock stream terminated without a terminal event");
       }
     );
-    queueMicrotask(() => {
+    const emit = () => {
       if (!step) {
         const message2 = createAssistantMessage(model, "");
         stream.push({ type: "done", reason: "stop", message: message2 });
@@ -83,13 +97,33 @@ function createTestStreamFnFromSequenceEnv(value = process.env.PIE_TEST_MOCK_STR
         stream.push({ type: "error", reason: "error", error });
         return;
       }
+      if (step.type === "toolCall") {
+        const message2 = createAssistantMessage(model, "", "toolUse");
+        const toolCall = {
+          type: "toolCall",
+          id: step.id || `mock-tool-${callIndex}`,
+          name: step.name,
+          arguments: step.arguments ?? {}
+        };
+        message2.content = [toolCall];
+        stream.push({ type: "start", partial: message2 });
+        stream.push({ type: "toolcall_start", contentIndex: 0, partial: message2 });
+        stream.push({ type: "toolcall_end", contentIndex: 0, toolCall, partial: message2 });
+        stream.push({ type: "done", reason: "toolUse", message: message2 });
+        return;
+      }
       const message = createAssistantMessage(model, step.text);
       stream.push({ type: "start", partial: message });
       stream.push({ type: "text_start", contentIndex: 0, partial: message });
       stream.push({ type: "text_delta", contentIndex: 0, delta: step.text, partial: message });
       stream.push({ type: "text_end", contentIndex: 0, content: step.text, partial: message });
       stream.push({ type: "done", reason: "stop", message });
-    });
+    };
+    if (step?.delayMs) {
+      setTimeout(emit, step.delayMs);
+    } else {
+      queueMicrotask(emit);
+    }
     return stream;
   };
 }