@crewai-ts/core 0.1.0

package/dist/chunk-LWD4QED4.js

@@ -0,0 +1,656 @@
+// src/hooks.ts
+var LLMCallHookContext = class {
+  executor;
+  agent;
+  task;
+  crew;
+  llm;
+  iterations;
+  messages;
+  response;
+  constructor(options = {}) {
+    this.executor = options.executor ?? null;
+    const executor = readHookExecutor(options.executor);
+    this.messages = options.messages ?? executor.messages ?? [];
+    this.llm = options.llm ?? executor.llm ?? null;
+    this.agent = options.agent ?? executor.agent ?? null;
+    this.task = options.task ?? executor.task ?? null;
+    this.crew = options.crew ?? executor.crew ?? null;
+    this.iterations = options.iterations ?? executor.iterations ?? 0;
+    this.response = options.response ?? null;
+  }
+  requestHumanInput(prompt, defaultMessage) {
+    return requestHookHumanInput(this, prompt, defaultMessage);
+  }
+  request_human_input(prompt, defaultMessage = "Press Enter to continue, or provide feedback:") {
+    return this.requestHumanInput(prompt, defaultMessage);
+  }
+};
+var ToolCallHookContext = class {
+  toolName;
+  tool_name;
+  tool;
+  agent;
+  task;
+  crew;
+  toolInput;
+  tool_input;
+  toolResult;
+  tool_result;
+  constructor(options) {
+    this.toolName = options.toolName ?? options.tool_name ?? options.tool.name;
+    this.tool_name = this.toolName;
+    this.toolInput = options.toolInput ?? options.tool_input ?? {};
+    this.tool_input = this.toolInput;
+    this.tool = options.tool;
+    this.agent = options.agent ?? null;
+    this.task = options.task ?? null;
+    this.crew = options.crew ?? null;
+    this.toolResult = options.toolResult ?? options.tool_result ?? null;
+    this.tool_result = this.toolResult;
+  }
+  requestHumanInput(prompt, defaultMessage) {
+    return requestHookHumanInput(this, prompt, defaultMessage);
+  }
+  request_human_input(prompt, defaultMessage = "Press Enter to continue, or provide feedback:") {
+    return this.requestHumanInput(prompt, defaultMessage);
+  }
+};
+var ContextT = Object.freeze({ kind: "TypeVar" });
+var ReturnT = Object.freeze({ kind: "TypeVar" });
+var P = Object.freeze({ kind: "TypeVar" });
+var R = Object.freeze({ kind: "TypeVar" });
+var U = Object.freeze({ kind: "TypeVar" });
+var Hook = Object.freeze({ kind: "Hook" });
+var HTTPTransportKwargs = Object.freeze({ kind: "HTTPTransportKwargs" });
+var BaseInterceptor = class _BaseInterceptor {
+  static __get_pydantic_core_schema__() {
+    return {
+      type: "plain-validator",
+      validator: (value) => this.validate_interceptor(value),
+      serialization: { type: "identity" }
+    };
+  }
+  static validateInterceptor(value) {
+    if (!(value instanceof _BaseInterceptor)) {
+      const typeName = value === null ? "null" : Array.isArray(value) ? "Array" : typeof value === "object" ? value.constructor.name : typeof value;
+      throw new Error(`Expected BaseInterceptor instance, got ${typeName}`);
+    }
+    return value;
+  }
+  static validate_interceptor(value) {
+    return this.validateInterceptor(value);
+  }
+  async aon_outbound(message) {
+    await Promise.resolve();
+    return this.on_outbound(message);
+  }
+  async aon_inbound(message) {
+    await Promise.resolve();
+    return this.on_inbound(message);
+  }
+};
+function _validate_interceptor(value) {
+  return BaseInterceptor.validateInterceptor(value);
+}
+var AsyncHTTPTransport = class {
+  interceptor;
+  kwargs;
+  constructor(interceptor, kwargs = {}) {
+    this.interceptor = interceptor;
+    this.kwargs = { ...kwargs };
+  }
+  async handle_async_request(request) {
+    const outbound = await this.interceptor.aon_outbound(request);
+    return await this.interceptor.aon_inbound(outbound);
+  }
+};
+var HTTPTransport = class {
+  interceptor;
+  kwargs;
+  constructor(interceptor, kwargs = {}) {
+    this.interceptor = interceptor;
+    this.kwargs = { ...kwargs };
+  }
+  handle_request(request) {
+    const outbound = this.interceptor.on_outbound(request);
+    return this.interceptor.on_inbound(outbound);
+  }
+};
+var BeforeLLMCallHook = Object.freeze({ kind: "BeforeLLMCallHook" });
+var AfterLLMCallHook = Object.freeze({ kind: "AfterLLMCallHook" });
+var BeforeToolCallHook = Object.freeze({ kind: "BeforeToolCallHook" });
+var AfterToolCallHook = Object.freeze({ kind: "AfterToolCallHook" });
+var BeforeLLMCallHookType = BeforeLLMCallHook;
+var AfterLLMCallHookType = AfterLLMCallHook;
+var BeforeToolCallHookType = BeforeToolCallHook;
+var AfterToolCallHookType = AfterToolCallHook;
+var BeforeLLMCallHookCallable = BeforeLLMCallHook;
+var AfterLLMCallHookCallable = AfterLLMCallHook;
+var BeforeToolCallHookCallable = BeforeToolCallHook;
+var AfterToolCallHookCallable = AfterToolCallHook;
+var HookMethod = class {
+  _meth;
+  agents;
+  tools;
+  constructor(method, options = {}) {
+    this._meth = method;
+    this.agents = options.agents ?? null;
+    this.tools = options.tools ?? null;
+    Object.defineProperties(this, {
+      __name__: { value: method.name, enumerable: false },
+      __doc__: { value: null, enumerable: false }
+    });
+  }
+  call(...args) {
+    return this._meth(...args);
+  }
+  __call__(...args) {
+    return this.call(...args);
+  }
+};
+var BeforeLLMCallHookMethod = class extends HookMethod {
+  is_before_llm_call_hook = true;
+  constructor(method, agents = null) {
+    super(method, { agents });
+  }
+};
+var AfterLLMCallHookMethod = class extends HookMethod {
+  is_after_llm_call_hook = true;
+  constructor(method, agents = null) {
+    super(method, { agents });
+  }
+};
+var BeforeToolCallHookMethod = class extends HookMethod {
+  is_before_tool_call_hook = true;
+  constructor(method, tools = null, agents = null) {
+    super(method, { agents, tools });
+  }
+};
+var AfterToolCallHookMethod = class extends HookMethod {
+  is_after_tool_call_hook = true;
+  constructor(method, tools = null, agents = null) {
+    super(method, { agents, tools });
+  }
+};
+var beforeLlmCallHooks = [];
+var afterLlmCallHooks = [];
+var beforeToolCallHooks = [];
+var afterToolCallHooks = [];
+function registerBeforeLlmCallHook(hook) {
+  beforeLlmCallHooks.push(hook);
+}
+var register_before_llm_call_hook = registerBeforeLlmCallHook;
+function registerAfterLlmCallHook(hook) {
+  afterLlmCallHooks.push(hook);
+}
+var register_after_llm_call_hook = registerAfterLlmCallHook;
+function getBeforeLlmCallHooks() {
+  return [...beforeLlmCallHooks];
+}
+var get_before_llm_call_hooks = getBeforeLlmCallHooks;
+function getAfterLlmCallHooks() {
+  return [...afterLlmCallHooks];
+}
+var get_after_llm_call_hooks = getAfterLlmCallHooks;
+function unregisterBeforeLlmCallHook(hook) {
+  return removeHook(beforeLlmCallHooks, hook);
+}
+var unregister_before_llm_call_hook = unregisterBeforeLlmCallHook;
+function unregisterAfterLlmCallHook(hook) {
+  return removeHook(afterLlmCallHooks, hook);
+}
+var unregister_after_llm_call_hook = unregisterAfterLlmCallHook;
+function clearBeforeLlmCallHooks() {
+  return clearHooks(beforeLlmCallHooks);
+}
+var clear_before_llm_call_hooks = clearBeforeLlmCallHooks;
+function clearAfterLlmCallHooks() {
+  return clearHooks(afterLlmCallHooks);
+}
+var clear_after_llm_call_hooks = clearAfterLlmCallHooks;
+function clearAllLlmCallHooks() {
+  return [clearBeforeLlmCallHooks(), clearAfterLlmCallHooks()];
+}
+var clear_all_llm_call_hooks = clearAllLlmCallHooks;
+function registerBeforeToolCallHook(hook) {
+  beforeToolCallHooks.push(hook);
+}
+var register_before_tool_call_hook = registerBeforeToolCallHook;
+function registerAfterToolCallHook(hook) {
+  afterToolCallHooks.push(hook);
+}
+var register_after_tool_call_hook = registerAfterToolCallHook;
+function getBeforeToolCallHooks() {
+  return [...beforeToolCallHooks];
+}
+var get_before_tool_call_hooks = getBeforeToolCallHooks;
+function getAfterToolCallHooks() {
+  return [...afterToolCallHooks];
+}
+var get_after_tool_call_hooks = getAfterToolCallHooks;
+function unregisterBeforeToolCallHook(hook) {
+  return removeHook(beforeToolCallHooks, hook);
+}
+var unregister_before_tool_call_hook = unregisterBeforeToolCallHook;
+function unregisterAfterToolCallHook(hook) {
+  return removeHook(afterToolCallHooks, hook);
+}
+var unregister_after_tool_call_hook = unregisterAfterToolCallHook;
+function clearBeforeToolCallHooks() {
+  return clearHooks(beforeToolCallHooks);
+}
+var clear_before_tool_call_hooks = clearBeforeToolCallHooks;
+function clearAfterToolCallHooks() {
+  return clearHooks(afterToolCallHooks);
+}
+var clear_after_tool_call_hooks = clearAfterToolCallHooks;
+function clearAllToolCallHooks() {
+  return [clearBeforeToolCallHooks(), clearAfterToolCallHooks()];
+}
+var clear_all_tool_call_hooks = clearAllToolCallHooks;
+function clearAllGlobalHooks() {
+  const llmHooks = clearAllLlmCallHooks();
+  const toolHooks = clearAllToolCallHooks();
+  return {
+    llm_hooks: llmHooks,
+    tool_hooks: toolHooks,
+    total: [llmHooks[0] + toolHooks[0], llmHooks[1] + toolHooks[1]]
+  };
+}
+var clear_all_global_hooks = clearAllGlobalHooks;
+function registerCrewScopedHooks(instance) {
+  const registered = [];
+  const seen = /* @__PURE__ */ new Set();
+  let prototype = Object.getPrototypeOf(instance);
+  while (prototype && prototype !== Object.prototype) {
+    for (const name of Reflect.ownKeys(prototype)) {
+      if (name === "constructor" || seen.has(name)) {
+        continue;
+      }
+      seen.add(name);
+      const descriptor = Object.getOwnPropertyDescriptor(prototype, name);
+      const method = getObjectProperty(descriptor, "value");
+      if (typeof method !== "function") {
+        continue;
+      }
+      registerCrewScopedHook(instance, method, registered);
+    }
+    prototype = Object.getPrototypeOf(prototype);
+  }
+  Object.defineProperty(instance, "_registered_hook_functions", {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value: registered
+  });
+  return registered;
+}
+function beforeLlmCall(value, context) {
+  if (typeof value === "function") {
+    if (context) {
+      markHook(value, "is_before_llm_call_hook", {});
+      return value;
+    }
+    return registerDecoratedHook(value, registerBeforeLlmCallHook, "is_before_llm_call_hook", {});
+  }
+  return createHookDecorator(registerBeforeLlmCallHook, "is_before_llm_call_hook", hookFilterOptions(value));
+}
+var before_llm_call = beforeLlmCall;
+function afterLlmCall(value, context) {
+  if (typeof value === "function") {
+    if (context) {
+      markHook(value, "is_after_llm_call_hook", {});
+      return value;
+    }
+    return registerDecoratedHook(value, registerAfterLlmCallHook, "is_after_llm_call_hook", {});
+  }
+  return createHookDecorator(registerAfterLlmCallHook, "is_after_llm_call_hook", hookFilterOptions(value));
+}
+var after_llm_call = afterLlmCall;
+function beforeToolCall(value, context) {
+  if (typeof value === "function") {
+    if (context) {
+      markHook(value, "is_before_tool_call_hook", {});
+      return value;
+    }
+    return registerDecoratedHook(value, registerBeforeToolCallHook, "is_before_tool_call_hook", {});
+  }
+  return createHookDecorator(registerBeforeToolCallHook, "is_before_tool_call_hook", hookFilterOptions(value));
+}
+var before_tool_call = beforeToolCall;
+function afterToolCall(value, context) {
+  if (typeof value === "function") {
+    if (context) {
+      markHook(value, "is_after_tool_call_hook", {});
+      return value;
+    }
+    return registerDecoratedHook(value, registerAfterToolCallHook, "is_after_tool_call_hook", {});
+  }
+  return createHookDecorator(registerAfterToolCallHook, "is_after_tool_call_hook", hookFilterOptions(value));
+}
+var after_tool_call = afterToolCall;
+async function runBeforeLlmCallHooks(context) {
+  for (const hook of beforeLlmCallHooks) {
+    if (await hook(context) === false) {
+      throw new Error("LLM call blocked by before_llm_call hook.");
+    }
+  }
+}
+async function runAfterLlmCallHooks(context) {
+  let response = context.response ?? "";
+  for (const hook of afterLlmCallHooks) {
+    context.response = response;
+    const replacement = await hook(context);
+    if (replacement !== null && replacement !== void 0) {
+      response = replacement;
+    }
+  }
+  return response;
+}
+async function runBeforeToolCallHooks(context) {
+  for (const hook of beforeToolCallHooks) {
+    if (await hook(context) === false) {
+      throw new Error(`Tool '${context.toolName}' execution blocked by before_tool_call hook.`);
+    }
+  }
+}
+async function runAfterToolCallHooks(context) {
+  let result = context.toolResult;
+  for (const hook of afterToolCallHooks) {
+    context.toolResult = result;
+    context.tool_result = result;
+    const replacement = await hook(context);
+    if (replacement !== null && replacement !== void 0) {
+      result = replacement;
+    }
+  }
+  return result;
+}
+function removeHook(hooks, hook) {
+  const index = hooks.indexOf(hook);
+  if (index < 0) {
+    return false;
+  }
+  hooks.splice(index, 1);
+  return true;
+}
+function clearHooks(hooks) {
+  const count = hooks.length;
+  hooks.length = 0;
+  return count;
+}
+function createHookDecorator(register, marker, options) {
+  const normalizedOptions = normalizeHookFilterOptions(options);
+  return ((targetOrHook, propertyKeyOrContext) => {
+    if (typeof targetOrHook === "function" && (propertyKeyOrContext === void 0 || isStandardDecoratorContext(propertyKeyOrContext))) {
+      markHook(targetOrHook, marker, normalizedOptions);
+      if (propertyKeyOrContext === void 0) {
+        registerFilteredHook(targetOrHook, register, normalizedOptions);
+      }
+      return targetOrHook;
+    }
+    if (propertyKeyOrContext === void 0 || typeof propertyKeyOrContext === "object") {
+      return void 0;
+    }
+    const target = targetOrHook;
+    const method = target[propertyKeyOrContext];
+    if (typeof method === "function") {
+      markHook(method, marker, normalizedOptions);
+    }
+    return void 0;
+  });
+}
+function registerDecoratedHook(hook, register, marker, options) {
+  const normalizedOptions = normalizeHookFilterOptions(options);
+  markHook(hook, marker, normalizedOptions);
+  registerFilteredHook(hook, register, normalizedOptions);
+  return hook;
+}
+function registerFilteredHook(hook, register, options) {
+  if (!options.tools?.length && !options.agents?.length) {
+    register(hook);
+    return;
+  }
+  register(((context) => {
+    if (!hookContextMatchesFilters(context, options)) {
+      return null;
+    }
+    return hook(context);
+  }));
+}
+function markHook(hook, marker, options) {
+  Object.assign(hook, {
+    [marker]: true,
+    ...options.agents?.length ? { agents: [...options.agents], _filter_agents: [...options.agents] } : {},
+    ...options.tools?.length ? { tools: [...options.tools], _filter_tools: [...options.tools] } : {}
+  });
+}
+function normalizeHookFilterOptions(options) {
+  return {
+    ...options.agents ? { agents: [...options.agents] } : {},
+    ...options.tools ? { tools: options.tools.map(sanitizeHookToolName) } : {}
+  };
+}
+function hookFilterOptions(options) {
+  return {
+    ...options.agents ? { agents: options.agents } : {},
+    ...options.tools ? { tools: options.tools } : {}
+  };
+}
+function hookContextMatchesFilters(context, options) {
+  if (options.tools?.length && hasStringProperty(context, "tool_name") && !options.tools.includes(context.tool_name)) {
+    return false;
+  }
+  const agent = getObjectProperty(context, "agent");
+  if (options.agents?.length && agent && hasStringProperty(agent, "role") && !options.agents.includes(agent.role)) {
+    return false;
+  }
+  return true;
+}
+function registerCrewScopedHook(instance, method, registered) {
+  const options = readHookFilterOptions(method);
+  if (hasBooleanProperty(method, "is_before_llm_call_hook")) {
+    const hook = ((context) => method.call(instance, context));
+    registerFilteredHook(hook, registerBeforeLlmCallHook, options);
+    registered.push(["before_llm_call", hook]);
+  }
+  if (hasBooleanProperty(method, "is_after_llm_call_hook")) {
+    const hook = ((context) => method.call(instance, context));
+    registerFilteredHook(hook, registerAfterLlmCallHook, options);
+    registered.push(["after_llm_call", hook]);
+  }
+  if (hasBooleanProperty(method, "is_before_tool_call_hook")) {
+    const hook = ((context) => method.call(instance, context));
+    registerFilteredHook(hook, registerBeforeToolCallHook, options);
+    registered.push(["before_tool_call", hook]);
+  }
+  if (hasBooleanProperty(method, "is_after_tool_call_hook")) {
+    const hook = ((context) => method.call(instance, context));
+    registerFilteredHook(hook, registerAfterToolCallHook, options);
+    registered.push(["after_tool_call", hook]);
+  }
+}
+function readHookFilterOptions(method) {
+  const agents = getStringArrayProperty(method, "_filter_agents") ?? getStringArrayProperty(method, "agents");
+  const tools = getStringArrayProperty(method, "_filter_tools") ?? getStringArrayProperty(method, "tools");
+  return {
+    ...agents ? { agents } : {},
+    ...tools ? { tools } : {}
+  };
+}
+function isStandardDecoratorContext(value) {
+  return typeof value === "object" && value !== null && "kind" in value;
+}
+function getObjectProperty(value, key) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && key in value ? value[key] : null;
+}
+function hasStringProperty(value, key) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && key in value && typeof value[key] === "string";
+}
+function hasBooleanProperty(value, key) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && key in value && typeof value[key] === "boolean";
+}
+function getStringArrayProperty(value, key) {
+  const property = getObjectProperty(value, key);
+  return Array.isArray(property) && property.every((item) => typeof item === "string") ? property : null;
+}
+function sanitizeHookToolName(name) {
+  return name.trim().replace(/[^\w-]/g, "_");
+}
+function requestHookHumanInput(source, prompt, defaultMessage) {
+  const formatter = resolveHookFormatter(source);
+  pauseHookFormatter(formatter);
+  try {
+    const promptFn = getObjectProperty(globalThis, "prompt");
+    const response = isHookPromptFunction(promptFn) ? promptFn(defaultMessage ?? prompt) : "";
+    if (response == null) {
+      return "";
+    }
+    if (typeof response === "string") {
+      return response.trim();
+    }
+    if (typeof response === "number" || typeof response === "boolean" || typeof response === "bigint") {
+      return response.toString().trim();
+    }
+    return "";
+  } finally {
+    resumeHookFormatter(formatter);
+  }
+}
+function isHookPromptFunction(value) {
+  return typeof value === "function";
+}
+function resolveHookFormatter(source) {
+  for (const candidate of hookContextCandidates(source)) {
+    const formatter = getObjectProperty(candidate, "formatter");
+    if (formatter) {
+      return formatter;
+    }
+    const eventListener = getObjectProperty(candidate, "event_listener") ?? getObjectProperty(candidate, "eventListener");
+    const listenerFormatter = getObjectProperty(eventListener, "formatter");
+    if (listenerFormatter) {
+      return listenerFormatter;
+    }
+  }
+  return null;
+}
+function hookContextCandidates(source) {
+  const candidates = [source];
+  for (const key of ["executor", "tool", "agent", "task", "crew"]) {
+    const value = getObjectProperty(source, key);
+    if (value) {
+      candidates.push(value);
+    }
+  }
+  return candidates;
+}
+function pauseHookFormatter(formatter) {
+  const pause = getObjectProperty(formatter, "pause_live_updates") ?? getObjectProperty(formatter, "pauseLiveUpdates");
+  if (typeof pause === "function") {
+    pause.call(formatter);
+  }
+}
+function resumeHookFormatter(formatter) {
+  const resume = getObjectProperty(formatter, "resume_live_updates") ?? getObjectProperty(formatter, "resumeLiveUpdates");
+  if (typeof resume === "function") {
+    resume.call(formatter);
+  }
+}
+function readHookExecutor(executor) {
+  if (!executor || typeof executor !== "object") {
+    return {};
+  }
+  const record = executor;
+  return {
+    ...Array.isArray(record.messages) ? { messages: record.messages } : {},
+    ..."llm" in record ? { llm: record.llm } : {},
+    ..."agent" in record ? { agent: record.agent } : {},
+    ..."task" in record ? { task: record.task } : {},
+    ..."crew" in record ? { crew: record.crew } : {},
+    ...typeof record.iterations === "number" ? { iterations: record.iterations } : {}
+  };
+}
+
+export {
+  LLMCallHookContext,
+  ToolCallHookContext,
+  ContextT,
+  ReturnT,
+  P,
+  R,
+  U,
+  Hook,
+  HTTPTransportKwargs,
+  BaseInterceptor,
+  _validate_interceptor,
+  AsyncHTTPTransport,
+  HTTPTransport,
+  BeforeLLMCallHook,
+  AfterLLMCallHook,
+  BeforeToolCallHook,
+  AfterToolCallHook,
+  BeforeLLMCallHookType,
+  AfterLLMCallHookType,
+  BeforeToolCallHookType,
+  AfterToolCallHookType,
+  BeforeLLMCallHookCallable,
+  AfterLLMCallHookCallable,
+  BeforeToolCallHookCallable,
+  AfterToolCallHookCallable,
+  BeforeLLMCallHookMethod,
+  AfterLLMCallHookMethod,
+  BeforeToolCallHookMethod,
+  AfterToolCallHookMethod,
+  registerBeforeLlmCallHook,
+  register_before_llm_call_hook,
+  registerAfterLlmCallHook,
+  register_after_llm_call_hook,
+  getBeforeLlmCallHooks,
+  get_before_llm_call_hooks,
+  getAfterLlmCallHooks,
+  get_after_llm_call_hooks,
+  unregisterBeforeLlmCallHook,
+  unregister_before_llm_call_hook,
+  unregisterAfterLlmCallHook,
+  unregister_after_llm_call_hook,
+  clearBeforeLlmCallHooks,
+  clear_before_llm_call_hooks,
+  clearAfterLlmCallHooks,
+  clear_after_llm_call_hooks,
+  clearAllLlmCallHooks,
+  clear_all_llm_call_hooks,
+  registerBeforeToolCallHook,
+  register_before_tool_call_hook,
+  registerAfterToolCallHook,
+  register_after_tool_call_hook,
+  getBeforeToolCallHooks,
+  get_before_tool_call_hooks,
+  getAfterToolCallHooks,
+  get_after_tool_call_hooks,
+  unregisterBeforeToolCallHook,
+  unregister_before_tool_call_hook,
+  unregisterAfterToolCallHook,
+  unregister_after_tool_call_hook,
+  clearBeforeToolCallHooks,
+  clear_before_tool_call_hooks,
+  clearAfterToolCallHooks,
+  clear_after_tool_call_hooks,
+  clearAllToolCallHooks,
+  clear_all_tool_call_hooks,
+  clearAllGlobalHooks,
+  clear_all_global_hooks,
+  registerCrewScopedHooks,
+  beforeLlmCall,
+  before_llm_call,
+  afterLlmCall,
+  after_llm_call,
+  beforeToolCall,
+  before_tool_call,
+  afterToolCall,
+  after_tool_call,
+  runBeforeLlmCallHooks,
+  runAfterLlmCallHooks,
+  runBeforeToolCallHooks,
+  runAfterToolCallHooks
+};