@mondaydotcomorg/atp-vercel-sdk 0.19.2

package/README.md

@@ -0,0 +1,416 @@
+# @mondaydotcomorg/atp-vercel-ai-sdk
+
+Vercel AI SDK integration for Agent Tool Protocol with production-ready features.
+
+## Overview
+
+This package integrates ATP with Vercel AI SDK, enabling agents to generate and execute ATP code as tools. Includes support for human-in-the-loop approvals, LLM sampling, and embeddings.
+
+## Installation
+
+```bash
+npm install @mondaydotcomorg/atp-vercel-ai-sdk ai @ai-sdk/openai
+```
+
+## Architecture
+
+```mermaid
+graph TB
+    Agent[Vercel AI SDK Agent] --> Tools[ATP Tools]
+    Tools --> Client[VercelAIATPClient]
+
+    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 --> Handler[Approval Handler]
+```
+
+## Features
+
+- 🤖 **Vercel AI SDK Tools** - Use ATP as tools with `generateText` and `streamText`
+- 🔄 **Multi-Step Execution** - Full integration with Vercel AI SDK's `maxSteps` parameter
+- 🧠 **LLM Sampling** - `atp.llm.call()` routes to your Vercel AI SDK model
+- 🔍 **Embedding Support** - `atp.embedding.*` routes to your embeddings model
+- ✅ **Approval Workflows** - Human-in-the-loop via async callbacks
+- 📡 **Streaming Support** - Works with both `generateText` and `streamText`
+- 📝 **TypeScript** - Full type safety
+
+## Quick Start
+
+### Basic Agent with Tools
+
+```typescript
+import { createATPTools } from '@mondaydotcomorg/atp-vercel-ai-sdk';
+import { openai } from '@ai-sdk/openai';
+import { generateText } from 'ai';
+
+const model = openai('gpt-4o');
+
+const { tools } = await createATPTools({
+	serverUrl: 'http://localhost:3333',
+	headers: { Authorization: 'Bearer your-api-key' },
+	model,
+	approvalHandler: async (message, context) => {
+		console.log('Approval needed:', message);
+		return true;
+	},
+});
+
+const result = await generateText({
+	model,
+	system: 'You can execute TypeScript code using ATP tools',
+	prompt: 'Use ATP to call an LLM and get a creative product idea',
+	tools,
+	maxSteps: 5,
+});
+```
+
+### With Streaming
+
+```typescript
+import { createATPTools } from '@mondaydotcomorg/atp-vercel-ai-sdk';
+import { openai } from '@ai-sdk/openai';
+import { streamText } from 'ai';
+
+const model = openai('gpt-4o');
+
+const { tools } = await createATPTools({
+	serverUrl: 'http://localhost:3333',
+	headers: { Authorization: 'Bearer your-api-key' },
+	model,
+	approvalHandler: async () => true,
+});
+
+const result = await streamText({
+	model,
+	prompt: 'Use ATP to generate code',
+	tools,
+	maxSteps: 5,
+});
+
+for await (const chunk of result.textStream) {
+	process.stdout.write(chunk);
+}
+```
+
+### With Embeddings
+
+```typescript
+import { createATPTools } from '@mondaydotcomorg/atp-vercel-ai-sdk';
+import { openai } from '@ai-sdk/openai';
+import { embed } from 'ai';
+
+const model = openai('gpt-4o');
+
+const embeddings = {
+	embed: async (text: string) => {
+		const result = await embed({
+			model: openai.embedding('text-embedding-3-small'),
+			value: text,
+		});
+		return result.embedding;
+	},
+};
+
+const { tools } = await createATPTools({
+	serverUrl: 'http://localhost:3333',
+	headers: { Authorization: 'Bearer your-api-key' },
+	model,
+	embeddings,
+});
+
+// Agent can now use atp.embedding.embed() in code
+```
+
+## How It Works
+
+### ATP Runtime in Vercel AI SDK
+
+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 Vercel AI SDK model:
+
+- Uses the same model 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,
+});
+
+// Structured extraction
+const structured = await atp.llm.extract({
+	prompt: 'Extract key information',
+	schema: z.object({
+		name: z.string(),
+		age: z.number(),
+	}),
+});
+```
+
+### Approval Mechanism
+
+When ATP code calls `atp.approval.request()`, your async handler is invoked:
+
+```typescript
+const { tools } = await createATPTools({
+	serverUrl: 'http://localhost:3333',
+	headers: { Authorization: 'Bearer your-api-key' },
+	model,
+	approvalHandler: async (message, context) => {
+		// Option 1: CLI prompt
+		return confirm(message);
+
+		// Option 2: Webhook notification
+		await sendSlackNotification(message);
+		return await waitForWebhookResponse();
+
+		// Option 3: Database queue
+		await db.approvals.create({ message, context });
+		return await pollForApproval();
+	},
+});
+```
+
+## API Reference
+
+### createATPTools()
+
+```typescript
+async function createATPTools(options: CreateATPToolsOptions): Promise<ATPToolsResult>;
+```
+
+**Options:**
+
+```typescript
+interface CreateATPToolsOptions {
+	serverUrl: string;
+	headers?: Record<string, string>;
+	model: any;
+	embeddings?: EmbeddingProvider;
+	approvalHandler?: ApprovalHandler;
+	defaultExecutionConfig?: Partial<ExecutionConfig>;
+	hooks?: ClientHooks;
+}
+```
+
+**Returns:**
+
+```typescript
+interface ATPToolsResult {
+	client: VercelAIATPClient;
+	tools: Record<string, any>;
+}
+```
+
+### VercelAIATPClient
+
+```typescript
+class VercelAIATPClient {
+	execute(code: string, config?: ExecutionConfig): Promise<ExecutionResult>;
+	getTypeDefinitions(): string;
+	getUnderlyingClient(): AgentToolProtocolClient;
+}
+```
+
+## Production Patterns
+
+### Webhook-Based Approval
+
+```typescript
+const pendingApprovals = new Map();
+
+const approvalHandler = async (message: string, context?: any) => {
+	const approvalId = generateId();
+
+	await db.approvals.create({
+		id: approvalId,
+		message,
+		context,
+		status: 'pending',
+	});
+
+	await sendSlackNotification({
+		channel: '#approvals',
+		text: message,
+		actions: [
+			{ type: 'button', text: 'Approve', action_id: `approve_${approvalId}` },
+			{ type: 'button', text: 'Deny', action_id: `deny_${approvalId}` },
+		],
+	});
+
+	return new Promise((resolve) => {
+		pendingApprovals.set(approvalId, resolve);
+		setTimeout(() => {
+			pendingApprovals.delete(approvalId);
+			resolve(false);
+		}, 300000);
+	});
+};
+
+app.post('/slack/actions', async (req, res) => {
+	const { action_id } = req.body;
+	const approvalId = action_id.replace(/^(approve|deny)_/, '');
+	const approved = action_id.startsWith('approve');
+
+	const resolve = pendingApprovals.get(approvalId);
+	if (resolve) {
+		resolve(approved);
+		pendingApprovals.delete(approvalId);
+	}
+
+	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 your approval handler.
+
+### Error Handling
+
+```typescript
+const { tools } = await createATPTools({
+	serverUrl: 'http://localhost:3333',
+	headers: { Authorization: 'Bearer your-api-key' },
+	model,
+	approvalHandler: async (message) => {
+		try {
+			return await requestApproval(message);
+		} catch (error) {
+			console.error('Approval error:', error);
+			return false;
+		}
+	},
+});
+```
+
+## Comparison with LangChain Integration
+
+| Feature                  | Vercel AI SDK       | LangChain               |
+| ------------------------ | ------------------- | ----------------------- |
+| Tool Format              | `tool()` function   | Tool classes            |
+| Agent Type               | ToolLoopAgent       | ReActAgent              |
+| Approval Mechanism       | Async callbacks     | Interrupts + Checkpoints|
+| State Persistence        | Custom              | Built-in (LangGraph)    |
+| Streaming                | Native support      | Via LangChain           |
+| Model Integration        | `generateText`      | `ChatModel.invoke`      |
+
+## Examples
+
+See [`examples/vercel-ai-sdk-example/`](../../examples/vercel-ai-sdk-example/):
+
+- **`agent.ts`** - Basic ToolLoopAgent with CLI approvals
+- **`streaming.ts`** - Streaming responses with ATP tools
+- **`webhook-approval.ts`** - Production webhook-based approvals
+
+### RAG with Embeddings
+
+```typescript
+import { createATPTools } from '@mondaydotcomorg/atp-vercel-ai-sdk';
+import { openai } from '@ai-sdk/openai';
+import { embed } from 'ai';
+
+const model = openai('gpt-4o');
+
+const embeddings = {
+	embed: async (text: string) => {
+		const result = await embed({
+			model: openai.embedding('text-embedding-3-small'),
+			value: text,
+		});
+		return result.embedding;
+	},
+};
+
+const { tools } = await createATPTools({
+	serverUrl: 'http://localhost:3333',
+	headers: { Authorization: 'Bearer your-api-key' },
+	model,
+	embeddings,
+});
+
+const result = await generateText({
+	model,
+	tools,
+	maxSteps: 5,
+	prompt: `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 {
+	VercelAIATPClient,
+	VercelAIATPClientOptions,
+	ApprovalRequest,
+	ApprovalResponse,
+	ApprovalHandler,
+	CreateATPToolsOptions,
+	ATPToolsResult,
+	EmbeddingProvider,
+} from '@mondaydotcomorg/atp-vercel-ai-sdk';
+```
+
+## Requirements
+
+- Node.js 18+
+- TypeScript 5.0+
+- `ai` ^4.0.0
+- Vercel AI SDK provider (e.g., `@ai-sdk/openai`)
+
+## License
+
+MIT
+
+## Learn More
+
+- [ATP Documentation](../../README.md)
+- [Vercel AI SDK Documentation](https://sdk.vercel.ai/docs)
+- [Examples](../../examples/vercel-ai-sdk-example/)
+

package/dist/client.d.ts

@@ -0,0 +1,20 @@
+import { AgentToolProtocolClient } from '@mondaydotcomorg/atp-client';
+import type { ExecutionResult, ExecutionConfig } from '@mondaydotcomorg/atp-protocol';
+import type { VercelAIATPClientOptions } from './types.js';
+export declare class VercelAIATPClient {
+    private client;
+    private model;
+    private embeddings?;
+    private approvalHandler?;
+    constructor(options: VercelAIATPClientOptions);
+    connect(): Promise<void>;
+    getTypeDefinitions(): string;
+    execute(code: string, config?: Partial<ExecutionConfig>): Promise<ExecutionResult>;
+    getUnderlyingClient(): AgentToolProtocolClient;
+    private handleLLMCall;
+    private handleLLMExtract;
+    private handleLLMClassify;
+    private handleEmbedding;
+    private handleApprovalRequest;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAEtF,OAAO,KAAK,EACX,wBAAwB,EAIxB,MAAM,YAAY,CAAC;AAEpB,qBAAa,iBAAiB;IAC7B,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,KAAK,CAAM;IACnB,OAAO,CAAC,UAAU,CAAC,CAAoB;IACvC,OAAO,CAAC,eAAe,CAAC,CAAkB;gBAE9B,OAAO,EAAE,wBAAwB;IAwCvC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAK9B,kBAAkB,IAAI,MAAM;IAItB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC;IAIxF,mBAAmB,IAAI,uBAAuB;YAIhC,aAAa;YAYb,gBAAgB;YAahB,iBAAiB;YAkCjB,eAAe;YAUf,qBAAqB;CAgBnC"}

package/dist/client.js

@@ -0,0 +1,117 @@
+import { AgentToolProtocolClient } from '@mondaydotcomorg/atp-client';
+import { generateObject, generateText } from 'ai';
+export class VercelAIATPClient {
+    client;
+    model;
+    embeddings;
+    approvalHandler;
+    constructor(options) {
+        const { serverUrl, headers, model, embeddings, tools, approvalHandler, hooks } = options;
+        this.client = new AgentToolProtocolClient({
+            baseUrl: serverUrl,
+            headers,
+            hooks,
+            serviceProviders: tools ? { tools } : undefined,
+        });
+        this.model = model;
+        this.embeddings = embeddings;
+        this.approvalHandler = approvalHandler;
+        this.client.provideLLM({
+            call: async (prompt, options) => {
+                return await this.handleLLMCall(prompt, options);
+            },
+            extract: async (prompt, schema, options) => {
+                return await this.handleLLMExtract(prompt, schema, options);
+            },
+            classify: async (text, categories, options) => {
+                return await this.handleLLMClassify(text, categories, options);
+            },
+        });
+        if (this.embeddings) {
+            this.client.provideEmbedding({
+                embed: async (text) => {
+                    return await this.handleEmbedding(text);
+                },
+            });
+        }
+        this.client.provideApproval({
+            request: async (message, context) => {
+                return await this.handleApprovalRequest(message, context);
+            },
+        });
+    }
+    async connect() {
+        await this.client.init({ name: 'vercel-ai-sdk-atp-client', version: '1.0.0' });
+        await this.client.connect();
+    }
+    getTypeDefinitions() {
+        return this.client.getTypeDefinitions();
+    }
+    async execute(code, config) {
+        return await this.client.execute(code, config);
+    }
+    getUnderlyingClient() {
+        return this.client;
+    }
+    async handleLLMCall(prompt, options) {
+        const result = await generateText({
+            model: this.model,
+            prompt,
+            temperature: options?.temperature,
+            maxTokens: options?.maxTokens,
+            system: options?.systemPrompt,
+        });
+        return result.text;
+    }
+    async handleLLMExtract(prompt, schema, options) {
+        const result = await generateObject({
+            model: this.model,
+            prompt,
+            schema,
+            system: options?.systemPrompt,
+            temperature: options?.temperature,
+            maxTokens: options?.maxTokens,
+        });
+        return result.object;
+    }
+    async handleLLMClassify(text, categories, options) {
+        const promptText = `Classify the following text into one of these categories: ${categories.join(', ')}\n\nText: ${text}\n\nRespond with ONLY the category name, nothing else.`;
+        const result = await generateText({
+            model: this.model,
+            prompt: promptText,
+            system: options?.systemPrompt,
+            temperature: 0,
+        });
+        const classification = result.text.trim();
+        if (categories.includes(classification)) {
+            return classification;
+        }
+        for (const category of categories) {
+            if (classification.toLowerCase().includes(category.toLowerCase())) {
+                return category;
+            }
+        }
+        const fallback = categories[0];
+        if (!fallback) {
+            throw new Error('No categories provided for classification');
+        }
+        return fallback;
+    }
+    async handleEmbedding(text) {
+        if (!this.embeddings) {
+            throw new Error('Embeddings provider not configured. Pass embeddings option when creating VercelAIATPClient.');
+        }
+        return await this.embeddings.embed(text);
+    }
+    async handleApprovalRequest(message, context) {
+        if (!this.approvalHandler) {
+            throw new Error('No approval handler configured. Pass approvalHandler option when creating VercelAIATPClient.');
+        }
+        const approved = await this.approvalHandler(message, context);
+        return {
+            approved,
+            timestamp: Date.now(),
+        };
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAEtE,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,IAAI,CAAC;AAQlD,MAAM,OAAO,iBAAiB;IACrB,MAAM,CAA0B;IAChC,KAAK,CAAM;IACX,UAAU,CAAqB;IAC/B,eAAe,CAAmB;IAE1C,YAAY,OAAiC;QAC5C,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC;QAEzF,IAAI,CAAC,MAAM,GAAG,IAAI,uBAAuB,CAAC;YACzC,OAAO,EAAE,SAAS;YAClB,OAAO;YACP,KAAK;YACL,gBAAgB,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS;SAC/C,CAAC,CAAC;QACH,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QAEvC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;YACtB,IAAI,EAAE,KAAK,EAAE,MAAc,EAAE,OAAa,EAAE,EAAE;gBAC7C,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YAClD,CAAC;YACD,OAAO,EAAE,KAAK,EAAE,MAAc,EAAE,MAAW,EAAE,OAAa,EAAE,EAAE;gBAC7D,OAAO,MAAM,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;YAC7D,CAAC;YACD,QAAQ,EAAE,KAAK,EAAE,IAAY,EAAE,UAAoB,EAAE,OAAa,EAAE,EAAE;gBACrE,OAAO,MAAM,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;YAChE,CAAC;SACD,CAAC,CAAC;QAEH,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC;gBAC5B,KAAK,EAAE,KAAK,EAAE,IAAY,EAAE,EAAE;oBAC7B,OAAO,MAAM,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;gBACzC,CAAC;aACD,CAAC,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC;YAC3B,OAAO,EAAE,KAAK,EAAE,OAAe,EAAE,OAAiC,EAAE,EAAE;gBACrE,OAAO,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAC3D,CAAC;SACD,CAAC,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,OAAO;QACZ,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,0BAA0B,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;QAC/E,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;IAC7B,CAAC;IAED,kBAAkB;QACjB,OAAO,IAAI,CAAC,MAAM,CAAC,kBAAkB,EAAE,CAAC;IACzC,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,IAAY,EAAE,MAAiC;QAC5D,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAChD,CAAC;IAED,mBAAmB;QAClB,OAAO,IAAI,CAAC,MAAM,CAAC;IACpB,CAAC;IAEO,KAAK,CAAC,aAAa,CAAC,MAAc,EAAE,OAAa;QACxD,MAAM,MAAM,GAAG,MAAM,YAAY,CAAC;YACjC,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,MAAM;YACN,WAAW,EAAE,OAAO,EAAE,WAAW;YACjC,SAAS,EAAE,OAAO,EAAE,SAAS;YAC7B,MAAM,EAAE,OAAO,EAAE,YAAY;SAC7B,CAAC,CAAC;QAEH,OAAO,MAAM,CAAC,IAAI,CAAC;IACpB,CAAC;IAEO,KAAK,CAAC,gBAAgB,CAAC,MAAc,EAAE,MAAW,EAAE,OAAa;QACxE,MAAM,MAAM,GAAG,MAAM,cAAc,CAAC;YACnC,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,MAAM;YACN,MAAM;YACN,MAAM,EAAE,OAAO,EAAE,YAAY;YAC7B,WAAW,EAAE,OAAO,EAAE,WAAW;YACjC,SAAS,EAAE,OAAO,EAAE,SAAS;SAC7B,CAAC,CAAC;QAEH,OAAO,MAAM,CAAC,MAAM,CAAC;IACtB,CAAC;IAEO,KAAK,CAAC,iBAAiB,CAC9B,IAAY,EACZ,UAAoB,EACpB,OAAa;QAGb,MAAM,UAAU,GAAG,6DAA6D,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,IAAI,wDAAwD,CAAC;QAE/K,MAAM,MAAM,GAAG,MAAM,YAAY,CAAC;YACjC,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,MAAM,EAAE,UAAU;YAClB,MAAM,EAAE,OAAO,EAAE,YAAY;YAC7B,WAAW,EAAE,CAAC;SACd,CAAC,CAAC;QAEH,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QAE1C,IAAI,UAAU,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC;YACzC,OAAO,cAAc,CAAC;QACvB,CAAC;QAED,KAAK,MAAM,QAAQ,IAAI,UAAU,EAAE,CAAC;YACnC,IAAI,cAAc,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC;gBACnE,OAAO,QAAQ,CAAC;YACjB,CAAC;QACF,CAAC;QAED,MAAM,QAAQ,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;QAC/B,IAAI,CAAC,QAAQ,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;QAC9D,CAAC;QACD,OAAO,QAAQ,CAAC;IACjB,CAAC;IAEO,KAAK,CAAC,eAAe,CAAC,IAAY;QACzC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CACd,6FAA6F,CAC7F,CAAC;QACH,CAAC;QAED,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC1C,CAAC;IAEO,KAAK,CAAC,qBAAqB,CAClC,OAAe,EACf,OAAiC;QAEjC,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CACd,8FAA8F,CAC9F,CAAC;QACH,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAC9D,OAAO;YACN,QAAQ;YACR,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;SACrB,CAAC;IACH,CAAC;CACD"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { VercelAIATPClient } from './client.js';
+export { createATPTools } from './tools.js';
+export type { VercelAIATPClientOptions, CreateATPToolsOptions, ATPToolsResult, ApprovalHandler, ApprovalRequest, ApprovalResponse, EmbeddingProvider, } from './types.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,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,YAAY,EACX,wBAAwB,EACxB,qBAAqB,EACrB,cAAc,EACd,eAAe,EACf,eAAe,EACf,gBAAgB,EAChB,iBAAiB,GACjB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { VercelAIATPClient } from './client.js';
+export { createATPTools } from './tools.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,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}

package/dist/tools.d.ts

@@ -0,0 +1,3 @@
+import type { CreateATPToolsOptions, ATPToolsResult } from './types.js';
+export declare function createATPTools(options: CreateATPToolsOptions): Promise<ATPToolsResult>;
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAKxE,wBAAsB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,cAAc,CAAC,CAgG5F"}

package/dist/tools.js

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+import { VercelAIATPClient } from './client.js';
+import { createToolsFromATPClient, ToolNames } from '@mondaydotcomorg/atp-client';
+import { ExecutionStatus } from '@mondaydotcomorg/atp-protocol';
+import { tool } from 'ai';
+export async function createATPTools(options) {
+    const { defaultExecutionConfig, ...clientOptions } = options;
+    const client = new VercelAIATPClient(clientOptions);
+    await client.connect();
+    const atpTools = createToolsFromATPClient(client.getUnderlyingClient());
+    const vercelTools = {};
+    for (const atpTool of atpTools) {
+        if (atpTool.name === ToolNames.EXECUTE_CODE) {
+            vercelTools.atp_execute_code = tool({
+                description: atpTool.description ||
+                    'Execute TypeScript code in ATP sandbox with access to runtime APIs (atp.llm.*, atp.embedding.*, atp.approval.*)',
+                parameters: z.object({
+                    code: z.string().describe('TypeScript code to execute in the ATP sandbox'),
+                }),
+                execute: async ({ code }) => {
+                    try {
+                        const result = await client.execute(code, defaultExecutionConfig);
+                        if (result.status === ExecutionStatus.COMPLETED) {
+                            return {
+                                success: true,
+                                result: result.result,
+                                stats: result.stats,
+                            };
+                        }
+                        else if (result.status === ExecutionStatus.FAILED) {
+                            return {
+                                success: false,
+                                error: result.error,
+                                stats: result.stats,
+                            };
+                        }
+                        else {
+                            return {
+                                success: false,
+                                error: 'Execution in unexpected state: ' + result.status,
+                            };
+                        }
+                    }
+                    catch (error) {
+                        return {
+                            success: false,
+                            error: error.message || 'Unknown error',
+                        };
+                    }
+                },
+            });
+        }
+        else {
+            const toolName = `atp_${atpTool.name}`;
+            vercelTools[toolName] = tool({
+                description: atpTool.description || '',
+                parameters: atpTool.zodSchema || z.object({}),
+                execute: async (input) => {
+                    try {
+                        const result = await atpTool.func(input);
+                        return {
+                            success: true,
+                            result,
+                        };
+                    }
+                    catch (error) {
+                        return {
+                            success: false,
+                            error: error.message,
+                        };
+                    }
+                },
+            });
+        }
+    }
+    vercelTools.atp_get_type_definitions = tool({
+        description: 'Get TypeScript type definitions for ATP runtime APIs to understand available functions',
+        parameters: z.object({}),
+        execute: async () => {
+            try {
+                const types = client.getTypeDefinitions();
+                return {
+                    success: true,
+                    types,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error.message,
+                };
+            }
+        },
+    });
+    return {
+        client,
+        tools: vercelTools,
+    };
+}
+//# sourceMappingURL=tools.js.map

package/dist/tools.js.map

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

package/dist/types.d.ts

@@ -0,0 +1,39 @@
+import type { ExecutionConfig, ClientTool } from '@mondaydotcomorg/atp-protocol';
+import type { ClientHooks } from '@mondaydotcomorg/atp-client';
+export interface ApprovalRequest {
+    message: string;
+    context?: Record<string, unknown>;
+    timestamp: number;
+}
+export interface ApprovalResponse {
+    approved: boolean;
+    reason?: string;
+    timestamp: number;
+}
+export type ApprovalHandler = (message: string, context?: Record<string, unknown>) => Promise<boolean>;
+export interface EmbeddingProvider {
+    embed(text: string): Promise<number[]>;
+}
+export interface VercelAIATPClientOptions {
+    serverUrl: string;
+    headers?: Record<string, string>;
+    model: any;
+    embeddings?: EmbeddingProvider;
+    tools?: ClientTool[];
+    approvalHandler?: ApprovalHandler;
+    hooks?: ClientHooks;
+}
+export interface CreateATPToolsOptions {
+    serverUrl: string;
+    headers?: Record<string, string>;
+    model: any;
+    embeddings?: EmbeddingProvider;
+    approvalHandler?: ApprovalHandler;
+    defaultExecutionConfig?: Partial<ExecutionConfig>;
+    hooks?: ClientHooks;
+}
+export interface ATPToolsResult {
+    client: any;
+    tools: Record<string, any>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AACjF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE/D,MAAM,WAAW,eAAe;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAChC,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,eAAe,GAAG,CAC7B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC7B,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtB,MAAM,WAAW,iBAAiB;IACjC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CACvC;AAED,MAAM,WAAW,wBAAwB;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,KAAK,EAAE,GAAG,CAAC;IACX,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAC/B,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;IACrB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,KAAK,CAAC,EAAE,WAAW,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,KAAK,EAAE,GAAG,CAAC;IACX,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAC/B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,sBAAsB,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;IAClD,KAAK,CAAC,EAAE,WAAW,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC9B,MAAM,EAAE,GAAG,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC3B"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,57 @@
+{
+	"name": "@mondaydotcomorg/atp-vercel-sdk",
+	"version": "0.19.2",
+	"description": "Vercel AI SDK integration for Agent Tool Protocol",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist",
+		"src"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/mondaycom/agent-tool-protocol",
+		"directory": "packages/vercel-ai-sdk"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "tsc -p tsconfig.json",
+		"dev": "tsc -p tsconfig.json --watch",
+		"clean": "rm -rf dist *.tsbuildinfo",
+		"test": "NODE_OPTIONS='--no-node-snapshot' jest --runInBand --forceExit --testTimeout=30000",
+		"lint": "tsc --noEmit"
+	},
+	"keywords": [
+		"agent",
+		"protocol",
+		"atp",
+		"vercel",
+		"ai-sdk",
+		"ai",
+		"llm"
+	],
+	"license": "MIT",
+	"dependencies": {
+		"@mondaydotcomorg/atp-client": "0.19.2",
+		"@mondaydotcomorg/atp-protocol": "0.19.2",
+		"zod": "^3.23.8"
+	},
+	"peerDependencies": {
+		"ai": "^4.0.0"
+	},
+	"devDependencies": {
+		"@jest/globals": "^29.7.0",
+		"@types/jest": "^29.5.11",
+		"jest": "^29.7.0",
+		"typescript": "^5.3.3"
+	}
+}

package/src/client.ts

@@ -0,0 +1,160 @@
+import { AgentToolProtocolClient } from '@mondaydotcomorg/atp-client';
+import type { ExecutionResult, ExecutionConfig } from '@mondaydotcomorg/atp-protocol';
+import { generateObject, generateText } from 'ai';
+import type {
+	VercelAIATPClientOptions,
+	ApprovalResponse,
+	EmbeddingProvider,
+	ApprovalHandler,
+} from './types.js';
+
+export class VercelAIATPClient {
+	private client: AgentToolProtocolClient;
+	private model: any;
+	private embeddings?: EmbeddingProvider;
+	private approvalHandler?: ApprovalHandler;
+
+	constructor(options: VercelAIATPClientOptions) {
+		const { serverUrl, headers, model, embeddings, tools, approvalHandler, hooks } = options;
+
+		this.client = new AgentToolProtocolClient({
+			baseUrl: serverUrl,
+			headers,
+			hooks,
+			serviceProviders: tools ? { tools } : undefined,
+		});
+		this.model = model;
+		this.embeddings = embeddings;
+		this.approvalHandler = approvalHandler;
+
+		this.client.provideLLM({
+			call: async (prompt: string, options?: any) => {
+				return await this.handleLLMCall(prompt, options);
+			},
+			extract: async (prompt: string, schema: any, options?: any) => {
+				return await this.handleLLMExtract(prompt, schema, options);
+			},
+			classify: async (text: string, categories: string[], options?: any) => {
+				return await this.handleLLMClassify(text, categories, options);
+			},
+		});
+
+		if (this.embeddings) {
+			this.client.provideEmbedding({
+				embed: async (text: string) => {
+					return await this.handleEmbedding(text);
+				},
+			});
+		}
+
+		this.client.provideApproval({
+			request: async (message: string, context?: Record<string, unknown>) => {
+				return await this.handleApprovalRequest(message, context);
+			},
+		});
+	}
+
+	async connect(): Promise<void> {
+		await this.client.init({ name: 'vercel-ai-sdk-atp-client', version: '1.0.0' });
+		await this.client.connect();
+	}
+
+	getTypeDefinitions(): string {
+		return this.client.getTypeDefinitions();
+	}
+
+	async execute(code: string, config?: Partial<ExecutionConfig>): Promise<ExecutionResult> {
+		return await this.client.execute(code, config);
+	}
+
+	getUnderlyingClient(): AgentToolProtocolClient {
+		return this.client;
+	}
+
+	private async handleLLMCall(prompt: string, options?: any): Promise<string> {
+		const result = await generateText({
+			model: this.model,
+			prompt,
+			temperature: options?.temperature,
+			maxTokens: options?.maxTokens,
+			system: options?.systemPrompt,
+		});
+
+		return result.text;
+	}
+
+	private async handleLLMExtract(prompt: string, schema: any, options?: any): Promise<any> {
+		const result = await generateObject({
+			model: this.model,
+			prompt,
+			schema,
+			system: options?.systemPrompt,
+			temperature: options?.temperature,
+			maxTokens: options?.maxTokens,
+		});
+
+		return result.object;
+	}
+
+	private async handleLLMClassify(
+		text: string,
+		categories: string[],
+		options?: any
+	): Promise<string> {
+
+		const promptText = `Classify the following text into one of these categories: ${categories.join(', ')}\n\nText: ${text}\n\nRespond with ONLY the category name, nothing else.`;
+
+		const result = await generateText({
+			model: this.model,
+			prompt: promptText,
+			system: options?.systemPrompt,
+			temperature: 0,
+		});
+
+		const classification = result.text.trim();
+
+		if (categories.includes(classification)) {
+			return classification;
+		}
+
+		for (const category of categories) {
+			if (classification.toLowerCase().includes(category.toLowerCase())) {
+				return category;
+			}
+		}
+
+		const fallback = categories[0];
+		if (!fallback) {
+			throw new Error('No categories provided for classification');
+		}
+		return fallback;
+	}
+
+	private async handleEmbedding(text: string): Promise<number[]> {
+		if (!this.embeddings) {
+			throw new Error(
+				'Embeddings provider not configured. Pass embeddings option when creating VercelAIATPClient.'
+			);
+		}
+
+		return await this.embeddings.embed(text);
+	}
+
+	private async handleApprovalRequest(
+		message: string,
+		context?: Record<string, unknown>
+	): Promise<ApprovalResponse> {
+		if (!this.approvalHandler) {
+			throw new Error(
+				'No approval handler configured. Pass approvalHandler option when creating VercelAIATPClient.'
+			);
+		}
+
+		const approved = await this.approvalHandler(message, context);
+		return {
+			approved,
+			timestamp: Date.now(),
+		};
+	}
+}
+

package/src/index.ts

@@ -0,0 +1,12 @@
+export { VercelAIATPClient } from './client.js';
+export { createATPTools } from './tools.js';
+export type {
+	VercelAIATPClientOptions,
+	CreateATPToolsOptions,
+	ATPToolsResult,
+	ApprovalHandler,
+	ApprovalRequest,
+	ApprovalResponse,
+	EmbeddingProvider,
+} from './types.js';
+

package/src/tools.ts

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+import { VercelAIATPClient } from './client.js';
+import type { CreateATPToolsOptions, ATPToolsResult } from './types.js';
+import { createToolsFromATPClient, ToolNames } from '@mondaydotcomorg/atp-client';
+import { ExecutionStatus } from '@mondaydotcomorg/atp-protocol';
+import { tool } from 'ai';
+
+export async function createATPTools(options: CreateATPToolsOptions): Promise<ATPToolsResult> {
+	const { defaultExecutionConfig, ...clientOptions } = options;
+
+	const client = new VercelAIATPClient(clientOptions);
+	await client.connect();
+
+	const atpTools = createToolsFromATPClient(client.getUnderlyingClient());
+
+	const vercelTools: Record<string, any> = {};
+
+	for (const atpTool of atpTools) {
+		if (atpTool.name === ToolNames.EXECUTE_CODE) {
+			vercelTools.atp_execute_code = tool({
+				description:
+					atpTool.description ||
+					'Execute TypeScript code in ATP sandbox with access to runtime APIs (atp.llm.*, atp.embedding.*, atp.approval.*)',
+				parameters: z.object({
+					code: z.string().describe('TypeScript code to execute in the ATP sandbox'),
+				}),
+				execute: async ({ code }: { code: string }) => {
+					try {
+						const result = await client.execute(code, defaultExecutionConfig);
+
+						if (result.status === ExecutionStatus.COMPLETED) {
+							return {
+								success: true,
+								result: result.result,
+								stats: result.stats,
+							};
+						} else if (result.status === ExecutionStatus.FAILED) {
+							return {
+								success: false,
+								error: result.error,
+								stats: result.stats,
+							};
+						} else {
+							return {
+								success: false,
+								error: 'Execution in unexpected state: ' + result.status,
+							};
+						}
+					} catch (error: any) {
+						return {
+							success: false,
+							error: error.message || 'Unknown error',
+						};
+					}
+				},
+			});
+		} else {
+			const toolName = `atp_${atpTool.name}`;
+			vercelTools[toolName] = tool({
+				description: atpTool.description || '',
+				parameters: atpTool.zodSchema || z.object({}),
+				execute: async (input: any) => {
+					try {
+						const result = await atpTool.func(input);
+						return {
+							success: true,
+							result,
+						};
+					} catch (error: any) {
+						return {
+							success: false,
+							error: error.message,
+						};
+					}
+				},
+			});
+		}
+	}
+
+	vercelTools.atp_get_type_definitions = tool({
+		description:
+			'Get TypeScript type definitions for ATP runtime APIs to understand available functions',
+		parameters: z.object({}),
+		execute: async () => {
+			try {
+				const types = client.getTypeDefinitions();
+				return {
+					success: true,
+					types,
+				};
+			} catch (error: any) {
+				return {
+					success: false,
+					error: error.message,
+				};
+			}
+		},
+	});
+
+	return {
+		client,
+		tools: vercelTools,
+	};
+}
+

package/src/types.ts

@@ -0,0 +1,49 @@
+import type { ExecutionConfig, ClientTool } from '@mondaydotcomorg/atp-protocol';
+import type { ClientHooks } from '@mondaydotcomorg/atp-client';
+
+export interface ApprovalRequest {
+	message: string;
+	context?: Record<string, unknown>;
+	timestamp: number;
+}
+
+export interface ApprovalResponse {
+	approved: boolean;
+	reason?: string;
+	timestamp: number;
+}
+
+export type ApprovalHandler = (
+	message: string,
+	context?: Record<string, unknown>
+) => Promise<boolean>;
+
+export interface EmbeddingProvider {
+	embed(text: string): Promise<number[]>;
+}
+
+export interface VercelAIATPClientOptions {
+	serverUrl: string;
+	headers?: Record<string, string>;
+	model: any;
+	embeddings?: EmbeddingProvider;
+	tools?: ClientTool[];
+	approvalHandler?: ApprovalHandler;
+	hooks?: ClientHooks;
+}
+
+export interface CreateATPToolsOptions {
+	serverUrl: string;
+	headers?: Record<string, string>;
+	model: any;
+	embeddings?: EmbeddingProvider;
+	approvalHandler?: ApprovalHandler;
+	defaultExecutionConfig?: Partial<ExecutionConfig>;
+	hooks?: ClientHooks;
+}
+
+export interface ATPToolsResult {
+	client: any;
+	tools: Record<string, any>;
+}
+