-
Notifications
You must be signed in to change notification settings - Fork 2.1k
/
openai_tools.ts
148 lines (122 loc) Β· 4.29 KB
/
openai_tools.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
import type { ChatGeneration } from "@langchain/core/outputs";
export type ParsedToolCall = {
id?: string;
type: string;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
args: Record<string, any>;
/** @deprecated Use `type` instead. Will be removed in 0.2.0. */
name: string;
/** @deprecated Use `args` instead. Will be removed in 0.2.0. */
arguments: Record<string, any>; // eslint-disable-line @typescript-eslint/no-explicit-any
};
export type JsonOutputToolsParserParams = {
/** Whether to return the tool call id. */
returnId?: boolean;
};
/**
* Class for parsing the output of a tool-calling LLM into a JSON object.
*/
export class JsonOutputToolsParser extends BaseLLMOutputParser<
ParsedToolCall[]
> {
static lc_name() {
return "JsonOutputToolsParser";
}
returnId = false;
lc_namespace = ["langchain", "output_parsers", "openai_tools"];
lc_serializable = true;
constructor(fields?: JsonOutputToolsParserParams) {
super(fields);
this.returnId = fields?.returnId ?? this.returnId;
}
/**
* Parses the output and returns a JSON object. If `argsOnly` is true,
* only the arguments of the function call are returned.
* @param generations The output of the LLM to parse.
* @returns A JSON object representation of the function call or its arguments.
*/
async parseResult(generations: ChatGeneration[]): Promise<ParsedToolCall[]> {
const toolCalls = generations[0].message.additional_kwargs.tool_calls;
if (!toolCalls) {
throw new Error(
`No tools_call in message ${JSON.stringify(generations)}`
);
}
const clonedToolCalls = JSON.parse(JSON.stringify(toolCalls));
const parsedToolCalls = [];
for (const toolCall of clonedToolCalls) {
if (toolCall.function !== undefined) {
// @ts-expect-error name and arguemnts are defined by Object.defineProperty
const parsedToolCall: ParsedToolCall = {
type: toolCall.function.name,
args: JSON.parse(toolCall.function.arguments),
};
if (this.returnId) {
parsedToolCall.id = toolCall.id;
}
// backward-compatibility with previous
// versions of Langchain JS, which uses `name` and `arguments`
Object.defineProperty(parsedToolCall, "name", {
get() {
return this.type;
},
});
Object.defineProperty(parsedToolCall, "arguments", {
get() {
return this.args;
},
});
parsedToolCalls.push(parsedToolCall);
}
}
return parsedToolCalls;
}
}
export type JsonOutputKeyToolsParserParams = {
keyName: string;
returnSingle?: boolean;
/** Whether to return the tool call id. */
returnId?: boolean;
};
/**
* Class for parsing the output of a tool-calling LLM into a JSON object if you are
* expecting only a single tool to be called.
*/
// eslint-disable-next-line @typescript-eslint/no-explicit-any
export class JsonOutputKeyToolsParser extends BaseLLMOutputParser<any> {
static lc_name() {
return "JsonOutputKeyToolsParser";
}
lc_namespace = ["langchain", "output_parsers", "openai_tools"];
lc_serializable = true;
returnId = false;
/** The type of tool calls to return. */
keyName: string;
/** Whether to return only the first tool call. */
returnSingle = false;
initialParser: JsonOutputToolsParser;
constructor(params: JsonOutputKeyToolsParserParams) {
super(params);
this.keyName = params.keyName;
this.returnSingle = params.returnSingle ?? this.returnSingle;
this.initialParser = new JsonOutputToolsParser(params);
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
async parseResult(generations: ChatGeneration[]): Promise<any> {
const results = await this.initialParser.parseResult(generations);
const matchingResults = results.filter(
(result) => result.type === this.keyName
);
// eslint-disable-next-line @typescript-eslint/no-explicit-any
let returnedValues: ParsedToolCall[] | Record<string, any>[] =
matchingResults;
if (!this.returnId) {
returnedValues = matchingResults.map((result) => result.args);
}
if (this.returnSingle) {
return returnedValues[0];
}
return returnedValues;
}
}