@prompty/core 2.0.0-alpha.4 → 2.0.0-alpha.6

package/dist/index.cjs

@@ -4515,6 +4515,9 @@ var init_common = __esm({
 });
 
 // src/core/tool-dispatch.ts
+function registerTool(name, handler) {
+  nameRegistry.set(name, handler);
+}
 function getTool(name) {
   return nameRegistry.get(name);
 }
@@ -4538,12 +4541,12 @@ async function dispatchTool(toolName, args, userTools, agent, parentInputs) {
       const result = await registeredFn(args);
       return typeof result === "string" ? result : JSON.stringify(result);
     }
-    const tool = agent.tools?.find((t) => t.name === toolName);
-    if (!tool) {
+    const tool2 = agent.tools?.find((t) => t.name === toolName);
+    if (!tool2) {
       const available = Object.keys(userTools).sort().join(", ") || "(none)";
       return `Error: tool "${toolName}" not found in userTools or agent.tools. Available user tools: ${available}`;
     }
-    const kind = tool.kind || "*";
+    const kind = tool2.kind || "*";
     let handler;
     try {
       handler = getToolHandler(kind);
@@ -4555,7 +4558,7 @@ async function dispatchTool(toolName, args, userTools, agent, parentInputs) {
       }
     }
     return await handler.executeTool(
-      tool,
+      tool2,
       args,
       agent,
       parentInputs
@@ -4581,36 +4584,36 @@ var init_tool_dispatch = __esm({
     nameRegistry = /* @__PURE__ */ new Map();
     toolHandlers = /* @__PURE__ */ new Map();
     FunctionToolHandler = class {
-      async executeTool(tool, _args, _agent, _parentInputs) {
-        const name = tool.name ?? "unknown";
+      async executeTool(tool2, _args, _agent, _parentInputs) {
+        const name = tool2.name ?? "unknown";
         throw new Error(
-          `Function tool '${name}' declared but no callable provided. Pass it via tools: { '${name}': fn } in executeAgent().`
+          `Function tool '${name}' declared but no callable provided. Pass it via tools: { '${name}': fn } in invokeAgent().`
         );
       }
     };
     PromptyToolHandler = class {
-      async executeTool(tool, args, agent, _parentInputs) {
+      async executeTool(tool2, args, agent, _parentInputs) {
         const { load: load2 } = await Promise.resolve().then(() => (init_loader(), loader_exports));
-        const { prepare: prepare2, run: run2, executeAgent: executeAgent2 } = await Promise.resolve().then(() => (init_pipeline(), pipeline_exports));
+        const { prepare: prepare2, run: run2, invokeAgent: invokeAgent2 } = await Promise.resolve().then(() => (init_pipeline(), pipeline_exports));
         const parentPath = (agent.metadata ?? {}).__source_path;
         if (!parentPath) {
-          return `Error: cannot resolve PromptyTool '${tool.name}': parent has no __source_path`;
+          return `Error: cannot resolve PromptyTool '${tool2.name}': parent has no __source_path`;
         }
-        const childPath = (0, import_node_path2.resolve)((0, import_node_path2.dirname)(parentPath), tool.path);
+        const childPath = (0, import_node_path2.resolve)((0, import_node_path2.dirname)(parentPath), tool2.path);
         const stack = (agent.metadata ?? {}).__prompty_tool_stack ?? [];
         const normalizedChild = (0, import_node_path2.resolve)(childPath);
         const visited = /* @__PURE__ */ new Set([...stack.map((p) => (0, import_node_path2.resolve)(p)), (0, import_node_path2.resolve)(parentPath)]);
         if (visited.has(normalizedChild)) {
           const chain = [...stack, parentPath, childPath].join(" \u2192 ");
-          return `Error executing PromptyTool '${tool.name}': circular reference detected: ${chain}`;
+          return `Error executing PromptyTool '${tool2.name}': circular reference detected: ${chain}`;
         }
         try {
           const child = load2(childPath);
           if (!child.metadata) child.metadata = {};
           child.metadata.__prompty_tool_stack = [...stack, parentPath];
-          const mode = tool.mode ?? "single";
+          const mode = tool2.mode ?? "single";
           if (mode === "agentic") {
-            const result = await executeAgent2(child, args);
+            const result = await invokeAgent2(child, args);
             return typeof result === "string" ? result : JSON.stringify(result);
           } else {
             const messages = await prepare2(child, args);
@@ -4618,7 +4621,7 @@ var init_tool_dispatch = __esm({
             return typeof result === "string" ? result : JSON.stringify(result);
           }
         } catch (err) {
-          return `Error executing PromptyTool '${tool.name}': ${err instanceof Error ? err.message : String(err)}`;
+          return `Error executing PromptyTool '${tool2.name}': ${err instanceof Error ? err.message : String(err)}`;
         }
       }
     };
@@ -4645,18 +4648,216 @@ var init_tool_dispatch = __esm({
   }
 });
 
+// src/core/agent-events.ts
+function emitEvent(callback, eventType, data) {
+  if (!callback) return;
+  try {
+    callback(eventType, data);
+  } catch (err) {
+    if (typeof globalThis.console?.debug === "function") {
+      globalThis.console.debug(`Event callback error for ${eventType}:`, err);
+    }
+  }
+}
+var init_agent_events = __esm({
+  "src/core/agent-events.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/cancellation.ts
+function checkCancellation(signal) {
+  if (signal?.aborted) {
+    throw new CancelledError();
+  }
+}
+var CancelledError;
+var init_cancellation = __esm({
+  "src/core/cancellation.ts"() {
+    "use strict";
+    CancelledError = class extends Error {
+      constructor(message = "Agent loop cancelled") {
+        super(message);
+        this.name = "CancelledError";
+      }
+    };
+  }
+});
+
+// src/core/context.ts
+function estimateChars(messages) {
+  let total = 0;
+  for (const msg of messages) {
+    total += msg.role.length + 4;
+    for (const part of msg.parts) {
+      if (part.kind === "text") {
+        total += part.value.length;
+      } else {
+        total += 200;
+      }
+    }
+    const toolCalls = msg.metadata?.tool_calls;
+    if (toolCalls) {
+      total += JSON.stringify(toolCalls).length;
+    }
+  }
+  return total;
+}
+function truncate(text2, maxLen = 200) {
+  return text2.length <= maxLen ? text2 : text2.slice(0, maxLen) + "\u2026";
+}
+function summarizeDropped(messages) {
+  const lines = [];
+  for (const msg of messages) {
+    const msgText = msg.text.trim();
+    if (msg.role === "user" && msgText) {
+      lines.push(`User asked: ${truncate(msgText)}`);
+    } else if (msg.role === "assistant") {
+      if (msgText) lines.push(`Assistant: ${truncate(msgText)}`);
+      const toolCalls = msg.metadata?.tool_calls;
+      if (Array.isArray(toolCalls)) {
+        const names = toolCalls.map(
+          (tc) => tc.name ?? (tc.function?.name ?? "?")
+        );
+        lines.push(`  Called tools: ${names.join(", ")}`);
+      }
+    }
+  }
+  if (lines.length === 0) return "";
+  let result = "[Context summary: ";
+  for (const line of lines) {
+    if (result.length + line.length > 4e3) {
+      result += "\n... (older messages omitted)";
+      break;
+    }
+    result += line + "\n";
+  }
+  return result.trimEnd() + "]";
+}
+function trimToContextWindow(messages, budgetChars) {
+  if (estimateChars(messages) <= budgetChars) {
+    return [0, []];
+  }
+  let systemEnd = 0;
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i].role !== "system") {
+      systemEnd = i;
+      break;
+    }
+    if (i === messages.length - 1) systemEnd = messages.length;
+  }
+  const systemMsgs = messages.slice(0, systemEnd);
+  const rest = messages.slice(systemEnd);
+  const summaryBudget = Math.min(5e3, Math.floor(budgetChars * 0.05));
+  const dropped = [];
+  while (estimateChars([...systemMsgs, ...rest]) > budgetChars - summaryBudget && rest.length > 2) {
+    dropped.push(rest.shift());
+  }
+  const droppedCount = dropped.length;
+  messages.length = 0;
+  messages.push(...systemMsgs);
+  if (droppedCount > 0) {
+    const summaryText = summarizeDropped(dropped);
+    if (summaryText) {
+      messages.push(new Message("user", [{ kind: "text", value: summaryText }]));
+    }
+  }
+  messages.push(...rest);
+  return [droppedCount, dropped];
+}
+var init_context2 = __esm({
+  "src/core/context.ts"() {
+    "use strict";
+    init_types();
+  }
+});
+
+// src/core/guardrails.ts
+var GuardrailError, Guardrails;
+var init_guardrails = __esm({
+  "src/core/guardrails.ts"() {
+    "use strict";
+    GuardrailError = class extends Error {
+      reason;
+      constructor(reason) {
+        super(`Guardrail denied: ${reason}`);
+        this.name = "GuardrailError";
+        this.reason = reason;
+      }
+    };
+    Guardrails = class {
+      inputHook;
+      outputHook;
+      toolHook;
+      constructor(options) {
+        this.inputHook = options?.input;
+        this.outputHook = options?.output;
+        this.toolHook = options?.tool;
+      }
+      checkInput(messages) {
+        if (!this.inputHook) return { allowed: true };
+        return this.inputHook(messages);
+      }
+      checkOutput(message) {
+        if (!this.outputHook) return { allowed: true };
+        return this.outputHook(message);
+      }
+      checkTool(name, args) {
+        if (!this.toolHook) return { allowed: true };
+        return this.toolHook(name, args);
+      }
+    };
+  }
+});
+
+// src/core/structured.ts
+function createStructuredResult(data, rawJson) {
+  const result = { ...data };
+  Object.defineProperty(result, StructuredResultSymbol, {
+    value: rawJson,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+  return result;
+}
+function isStructuredResult(value) {
+  return typeof value === "object" && value !== null && StructuredResultSymbol in value;
+}
+function cast(result, validator) {
+  let jsonStr;
+  if (isStructuredResult(result)) {
+    jsonStr = result[StructuredResultSymbol];
+  } else if (typeof result === "string") {
+    jsonStr = result;
+  } else {
+    jsonStr = JSON.stringify(result);
+  }
+  const parsed = JSON.parse(jsonStr);
+  if (validator) {
+    return validator(parsed);
+  }
+  return parsed;
+}
+var StructuredResultSymbol;
+var init_structured = __esm({
+  "src/core/structured.ts"() {
+    "use strict";
+    StructuredResultSymbol = /* @__PURE__ */ Symbol("prompty.rawJson");
+  }
+});
+
 // src/core/pipeline.ts
 var pipeline_exports = {};
 __export(pipeline_exports, {
-  execute: () => execute,
-  executeAgent: () => executeAgent,
+  invoke: () => invoke,
+  invokeAgent: () => invokeAgent,
   parse: () => parse,
   prepare: () => prepare,
   process: () => process2,
   render: () => render,
   resolveBindings: () => resolveBindings,
   run: () => run,
-  runAgent: () => runAgent,
   validateInputs: () => validateInputs
 });
 function sanitizeNonces(value) {
@@ -4833,8 +5034,8 @@ async function run(agent, messages, options) {
     return result;
   });
 }
-async function execute(prompt, inputs, options) {
-  return traceSpan("execute", async (emit) => {
+async function invoke(prompt, inputs, options) {
+  return traceSpan("invoke", async (emit) => {
     const agent = typeof prompt === "string" ? await traceSpan("load", async (loadEmit) => {
       loadEmit("signature", "prompty.load");
       loadEmit("description", "Load a prompty file.");
@@ -4843,12 +5044,15 @@ async function execute(prompt, inputs, options) {
       loadEmit("result", serializeAgent(loaded));
       return loaded;
     }) : prompt;
-    emit("signature", "prompty.execute");
-    emit("description", "Execute a prompty");
+    emit("signature", "prompty.invoke");
+    emit("description", "Invoke a prompty");
     emit("inputs", { prompt: serializeAgent(agent), inputs: inputs ?? {} });
     const messages = await prepare(agent, inputs);
     const result = await run(agent, messages, options);
     emit("result", result);
+    if (options?.validator) {
+      return cast(result, options.validator);
+    }
     return result;
   });
 }
@@ -4870,7 +5074,7 @@ function isAsyncIterable(value) {
 function isToolCallLike(item) {
   return typeof item === "object" && item !== null && "id" in item && "name" in item && "arguments" in item;
 }
-async function consumeStream(agent, response) {
+async function consumeStream(agent, response, onEvent) {
   const processed = await process2(agent, response);
   const toolCalls = [];
   const textParts = [];
@@ -4880,96 +5084,17 @@ async function consumeStream(agent, response) {
         toolCalls.push(item);
       } else if (typeof item === "string") {
         textParts.push(item);
+        emitEvent(onEvent, "token", { token: item });
       }
     }
   } else if (typeof processed === "string") {
     textParts.push(processed);
+    emitEvent(onEvent, "token", { token: processed });
   }
   return { toolCalls, content: textParts.join("") };
 }
-async function buildToolMessagesFromCalls(toolCalls, textContent, tools, agent, parentInputs, parentEmit) {
-  const provider = resolveProvider(agent);
-  const apiType = agent.model?.apiType || "chat";
-  const messages = [];
-  const toolInputs = [];
-  if (provider === "anthropic") {
-    const rawContent = [];
-    if (textContent) rawContent.push({ type: "text", text: textContent });
-    for (const tc of toolCalls) {
-      rawContent.push({
-        type: "tool_use",
-        id: tc.id,
-        name: tc.name,
-        input: JSON.parse(tc.arguments)
-      });
-    }
-    messages.push(
-      new Message("assistant", textContent ? [text(textContent)] : [], { content: rawContent })
-    );
-  } else if (apiType === "responses") {
-    for (const tc of toolCalls) {
-      messages.push(
-        new Message("assistant", [], {
-          responses_function_call: {
-            type: "function_call",
-            call_id: tc.id,
-            name: tc.name,
-            arguments: tc.arguments
-          }
-        })
-      );
-    }
-  } else {
-    const rawToolCalls = toolCalls.map((tc) => ({
-      id: tc.id,
-      type: "function",
-      function: { name: tc.name, arguments: tc.arguments }
-    }));
-    messages.push(
-      new Message("assistant", textContent ? [text(textContent)] : [], {
-        tool_calls: rawToolCalls
-      })
-    );
-  }
-  const toolResultBlocks = [];
-  for (const tc of toolCalls) {
-    let result;
-    let parsedArgs;
-    try {
-      parsedArgs = JSON.parse(tc.arguments);
-      if (parentInputs && typeof parsedArgs === "object" && parsedArgs !== null && !Array.isArray(parsedArgs)) {
-        parsedArgs = resolveBindings(agent, tc.name, parsedArgs, parentInputs);
-      }
-      result = await traceSpan(tc.name, async (toolEmit) => {
-        toolEmit("signature", `prompty.tool.${tc.name}`);
-        toolEmit("description", `Execute tool: ${tc.name}`);
-        toolEmit("inputs", { arguments: parsedArgs, id: tc.id });
-        const r = await dispatchTool(tc.name, parsedArgs, tools, agent, parentInputs ?? {});
-        toolEmit("result", r);
-        return r;
-      });
-    } catch (err) {
-      result = `Error: ${err instanceof Error ? err.message : String(err)}`;
-    }
-    toolInputs.push({ name: tc.name, arguments: parsedArgs, id: tc.id, result });
-    if (provider === "anthropic") {
-      toolResultBlocks.push({ type: "tool_result", tool_use_id: tc.id, content: result });
-    } else {
-      messages.push(
-        new Message("tool", [text(result)], { tool_call_id: tc.id, name: tc.name })
-      );
-    }
-  }
-  if (provider === "anthropic" && toolResultBlocks.length > 0) {
-    messages.push(new Message("user", [], { tool_results: toolResultBlocks }));
-  }
-  if (parentEmit) {
-    parentEmit("inputs", { tool_calls: toolInputs });
-  }
-  return messages;
-}
-async function executeAgent(prompt, inputs, options) {
-  return traceSpan("executeAgent", async (emit) => {
+async function invokeAgent(prompt, inputs, options) {
+  const rawResult = await traceSpan("invokeAgent", async (emit) => {
     const agent = typeof prompt === "string" ? await traceSpan("load", async (loadEmit) => {
       loadEmit("signature", "prompty.load");
       loadEmit("description", "Load a prompty file.");
@@ -4980,21 +5105,72 @@ async function executeAgent(prompt, inputs, options) {
     }) : prompt;
     const tools = options?.tools ?? {};
     const maxIterations = options?.maxIterations ?? DEFAULT_MAX_ITERATIONS;
-    emit("signature", "prompty.executeAgent");
-    emit("description", "Execute a prompty with tool calling");
+    const onEvent = options?.onEvent;
+    const signal = options?.signal;
+    const contextBudget = options?.contextBudget;
+    const guardrails = options?.guardrails;
+    const steering = options?.steering;
+    const parallelToolCalls = options?.parallelToolCalls ?? false;
+    emit("signature", "prompty.invokeAgent");
+    emit("description", "Invoke a prompty with tool calling");
     emit("inputs", { prompt: serializeAgent(agent), tools: Object.keys(tools), inputs: inputs ?? {} });
-    const messages = await prepare(agent, inputs);
+    let messages = await prepare(agent, inputs);
     const parentInputs = inputs ?? {};
     const provider = resolveProvider(agent);
     const executor = getExecutor(provider);
-    let response = await executor.execute(agent, messages);
+    let response = null;
     let iteration = 0;
     while (true) {
+      try {
+        checkCancellation(signal);
+      } catch (err) {
+        emitEvent(onEvent, "cancelled", {});
+        throw err;
+      }
+      if (steering) {
+        const pending = steering.drain();
+        if (pending.length > 0) {
+          messages.push(...pending);
+          emitEvent(onEvent, "messages_updated", { messages });
+          emitEvent(onEvent, "status", { message: `Injected ${pending.length} steering message(s)` });
+        }
+      }
+      if (contextBudget !== void 0) {
+        const [droppedCount] = trimToContextWindow(messages, contextBudget);
+        if (droppedCount > 0) {
+          emitEvent(onEvent, "messages_updated", { messages });
+          emitEvent(onEvent, "status", { message: `Trimmed ${droppedCount} messages for context budget` });
+        }
+      }
+      if (guardrails) {
+        const result2 = guardrails.checkInput(messages);
+        if (!result2.allowed) {
+          emitEvent(onEvent, "error", { message: `Input guardrail denied: ${result2.reason}` });
+          throw new GuardrailError(result2.reason ?? "Input guardrail denied");
+        }
+        if (result2.rewrite) messages = result2.rewrite;
+      }
+      try {
+        checkCancellation(signal);
+      } catch (err) {
+        emitEvent(onEvent, "cancelled", {});
+        throw err;
+      }
+      response = await executor.execute(agent, messages);
       if (isAsyncIterable(response)) {
-        const { toolCalls, content } = await consumeStream(agent, response);
+        const { toolCalls, content } = await consumeStream(agent, response, onEvent);
+        if (guardrails && content) {
+          const assistantMsg = new Message("assistant", [text(content)]);
+          const gr = guardrails.checkOutput(assistantMsg);
+          if (!gr.allowed) {
+            emitEvent(onEvent, "error", { message: `Output guardrail denied: ${gr.reason}` });
+            throw new GuardrailError(gr.reason ?? "Output guardrail denied");
+          }
+        }
         if (toolCalls.length === 0) {
           emit("iterations", iteration);
           emit("result", content);
+          emitEvent(onEvent, "done", { response: content, messages });
           return content;
         }
         iteration++;
@@ -5004,17 +5180,57 @@ async function executeAgent(prompt, inputs, options) {
           );
         }
         const toolMessages2 = await traceSpan("toolCalls", async (toolEmit) => {
-          toolEmit("signature", "prompty.executeAgent.toolCalls");
+          toolEmit("signature", "prompty.invokeAgent.toolCalls");
           toolEmit("description", `Tool call round ${iteration}`);
-          const result2 = await buildToolMessagesFromCalls(toolCalls, content, tools, agent, parentInputs, toolEmit);
+          const result2 = await buildToolMessagesFromCallsWithExtensions(
+            toolCalls,
+            content,
+            tools,
+            agent,
+            parentInputs,
+            toolEmit,
+            { onEvent, signal, guardrails, parallel: parallelToolCalls }
+          );
           toolEmit("result", result2.map((m) => ({ role: m.role, content: m.parts.map((p) => p.value ?? "").join(""), metadata: m.metadata })));
           return result2;
         });
         messages.push(...toolMessages2);
-        response = await executor.execute(agent, messages);
+        emitEvent(onEvent, "messages_updated", { messages });
         continue;
       }
-      if (!hasToolCalls(response)) break;
+      if (!hasToolCalls(response)) {
+        const finalResult = options?.raw ? response : await process2(agent, response);
+        if (guardrails) {
+          const contentStr = typeof finalResult === "string" ? finalResult : JSON.stringify(finalResult);
+          const assistantMsg = new Message("assistant", [text(contentStr)]);
+          const gr = guardrails.checkOutput(assistantMsg);
+          if (!gr.allowed) {
+            emitEvent(onEvent, "error", { message: `Output guardrail denied: ${gr.reason}` });
+            throw new GuardrailError(gr.reason ?? "Output guardrail denied");
+          }
+          if (gr.rewrite !== void 0) {
+            emit("iterations", iteration);
+            emit("result", gr.rewrite);
+            emitEvent(onEvent, "done", { response: gr.rewrite, messages });
+            return gr.rewrite;
+          }
+        }
+        emit("iterations", iteration);
+        emit("result", finalResult);
+        emitEvent(onEvent, "done", { response: finalResult, messages });
+        return finalResult;
+      }
+      if (guardrails) {
+        const { textContent } = extractToolInfo(response);
+        if (textContent) {
+          const assistantMsg = new Message("assistant", [text(textContent)]);
+          const gr = guardrails.checkOutput(assistantMsg);
+          if (!gr.allowed) {
+            emitEvent(onEvent, "error", { message: `Output guardrail denied: ${gr.reason}` });
+            throw new GuardrailError(gr.reason ?? "Output guardrail denied");
+          }
+        }
+      }
       iteration++;
       if (iteration > maxIterations) {
         throw new Error(
@@ -5022,24 +5238,37 @@ async function executeAgent(prompt, inputs, options) {
         );
       }
       const toolMessages = await traceSpan("toolCalls", async (toolEmit) => {
-        toolEmit("signature", "prompty.executeAgent.toolCalls");
+        toolEmit("signature", "prompty.invokeAgent.toolCalls");
         toolEmit("description", `Tool call round ${iteration}`);
-        const result2 = await buildToolResultMessages(response, tools, agent, parentInputs, toolEmit);
+        const result2 = await buildToolResultMessagesWithExtensions(
+          response,
+          tools,
+          agent,
+          parentInputs,
+          toolEmit,
+          { onEvent, signal, guardrails, parallel: parallelToolCalls }
+        );
         toolEmit("result", result2.map((m) => ({ role: m.role, content: m.parts.map((p) => p.value ?? "").join(""), metadata: m.metadata })));
         return result2;
       });
       messages.push(...toolMessages);
-      response = await executor.execute(agent, messages);
+      emitEvent(onEvent, "messages_updated", { messages });
     }
     emit("iterations", iteration);
     if (options?.raw) {
       emit("result", response);
+      emitEvent(onEvent, "done", { response, messages });
       return response;
     }
     const result = await process2(agent, response);
     emit("result", result);
+    emitEvent(onEvent, "done", { response: result, messages });
     return result;
   });
+  if (options?.validator) {
+    return cast(rawResult, options.validator);
+  }
+  return rawResult;
 }
 function expandThreads(messages, nonces, inputs) {
   if (nonces.size === 0) return messages;
@@ -5108,160 +5337,138 @@ function hasToolCalls(response) {
   }
   return false;
 }
-async function buildToolResultMessages(response, tools, agent, parentInputs, parentEmit) {
+function extractToolInfo(response) {
+  if (typeof response !== "object" || response === null) {
+    return { toolCalls: [], textContent: "" };
+  }
   const r = response;
   if (Array.isArray(r.content) && r.stop_reason === "tool_use") {
-    return buildAnthropicToolResultMessages(r, tools, agent, parentInputs, parentEmit);
+    const content = r.content;
+    const toolCalls = content.filter((b) => b.type === "tool_use").map((b) => ({
+      id: b.id,
+      name: b.name,
+      arguments: JSON.stringify(b.input)
+    }));
+    const textContent = content.filter((b) => b.type === "text").map((b) => b.text).join("");
+    return { toolCalls, textContent };
   }
   if (r.object === "response" && Array.isArray(r.output)) {
-    return buildResponsesToolResultMessages(r, tools, agent, parentInputs, parentEmit);
+    const funcCalls = r.output.filter(
+      (item) => item.type === "function_call"
+    );
+    const toolCalls = funcCalls.map((fc) => ({
+      id: fc.call_id ?? fc.id ?? "",
+      call_id: fc.call_id ?? fc.id ?? "",
+      name: fc.name,
+      arguments: fc.arguments ?? "{}"
+    }));
+    return { toolCalls, textContent: "" };
   }
-  return buildOpenAIToolResultMessages(r, tools, agent, parentInputs, parentEmit);
-}
-async function buildOpenAIToolResultMessages(r, tools, agent, parentInputs, parentEmit) {
   const choices = r.choices;
-  const choice = choices[0];
-  const message = choice.message;
-  const toolCalls = message.tool_calls;
-  const messages = [];
-  const assistantContent = message.content ?? "";
-  messages.push(
-    new Message("assistant", assistantContent ? [text(assistantContent)] : [], {
-      tool_calls: toolCalls
-    })
-  );
-  const toolInputs = [];
-  for (const tc of toolCalls) {
-    const fn = tc.function;
-    const toolName = fn.name;
-    const toolCallId = tc.id;
-    let result;
-    let parsedArgs;
-    try {
-      parsedArgs = JSON.parse(fn.arguments);
-      if (agent && parentInputs && typeof parsedArgs === "object" && parsedArgs !== null && !Array.isArray(parsedArgs)) {
-        parsedArgs = resolveBindings(agent, toolName, parsedArgs, parentInputs);
-      }
-      result = await traceSpan(toolName, async (toolEmit) => {
-        toolEmit("signature", `prompty.tool.${toolName}`);
-        toolEmit("description", `Execute tool: ${toolName}`);
-        toolEmit("inputs", { arguments: parsedArgs, tool_call_id: toolCallId });
-        const r2 = await dispatchTool(toolName, parsedArgs, tools, agent ?? {}, parentInputs ?? {});
-        toolEmit("result", r2);
-        return r2;
+  if (Array.isArray(choices) && choices.length > 0) {
+    const choice = choices[0];
+    const message = choice.message;
+    if (message && Array.isArray(message.tool_calls)) {
+      const toolCalls = message.tool_calls.map((tc) => {
+        const fn = tc.function;
+        return {
+          id: tc.id,
+          name: fn.name,
+          arguments: fn.arguments
+        };
       });
-    } catch (err) {
-      result = `Error: ${err instanceof Error ? err.message : String(err)}`;
+      return { toolCalls, textContent: message.content ?? "" };
     }
-    toolInputs.push({ name: toolName, arguments: parsedArgs, tool_call_id: toolCallId, result });
-    messages.push(
-      new Message("tool", [text(result)], {
-        tool_call_id: toolCallId,
-        name: toolName
-      })
-    );
-  }
-  if (parentEmit) {
-    parentEmit("inputs", { tool_calls: toolInputs });
   }
-  return messages;
+  return { toolCalls: [], textContent: "" };
 }
-async function buildAnthropicToolResultMessages(r, tools, agent, parentInputs, parentEmit) {
-  const content = r.content;
-  const toolUseBlocks = content.filter((block) => block.type === "tool_use");
-  const messages = [];
-  const textParts = content.filter((block) => block.type === "text").map((block) => text(block.text));
-  messages.push(
-    new Message("assistant", textParts, { content })
-  );
-  const toolInputs = [];
-  const toolResultBlocks = [];
-  for (const block of toolUseBlocks) {
-    const toolName = block.name;
-    const toolCallId = block.id;
-    let toolArgs = block.input;
-    if (agent && parentInputs && typeof toolArgs === "object" && toolArgs !== null && !Array.isArray(toolArgs)) {
-      toolArgs = resolveBindings(agent, toolName, toolArgs, parentInputs);
-    }
-    let result;
+async function dispatchOneToolWithExtensions(tc, tools, agent, parentInputs, ext) {
+  const { onEvent, signal, guardrails } = ext;
+  try {
+    checkCancellation(signal);
+  } catch (err) {
+    emitEvent(onEvent, "cancelled", {});
+    throw err;
+  }
+  emitEvent(onEvent, "tool_call_start", { name: tc.name, arguments: tc.arguments });
+  if (guardrails) {
+    let parsedArgs2 = {};
     try {
-      result = await traceSpan(toolName, async (toolEmit) => {
-        toolEmit("signature", `prompty.tool.${toolName}`);
-        toolEmit("description", `Execute tool: ${toolName}`);
-        toolEmit("inputs", { arguments: toolArgs, tool_use_id: toolCallId });
-        const r2 = await dispatchTool(toolName, toolArgs, tools, agent ?? {}, parentInputs ?? {});
-        toolEmit("result", r2);
-        return r2;
-      });
-    } catch (err) {
-      result = `Error: ${err instanceof Error ? err.message : String(err)}`;
+      const parsed = JSON.parse(tc.arguments);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        parsedArgs2 = parsed;
+      }
+    } catch {
+    }
+    const gr = guardrails.checkTool(tc.name, parsedArgs2);
+    if (!gr.allowed) {
+      const deniedMsg = `Tool denied by guardrail: ${gr.reason}`;
+      emitEvent(onEvent, "tool_result", { name: tc.name, result: deniedMsg });
+      return deniedMsg;
+    }
+    if (gr.rewrite !== void 0) {
+      tc = { ...tc, arguments: typeof gr.rewrite === "string" ? gr.rewrite : JSON.stringify(gr.rewrite) };
     }
-    toolInputs.push({ name: toolName, arguments: toolArgs, tool_use_id: toolCallId, result });
-    toolResultBlocks.push({
-      type: "tool_result",
-      tool_use_id: toolCallId,
-      content: result
-    });
   }
-  if (parentEmit) {
-    parentEmit("inputs", { tool_calls: toolInputs });
+  let result;
+  let parsedArgs;
+  try {
+    parsedArgs = JSON.parse(tc.arguments);
+    if (agent && parentInputs && typeof parsedArgs === "object" && parsedArgs !== null && !Array.isArray(parsedArgs)) {
+      parsedArgs = resolveBindings(agent, tc.name, parsedArgs, parentInputs);
+    }
+    result = await traceSpan(tc.name, async (toolEmit) => {
+      toolEmit("signature", `prompty.tool.${tc.name}`);
+      toolEmit("description", `Execute tool: ${tc.name}`);
+      toolEmit("inputs", { arguments: parsedArgs, id: tc.id });
+      const r = await dispatchTool(tc.name, parsedArgs, tools, agent, parentInputs);
+      toolEmit("result", r);
+      return r;
+    });
+  } catch (err) {
+    if (err instanceof CancelledError) throw err;
+    result = `Error: ${err instanceof Error ? err.message : String(err)}`;
   }
-  messages.push(
-    new Message("user", [], { tool_results: toolResultBlocks })
-  );
-  return messages;
+  emitEvent(onEvent, "tool_result", { name: tc.name, result });
+  return result;
 }
-async function buildResponsesToolResultMessages(r, tools, agent, parentInputs, parentEmit) {
-  const output = r.output;
-  const funcCalls = output.filter((item) => item.type === "function_call");
-  const messages = [];
-  const toolInputs = [];
-  for (const fc of funcCalls) {
-    const toolName = fc.name;
-    const callId = fc.call_id ?? fc.id ?? "";
-    const argsStr = fc.arguments ?? "{}";
-    messages.push(
-      new Message("assistant", [], {
-        responses_function_call: {
-          type: "function_call",
-          call_id: callId,
-          name: toolName,
-          arguments: argsStr
-        }
-      })
-    );
-    let result;
-    let parsedArgs;
-    try {
-      parsedArgs = JSON.parse(argsStr);
-      if (agent && parentInputs && typeof parsedArgs === "object" && parsedArgs !== null && !Array.isArray(parsedArgs)) {
-        parsedArgs = resolveBindings(agent, toolName, parsedArgs, parentInputs);
-      }
-      result = await traceSpan(toolName, async (toolEmit) => {
-        toolEmit("signature", `prompty.tool.${toolName}`);
-        toolEmit("description", `Execute tool: ${toolName}`);
-        toolEmit("inputs", { arguments: parsedArgs, call_id: callId });
-        const r2 = await dispatchTool(toolName, parsedArgs, tools, agent ?? {}, parentInputs ?? {});
-        toolEmit("result", r2);
-        return r2;
-      });
-    } catch (err) {
-      result = `Error: ${err instanceof Error ? err.message : String(err)}`;
-    }
-    toolInputs.push({ name: toolName, arguments: parsedArgs, call_id: callId, result });
-    messages.push(
-      new Message("tool", [text(result)], {
-        tool_call_id: callId,
-        name: toolName
-      })
+async function dispatchToolsWithExtensions(toolCalls, tools, agent, parentInputs, ext) {
+  if (ext.parallel && toolCalls.length > 1) {
+    return Promise.all(
+      toolCalls.map((tc) => dispatchOneToolWithExtensions(tc, tools, agent, parentInputs, ext))
     );
   }
+  const results = [];
+  for (const tc of toolCalls) {
+    results.push(await dispatchOneToolWithExtensions(tc, tools, agent, parentInputs, ext));
+  }
+  return results;
+}
+async function buildToolResultMessagesWithExtensions(response, tools, agent, parentInputs, parentEmit, ext) {
+  const { toolCalls, textContent } = extractToolInfo(response);
+  const toolResults = await dispatchToolsWithExtensions(toolCalls, tools, agent, parentInputs, ext);
+  if (parentEmit) {
+    parentEmit("inputs", {
+      tool_calls: toolCalls.map((tc, i) => ({ name: tc.name, arguments: tc.arguments, id: tc.id, result: toolResults[i] }))
+    });
+  }
+  const provider = resolveProvider(agent);
+  const executor = getExecutor(provider);
+  return executor.formatToolMessages(response, toolCalls, toolResults, textContent);
+}
+async function buildToolMessagesFromCallsWithExtensions(toolCalls, textContent, tools, agent, parentInputs, parentEmit, ext) {
+  const normalizedCalls = toolCalls.map((tc) => ({ id: tc.id, name: tc.name, arguments: tc.arguments }));
+  const toolResults = await dispatchToolsWithExtensions(normalizedCalls, tools, agent, parentInputs, ext);
   if (parentEmit) {
-    parentEmit("inputs", { tool_calls: toolInputs });
+    parentEmit("inputs", {
+      tool_calls: normalizedCalls.map((tc, i) => ({ name: tc.name, arguments: tc.arguments, id: tc.id, result: toolResults[i] }))
+    });
   }
-  return messages;
+  const provider = resolveProvider(agent);
+  const executor = getExecutor(provider);
+  return executor.formatToolMessages(null, normalizedCalls, toolResults, textContent);
 }
-var DEFAULT_FORMAT, DEFAULT_PARSER, DEFAULT_PROVIDER, DEFAULT_MAX_ITERATIONS, runAgent;
+var DEFAULT_FORMAT, DEFAULT_PARSER, DEFAULT_PROVIDER, DEFAULT_MAX_ITERATIONS;
 var init_pipeline = __esm({
   "src/core/pipeline.ts"() {
     "use strict";
@@ -5271,11 +5478,15 @@ var init_pipeline = __esm({
     init_tracer();
     init_loader();
     init_tool_dispatch();
+    init_agent_events();
+    init_cancellation();
+    init_context2();
+    init_guardrails();
+    init_structured();
     DEFAULT_FORMAT = "nunjucks";
     DEFAULT_PARSER = "prompty";
     DEFAULT_PROVIDER = "openai";
     DEFAULT_MAX_ITERATIONS = 10;
-    runAgent = executeAgent;
   }
 });
 
@@ -5287,11 +5498,14 @@ __export(index_exports, {
   ApiKeyConnection: () => ApiKeyConnection,
   ArrayProperty: () => ArrayProperty,
   Binding: () => Binding,
+  CancelledError: () => CancelledError,
   Connection: () => Connection,
   CustomTool: () => CustomTool,
   FormatConfig: () => FormatConfig,
   FoundryConnection: () => FoundryConnection,
   FunctionTool: () => FunctionTool,
+  GuardrailError: () => GuardrailError,
+  Guardrails: () => Guardrails,
   InvokerError: () => InvokerError,
   LoadContext: () => LoadContext,
   McpApprovalMode: () => McpApprovalMode,
@@ -5317,22 +5531,31 @@ __export(index_exports, {
   ReferenceConnection: () => ReferenceConnection,
   RemoteConnection: () => RemoteConnection,
   SaveContext: () => SaveContext,
+  Steering: () => Steering,
+  StructuredResultSymbol: () => StructuredResultSymbol,
   Template: () => Template,
   ThreadMarker: () => ThreadMarker,
   Tool: () => Tool,
   Tracer: () => Tracer,
+  bindTools: () => bindTools,
+  cast: () => cast,
+  checkCancellation: () => checkCancellation,
   clearCache: () => clearCache,
   clearConnections: () => clearConnections,
   consoleTracer: () => consoleTracer,
+  createStructuredResult: () => createStructuredResult,
   dictContentToPart: () => dictContentToPart,
   dictToMessage: () => dictToMessage,
-  execute: () => execute,
-  executeAgent: () => executeAgent,
+  emitEvent: () => emitEvent,
+  estimateChars: () => estimateChars,
   getConnection: () => getConnection,
   getExecutor: () => getExecutor,
   getParser: () => getParser,
   getProcessor: () => getProcessor,
   getRenderer: () => getRenderer,
+  invoke: () => invoke,
+  invokeAgent: () => invokeAgent,
+  isStructuredResult: () => isStructuredResult,
   load: () => load,
   otelTracer: () => otelTracer,
   parse: () => parse,
@@ -5346,14 +5569,16 @@ __export(index_exports, {
   render: () => render,
   resolveBindings: () => resolveBindings,
   run: () => run,
-  runAgent: () => runAgent,
   sanitizeValue: () => sanitizeValue,
+  summarizeDropped: () => summarizeDropped,
   text: () => text,
   textMessage: () => textMessage,
   toSerializable: () => toSerializable,
+  tool: () => tool,
   trace: () => trace,
   traceMethod: () => traceMethod,
   traceSpan: () => traceSpan,
+  trimToContextWindow: () => trimToContextWindow,
   validateInputs: () => validateInputs
 });
 module.exports = __toCommonJS(index_exports);
@@ -5384,6 +5609,101 @@ function clearConnections() {
 init_loader();
 init_pipeline();
 init_tool_dispatch();
+init_agent_events();
+init_cancellation();
+init_context2();
+init_guardrails();
+
+// src/core/steering.ts
+init_types();
+var Steering = class {
+  queue = [];
+  /** Enqueue a message to be injected at the next iteration. */
+  send(message) {
+    this.queue.push(message);
+  }
+  /** Remove and return all queued messages as Message objects. */
+  drain() {
+    const items = this.queue.splice(0);
+    return items.map((text2) => new Message("user", [{ kind: "text", value: text2 }]));
+  }
+  /** Whether there are pending messages without consuming them. */
+  get hasPending() {
+    return this.queue.length > 0;
+  }
+};
+
+// src/core/tool-decorator.ts
+init_tool();
+init_property();
+init_tool_dispatch();
+function tool(fn, options) {
+  const toolName = options?.name ?? fn.name;
+  const toolDesc = options?.description ?? "";
+  const shouldRegister = options?.register !== false;
+  const properties = (options?.parameters ?? []).map(
+    (p) => new Property({
+      name: p.name,
+      kind: p.kind ?? "string",
+      required: p.required ?? p.default === void 0,
+      description: p.description,
+      default: p.default
+    })
+  );
+  const toolDef = new FunctionTool({
+    name: toolName,
+    kind: "function",
+    description: toolDesc,
+    parameters: properties
+  });
+  const wrapped = fn;
+  wrapped.__tool__ = toolDef;
+  if (shouldRegister) {
+    registerTool(toolName, fn);
+  }
+  return wrapped;
+}
+function bindTools(agent, tools) {
+  const handlers = {};
+  for (const fn of tools) {
+    const toolDef = fn.__tool__;
+    if (!toolDef) {
+      throw new Error(
+        `Function '${fn.name || "(anonymous)"}' is not a tool()-wrapped function (missing __tool__ property)`
+      );
+    }
+    const name = toolDef.name;
+    if (name in handlers) {
+      throw new Error(`Duplicate tool handler: '${name}'`);
+    }
+    handlers[name] = fn;
+  }
+  const declaredFunctionTools = /* @__PURE__ */ new Set();
+  for (const toolDef of agent.tools ?? []) {
+    if (toolDef.kind === "function") {
+      declaredFunctionTools.add(toolDef.name);
+    }
+  }
+  for (const name of Object.keys(handlers)) {
+    if (!declaredFunctionTools.has(name)) {
+      const declared = [...declaredFunctionTools].sort().join(", ") || "(none)";
+      throw new Error(
+        `Tool handler '${name}' has no matching 'kind: function' declaration in agent.tools. Declared function tools: ${declared}`
+      );
+    }
+  }
+  for (const name of declaredFunctionTools) {
+    if (!(name in handlers)) {
+      console.warn(
+        `Tool '${name}' is declared in agent.tools but no handler was provided to bindTools()`
+      );
+    }
+  }
+  return handlers;
+}
+
+// src/core/index.ts
+init_structured();
 
 // src/renderers/nunjucks.ts
 var import_nunjucks = __toESM(require("nunjucks"), 1);
@@ -5777,11 +6097,14 @@ registerParser("prompty", new PromptyChatParser());
   ApiKeyConnection,
   ArrayProperty,
   Binding,
+  CancelledError,
   Connection,
   CustomTool,
   FormatConfig,
   FoundryConnection,
   FunctionTool,
+  GuardrailError,
+  Guardrails,
   InvokerError,
   LoadContext,
   McpApprovalMode,
@@ -5807,22 +6130,31 @@ registerParser("prompty", new PromptyChatParser());
   ReferenceConnection,
   RemoteConnection,
   SaveContext,
+  Steering,
+  StructuredResultSymbol,
   Template,
   ThreadMarker,
   Tool,
   Tracer,
+  bindTools,
+  cast,
+  checkCancellation,
   clearCache,
   clearConnections,
   consoleTracer,
+  createStructuredResult,
   dictContentToPart,
   dictToMessage,
-  execute,
-  executeAgent,
+  emitEvent,
+  estimateChars,
   getConnection,
   getExecutor,
   getParser,
   getProcessor,
   getRenderer,
+  invoke,
+  invokeAgent,
+  isStructuredResult,
   load,
   otelTracer,
   parse,
@@ -5836,14 +6168,16 @@ registerParser("prompty", new PromptyChatParser());
   render,
   resolveBindings,
   run,
-  runAgent,
   sanitizeValue,
+  summarizeDropped,
   text,
   textMessage,
   toSerializable,
+  tool,
   trace,
   traceMethod,
   traceSpan,
+  trimToContextWindow,
   validateInputs
 });
 //# sourceMappingURL=index.cjs.map