pulse-coder-engine 0.0.1-alpha.10 → 0.0.1-alpha.11

package/dist/built-in/index.cjs

@@ -504,25 +504,6 @@ var BuiltInPlanModeService = class {
     }
     return lines.join("\n");
   }
-  applyHooks(baseHooks) {
-    return {
-      onBeforeToolCall: async (name, input) => {
-        this.observePotentialPolicyViolation(name, input);
-        if (baseHooks?.onBeforeToolCall) {
-          const nextInput = await baseHooks.onBeforeToolCall(name, input);
-          return nextInput ?? input;
-        }
-        return input;
-      },
-      onAfterToolCall: async (name, input, output) => {
-        if (baseHooks?.onAfterToolCall) {
-          const nextOutput = await baseHooks.onAfterToolCall(name, input, output);
-          return nextOutput ?? output;
-        }
-        return output;
-      }
-    };
-  }
   getEvents(limit = 50) {
     return this.events.slice(-Math.max(0, limit));
   }
@@ -659,21 +640,18 @@ var builtInPlanModePlugin = {
   version: "1.0.0",
   async initialize(context) {
     const service = new BuiltInPlanModeService(context.logger, context.events, "executing");
-    context.registerRunHook("plan-mode", ({ context: runContext, tools, systemPrompt, hooks }) => {
+    context.registerHook("beforeLLMCall", ({ context: runContext, tools, systemPrompt }) => {
       const mode = service.getMode();
       if (mode === "executing") {
-        return {
-          systemPrompt,
-          hooks
-        };
+        return;
       }
       const transition = service.processContextMessages(runContext.messages);
       const append = service.buildPromptAppend(Object.keys(tools), transition);
       const finalSystemPrompt = appendSystemPrompt(systemPrompt, append);
-      return {
-        systemPrompt: finalSystemPrompt,
-        hooks: service.applyHooks(hooks)
-      };
+      return { systemPrompt: finalSystemPrompt };
+    });
+    context.registerHook("beforeToolCall", ({ name, input }) => {
+      service.observePotentialPolicyViolation(name, input);
     });
     context.registerService("planMode", service);
     context.registerService("planModeService", service);
@@ -1047,15 +1025,28 @@ var maybeCompactContext = async (context, options) => {
 };
 
 // src/core/loop.ts
-function applyToolHooks(tools, hooks) {
+function wrapToolsWithHooks(tools, beforeHooks, afterHooks) {
   const wrapped = {};
   for (const [name, t] of Object.entries(tools)) {
     wrapped[name] = {
       ...t,
       execute: async (input, ctx) => {
-        const finalInput = hooks.onBeforeToolCall ? await hooks.onBeforeToolCall(name, input) ?? input : input;
+        let finalInput = input;
+        for (const hook of beforeHooks) {
+          const result = await hook({ name, input: finalInput });
+          if (result && "input" in result) {
+            finalInput = result.input;
+          }
+        }
         const output = await t.execute(finalInput, ctx);
-        return hooks.onAfterToolCall ? await hooks.onAfterToolCall(name, finalInput, output) ?? output : output;
+        let finalOutput = output;
+        for (const hook of afterHooks) {
+          const result = await hook({ name, input: finalInput, output: finalOutput });
+          if (result && "output" in result) {
+            finalOutput = result.output;
+          }
+        }
+        return finalOutput;
       }
     };
   }
@@ -1065,6 +1056,7 @@ async function loop(context, options) {
   let errorCount = 0;
   let totalSteps = 0;
   let compactionAttempts = 0;
+  const loopHooks = options?.hooks ?? {};
   while (true) {
     try {
       if (compactionAttempts < MAX_COMPACTION_ATTEMPTS) {
@@ -1081,8 +1073,24 @@ async function loop(context, options) {
         }
       }
       let tools = options?.tools || {};
-      if (options?.hooks) {
-        tools = applyToolHooks(tools, options.hooks);
+      let systemPrompt = options?.systemPrompt;
+      if (loopHooks.beforeLLMCall?.length) {
+        for (const hook of loopHooks.beforeLLMCall) {
+          const result2 = await hook({ context, systemPrompt, tools });
+          if (result2) {
+            if ("systemPrompt" in result2 && result2.systemPrompt !== void 0) {
+              systemPrompt = result2.systemPrompt;
+            }
+            if ("tools" in result2 && result2.tools !== void 0) {
+              tools = result2.tools;
+            }
+          }
+        }
+      }
+      const beforeToolHooks = loopHooks.beforeToolCall ?? [];
+      const afterToolHooks = loopHooks.afterToolCall ?? [];
+      if (beforeToolHooks.length || afterToolHooks.length) {
+        tools = wrapToolsWithHooks(tools, beforeToolHooks, afterToolHooks);
       }
       const toolExecutionContext = {
         onClarificationRequest: options?.onClarificationRequest,
@@ -1093,7 +1101,7 @@ async function loop(context, options) {
         toolExecutionContext,
         provider: options?.provider,
         model: options?.model,
-        systemPrompt: options?.systemPrompt,
+        systemPrompt,
         onStepFinish: (step) => {
           options?.onStepFinish?.(step);
         },
@@ -1121,6 +1129,11 @@ async function loop(context, options) {
           options?.onResponse?.(messages);
         }
       }
+      if (loopHooks.afterLLMCall?.length) {
+        for (const hook of loopHooks.afterLLMCall) {
+          await hook({ context, finishReason, text });
+        }
+      }
       if (finishReason === "stop") {
         return text || "Task completed.";
       }