@mondaydotcomorg/atp-langchain 0.20.1 → 0.20.3

package/dist/index.js

@@ -1,5 +1,580 @@
-export { createATPTools as createATPToolsBasic, convertToLangChainTools } from './tools.js';
-export * from './langgraph-client.js';
-export { createATPTools, createSimpleATPTool, } from './langgraph-tools.js';
-export * from './node.js';
+import { ClientCallbackError, AgentToolProtocolClient, createToolsFromATPClient, ToolNames } from '@mondaydotcomorg/atp-client';
+import { DynamicTool, Tool, DynamicStructuredTool } from '@langchain/core/tools';
+import { log } from '@mondaydotcomorg/atp-runtime';
+import { SystemMessage, HumanMessage } from '@langchain/core/messages';
+import { ExecutionStatus, ATPEventType } from '@mondaydotcomorg/atp-protocol';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+async function createATPTools(serverUrl, headers, hooks) {
+  const client = new AgentToolProtocolClient({
+    baseUrl: serverUrl,
+    headers,
+    hooks
+  });
+  await client.connect();
+  const atpTools = createToolsFromATPClient(client);
+  const tools = atpTools.map((tool) => new DynamicTool({
+    name: tool.name,
+    description: tool.description || "",
+    func: tool.func
+  }));
+  return {
+    client,
+    tools
+  };
+}
+__name(createATPTools, "createATPTools");
+function convertToLangChainTools(tools) {
+  return tools.map((tool) => new DynamicTool({
+    name: tool.name,
+    description: tool.description || "",
+    func: tool.func
+  }));
+}
+__name(convertToLangChainTools, "convertToLangChainTools");
+var ApprovalRequiredException = class extends ClientCallbackError {
+  static {
+    __name(this, "ApprovalRequiredException");
+  }
+  approvalRequest;
+  constructor(approvalRequest) {
+    super(`Approval required: ${approvalRequest.message}`);
+    this.approvalRequest = approvalRequest;
+    this.name = "ApprovalRequiredException";
+  }
+};
+var LangGraphATPClient = class {
+  static {
+    __name(this, "LangGraphATPClient");
+  }
+  client;
+  llm;
+  embeddings;
+  useLangGraphInterrupts;
+  directApprovalHandler;
+  pendingApprovals = /* @__PURE__ */ new Map();
+  constructor(options) {
+    const { serverUrl, headers, llm, embeddings, tools, useLangGraphInterrupts = true, approvalHandler, hooks } = options;
+    this.client = new AgentToolProtocolClient({
+      baseUrl: serverUrl,
+      headers,
+      hooks,
+      serviceProviders: tools ? {
+        tools
+      } : void 0
+    });
+    this.llm = llm;
+    this.embeddings = embeddings;
+    this.useLangGraphInterrupts = useLangGraphInterrupts;
+    this.directApprovalHandler = approvalHandler;
+    this.client.provideLLM({
+      call: /* @__PURE__ */ __name(async (prompt, options2) => {
+        return await this.handleLLMCall(prompt, options2);
+      }, "call"),
+      extract: /* @__PURE__ */ __name(async (prompt, schema, options2) => {
+        return await this.handleLLMExtract(prompt, schema, options2);
+      }, "extract"),
+      classify: /* @__PURE__ */ __name(async (text, categories, options2) => {
+        return await this.handleLLMClassify(text, categories, options2);
+      }, "classify")
+    });
+    if (this.embeddings) {
+      this.client.provideEmbedding({
+        embed: /* @__PURE__ */ __name(async (text) => {
+          return await this.handleEmbedding(text);
+        }, "embed")
+      });
+    }
+    this.client.provideApproval({
+      request: /* @__PURE__ */ __name(async (message, context) => {
+        return await this.handleApprovalRequest(message, context);
+      }, "request")
+    });
+  }
+  /**
+  * Initialize the client connection
+  */
+  async connect() {
+    await this.client.init({
+      name: "langgraph-atp-client",
+      version: "1.0.0"
+    });
+    await this.client.connect();
+  }
+  /**
+  * Get TypeScript API definitions
+  */
+  getTypeDefinitions() {
+    return this.client.getTypeDefinitions();
+  }
+  /**
+  * Execute ATP code with LangGraph interrupt support
+  *
+  * When approval is needed:
+  * - If useLangGraphInterrupts=true: Throws ApprovalRequiredException
+  * - If useLangGraphInterrupts=false: Uses direct approval handler
+  *
+  * @throws ApprovalRequiredException when approval is needed (interrupt mode)
+  */
+  async execute(code, config) {
+    const result = await this.client.execute(code, config);
+    return {
+      result,
+      needsApproval: false
+    };
+  }
+  /**
+  * Resume execution after approval decision
+  *
+  * Call this after LangGraph resumes from interrupt with approval decision.
+  */
+  async resumeWithApproval(executionId, approved, reason) {
+    const approvalResponse = {
+      approved,
+      reason,
+      timestamp: Date.now()
+    };
+    this.pendingApprovals.delete(executionId);
+    return await this.client.resume(executionId, approvalResponse);
+  }
+  /**
+  * Get pending approval request for an execution
+  */
+  getPendingApproval(executionId) {
+    return this.pendingApprovals.get(executionId);
+  }
+  /**
+  * Handle LLM call - route to LangChain LLM
+  */
+  async handleLLMCall(prompt, options) {
+    const messages = [];
+    if (options?.systemPrompt) {
+      messages.push(new SystemMessage(options.systemPrompt));
+    }
+    messages.push(new HumanMessage(prompt));
+    const response = await this.llm.invoke(messages);
+    return typeof response.content === "string" ? response.content : JSON.stringify(response.content);
+  }
+  /**
+  * Handle LLM extract - route to LangChain LLM with structured output
+  */
+  async handleLLMExtract(prompt, schema, options) {
+    const structuredLLM = this.llm.withStructuredOutput(schema);
+    const messages = [];
+    if (options?.systemPrompt) {
+      messages.push(new SystemMessage(options.systemPrompt));
+    }
+    messages.push(new HumanMessage(prompt));
+    const result = await structuredLLM.invoke(messages);
+    return result;
+  }
+  /**
+  * Handle LLM classify - route to LangChain LLM
+  */
+  async handleLLMClassify(text, categories, options) {
+    const prompt = `Classify the following text into one of these categories: ${categories.join(", ")}
+
+Text: ${text}
+
+Category:`;
+    const messages = [];
+    if (options?.systemPrompt) {
+      messages.push(new SystemMessage(options.systemPrompt));
+    }
+    messages.push(new HumanMessage(prompt));
+    const response = await this.llm.invoke(messages);
+    const result = typeof response.content === "string" ? response.content.trim() : JSON.stringify(response.content).trim();
+    if (!categories.includes(result)) {
+      for (const category of categories) {
+        if (result.toLowerCase().includes(category.toLowerCase())) {
+          return category;
+        }
+      }
+      const fallback = categories[0];
+      if (!fallback) {
+        throw new Error("No categories provided for classification");
+      }
+      return fallback;
+    }
+    return result;
+  }
+  /**
+  * Handle embedding - route to LangChain embeddings model
+  */
+  async handleEmbedding(text) {
+    if (!this.embeddings) {
+      throw new Error("Embeddings model not provided. Pass embeddings option when creating LangGraphATPClient.");
+    }
+    return await this.embeddings.embedQuery(text);
+  }
+  /**
+  * Get the underlying ATP client for advanced usage
+  */
+  getUnderlyingClient() {
+    return this.client;
+  }
+  async handleApprovalRequest(message, context) {
+    const executionId = context?.executionId;
+    const cleanContext = context ? {
+      ...context
+    } : void 0;
+    if (cleanContext) {
+      delete cleanContext.executionId;
+    }
+    if (this.useLangGraphInterrupts) {
+      if (typeof executionId !== "string" || !executionId) {
+        throw new Error("executionId is missing in approval request context");
+      }
+      const approvalRequest = {
+        message,
+        context: cleanContext,
+        executionId,
+        timestamp: Date.now()
+      };
+      this.pendingApprovals.set(executionId, approvalRequest);
+      throw new ApprovalRequiredException(approvalRequest);
+    }
+    if (this.directApprovalHandler) {
+      const approved = await this.directApprovalHandler(message, cleanContext);
+      return {
+        approved,
+        timestamp: Date.now()
+      };
+    }
+    log.warn(`Approval request rejected (no handler): ${message}`);
+    return {
+      approved: false,
+      timestamp: Date.now()
+    };
+  }
+};
+async function createATPTools2(options) {
+  const { serverUrl, defaultExecutionConfig, ...clientOptions } = options;
+  const client = new LangGraphATPClient({
+    serverUrl,
+    ...clientOptions
+  });
+  await client.connect();
+  const atpTools = createToolsFromATPClient(client.getUnderlyingClient());
+  const tools = atpTools.map((atpTool) => {
+    if (atpTool.name === ToolNames.EXECUTE_CODE) {
+      let ATPExecuteTool = class ATPExecuteTool extends Tool {
+        static {
+          __name(this, "ATPExecuteTool");
+        }
+        name = `atp_${atpTool.name}`;
+        description = atpTool.description || "Execute TypeScript code in ATP sandbox";
+        async _call(input) {
+          try {
+            let code;
+            try {
+              const parsed = JSON.parse(input);
+              code = parsed.code || input;
+            } catch {
+              code = input;
+            }
+            const result = await client.execute(code, defaultExecutionConfig);
+            if (result.result.status === ExecutionStatus.COMPLETED) {
+              return JSON.stringify({
+                success: true,
+                result: result.result.result,
+                stats: result.result.stats
+              }, null, 2);
+            } else if (result.result.status === ExecutionStatus.FAILED) {
+              return JSON.stringify({
+                success: false,
+                error: result.result.error,
+                stats: result.result.stats
+              }, null, 2);
+            } else {
+              return JSON.stringify({
+                success: false,
+                error: "Execution in unexpected state: " + result.result.status
+              }, null, 2);
+            }
+          } catch (error) {
+            if (error instanceof ApprovalRequiredException) {
+              throw error;
+            }
+            return JSON.stringify({
+              success: false,
+              error: error.message || "Unknown error"
+            }, null, 2);
+          }
+        }
+      };
+      return new ATPExecuteTool();
+    }
+    return new DynamicStructuredTool({
+      name: `atp_${atpTool.name}`,
+      description: atpTool.description || "",
+      schema: atpTool.zodSchema || atpTool.inputSchema,
+      func: /* @__PURE__ */ __name(async (input) => {
+        try {
+          const result = await atpTool.func(input);
+          return typeof result === "string" ? result : JSON.stringify(result, null, 2);
+        } catch (error) {
+          return JSON.stringify({
+            success: false,
+            error: error.message
+          }, null, 2);
+        }
+      }, "func")
+    });
+  });
+  return {
+    client,
+    tools,
+    isApprovalRequired: /* @__PURE__ */ __name((error) => {
+      return error instanceof ApprovalRequiredException;
+    }, "isApprovalRequired"),
+    resumeWithApproval: /* @__PURE__ */ __name(async (executionId, approved, reason) => {
+      return await client.resumeWithApproval(executionId, approved, reason);
+    }, "resumeWithApproval")
+  };
+}
+__name(createATPTools2, "createATPTools");
+async function createSimpleATPTool(serverUrl, llm, headers) {
+  const result = await createATPTools2({
+    serverUrl,
+    headers,
+    llm
+  });
+  const tool = result.tools.find((t) => t.name === `atp_${ToolNames.EXECUTE_CODE}`);
+  if (!tool) {
+    throw new Error("Failed to create ATP execute_code tool");
+  }
+  return tool;
+}
+__name(createSimpleATPTool, "createSimpleATPTool");
+function createLangChainEventHandler(onEvent, options = {}) {
+  const { tags = [], metadata = {} } = options;
+  return (event) => {
+    const baseEvent = {
+      run_id: event.runId,
+      tags: [
+        "atp",
+        ...tags
+      ],
+      metadata: {
+        ...metadata,
+        timestamp: event.timestamp
+      }
+    };
+    switch (event.type) {
+      case ATPEventType.THINKING: {
+        const data = event.data;
+        onEvent({
+          ...baseEvent,
+          event: "on_llm_stream",
+          name: "atp_thinking",
+          data: {
+            chunk: data.content,
+            step: data.step
+          }
+        });
+        break;
+      }
+      case ATPEventType.TOOL_START: {
+        const data = event.data;
+        onEvent({
+          ...baseEvent,
+          event: "on_tool_start",
+          name: `${data.apiGroup}.${data.toolName}`,
+          data: {
+            input: data.input
+          },
+          metadata: {
+            ...baseEvent.metadata,
+            apiGroup: data.apiGroup,
+            toolName: data.toolName
+          }
+        });
+        break;
+      }
+      case ATPEventType.TOOL_END: {
+        const data = event.data;
+        onEvent({
+          ...baseEvent,
+          event: "on_tool_end",
+          name: `${data.apiGroup}.${data.toolName}`,
+          data: {
+            output: data.output,
+            error: data.error
+          },
+          metadata: {
+            ...baseEvent.metadata,
+            apiGroup: data.apiGroup,
+            toolName: data.toolName,
+            duration: data.duration,
+            success: data.success
+          }
+        });
+        break;
+      }
+      case ATPEventType.TEXT: {
+        const data = event.data;
+        onEvent({
+          ...baseEvent,
+          event: "on_chain_stream",
+          name: "atp_output",
+          data: {
+            chunk: data.text
+          }
+        });
+        break;
+      }
+      case ATPEventType.TEXT_END:
+        onEvent({
+          ...baseEvent,
+          event: "on_chain_end",
+          name: "atp_output",
+          data: {}
+        });
+        break;
+      case ATPEventType.SOURCE: {
+        const data = event.data;
+        onEvent({
+          ...baseEvent,
+          event: "on_custom_event",
+          name: "atp_source",
+          data: {
+            url: data.url,
+            title: data.title,
+            summary: data.summary,
+            createdAt: data.createdAt
+          }
+        });
+        break;
+      }
+      case ATPEventType.PROGRESS: {
+        const data = event.data;
+        onEvent({
+          ...baseEvent,
+          event: "on_custom_event",
+          name: "atp_progress",
+          data: {
+            message: data.message,
+            fraction: data.fraction,
+            percentage: Math.round(data.fraction * 100)
+          }
+        });
+        break;
+      }
+      case ATPEventType.ERROR: {
+        const data = event.data;
+        onEvent({
+          ...baseEvent,
+          event: "on_chain_error",
+          name: "atp_error",
+          data: {
+            error: data.message,
+            code: data.code
+          }
+        });
+        break;
+      }
+      default:
+        onEvent({
+          ...baseEvent,
+          event: "on_custom_event",
+          name: `atp_${event.type}`,
+          data: event.data
+        });
+        break;
+    }
+  };
+}
+__name(createLangChainEventHandler, "createLangChainEventHandler");
+function createCallbackManagerHandler(callbackManager) {
+  return (event) => {
+    switch (event.type) {
+      case ATPEventType.THINKING: {
+        const data = event.data;
+        callbackManager.handleLLMNewToken?.(data.content, void 0, event.runId);
+        break;
+      }
+      case ATPEventType.TOOL_START: {
+        const data = event.data;
+        callbackManager.handleToolStart?.({
+          name: `${data.apiGroup}.${data.toolName}`
+        }, JSON.stringify(data.input), event.runId, void 0, [
+          "atp"
+        ], {
+          apiGroup: data.apiGroup
+        });
+        break;
+      }
+      case ATPEventType.TOOL_END: {
+        const data = event.data;
+        callbackManager.handleToolEnd?.(JSON.stringify(data.output), event.runId, void 0, [
+          "atp"
+        ]);
+        break;
+      }
+      case ATPEventType.TEXT: {
+        const data = event.data;
+        callbackManager.handleLLMNewToken?.(data.text, void 0, event.runId);
+        break;
+      }
+      default:
+        callbackManager.handleCustomEvent?.(`atp_${event.type}`, event.data, event.runId, [
+          "atp"
+        ], {
+          timestamp: event.timestamp
+        });
+        break;
+    }
+  };
+}
+__name(createCallbackManagerHandler, "createCallbackManagerHandler");
+var ATPExecutionNode = class {
+  static {
+    __name(this, "ATPExecutionNode");
+  }
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+  * Execute code from the state and update the state with results
+  */
+  async execute(state) {
+    if (!state.code) {
+      throw new Error("No code provided in state");
+    }
+    const result = await this.client.execute(state.code);
+    return {
+      ...state,
+      executionResult: result,
+      lastExecutionStatus: result.status,
+      lastExecutionOutput: result.status === ExecutionStatus.COMPLETED ? result.result : result.error
+    };
+  }
+  /**
+  * Create a function suitable for LangGraph node
+  */
+  asFunction() {
+    return this.execute.bind(this);
+  }
+};
+function createATPNode(client) {
+  return async (state) => {
+    if (!state.code) {
+      throw new Error("No code provided in state");
+    }
+    const result = await client.execute(state.code);
+    return {
+      ...state,
+      executionResult: result,
+      lastExecutionStatus: result.status,
+      lastExecutionOutput: result.status === ExecutionStatus.COMPLETED ? result.result : result.error
+    };
+  };
+}
+__name(createATPNode, "createATPNode");
+
+export { ATPExecutionNode, ApprovalRequiredException, LangGraphATPClient, convertToLangChainTools, createATPNode, createATPTools2 as createATPTools, createATPTools as createATPToolsBasic, createCallbackManagerHandler, createLangChainEventHandler, createSimpleATPTool };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map