-
Notifications
You must be signed in to change notification settings - Fork 2.1k
/
base.ts
126 lines (109 loc) Β· 3.13 KB
/
base.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
import { BaseOutputParser } from "@langchain/core/output_parsers";
import { ChainValues } from "@langchain/core/utils/types";
import { CallbackManager } from "@langchain/core/callbacks/manager";
import { BaseChain } from "../../chains/base.js";
import { LLMChain } from "../../chains/llm_chain.js";
/**
* Represents an action to be performed in a step.
*/
export type StepAction = {
text: string;
};
/**
* Represents the result of a step.
*/
export type StepResult = {
response: string;
};
/**
* Represents a step, which includes an action and its result.
*/
export type Step = {
action: StepAction;
result: StepResult;
};
/**
* Represents a plan, which is a sequence of step actions.
*/
export type Plan = {
steps: StepAction[];
};
/**
* Abstract class that defines the structure for a planner. Planners are
* responsible for generating a plan based on inputs.
*/
export abstract class BasePlanner {
abstract plan(
inputs: ChainValues,
runManager?: CallbackManager
): Promise<Plan>;
}
/**
* Abstract class that defines the structure for a step executor. Step
* executors are responsible for executing a step based on inputs.
*/
export abstract class BaseStepExecutor {
abstract step(
inputs: ChainValues,
runManager?: CallbackManager
): Promise<StepResult>;
}
/**
* Abstract class that defines the structure for a step container. Step
* containers are responsible for managing steps.
*/
export abstract class BaseStepContainer {
abstract addStep(action: StepAction, result: StepResult): void;
abstract getSteps(): Step[];
abstract getFinalResponse(): string;
}
/**
* Class that extends BaseStepContainer and provides an implementation for
* its methods. It maintains a list of steps and provides methods to add a
* step, get all steps, and get the final response.
*/
export class ListStepContainer extends BaseStepContainer {
private steps: Step[] = [];
addStep(action: StepAction, result: StepResult) {
this.steps.push({ action, result });
}
getSteps() {
return this.steps;
}
getFinalResponse(): string {
return this.steps[this.steps.length - 1]?.result?.response;
}
}
/**
* Class that extends BasePlanner and provides an implementation for the
* plan method. It uses an instance of LLMChain and an output parser to
* generate a plan.
*/
export class LLMPlanner extends BasePlanner {
constructor(
private llmChain: LLMChain,
private outputParser: BaseOutputParser<Plan>
) {
super();
}
async plan(inputs: ChainValues, runManager?: CallbackManager): Promise<Plan> {
const output = await this.llmChain.run(inputs, runManager);
return this.outputParser.parse(output);
}
}
/**
* Class that extends BaseStepExecutor and provides an implementation for
* the step method. It uses an instance of BaseChain to execute a step.
*/
export class ChainStepExecutor extends BaseStepExecutor {
constructor(private chain: BaseChain) {
super();
}
async step(
inputs: ChainValues,
runManager?: CallbackManager
): Promise<StepResult> {
const chainResponse = await this.chain.call(inputs, runManager);
return { response: chainResponse.output };
}
}