@knocklabs/agent-toolkit 0.1.8 → 0.1.10

package/dist/chunk-6O7VMHBN.js

@@ -0,0 +1,57 @@
+// src/lib/human-in-the-loop/index.ts
+function wrapToolDescription(description) {
+  return `${description}
+
+This tool call is deferred. You will NOT receive a result from this tool but this is NOT an error. Do NOT retry the tool call as the result will be the same. The tool call result will be provided to you in the future.`;
+}
+async function triggerHumanInTheLoopWorkflow({
+  knockClient,
+  config,
+  toolCall,
+  inputConfig
+}) {
+  const knock = await knockClient.publicApi(config.environment);
+  const result = await knock.workflows.trigger(inputConfig.workflow, {
+    data: {
+      type: "deferred_tool_call",
+      tool_call: toolCall,
+      metadata: inputConfig.metadata
+    },
+    recipients: inputConfig.recipients,
+    tenant: inputConfig.tenant,
+    actor: inputConfig.actor
+  });
+  return result;
+}
+function handleMessageInteraction(event) {
+  const { data: message } = event;
+  if (event.type !== "message.interacted") {
+    return null;
+  }
+  if (message.data.type !== "deferred_tool_call" || !message.data.tool_call) {
+    return null;
+  }
+  const messageData = message.data;
+  return {
+    workflow: message.source.key,
+    interaction: event.event_data,
+    toolCall: {
+      method: messageData.tool_call.method,
+      args: messageData.tool_call.args,
+      extra: messageData.tool_call.extra
+    },
+    metadata: messageData.metadata,
+    context: {
+      messageId: message.id,
+      channelId: message.channel_id,
+      timestamp: event.created_at
+    }
+  };
+}
+
+export {
+  wrapToolDescription,
+  triggerHumanInTheLoopWorkflow,
+  handleMessageInteraction
+};
+//# sourceMappingURL=chunk-6O7VMHBN.js.map

package/dist/chunk-6O7VMHBN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/human-in-the-loop/index.ts"],"sourcesContent":["import { Config } from \"@/types\";\n\nimport { KnockClient } from \"../knock-client\";\n\nimport {\n  DeferredToolCallWorkflowData,\n  DeferredToolCallConfig,\n  KnockOutboundWebhookEvent,\n  DeferredToolCall,\n  DeferredToolCallInteractionResult,\n} from \"./types\";\n\nfunction wrapToolDescription(description: string) {\n  return `${description}\\n\\nThis tool call is deferred. You will NOT receive a result from this tool but this is NOT an error. Do NOT retry the tool call as the result will be the same. The tool call result will be provided to you in the future.`;\n}\n\n/**\n * Triggers a human in the loop workflow.\n *\n * @param knockClient - The Knock client to use.\n * @param toolCall - The tool call to trigger.\n * @param config - The configuration to use.\n */\nasync function triggerHumanInTheLoopWorkflow({\n  knockClient,\n  config,\n  toolCall,\n  inputConfig,\n}: {\n  knockClient: KnockClient;\n  config: Config;\n  toolCall: DeferredToolCall;\n  inputConfig: DeferredToolCallConfig;\n}) {\n  const knock = await knockClient.publicApi(config.environment);\n\n  const result = await knock.workflows.trigger(inputConfig.workflow, {\n    data: {\n      type: \"deferred_tool_call\",\n      tool_call: toolCall,\n      metadata: inputConfig.metadata,\n    } as DeferredToolCallWorkflowData,\n    recipients: inputConfig.recipients,\n    tenant: inputConfig.tenant,\n    actor: inputConfig.actor,\n  });\n\n  return result;\n}\n\n/**\n * Given an outboundwebhook event, this function will parse the event into a normalized format.\n *\n * If the event is not associated with a deferred tool call, this function will return null.\n *\n * @param event - The outbound webhook event\n * @returns A deferred tool call interaction result, or null if the event is not a deferred tool call\n */\nfunction handleMessageInteraction(\n  event: KnockOutboundWebhookEvent\n): DeferredToolCallInteractionResult | null {\n  const { data: message } = event;\n\n  // We only care about message.interacted events\n  if (event.type !== \"message.interacted\") {\n    return null;\n  }\n\n  // We only care about messages that contain a tool call\n  if (message.data.type !== \"deferred_tool_call\" || !message.data.tool_call) {\n    return null;\n  }\n\n  const messageData = message.data as DeferredToolCallWorkflowData;\n\n  return {\n    workflow: message.source.key,\n    interaction: event.event_data,\n    toolCall: {\n      method: messageData.tool_call.method,\n      args: messageData.tool_call.args,\n      extra: messageData.tool_call.extra,\n    },\n    metadata: messageData.metadata,\n    context: {\n      messageId: message.id,\n      channelId: message.channel_id,\n      timestamp: event.created_at,\n    },\n  };\n}\n\nexport {\n  handleMessageInteraction,\n  triggerHumanInTheLoopWorkflow,\n  wrapToolDescription,\n};\n"],"mappings":";AAYA,SAAS,oBAAoB,aAAqB;AAChD,SAAO,GAAG,WAAW;AAAA;AAAA;AACvB;AASA,eAAe,8BAA8B;AAAA,EAC3C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAKG;AACD,QAAM,QAAQ,MAAM,YAAY,UAAU,OAAO,WAAW;AAE5D,QAAM,SAAS,MAAM,MAAM,UAAU,QAAQ,YAAY,UAAU;AAAA,IACjE,MAAM;AAAA,MACJ,MAAM;AAAA,MACN,WAAW;AAAA,MACX,UAAU,YAAY;AAAA,IACxB;AAAA,IACA,YAAY,YAAY;AAAA,IACxB,QAAQ,YAAY;AAAA,IACpB,OAAO,YAAY;AAAA,EACrB,CAAC;AAED,SAAO;AACT;AAUA,SAAS,yBACP,OAC0C;AAC1C,QAAM,EAAE,MAAM,QAAQ,IAAI;AAG1B,MAAI,MAAM,SAAS,sBAAsB;AACvC,WAAO;AAAA,EACT;AAGA,MAAI,QAAQ,KAAK,SAAS,wBAAwB,CAAC,QAAQ,KAAK,WAAW;AACzE,WAAO;AAAA,EACT;AAEA,QAAM,cAAc,QAAQ;AAE5B,SAAO;AAAA,IACL,UAAU,QAAQ,OAAO;AAAA,IACzB,aAAa,MAAM;AAAA,IACnB,UAAU;AAAA,MACR,QAAQ,YAAY,UAAU;AAAA,MAC9B,MAAM,YAAY,UAAU;AAAA,MAC5B,OAAO,YAAY,UAAU;AAAA,IAC/B;AAAA,IACA,UAAU,YAAY;AAAA,IACtB,SAAS;AAAA,MACP,WAAW,QAAQ;AAAA,MACnB,WAAW,QAAQ;AAAA,MACnB,WAAW,MAAM;AAAA,IACnB;AAAA,EACF;AACF;","names":[]}

package/dist/{chunk-WXHVAABP.js → chunk-C7RK7AZJ.js}

@@ -1,14 +1,14 @@
 import {
   allTools,
   createWorkflowTools
-} from "./chunk-JBEVT2QK.js";
+} from "./chunk-25NTCHCG.js";
 
 // src/modelcontextprotocol/adapter.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 var KnockMcpServer = class extends McpServer {
   constructor(knockClient, config, tools) {
-    super({ name: "Knock", version: "0.1.8" });
+    super({ name: "Knock", version: "0.1.10" });
     tools.forEach((tool) => {
       const toolParams = tool.parameters ?? z.object({});
       this.tool(
@@ -28,10 +28,14 @@ var KnockMcpServer = class extends McpServer {
 
 // src/modelcontextprotocol/index.ts
 var createKnockMcpServer = async (params) => {
-  const { tools, knockClient, config } = params;
+  const { tools, knockClient, config, workflows } = params;
   let baseTools = tools || Object.values(allTools);
-  if (baseTools.some((tool) => tool.method === "list_workflows")) {
-    const workflowTools = await createWorkflowTools(knockClient, config);
+  if (workflows && Array.isArray(workflows) && workflows.length > 0) {
+    const workflowTools = await createWorkflowTools(
+      knockClient,
+      config,
+      workflows
+    );
     baseTools = [...baseTools, ...workflowTools];
   }
   return Promise.resolve(new KnockMcpServer(knockClient, config, baseTools));
@@ -40,4 +44,4 @@ var createKnockMcpServer = async (params) => {
 export {
   createKnockMcpServer
 };
-//# sourceMappingURL=chunk-WXHVAABP.js.map
+//# sourceMappingURL=chunk-C7RK7AZJ.js.map

package/dist/chunk-C7RK7AZJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/modelcontextprotocol/adapter.ts","../src/modelcontextprotocol/index.ts"],"sourcesContent":["import { McpServer } from \"@modelcontextprotocol/sdk/server/mcp.js\";\nimport { z } from \"zod\";\n\nimport { KnockClient } from \"../lib/knock-client.js\";\nimport type { KnockTool } from \"../lib/knock-tool.js\";\nimport { Config } from \"../types.js\";\n\nexport class KnockMcpServer extends McpServer {\n  constructor(knockClient: KnockClient, config: Config, tools: KnockTool[]) {\n    super({ name: \"Knock\", version: PACKAGE_VERSION });\n\n    tools.forEach((tool) => {\n      const toolParams = tool.parameters ?? z.object({});\n\n      this.tool(\n        tool.method,\n        tool.description,\n        toolParams.shape,\n        async (arg: unknown) => {\n          const res = await tool.bindExecute(knockClient, config)(arg);\n\n          return {\n            content: [{ type: \"text\" as const, text: JSON.stringify(res) }],\n          };\n        }\n      );\n    });\n  }\n}\n","import { KnockClient } from \"../lib/knock-client.js\";\nimport type { KnockTool } from \"../lib/knock-tool.js\";\nimport { allTools } from \"../lib/tools/index.js\";\nimport { createWorkflowTools } from \"../lib/tools/workflows-as-tools.js\";\nimport { Config } from \"../types.js\";\n\nimport { KnockMcpServer } from \"./adapter.js\";\n\ntype CreateKnockMcpServerParams = {\n  /**\n   * Array of Knock tools to enable in the server.\n   */\n  tools?: KnockTool[];\n\n  /**\n   * A Knock client to use for the server.\n   */\n  knockClient: KnockClient;\n\n  /**\n   * The config to use for the server.\n   */\n  config: Config;\n\n  /**\n   * The workflows to enable as tools in the MCP server.\n   */\n  workflows?: string[];\n};\n\n/**\n * Creates a Knock MCP Server with the given parameters.\n */\nexport const createKnockMcpServer = async (\n  params: CreateKnockMcpServerParams\n): Promise<KnockMcpServer> => {\n  const { tools, knockClient, config, workflows } = params;\n\n  let baseTools = tools || Object.values(allTools);\n\n  if (workflows && Array.isArray(workflows) && workflows.length > 0) {\n    const workflowTools = await createWorkflowTools(\n      knockClient,\n      config,\n      workflows\n    );\n\n    baseTools = [...baseTools, ...workflowTools];\n  }\n\n  return Promise.resolve(new KnockMcpServer(knockClient, config, baseTools));\n};\n"],"mappings":";;;;;;AAAA,SAAS,iBAAiB;AAC1B,SAAS,SAAS;AAMX,IAAM,iBAAN,cAA6B,UAAU;AAAA,EAC5C,YAAY,aAA0B,QAAgB,OAAoB;AACxE,UAAM,EAAE,MAAM,SAAS,SAAS,SAAgB,CAAC;AAEjD,UAAM,QAAQ,CAAC,SAAS;AACtB,YAAM,aAAa,KAAK,cAAc,EAAE,OAAO,CAAC,CAAC;AAEjD,WAAK;AAAA,QACH,KAAK;AAAA,QACL,KAAK;AAAA,QACL,WAAW;AAAA,QACX,OAAO,QAAiB;AACtB,gBAAM,MAAM,MAAM,KAAK,YAAY,aAAa,MAAM,EAAE,GAAG;AAE3D,iBAAO;AAAA,YACL,SAAS,CAAC,EAAE,MAAM,QAAiB,MAAM,KAAK,UAAU,GAAG,EAAE,CAAC;AAAA,UAChE;AAAA,QACF;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AACF;;;ACKO,IAAM,uBAAuB,OAClC,WAC4B;AAC5B,QAAM,EAAE,OAAO,aAAa,QAAQ,UAAU,IAAI;AAElD,MAAI,YAAY,SAAS,OAAO,OAAO,QAAQ;AAE/C,MAAI,aAAa,MAAM,QAAQ,SAAS,KAAK,UAAU,SAAS,GAAG;AACjE,UAAM,gBAAgB,MAAM;AAAA,MAC1B;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAEA,gBAAY,CAAC,GAAG,WAAW,GAAG,aAAa;AAAA,EAC7C;AAEA,SAAO,QAAQ,QAAQ,IAAI,eAAe,aAAa,QAAQ,SAAS,CAAC;AAC3E;","names":[]}

package/dist/chunk-G3PMV62Z.js

@@ -0,0 +1,36 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __export,
+  __toESM
+};
+//# sourceMappingURL=chunk-G3PMV62Z.js.map

package/dist/chunk-G3PMV62Z.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/human-in-the-loop.d.ts

@@ -0,0 +1,33 @@
+import * as _knocklabs_node from '@knocklabs/node';
+import { Config } from './types.js';
+import { K as KnockClient } from './knock-client-BH7Juvis.js';
+import { K as KnockOutboundWebhookEvent, D as DeferredToolCallInteractionResult, a as DeferredToolCall, b as DeferredToolCallConfig } from './types-CrTRlRnE.js';
+export { c as DeferredToolCallWorkflowData } from './types-CrTRlRnE.js';
+import '@knocklabs/mgmt';
+import '@knocklabs/node/dist/src/resources/messages/interfaces';
+
+declare function wrapToolDescription(description: string): string;
+/**
+ * Triggers a human in the loop workflow.
+ *
+ * @param knockClient - The Knock client to use.
+ * @param toolCall - The tool call to trigger.
+ * @param config - The configuration to use.
+ */
+declare function triggerHumanInTheLoopWorkflow({ knockClient, config, toolCall, inputConfig, }: {
+    knockClient: KnockClient;
+    config: Config;
+    toolCall: DeferredToolCall;
+    inputConfig: DeferredToolCallConfig;
+}): Promise<_knocklabs_node.WorkflowRun>;
+/**
+ * Given an outboundwebhook event, this function will parse the event into a normalized format.
+ *
+ * If the event is not associated with a deferred tool call, this function will return null.
+ *
+ * @param event - The outbound webhook event
+ * @returns A deferred tool call interaction result, or null if the event is not a deferred tool call
+ */
+declare function handleMessageInteraction(event: KnockOutboundWebhookEvent): DeferredToolCallInteractionResult | null;
+
+export { DeferredToolCall, DeferredToolCallConfig, DeferredToolCallInteractionResult, KnockOutboundWebhookEvent, handleMessageInteraction, triggerHumanInTheLoopWorkflow, wrapToolDescription };

package/dist/human-in-the-loop.js

@@ -0,0 +1,12 @@
+import {
+  handleMessageInteraction,
+  triggerHumanInTheLoopWorkflow,
+  wrapToolDescription
+} from "./chunk-6O7VMHBN.js";
+import "./chunk-G3PMV62Z.js";
+export {
+  handleMessageInteraction,
+  triggerHumanInTheLoopWorkflow,
+  wrapToolDescription
+};
+//# sourceMappingURL=human-in-the-loop.js.map

package/dist/human-in-the-loop.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/knock-client-BH7Juvis.d.ts

@@ -0,0 +1,10 @@
+import KnockMgmt from '@knocklabs/mgmt';
+import { Knock } from '@knocklabs/node';
+import { Config } from './types.js';
+
+type KnockClient = ReturnType<typeof createKnockClient>;
+declare const createKnockClient: (config: Config) => KnockMgmt & {
+    publicApi: (environmentSlug?: string) => Promise<Knock>;
+};
+
+export type { KnockClient as K };

package/dist/langchain/index.d.ts

@@ -0,0 +1,17 @@
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { ToolkitConfig, ToolCategory } from '../types.js';
+
+type KnockToolkit = {
+    getAllTools: () => DynamicStructuredTool[];
+    getTools: (category: ToolCategory) => DynamicStructuredTool[];
+    getToolMap: () => Record<string, DynamicStructuredTool>;
+};
+/**
+ * Create a toolkit for use with the LangChain framework.
+ *
+ * @param config - The configuration to use for the toolkit
+ * @returns A toolkit for use with the LangChain framework
+ */
+declare const createKnockToolkit: (config: ToolkitConfig) => Promise<KnockToolkit>;
+
+export { createKnockToolkit };