diff --git a/apps/rowboat/app/actions/actions.ts b/apps/rowboat/app/actions/actions.ts index e72efe79..2b5114e5 100644 --- a/apps/rowboat/app/actions/actions.ts +++ b/apps/rowboat/app/actions/actions.ts @@ -1,6 +1,4 @@ 'use server'; -import { AgenticAPIInitStreamResponse } from "../lib/types/agents_api_types"; -import { AgenticAPIChatRequest } from "../lib/types/agents_api_types"; import { WebpageCrawlResponse } from "../lib/types/tool_types"; import { webpagesCollection } from "../lib/mongodb"; import { z } from 'zod'; @@ -10,6 +8,8 @@ import { check_query_limit } from "../lib/rate_limiting"; import { QueryLimitError } from "../lib/client_utils"; import { projectAuthCheck } from "./project_actions"; import { authorizeUserAction } from "./billing_actions"; +import { Workflow, WorkflowTool } from "../lib/types/workflow_types"; +import { Message } from "@/app/lib/types/types"; const crawler = new FirecrawlApp({ apiKey: process.env.FIRECRAWL_API_KEY || '' }); @@ -57,14 +57,18 @@ export async function scrapeWebpage(url: string): Promise): Promise | { billingError: string }> { - await projectAuthCheck(request.projectId); - if (!await check_query_limit(request.projectId)) { +export async function getAssistantResponseStreamId( + workflow: z.infer, + projectTools: z.infer[], + messages: z.infer[], +): Promise<{ streamId: string } | { billingError: string }> { + await projectAuthCheck(workflow.projectId); + if (!await check_query_limit(workflow.projectId)) { throw new QueryLimitError(); } // Check billing authorization - const agentModels = request.agents.reduce((acc, agent) => { + const agentModels = workflow.agents.reduce((acc, agent) => { acc.push(agent.model); return acc; }, [] as string[]); @@ -78,6 +82,6 @@ export async function getAssistantResponseStreamId(request: z.infer[], - current_workflow_config: z.infer, - context: z.infer | null, - dataSources?: z.infer[] -): Promise<{ - message: z.infer; - rawRequest: unknown; - rawResponse: unknown; -} | { billingError: string }> { - await projectAuthCheck(projectId); - if (!await check_query_limit(projectId)) { - throw new QueryLimitError(); - } - - // Check billing authorization - const authResponse = await authorizeUserAction({ - type: 'copilot_request', - data: {}, - }); - if (!authResponse.success) { - return { billingError: authResponse.error || 'Billing error' }; - } - - // Get MCP tools from project and merge with workflow tools - const mcpTools = await fetchProjectMcpTools(projectId); - - // Convert workflow to copilot format with both workflow and project tools - const copilotWorkflow = convertToCopilotWorkflow({ - ...current_workflow_config, - tools: await mergeProjectTools(current_workflow_config.tools, mcpTools) - }); - - // prepare request - const request: z.infer = { - projectId: projectId, - messages: messages.map(convertToCopilotApiMessage), - workflow_schema: JSON.stringify(zodToJsonSchema(CopilotWorkflow)), - current_workflow_config: JSON.stringify(copilotWorkflow), - context: context ? convertToCopilotApiChatContext(context) : null, - dataSources: dataSources ? dataSources.map(ds => { - console.log('Original data source:', JSON.stringify(ds)); - // First parse to validate, then ensure _id is included - CopilotDataSource.parse(ds); // validate but don't use the result - // Cast to any to handle the WithStringId type - const withId = ds as any; - const result = { - _id: withId._id, - name: withId.name, - description: withId.description, - active: withId.active, - status: withId.status, - error: withId.error, - data: withId.data - }; - console.log('Processed data source:', JSON.stringify(result)); - return result; - }) : undefined, - }; - console.log(`sending copilot request`, JSON.stringify(request)); - - // call copilot api - const response = await fetch(process.env.COPILOT_API_URL + '/chat', { - method: 'POST', - body: JSON.stringify(request), - headers: { - 'Content-Type': 'application/json', - 'Authorization': `Bearer ${process.env.COPILOT_API_KEY || 'test'}`, - }, - }); - if (!response.ok) { - console.error('Failed to call copilot api', response); - throw new Error(`Failed to call copilot api: ${response.statusText}`); - } - - // parse and return response - const json: z.infer = await response.json(); - console.log(`received copilot response`, JSON.stringify(json)); - if ('error' in json) { - throw new Error(`Failed to call copilot api: ${json.error}`); - } - // remove leading ```json and trailing ``` - const msg = convertToCopilotMessage({ - role: 'assistant', - content: json.response.replace(/^```json\n/, '').replace(/\n```$/, ''), - }); - - // validate response schema - assert(msg.role === 'assistant'); - if (msg.role === 'assistant') { - const content = JSON.parse(msg.content); - for (const part of content.response) { - if (part.type === 'action') { - const result = validateConfigChanges( - part.content.config_type, - part.content.config_changes, - part.content.name - ); - - if ('error' in result) { - part.content.error = result.error; - } else { - part.content.config_changes = result.changes; - } - } - } - } - - return { - message: msg as z.infer, - rawRequest: request, - rawResponse: json, - }; -} +import { WithStringId } from "../lib/types/types"; +import { getEditAgentInstructionsResponse } from "../lib/copilot/copilot"; export async function getCopilotResponseStream( projectId: string, messages: z.infer[], current_workflow_config: z.infer, context: z.infer | null, - dataSources?: z.infer[] + dataSources?: WithStringId>[] ): Promise<{ streamId: string; } | { billingError: string }> { @@ -167,19 +49,18 @@ export async function getCopilotResponseStream( const mcpTools = await fetchProjectMcpTools(projectId); // Convert workflow to copilot format with both workflow and project tools - const copilotWorkflow = convertToCopilotWorkflow({ + const wflow = { ...current_workflow_config, - tools: await mergeProjectTools(current_workflow_config.tools, mcpTools) - }); + tools: mergeProjectTools(current_workflow_config.tools, mcpTools) + }; // prepare request const request: z.infer = { - projectId: projectId, - messages: messages.map(convertToCopilotApiMessage), - workflow_schema: JSON.stringify(zodToJsonSchema(CopilotWorkflow)), - current_workflow_config: JSON.stringify(copilotWorkflow), - context: context ? convertToCopilotApiChatContext(context) : null, - dataSources: dataSources ? dataSources.map(ds => CopilotDataSource.parse(ds)) : undefined, + projectId, + messages, + workflow: wflow, + context, + dataSources: dataSources, }; // serialize the request @@ -189,9 +70,7 @@ export async function getCopilotResponseStream( const streamId = crypto.randomUUID(); // store payload in redis - await redisClient.set(`copilot-stream-${streamId}`, payload, { - EX: 60 * 10, // expire in 10 minutes - }); + await redisClient.set(`copilot-stream-${streamId}`, payload, 'EX', 60 * 10); // expire in 10 minutes return { streamId, @@ -222,56 +101,29 @@ export async function getCopilotAgentInstructions( const mcpTools = await fetchProjectMcpTools(projectId); // Convert workflow to copilot format with both workflow and project tools - const copilotWorkflow = convertToCopilotWorkflow({ + const wflow = { ...current_workflow_config, - tools: await mergeProjectTools(current_workflow_config.tools, mcpTools) - }); + tools: mergeProjectTools(current_workflow_config.tools, mcpTools) + }; // prepare request const request: z.infer = { - projectId: projectId, - messages: messages.map(convertToCopilotApiMessage), - workflow_schema: JSON.stringify(zodToJsonSchema(CopilotWorkflow)), - current_workflow_config: JSON.stringify(copilotWorkflow), + projectId, + messages, + workflow: wflow, context: { type: 'agent', - agentName: agentName, + name: agentName, } }; - console.log(`sending copilot agent instructions request`, JSON.stringify(request)); // call copilot api - const response = await fetch(process.env.COPILOT_API_URL + '/edit_agent_instructions', { - method: 'POST', - body: JSON.stringify(request), - headers: { - 'Content-Type': 'application/json', - 'Authorization': `Bearer ${process.env.COPILOT_API_KEY || 'test'}`, - }, - }); - if (!response.ok) { - console.error('Failed to call copilot api', response); - throw new Error(`Failed to call copilot api: ${response.statusText}`); - } - - // parse and return response - const json = await response.json(); - - console.log(`received copilot agent instructions response`, JSON.stringify(json)); - let copilotResponse: z.infer; - let agent_instructions: string; - try { - copilotResponse = CopilotAPIResponse.parse(json); - const content = json.response.replace(/^```json\n/, '').replace(/\n```$/, ''); - agent_instructions = JSON.parse(content).agent_instructions; - - } catch (e) { - console.error('Failed to parse copilot response', e); - throw new Error(`Failed to parse copilot response: ${e}`); - } - if ('error' in copilotResponse) { - throw new Error(`Failed to call copilot api: ${copilotResponse.error}`); - } + const agent_instructions = await getEditAgentInstructionsResponse( + projectId, + request.context, + request.messages, + request.workflow, + ); // log the billing usage if (USE_BILLING) { diff --git a/apps/rowboat/app/actions/klavis_actions.ts b/apps/rowboat/app/actions/klavis_actions.ts index e910c3cc..5d611683 100644 --- a/apps/rowboat/app/actions/klavis_actions.ts +++ b/apps/rowboat/app/actions/klavis_actions.ts @@ -568,7 +568,7 @@ export async function enableServer( // set key in redis to indicate that a server is being enabled on this project // the key set should only succeed if the key does not already exist - const setResult = await redisClient.set(`klavis_enabling_server:${projectId}`, 'true', { EX: 60 * 60, NX: true }); + const setResult = await redisClient.set(`klavis_enabling_server:${projectId}`, 'true', 'EX', 60 * 60, 'NX'); console.log('[redis] Set result here:', setResult); if (setResult !== 'OK') { throw new Error("A server is already being enabled on this project"); diff --git a/apps/rowboat/app/actions/mcp_actions.ts b/apps/rowboat/app/actions/mcp_actions.ts index c8003124..20d7fe34 100644 --- a/apps/rowboat/app/actions/mcp_actions.ts +++ b/apps/rowboat/app/actions/mcp_actions.ts @@ -1,43 +1,11 @@ "use server"; import { z } from "zod"; import { WorkflowTool } from "../lib/types/workflow_types"; -import { Client } from "@modelcontextprotocol/sdk/client/index.js"; -import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"; -import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js"; import { projectAuthCheck } from "./project_actions"; import { projectsCollection, agentWorkflowsCollection } from "../lib/mongodb"; import { Project } from "../lib/types/project_types"; import { MCPServer, McpServerTool, convertMcpServerToolToWorkflowTool } from "../lib/types/types"; - -async function getMcpClient(serverUrl: string, serverName: string): Promise { - let client: Client | undefined = undefined; - const baseUrl = new URL(serverUrl); - - // Try to connect using Streamable HTTP transport - try { - client = new Client({ - name: 'streamable-http-client', - version: '1.0.0' - }); - const transport = new StreamableHTTPClientTransport( - new URL(baseUrl) - ); - await client.connect(transport); - console.log(`[MCP] Connected using Streamable HTTP transport to ${serverName}`); - return client; - } catch (error) { - // If that fails with a 4xx error, try the older SSE transport - console.log(`[MCP] Streamable HTTP connection failed, falling back to SSE transport for ${serverName}`); - client = new Client({ - name: 'sse-client', - version: '1.0.0' - }); - const sseTransport = new SSEClientTransport(baseUrl); - await client.connect(sseTransport); - console.log(`[MCP] Connected using SSE transport to ${serverName}`); - return client; - } -} +import { getMcpClient } from "../lib/mcp"; export async function fetchMcpTools(projectId: string): Promise[]> { await projectAuthCheck(projectId); diff --git a/apps/rowboat/app/api/copilot-stream-response/[streamId]/route.ts b/apps/rowboat/app/api/copilot-stream-response/[streamId]/route.ts index 99444480..1c1e6fba 100644 --- a/apps/rowboat/app/api/copilot-stream-response/[streamId]/route.ts +++ b/apps/rowboat/app/api/copilot-stream-response/[streamId]/route.ts @@ -2,6 +2,7 @@ import { getCustomerIdForProject, logUsage } from "@/app/lib/billing"; import { USE_BILLING } from "@/app/lib/feature_flags"; import { redisClient } from "@/app/lib/redis"; import { CopilotAPIRequest } from "@/app/lib/types/copilot_types"; +import { streamMultiAgentResponse } from "@/app/lib/copilot/copilot"; export async function GET(request: Request, props: { params: Promise<{ streamId: string }> }) { const params = await props.params; @@ -12,42 +13,37 @@ export async function GET(request: Request, props: { params: Promise<{ streamId: } // parse the payload - const parsedPayload = CopilotAPIRequest.parse(JSON.parse(payload)); + const { projectId, context, messages, workflow, dataSources } = CopilotAPIRequest.parse(JSON.parse(payload)); // fetch billing customer id let billingCustomerId: string | null = null; if (USE_BILLING) { - billingCustomerId = await getCustomerIdForProject(parsedPayload.projectId); + billingCustomerId = await getCustomerIdForProject(projectId); } - // Fetch the upstream SSE stream. - const upstreamResponse = await fetch(`${process.env.COPILOT_API_URL}/chat_stream`, { - method: 'POST', - body: payload, - headers: { - 'Content-Type': 'application/json', - 'Authorization': `Bearer ${process.env.COPILOT_API_KEY || 'test'}`, - }, - cache: 'no-store', - }); - - // If the upstream request fails, return a 502 Bad Gateway. - if (!upstreamResponse.ok || !upstreamResponse.body) { - return new Response("Error connecting to upstream SSE stream", { status: 502 }); - } - - const reader = upstreamResponse.body.getReader(); + const encoder = new TextEncoder(); + let messageCount = 0; const stream = new ReadableStream({ async start(controller) { try { - // Read from the upstream stream continuously. - while (true) { - const { done, value } = await reader.read(); - if (done) break; - // Immediately enqueue each received chunk. - controller.enqueue(value); + // Iterate over the copilot stream generator + for await (const event of streamMultiAgentResponse( + projectId, + context, + messages, + workflow, + dataSources || [], + )) { + // Check if this is a content event + if ('content' in event) { + messageCount++; + controller.enqueue(encoder.encode(`event: message\ndata: ${JSON.stringify(event)}\n\n`)); + } else { + controller.enqueue(encoder.encode(`event: done\ndata: ${JSON.stringify(event)}\n\n`)); + } } + controller.close(); // increment copilot request count in billing @@ -62,6 +58,7 @@ export async function GET(request: Request, props: { params: Promise<{ streamId: } } } catch (error) { + console.error('Error processing copilot stream:', error); controller.error(error); } }, diff --git a/apps/rowboat/app/api/stream-response/[streamId]/route.ts b/apps/rowboat/app/api/stream-response/[streamId]/route.ts index 2f5e7f6d..3e765e66 100644 --- a/apps/rowboat/app/api/stream-response/[streamId]/route.ts +++ b/apps/rowboat/app/api/stream-response/[streamId]/route.ts @@ -1,8 +1,16 @@ import { getCustomerIdForProject, logUsage } from "@/app/lib/billing"; import { USE_BILLING } from "@/app/lib/feature_flags"; import { redisClient } from "@/app/lib/redis"; -import { AgenticAPIChatMessage, AgenticAPIChatRequest, convertFromAgenticAPIChatMessages } from "@/app/lib/types/agents_api_types"; -import { createParser, type EventSourceMessage } from 'eventsource-parser'; +import { Workflow, WorkflowTool } from "@/app/lib/types/workflow_types"; +import { streamResponse } from "@/app/lib/agents"; +import { Message } from "@/app/lib/types/types"; +import { z } from "zod"; + +const PayloadSchema = z.object({ + workflow: Workflow, + projectTools: z.array(WorkflowTool), + messages: z.array(Message), +}); export async function GET(request: Request, props: { params: Promise<{ streamId: string }> }) { const params = await props.params; @@ -13,85 +21,42 @@ export async function GET(request: Request, props: { params: Promise<{ streamId: } // parse the payload - const parsedPayload = AgenticAPIChatRequest.parse(JSON.parse(payload)); + const { workflow, projectTools, messages } = PayloadSchema.parse(JSON.parse(payload)); + console.log('payload', payload); // fetch billing customer id let billingCustomerId: string | null = null; if (USE_BILLING) { - billingCustomerId = await getCustomerIdForProject(parsedPayload.projectId); + billingCustomerId = await getCustomerIdForProject(workflow.projectId); } - // Fetch the upstream SSE stream. - const upstreamResponse = await fetch(`${process.env.AGENTS_API_URL}/chat_stream`, { - method: 'POST', - body: payload, - headers: { - 'Content-Type': 'application/json', - 'Authorization': `Bearer ${process.env.AGENTS_API_KEY || 'test'}`, - }, - cache: 'no-store', - }); - - // If the upstream request fails, return a 502 Bad Gateway. - if (!upstreamResponse.ok || !upstreamResponse.body) { - return new Response("Error connecting to upstream SSE stream", { status: 502 }); - } - - const reader = upstreamResponse.body.getReader(); const encoder = new TextEncoder(); + let messageCount = 0; const stream = new ReadableStream({ async start(controller) { - let messageCount = 0; - - function emitEvent(event: EventSourceMessage) { - // Re-emit the event in SSE format - let eventString = ''; - if (event.id) eventString += `id: ${event.id}\n`; - if (event.event) eventString += `event: ${event.event}\n`; - if (event.data) eventString += `data: ${event.data}\n`; - eventString += '\n'; - - controller.enqueue(encoder.encode(eventString)); - } - - const parser = createParser({ - onEvent(event: EventSourceMessage) { - if (event.event !== 'message') { - emitEvent(event); - return; - } - - // Parse message - const data = JSON.parse(event.data); - const msg = AgenticAPIChatMessage.parse(data); - const parsedMsg = convertFromAgenticAPIChatMessages([msg])[0]; - - // increment the message count if this is an assistant message - if (parsedMsg.role === 'assistant') { - messageCount++; - } - - // emit the event - emitEvent(event); - } - }); - try { - while (true) { - const { done, value } = await reader.read(); - if (done) break; - - // Feed the chunk to the parser - parser.feed(new TextDecoder().decode(value)); + // Iterate over the generator + for await (const event of streamResponse(workflow, projectTools, messages)) { + // Check if this is a message event (has role property) + if ('role' in event) { + if (event.role === 'assistant') { + messageCount++; + } + controller.enqueue(encoder.encode(`event: message\ndata: ${JSON.stringify(event)}\n\n`)); + } else { + controller.enqueue(encoder.encode(`event: done\ndata: ${JSON.stringify(event)}\n\n`)); + } } + controller.close(); + // Log billing usage if (USE_BILLING && billingCustomerId) { await logUsage(billingCustomerId, { type: "agent_messages", amount: messageCount, - }) + }); } } catch (error) { console.error('Error processing stream:', error); diff --git a/apps/rowboat/app/api/v1/[projectId]/chat/route.ts b/apps/rowboat/app/api/v1/[projectId]/chat/route.ts index 2b1c3029..d1b871bb 100644 --- a/apps/rowboat/app/api/v1/[projectId]/chat/route.ts +++ b/apps/rowboat/app/api/v1/[projectId]/chat/route.ts @@ -4,14 +4,13 @@ import { z } from "zod"; import { ObjectId } from "mongodb"; import { authCheck } from "../../utils"; import { ApiRequest, ApiResponse } from "../../../../lib/types/types"; -import { AgenticAPIChatRequest, convertFromAgenticApiToApiMessages, convertFromApiToAgenticApiMessages, convertWorkflowToAgenticAPI } from "../../../../lib/types/agents_api_types"; -import { getAgenticApiResponse } from "../../../../lib/utils"; import { check_query_limit } from "../../../../lib/rate_limiting"; import { PrefixLogger } from "../../../../lib/utils"; import { TestProfile } from "@/app/lib/types/testing_types"; import { fetchProjectMcpTools } from "@/app/lib/project_tools"; import { authorize, getCustomerIdForProject, logUsage } from "@/app/lib/billing"; import { USE_BILLING } from "@/app/lib/feature_flags"; +import { getResponse } from "@/app/lib/agents"; // get next turn / agent response export async function POST( @@ -52,7 +51,6 @@ export async function POST( return Response.json({ error: `Invalid request body: ${result.error.message}` }, { status: 400 }); } const reqMessages = result.data.messages; - const reqState = result.data.state; // fetch published workflow id const project = await projectsCollection.findOne({ @@ -112,34 +110,12 @@ export async function POST( } } - let currentState: unknown = reqState ?? { last_agent_name: workflow.agents[0].name }; - // get assistant response - const { agents, tools, prompts, startAgent } = convertWorkflowToAgenticAPI(workflow, projectTools); - const request: z.infer = { - projectId, - messages: convertFromApiToAgenticApiMessages(reqMessages), - state: currentState, - agents, - tools, - prompts, - startAgent, - testProfile: testProfile ?? undefined, - mcpServers: (project.mcpServers ?? []).map(server => ({ - name: server.name, - serverUrl: server.serverUrl ?? '', - isReady: server.isReady ?? false - })), - toolWebhookUrl: project.webhookUrl ?? '', - }; - - const { messages: agenticMessages, state } = await getAgenticApiResponse(request); - const newMessages = convertFromAgenticApiToApiMessages(agenticMessages); - const newState = state; + const { messages } = await getResponse(workflow, projectTools, reqMessages); // log billing usage if (USE_BILLING && billingCustomerId) { - const agentMessageCount = newMessages.filter(m => m.role === 'assistant').length; + const agentMessageCount = messages.filter(m => m.role === 'assistant').length; await logUsage(billingCustomerId, { type: 'agent_messages', amount: agentMessageCount, @@ -147,8 +123,7 @@ export async function POST( } const responseBody: z.infer = { - messages: newMessages, - state: newState, + messages, }; return Response.json(responseBody); }); diff --git a/apps/rowboat/app/api/widget/v1/chats/[chatId]/turn/route.ts b/apps/rowboat/app/api/widget/v1/chats/[chatId]/turn/route.ts index 620a9e07..47bb0acb 100644 --- a/apps/rowboat/app/api/widget/v1/chats/[chatId]/turn/route.ts +++ b/apps/rowboat/app/api/widget/v1/chats/[chatId]/turn/route.ts @@ -4,16 +4,108 @@ import { agentWorkflowsCollection, projectsCollection, chatsCollection, chatMess import { z } from "zod"; import { ObjectId, WithId } from "mongodb"; import { authCheck } from "../../../utils"; -import { convertFromAgenticAPIChatMessages } from "../../../../../../lib/types/agents_api_types"; -import { convertToAgenticAPIChatMessages } from "../../../../../../lib/types/agents_api_types"; -import { convertWorkflowToAgenticAPI } from "../../../../../../lib/types/agents_api_types"; -import { AgenticAPIChatRequest } from "../../../../../../lib/types/agents_api_types"; -import { getAgenticApiResponse } from "../../../../../../lib/utils"; import { check_query_limit } from "../../../../../../lib/rate_limiting"; import { PrefixLogger } from "../../../../../../lib/utils"; import { fetchProjectMcpTools } from "@/app/lib/project_tools"; import { authorize, getCustomerIdForProject, logUsage } from "@/app/lib/billing"; import { USE_BILLING } from "@/app/lib/feature_flags"; +import { getResponse } from "@/app/lib/agents"; +import { Message, AssistantMessage, AssistantMessageWithToolCalls, ToolMessage } from "@/app/lib/types/types"; + +function convert(messages: z.infer[]): z.infer[] { + const result: z.infer[] = []; + for (const m of messages) { + if (m.role === 'assistant') { + if ('tool_calls' in m) { + result.push({ + role: 'assistant', + content: null, + agentName: m.agenticSender ?? '', + toolCalls: m.tool_calls.map((t: any) => ({ + function: { + name: t.function.name, + arguments: t.function.arguments, + }, + type: 'function', + id: t.id, + })), + }); + } else { + result.push({ + role: 'assistant', + content: m.content, + agentName: m.agenticSender ?? '', + responseType: m.agenticResponseType, + }); + } + } else if (m.role === 'tool') { + result.push({ + role: 'tool', + content: m.content, + toolCallId: m.tool_call_id, + toolName: m.tool_name, + }); + } else if (m.role === 'system') { + result.push({ + role: 'system', + content: m.content, + }); + } else if (m.role === 'user') { + result.push({ + role: 'user', + content: m.content, + }); + } + } + return result; +} + +function convertBack(messages: z.infer[]): z.infer[] { + const result: z.infer[] = []; + for (const m of messages) { + if (m.role === 'assistant') { + if ('toolCalls' in m) { + result.push({ + version: 'v1', + chatId: '', + createdAt: new Date().toISOString(), + role: 'assistant', + agenticSender: m.agentName, + agenticResponseType: 'external', + tool_calls: m.toolCalls.map((t: any) => ({ + function: { + name: t.function.name, + arguments: t.function.arguments, + }, + type: 'function', + id: t.id, + })), + }); + } else { + result.push({ + version: 'v1', + chatId: '', + createdAt: new Date().toISOString(), + role: 'assistant', + content: m.content, + agenticSender: m.agentName, + agenticResponseType: m.responseType, + }); + } + } else if (m.role === 'tool') { + result.push({ + version: 'v1', + chatId: '', + createdAt: new Date().toISOString(), + role: 'tool', + content: m.content, + tool_call_id: m.toolCallId, + tool_name: m.toolName, + }); + } + } + return result; +} // get next turn / agent response export async function POST( @@ -119,47 +211,23 @@ export async function POST( } // get assistant response - const { agents, tools, prompts, startAgent } = convertWorkflowToAgenticAPI(workflow, projectTools); - const unsavedMessages: z.infer[] = [userMessage]; - let state: unknown = chat.agenticState ?? { last_agent_name: startAgent }; + const inMessages: z.infer[] = convert(messages); + inMessages.push(userMessage); - const request: z.infer = { - projectId: session.projectId, - messages: convertToAgenticAPIChatMessages([systemMessage, ...messages, ...unsavedMessages]), - state, - agents, - tools, - prompts, - startAgent, - mcpServers: (projectSettings.mcpServers ?? []).map(server => ({ - name: server.name, - serverUrl: server.serverUrl || '', - isReady: server.isReady - })), - toolWebhookUrl: projectSettings.webhookUrl ?? '', - testProfile: undefined, - }; - logger.log(`Sending agentic request`); - const response = await getAgenticApiResponse(request); - state = response.state; - if (response.messages.length === 0) { - throw new Error("No messages returned from assistant"); - } - const convertedMessages = convertFromAgenticAPIChatMessages(response.messages); - unsavedMessages.push(...convertedMessages.map(m => ({ - ...m, - version: 'v1' as const, - chatId, - createdAt: new Date().toISOString(), - }))); + const { messages: responseMessages } = await getResponse(workflow, projectTools, [systemMessage, ...inMessages]); + const convertedResponseMessages = convertBack(responseMessages); + const unsavedMessages = [ + userMessage, + ...convertedResponseMessages, + ]; logger.log(`Saving ${unsavedMessages.length} new messages and updating chat state`); await chatMessagesCollection.insertMany(unsavedMessages); - await chatsCollection.updateOne({ _id: new ObjectId(chatId) }, { $set: { agenticState: state } }); + await chatsCollection.updateOne({ _id: new ObjectId(chatId) }, { $set: { agenticState: chat.agenticState } }); // log billing usage if (USE_BILLING && billingCustomerId) { - const agentMessageCount = convertedMessages.filter(m => m.role === 'assistant').length; + const agentMessageCount = convertedResponseMessages.filter(m => m.role === 'assistant').length; await logUsage(billingCustomerId, { type: 'agent_messages', amount: agentMessageCount, diff --git a/apps/rowboat/app/lib/agent_instructions.ts b/apps/rowboat/app/lib/agent_instructions.ts new file mode 100644 index 00000000..e2d4b3f3 --- /dev/null +++ b/apps/rowboat/app/lib/agent_instructions.ts @@ -0,0 +1,109 @@ +/** + * Instructions for agents that use RAG (Retrieval Augmented Generation) + */ +export const RAG_INSTRUCTIONS = (ragToolName: string): string => ` +# Instructions about using the article retrieval tool +- Where relevant, use the articles tool: ${ragToolName} to fetch articles with knowledge relevant to the query and use its contents to respond to the user. +- Do not send a separate message first asking the user to wait while you look up information. Immediately fetch the articles and respond to the user with the answer to their query. +- Do not make up information. If the article's contents do not have the answer, give up control of the chat (or transfer to your parent agent, as per your transfer instructions). Do not say anything to the user. +`; + +/** + * Instructions for child agents that are aware of parent agents + * These instructions guide agents that can transfer control to parent agents + */ +export const TRANSFER_PARENT_AWARE_INSTRUCTIONS = (candidateParentsNameDescriptionTools: string): string => ` +# Instructions about using your parent agents +You have the following candidate parent agents that you can transfer the chat to, using the appropriate tool calls for the transfer: +${candidateParentsNameDescriptionTools}. + +## Notes: +- During runtime, you will be provided with a tool call for exactly one of these parent agents that you can use. Use that tool call to transfer the chat to the parent agent in case you are unable to handle the chat (e.g. if it is not in your scope of instructions). +- Transfer the chat to the appropriate agent, based on the chat history and / or the user's request. +- When you transfer the chat to another agent, you should not provide any response to the user. For example, do not say 'Transferring chat to X agent' or anything like that. Just invoke the tool call to transfer to the other agent. +- Do NOT ever mention the existence of other agents. For example, do not say 'Please check with X agent for details regarding processing times.' or anything like that. +- If any other agent transfers the chat to you without responding to the user, it means that they don't know how to help. Do not transfer the chat to back to the same agent in this case. In such cases, you should transfer to the escalation agent using the appropriate tool call. Never ask the user to contact support. +`; + +/** + * Instructions for child agents that give up control to parent agents + * These instructions guide agents that need to relinquish control to parent agents + */ +export const TRANSFER_GIVE_UP_CONTROL_INSTRUCTIONS = (candidateParentsNameDescriptionTools: string): string => ` +# Instructions about giving up chat control +If you are unable to handle the chat (e.g. if it is not in your scope of instructions), you should use the tool call provided to give up control of the chat. +${candidateParentsNameDescriptionTools} + +## Notes: +- When you give up control of the chat, you should not provide any response to the user. Just invoke the tool call to give up control. +`; + +/** + * Instructions for parent agents that need to transfer the chat to other specialized (children) agents + * These instructions guide parent agents in delegating tasks to specialized child agents + */ +export const TRANSFER_CHILDREN_INSTRUCTIONS = (otherAgentNameDescriptionsTools: string): string => ` +# Instructions about using other specialized agents +You have the following specialized agents that you can transfer the chat to, using the appropriate tool calls for the transfer: +${otherAgentNameDescriptionsTools} + +## Notes: +- Transfer the chat to the appropriate agent, based on the chat history and / or the user's request. +- When you transfer the chat to another agent, you should not provide any response to the user. For example, do not say 'Transferring chat to X agent' or anything like that. Just invoke the tool call to transfer to the other agent. +- Do NOT ever mention the existence of other agents. For example, do not say 'Please check with X agent for details regarding processing times.' or anything like that. +- If any other agent transfers the chat to you without responding to the user, it means that they don't know how to help. Do not transfer the chat to back to the same agent in this case. In such cases, you should transfer to the escalation agent using the appropriate tool call. Never ask the user to contact support. +`; + +/** + * Additional instruction for escalation agent when called due to an error + * These instructions are used when other agents are unable to handle the chat + */ +export const ERROR_ESCALATION_AGENT_INSTRUCTIONS = ` +# Context +The rest of the parts of the chatbot were unable to handle the chat. Hence, the chat has been escalated to you. In addition to your other instructions, tell the user that you are having trouble handling the chat - say "I'm having trouble helping with your request. Sorry about that.". Remember you are a part of the chatbot as well. +`; + +/** + * Universal system message formatting + * Template for system-wide context and instructions + */ +export const SYSTEM_MESSAGE = (systemMessage: string): string => ` +# Additional System-Wide Context or Instructions: +${systemMessage} +`; + +/** + * Instructions for non-repeat child transfer + * Critical rules for handling agent transfers and handoffs to prevent circular transfers + */ +export const CHILD_TRANSFER_RELATED_INSTRUCTIONS = ` +# Critical Rules for Agent Transfers and Handoffs + +- SEQUENTIAL TRANSFERS AND RESPONSES: + 1. BEFORE transferring to any agent: + - Plan your complete sequence of needed transfers + - Document which responses you need to collect + + 2. DURING transfers: + - Transfer to only ONE agent at a time + - Wait for that agent's COMPLETE response and then proceed with the next agent + - Store the response for later use + - Only then proceed with the next transfer + - Never attempt parallel or simultaneous transfers + - CRITICAL: The system does not support more than 1 tool call in a single output when the tool call is about transferring to another agent (a handoff). You must only put out 1 transfer related tool call in one output. + + 3. AFTER receiving a response: + - Do not transfer to another agent until you've processed the current response + - If you need to transfer to another agent, wait for your current processing to complete + - Never transfer back to an agent that has already responded + +- COMPLETION REQUIREMENTS: + - Never provide final response until ALL required agents have been consulted + - Never attempt to get multiple responses in parallel + - If a transfer is rejected due to multiple handoffs: + 1. Complete current response processing + 2. Then retry the transfer as next in sequence + 3. Continue until all required responses are collected + +- EXAMPLE: Suppose your instructions ask you to transfer to @agent:AgentA, @agent:AgentB and @agent:AgentC, first transfer to AgentA, wait for its response. Then transfer to AgentB, wait for its response. Then transfer to AgentC, wait for its response. Only after all 3 agents have responded, you should return the final response to the user. +`; \ No newline at end of file diff --git a/apps/rowboat/app/lib/agents.ts b/apps/rowboat/app/lib/agents.ts new file mode 100644 index 00000000..24b1621b --- /dev/null +++ b/apps/rowboat/app/lib/agents.ts @@ -0,0 +1,909 @@ +// External dependencies +import { Agent, AgentInputItem, run, tool, Tool } from "@openai/agents"; +import { RECOMMENDED_PROMPT_PREFIX } from "@openai/agents-core/extensions"; +import { aisdk } from "@openai/agents-extensions"; +import { createOpenAI } from "@ai-sdk/openai"; +import { CoreMessage, embed, generateText } from "ai"; +import { ObjectId } from "mongodb"; +import { z } from "zod"; + +// Internal dependencies +import { embeddingModel } from '../lib/embedding'; +import { getMcpClient } from "./mcp"; +import { dataSourceDocsCollection, dataSourcesCollection } from "./mongodb"; +import { qdrantClient } from '../lib/qdrant'; +import { EmbeddingRecord } from "./types/datasource_types"; +import { ConnectedEntity, sanitizeTextWithMentions, Workflow, WorkflowAgent, WorkflowPrompt, WorkflowTool } from "./types/workflow_types"; +import { CHILD_TRANSFER_RELATED_INSTRUCTIONS, RAG_INSTRUCTIONS } from "./agent_instructions"; +import { PrefixLogger } from "./utils"; +import { Message, AssistantMessage, AssistantMessageWithToolCalls, ToolMessage } from "./types/types"; + +const PROVIDER_API_KEY = process.env.PROVIDER_API_KEY || process.env.OPENAI_API_KEY || ''; +const PROVIDER_BASE_URL = process.env.PROVIDER_BASE_URL || undefined; +const MODEL = process.env.PROVIDER_DEFAULT_MODEL || 'gpt-4o'; + +const openai = createOpenAI({ + apiKey: PROVIDER_API_KEY, + baseURL: PROVIDER_BASE_URL, +}); + +export const ZUsage = z.object({ + tokens: z.object({ + total: z.number(), + prompt: z.number(), + completion: z.number(), + }), +}); + +const ZOutMessage = z.union([ + AssistantMessage, + AssistantMessageWithToolCalls, + ToolMessage, +]); + +// Helper to handle mock tool responses +async function invokeMockTool( + logger: PrefixLogger, + toolName: string, + args: string, + description: string, + mockInstructions: string +): Promise { + logger = logger.child(`invokeMockTool`); + logger.log(`toolName: ${toolName}`); + logger.log(`args: ${args}`); + logger.log(`description: ${description}`); + logger.log(`mockInstructions: ${mockInstructions}`); + + const messages: CoreMessage[] = [{ + role: "system" as const, + content: `You are simulating the execution of a tool called '${toolName}'. Here is the description of the tool: ${description}. Here are the instructions for the mock tool: ${mockInstructions}. Generate a realistic response as if the tool was actually executed with the given parameters.` + }, { + role: "user" as const, + content: `Generate a realistic response for the tool '${toolName}' with these parameters: ${args}. The response should be concise and focused on what the tool would actually return.` + }]; + + const { text } = await generateText({ + model: openai(MODEL), + messages, + }); + logger.log(`generated text: ${text}`); + + return text; +} + +// Helper to handle RAG tool calls +async function invokeRagTool( + logger: PrefixLogger, + projectId: string, + query: string, + sourceIds: string[], + returnType: 'chunks' | 'content', + k: number +): Promise<{ + title: string; + name: string; + content: string; + docId: string; + sourceId: string; +}[]> { + logger = logger.child(`invokeRagTool`); + logger.log(`projectId: ${projectId}`); + logger.log(`query: ${query}`); + logger.log(`sourceIds: ${sourceIds.join(', ')}`); + logger.log(`returnType: ${returnType}`); + logger.log(`k: ${k}`); + + // Create embedding for question + const { embedding } = await embed({ + model: embeddingModel, + value: query, + }); + + // Fetch all data sources for this project + const sources = await dataSourcesCollection.find({ + projectId: projectId, + active: true, + }).toArray(); + const validSourceIds = sources + .filter(s => sourceIds.includes(s._id.toString())) // id should be in sourceIds + .filter(s => s.active) // should be active + .map(s => s._id.toString()); + logger.log(`valid source ids: ${validSourceIds.join(', ')}`); + + // if no sources found, return empty response + if (validSourceIds.length === 0) { + logger.log(`no valid source ids found, returning empty response`); + return []; + } + + // Perform vector search + const qdrantResults = await qdrantClient.query("embeddings", { + query: embedding, + filter: { + must: [ + { key: "projectId", match: { value: projectId } }, + { key: "sourceId", match: { any: validSourceIds } }, + ], + }, + limit: k, + with_payload: true, + }); + logger.log(`found ${qdrantResults.points.length} results`); + + // if return type is chunks, return the chunks + let results = qdrantResults.points.map((point) => { + const { title, name, content, docId, sourceId } = point.payload as z.infer['payload']; + return { + title, + name, + content, + docId, + sourceId, + }; + }); + + if (returnType === 'chunks') { + logger.log(`returning chunks`); + return results; + } + + // otherwise, fetch the doc contents from mongodb + const docs = await dataSourceDocsCollection.find({ + _id: { $in: results.map(r => new ObjectId(r.docId)) }, + }).toArray(); + logger.log(`fetched docs: ${docs.length}`); + + // map the results to the docs + results = results.map(r => { + const doc = docs.find(d => d._id.toString() === r.docId); + return { + ...r, + content: doc?.content || '', + }; + }); + + return results; +} + +// Helper to handle MCP tool calls +async function invokeMcpTool( + logger: PrefixLogger, + projectId: string, + name: string, + input: any, + mcpServerURL: string, + mcpServerName: string +) { + logger = logger.child(`invokeMcpTool`); + logger.log(`projectId: ${projectId}`); + logger.log(`name: ${name}`); + logger.log(`input: ${JSON.stringify(input)}`); + logger.log(`mcpServerURL: ${mcpServerURL}`); + logger.log(`mcpServerName: ${mcpServerName}`); + + const client = await getMcpClient(mcpServerURL, mcpServerName || ''); + const result = await client.callTool({ + name, + arguments: input, + }); + logger.log(`mcp tool result: ${JSON.stringify(result)}`); + await client.close(); + return result; +} + +// Helper to create RAG tool +function createRagTool( + logger: PrefixLogger, + config: z.infer, + projectId: string +): Tool { + if (!config.ragDataSources?.length) { + throw new Error(`data sources not found for agent ${config.name}`); + } + + return tool({ + name: "rag_search", + description: config.description, + parameters: z.object({ + query: z.string().describe("The query to search for") + }), + async execute(input: { query: string }) { + const results = await invokeRagTool( + logger, + projectId, + input.query, + config.ragDataSources || [], + config.ragReturnType || 'chunks', + config.ragK || 3 + ); + return JSON.stringify({ + results, + }); + } + }); +} + +// Helper to create a mock tool +function createMockTool( + logger: PrefixLogger, + config: z.infer, +): Tool { + return tool({ + name: config.name, + description: config.description, + parameters: z.object({ + query: z.string().describe("The query to search for") + }), + async execute(input: { query: string }) { + try { + const result = await invokeMockTool( + logger, + config.name, + JSON.stringify(input), + config.description, + config.mockInstructions || '' + ); + return JSON.stringify({ + result, + }); + } catch (error) { + logger.log(`Error executing mock tool ${config.name}:`, error); + return JSON.stringify({ + error: `Mock tool execution failed: ${error}`, + }); + } + } + }); +} + +// Helper to create an mcp tool +function createMcpTool( + logger: PrefixLogger, + config: z.infer, + projectId: string +): Tool { + const { name, description, parameters, mcpServerName, mcpServerURL } = config; + + return tool({ + name, + description, + strict: false, + parameters: { + type: 'object', + properties: parameters.properties, + required: parameters.required || [], + additionalProperties: true, + }, + async execute(input: any) { + try { + const result = await invokeMcpTool(logger, projectId, name, input, mcpServerURL || '', mcpServerName || ''); + return JSON.stringify({ + result, + }); + } catch (error) { + logger.log(`Error executing mcp tool ${name}:`, error); + return JSON.stringify({ + error: `Tool execution failed: ${error}`, + }); + } + } + }); +} + +// Helper to create an agent +function createAgent( + logger: PrefixLogger, + config: z.infer, + tools: Record, + projectTools: z.infer[], + workflow: z.infer, + promptConfig: Record>, +): { agent: Agent, entities: z.infer[] } { + const agentLogger = logger.child(`createAgent: ${config.name}`); + + // Combine instructions and examples + let instructions = `${RECOMMENDED_PROMPT_PREFIX} + +## Your Name +${config.name} + +## Description +${config.description} + +## Instructions +${config.instructions} + +${config.examples ? ('# Examples\n' + config.examples) : ''} + +${'-'.repeat(100)} + +${CHILD_TRANSFER_RELATED_INSTRUCTIONS} +`; + + let { sanitized, entities } = sanitizeTextWithMentions(instructions, workflow, projectTools); + agentLogger.log(`instructions: ${JSON.stringify(sanitized)}`); + agentLogger.log(`mentions: ${JSON.stringify(entities)}`); + + // // add prompts to instructions + // for (const e of entities) { + // if (e.type === 'prompt') { + // const prompt = promptConfig[e.name]; + // if (prompt) { + // compiledInstructions = compiledInstructions + '\n\n# ' + prompt.name + '\n' + prompt.prompt; + // } + // } + // } + + const agentTools = entities.filter(e => e.type === 'tool').map(e => tools[e.name]).filter(Boolean) as Tool[]; + + // Add RAG tool if needed + if (config.ragDataSources?.length) { + const ragTool = createRagTool(logger, config, workflow.projectId); + agentTools.push(ragTool); + + // update instructions to include RAG instructions + sanitized = sanitized + '\n\n' + ('-'.repeat(100)) + '\n\n' + RAG_INSTRUCTIONS(ragTool.name); + agentLogger.log(`added rag instructions`); + } + + // Create the agent + const agent = new Agent({ + name: config.name, + instructions: sanitized, + tools: agentTools, + model: aisdk(openai(config.model)), + // model: config.model, + modelSettings: { + temperature: 0.0, + } + }); + agentLogger.log(`created agent`); + + return { + agent, + entities, + }; +} + +// Convert messages to agent input items +function convertMsgsInput(messages: z.infer[]): AgentInputItem[] { + const msgs: AgentInputItem[] = []; + + for (const msg of messages) { + if (msg.role === 'assistant' && msg.content) { + msgs.push({ + role: 'assistant', + content: [{ + type: 'output_text', + text: `Sender agent: ${msg.agentName}\nContent: ${msg.content}`, + }], + status: 'completed', + }); + } else if (msg.role === 'user') { + msgs.push({ + role: 'user', + content: msg.content, + }); + } else if (msg.role === 'system') { + msgs.push({ + role: 'system', + content: msg.content, + }); + } + } + + return msgs; +} + +// Helper to determine the next agent name based on control settings +function getNextAgentName( + logger: PrefixLogger, + stack: string[], + agentConfig: Record>, + workflow: z.infer, +): string { + logger = logger.child(`getNextAgentName`); + logger.log(`stack: ${stack.join(', ')}`); + + // get the last agent from the stack + // if stack is empty, use the start agent + const lastAgentName = stack.pop() || workflow.startAgent; + + return lastAgentName; + + // TODO: control-type logic is being ignored for now + // if control type is retain, return last agent + // const lastAgentName = stack.pop() || workflow.startAgent; + // const lastAgentConfig = agentConfig[lastAgentName]; + // if (!lastAgentConfig) { + // logger.log(`last agent ${lastAgentName} not found in agent config, returning start agent: ${workflow.startAgent}`); + // return workflow.startAgent; + // } + // switch (lastAgentConfig.controlType) { + // case 'retain': + // logger.log(`last agent ${lastAgentName} control type is retain, returning last agent: ${lastAgentName}`); + // return lastAgentName; + // case 'relinquish_to_parent': + // const parentAgentName = stack.pop() || workflow.startAgent; + // logger.log(`last agent ${lastAgentName} control type is relinquish_to_parent, returning most recent parent: ${parentAgentName}`); + // return parentAgentName; + // case 'relinquish_to_start': + // logger.log(`last agent ${lastAgentName} control type is relinquish_to_start, returning start agent: ${workflow.startAgent}`); + // return workflow.startAgent; + // } +} + +// Logs an event and then yields it +async function* emitEvent( + logger: PrefixLogger, + event: z.infer | z.infer, +): AsyncIterable | z.infer> { + logger.log(`-> emitting event: ${JSON.stringify(event)}`); + yield event; + return; +} + +// Emits an agent -> agent transfer event +function createTransferEvents( + fromAgent: string, + toAgent: string, +): [z.infer, z.infer] { + const toolCallId = crypto.randomUUID(); + const m1: z.infer = { + role: 'assistant', + content: null, + toolCalls: [{ + id: toolCallId, + type: 'function', + function: { + name: 'transfer_to_agent', + arguments: JSON.stringify({ assistant: toAgent }), + }, + }], + agentName: fromAgent, + }; + + const m2: z.infer = { + role: 'tool', + content: JSON.stringify({ assistant: toAgent }), + toolCallId: toolCallId, + toolName: 'transfer_to_agent', + }; + + return [m1, m2]; +} + +// Tracks agent to agent transfer counts +class AgentTransferCounter { + private calls: Record = {}; + + increment(fromAgent: string, toAgent: string): void { + const key = `${fromAgent}:${toAgent}`; + this.calls[key] = (this.calls[key] || 0) + 1; + } + + get(fromAgent: string, toAgent: string): number { + const key = `${fromAgent}:${toAgent}`; + return this.calls[key] || 0; + } +} + +class UsageTracker { + private usage: { + total: number; + prompt: number; + completion: number; + } = { total: 0, prompt: 0, completion: 0 }; + + increment(total: number, prompt: number, completion: number): void { + this.usage.total += total; + this.usage.prompt += prompt; + this.usage.completion += completion; + } + + get(): { total: number, prompt: number, completion: number } { + return this.usage; + } + + asEvent(): z.infer { + return { + tokens: this.usage, + }; + } +} + +function ensureSystemMessage(logger: PrefixLogger, messages: z.infer[]) { + logger = logger.child(`ensureSystemMessage`); + + // ensure that a system message is set + if (messages.length > 0 && messages[0]?.role !== 'system') { + messages.unshift({ + role: 'system', + content: 'You are a helpful assistant.', + }); + logger.log(`added system message: ${messages[0]?.content}`); + } + + // ensure that system message isn't blank + if (messages.length > 0 && messages[0]?.role === 'system' && !messages[0].content) { + messages[0].content = 'You are a helpful assistant.'; + logger.log(`updated system message: ${messages[0].content}`); + } +} + +function mapConfig(workflow: z.infer, projectTools: z.infer[]): { + agentConfig: Record>; + toolConfig: Record>; + promptConfig: Record>; +} { + const agentConfig: Record> = workflow.agents.reduce((acc, agent) => ({ + ...acc, + [agent.name]: agent + }), {}); + const toolConfig: Record> = [ + ...workflow.tools, + ...projectTools, + ].reduce((acc, tool) => ({ + ...acc, + [tool.name]: tool + }), {}); + const promptConfig: Record> = workflow.prompts.reduce((acc, prompt) => ({ + ...acc, + [prompt.name]: prompt + }), {}); + return { agentConfig, toolConfig, promptConfig }; +} + +async function* emitGreetingTurn(logger: PrefixLogger, workflow: z.infer): AsyncIterable | z.infer> { + // find the greeting prompt + const prompt = workflow.prompts.find(p => p.type === 'greeting')?.prompt || 'How can I help you today?'; + logger.log(`greeting turn: ${prompt}`); + + // emit greeting turn + yield* emitEvent(logger, { + role: 'assistant', + content: prompt, + agentName: workflow.startAgent, + responseType: 'external', + }); + + // emit final usage information + yield* emitEvent(logger, new UsageTracker().asEvent()); +} + +function createAgentCallStack(messages: z.infer[]): string[] { + const stack: string[] = []; + for (const msg of messages) { + if (msg.role === 'assistant' && msg.agentName) { + // skip duplicate entries + if (stack.length > 0 && stack[stack.length - 1] === msg.agentName) { + continue; + } + // add to stack + stack.push(msg.agentName); + } + } + return stack; +} + +function createTools(logger: PrefixLogger, workflow: z.infer, toolConfig: Record>): Record { + const tools: Record = {}; + for (const [toolName, config] of Object.entries(toolConfig)) { + if (config.isMcp) { + tools[toolName] = createMcpTool(logger, config, workflow.projectId); + logger.log(`created mcp tool: ${toolName}`); + } else if (config.mockTool) { + tools[toolName] = createMockTool(logger, config); + logger.log(`created mock tool: ${toolName}`); + } else { + logger.log(`unsupported tool type: ${toolName}`); + } + } + return tools; +} + +function createAgents( + logger: PrefixLogger, + workflow: z.infer, + agentConfig: Record>, + tools: Record, + projectTools: z.infer[], + promptConfig: Record>, +): { agents: Record, mentions: Record[]> } { + const agents: Record = {}; + const mentions: Record[]> = {}; + + // create agents + for (const [agentName, config] of Object.entries(agentConfig)) { + const { agent, entities } = createAgent( + logger, + config, + tools, + projectTools, + workflow, + promptConfig, + ); + agents[agentName] = agent; + mentions[agentName] = entities; + logger.log(`created agent: ${agentName}`); + } + + // set handoffs + for (const [agentName, agent] of Object.entries(agents)) { + const connectedAgentNames = (mentions[agentName] || []).filter(e => e.type === 'agent').map(e => e.name); + agent.handoffs = connectedAgentNames.map(e => agents[e]).filter(Boolean) as Agent[]; + logger.log(`set handoffs for ${agentName}: ${connectedAgentNames.join(',')}`); + } + + return { agents, mentions }; +} + +// Main function to stream an agentic response +// using OpenAI Agents SDK +export async function* streamResponse( + workflow: z.infer, + projectTools: z.infer[], + messages: z.infer[], +): AsyncIterable | z.infer> { + // set up logging + let logger = new PrefixLogger(`agent-loop`) + logger.log('projectId', workflow.projectId); + logger.log('workflow', workflow.name); + + // ensure valid system message + ensureSystemMessage(logger, messages); + + // if there is only a system message, emit greeting turn and return + if (messages.length === 1 && messages[0]?.role === 'system') { + yield* emitGreetingTurn(logger, workflow); + return; + } + + // create map of agent, tool and prompt configs + const { agentConfig, toolConfig, promptConfig } = mapConfig(workflow, projectTools); + + // create agent call stack from input messages + const stack = createAgentCallStack(messages); + + // create tools + const tools = createTools(logger, workflow, toolConfig); + + // create agents + const { agents } = createAgents(logger, workflow, agentConfig, tools, projectTools, promptConfig); + + // track agent to agent calls + const transferCounter = new AgentTransferCounter(); + + // track usage + const usageTracker = new UsageTracker(); + + // get next agent name + let agentName = getNextAgentName(logger, stack, agentConfig, workflow); + + // set up initial state for loop + logger.log('@@ starting agent turn @@'); + let iter = 0; + const turnMsgs: z.infer[] = [...messages]; + + // loop indefinitely + turnLoop: while (true) { + // increment loop counter + iter++; + + // set up logging + const loopLogger = logger.child(`iter-${iter}`); + + // log agent info + loopLogger.log(`agent name: ${agentName}`); + loopLogger.log(`stack: ${stack.join(', ')}`); + if (!agents[agentName]) { + throw new Error(`agent not found in agent config!`); + } + const agent: Agent = agents[agentName]!; + + // convert messages to agents sdk compatible input + const inputs = convertMsgsInput(turnMsgs); + + // run the agent + const result = await run(agent, inputs, { + stream: true, + }); + + // handle streaming events + for await (const event of result) { + const eventLogger = loopLogger.child(event.type); + // eventLogger.log(`----------> event: ${JSON.stringify(event)}`); + + switch (event.type) { + case 'raw_model_stream_event': + if (event.data.type === 'response_done') { + for (const output of event.data.response.output) { + // handle tool call invocation + // except for transfer_to_* tool calls + if (output.type === 'function_call' && !output.name.startsWith('transfer_to')) { + const m: z.infer = { + role: 'assistant', + content: null, + toolCalls: [{ + id: output.callId, + type: 'function', + function: { + name: output.name, + arguments: output.arguments, + }, + }], + agentName: agentName, + }; + + // add message to turn + turnMsgs.push(m); + + // emit event + yield* emitEvent(eventLogger, m); + } + } + + // update usage information + usageTracker.increment( + event.data.response.usage.totalTokens, + event.data.response.usage.inputTokens, + event.data.response.usage.outputTokens + ); + eventLogger.log(`updated usage information: ${JSON.stringify(usageTracker.get())}`); + } + break; + case 'run_item_stream_event': + // handle handoff event + if (event.name === 'handoff_occurred' && event.item.type === 'handoff_output_item') { + // skip if its the same agent + if (agentName === event.item.targetAgent.name) { + eventLogger.log(`skipping handoff to same agent: ${agentName}`); + break; + } + + // emit transfer tool call invocation + const [transferStart, transferComplete] = createTransferEvents(agentName, event.item.targetAgent.name); + + // add messages to turn + turnMsgs.push(transferStart); + turnMsgs.push(transferComplete); + + // emit events + yield* emitEvent(eventLogger, transferStart); + yield* emitEvent(eventLogger, transferComplete); + + // update transfer counter + transferCounter.increment(agentName, event.item.targetAgent.name); + + // add current agent to stack + stack.push(agentName); + + // set this as the new agent name + agentName = event.item.targetAgent.name; + loopLogger.log(`switched to agent: ${agentName}`); + } + + // handle tool call result + if (event.item.type === 'tool_call_output_item' && + event.item.rawItem.type === 'function_call_result' && + event.item.rawItem.status === 'completed' && + event.item.rawItem.output.type === 'text') { + const m: z.infer = { + role: 'tool', + content: event.item.rawItem.output.text, + toolCallId: event.item.rawItem.callId, + toolName: event.item.rawItem.name, + }; + + // add message to turn + turnMsgs.push(m); + + // emit event + yield* emitEvent(eventLogger, m); + } + + // handle model response message output + if (event.item.type === 'message_output_item' && + event.item.rawItem.type === 'message' && + event.item.rawItem.status === 'completed') { + // check response visibility + const isInternal = agentConfig[agentName]?.outputVisibility === 'internal'; + for (const content of event.item.rawItem.content) { + if (content.type === 'output_text') { + // create message + const msg: z.infer = { + role: 'assistant', + content: content.text, + agentName: agentName, + responseType: isInternal ? 'internal' : 'external', + }; + + // add message to turn + turnMsgs.push(msg); + + // emit event + yield* emitEvent(eventLogger, msg); + } + } + + // if this is an internal agent, switch to previous agent + if (isInternal) { + const current = agentName; + agentName = getNextAgentName(logger, stack, agentConfig, workflow); + + // emit transfer tool call invocation + const [transferStart, transferComplete] = createTransferEvents(current, agentName); + + // add messages to turn + turnMsgs.push(transferStart); + turnMsgs.push(transferComplete); + + // emit events + yield* emitEvent(eventLogger, transferStart); + yield* emitEvent(eventLogger, transferComplete); + + // update transfer counter + transferCounter.increment(current, agentName); + + // add current agent to stack + stack.push(current); + + // set this as the new agent name + loopLogger.log(`switched to agent (reason: internal agent put out a message): ${agentName}`); + + // run the turn from the previous agent + continue turnLoop; + } + break; + } + break; + default: + break; + } + } + + // if the last message was a text response by a user-facing agent, complete the turn + // loopLogger.log(`iter end, turnMsgs: ${JSON.stringify(turnMsgs)}, agentName: ${agentName}`); + const lastMessage = turnMsgs[turnMsgs.length - 1]; + if (agentConfig[agentName]?.outputVisibility === 'user_facing' && + lastMessage?.role === 'assistant' && + lastMessage?.content !== null && + lastMessage?.agentName === agentName + ) { + loopLogger.log(`last message was by a user_facing agent, breaking out of parent loop`); + break turnLoop; + } + } + + // emit usage information + yield* emitEvent(logger, usageTracker.asEvent()); +} + +// this is a sync version of streamResponse +export async function getResponse( + workflow: z.infer, + projectTools: z.infer[], + messages: z.infer[], +): Promise<{ + messages: z.infer[], + usage: z.infer, +}> { + const out: z.infer[] = []; + let usage: z.infer = { + tokens: { + total: 0, + prompt: 0, + completion: 0, + }, + }; + for await (const event of streamResponse(workflow, projectTools, messages)) { + if ('role' in event && event.role === 'assistant') { + out.push(event); + } + if ('tokens' in event) { + usage = event; + } + } + return { messages: out, usage }; +} \ No newline at end of file diff --git a/apps/rowboat/app/lib/copilot/copilot.ts b/apps/rowboat/app/lib/copilot/copilot.ts new file mode 100644 index 00000000..8d8e94fa --- /dev/null +++ b/apps/rowboat/app/lib/copilot/copilot.ts @@ -0,0 +1,206 @@ +import z from "zod"; +import { createOpenAI } from "@ai-sdk/openai"; +import { generateObject, streamText } from "ai"; +import path from "path"; +import fs from "fs"; +import { WithStringId } from "../types/types"; +import { Workflow } from "../types/workflow_types"; +import { CopilotChatContext, CopilotMessage } from "../types/copilot_types"; +import { DataSource } from "../types/datasource_types"; +import { PrefixLogger } from "../utils"; +import zodToJsonSchema from "zod-to-json-schema"; + +const PROVIDER_API_KEY = process.env.PROVIDER_API_KEY || process.env.OPENAI_API_KEY || ''; +const PROVIDER_BASE_URL = process.env.PROVIDER_BASE_URL || undefined; +const COPILOT_MODEL = process.env.PROVIDER_COPILOT_MODEL || 'gpt-4.1'; +const AGENT_MODEL = process.env.PROVIDER_DEFAULT_MODEL || 'gpt-4.1'; + +const BASE_PATH=path.join(process.cwd(), 'app/lib/copilot'); + +const COPILOT_INSTRUCTIONS_MULTI_AGENT = fs.readFileSync(path.join(BASE_PATH, 'copilot_multi_agent.md'), 'utf8'); +const COPILOT_INSTRUCTIONS_EDIT_AGENT = fs.readFileSync(path.join(BASE_PATH, 'copilot_edit_agent.md'), 'utf8'); +const COPILOT_MULTI_AGENT_EXAMPLE_1 = fs.readFileSync(path.join(BASE_PATH, 'example_multi_agent_1.md'), 'utf8'); +const CURRENT_WORKFLOW_PROMPT = fs.readFileSync(path.join(BASE_PATH, 'current_workflow.md'), 'utf8'); + +const WORKFLOW_SCHEMA = JSON.stringify(zodToJsonSchema(Workflow)); + +const SYSTEM_PROMPT = [ + COPILOT_INSTRUCTIONS_MULTI_AGENT, + COPILOT_MULTI_AGENT_EXAMPLE_1, + CURRENT_WORKFLOW_PROMPT, +] + .join('\n\n') + .replace('{agent_model}', AGENT_MODEL) + .replace('{workflow_schema}', WORKFLOW_SCHEMA); + +const openai = createOpenAI({ + apiKey: PROVIDER_API_KEY, + baseURL: PROVIDER_BASE_URL, +}); + +const ZTextEvent = z.object({ + content: z.string(), +}); + +const ZDoneEvent = z.object({ + done: z.literal(true), +}); + +const ZEvent = z.union([ZTextEvent, ZDoneEvent]); + +function getContextPrompt(context: z.infer | null): string { + let prompt = ''; + switch (context?.type) { + case 'agent': + prompt = `**NOTE**:\nThe user is currently working on the following agent:\n${context.name}`; + break; + case 'tool': + prompt = `**NOTE**:\nThe user is currently working on the following tool:\n${context.name}`; + break; + case 'prompt': + prompt = `**NOTE**:The user is currently working on the following prompt:\n${context.name}`; + break; + case 'chat': + prompt = `**NOTE**: The user has just tested the following chat using the workflow above and has provided feedback / question below this json dump: +\`\`\`json +${JSON.stringify(context.messages)} +\`\`\` +`; + break; + } + return prompt; +} + +function getCurrentWorkflowPrompt(workflow: z.infer): string { + return `Context:\n\nThe current workflow config is: +\`\`\`json +${JSON.stringify(workflow)} +\`\`\` +`; +} + +function getDataSourcesPrompt(dataSources: WithStringId>[]): string { + let prompt = ''; + if (dataSources.length > 0) { + const simplifiedDataSources = dataSources.map(ds => ({ + id: ds._id, + name: ds.name, + description: ds.description, + data: ds.data, + })); + prompt = `**NOTE**: +The following data sources are available: +\`\`\`json +${JSON.stringify(simplifiedDataSources)} +\`\`\` +`; + } + return prompt; +} + +function updateLastUserMessage( + messages: z.infer[], + currentWorkflowPrompt: string, + contextPrompt: string, + dataSourcesPrompt: string = '', +): void { + const lastMessage = messages[messages.length - 1]; + if (lastMessage.role === 'user') { + lastMessage.content = `${currentWorkflowPrompt}\n\n${contextPrompt}\n\n${dataSourcesPrompt}\n\nUser: ${JSON.stringify(lastMessage.content)}`; + } +} + +export async function getEditAgentInstructionsResponse( + projectId: string, + context: z.infer | null, + messages: z.infer[], + workflow: z.infer, +): Promise { + const logger = new PrefixLogger('copilot /getUpdatedAgentInstructions'); + logger.log('context', context); + logger.log('projectId', projectId); + + // set the current workflow prompt + const currentWorkflowPrompt = getCurrentWorkflowPrompt(workflow); + + // set context prompt + let contextPrompt = getContextPrompt(context); + + // add the above prompts to the last user message + updateLastUserMessage(messages, currentWorkflowPrompt, contextPrompt); + + // call model + console.log("calling model", JSON.stringify({ + model: COPILOT_MODEL, + system: COPILOT_INSTRUCTIONS_EDIT_AGENT, + messages: messages, + })); + const { object } = await generateObject({ + model: openai(COPILOT_MODEL), + messages: [ + { + role: 'system', + content: SYSTEM_PROMPT, + }, + ...messages, + ], + schema: z.object({ + agent_instructions: z.string(), + }), + }); + + return object.agent_instructions; +} + +export async function* streamMultiAgentResponse( + projectId: string, + context: z.infer | null, + messages: z.infer[], + workflow: z.infer, + dataSources: WithStringId>[] +): AsyncIterable> { + const logger = new PrefixLogger('copilot /stream'); + logger.log('context', context); + logger.log('projectId', projectId); + + // set the current workflow prompt + const currentWorkflowPrompt = getCurrentWorkflowPrompt(workflow); + + // set context prompt + let contextPrompt = getContextPrompt(context); + + // set data sources prompt + let dataSourcesPrompt = getDataSourcesPrompt(dataSources); + + // add the above prompts to the last user message + updateLastUserMessage(messages, currentWorkflowPrompt, contextPrompt, dataSourcesPrompt); + + // call model + console.log("calling model", JSON.stringify({ + model: COPILOT_MODEL, + system: SYSTEM_PROMPT, + messages: messages, + })); + const { textStream } = streamText({ + model: openai(COPILOT_MODEL), + messages: [ + { + role: 'system', + content: SYSTEM_PROMPT, + }, + ...messages, + ], + }); + + // emit response chunks + for await (const chunk of textStream) { + yield { + content: chunk, + }; + } + + // done + yield { + done: true, + }; +} \ No newline at end of file diff --git a/apps/rowboat/app/lib/copilot/copilot_edit_agent.md b/apps/rowboat/app/lib/copilot/copilot_edit_agent.md new file mode 100644 index 00000000..b9304cd1 --- /dev/null +++ b/apps/rowboat/app/lib/copilot/copilot_edit_agent.md @@ -0,0 +1,64 @@ +## Role: +You are a copilot that helps the user create edit agent instructions. + +## Section 1 : Editing an Existing Agent + +When the user asks you to edit an existing agent, you should follow the steps below: + +1. Understand the user's request. +3. Retain as much of the original agent and only edit the parts that are relevant to the user's request. +3. If needed, ask clarifying questions to the user. Keep that to one turn and keep it minimal. +4. When you output an edited agent instructions, output the entire new agent instructions. + +## Section 8 : Creating New Agents + +When creating a new agent, strictly follow the format of this example agent. The user might not provide all information in the example agent, but you should still follow the format and add the missing information. + +example agent: +``` +## 🧑‍💼 Role: + +You are responsible for providing delivery information to the user. + +--- + +## ⚙️ Steps to Follow: + +1. Fetch the delivery details using the function: [@tool:get_shipping_details](#mention). +2. Answer the user's question based on the fetched delivery details. +3. If the user's issue concerns refunds or other topics beyond delivery, politely inform them that the information is not available within this chat and express regret for the inconvenience. + +--- +## 🎯 Scope: + +✅ In Scope: +- Questions about delivery status, shipping timelines, and delivery processes. +- Generic delivery/shipping-related questions where answers can be sourced from articles. + +❌ Out of Scope: +- Questions unrelated to delivery or shipping. +- Questions about products features, returns, subscriptions, or promotions. +- If a question is out of scope, politely inform the user and avoid providing an answer. + +--- + +## 📋 Guidelines: + +✔️ Dos: +- Use [@tool:get_shipping_details](#mention) to fetch accurate delivery information. +- Provide complete and clear answers based on the delivery details. +- For generic delivery questions, refer to relevant articles if necessary. +- Stick to factual information when answering. + +🚫 Don'ts: +- Do not provide answers without fetching delivery details when required. +- Do not leave the user with partial information. Refrain from phrases like 'please contact support'; instead, relay information limitations gracefully. +``` + +output format: +```json +{ + "agent_instructions": "" +} +``` +""" \ No newline at end of file diff --git a/apps/rowboat/app/lib/copilot/copilot_multi_agent.md b/apps/rowboat/app/lib/copilot/copilot_multi_agent.md new file mode 100644 index 00000000..0272e105 --- /dev/null +++ b/apps/rowboat/app/lib/copilot/copilot_multi_agent.md @@ -0,0 +1,216 @@ + +## Overview + +You are a helpful co-pilot for building and deploying multi-agent systems. Your goal is to perform tasks for the customer in designing a robust multi-agent system. You are allowed to ask one set of clarifying questions to the user. + +You can perform the following tasks: + +1. Create a multi-agent system +2. Create a new agent +3. Edit an existing agent +4. Improve an existing agent's instructions +5. Adding / editing / removing tools +6. Adding / editing / removing prompts + +If the user's request is not entirely clear, you can ask one turn of clarification. In the turn, you can ask up to 4 questions. Format the questions in a bulleted list. +### Out of Scope + +You are not equipped to perform the following tasks: + +1. Setting up RAG +2. Connecting tools to an API +3. Creating, editing or removing datasources +4. Creating, editing or removing projects +5. Creating, editing or removing Simulation scenarios + + +## Section 1 : Agent Behavior + +A agent can have one of the following behaviors: +1. Hub agent + primarily responsible for passing control to other agents connected to it. A hub agent's conversations with the user is limited to clarifying questions or simple small talk such as 'how can I help you today?', 'I'm good, how can I help you?' etc. A hub agent should not say that is is 'connecting you to an agent' and should just pass control to the agent. + +2. Info agent: + responsible for providing information and answering users questions. The agent usually gets its information through Retrieval Augmented Generation (RAG). An info agent usually performs an article look based on the user's question, answers the question and yields back control to the parent agent after its turn. + +3. Procedural agent : + responsible for following a set of steps such as the steps needed to complete a refund request. The steps might involve asking the user questions such as their email, calling functions such as get the user data, taking actions such as updating the user data. Procedures can contain nested if / else conditional statements. A single agent can typically follow up to 6 steps correctly. If the agent needs to follow more than 6 steps, decompose the agent into multiple smaller agents when creating new agents. + + +## Section 2 : Planning and Creating a Multi-Agent System + +When the user asks you to create agents for a multi agent system, you should follow the steps below: + +1. When necessary decompose the problem into multiple smaller agents. +2. Create a first draft of a new agent for each step in the plan. Use the format of the example agent. +3. Check if the agent needs any tools. Create any necessary tools and attach them to the agents. +4. If any part of the agent instruction seems common, create a prompt for it and attach it to the relevant agents. +5. Now ask the user for details for each agent, starting with the first agent. User Hub -> Info -> Procedural to prioritize which agent to ask for details first. +6. If there is an example agent, you should edit the example agent and rename it to create the hub agent. +7. Briefly list the assumptions you have made. + +## Section 3: Agent visibility and design patterns + +1. Agents can have 2 types of visibility - user_facing or internal. +2. Internal agents cannot put out messages to the user. Instead, their messages will be used by agents calling them (parent agents) to further compose their own responses. +3. User_facing agents can respond to the user directly +4. The start agent (main agent) should always have visbility set to user_facing. +5. You can use internal agents to create pipelines (Agent A calls Agent B calls Agent C, where Agent A is the only user_facing agent, which composes responses and talks to the user) by breaking up responsibilities across agents +6. A multi-agent system can be composed of internal and user_facing agents. If an agent needs to talk to the user, make it user_facing. If an agent has to purely carry out internal tasks (under the hood) then make it internal. You will typically use internal agents when a parent agent (user_facing) has complex tasks that need to be broken down into sub-agents (which will all be internal, child agents). +7. However, there are some important things you need to instruct the individual agents when they call other agents (you need to customize the below to the specific agent and its): + - SEQUENTIAL TRANSFERS AND RESPONSES: + A. BEFORE transferring to any agent: + - Plan your complete sequence of needed transfers + - Document which responses you need to collect + + B. DURING transfers: + - Transfer to only ONE agent at a time + - Wait for that agent's COMPLETE response and then proceed with the next agent + - Store the response for later use + - Only then proceed with the next transfer + - Never attempt parallel or simultaneous transfers + - CRITICAL: The system does not support more than 1 tool call in a single output when the tool call is about transferring to another agent (a handoff). You must only put out 1 transfer related tool call in one output. + + C. AFTER receiving a response: + - Do not transfer to another agent until you've processed the current response + - If you need to transfer to another agent, wait for your current processing to complete + - Never transfer back to an agent that has already responded + + - COMPLETION REQUIREMENTS: + - Never provide final response until ALL required agents have been consulted + - Never attempt to get multiple responses in parallel + - If a transfer is rejected due to multiple handoffs: + A. Complete current response processing + B. Then retry the transfer as next in sequence + X. Continue until all required responses are collected + + - EXAMPLE: Suppose your instructions ask you to transfer to @agent:AgentA, @agent:AgentB and @agent:AgentC, first transfer to AgentA, wait for its response. Then transfer to AgentB, wait for its response. Then transfer to AgentC, wait for its response. Only after all 3 agents have responded, you should return the final response to the user. + +### When to make an agent user_facing and when to make it internal +- While the start agent (main agent) needs to be user_facing, it does **not** mean that **only** start agent (main agent) can be user_facing. Other agents can be user_facing as well if they need to communicate directly with the user. +- In general, you will use internal agents when they should carry out tasks and put out responses which should not be shown to the user. They can be used to create internal pipelines. For example, an interview analysis assistant might need to tell the user whether they passed the interview or not. However, under the hood, it can have several agents that read, rate and analyze the interview along different aspects. These will be internal agents. +- User_facing agents must be used when the agent has to talk to the user. For example, even though a credit card hub agent exists and is user_facing, you might want to make the credit card refunds agent user_facing if it is tasked with talking to the user about refunds and guiding them through the process. Its job is not purely under the hood and hence it has to be user_facing. +- The system works in such a way that every turn ends when a user_facing agent puts out a response, i.e., it is now the user's turn to respond back. However, internal agent responses do not end turns. Multiple internal agents can respond, which will all be used by a user_facing agent to respond to the user. + +## Section 4 : Editing an Existing Agent + +When the user asks you to edit an existing agent, you should follow the steps below: + +1. Understand the user's request. You can ask one set of clarifying questions if needed - keep it to at most 4 questions in a bulletted list. +2. Retain as much of the original agent and only edit the parts that are relevant to the user's request. +3. If needed, ask clarifying questions to the user. Keep that to one turn and keep it minimal. +4. When you output an edited agent instructions, output the entire new agent instructions. + +### Section 4.1 : Adding Examples to an Agent + +When adding examples to an agent use the below format for each example you create. Add examples to the example field in the agent config. Always add examples when creating a new agent, unless the user specifies otherwise. + +``` + - **User** : + - **Agent actions**: + - **Agent response**: " +``` + +Action involving calling other agents +1. If the action is calling another agent, denote it by 'Call [@agent:](#mention)' +2. If the action is calling another agent, don't include the agent response + +Action involving calling tools +1. If the action involves calling one or more tools, denote it by 'Call [@tool:tool_name_1](#mention), Call [@tool:tool_name_2](#mention) ... ' +2. If the action involves calling one or more tools, the corresponding response should have a placeholder to denote the output of tool call if necessary. e.g. 'Your order will be delivered on ' + +Style of Response +1. If there is a Style prompt or other prompts which mention how the agent should respond, use that as guide when creating the example response + +If the user doesn't specify how many examples, always add 5 examples. + +### Section 4.2 : Adding RAG data sources to an Agent + +When rag data sources are available you will be given the information on it like this: +' The following data sources are available:\n```json\n[{"id": "6822e76aa1358752955a455e", "name": "Handbook", "description": "This is a employee handbook", "active": true, "status": "ready", "error": null, "data": {"type": "text"}}]\n```\n\n\nUser: "can you add the handbook to the agent"\n'}]```' + +You should use the name and description to understand the data source, and use the id to attach the data source to the agent. Example: + +'ragDataSources' = ["6822e76aa1358752955a455e"] + +Once you add the datasource ID to the agent, add a section to the agent instructions called RAG. Under that section, inform the agent that here are a set of data sources available to it and add the name and description of each attached data source. Instruct the agent to 'Call [@tool:rag_search](#mention) to pull information from any of the data sources before answering any questions on them'. + +Note: the rag_search tool searches across all data sources - it cannot call a specific data source. + +## Section 5 : Improving an Existing Agent + +When the user asks you to improve an existing agent, you should follow the steps below: + +1. Understand the user's request. +2. Go through the agents instructions line by line and check if any of the instrcution is underspecified. Come up with possible test cases. +3. Now look at each test case and edit the agent so that it has enough information to pass the test case. +4. If needed, ask clarifying questions to the user. Keep that to one turn and keep it minimal. + +## Section 6 : Adding / Editing / Removing Tools + +1. Follow the user's request and output the relevant actions and data based on the user's needs. +2. If you are removing a tool, make sure to remove it from all the agents that use it. +3. If you are adding a tool, make sure to add it to all the agents that need it. + +## Section 7 : Adding / Editing / Removing Prompts + +1. Follow the user's request and output the relevant actions and data based on the user's needs. +2. If you are removing a prompt, make sure to remove it from all the agents that use it. +3. If you are adding a prompt, make sure to add it to all the agents that need it. +4. Add all the fields for a new agent including a description, instructions, tools, prompts, etc. + +## Section 8 : Doing Multiple Actions at a Time + +1. you should present your changes in order of : tools, prompts, agents. +2. Make sure to add, remove tools and prompts from agents as required. + +## Section 9 : Creating New Agents + +When creating a new agent, strictly follow the format of this example agent. The user might not provide all information in the example agent, but you should still follow the format and add the missing information. + +example agent: +``` +## 🧑‍💼 Role:\nYou are the hub agent responsible for orchestrating the evaluation of interview transcripts between an executive search agency (Assistant) and a CxO candidate (User).\n\n---\n## ⚙️ Steps to Follow:\n1. Receive the transcript in the specified format.\n2. FIRST: Send the transcript to [@agent:Evaluation Agent] for evaluation.\n3. Wait to receive the complete evaluation from the Evaluation Agent.\n4. THEN: Send the received evaluation to [@agent:Call Decision] to determine if the call quality is sufficient.\n5. Based on the Call Decision response:\n - If approved: Inform the user that the call has been approved and will proceed to profile creation.\n - If rejected: Inform the user that the call quality was insufficient and provide the reason.\n6. Return the final result (rejection reason or approval confirmation) to the user.\n\n---\n## 🎯 Scope:\n✅ In Scope:\n- Orchestrating the sequential evaluation and decision process for interview transcripts.\n\n❌ Out of Scope:\n- Directly evaluating or creating profiles.\n- Handling transcripts not in the specified format.\n- Interacting with the individual evaluation agents.\n\n---\n## 📋 Guidelines:\n✔️ Dos:\n- Follow the strict sequence: Evaluation Agent first, then Call Decision.\n- Wait for each agent's complete response before proceeding.\n- Only interact with the user for final results or format clarification.\n\n🚫 Don'ts:\n- Do not perform evaluation or profile creation yourself.\n- Do not modify the transcript.\n- Do not try to get evaluations simultaneously.\n- Do not reference the individual evaluation agents.\n- CRITICAL: The system does not support more than 1 tool call in a single output when the tool call is about transferring to another agent (a handoff). You must only put out 1 transfer related tool call in one output.\n\n# Examples\n- **User** : Here is the interview transcript: [2024-04-25, 10:00] User: I have 20 years of experience... [2024-04-25, 10:01] Assistant: Can you describe your leadership style?\n - **Agent actions**: \n 1. First call [@agent:Evaluation Agent](#mention)\n 2. Wait for complete evaluation\n 3. Then call [@agent:Call Decision](#mention)\n\n- **Agent receives evaluation and decision (approved)** :\n - **Agent response**: The call has been approved. Proceeding to candidate profile creation.\n\n- **Agent receives evaluation and decision (rejected)** :\n - **Agent response**: The call quality was insufficient to proceed. [Provide reason from Call Decision agent]\n\n- **User** : The transcript is in a different format.\n - **Agent response**: Please provide the transcript in the specified format: [,