@cognipeer/agent-sdk 0.2.2 → 0.2.3

package/dist/index.cjs

@@ -143,7 +143,7 @@ function withTools(model, tools) {
 function fromLangchainModel(lcModel) {
   if (!lcModel) throw new Error("fromLangchainModel: model is undefined/null");
   const adapted = {
-    invoke: async (messages) => {
+    invoke: async (messages, options) => {
       const normalizeContent = (content) => {
         if (content == null) return content;
         if (typeof content === "string") return content;
@@ -176,7 +176,7 @@ function fromLangchainModel(lcModel) {
         return { role, content: normalizeContent(m.content), name: m.name, tool_calls: m.tool_calls, tool_call_id: m.tool_call_id };
       };
       const lcMessages = messages.map(toLC);
-      const response = await lcModel.invoke(lcMessages);
+      const response = await lcModel.invoke(lcMessages, options);
       if (response && typeof response === "object") {
         const content = response.content ?? response.text ?? "";
         return {
@@ -190,6 +190,43 @@ function fromLangchainModel(lcModel) {
       }
       return { role: "assistant", content: String(response ?? "") };
     },
+    stream: async function* (messages, options) {
+      if (typeof lcModel.stream !== "function") return;
+      const normalizeContent = (content) => {
+        if (content == null) return content;
+        if (typeof content === "string") return content;
+        if (Array.isArray(content)) {
+          return content.map((part) => {
+            if (!part || typeof part !== "object") return part;
+            if (part.type === "text") return { type: "text", text: String(part.text ?? "") };
+            if (part.type === "image_url") {
+              const img = part.image_url;
+              if (typeof img === "string") return { type: "image_url", image_url: { url: img } };
+              if (img && typeof img === "object") {
+                if ("url" in img) return { type: "image_url", image_url: img };
+                if ("base64" in img) {
+                  const media = img.media_type || "image/jpeg";
+                  const dataUrl = `data:${media};base64,${img.base64}`;
+                  const detail = img.detail;
+                  return { type: "image_url", image_url: { url: dataUrl, detail } };
+                }
+              }
+              return part;
+            }
+            return part;
+          });
+        }
+        return content;
+      };
+      const toLC = (m) => {
+        if (m._getType || m.lc_serializable) return m;
+        return { role: m.role, content: normalizeContent(m.content), name: m.name, tool_calls: m.tool_calls, tool_call_id: m.tool_call_id };
+      };
+      const lcMessages = messages.map(toLC);
+      for await (const chunk of lcModel.stream(lcMessages, options)) {
+        yield chunk;
+      }
+    },
     bindTools: (tools) => {
       const lcReady = toLangchainTools(tools);
       if (typeof lcModel.bindTools === "function") {
@@ -343,7 +380,7 @@ function safe(v) {
   const n = Number(v);
   return Number.isFinite(n) && n >= 0 ? n : 0;
 }
-var DEFAULT_COGNIPEER_URL = "https://api.cognipeer.com/v1/client/tracing/sessions";
+var DEFAULT_COGNIPEER_URL = "https://console.cognipeer.com/api/client/v1/tracing/sessions";
 function fileSink(path2) {
   return { type: "file", path: path2 };
 }
@@ -401,133 +438,113 @@ function coerceToString(value) {
   }
   return void 0;
 }
-function firstNonEmptyString(...candidates) {
-  for (const candidate of candidates) {
-    const normalized = coerceToString(candidate);
-    if (normalized) return normalized;
-  }
-  return void 0;
+var METADATA_PATHS = {
+  model: [
+    "model",
+    "options.model",
+    "params.model",
+    "config.model",
+    "configuration.model",
+    "metadata.model",
+    "lc_kwargs.model",
+    "metadata.modelName",
+    "modelName",
+    "lc_alias",
+    "model_id",
+    "id",
+    "_model",
+    "_modelName",
+    "__model",
+    "_modelId",
+    "_llmType"
+  ],
+  provider: [
+    "provider",
+    "options.provider",
+    "params.provider",
+    "config.provider",
+    "configuration.provider",
+    "metadata.provider",
+    "lc_kwargs.provider"
+  ]
+};
+function getNestedValue(obj, path2) {
+  if (!obj || typeof path2 !== "string") return void 0;
+  return path2.split(".").reduce((current, key) => current?.[key], obj);
 }
-function getModelName(model) {
+function extractMetadata(model, paths) {
   if (!model) return void 0;
+  for (const path2 of paths) {
+    const value = getNestedValue(model, path2);
+    const str = coerceToString(value);
+    if (str) return str;
+  }
   const maybeLc = model?._lc;
-  const direct = firstNonEmptyString(
-    model?.model,
-    model?.options?.model,
-    model?.params?.model,
-    model?.config?.model,
-    model?.configuration?.model,
-    model?.metadata?.model,
-    model?.lc_kwargs?.model,
-    maybeLc?.model,
-    maybeLc?.options?.model,
-    maybeLc?.params?.model,
-    maybeLc?.config?.model,
-    maybeLc?.configuration?.model,
-    maybeLc?.metadata?.model,
-    maybeLc?.lc_kwargs?.model,
-    model?.metadata?.modelName,
-    maybeLc?.metadata?.modelName,
-    model?.modelName,
-    maybeLc?.modelName,
-    model?.lc_alias,
-    model?.model_id,
-    model?.id,
-    maybeLc?.model_id,
-    maybeLc?.id,
-    model?._model,
-    model?._modelName,
-    model?.__model
-  );
-  if (direct) return direct;
+  if (maybeLc) {
+    for (const path2 of paths) {
+      const value = getNestedValue(maybeLc, path2);
+      const str = coerceToString(value);
+      if (str) return str;
+    }
+  }
   const maybeClient = model?.client || model?.api || model?.service;
-  const clientValue = firstNonEmptyString(
-    maybeClient?.model,
-    maybeClient?.config?.model,
-    maybeClient?.options?.model,
-    maybeClient?.default?.model
-  );
-  if (clientValue) return clientValue;
-  const fnNames = firstNonEmptyString(model?._modelId, model?._llmType, maybeLc?._modelId, maybeLc?._llmType, model?.constructor?.name);
-  return fnNames;
+  if (maybeClient) {
+    for (const path2 of paths) {
+      const value = getNestedValue(maybeClient, path2);
+      const str = coerceToString(value);
+      if (str) return str;
+    }
+  }
+  const constructorName = model?.constructor?.name;
+  if (constructorName && !["Object", "Function"].includes(constructorName)) {
+    return constructorName;
+  }
+  return void 0;
+}
+function getModelName(model) {
+  return extractMetadata(model, METADATA_PATHS.model);
 }
 function getProviderName(model) {
-  if (!model) return void 0;
-  const direct = firstNonEmptyString(
-    model?.provider,
-    model?.options?.provider,
-    model?.params?.provider,
-    model?.config?.provider,
-    model?.configuration?.provider,
-    model?.metadata?.provider,
-    model?.lc_kwargs?.provider,
-    model?.lc_alias,
-    model?.__provider
-  );
-  if (direct) return direct;
-  const maybeLc = model?._lc;
-  const lcValue = maybeLc ? firstNonEmptyString(
-    maybeLc?.provider,
-    maybeLc?.options?.provider,
-    maybeLc?.config?.provider,
-    maybeLc?.configuration?.provider,
-    maybeLc?.metadata?.provider,
-    maybeLc?.lc_kwargs?.provider,
-    maybeLc?.client?.config?.provider
-  ) : void 0;
-  if (lcValue) return lcValue;
-  const maybeClient = model?.client || model?.api || model?.service;
-  return firstNonEmptyString(
-    maybeClient?.provider,
-    maybeClient?.config?.provider,
-    maybeClient?.options?.provider,
-    maybeClient?.metadata?.provider
-  );
+  return extractMetadata(model, METADATA_PATHS.provider);
 }
 function inferModelFromMessages(messageList) {
   if (!Array.isArray(messageList)) return void 0;
-  for (let i = messageList.length - 1; i >= 0; i -= 1) {
+  const messagePaths = [
+    "metadata.model",
+    "metadata.modelName",
+    "response_metadata.model",
+    "response_metadata.modelName",
+    "usage_metadata.model",
+    "model",
+    "modelName"
+  ];
+  for (let i = messageList.length - 1; i >= 0; i--) {
     const message = messageList[i];
     if (!message) continue;
-    const candidate = firstNonEmptyString(
-      message?.metadata?.model,
-      message?.metadata?.modelName,
-      message?.metadata?.modelNames,
-      message?.metadata?.model_id,
-      message?.response_metadata?.model,
-      message?.response_metadata?.modelName,
-      message?.response_metadata?.modelNames,
-      message?.response_metadata?.model_id,
-      message?.usage_metadata?.model,
-      message?.model,
-      message?.modelName,
-      message?.model_id,
-      message?.additional_kwargs?.model,
-      message?.additional_kwargs?.modelName,
-      message?.info?.model,
-      message?.annotations?.model
-    );
-    if (candidate) return candidate;
+    for (const path2 of messagePaths) {
+      const value = getNestedValue(message, path2);
+      const str = coerceToString(value);
+      if (str) return str;
+    }
   }
   return void 0;
 }
 function inferProviderFromMessages(messageList) {
   if (!Array.isArray(messageList)) return void 0;
-  for (let i = messageList.length - 1; i >= 0; i -= 1) {
+  const messagePaths = [
+    "metadata.provider",
+    "response_metadata.provider",
+    "usage_metadata.provider",
+    "provider"
+  ];
+  for (let i = messageList.length - 1; i >= 0; i--) {
     const message = messageList[i];
     if (!message) continue;
-    const candidate = firstNonEmptyString(
-      message?.metadata?.provider,
-      message?.metadata?.providers,
-      message?.response_metadata?.provider,
-      message?.response_metadata?.providers,
-      message?.usage_metadata?.provider,
-      message?.provider,
-      message?.additional_kwargs?.provider,
-      message?.info?.provider,
-      message?.annotations?.provider
-    );
-    if (candidate) return candidate;
+    for (const path2 of messagePaths) {
+      const value = getNestedValue(message, path2);
+      const str = coerceToString(value);
+      if (str) return str;
+    }
   }
   return void 0;
 }
@@ -625,20 +642,32 @@ async function postTraceSession(url, headers, payload) {
   if (!Object.keys(finalHeaders).some((key) => key.toLowerCase() === "content-type")) {
     finalHeaders["content-type"] = "application/json";
   }
-  const response = await fetchFn(url, {
-    method: "POST",
-    headers: finalHeaders,
-    body: JSON.stringify(payload)
-  });
-  if (!response.ok) {
-    let responseText = "";
-    try {
-      responseText = await response.text();
-    } catch {
+  try {
+    const response = await fetchFn(url, {
+      method: "POST",
+      headers: finalHeaders,
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      let responseText = "";
+      try {
+        responseText = await response.text();
+      } catch {
+      }
+      const statusLine = `HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
+      const bodyPreview = responseText ? ` - ${responseText.slice(0, 200)}` : "";
+      const errorMsg = `${statusLine}${bodyPreview}`;
+      if (typeof console !== "undefined" && typeof console.error === "function") {
+        console.error("[Tracing] Error posting to", url, ":", errorMsg);
+      }
+      throw new Error(errorMsg);
+    }
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    if (typeof console !== "undefined" && typeof console.error === "function") {
+      console.error("[Tracing] Failed to post:", errMsg);
     }
-    const statusLine = `HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
-    const bodyPreview = responseText ? ` - ${responseText.slice(0, 200)}` : "";
-    throw new Error(`${statusLine}${bodyPreview}`);
+    throw err;
   }
 }
 function createEmptySummary() {
@@ -939,12 +968,16 @@ async function finalizeTraceSession(session, params = {}) {
   const endedAtIso = new Date(endedAtMs).toISOString();
   const durationMs = endedAtMs - session.startedAt;
   const startedAtIso = new Date(session.startedAt).toISOString();
-  const agentInfo = params.agentRuntime ? {
-    name: params.agentRuntime.name,
-    version: params.agentRuntime.version,
-    model: getModelName(params.agentRuntime.model),
-    provider: getProviderName(params.agentRuntime.model)
-  } : void 0;
+  const buildAgentInfo = (runtime) => {
+    if (!runtime) return void 0;
+    return {
+      name: runtime.name || "unknown-agent",
+      version: runtime.version,
+      model: getModelName(runtime.model) || "unknown-model",
+      provider: getProviderName(runtime.model)
+    };
+  };
+  const agentInfo = buildAgentInfo(params.agentRuntime);
   if (params.error) {
     session.errors.push({
       eventId: "session",
@@ -1112,12 +1145,29 @@ function createAgentCoreNode(opts) {
     };
     const normalizeBedrockToolPairing = (input) => {
       const msgs = Array.isArray(input) ? [...input] : [];
-      for (let i = 0; i < msgs.length; i++) {
-        const m = msgs[i];
+      const validToolCallIds = /* @__PURE__ */ new Set();
+      for (const m of msgs) {
+        if (m?.role === "assistant") {
+          for (const tu of extractToolUses(m)) {
+            if (tu.id) validToolCallIds.add(tu.id);
+          }
+        }
+      }
+      const filteredMsgs = msgs.filter((m) => {
+        if (m?.role === "tool") {
+          const toolCallId = m.tool_call_id;
+          if (!toolCallId || !validToolCallIds.has(toolCallId)) {
+            return false;
+          }
+        }
+        return true;
+      });
+      for (let i = 0; i < filteredMsgs.length; i++) {
+        const m = filteredMsgs[i];
         if (m?.role !== "assistant") continue;
         const toolUses = extractToolUses(m);
         if (toolUses.length === 0) continue;
-        const next = msgs[i + 1];
+        const next = filteredMsgs[i + 1];
         const firstId = toolUses[0]?.id;
         const nextIsToolForFirst = !!(next && next.role === "tool" && next.tool_call_id === firstId);
         if (nextIsToolForFirst) continue;
@@ -1125,12 +1175,12 @@ function createAgentCoreNode(opts) {
           role: "tool",
           name: tu.name || "unknown_tool",
           tool_call_id: tu.id,
-          content: "SUMMARIZED/DEFERRED: tool result missing in transcript; inserted placeholder for Bedrock tool_result adjacency."
+          content: "SUMMARIZED/DEFERRED: tool result missing in transcript; inserted placeholder for tool_result adjacency."
         }));
-        msgs.splice(i + 1, 0, ...placeholders);
+        filteredMsgs.splice(i + 1, 0, ...placeholders);
         i += placeholders.length;
       }
-      return msgs;
+      return filteredMsgs;
     };
     const debugToolPairing = (messagesToSend) => {
       try {
@@ -1152,11 +1202,54 @@ function createAgentCoreNode(opts) {
       } catch (e) {
       }
     };
+    const onEvent = state.ctx?.__onEvent;
+    const onStream = state.ctx?.__onStream;
+    const streamingEnabled = Boolean(state.ctx?.__streaming);
+    const cancellationToken = state.ctx?.__cancellationToken;
+    const abortSignal = state.ctx?.__abortSignal;
+    const extractText = (chunk) => {
+      if (chunk == null) return "";
+      if (typeof chunk === "string") return chunk;
+      if (typeof chunk?.content === "string") return chunk.content;
+      if (Array.isArray(chunk?.content)) {
+        return chunk.content.map((c) => typeof c === "string" ? c : c?.text ?? c?.content ?? "").join("");
+      }
+      if (typeof chunk?.text === "string") return chunk.text;
+      if (typeof chunk?.delta?.content === "string") return chunk.delta.content;
+      return "";
+    };
     let response;
     try {
       const normalizedMessages = normalizeBedrockToolPairing([...state.messages]);
       debugToolPairing(normalizedMessages);
-      response = await modelWithTools.invoke(normalizedMessages);
+      if (streamingEnabled && typeof modelWithTools.stream === "function") {
+        let streamedText = "";
+        let streamedMessage;
+        for await (const chunk of modelWithTools.stream(normalizedMessages, { signal: abortSignal, cancellationToken })) {
+          if (cancellationToken && cancellationToken.isCancellationRequested || abortSignal?.aborted) {
+            break;
+          }
+          if (chunk && typeof chunk === "object" && chunk.role) {
+            streamedMessage = chunk;
+          }
+          const text = extractText(chunk);
+          if (text) {
+            streamedText += text;
+            onStream?.({ text });
+            onEvent?.({ type: "stream", text });
+          }
+        }
+        if (streamedMessage) {
+          response = { ...streamedMessage };
+          if (response.content == null || response.content === "") {
+            response.content = streamedText;
+          }
+        } else {
+          response = { role: "assistant", content: streamedText };
+        }
+      } else {
+        response = await modelWithTools.invoke(normalizedMessages, { signal: abortSignal, cancellationToken });
+      }
     } catch (err) {
       const durationMs2 = Date.now() - start;
       recordTraceEvent(traceSession, {
@@ -1177,7 +1270,7 @@ function createAgentCoreNode(opts) {
       ...state.messages,
       response
     ];
-    const rawUsage = response?.usage || response?.response_metadata?.token_usage || response?.response_metadata?.usage;
+    const rawUsage = response?.usage || response?.response_metadata?.token_usage || response?.response_metadata?.tokenUsage || response?.response_metadata?.usage;
     const normalized = normalizeUsage(rawUsage);
     const modelName = getModelName(runtime.model || opts.model) || "unknown_model";
     const durationMs = Date.now() - start;
@@ -1244,6 +1337,9 @@ function createToolsNode(initialTools, opts) {
     };
     const appended = [];
     const onEvent = state.ctx?.__onEvent;
+    const onProgress = state.ctx?.__onProgress;
+    const cancellationToken = state.ctx?.__cancellationToken;
+    const abortSignal = state.ctx?.__abortSignal;
     const traceSession = state.ctx?.__traceSession;
     const pendingApprovals = Array.isArray(state.pendingApprovals) ? state.pendingApprovals.map((entry) => ({ ...entry })) : [];
     const pendingByCallId = new Map(pendingApprovals.map((entry) => [entry.toolCallId, entry]));
@@ -1300,7 +1396,20 @@ function createToolsNode(initialTools, opts) {
         name: tc.name
       });
     }
+    const isCancelled = () => {
+      if (abortSignal?.aborted) return { cancelled: true, reason: "aborted" };
+      if (cancellationToken && cancellationToken.isCancellationRequested) return { cancelled: true, reason: "cancelled" };
+      return { cancelled: false, reason: void 0 };
+    };
     const runOne = async (tc) => {
+      const cancelState = isCancelled();
+      if (cancelState.cancelled) {
+        const ctx = state.ctx = state.ctx || {};
+        ctx.__cancelled = { stage: "tools", reason: cancelState.reason, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+        onEvent?.({ type: "cancelled", stage: "tools", reason: cancelState.reason });
+        onProgress?.({ stage: "tools", message: "Cancelled", detail: { reason: cancelState.reason } });
+        return { status: "error" };
+      }
       const t = toolByName.get(tc.name);
       if (!t) {
         onEvent?.({ type: "tool_call", phase: "error", name: tc.name, id: tc.id, args: tc.args, error: { message: "Tool not found" } });
@@ -1379,15 +1488,17 @@ function createToolsNode(initialTools, opts) {
       const start = Date.now();
       try {
         onEvent?.({ type: "tool_call", phase: "start", name: t.name, id: tc.id, args });
+        onProgress?.({ stage: "tools", message: `Running tool ${tc.name}` });
         const sanitizedArgs = sanitizeTracePayload(args);
         const inputBytes = traceSession?.resolvedConfig.logData ? estimatePayloadBytes(sanitizedArgs) : void 0;
         let output;
         const anyTool = t;
-        if (typeof anyTool.func === "function") output = await anyTool.func(args);
-        else if (typeof anyTool.invoke === "function") output = await anyTool.invoke(args);
-        else if (typeof anyTool.call === "function") output = await anyTool.call(args);
-        else if (typeof anyTool._call === "function") output = await anyTool._call(args);
-        else if (typeof anyTool.run === "function") output = await anyTool.run(args);
+        const callOptions = { cancellationToken, signal: abortSignal };
+        if (typeof anyTool.func === "function") output = await anyTool.func(args, callOptions);
+        else if (typeof anyTool.invoke === "function") output = await anyTool.invoke(args, callOptions);
+        else if (typeof anyTool.call === "function") output = await anyTool.call(args, callOptions);
+        else if (typeof anyTool._call === "function") output = await anyTool._call(args, callOptions);
+        else if (typeof anyTool.run === "function") output = await anyTool.run(args, callOptions);
         else throw new Error("Tool is not invokable");
         if (output && typeof output === "object" && output.__handoff && output.__handoff.runtime) {
           const newRuntime = output.__handoff.runtime;
@@ -1417,6 +1528,7 @@ function createToolsNode(initialTools, opts) {
         toolHistory.push({ executionId, toolName: t.name, args, output, rawOutput: output, timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool_call_id: tc.id });
         appended.push({ role: "tool", content, tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name });
         onEvent?.({ type: "tool_call", phase: "success", name: t.name, id: tc.id, args, result: output, durationMs });
+        onProgress?.({ stage: "tools", message: `Tool ${tc.name} completed`, detail: { durationMs } });
         if (needsApproval && approvalEntry) {
           approvalEntry.status = "executed";
           approvalEntry.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -1466,6 +1578,7 @@ function createToolsNode(initialTools, opts) {
         toolHistory.push({ executionId, toolName: t.name, args, output: `Error executing tool: ${e?.message || String(e)}`, rawOutput: null, timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool_call_id: tc.id });
         appended.push({ role: "tool", content: `Error executing tool: ${e?.message || String(e)}`, tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name });
         onEvent?.({ type: "tool_call", phase: "error", name: t.name, id: tc.id, args, error: { message: e?.message || String(e) } });
+        onProgress?.({ stage: "tools", message: `Tool ${tc.name} failed`, detail: { error: e?.message || String(e) } });
         const sanitizedArgs = sanitizeTracePayload(args);
         const inputBytes = traceSession?.resolvedConfig.logData ? estimatePayloadBytes(sanitizedArgs) : void 0;
         const toolName = t.name || tc.name;
@@ -1509,6 +1622,14 @@ function createToolsNode(initialTools, opts) {
     };
     for (const tc of planned) {
       if (awaitingApproval) break;
+      const cancelState = isCancelled();
+      if (cancelState.cancelled) {
+        const ctx = state.ctx = state.ctx || {};
+        ctx.__cancelled = { stage: "tools", reason: cancelState.reason, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+        onEvent?.({ type: "cancelled", stage: "tools", reason: cancelState.reason });
+        onProgress?.({ stage: "tools", message: "Cancelled", detail: { reason: cancelState.reason } });
+        break;
+      }
       const result = await runOne(tc);
       if (result?.status === "awaiting_approval") {
         awaitingApproval = true;
@@ -1536,7 +1657,7 @@ function createToolsNode(initialTools, opts) {
 // src/nodes/toolLimitFinalize.ts
 function createToolLimitFinalizeNode(_opts) {
   return async (state) => {
-    const notice = { role: "system", content: "Tool-call limit reached. Produce the best possible final answer using the available context and prior tool outputs. Do not call any more tools." };
+    const notice = { role: "user", content: "[System Notice] Tool-call limit reached. Produce the best possible final answer using the available context and prior tool outputs. Do not call any more tools." };
     const ctx = { ...state.ctx || {}, __finalizedDueToToolLimit: true };
     return { messages: [...state.messages, notice], ctx };
   };
@@ -1813,12 +1934,37 @@ function createAgent(opts) {
       delete nextCtx.__resumeStage;
       state = { ...state, ctx: Object.keys(nextCtx).length > 0 ? nextCtx : void 0 };
     }
-    const maxToolCalls = opts.limits?.maxToolCalls === void 0 ? 50 : opts.limits?.maxToolCalls;
+    const mergedLimits = {
+      ...opts.limits || {},
+      ...config?.limits || {}
+    };
+    const maxToolCalls = mergedLimits?.maxToolCalls === void 0 ? 50 : mergedLimits?.maxToolCalls;
     const iterationLimit = maxToolCalls === Infinity ? 100 : Math.max(maxToolCalls * 3 + 10, 40);
     let iterations = 0;
     const onStateChange = config?.onStateChange;
     const checkpointReason = config?.checkpointReason;
     let pausedStage = null;
+    const onProgress = state.ctx?.__onProgress;
+    const isCancelled = () => {
+      const ctx = state.ctx || {};
+      const token = ctx.__cancellationToken;
+      const signal = ctx.__abortSignal;
+      const deadline = ctx.__deadline;
+      if (signal?.aborted) return { cancelled: true, reason: "aborted" };
+      if (token && token.isCancellationRequested) return { cancelled: true, reason: "cancelled" };
+      if (deadline && Date.now() > deadline) return { cancelled: true, reason: "timeout" };
+      return { cancelled: false, reason: void 0 };
+    };
+    const cancelIfRequested = (stage) => {
+      const result = isCancelled();
+      if (!result.cancelled) return false;
+      const ctx = { ...state.ctx || {} };
+      ctx.__cancelled = { stage, reason: result.reason, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+      state = { ...state, ctx };
+      emit?.({ type: "cancelled", stage, reason: result.reason });
+      onProgress?.({ stage, message: "Cancelled", detail: { reason: result.reason } });
+      return true;
+    };
     const checkpointIfRequested = (stage) => {
       if (typeof onStateChange !== "function") return false;
       let result = false;
@@ -1841,8 +1987,10 @@ function createAgent(opts) {
     };
     while (iterations < iterationLimit) {
       iterations++;
+      if (cancelIfRequested("loop")) break;
       const skippingAgent = resumeStage === "tools";
       if (!skippingAgent) {
+        if (cancelIfRequested("before_guardrails")) break;
         if (checkpointIfRequested("before_guardrails")) break;
         const preGuardrails = getGuardrailConfig(state);
         if (preGuardrails.length > 0) {
@@ -1897,7 +2045,10 @@ function createAgent(opts) {
             break;
           }
         }
+        onProgress?.({ stage: "agent", message: "Invoking model" });
+        if (cancelIfRequested("before_agent")) break;
         state = { ...state, ...await agentCore(state) };
+        onProgress?.({ stage: "agent", message: "Model response received" });
         if (checkpointIfRequested("after_agent")) break;
         const postGuardrails = getGuardrailConfig(state);
         if (postGuardrails.length > 0) {
@@ -1965,7 +2116,10 @@ function createAgent(opts) {
         continue;
       }
       if (toolCalls.length === 0) break;
+      onProgress?.({ stage: "tools", message: "Running tools" });
+      if (cancelIfRequested("before_tools")) break;
       state = { ...state, ...await toolsNode(state) };
+      onProgress?.({ stage: "tools", message: "Tools finished" });
       if (state.ctx?.__awaitingApproval) break;
       if (checkpointIfRequested("after_tools")) break;
       if (state.ctx?.__finalizedDueToStructuredOutput) break;
@@ -2006,15 +2160,39 @@ function createAgent(opts) {
   }
   const invokeAgent = async (input, config) => {
     const onEvent = config?.onEvent;
+    const onProgress = config?.onProgress;
+    const onStream = config?.onStream;
+    const streamEnabled = config?.stream === true;
     const emit = (e) => {
       try {
         onEvent?.(e);
       } catch {
       }
     };
+    const emitProgress = (progress) => {
+      try {
+        onProgress?.(progress);
+      } catch {
+      }
+      emit({ type: "progress", ...progress });
+    };
     const traceSession = createTraceSession(opts);
-    const ctx = { ...input.ctx || {}, __onEvent: onEvent };
+    const ctx = {
+      ...input.ctx || {},
+      __onEvent: onEvent,
+      __onProgress: emitProgress,
+      __onStream: onStream,
+      __streaming: streamEnabled
+    };
     if (traceSession) ctx.__traceSession = traceSession;
+    if (config?.cancellationToken) ctx.__cancellationToken = config.cancellationToken;
+    if (config?.cancellationToken?.aborted !== void 0) {
+      ctx.__abortSignal = config?.cancellationToken;
+    }
+    if (config?.timeoutMs && config.timeoutMs > 0) {
+      ctx.__deadline = Date.now() + config.timeoutMs;
+    }
+    const runtimeWithInvokeLimits = config?.limits ? { ...runtime, limits: { ...runtime.limits || {}, ...config.limits } } : runtime;
     const initial = {
       messages: input.messages || [],
       toolCallCount: input.toolCallCount || 0,
@@ -2023,7 +2201,7 @@ function createAgent(opts) {
       metadata: input.metadata,
       ctx,
       pendingApprovals: input.pendingApprovals || [],
-      agent: input.agent || runtime,
+      agent: input.agent || runtimeWithInvokeLimits,
       usage: input.usage || { perRequest: [], totals: {} }
     };
     let res;
@@ -2066,6 +2244,10 @@ function createAgent(opts) {
       }
     }
     emit({ type: "finalAnswer", content: typeof finalMsg?.content === "string" ? finalMsg.content : content });
+    if (streamEnabled && content) {
+      onStream?.({ text: content, isFinal: true });
+      emit({ type: "stream", text: content, isFinal: true });
+    }
     return {
       content,
       output: parsed,
@@ -2236,6 +2418,31 @@ function createAgentNode(opts) {
 // src/nodes/contextSummarize.ts
 var systemMessage = (content) => ({ role: "system", content });
 var humanMessage = (content) => ({ role: "user", content });
+function validateMessageSequence(messages) {
+  const validated = [];
+  const pendingToolCallIds = /* @__PURE__ */ new Set();
+  for (const m of messages) {
+    if (m.role === "assistant") {
+      if (!m.tool_calls || m.tool_calls.length === 0) {
+        pendingToolCallIds.clear();
+      } else {
+        m.tool_calls.forEach((tc) => {
+          if (tc.id) pendingToolCallIds.add(tc.id);
+        });
+      }
+      validated.push(m);
+    } else if (m.role === "tool") {
+      const toolCallId = m.tool_call_id;
+      if (toolCallId && pendingToolCallIds.has(toolCallId)) {
+        pendingToolCallIds.delete(toolCallId);
+        validated.push(m);
+      }
+    } else {
+      validated.push(m);
+    }
+  }
+  return validated;
+}
 function getSummarizationConfig(opts) {
   if (typeof opts.summarization === "object") {
     return {
@@ -2243,13 +2450,15 @@ function getSummarizationConfig(opts) {
       maxTokens: opts.summarization.maxTokens ?? 5e4,
       // Max tokens we can send to the model for summarization prompt itself
       // This should be well under the model's context limit
-      summaryPromptMaxTokens: opts.summarization.summaryPromptMaxTokens ?? 8e3
+      summaryPromptMaxTokens: opts.summarization.summaryPromptMaxTokens ?? 8e3,
+      promptTemplate: opts.summarization.promptTemplate
     };
   }
   return {
     enabled: opts.summarization !== false,
     maxTokens: 5e4,
-    summaryPromptMaxTokens: 8e3
+    summaryPromptMaxTokens: 8e3,
+    promptTemplate: void 0
   };
 }
 function createContextSummarizeNode(opts) {
@@ -2289,21 +2498,26 @@ function createContextSummarizeNode(opts) {
       accumulatedTokens += messageTokens;
     }
     const conversationText = messageTexts.join("\n\n");
-    const summaryPrompt = [
-      systemMessage("You are a helpful assistant that summarizes conversation history efficiently."),
-      humanMessage(
-        `Please summarize the following conversation history. 
+    const previousSummary = Array.isArray(state.summaries) && state.summaries.length > 0 ? state.summaries[state.summaries.length - 1] : "";
+    const defaultPrompt = `Please summarize the following conversation history and update any previous summary.
 Focus on:
 - User goals and intent.
 - Key decisions made and actions taken.
 - Important tool outputs and data retrieved.
 - Current state of the task.
 
+Previous summary (if any):
+${previousSummary || "(none)"}
+
 Conversation:
 ${conversationText}
 
-Summary:`
-      )
+Summary:`;
+    const template = config.promptTemplate || defaultPrompt;
+    const promptBody = template.replace(/\{\{\s*conversation\s*\}\}/g, conversationText).replace(/\{\{\s*previousSummary\s*\}\}/g, previousSummary || "");
+    const summaryPrompt = [
+      systemMessage("You are a helpful assistant that summarizes conversation history efficiently."),
+      humanMessage(promptBody)
     ];
     let summaryText = "Summary unavailable.";
     try {
@@ -2313,8 +2527,22 @@ Summary:`
       console.error("[ContextSummarize] Failed to generate summary:", err);
       return {};
     }
+    const toolCallIdToAssistantIdx = /* @__PURE__ */ new Map();
+    messages.forEach((m, idx) => {
+      if (m.role === "assistant" && m.tool_calls && Array.isArray(m.tool_calls)) {
+        m.tool_calls.forEach((tc) => {
+          if (tc.id) {
+            toolCallIdToAssistantIdx.set(tc.id, idx);
+          }
+        });
+      }
+    });
     const newMessages = messages.map((m) => {
       if (m.role === "tool") {
+        const toolCallId = m.tool_call_id;
+        if (!toolCallId || !toolCallIdToAssistantIdx.has(toolCallId)) {
+          return null;
+        }
         if (m.content === "SUMMARIZED") return m;
         return {
           ...m,
@@ -2322,7 +2550,8 @@ Summary:`
         };
       }
       return m;
-    });
+    }).filter((m) => m !== null);
+    const validatedMessages = validateMessageSequence(newMessages);
     const summaryToolCallId = `call_summary_${Date.now()}`;
     const assistantSummaryCall = {
       role: "assistant",
@@ -2346,8 +2575,10 @@ Summary:`
       // Matches the tool name in the call
       content: summaryText
     };
+    const summaries = Array.isArray(state.summaries) ? [...state.summaries, summaryText] : [summaryText];
     return {
-      messages: [...newMessages, assistantSummaryCall, toolSummaryResponse]
+      messages: [...validatedMessages, assistantSummaryCall, toolSummaryResponse],
+      summaries
     };
   };
 }
@@ -2452,9 +2683,29 @@ function needsSummarization(state, opts, summarizationEnabled) {
     maxTok = 5e4;
   }
   try {
-    const allText = (state.messages || []).map((m) => typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.map((c) => typeof c === "string" ? c : c?.text ?? c?.content ?? "").join("") : "").join("\n");
+    const allText = (state.messages || []).map((m) => {
+      if (typeof m.content === "string") return m.content;
+      if (Array.isArray(m.content)) {
+        return m.content.map((c) => typeof c === "string" ? c : c?.text ?? c?.content ?? JSON.stringify(c)).join("");
+      }
+      if (m.content && typeof m.content === "object") {
+        return JSON.stringify(m.content);
+      }
+      return "";
+    }).join("\n");
     const tokenCount = countApproxTokens(allText);
     const needsSum = tokenCount > maxTok;
+    if (process.env.DEBUG_SUMMARIZATION) {
+      const msgCount = (state.messages || []).length;
+      const toolMsgs = (state.messages || []).filter((m) => m.role === "tool");
+      const toolDetails = toolMsgs.map((m, i) => {
+        const contentStr = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+        return `[${i}] id:${m.tool_call_id?.slice(-8) || "none"} len:${contentStr.length} preview:"${contentStr.slice(0, 30)}..."`;
+      });
+      console.log(`[Summarization] Messages: ${msgCount}, Tool messages: ${toolMsgs.length}`);
+      toolDetails.forEach((d) => console.log(`  ${d}`));
+      console.log(`[Summarization] Token count: ${tokenCount}, Max: ${maxTok}, Needs summarization: ${needsSum}`);
+    }
     return needsSum;
   } catch (e) {
     return false;
@@ -2512,7 +2763,8 @@ function createSmartAgent(opts) {
       const seedMessages = alreadyHasSystem ? [...input.messages || []] : [systemMessage2(), ...input.messages || []];
       let state = { ...input, messages: seedMessages };
       let lastResult = null;
-      const iterationLimit = Math.max((opts.limits?.maxToolCalls ?? 10) * 3 + 5, 30);
+      const effectiveMaxToolCalls = config?.limits?.maxToolCalls ?? opts.limits?.maxToolCalls ?? 10;
+      const iterationLimit = Math.max(effectiveMaxToolCalls * 3 + 5, 30);
       for (let i = 0; i < iterationLimit; i++) {
         const next = summarizationEnabled ? decideBefore(state) : "agent";
         if (next === "contextSummarize" && summarizer) {
@@ -2524,7 +2776,11 @@ function createSmartAgent(opts) {
         }
         const res = await base.invoke(state, config);
         lastResult = res;
+        const currentSummaries = state.summaries;
         state = res.state || { ...state, messages: res.messages };
+        if (currentSummaries && currentSummaries.length > 0 && (!state.summaries || state.summaries.length === 0)) {
+          state = { ...state, summaries: currentSummaries };
+        }
         if (state.ctx?.__needsSummarization && summarizer) {
           const ctx = { ...state.ctx || {} };
           delete ctx.__needsSummarization;
@@ -2552,6 +2808,13 @@ function createSmartAgent(opts) {
         const res = await base.invoke(state, config);
         lastResult = res;
       }
+      if (state.summaries && state.summaries.length > 0) {
+        if (lastResult.state) {
+          lastResult = { ...lastResult, state: { ...lastResult.state, summaries: state.summaries } };
+        } else {
+          lastResult = { ...lastResult, state: { ...state, summaries: state.summaries } };
+        }
+      }
       return lastResult;
     },
     snapshot: base.snapshot,