@skilder-ai/runtime 0.8.2 → 0.8.4

package/dist/index.js

@@ -87668,6 +87668,7 @@ var DEFAULT_OPTIMIZATION_INSIGHTS_LOOKBACK_SECONDS = 30 * 24 * 60 * 60;
 // ../common/src/constants.node.ts
 var MCP_CALL_TOOL_TIMEOUT = parseInt(process.env.MCP_CALL_TOOL_TIMEOUT ?? "10000", 10);
 var DEFAULT_REQUEST_TIMEOUT = parseInt(process.env.DEFAULT_REQUEST_TIMEOUT ?? "10000", 10);
+var SCRIPT_ROUTE_TIMEOUT_MS = 31e4;
 
 // ../../node_modules/.pnpm/bcryptjs@3.0.3/node_modules/bcryptjs/index.js
 var nextTick = typeof setImmediate === "function" ? setImmediate : typeof scheduler === "object" && typeof scheduler.postTask === "function" ? scheduler.postTask.bind(scheduler) : setTimeout;
@@ -144488,7 +144489,7 @@ For other resources, use the \`learn\` tool instead.`
       delegateDepth
     });
     try {
-      const response = await this.natsService.request(toolCallRequest, { timeout: MCP_CALL_TOOL_TIMEOUT });
+      const response = await this.natsService.request(toolCallRequest, { timeout: SCRIPT_ROUTE_TIMEOUT_MS });
       if (response instanceof ErrorResponse) {
         return {
           content: [{ type: "text", text: `Error: ${response.data.error}` }],
@@ -145958,7 +145959,8 @@ The path must point to a downloadable (binary) resource in a skill's related ite
     if (toolConfig.__routing.type === "static") {
       this.logger.debug(`Handling static tool ${toolConfig.__routing.toolName} for user ${this.identity.id}`);
       const { response, skillIds } = await this.handleStaticTool(toolConfig.__routing.toolName, args);
-      if (toolConfig.__routing.workspaceId) {
+      const isWrapperTool = toolConfig.__routing.toolName === "call_tool";
+      if (toolConfig.__routing.workspaceId && !isWrapperTool) {
         try {
           const message = SkillCallToolRequest.create({
             type: "static",
@@ -149850,12 +149852,29 @@ var ScriptExecutorService = class ScriptExecutorService2 {
           NODE_PATH: (0, import_path2.join)(tempDir, "node_modules")
         }
       });
+      const pendingIds = /* @__PURE__ */ new Set();
       let currentTimeout = timeout2;
       let lastExtendingMethod;
+      const killForTimeout = (reason) => {
+        const ids = Array.from(pendingIds);
+        pendingIds.clear();
+        for (const id of ids) {
+          writeFromKill(id, -32001, reason);
+        }
+        try {
+          child.stdin?.end();
+        } catch (err) {
+          this.logger.debug({ error: err }, "child.stdin.end() during killForTimeout failed");
+        }
+        setTimeout(() => {
+          if (!childExited)
+            child.kill("SIGKILL");
+        }, 250);
+      };
       let timeoutId = setTimeout(() => {
         killed = true;
-        child.kill("SIGKILL");
         this.logger.warn({ timeout: currentTimeout, method: lastExtendingMethod }, "Interactive script timed out");
+        killForTimeout(`Script timeout: runtime killed the script after ${currentTimeout}ms${lastExtendingMethod ? ` (last extending method: ${lastExtendingMethod})` : ""}.`);
       }, currentTimeout);
       const resetTimeout = (extraMs, method) => {
         clearTimeout(timeoutId);
@@ -149863,25 +149882,27 @@ var ScriptExecutorService = class ScriptExecutorService2 {
         const remaining = Math.min(extraMs, MAX_INTERACTIVE_SCRIPT_TIMEOUT_MS - elapsed);
         if (remaining <= 0) {
           killed = true;
-          child.kill("SIGKILL");
           this.logger.warn({ method }, "Interactive script exceeded max total timeout");
+          killForTimeout(`Script timeout: exceeded max total interactive timeout (${MAX_INTERACTIVE_SCRIPT_TIMEOUT_MS}ms)${method ? ` while waiting on ${method}` : ""}.`);
           return;
         }
         lastExtendingMethod = method;
         currentTimeout = remaining;
         timeoutId = setTimeout(() => {
           killed = true;
-          child.kill("SIGKILL");
           this.logger.warn({ timeout: currentTimeout, method: lastExtendingMethod }, "Interactive script timed out");
+          killForTimeout(`Script timeout: runtime killed the script after ${currentTimeout}ms${lastExtendingMethod ? ` (last extending method: ${lastExtendingMethod})` : ""}.`);
         }, currentTimeout);
       };
       const safeWrite = (data) => {
         if (childExited || !child.stdin?.writable)
-          return;
+          return false;
         try {
           child.stdin.write(data);
+          return true;
         } catch (err) {
           this.logger.debug({ error: err }, "Failed to write to child stdin (process may have exited)");
+          return false;
         }
       };
       const writeResponse = (id, result) => {
@@ -149890,6 +149911,12 @@ var ScriptExecutorService = class ScriptExecutorService2 {
       const writeError = (id, code, message) => {
         safeWrite(JSON.stringify({ jsonrpc: "2.0", error: { code, message }, id }) + "\n");
       };
+      const writeFromKill = (id, code, message) => {
+        const ok = safeWrite(JSON.stringify({ jsonrpc: "2.0", error: { code, message }, id }) + "\n");
+        if (!ok) {
+          this.logger.warn({ id, message, event: "script_timeout_error_frame_drop" }, "Failed to deliver timeout JSON-RPC error frame to script \u2014 SDK will fall back to generic IPC-closed message");
+        }
+      };
       const rl = (0, import_readline.createInterface)({ input: child.stdout, crlfDelay: Infinity });
       rl.on("line", (line) => {
         if (outputTruncated)
@@ -149917,6 +149944,7 @@ var ScriptExecutorService = class ScriptExecutorService2 {
           return;
         }
         inflightCount++;
+        pendingIds.add(msg.id);
         (async () => {
           try {
             if (msg.method === "delegate") {
@@ -149925,11 +149953,16 @@ var ScriptExecutorService = class ScriptExecutorService2 {
               resetTimeout(toolCallTimeout + timeout2, msg.method);
             }
             const result = await onRequest(msg.method, msg.params);
-            writeResponse(msg.id, result);
+            if (pendingIds.delete(msg.id)) {
+              writeResponse(msg.id, result);
+            }
           } catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            writeError(msg.id, -32e3, message);
+            if (pendingIds.delete(msg.id)) {
+              const message = err instanceof Error ? err.message : String(err);
+              writeError(msg.id, -32e3, message);
+            }
           } finally {
+            pendingIds.delete(msg.id);
             inflightCount--;
             if (inflightCount === 0 && inflightDone)
               inflightDone();
@@ -154158,7 +154191,7 @@ ${cleanError}` : cleanError;
           throw new Error("Invalid delegate params: expected { context: string, model?: string, temperature?: number }");
         }
         const { context: context2, model, temperature } = params;
-        return this.handleScriptDelegate(context2, model, temperature, workspaceId, userKey, delegateDepth);
+        return this.handleScriptDelegate(context2, model, temperature, workspaceId, userId, userKey, runtimeId, delegateDepth);
       }
       case "scripts/execute": {
         if (!params || typeof params !== "object" || typeof params.path !== "string") {
@@ -154248,7 +154281,7 @@ ${cleanError}` : cleanError;
    * Handle a delegate request from a TypeScript script via JSON-RPC IPC.
    * Spawns a sub-agent using DelegateService and returns the result as a CallToolResult.
    */
-  async handleScriptDelegate(context2, model, temperature, workspaceId, userKey, delegateDepth) {
+  async handleScriptDelegate(context2, model, temperature, workspaceId, userId, userKey, runtimeId, delegateDepth) {
     if (!this.delegateService) {
       this.logger.warn({ event: "delegate_service_unavailable" }, "Delegate requested but DelegateService not injected");
       return {
@@ -154261,14 +154294,51 @@ ${cleanError}` : cleanError;
         isError: true
       };
     }
-    return this.delegateService.execute({
-      context: context2,
-      model,
-      temperature,
-      workspaceId,
-      userKey,
-      delegateDepth: delegateDepth ?? 0
+    const publishMonitoring = (response) => {
+      try {
+        const message = new SkillCallToolRequest({
+          type: "static",
+          toolName: "delegate",
+          workspaceId,
+          from: runtimeId ?? "script",
+          userId,
+          userKey,
+          arguments: {
+            context: context2,
+            ...model !== void 0 && { model },
+            ...temperature !== void 0 && { temperature }
+          },
+          response,
+          delegateDepth
+        });
+        this.natsService.publish(message);
+      } catch (error48) {
+        this.logger.error({ err: error48, event: "script_delegate_publish_failed" }, "Failed to publish script delegate monitoring event");
+      }
+    };
+    let result;
+    try {
+      result = await this.delegateService.execute({
+        context: context2,
+        model,
+        temperature,
+        workspaceId,
+        userKey,
+        delegateDepth: delegateDepth ?? 0
+      });
+    } catch (error48) {
+      const message = error48 instanceof Error ? error48.message : String(error48);
+      publishMonitoring({
+        content: [{ type: "text", text: `Error: Delegate failed unexpectedly: ${message}` }],
+        isError: true
+      });
+      throw error48;
+    }
+    publishMonitoring({
+      content: result.content,
+      ...result.isError && { isError: true }
     });
+    return result;
   }
   /**
    * Route a tool call from a script to the appropriate MCP server via NATS.