illuma-agents 1.0.2

package/src/mockStream.ts

@@ -0,0 +1,99 @@
+
+// import { nanoid } from 'nanoid';
+import type OpenAITypes from 'openai';
+import type * as t from '@/types';
+// import { SplitStreamHandler } from '@/splitStream';
+// import { GraphEvents } from '@/common';
+import { sleep } from '@/utils';
+
+const choiceProps: OpenAITypes.Chat.Completions.ChatCompletionChunk.Choice = { finish_reason: null, index: 0, delta: {} };
+const reasoningSplitRegex = /(?<=\s+)|(?=\s+)/;
+const contentSplitRegex = /(?<=<\/?think>)|(?=<\/?think>)|(?<=\s+)|(?=\s+)/;
+export const createMockStream = (options: {
+  text?: string;
+  reasoningText?: string;
+  streamRate?: number;
+  reasoningKey?: 'reasoning' | 'reasoning_content';
+} = {}) => {
+  const {
+    text,
+    reasoningText,
+    streamRate = 25,
+    reasoningKey = 'reasoning_content'
+  } = options;
+
+  return async function* mockOpenAIStream(): AsyncGenerator<t.CustomChunk> {
+    const content = text ?? `Here's a sample message that includes code:
+\`\`\`python
+def hello_world():
+    print("Hello, World!")
+    # This is a long code block
+    # That shouldn't be split
+    return True
+\`\`\`
+Now we're back to regular text. This is a very long sentence that should probably be split at some point because it exceeds our threshold and contains multiple natural breaking points. Let's see how it handles this case properly.
+
+Here's another code block:
+\`\`\`javascript
+console.log("Another test");
+// More code here
+\`\`\`
+And finally some more regular text to test our splitting logic.`;
+
+    if (reasoningText != null && reasoningText) {
+      // Split reasoning text into "token-like" chunks
+      const reasoningTokens = reasoningText.split(reasoningSplitRegex);
+      for (const token of reasoningTokens) {
+        yield {
+          choices: [{
+            ...choiceProps,
+            delta: {
+              [reasoningKey]: token,
+            },
+          }]
+        };
+        await sleep(streamRate);
+      }
+    }
+
+    // Split main content into "token-like" chunks
+    const tokens = content.split(contentSplitRegex);
+    for (const token of tokens) {
+      yield {
+        choices: [{
+          ...choiceProps,
+          delta: {
+            content: token
+          }
+        }]
+      };
+      await sleep(streamRate);
+    }
+  };
+};
+
+/**
+(async function testStream(): Promise<void> {
+  const runId = nanoid();
+
+  const streamHandler = new SplitStreamHandler({
+    runId,
+    handlers: {
+      [GraphEvents.ON_RUN_STEP]: (data): void => {
+        console.dir(data, { depth: null });
+      },
+      [GraphEvents.ON_MESSAGE_DELTA]: (): void => {
+        // console.dir(data, { depth: null });
+      },
+    },
+  });
+  const stream = createMockStream({
+    reasoningText: 'This is a test reasoning text.',
+    streamRate: 5,
+  })();
+
+  for await (const chunk of stream) {
+    streamHandler.handle(chunk);
+  }
+})();
+ */

package/src/prompts/collab.ts

@@ -0,0 +1,6 @@
+// src/prompts/collab.ts
+export const supervisorPrompt = `You are a supervisor tasked with managing a conversation between the
+following workers: {members}. Given the following user request,
+respond with the worker to act next. Each worker will perform a
+task and respond with their results and status. Multiple workers can work at once, and they can use multiple tools at once. Each worker can run their tools multiple times per task. When finished,
+respond with FINISH.`;

package/src/prompts/index.ts

@@ -0,0 +1,2 @@
+export * from './collab';
+export * from './taskmanager';

package/src/prompts/taskmanager.ts

@@ -0,0 +1,61 @@
+export const taskManagerPrompt = `You are a Task Manager responsible for efficiently coordinating a team of specialized workers: {members}. Your PRIMARY and SOLE OBJECTIVE is to fulfill the user's specific request as quickly and effectively as possible.
+
+CRITICAL GUIDELINES:
+1. The user's request is your CHIEF CONCERN. Every action must directly contribute to fulfilling this request.
+2. Aim to complete the entire task in NO MORE THAN 2-3 TURNS, unless explicitly instructed otherwise.
+3. Eliminate all superfluous activity. Each task must be essential to achieving the user's goal.
+4. Assign no more than 5 tasks per turn, and only if absolutely necessary.
+5. Be concise and direct in your task assignments.
+6. End the process IMMEDIATELY once the user's request is fulfilled by setting 'end' to true and assigning no new tasks.
+
+Your responsibilities:
+1. Analyze the user's request and break it down into the minimum necessary subtasks.
+2. Assign these essential tasks to the most appropriate team members based on their skills and tools.
+3. Prioritize tasks to ensure the most efficient path to completion.
+4. Continuously evaluate if the user's request has been fully addressed.
+5. End the process IMMEDIATELY once the user's request is fulfilled.
+
+Task Assignment Guidelines:
+- Assign only the most crucial tasks required to meet the user's needs.
+- Multiple tasks can be assigned to the same team member if it improves efficiency.
+- Always specify the tool to use if applicable.
+- Consider task dependencies to minimize the number of turns.
+
+After each round:
+- Critically assess if the user's request has been fully addressed.
+- If more work is genuinely needed, assign only the most essential remaining tasks.
+- If the user's request has been fulfilled or can be fulfilled with the results at hand, set 'end' to true and assign no new tasks.
+
+REMEMBER: Your success is measured by how quickly and effectively you fulfill the user's request, not by the number of tasks assigned or turns taken. Excessive deliberation or unnecessary tasks are counterproductive. Focus solely on the user's needs and conclude the process as soon as those needs are met.`;
+
+export const assignTasksFunctionDescription = 'Assign the minimum necessary tasks to team members to fulfill the user\'s request as quickly as possible. Assign up to 5 tasks maximum per turn, only if absolutely necessary. Each task must specify the team member, a concise description, and the tool to use if applicable.';
+
+export const assignTasksFunctionParameters = {
+  type: 'object',
+  properties: {
+    tasks: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          member: { type: 'string', description: 'Name of the team member assigned to the task' },
+          description: { type: 'string', description: 'Concise description of the essential task to be performed' },
+          tool: { type: 'string', description: 'Specific tool to be used for the task, if applicable' },
+        },
+        required: ['member', 'description'],
+      },
+      description: 'List of essential tasks to be assigned, maximum 5 tasks per turn.',
+    },
+  },
+  required: ['tasks'],
+};
+
+export const endProcessFunctionDescription = 'End the process when the user\'s request has been fulfilled.';
+
+export const endProcessFunctionParameters = {
+  type: 'object',
+  properties: {
+    reason: { type: 'string', description: 'Brief explanation of why the process is ending' },
+  },
+  required: ['reason'],
+};

package/src/proto/CollabGraph.ts

@@ -0,0 +1,269 @@
+// src/graphs/CollabGraph.ts
+import { AIMessageChunk, BaseMessage, HumanMessage } from '@langchain/core/messages';
+import { END, StateGraphArgs, START, StateGraph, MemorySaver } from '@langchain/langgraph';
+import { AgentExecutor, createOpenAIToolsAgent } from 'langchain/agents';
+import { ChatPromptTemplate, MessagesPlaceholder } from '@langchain/core/prompts';
+import type { StructuredTool } from '@langchain/core/tools';
+import { Runnable, RunnableConfig } from '@langchain/core/runnables';
+import { JsonOutputToolsParser } from 'langchain/output_parsers';
+import { Providers } from '@/common';
+import { getChatModelClass } from '@/llm/providers';
+import { Graph } from '../graphs/Graph';
+import type * as t from '@/types';
+import { supervisorPrompt } from '@/prompts/collab';
+
+export interface CollabAgentStateChannels {
+  messages: BaseMessage[];
+  next: string;
+  [key: string]: any;
+}
+
+export interface CollabMember {
+  name: string;
+  systemPrompt: string;
+  tools: any[];
+  llmConfig: t.LLMConfig;
+}
+
+interface SupervisorConfig {
+  systemPrompt?: string;
+  llmConfig: t.LLMConfig;
+}
+
+export class CollabGraph extends Graph<CollabAgentStateChannels, string> {
+  resetValues(): void {
+    throw new Error('Method not implemented.');
+  }
+  getFinalMessage(): AIMessageChunk | undefined {
+    throw new Error('Method not implemented.');
+  }
+  generateStepId(stepKey: string): [string, number] {
+    throw new Error('Method not implemented.');
+  }
+  getKeyList(metadata: Record<string, unknown> | undefined): (string | number | undefined)[] {
+    throw new Error('Method not implemented.');
+  }
+  getStepKey(metadata: Record<string, unknown> | undefined): string {
+    throw new Error('Method not implemented.');
+  }
+  checkKeyList(keyList: (string | number | undefined)[]): boolean {
+    throw new Error('Method not implemented.');
+  }
+  getStepIdByKey(stepKey: string, index?: number): string {
+    throw new Error('Method not implemented.');
+  }
+  getRunStep(stepId: string): t.RunStep | undefined {
+    throw new Error('Method not implemented.');
+  }
+  dispatchRunStep(stepKey: string, stepDetails: t.StepDetails): void {
+    throw new Error('Method not implemented.');
+  }
+  dispatchRunStepDelta(id: string, delta: t.ToolCallDelta): void {
+    throw new Error('Method not implemented.');
+  }
+  dispatchMessageDelta(id: string, delta: t.MessageDelta): void {
+    throw new Error('Method not implemented.');
+  }
+  private graph: t.CompiledWorkflow<CollabAgentStateChannels, Partial<CollabAgentStateChannels>, string> | null = null;
+  private members: t.Member[];
+  private supervisorConfig: SupervisorConfig;
+  private supervisorChain: Runnable | null = null;
+
+  constructor(members: t.Member[], supervisorConfig: SupervisorConfig) {
+    super();
+    this.members = members;
+    this.supervisorConfig = supervisorConfig;
+  }
+
+  async initialize(): Promise<void> {
+    const memberNames = this.members.map(member => member.name);
+    const systemPrompt = this.supervisorConfig.systemPrompt || supervisorPrompt;
+    const options = [END, ...memberNames];
+    this.supervisorChain = await this.createSupervisorChain(systemPrompt, options);
+  }
+
+  createGraphState(): StateGraphArgs<CollabAgentStateChannels>['channels'] {
+    return {
+      messages: {
+        value: (x?: BaseMessage[], y?: BaseMessage[]) => (x ?? []).concat(y ?? []),
+        default: () => [],
+      },
+      next: {
+        value: (x?: string, y?: string) => y ?? x ?? END,
+        default: () => END,
+      },
+    };
+  }
+
+  initializeTools(tools: StructuredTool[]): any {
+    // This method is not used in the collaborative graph
+    return null;
+  }
+
+  initializeModel(provider: Providers, clientOptions: Record<string, unknown>, tools: any[]) {
+    const LLMClass = getChatModelClass(provider);
+    if (!LLMClass) {
+      throw new Error(`Unsupported LLM provider: ${provider}`);
+    }
+    return new LLMClass(clientOptions);
+  }
+
+  createCallModel(boundModel: any) {
+    // This method is not directly used in the collaborative graph
+    return async (state: CollabAgentStateChannels, config?: RunnableConfig) => {
+      return { messages: [] };
+    };
+  }
+
+  private async createAgent(
+    llmConfig: t.LLMConfig,
+    tools: any[],
+    systemPrompt: string
+  ): Promise<AgentExecutor> {
+    const { provider, ...clientOptions } = llmConfig;
+    const LLMClass = getChatModelClass(provider);
+    if (!LLMClass) {
+      throw new Error(`Unsupported LLM provider: ${provider}`);
+    }
+    const llm = new LLMClass(clientOptions);
+
+    const prompt = await ChatPromptTemplate.fromMessages([
+      ['system', systemPrompt],
+      new MessagesPlaceholder('messages'),
+      new MessagesPlaceholder('agent_scratchpad'),
+    ]);
+    const agent = await createOpenAIToolsAgent({ llm, tools, prompt });
+    return new AgentExecutor({ agent, tools });
+  }
+
+  createWorkflow(
+    graphState: StateGraphArgs<CollabAgentStateChannels>['channels'],
+    callModel?: any,
+    toolNode?: any
+  ): t.CompiledWorkflow<CollabAgentStateChannels, Partial<CollabAgentStateChannels>, string> {
+    if (!this.supervisorChain) {
+      throw new Error('CollabGraph not initialized. Call initialize() first.');
+    }
+
+    const workflow = new StateGraph<CollabAgentStateChannels, Partial<CollabAgentStateChannels>, string>({
+      channels: graphState,
+    });
+
+    // Dynamically create agents and add nodes for each member
+    for (const member of this.members) {
+      const node = async (
+        state: CollabAgentStateChannels,
+        config?: RunnableConfig,
+      ) => {
+        const agent = await this.createAgent(member.llmConfig, member.tools, member.systemPrompt);
+        const agentPromise = agent.invoke(state, config);
+
+        // Store the promise in the state
+        await this.graph?.updateState(config ?? {}, {
+          [`${member.name}Promise`]: agentPromise,
+        });
+
+        const result = await agentPromise;
+        return {
+          messages: [
+            new HumanMessage({ content: result.output, name: member.name }),
+          ],
+        };
+      };
+      workflow.addNode(member.name, node);
+      workflow.addEdge(member.name, 'supervisor');
+    }
+
+    const supervisorNode = async (
+      state: CollabAgentStateChannels,
+      config?: RunnableConfig,
+    ) => {
+      // Get the current state
+      const currentState = await this.graph?.getState(config ?? {});
+
+      // Wait for all member promises to resolve
+      const memberPromises = this.members.map(member => currentState?.[`${member.name}Promise` as keyof typeof currentState]);
+      await Promise.all(memberPromises);
+
+      // Clear the promises for the next iteration
+      for (const member of this.members) {
+        await this.graph?.updateState(config ?? {}, {
+          [`${member.name}Promise`]: undefined,
+        });
+      }
+
+      const result = await this.supervisorChain?.invoke(state, config);
+      return result;
+    };
+
+    workflow.addNode('supervisor', supervisorNode);
+
+    workflow.addConditionalEdges(
+      'supervisor',
+      (x: CollabAgentStateChannels) => x.next,
+    );
+
+    workflow.addEdge(START, 'supervisor');
+
+    const memory = new MemorySaver();
+    this.graph = workflow.compile({ checkpointer: memory });
+    return this.graph;
+  }
+
+  private async createSupervisorChain(systemPrompt: string, options: string[]): Promise<Runnable> {
+    const functionDef = {
+      name: 'route',
+      description: 'Select the next role.',
+      parameters: {
+        title: 'routeSchema',
+        type: 'object',
+        properties: {
+          next: {
+            title: 'Next',
+            anyOf: [
+              { enum: options },
+            ],
+          },
+        },
+        required: ['next'],
+      },
+    };
+
+    const toolDef = {
+      type: 'function',
+      function: functionDef,
+    } as const;
+
+    const prompt = ChatPromptTemplate.fromMessages([
+      ['system', systemPrompt],
+      new MessagesPlaceholder('messages'),
+      [
+        'system',
+        'Given the conversation above, who should act next?' +
+        ' Or should we FINISH? Select one of: {options}',
+      ],
+    ]);
+
+    const formattedPrompt = await prompt.partial({
+      options: options.join(', '),
+      members: this.members.map(m => m.name).join(', '),
+    });
+
+    const { provider, ...clientOptions } = this.supervisorConfig.llmConfig;
+    const LLMClass = getChatModelClass(provider);
+    if (!LLMClass) {
+      throw new Error(`Unsupported LLM provider for supervisor: ${provider}`);
+    }
+    const llm = new LLMClass(clientOptions);
+
+    return formattedPrompt
+      .pipe(llm.bindTools(
+        [toolDef],
+        {
+          tool_choice: { type: 'function', function: { name: 'route' } } as any,
+        },
+      ))
+      .pipe(new JsonOutputToolsParser())
+      .pipe((x: any) => (x[0].args));
+  }
+}

package/src/proto/TaskManager.ts

@@ -0,0 +1,243 @@
+// src/graphs/TaskManager.ts
+import { JsonOutputToolsParser } from 'langchain/output_parsers';
+import { AgentExecutor, createOpenAIToolsAgent } from 'langchain/agents';
+import { BaseMessage, HumanMessage, AIMessage } from '@langchain/core/messages';
+import { ChatPromptTemplate, MessagesPlaceholder } from '@langchain/core/prompts';
+import { END, START, StateGraph, MemorySaver } from '@langchain/langgraph';
+import type { Runnable, RunnableConfig } from '@langchain/core/runnables';
+import type { ToolNode } from '@langchain/langgraph/prebuilt';
+import type { StructuredTool } from '@langchain/core/tools';
+import type { StateGraphArgs } from '@langchain/langgraph';
+import type * as t from '@/types';
+import {
+  taskManagerPrompt,
+  endProcessFunctionParameters,
+  endProcessFunctionDescription,
+  assignTasksFunctionParameters,
+  assignTasksFunctionDescription,
+} from '@/prompts/taskmanager';
+import { getChatModelClass } from '@/llm/providers';
+import { Providers } from '@/common';
+import { Graph } from '../graphs/Graph';
+
+export interface TaskManagerStateChannels {
+  messages: BaseMessage[];
+  tasks: Task[];
+  completedTasks: string[];
+  next: string;
+}
+
+export interface Task {
+  member: string;
+  description: string;
+  tool?: string;
+}
+
+export interface TaskMember {
+  name: string;
+  systemPrompt: string;
+  tools: StructuredTool[];
+  llmConfig: t.LLMConfig;
+}
+
+interface SupervisorConfig {
+  systemPrompt?: string;
+  llmConfig: t.LLMConfig;
+}
+
+export class TaskManager extends Graph<TaskManagerStateChannels, string> {
+  initializeTools(tools: StructuredTool[]): ToolNode<TaskManagerStateChannels> {
+    throw new Error('Method not implemented.');
+  }
+  initializeModel(provider: Providers, clientOptions: Record<string, unknown>, tools: StructuredTool[]) {
+    throw new Error('Method not implemented.');
+  }
+  createCallModel(boundModel: any): (state: TaskManagerStateChannels, config?: RunnableConfig) => Promise<Partial<TaskManagerStateChannels>> {
+    throw new Error('Method not implemented.');
+  }
+  private graph: t.CompiledWorkflow<TaskManagerStateChannels, Partial<TaskManagerStateChannels>, string> | null = null;
+  private members: TaskMember[];
+  private supervisorConfig: SupervisorConfig;
+  private supervisorChain: Runnable | null = null;
+
+  constructor(members: TaskMember[], supervisorConfig: SupervisorConfig) {
+    super();
+    this.members = members;
+    this.supervisorConfig = supervisorConfig;
+  }
+
+  async initialize(): Promise<void> {
+    const memberNames = this.members.map(member => member.name);
+    const systemPrompt = this.supervisorConfig.systemPrompt || taskManagerPrompt;
+    this.supervisorChain = await this.createSupervisorChain(systemPrompt, memberNames);
+  }
+
+  createGraphState(): StateGraphArgs<TaskManagerStateChannels>['channels'] {
+    return {
+      messages: {
+        value: (x?: BaseMessage[], y?: BaseMessage[]) => (x ?? []).concat(y ?? []),
+        default: () => [],
+      },
+      tasks: {
+        value: (x?: Task[], y?: Task[]) => y ?? x ?? [],
+        default: () => [],
+      },
+      completedTasks: {
+        value: (x?: string[], y?: string[]) => [...new Set([...(x ?? []), ...(y ?? [])])],
+        default: () => [],
+      },
+      next: {
+        value: (x?: string, y?: string) => y ?? x ?? END,
+        default: () => END,
+      },
+    };
+  }
+
+  private async createAgent(
+    llmConfig: t.LLMConfig,
+    tools: StructuredTool[],
+    systemPrompt: string
+  ): Promise<AgentExecutor> {
+    const { provider, ...clientOptions } = llmConfig;
+    const LLMClass = getChatModelClass(provider);
+    if (!LLMClass) {
+      throw new Error(`Unsupported LLM provider: ${provider}`);
+    }
+    const llm = new LLMClass(clientOptions);
+
+    const prompt = ChatPromptTemplate.fromMessages([
+      ['system', systemPrompt],
+      new MessagesPlaceholder('chat_history'),
+      ['human', '{input}'],
+      new MessagesPlaceholder('agent_scratchpad'),
+    ]);
+    const agent = await createOpenAIToolsAgent({ llm, tools, prompt });
+    return new AgentExecutor({ agent, tools });
+  }
+
+  createWorkflow(
+    graphState: StateGraphArgs<TaskManagerStateChannels>['channels'],
+    callModel?: any,
+  ): t.CompiledWorkflow<TaskManagerStateChannels, Partial<TaskManagerStateChannels>, string> {
+    if (!this.supervisorChain) {
+      throw new Error('TaskManager not initialized. Call initialize() first.');
+    }
+
+    const workflow = new StateGraph<TaskManagerStateChannels, Partial<TaskManagerStateChannels>, string>({
+      channels: graphState,
+    });
+
+    const supervisorNode = async (
+      state: TaskManagerStateChannels,
+      config?: RunnableConfig,
+    ) => {
+      const result = await this.supervisorChain?.invoke(state, config) as { tasks?: Task[], reason?: string };
+      console.log('Supervisor Node Output:', result);
+
+      if (result && result.reason) {
+        console.log('Process ending. Reason:', result.reason);
+        return { next: END };
+      }
+
+      const newTasks = (result.tasks || []).filter(task =>
+        !state.completedTasks.includes(`${task.member}:${task.description}`)
+      );
+
+      return {
+        tasks: newTasks,
+        next: newTasks.length > 0 ? 'execute_tasks' : END,
+      };
+    };
+
+    const executeTasksNode = async (
+      state: TaskManagerStateChannels,
+      config?: RunnableConfig,
+    ) => {
+      const results: BaseMessage[] = [];
+      const completedTasks: string[] = [];
+
+      for (const task of state.tasks) {
+        const member = this.members.find(m => m.name === task.member);
+        if (!member) {
+          throw new Error(`TaskMember ${task.member} not found`);
+        }
+
+        const agent = await this.createAgent(member.llmConfig, member.tools, member.systemPrompt);
+        const taskMessage = new HumanMessage(`Task: ${task.description}${task.tool ? ` Use the ${task.tool} tool.` : ''}`);
+        const result = await agent.invoke({
+          input: taskMessage.content,
+          chat_history: state.messages,
+        }, config);
+
+        results.push(new AIMessage({ content: result.output, name: task.member }));
+        completedTasks.push(`${task.member}:${task.description}`);
+      }
+
+      return {
+        messages: state.messages.concat(results),
+        completedTasks: state.completedTasks.concat(completedTasks),
+        tasks: [],
+        next: 'supervisor',
+      };
+    };
+
+    workflow.addNode('supervisor', supervisorNode);
+    workflow.addNode('execute_tasks', executeTasksNode);
+
+    workflow.addEdge(START, 'supervisor');
+    workflow.addConditionalEdges(
+      'supervisor',
+      (x: TaskManagerStateChannels) => x.next,
+    );
+    workflow.addEdge('execute_tasks', 'supervisor');
+
+    const memory = new MemorySaver();
+    this.graph = workflow.compile({ checkpointer: memory });
+    return this.graph;
+  }
+
+  private async createSupervisorChain(systemPrompt: string, memberNames: string[]): Promise<Runnable> {
+    const assignTasksDef = {
+      name: 'assign_tasks',
+      description: assignTasksFunctionDescription,
+      parameters: assignTasksFunctionParameters,
+    };
+
+    const endProcessDef = {
+      name: 'end_process',
+      description: endProcessFunctionDescription,
+      parameters: endProcessFunctionParameters,
+    };
+
+    const toolDefs = [
+      { type: 'function', function: assignTasksDef },
+      { type: 'function', function: endProcessDef },
+    ];
+
+    const prompt = ChatPromptTemplate.fromMessages([
+      ['system', systemPrompt],
+      new MessagesPlaceholder('messages'),
+      new MessagesPlaceholder('completedTasks'),
+      [
+        'human',
+        'Based on the conversation above and the completed tasks, either assign new tasks using the \'assign_tasks\' function or end the process using the \'end_process\' function if the user\'s request is fulfilled. Assign only the most essential tasks to minimize the number of turns. Do not repeat tasks that have already been completed.',
+      ],
+    ]);
+
+    const formattedPrompt = await prompt.partial({
+      members: memberNames.join(', '),
+    });
+
+    const { provider, ...clientOptions } = this.supervisorConfig.llmConfig;
+    const LLMClass = getChatModelClass(provider);
+    if (!LLMClass) {
+      throw new Error(`Unsupported LLM provider for supervisor: ${provider}`);
+    }
+    const llm = new LLMClass(clientOptions);
+
+    return formattedPrompt
+      .pipe(llm.bindTools(toolDefs))
+      .pipe(new JsonOutputToolsParser())
+      .pipe((x: any) => x[0].args);
+  }
+}