@mondaydotcomorg/atp-langchain 0.17.14

package/README.md

@@ -0,0 +1,434 @@
+# @mondaydotcomorg/atp-langchain
+
+LangChain and LangGraph integration for Agent Tool Protocol with production-ready human-in-the-loop support.
+
+## Overview
+
+This package integrates ATP with LangChain and LangGraph, enabling agents to generate and execute ATP code as tools. Includes production-ready async approval workflows using LangGraph interrupts and checkpoints.
+
+## Installation
+
+```bash
+npm install @mondaydotcomorg/atp-langchain @langchain/core @langchain/langgraph
+```
+
+## Architecture
+
+```mermaid
+graph TB
+    LangChain[LangChain Agent] --> Tools[ATP Tools]
+    Tools --> Client[LangGraphATPClient]
+
+    Client --> Server[ATP Server]
+    Server --> Runtime[Runtime APIs]
+
+    Runtime --> LLM[atp.llm.*]
+    Runtime --> Embed[atp.embedding.*]
+    Runtime --> Approval[atp.approval.*]
+
+    LLM --> Callback[Client LLM Callback]
+    Embed --> EmbedCallback[Client Embedding Callback]
+    Approval --> Interrupt[LangGraph Interrupt]
+
+    Interrupt --> Checkpoint[Save State]
+    Checkpoint --> Resume[Resume Later]
+```
+
+## Features
+
+- 🤖 **LangChain Tools** - Use ATP as tools in any LangChain agent
+- 🔄 **LangGraph Interrupts** - Production-ready async approvals
+- 🧠 **LLM Sampling** - `atp.llm.call()` routes to your LangChain LLM
+- 🔍 **Embedding Support** - `atp.embedding.*` routes to your embeddings model
+- ✅ **Approval Workflows** - Human-in-the-loop via LangGraph checkpoints
+- 💾 **State Persistence** - PostgreSQL/Redis checkpointing
+- 📝 **TypeScript** - Full type safety
+
+## Quick Start
+
+### Simple Agent
+
+```typescript
+import { ChatOpenAI } from '@langchain/openai';
+import { createReactAgent } from '@langchain/langgraph/prebuilt';
+import { createATPTools } from '@mondaydotcomorg/atp-langchain';
+
+const llm = new ChatOpenAI({ modelName: 'gpt-4' });
+
+// Create ATP tools
+const { tools } = await createATPTools('http://localhost:3333', 'your-api-key', { llm });
+
+// Create agent
+const agent = createReactAgent({ llm, tools });
+
+// Run agent
+const result = await agent.invoke({
+	messages: [{ role: 'user', content: 'Execute ATP code to get a joke from the LLM' }],
+});
+```
+
+### Production Agent with Approvals
+
+```typescript
+import { MemorySaver } from '@langchain/langgraph';
+import { createATPTools, ApprovalRequiredException } from '@mondaydotcomorg/atp-langchain';
+
+const llm = new ChatOpenAI({ modelName: 'gpt-4' });
+
+// Create tools with interrupt-based approvals
+const { client, tools, isApprovalRequired, resumeWithApproval } =
+  await createATPTools('http://localhost:3333', 'api-key', { llm });
+
+// Create agent with checkpointer
+const checkpointer = new MemorySaver();
+const agent = createReactAgent({ llm, tools, checkpointSaver: checkpointer });
+
+try {
+  await agent.invoke({ messages: [...] }, { configurable: { thread_id: 'thread-1' } });
+} catch (error) {
+  if (isApprovalRequired(error)) {
+    const { executionId, message, context } = error.approvalRequest;
+
+    // Save to DB, notify user via Slack/email
+    console.log(`Approval needed: ${message}`);
+    await notifyUser(message);
+
+    // Wait for approval (async - can take hours/days)
+    const approved = await waitForUserApproval(executionId);
+
+    // Resume execution
+    const result = await resumeWithApproval(executionId, approved);
+  }
+}
+```
+
+### With Embeddings
+
+```typescript
+import { ChatOpenAI, OpenAIEmbeddings } from '@langchain/openai';
+import { createATPTools } from '@mondaydotcomorg/atp-langchain';
+
+const llm = new ChatOpenAI({ modelName: 'gpt-4' });
+const embeddings = new OpenAIEmbeddings({ model: 'text-embedding-3-small' });
+
+// Create tools with LLM and embedding support
+const { tools } = await createATPTools('http://localhost:3333', 'api-key', {
+	llm,
+	embeddings, // Enable atp.embedding.*
+});
+
+const agent = createReactAgent({ llm, tools });
+
+// Agent can now generate code that uses embeddings:
+// const id = await atp.embedding.embed("Store this text");
+// const results = await atp.embedding.search("Find similar", { topK: 5 });
+```
+
+## How It Works
+
+### ATP Runtime in LangChain
+
+When agents use ATP tools, they can generate TypeScript code using ATP's runtime APIs:
+
+```typescript
+// Agent generates this code:
+const idea = await atp.llm.call({
+	prompt: 'Generate a product idea',
+});
+
+// Store embedding for semantic search
+const embeddingId = await atp.embedding.embed(idea);
+
+// Request approval
+const approval = await atp.approval.request(`Launch product: ${idea}?`, { idea });
+
+if (approval.approved) {
+	return await atp.llm.call({
+		prompt: `Create marketing copy for: ${idea}`,
+	});
+}
+```
+
+### LLM Sampling
+
+`atp.llm.call()` routes to your LangChain LLM:
+
+- Uses the same LLM as your agent
+- Fresh context for sub-reasoning
+- Supports `call()`, `extract()`, `classify()`
+
+```typescript
+// In ATP code:
+const analysis = await atp.llm.call({
+	prompt: 'Analyze this data: ' + JSON.stringify(data),
+	temperature: 0.7,
+	model: 'gpt-4',
+});
+```
+
+### Approval Interrupts
+
+When ATP code calls `atp.approval.request()`, LangGraph interrupts:
+
+1. **Pause** - Execution pauses, state saved to checkpoint
+2. **Notify** - Your code sends approval request (Slack, email, UI)
+3. **Wait** - User reviews asynchronously (hours/days OK)
+4. **Resume** - Call `resumeWithApproval()` with decision
+5. **Continue** - Execution resumes from checkpoint
+
+```mermaid
+sequenceDiagram
+    participant Agent
+    participant ATP
+    participant Checkpoint
+    participant User
+
+    Agent->>ATP: Execute code
+    ATP->>ATP: atp.approval.request()
+    ATP->>Checkpoint: Save state
+    ATP-->>Agent: Throw ApprovalRequiredException
+    Agent->>User: Notify (Slack/Email)
+
+    Note over User: User reviews<br/>(async, can take hours)
+
+    User->>Agent: Approve/Deny
+    Agent->>ATP: resumeWithApproval(executionId, approved)
+    ATP->>Checkpoint: Restore state
+    ATP->>ATP: Continue execution
+    ATP-->>Agent: Final result
+```
+
+## API Reference
+
+### createATPTools()
+
+```typescript
+async function createATPTools(
+	serverUrl: string,
+	apiKey: string,
+	options: CreateATPToolsOptions
+): Promise<ATPToolsResult>;
+```
+
+**Options:**
+
+```typescript
+interface CreateATPToolsOptions {
+	llm: BaseChatModel; // Required: LangChain LLM
+	embeddings?: Embeddings; // Optional: Embeddings model
+	useLangGraphInterrupts?: boolean; // Default: true
+	approvalHandler?: ApprovalHandler; // If interrupts disabled
+	defaultExecutionConfig?: ExecutionConfig;
+}
+```
+
+**Returns:**
+
+```typescript
+interface ATPToolsResult {
+	client: LangGraphATPClient;
+	tools: Tool[]; // LangChain tools
+	isApprovalRequired: (error: any) => boolean;
+	resumeWithApproval: (executionId: string, approved: boolean, reason?: string) => Promise<any>;
+}
+```
+
+### LangGraphATPClient
+
+```typescript
+class LangGraphATPClient extends AgentToolProtocolClient {
+	execute(code: string, config?: ExecutionConfig): Promise<ExecutionResult>;
+	resumeWithApproval(executionId: string, approved: boolean, reason?: string): Promise<any>;
+	getPendingApproval(executionId: string): Promise<ApprovalRequest | null>;
+}
+```
+
+### ApprovalRequiredException
+
+```typescript
+class ApprovalRequiredException extends Error {
+	approvalRequest: {
+		executionId: string;
+		message: string;
+		context?: any;
+		timestamp: number;
+	};
+}
+```
+
+## Production Patterns
+
+### PostgreSQL Checkpointing
+
+```typescript
+import { PostgresSaver } from '@langchain/langgraph-checkpoint-postgres';
+
+const checkpointer = new PostgresSaver({
+	connectionString: process.env.DATABASE_URL,
+});
+
+const agent = createReactAgent({
+	llm,
+	tools,
+	checkpointSaver: checkpointer,
+});
+
+// State persists across restarts
+```
+
+### Async Approval via Slack
+
+```typescript
+if (isApprovalRequired(error)) {
+	const { executionId, message, context } = error.approvalRequest;
+
+	// Save to database
+	await db.approvals.create({
+		id: executionId,
+		message,
+		context,
+		status: 'pending',
+	});
+
+	// Send Slack notification
+	await slack.chat.postMessage({
+		channel: '#approvals',
+		text: message,
+		blocks: [
+			{
+				type: 'actions',
+				elements: [
+					{ type: 'button', text: 'Approve', action_id: 'approve' },
+					{ type: 'button', text: 'Deny', action_id: 'deny' },
+				],
+			},
+		],
+	});
+}
+
+// In Slack webhook handler:
+app.post('/slack/actions', async (req, res) => {
+	const { action_id } = req.body;
+	const executionId = req.body.state.executionId;
+
+	const approved = action_id === 'approve';
+	const result = await resumeWithApproval(executionId, approved);
+
+	await db.approvals.update(executionId, { status: approved ? 'approved' : 'denied' });
+	res.json({ ok: true });
+});
+```
+
+### Multiple Sequential Approvals
+
+```typescript
+// Agent generates ATP code with multiple approvals:
+const step1 = await atp.approval.request('Approve step 1?');
+if (!step1.approved) return { cancelled: true };
+
+const step2 = await atp.approval.request('Approve step 2?');
+if (!step2.approved) return { cancelled: true };
+
+return { success: true };
+```
+
+Each `atp.approval.request()` triggers a new interrupt → checkpoint → resume cycle.
+
+## Comparison: Direct vs Interrupt Mode
+
+### Direct Mode
+
+```typescript
+const { tools } = await createATPTools(url, key, {
+	llm,
+	useLangGraphInterrupts: false,
+	approvalHandler: async (message) => {
+		return await promptUser(message); // Blocks
+	},
+});
+```
+
+**Pros:** Simpler setup, good for CLI tools  
+**Cons:** Blocks execution, no persistence, not production-ready
+
+### Interrupt Mode ⭐ Recommended
+
+```typescript
+const { tools, isApprovalRequired, resumeWithApproval } = await createATPTools(url, key, { llm });
+
+try {
+	await agent.invoke({ messages });
+} catch (error) {
+	if (isApprovalRequired(error)) {
+		await handleApprovalAsync(error.approvalRequest);
+	}
+}
+```
+
+**Pros:** Non-blocking, state persists, production-ready, multi-user support  
+**Cons:** Slightly more complex setup
+
+## Examples
+
+See [`examples/langchain-react-agent/`](../../examples/langchain-react-agent/):
+
+- **`simple-test.ts`** - Integration test with all 3 ATP tools
+- **`simple-agent.ts`** - Basic React agent without approvals
+- **`agent.ts`** - Production agent with interrupts and checkpoints
+
+### RAG with Embeddings
+
+```typescript
+import { ChatOpenAI, OpenAIEmbeddings } from '@langchain/openai';
+import { createATPTools } from '@mondaydotcomorg/atp-langchain';
+
+const llm = new ChatOpenAI({ modelName: 'gpt-4' });
+const embeddings = new OpenAIEmbeddings();
+
+const { tools } = await createATPTools(url, key, { llm, embeddings });
+const agent = createReactAgent({ llm, tools });
+
+// Agent can do RAG:
+const result = await agent.invoke({
+	messages: [
+		{
+			role: 'user',
+			content: `Use ATP to:
+      1. Embed these documents: ["AI is...", "ML is...", "DL is..."]
+      2. Search for content similar to "neural networks"
+      3. Use atp.llm.call() to answer based on results`,
+		},
+	],
+});
+```
+
+## TypeScript Support
+
+```typescript
+import type {
+	LangGraphATPClient,
+	LangGraphATPClientOptions,
+	ApprovalRequest,
+	ApprovalResponse,
+	CreateATPToolsOptions,
+	ATPToolsResult,
+} from '@mondaydotcomorg/atp-langchain';
+```
+
+## Requirements
+
+- Node.js 18+
+- TypeScript 5.0+
+- `@langchain/core` ^0.3.0
+- `@langchain/langgraph` ^0.2.0
+
+## License
+
+MIT
+
+## Learn More
+
+- [ATP Documentation](../../README.md)
+- [LangGraph Human-in-the-Loop](https://langchain-ai.github.io/langgraphjs/how-tos/human-in-the-loop/)
+- [LangChain Tools](https://js.langchain.com/docs/modules/agents/tools/)
+- [Examples](../../examples/langchain-react-agent/)

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { createATPTools as createATPToolsBasic, convertToLangChainTools } from './tools.js';
+export * from './langgraph-client.js';
+export { createATPTools, createSimpleATPTool, type CreateATPToolsOptions, type ATPToolsResult, } from './langgraph-tools.js';
+export * from './node.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,IAAI,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAE5F,cAAc,uBAAuB,CAAC;AACtC,OAAO,EACN,cAAc,EACd,mBAAmB,EACnB,KAAK,qBAAqB,EAC1B,KAAK,cAAc,GACnB,MAAM,sBAAsB,CAAC;AAE9B,cAAc,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export { createATPTools as createATPToolsBasic, convertToLangChainTools } from './tools.js';
+export * from './langgraph-client.js';
+export { createATPTools, createSimpleATPTool, } from './langgraph-tools.js';
+export * from './node.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,IAAI,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAE5F,cAAc,uBAAuB,CAAC;AACtC,OAAO,EACN,cAAc,EACd,mBAAmB,GAGnB,MAAM,sBAAsB,CAAC;AAE9B,cAAc,WAAW,CAAC"}

package/dist/langgraph-client.d.ts

@@ -0,0 +1,156 @@
+/**
+ * LangGraph-aware ATP Client
+ *
+ * This client integrates ATP execution with LangGraph's interrupt-based
+ * human-in-the-loop (HITL) system. When ATP code calls atp.approval.request(),
+ * it triggers a LangGraph interrupt for production-ready async approval flows.
+ *
+ * Features:
+ * - LangGraph interrupt integration for approvals
+ * - LLM sampling via LangChain models
+ * - Checkpoint-aware state management
+ * - Production-ready async approval workflows
+ */
+import { AgentToolProtocolClient, ClientCallbackError } from '@mondaydotcomorg/atp-client';
+import type { ClientHooks } from '@mondaydotcomorg/atp-client';
+import type { ExecutionResult, ExecutionConfig, ClientTool } from '@mondaydotcomorg/atp-protocol';
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { Embeddings } from '@langchain/core/embeddings';
+/**
+ * Approval request that needs human decision
+ */
+export interface ApprovalRequest {
+    message: string;
+    context?: Record<string, unknown>;
+    executionId: string;
+    timestamp: number;
+}
+/**
+ * Approval response from human
+ */
+export interface ApprovalResponse {
+    approved: boolean;
+    reason?: string;
+    timestamp: number;
+}
+/**
+ * Options for creating the LangGraph ATP client
+ */
+export interface LangGraphATPClientOptions {
+    /** Base URL of ATP server */
+    serverUrl: string;
+    /** Custom headers for authentication (e.g., { Authorization: 'Bearer token' }) */
+    headers?: Record<string, string>;
+    /** LangChain LLM for atp.llm.call() sampling */
+    llm: BaseChatModel;
+    /**
+     * LangChain embeddings model for atp.embedding.embed() and atp.embedding.search()
+     * Optional - if not provided, embedding calls will fail
+     */
+    embeddings?: Embeddings;
+    /**
+     * Client-provided tools that execute locally (e.g., file operations, browser automation)
+     * These tools are registered with the server and can be called from server code execution
+     */
+    tools?: ClientTool[];
+    /**
+     * Whether to use LangGraph interrupts for approvals (production mode).
+     * If false, will use a direct callback handler.
+     * Default: true
+     */
+    useLangGraphInterrupts?: boolean;
+    /**
+     * Direct approval handler (only used if useLangGraphInterrupts = false)
+     */
+    approvalHandler?: (message: string, context?: Record<string, unknown>) => Promise<boolean>;
+    /**
+     * Hooks for intercepting and modifying client behavior
+     */
+    hooks?: ClientHooks;
+}
+/**
+ * Result of ATP execution that may need approval
+ */
+export interface ATPExecutionResult {
+    /** Standard execution result */
+    result: ExecutionResult;
+    /** If true, execution is waiting for approval via LangGraph interrupt */
+    needsApproval: boolean;
+    /** Approval request details (if needsApproval = true) */
+    approvalRequest?: ApprovalRequest;
+}
+/**
+ * Exception thrown when approval is needed - this triggers LangGraph interrupt
+ */
+export declare class ApprovalRequiredException extends ClientCallbackError {
+    readonly approvalRequest: ApprovalRequest;
+    constructor(approvalRequest: ApprovalRequest);
+}
+/**
+ * LangGraph-aware ATP Client
+ *
+ * Integrates ATP with LangGraph's production-ready interrupt system:
+ * - atp.llm.call() → Routes to LangChain LLM (no interrupt)
+ * - atp.approval.request() → Throws ApprovalRequiredException (triggers LangGraph interrupt)
+ * - Supports checkpoint-based state persistence
+ * - Enables async approval workflows
+ */
+export declare class LangGraphATPClient {
+    private client;
+    private llm;
+    private embeddings?;
+    private useLangGraphInterrupts;
+    private directApprovalHandler?;
+    private pendingApprovals;
+    constructor(options: LangGraphATPClientOptions);
+    /**
+     * Initialize the client connection
+     */
+    connect(): Promise<void>;
+    /**
+     * Get TypeScript API definitions
+     */
+    getTypeDefinitions(): string;
+    /**
+     * 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)
+     */
+    execute(code: string, config?: Partial<ExecutionConfig>): Promise<ATPExecutionResult>;
+    /**
+     * Resume execution after approval decision
+     *
+     * Call this after LangGraph resumes from interrupt with approval decision.
+     */
+    resumeWithApproval(executionId: string, approved: boolean, reason?: string): Promise<ExecutionResult>;
+    /**
+     * Get pending approval request for an execution
+     */
+    getPendingApproval(executionId: string): ApprovalRequest | undefined;
+    /**
+     * Handle LLM call - route to LangChain LLM
+     */
+    private handleLLMCall;
+    /**
+     * Handle LLM extract - route to LangChain LLM with structured output
+     */
+    private handleLLMExtract;
+    /**
+     * Handle LLM classify - route to LangChain LLM
+     */
+    private handleLLMClassify;
+    /**
+     * Handle embedding - route to LangChain embeddings model
+     */
+    private handleEmbedding;
+    /**
+     * Get the underlying ATP client for advanced usage
+     */
+    getUnderlyingClient(): AgentToolProtocolClient;
+    private handleApprovalRequest;
+}
+//# sourceMappingURL=langgraph-client.d.ts.map

package/dist/langgraph-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"langgraph-client.d.ts","sourceRoot":"","sources":["../src/langgraph-client.ts"],"names":[],"mappings":"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"}