@mondaydotcomorg/atp-langchain 0.20.0 → 0.20.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/event-adapter.d.ts +68 -0
- package/dist/event-adapter.d.ts.map +1 -0
- package/dist/event-adapter.js +197 -0
- package/dist/event-adapter.js.map +1 -0
- package/dist/index.d.ts +1 -0
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +1 -0
- package/dist/index.js.map +1 -1
- package/package.json +4 -4
- package/src/event-adapter.ts +289 -0
- package/src/index.ts +7 -0
|
@@ -0,0 +1,68 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* LangChain Event Adapter
|
|
3
|
+
*
|
|
4
|
+
* Converts ATP streaming events to LangChain-compatible event format.
|
|
5
|
+
* Works with LangChain's callback system and streamEvents API.
|
|
6
|
+
*/
|
|
7
|
+
import { type ATPEvent } from '@mondaydotcomorg/atp-protocol';
|
|
8
|
+
/**
|
|
9
|
+
* LangChain-style event format
|
|
10
|
+
* Compatible with LangChain's streamEvents() output format
|
|
11
|
+
*/
|
|
12
|
+
export interface LangChainEvent {
|
|
13
|
+
event: string;
|
|
14
|
+
name?: string;
|
|
15
|
+
data: unknown;
|
|
16
|
+
run_id?: string;
|
|
17
|
+
metadata?: Record<string, unknown>;
|
|
18
|
+
tags?: string[];
|
|
19
|
+
}
|
|
20
|
+
/**
|
|
21
|
+
* Options for creating the LangChain event handler
|
|
22
|
+
*/
|
|
23
|
+
export interface CreateLangChainEventHandlerOptions {
|
|
24
|
+
/**
|
|
25
|
+
* Tags to add to all events
|
|
26
|
+
*/
|
|
27
|
+
tags?: string[];
|
|
28
|
+
/**
|
|
29
|
+
* Metadata to add to all events
|
|
30
|
+
*/
|
|
31
|
+
metadata?: Record<string, unknown>;
|
|
32
|
+
}
|
|
33
|
+
/**
|
|
34
|
+
* Creates an event handler that converts ATP events to LangChain event format.
|
|
35
|
+
*
|
|
36
|
+
* @param onEvent - Callback to receive LangChain-formatted events
|
|
37
|
+
* @param options - Optional configuration
|
|
38
|
+
* @returns An event handler function to pass to ATP's executeStream
|
|
39
|
+
*
|
|
40
|
+
* @example
|
|
41
|
+
* ```typescript
|
|
42
|
+
* const handler = createLangChainEventHandler((event) => {
|
|
43
|
+
* console.log(event.event, event.data);
|
|
44
|
+
* });
|
|
45
|
+
*
|
|
46
|
+
* const result = await client.executeStream(code, {}, handler);
|
|
47
|
+
* ```
|
|
48
|
+
*/
|
|
49
|
+
export declare function createLangChainEventHandler(onEvent: (event: LangChainEvent) => void, options?: CreateLangChainEventHandlerOptions): (event: ATPEvent) => void;
|
|
50
|
+
/**
|
|
51
|
+
* Creates an event handler compatible with LangChain's CallbackManager.
|
|
52
|
+
* Useful for integrating with existing LangChain callback infrastructure.
|
|
53
|
+
*
|
|
54
|
+
* @param callbackManager - LangChain CallbackManager or similar interface
|
|
55
|
+
* @returns An event handler function to pass to ATP's executeStream
|
|
56
|
+
*/
|
|
57
|
+
export declare function createCallbackManagerHandler(callbackManager: {
|
|
58
|
+
handleCustomEvent?: (eventName: string, data: unknown, runId?: string, tags?: string[], metadata?: Record<string, unknown>) => Promise<void> | void;
|
|
59
|
+
handleToolStart?: (tool: {
|
|
60
|
+
name: string;
|
|
61
|
+
}, input: string, runId?: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>) => Promise<void> | void;
|
|
62
|
+
handleToolEnd?: (output: string, runId?: string, parentRunId?: string, tags?: string[]) => Promise<void> | void;
|
|
63
|
+
handleLLMNewToken?: (token: string, idx?: {
|
|
64
|
+
prompt: number;
|
|
65
|
+
completion: number;
|
|
66
|
+
}, runId?: string) => Promise<void> | void;
|
|
67
|
+
}): (event: ATPEvent) => void;
|
|
68
|
+
//# sourceMappingURL=event-adapter.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"event-adapter.d.ts","sourceRoot":"","sources":["../src/event-adapter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,KAAK,QAAQ,EAAgB,MAAM,+BAA+B,CAAC;AAE5E;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,kCAAkC;IAClD;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,2BAA2B,CAC1C,OAAO,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,EACxC,OAAO,GAAE,kCAAuC,GAC9C,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,CA0J3B;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAAC,eAAe,EAAE;IAC7D,iBAAiB,CAAC,EAAE,CACnB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,OAAO,EACb,KAAK,CAAC,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,MAAM,EAAE,EACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC9B,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC1B,eAAe,CAAC,EAAE,CACjB,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,EACtB,KAAK,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,MAAM,EACpB,IAAI,CAAC,EAAE,MAAM,EAAE,EACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC9B,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC1B,aAAa,CAAC,EAAE,CACf,MAAM,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,MAAM,EACpB,IAAI,CAAC,EAAE,MAAM,EAAE,KACX,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC1B,iBAAiB,CAAC,EAAE,CACnB,KAAK,EAAE,MAAM,EACb,GAAG,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,EAC5C,KAAK,CAAC,EAAE,MAAM,KACV,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC1B,GAAG,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,CA2C5B"}
|
|
@@ -0,0 +1,197 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* LangChain Event Adapter
|
|
3
|
+
*
|
|
4
|
+
* Converts ATP streaming events to LangChain-compatible event format.
|
|
5
|
+
* Works with LangChain's callback system and streamEvents API.
|
|
6
|
+
*/
|
|
7
|
+
import { ATPEventType } from '@mondaydotcomorg/atp-protocol';
|
|
8
|
+
/**
|
|
9
|
+
* Creates an event handler that converts ATP events to LangChain event format.
|
|
10
|
+
*
|
|
11
|
+
* @param onEvent - Callback to receive LangChain-formatted events
|
|
12
|
+
* @param options - Optional configuration
|
|
13
|
+
* @returns An event handler function to pass to ATP's executeStream
|
|
14
|
+
*
|
|
15
|
+
* @example
|
|
16
|
+
* ```typescript
|
|
17
|
+
* const handler = createLangChainEventHandler((event) => {
|
|
18
|
+
* console.log(event.event, event.data);
|
|
19
|
+
* });
|
|
20
|
+
*
|
|
21
|
+
* const result = await client.executeStream(code, {}, handler);
|
|
22
|
+
* ```
|
|
23
|
+
*/
|
|
24
|
+
export function createLangChainEventHandler(onEvent, options = {}) {
|
|
25
|
+
const { tags = [], metadata = {} } = options;
|
|
26
|
+
return (event) => {
|
|
27
|
+
const baseEvent = {
|
|
28
|
+
run_id: event.runId,
|
|
29
|
+
tags: ['atp', ...tags],
|
|
30
|
+
metadata: { ...metadata, timestamp: event.timestamp },
|
|
31
|
+
};
|
|
32
|
+
switch (event.type) {
|
|
33
|
+
case ATPEventType.THINKING: {
|
|
34
|
+
const data = event.data;
|
|
35
|
+
onEvent({
|
|
36
|
+
...baseEvent,
|
|
37
|
+
event: 'on_llm_stream',
|
|
38
|
+
name: 'atp_thinking',
|
|
39
|
+
data: {
|
|
40
|
+
chunk: data.content,
|
|
41
|
+
step: data.step,
|
|
42
|
+
},
|
|
43
|
+
});
|
|
44
|
+
break;
|
|
45
|
+
}
|
|
46
|
+
case ATPEventType.TOOL_START: {
|
|
47
|
+
const data = event.data;
|
|
48
|
+
onEvent({
|
|
49
|
+
...baseEvent,
|
|
50
|
+
event: 'on_tool_start',
|
|
51
|
+
name: `${data.apiGroup}.${data.toolName}`,
|
|
52
|
+
data: {
|
|
53
|
+
input: data.input,
|
|
54
|
+
},
|
|
55
|
+
metadata: {
|
|
56
|
+
...baseEvent.metadata,
|
|
57
|
+
apiGroup: data.apiGroup,
|
|
58
|
+
toolName: data.toolName,
|
|
59
|
+
},
|
|
60
|
+
});
|
|
61
|
+
break;
|
|
62
|
+
}
|
|
63
|
+
case ATPEventType.TOOL_END: {
|
|
64
|
+
const data = event.data;
|
|
65
|
+
onEvent({
|
|
66
|
+
...baseEvent,
|
|
67
|
+
event: 'on_tool_end',
|
|
68
|
+
name: `${data.apiGroup}.${data.toolName}`,
|
|
69
|
+
data: {
|
|
70
|
+
output: data.output,
|
|
71
|
+
error: data.error,
|
|
72
|
+
},
|
|
73
|
+
metadata: {
|
|
74
|
+
...baseEvent.metadata,
|
|
75
|
+
apiGroup: data.apiGroup,
|
|
76
|
+
toolName: data.toolName,
|
|
77
|
+
duration: data.duration,
|
|
78
|
+
success: data.success,
|
|
79
|
+
},
|
|
80
|
+
});
|
|
81
|
+
break;
|
|
82
|
+
}
|
|
83
|
+
case ATPEventType.TEXT: {
|
|
84
|
+
const data = event.data;
|
|
85
|
+
onEvent({
|
|
86
|
+
...baseEvent,
|
|
87
|
+
event: 'on_chain_stream',
|
|
88
|
+
name: 'atp_output',
|
|
89
|
+
data: {
|
|
90
|
+
chunk: data.text,
|
|
91
|
+
},
|
|
92
|
+
});
|
|
93
|
+
break;
|
|
94
|
+
}
|
|
95
|
+
case ATPEventType.TEXT_END:
|
|
96
|
+
onEvent({
|
|
97
|
+
...baseEvent,
|
|
98
|
+
event: 'on_chain_end',
|
|
99
|
+
name: 'atp_output',
|
|
100
|
+
data: {},
|
|
101
|
+
});
|
|
102
|
+
break;
|
|
103
|
+
case ATPEventType.SOURCE: {
|
|
104
|
+
const data = event.data;
|
|
105
|
+
onEvent({
|
|
106
|
+
...baseEvent,
|
|
107
|
+
event: 'on_custom_event',
|
|
108
|
+
name: 'atp_source',
|
|
109
|
+
data: {
|
|
110
|
+
url: data.url,
|
|
111
|
+
title: data.title,
|
|
112
|
+
summary: data.summary,
|
|
113
|
+
createdAt: data.createdAt,
|
|
114
|
+
},
|
|
115
|
+
});
|
|
116
|
+
break;
|
|
117
|
+
}
|
|
118
|
+
case ATPEventType.PROGRESS: {
|
|
119
|
+
const data = event.data;
|
|
120
|
+
onEvent({
|
|
121
|
+
...baseEvent,
|
|
122
|
+
event: 'on_custom_event',
|
|
123
|
+
name: 'atp_progress',
|
|
124
|
+
data: {
|
|
125
|
+
message: data.message,
|
|
126
|
+
fraction: data.fraction,
|
|
127
|
+
percentage: Math.round(data.fraction * 100),
|
|
128
|
+
},
|
|
129
|
+
});
|
|
130
|
+
break;
|
|
131
|
+
}
|
|
132
|
+
case ATPEventType.ERROR: {
|
|
133
|
+
const data = event.data;
|
|
134
|
+
onEvent({
|
|
135
|
+
...baseEvent,
|
|
136
|
+
event: 'on_chain_error',
|
|
137
|
+
name: 'atp_error',
|
|
138
|
+
data: {
|
|
139
|
+
error: data.message,
|
|
140
|
+
code: data.code,
|
|
141
|
+
},
|
|
142
|
+
});
|
|
143
|
+
break;
|
|
144
|
+
}
|
|
145
|
+
default:
|
|
146
|
+
// Forward unknown events as custom events
|
|
147
|
+
onEvent({
|
|
148
|
+
...baseEvent,
|
|
149
|
+
event: 'on_custom_event',
|
|
150
|
+
name: `atp_${event.type}`,
|
|
151
|
+
data: event.data,
|
|
152
|
+
});
|
|
153
|
+
break;
|
|
154
|
+
}
|
|
155
|
+
};
|
|
156
|
+
}
|
|
157
|
+
/**
|
|
158
|
+
* Creates an event handler compatible with LangChain's CallbackManager.
|
|
159
|
+
* Useful for integrating with existing LangChain callback infrastructure.
|
|
160
|
+
*
|
|
161
|
+
* @param callbackManager - LangChain CallbackManager or similar interface
|
|
162
|
+
* @returns An event handler function to pass to ATP's executeStream
|
|
163
|
+
*/
|
|
164
|
+
export function createCallbackManagerHandler(callbackManager) {
|
|
165
|
+
return (event) => {
|
|
166
|
+
switch (event.type) {
|
|
167
|
+
case ATPEventType.THINKING: {
|
|
168
|
+
const data = event.data;
|
|
169
|
+
callbackManager.handleLLMNewToken?.(data.content, undefined, event.runId);
|
|
170
|
+
break;
|
|
171
|
+
}
|
|
172
|
+
case ATPEventType.TOOL_START: {
|
|
173
|
+
const data = event.data;
|
|
174
|
+
callbackManager.handleToolStart?.({ name: `${data.apiGroup}.${data.toolName}` }, JSON.stringify(data.input), event.runId, undefined, ['atp'], { apiGroup: data.apiGroup });
|
|
175
|
+
break;
|
|
176
|
+
}
|
|
177
|
+
case ATPEventType.TOOL_END: {
|
|
178
|
+
const data = event.data;
|
|
179
|
+
callbackManager.handleToolEnd?.(JSON.stringify(data.output), event.runId, undefined, [
|
|
180
|
+
'atp',
|
|
181
|
+
]);
|
|
182
|
+
break;
|
|
183
|
+
}
|
|
184
|
+
case ATPEventType.TEXT: {
|
|
185
|
+
const data = event.data;
|
|
186
|
+
callbackManager.handleLLMNewToken?.(data.text, undefined, event.runId);
|
|
187
|
+
break;
|
|
188
|
+
}
|
|
189
|
+
default:
|
|
190
|
+
callbackManager.handleCustomEvent?.(`atp_${event.type}`, event.data, event.runId, ['atp'], {
|
|
191
|
+
timestamp: event.timestamp,
|
|
192
|
+
});
|
|
193
|
+
break;
|
|
194
|
+
}
|
|
195
|
+
};
|
|
196
|
+
}
|
|
197
|
+
//# sourceMappingURL=event-adapter.js.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"event-adapter.js","sourceRoot":"","sources":["../src/event-adapter.ts"],"names":[],"mappings":"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"}
|
package/dist/index.d.ts
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
export { createATPTools as createATPToolsBasic, convertToLangChainTools } from './tools.js';
|
|
2
2
|
export * from './langgraph-client.js';
|
|
3
3
|
export { createATPTools, createSimpleATPTool, type CreateATPToolsOptions, type ATPToolsResult, } from './langgraph-tools.js';
|
|
4
|
+
export { createLangChainEventHandler, createCallbackManagerHandler, type LangChainEvent, type CreateLangChainEventHandlerOptions, } from './event-adapter.js';
|
|
4
5
|
export * from './node.js';
|
|
5
6
|
//# sourceMappingURL=index.d.ts.map
|
package/dist/index.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
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"}
|
|
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,OAAO,EACN,2BAA2B,EAC3B,4BAA4B,EAC5B,KAAK,cAAc,EACnB,KAAK,kCAAkC,GACvC,MAAM,oBAAoB,CAAC;AAE5B,cAAc,WAAW,CAAC"}
|
package/dist/index.js
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
export { createATPTools as createATPToolsBasic, convertToLangChainTools } from './tools.js';
|
|
2
2
|
export * from './langgraph-client.js';
|
|
3
3
|
export { createATPTools, createSimpleATPTool, } from './langgraph-tools.js';
|
|
4
|
+
export { createLangChainEventHandler, createCallbackManagerHandler, } from './event-adapter.js';
|
|
4
5
|
export * from './node.js';
|
|
5
6
|
//# sourceMappingURL=index.js.map
|
package/dist/index.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
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"}
|
|
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,OAAO,EACN,2BAA2B,EAC3B,4BAA4B,GAG5B,MAAM,oBAAoB,CAAC;AAE5B,cAAc,WAAW,CAAC"}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@mondaydotcomorg/atp-langchain",
|
|
3
|
-
"version": "0.20.
|
|
3
|
+
"version": "0.20.2",
|
|
4
4
|
"description": "LangChain integration for Agent Tool Protocol",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"main": "./dist/index.cjs",
|
|
@@ -44,9 +44,9 @@
|
|
|
44
44
|
"license": "MIT",
|
|
45
45
|
"dependencies": {
|
|
46
46
|
"@langchain/core": "^0.3.78",
|
|
47
|
-
"@mondaydotcomorg/atp-client": "0.19.
|
|
48
|
-
"@mondaydotcomorg/atp-protocol": "0.19.
|
|
49
|
-
"@mondaydotcomorg/atp-runtime": "0.19.
|
|
47
|
+
"@mondaydotcomorg/atp-client": "0.19.15",
|
|
48
|
+
"@mondaydotcomorg/atp-protocol": "0.19.15",
|
|
49
|
+
"@mondaydotcomorg/atp-runtime": "0.19.14",
|
|
50
50
|
"json-schema-to-zod": "^2.6.1",
|
|
51
51
|
"langchain": "^0.3.35"
|
|
52
52
|
},
|
|
@@ -0,0 +1,289 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* LangChain Event Adapter
|
|
3
|
+
*
|
|
4
|
+
* Converts ATP streaming events to LangChain-compatible event format.
|
|
5
|
+
* Works with LangChain's callback system and streamEvents API.
|
|
6
|
+
*/
|
|
7
|
+
|
|
8
|
+
import { type ATPEvent, ATPEventType } from '@mondaydotcomorg/atp-protocol';
|
|
9
|
+
|
|
10
|
+
/**
|
|
11
|
+
* LangChain-style event format
|
|
12
|
+
* Compatible with LangChain's streamEvents() output format
|
|
13
|
+
*/
|
|
14
|
+
export interface LangChainEvent {
|
|
15
|
+
event: string;
|
|
16
|
+
name?: string;
|
|
17
|
+
data: unknown;
|
|
18
|
+
run_id?: string;
|
|
19
|
+
metadata?: Record<string, unknown>;
|
|
20
|
+
tags?: string[];
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
/**
|
|
24
|
+
* Options for creating the LangChain event handler
|
|
25
|
+
*/
|
|
26
|
+
export interface CreateLangChainEventHandlerOptions {
|
|
27
|
+
/**
|
|
28
|
+
* Tags to add to all events
|
|
29
|
+
*/
|
|
30
|
+
tags?: string[];
|
|
31
|
+
/**
|
|
32
|
+
* Metadata to add to all events
|
|
33
|
+
*/
|
|
34
|
+
metadata?: Record<string, unknown>;
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
/**
|
|
38
|
+
* Creates an event handler that converts ATP events to LangChain event format.
|
|
39
|
+
*
|
|
40
|
+
* @param onEvent - Callback to receive LangChain-formatted events
|
|
41
|
+
* @param options - Optional configuration
|
|
42
|
+
* @returns An event handler function to pass to ATP's executeStream
|
|
43
|
+
*
|
|
44
|
+
* @example
|
|
45
|
+
* ```typescript
|
|
46
|
+
* const handler = createLangChainEventHandler((event) => {
|
|
47
|
+
* console.log(event.event, event.data);
|
|
48
|
+
* });
|
|
49
|
+
*
|
|
50
|
+
* const result = await client.executeStream(code, {}, handler);
|
|
51
|
+
* ```
|
|
52
|
+
*/
|
|
53
|
+
export function createLangChainEventHandler(
|
|
54
|
+
onEvent: (event: LangChainEvent) => void,
|
|
55
|
+
options: CreateLangChainEventHandlerOptions = {}
|
|
56
|
+
): (event: ATPEvent) => void {
|
|
57
|
+
const { tags = [], metadata = {} } = options;
|
|
58
|
+
|
|
59
|
+
return (event: ATPEvent) => {
|
|
60
|
+
const baseEvent = {
|
|
61
|
+
run_id: event.runId,
|
|
62
|
+
tags: ['atp', ...tags],
|
|
63
|
+
metadata: { ...metadata, timestamp: event.timestamp },
|
|
64
|
+
};
|
|
65
|
+
|
|
66
|
+
switch (event.type) {
|
|
67
|
+
case ATPEventType.THINKING: {
|
|
68
|
+
const data = event.data as { content: string; step?: string };
|
|
69
|
+
onEvent({
|
|
70
|
+
...baseEvent,
|
|
71
|
+
event: 'on_llm_stream',
|
|
72
|
+
name: 'atp_thinking',
|
|
73
|
+
data: {
|
|
74
|
+
chunk: data.content,
|
|
75
|
+
step: data.step,
|
|
76
|
+
},
|
|
77
|
+
});
|
|
78
|
+
break;
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
case ATPEventType.TOOL_START: {
|
|
82
|
+
const data = event.data as { toolName: string; apiGroup: string; input: unknown };
|
|
83
|
+
onEvent({
|
|
84
|
+
...baseEvent,
|
|
85
|
+
event: 'on_tool_start',
|
|
86
|
+
name: `${data.apiGroup}.${data.toolName}`,
|
|
87
|
+
data: {
|
|
88
|
+
input: data.input,
|
|
89
|
+
},
|
|
90
|
+
metadata: {
|
|
91
|
+
...baseEvent.metadata,
|
|
92
|
+
apiGroup: data.apiGroup,
|
|
93
|
+
toolName: data.toolName,
|
|
94
|
+
},
|
|
95
|
+
});
|
|
96
|
+
break;
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
case ATPEventType.TOOL_END: {
|
|
100
|
+
const data = event.data as {
|
|
101
|
+
toolName: string;
|
|
102
|
+
apiGroup: string;
|
|
103
|
+
output: unknown;
|
|
104
|
+
duration: number;
|
|
105
|
+
success: boolean;
|
|
106
|
+
error?: string;
|
|
107
|
+
};
|
|
108
|
+
onEvent({
|
|
109
|
+
...baseEvent,
|
|
110
|
+
event: 'on_tool_end',
|
|
111
|
+
name: `${data.apiGroup}.${data.toolName}`,
|
|
112
|
+
data: {
|
|
113
|
+
output: data.output,
|
|
114
|
+
error: data.error,
|
|
115
|
+
},
|
|
116
|
+
metadata: {
|
|
117
|
+
...baseEvent.metadata,
|
|
118
|
+
apiGroup: data.apiGroup,
|
|
119
|
+
toolName: data.toolName,
|
|
120
|
+
duration: data.duration,
|
|
121
|
+
success: data.success,
|
|
122
|
+
},
|
|
123
|
+
});
|
|
124
|
+
break;
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
case ATPEventType.TEXT: {
|
|
128
|
+
const data = event.data as { text: string };
|
|
129
|
+
onEvent({
|
|
130
|
+
...baseEvent,
|
|
131
|
+
event: 'on_chain_stream',
|
|
132
|
+
name: 'atp_output',
|
|
133
|
+
data: {
|
|
134
|
+
chunk: data.text,
|
|
135
|
+
},
|
|
136
|
+
});
|
|
137
|
+
break;
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
case ATPEventType.TEXT_END:
|
|
141
|
+
onEvent({
|
|
142
|
+
...baseEvent,
|
|
143
|
+
event: 'on_chain_end',
|
|
144
|
+
name: 'atp_output',
|
|
145
|
+
data: {},
|
|
146
|
+
});
|
|
147
|
+
break;
|
|
148
|
+
|
|
149
|
+
case ATPEventType.SOURCE: {
|
|
150
|
+
const data = event.data as {
|
|
151
|
+
url: string;
|
|
152
|
+
title: string;
|
|
153
|
+
summary?: string;
|
|
154
|
+
createdAt?: string;
|
|
155
|
+
};
|
|
156
|
+
onEvent({
|
|
157
|
+
...baseEvent,
|
|
158
|
+
event: 'on_custom_event',
|
|
159
|
+
name: 'atp_source',
|
|
160
|
+
data: {
|
|
161
|
+
url: data.url,
|
|
162
|
+
title: data.title,
|
|
163
|
+
summary: data.summary,
|
|
164
|
+
createdAt: data.createdAt,
|
|
165
|
+
},
|
|
166
|
+
});
|
|
167
|
+
break;
|
|
168
|
+
}
|
|
169
|
+
|
|
170
|
+
case ATPEventType.PROGRESS: {
|
|
171
|
+
const data = event.data as { message: string; fraction: number };
|
|
172
|
+
onEvent({
|
|
173
|
+
...baseEvent,
|
|
174
|
+
event: 'on_custom_event',
|
|
175
|
+
name: 'atp_progress',
|
|
176
|
+
data: {
|
|
177
|
+
message: data.message,
|
|
178
|
+
fraction: data.fraction,
|
|
179
|
+
percentage: Math.round(data.fraction * 100),
|
|
180
|
+
},
|
|
181
|
+
});
|
|
182
|
+
break;
|
|
183
|
+
}
|
|
184
|
+
|
|
185
|
+
case ATPEventType.ERROR: {
|
|
186
|
+
const data = event.data as { message: string; code?: string };
|
|
187
|
+
onEvent({
|
|
188
|
+
...baseEvent,
|
|
189
|
+
event: 'on_chain_error',
|
|
190
|
+
name: 'atp_error',
|
|
191
|
+
data: {
|
|
192
|
+
error: data.message,
|
|
193
|
+
code: data.code,
|
|
194
|
+
},
|
|
195
|
+
});
|
|
196
|
+
break;
|
|
197
|
+
}
|
|
198
|
+
|
|
199
|
+
default:
|
|
200
|
+
// Forward unknown events as custom events
|
|
201
|
+
onEvent({
|
|
202
|
+
...baseEvent,
|
|
203
|
+
event: 'on_custom_event',
|
|
204
|
+
name: `atp_${event.type}`,
|
|
205
|
+
data: event.data,
|
|
206
|
+
});
|
|
207
|
+
break;
|
|
208
|
+
}
|
|
209
|
+
};
|
|
210
|
+
}
|
|
211
|
+
|
|
212
|
+
/**
|
|
213
|
+
* Creates an event handler compatible with LangChain's CallbackManager.
|
|
214
|
+
* Useful for integrating with existing LangChain callback infrastructure.
|
|
215
|
+
*
|
|
216
|
+
* @param callbackManager - LangChain CallbackManager or similar interface
|
|
217
|
+
* @returns An event handler function to pass to ATP's executeStream
|
|
218
|
+
*/
|
|
219
|
+
export function createCallbackManagerHandler(callbackManager: {
|
|
220
|
+
handleCustomEvent?: (
|
|
221
|
+
eventName: string,
|
|
222
|
+
data: unknown,
|
|
223
|
+
runId?: string,
|
|
224
|
+
tags?: string[],
|
|
225
|
+
metadata?: Record<string, unknown>
|
|
226
|
+
) => Promise<void> | void;
|
|
227
|
+
handleToolStart?: (
|
|
228
|
+
tool: { name: string },
|
|
229
|
+
input: string,
|
|
230
|
+
runId?: string,
|
|
231
|
+
parentRunId?: string,
|
|
232
|
+
tags?: string[],
|
|
233
|
+
metadata?: Record<string, unknown>
|
|
234
|
+
) => Promise<void> | void;
|
|
235
|
+
handleToolEnd?: (
|
|
236
|
+
output: string,
|
|
237
|
+
runId?: string,
|
|
238
|
+
parentRunId?: string,
|
|
239
|
+
tags?: string[]
|
|
240
|
+
) => Promise<void> | void;
|
|
241
|
+
handleLLMNewToken?: (
|
|
242
|
+
token: string,
|
|
243
|
+
idx?: { prompt: number; completion: number },
|
|
244
|
+
runId?: string
|
|
245
|
+
) => Promise<void> | void;
|
|
246
|
+
}): (event: ATPEvent) => void {
|
|
247
|
+
return (event: ATPEvent) => {
|
|
248
|
+
switch (event.type) {
|
|
249
|
+
case ATPEventType.THINKING: {
|
|
250
|
+
const data = event.data as { content: string };
|
|
251
|
+
callbackManager.handleLLMNewToken?.(data.content, undefined, event.runId);
|
|
252
|
+
break;
|
|
253
|
+
}
|
|
254
|
+
|
|
255
|
+
case ATPEventType.TOOL_START: {
|
|
256
|
+
const data = event.data as { toolName: string; apiGroup: string; input: unknown };
|
|
257
|
+
callbackManager.handleToolStart?.(
|
|
258
|
+
{ name: `${data.apiGroup}.${data.toolName}` },
|
|
259
|
+
JSON.stringify(data.input),
|
|
260
|
+
event.runId,
|
|
261
|
+
undefined,
|
|
262
|
+
['atp'],
|
|
263
|
+
{ apiGroup: data.apiGroup }
|
|
264
|
+
);
|
|
265
|
+
break;
|
|
266
|
+
}
|
|
267
|
+
|
|
268
|
+
case ATPEventType.TOOL_END: {
|
|
269
|
+
const data = event.data as { output: unknown };
|
|
270
|
+
callbackManager.handleToolEnd?.(JSON.stringify(data.output), event.runId, undefined, [
|
|
271
|
+
'atp',
|
|
272
|
+
]);
|
|
273
|
+
break;
|
|
274
|
+
}
|
|
275
|
+
|
|
276
|
+
case ATPEventType.TEXT: {
|
|
277
|
+
const data = event.data as { text: string };
|
|
278
|
+
callbackManager.handleLLMNewToken?.(data.text, undefined, event.runId);
|
|
279
|
+
break;
|
|
280
|
+
}
|
|
281
|
+
|
|
282
|
+
default:
|
|
283
|
+
callbackManager.handleCustomEvent?.(`atp_${event.type}`, event.data, event.runId, ['atp'], {
|
|
284
|
+
timestamp: event.timestamp,
|
|
285
|
+
});
|
|
286
|
+
break;
|
|
287
|
+
}
|
|
288
|
+
};
|
|
289
|
+
}
|
package/src/index.ts
CHANGED
|
@@ -8,4 +8,11 @@ export {
|
|
|
8
8
|
type ATPToolsResult,
|
|
9
9
|
} from './langgraph-tools.js';
|
|
10
10
|
|
|
11
|
+
export {
|
|
12
|
+
createLangChainEventHandler,
|
|
13
|
+
createCallbackManagerHandler,
|
|
14
|
+
type LangChainEvent,
|
|
15
|
+
type CreateLangChainEventHandlerOptions,
|
|
16
|
+
} from './event-adapter.js';
|
|
17
|
+
|
|
11
18
|
export * from './node.js';
|