apunkt/rowboat
1
0
Fork 0
mirror of https://github.com/rowboatlabs/rowboat.git synced 2026-06-06 19:35:44 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #165 from rowboatlabs/port-agents

Browse source 
port agents runtime to ts
This commit is contained in:
Ramnique Singh 2025-07-01 12:12:30 +05:30 • committed by GitHub
commit ddee06a54c
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
33 changed files with 2404 additions and 1098 deletions
Download patch file Download diff file Expand all files Collapse all files

18
apps/rowboat/app/actions/actions.ts
View file

@ -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<z.infer<typeof Webpage
};
}
export async function getAssistantResponseStreamId(request: z.infer<typeof AgenticAPIChatRequest>): Promise<z.infer<typeof AgenticAPIInitStreamResponse> | { billingError: string }> {
await projectAuthCheck(request.projectId);
if (!await check_query_limit(request.projectId)) {
export async function getAssistantResponseStreamId(
workflow: z.infer<typeof Workflow>,
projectTools: z.infer<typeof WorkflowTool>[],
messages: z.infer<typeof Message>[],
): 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<typeof Agent
return { billingError: error || 'Billing error' };
}
const response = await getAgenticResponseStreamId(request);
const response = await getAgenticResponseStreamId(workflow, projectTools, messages);
return response;
}

204
apps/rowboat/app/actions/copilot_actions.ts
View file

@ -1,147 +1,29 @@
'use server';
import {
convertToCopilotWorkflow, convertToCopilotMessage, convertToCopilotApiMessage,
convertToCopilotApiChatContext, CopilotAPIResponse, CopilotAPIRequest,
CopilotChatContext, CopilotMessage, CopilotAssistantMessage, CopilotWorkflow,
CopilotDataSource
CopilotAPIRequest,
CopilotChatContext, CopilotMessage,
} from "../lib/types/copilot_types";
import {
Workflow} from "../lib/types/workflow_types";
import { DataSource } from "../lib/types/datasource_types";
import { z } from 'zod';
import { zodToJsonSchema } from 'zod-to-json-schema';
import { assert } from "node:console";
import { check_query_limit } from "../lib/rate_limiting";
import { QueryLimitError, validateConfigChanges } from "../lib/client_utils";
import { QueryLimitError } from "../lib/client_utils";
import { projectAuthCheck } from "./project_actions";
import { redisClient } from "../lib/redis";
import { fetchProjectMcpTools } from "../lib/project_tools";
import { mergeProjectTools } from "../lib/types/project_types";
import { authorizeUserAction, logUsage } from "./billing_actions";
import { USE_BILLING } from "../lib/feature_flags";
export async function getCopilotResponse(
projectId: string,
messages: z.infer<typeof CopilotMessage>[],
current_workflow_config: z.infer<typeof Workflow>,
context: z.infer<typeof CopilotChatContext> | null,
dataSources?: z.infer<typeof DataSource>[]
): Promise<{
message: z.infer<typeof CopilotAssistantMessage>;
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<typeof CopilotAPIRequest> = {
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<typeof CopilotAPIResponse> = 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<typeof CopilotAssistantMessage>,
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<typeof CopilotMessage>[],
current_workflow_config: z.infer<typeof Workflow>,
context: z.infer<typeof CopilotChatContext> | null,
dataSources?: z.infer<typeof DataSource>[]
dataSources?: WithStringId<z.infer<typeof DataSource>>[]
): 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<typeof CopilotAPIRequest> = {
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<typeof CopilotAPIRequest> = {
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<typeof CopilotAPIResponse>;
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) {

2
apps/rowboat/app/actions/klavis_actions.ts
View file

@ -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");

34
apps/rowboat/app/actions/mcp_actions.ts
View file

@ -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<Client> {
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<z.infer<typeof WorkflowTool>[]> {
await projectAuthCheck(projectId);

47
apps/rowboat/app/api/copilot-stream-response/[streamId]/route.ts
View file

@ -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);
}
},

91
apps/rowboat/app/api/stream-response/[streamId]/route.ts
View file

@ -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);

33
apps/rowboat/app/api/v1/[projectId]/chat/route.ts
View file

@ -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<typeof AgenticAPIChatRequest> = {
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<typeof ApiResponse> = {
messages: newMessages,
state: newState,
messages,
};
return Response.json(responseBody);
});

146
apps/rowboat/app/api/widget/v1/chats/[chatId]/turn/route.ts
View file

@ -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<typeof apiV1.ChatMessage>[]): z.infer<typeof Message>[] {
const result: z.infer<typeof Message>[] = [];
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<typeof AssistantMessage | typeof AssistantMessageWithToolCalls | typeof ToolMessage>[]): z.infer<typeof apiV1.ChatMessage>[] {
const result: z.infer<typeof apiV1.ChatMessage>[] = [];
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<typeof apiV1.ChatMessage>[] = [userMessage];
let state: unknown = chat.agenticState ?? { last_agent_name: startAgent };
const inMessages: z.infer<typeof Message>[] = convert(messages);
inMessages.push(userMessage);
const request: z.infer<typeof AgenticAPIChatRequest> = {
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,

109
apps/rowboat/app/lib/agent_instructions.ts Normal file
View file

@ -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.
`;

909
apps/rowboat/app/lib/agents.ts Normal file
View file

@ -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<string> {
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<typeof EmbeddingRecord>['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<typeof WorkflowAgent>,
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<typeof WorkflowTool>,
): 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<typeof WorkflowTool>,
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<typeof WorkflowAgent>,
tools: Record<string, Tool>,
projectTools: z.infer<typeof WorkflowTool>[],
workflow: z.infer<typeof Workflow>,
promptConfig: Record<string, z.infer<typeof WorkflowPrompt>>,
): { agent: Agent, entities: z.infer<typeof ConnectedEntity>[] } {
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<typeof Message>[]): 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<string, z.infer<typeof WorkflowAgent>>,
workflow: z.infer<typeof Workflow>,
): 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<typeof ZOutMessage> | z.infer<typeof ZUsage>,
): AsyncIterable<z.infer<typeof ZOutMessage> | z.infer<typeof ZUsage>> {
logger.log(`-> emitting event: ${JSON.stringify(event)}`);
yield event;
return;
}
// Emits an agent -> agent transfer event
function createTransferEvents(
fromAgent: string,
toAgent: string,
): [z.infer<typeof AssistantMessageWithToolCalls>, z.infer<typeof ToolMessage>] {
const toolCallId = crypto.randomUUID();
const m1: z.infer<typeof Message> = {
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<typeof Message> = {
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<string, number> = {};
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<typeof ZUsage> {
return {
tokens: this.usage,
};
}
}
function ensureSystemMessage(logger: PrefixLogger, messages: z.infer<typeof Message>[]) {
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<typeof Workflow>, projectTools: z.infer<typeof WorkflowTool>[]): {
agentConfig: Record<string, z.infer<typeof WorkflowAgent>>;
toolConfig: Record<string, z.infer<typeof WorkflowTool>>;
promptConfig: Record<string, z.infer<typeof WorkflowPrompt>>;
} {
const agentConfig: Record<string, z.infer<typeof WorkflowAgent>> = workflow.agents.reduce((acc, agent) => ({
...acc,
[agent.name]: agent
}), {});
const toolConfig: Record<string, z.infer<typeof WorkflowTool>> = [
...workflow.tools,
...projectTools,
].reduce((acc, tool) => ({
...acc,
[tool.name]: tool
}), {});
const promptConfig: Record<string, z.infer<typeof WorkflowPrompt>> = workflow.prompts.reduce((acc, prompt) => ({
...acc,
[prompt.name]: prompt
}), {});
return { agentConfig, toolConfig, promptConfig };
}
async function* emitGreetingTurn(logger: PrefixLogger, workflow: z.infer<typeof Workflow>): AsyncIterable<z.infer<typeof ZOutMessage> | z.infer<typeof ZUsage>> {
// 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<typeof Message>[]): 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<typeof Workflow>, toolConfig: Record<string, z.infer<typeof WorkflowTool>>): Record<string, Tool> {
const tools: Record<string, Tool> = {};
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<typeof Workflow>,
agentConfig: Record<string, z.infer<typeof WorkflowAgent>>,
tools: Record<string, Tool>,
projectTools: z.infer<typeof WorkflowTool>[],
promptConfig: Record<string, z.infer<typeof WorkflowPrompt>>,
): { agents: Record<string, Agent>, mentions: Record<string, z.infer<typeof ConnectedEntity>[]> } {
const agents: Record<string, Agent> = {};
const mentions: Record<string, z.infer<typeof ConnectedEntity>[]> = {};
// 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<typeof Workflow>,
projectTools: z.infer<typeof WorkflowTool>[],
messages: z.infer<typeof Message>[],
): AsyncIterable<z.infer<typeof ZOutMessage> | z.infer<typeof ZUsage>> {
// 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<typeof Message>[] = [...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<typeof Message> = {
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<typeof Message> = {
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<typeof Message> = {
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<typeof Workflow>,
projectTools: z.infer<typeof WorkflowTool>[],
messages: z.infer<typeof Message>[],
): Promise<{
messages: z.infer<typeof ZOutMessage>[],
usage: z.infer<typeof ZUsage>,
}> {
const out: z.infer<typeof ZOutMessage>[] = [];
let usage: z.infer<typeof ZUsage> = {
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 };
}

206
apps/rowboat/app/lib/copilot/copilot.ts Normal file
View file

@ -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<typeof CopilotChatContext> | 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<typeof Workflow>): string {
return `Context:\n\nThe current workflow config is:
\`\`\`json
${JSON.stringify(workflow)}
\`\`\`
`;
}
function getDataSourcesPrompt(dataSources: WithStringId<z.infer<typeof DataSource>>[]): 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<typeof CopilotMessage>[],
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<typeof CopilotChatContext> | null,
messages: z.infer<typeof CopilotMessage>[],
workflow: z.infer<typeof Workflow>,
): Promise<string> {
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<typeof CopilotChatContext> | null,
messages: z.infer<typeof CopilotMessage>[],
workflow: z.infer<typeof Workflow>,
dataSources: WithStringId<z.infer<typeof DataSource>>[]
): AsyncIterable<z.infer<typeof ZEvent>> {
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,
};
}

64
apps/rowboat/app/lib/copilot/copilot_edit_agent.md Normal file
View file

@ -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": "<new agent instructions with relevant changes>"
}
```
"""

216
apps/rowboat/app/lib/copilot/copilot_multi_agent.md Normal file
View file

@ -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** : <user's message>
- **Agent actions**: <actions like if applicable>
- **Agent response**: "<response to the user if applicable>
```
Action involving calling other agents
1. If the action is calling another agent, denote it by 'Call [@agent:<agent_name>](#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 <delivery_date>'
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: [<date>, <time>] User: <user-message> [<date>, <time>] Assistant: <assistant-message>\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**: Call [@agent:Evaluation Agent](#mention)\n\n- **Agent receives Evaluation Agent result** :\n - **Agent actions**: Call [@agent:Call Decision](#mention)\n\n- **Agent receives Call Decision result (approved)** :\n - **Agent response**: The call has been approved. Proceeding to candidate profile creation.\n\n- **Agent receives Call Decision result (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: [<date>, <time>] User: <user-message> [<date>, <time>] Assistant: <assistant-message>\n\n- **User** : What happens after evaluation?\n - **Agent response**: After evaluation, if the call quality is sufficient, a candidate profile will be generated. Otherwise, you will receive feedback on why the call was rejected.
```
IMPORTANT: Use {agent_model} as the default model for new agents.
## Section 10: General Guidelines
The user will provide the current config of the multi-agent system and ask you to make changes to it. Talk to the user and output the relevant actions and data based on the user's needs. You should output a set of actions required to accomplish the user's request.
Note:
1. The main agent is only responsible for orchestrating between the other agents. It should not perform any actions.
2. You should not edit the main agent unless absolutely necessary.
3. Make sure the there are no special characters in the agent names.
4. Add any escalation related request to the escalation agent.
5. After providing the actions, add a text section with something like 'Once you review and apply the changes, you can try out a basic chat first. I can then help you better configure each agent.'
6. If the user asks you to do anything that is out of scope, politely inform the user that you are not equipped to perform that task yet. E.g. "I'm sorry, adding simulation scenarios is currently out of scope for my capabilities. Is there anything else you would like me to do?"
7. Always speak with agency like "I'll do ... ", "I'll create ..."
8. Don't mention the style prompt
9. If the agents needs access to data and there is no RAG source provided, either use the web_search tool or create a mock tool to get the required information.
10. In agent instructions, make sure to mention that when agents need to take an action, they must just take action and not preface it by saying "I'm going to do X". Instead, they should just do X (e.g. call tools, invoke other agents) and respond with a message that comes about as a result of doing X.
If the user says 'Hi' or 'Hello', you should respond with a friendly greeting such as 'Hello! How can I help you today?'
**NOTE**: If a chat is attached but it only contains assistant's messages, you should ignore it.
## Section 11 : In-product Support
Below are FAQ's you should use when a use asks a questions on how to use the product (Rowboat).
User Question : How do I connect an MCP server?
Your Answer: Refer to https://docs.rowboatlabs.com/add_tools/ on how to connect MCP tools. Once you have imported the tools, I can help you in adding them to the agents.
User Question : How do I connect an Webhook?
Your Answer: Refer to https://docs.rowboatlabs.com/add_tools/ on how to connect a webhook. Once you have the tools setup, I can help you in adding them to the agents.
User Question: How do I use the Rowboat API?
Your Answer: Refer to https://docs.rowboatlabs.com/using_the_api/ on using the Rowboat API.
User Question: How do I use the SDK?
Your Answer: Refer to https://docs.rowboatlabs.com/using_the_sdk/ on using the Rowboat SDK.
User Question: I want to add RAG?
Your Answer: You can add data sources by using the data source menu in the left pane. You can fine more details in our docs: https://docs.rowboatlabs.com/using_rag.

11
apps/rowboat/app/lib/copilot/current_workflow.md Normal file
View file

@ -0,0 +1,11 @@
## Section: State of the Current Multi-Agent System
The design of the multi-agent system is represented by the following JSON schema:
```
{workflow_schema}
```
If the workflow has an 'Example Agent' as the main agent, it means the user is yet to create the main agent. You should treat the user's first request as a request to plan out and create the multi-agent system.
---

238
apps/rowboat/app/lib/copilot/example_multi_agent_1.md Normal file
View file

@ -0,0 +1,238 @@
## Examples
### Example 1:
User: create a system to handle 2fa related customer support queries for a banking app. The queries can be: 1. setting up 2fa : ask the users preferred methods 2. changing 2fa : changing the 2fa method 3. troubleshooting : not getting 2fa codes etc.
Copilot output:
I'm creating the get_current_2fa_method tool to fetch the user's current 2FA method and assist the 2FA Change agent:
```copilot_change
// action: create_new
// config_type: tool
// name: get_current_2fa_method
{
"change_description": "Created a tool to fetch the current 2FA method to assist in changing 2FA settings, with detailed parameters.",
"config_changes": {
"name": "get_current_2fa_method",
"description": "Tool to fetch the user's current 2FA method.",
"mockInstructions": "Return a random 2FA method for a banking app.",
"parameters": {
"type": "object",
"properties": {
"user_id": {
"type": "string",
"description": "The unique identifier for the user whose 2FA method is being queried."
}
},
"required": [
"user_id"
]
}
}
}
```
I'm creating the 2FA Setup agent to assist users in setting up their preferred 2FA method:
```copilot_change
// action: create_new
// config_type: agent
// name: 2FA Setup
{
"change_description": "Created an agent to guide users in setting up their 2FA method, with added prompts for user interaction.",
"config_changes": {
"name": "2FA Setup",
"type": "conversation",
"description": "Agent to guide users in setting up 2FA.",
"instructions": "## 🧑‍💼 Role:\nHelp users set up their 2FA preferences.\n\n---\n## ⚙️ Steps to Follow:\n1. Ask the user about their preferred 2FA method (e.g., SMS, Email).\n2. Confirm the setup method with the user.\n3. Guide them through the setup steps.\n4. If the user request is out of scope, call [@agent:2FA Hub](#mention)\n\n---\n## 🎯 Scope:\n✅ In Scope:\n- Setting up 2FA preferences\n\n❌ Out of Scope:\n- Changing existing 2FA settings\n- Handling queries outside 2FA setup.\n- General knowledge queries.\n\n---\n## 📋 Guidelines:\n✔️ Dos:\n- Clearly explain setup options and steps.\n\n🚫 Don'ts:\n- Assume preferences without user confirmation.\n- Extend the conversation beyond 2FA setup.",
"examples": "- **User** : I'd like to set up 2FA for my account.\n - **Agent response**: Sure, can you tell me your preferred method for 2FA? Options include SMS, Email, or an Authenticator App.\n\n- **User** : I want to use SMS for 2FA.\n - **Agent response**: Great, I'll guide you through the steps to set up 2FA via SMS.\n\n- **User** : How about using an Authenticator App?\n - **Agent response**: Sure, let's set up 2FA with an Authenticator App. I'll walk you through the necessary steps.\n\n- **User** : Can you help me set up 2FA through Email?\n - **Agent response**: No problem, I'll explain how to set up 2FA via Email now.\n\n- **User** : I changed my mind, can we start over?\n - **Agent response**: Of course, let's begin again. Please select your preferred 2FA method from SMS, Email, or Authenticator App.",
"model": "gpt-4o",
"toggleAble": true,
"outputVisibility": "user_facing"
}
}
```
I'm creating the 2FA Change agent to help users change their 2FA methods effectively:
```copilot_change
// action: create_new
// config_type: agent
// name: 2FA Change
{
"change_description": "Created an agent to help users change their 2FA methods, with additional tool integration for better functionality.",
"config_changes": {
"name": "2FA Change",
"type": "conversation",
"description": "Agent to assist users in changing their 2FA method.",
"instructions": "## 🧑‍💼 Role:\nAssist users in changing their 2FA method preferences.\n\n---\n## ⚙️ Steps to Follow:\n1. Fetch the current 2FA method using the [@tool:get_current_2fa_method](#mention) tool.\n2. Confirm with the user if they want to change the method.\n3. Guide them through the process of changing the method.\n4. If the user request is out of scope, call [@agent:2FA Hub](#mention)\n\n---\n## 🎯 Scope:\n✅ In Scope:\n- Changing existing 2FA settings\n\n❌ Out of Scope:\n- Initial setup of 2FA\n- Handling queries outside 2FA setup.\n- General knowledge queries.\n\n---\n## 📋 Guidelines:\n✔️ Dos:\n- Ensure the user is aware of the current method before change.\n\n🚫 Don'ts:\n- Change methods without explicit user confirmation.\n- Extend the conversation beyond 2FA change.",
"examples": "- **User** : I want to change my 2FA method from SMS to Email.\n - **Agent response**: I can help with that. Let me fetch your current 2FA setting first.\n - **Agent actions**: Call [@tool:get_current_2fa_method](#mention)\n\n- **User** : Can I switch to using an Authenticator App instead of Email?\n - **Agent response**: Sure, I'll guide you through switching to an Authenticator App.\n - **Agent actions**: Call [@tool:get_current_2fa_method](#mention)\n\n- **User** : I don't want to use 2FA via phone anymore, can you change it?\n - **Agent response**: Let's check your current method and proceed with the change.\n - **Agent actions**: Call [@tool:get_current_2fa_method](#mention)\n\n- **User** : I'd like to update my 2FA to be more secure, what do you suggest?\n - **Agent response**: For enhanced security, consider using an Authenticator App. Let's fetch your current method and update it.\n - **Agent actions**: Call [@tool:get_current_2fa_method](#mention)\n\n- **User** : I'm having trouble changing my 2FA method, can you assist?\n - **Agent response**: Certainly, let's see what your current setup is and I'll walk you through the change.",
"model": "gpt-4o",
"toggleAble": true,
"outputVisibility": "user_facing"
}
}
```
I'm creating the 2FA Troubleshooting agent to assist users in resolving issues with receiving 2FA codes:
```copilot_change
// action: create_new
// config_type: agent
// name: 2FA Troubleshooting
{
"change_description": "Created an agent to troubleshoot problems with receiving 2FA codes, with added verification prompts.",
"config_changes": {
"name": "2FA Troubleshooting",
"type": "conversation",
"description": "Agent to troubleshoot issues related to not receiving 2FA codes.",
"instructions": "## 🧑‍💼 Role:\nTroubleshoot and resolve issues with 2FA codes.\n\n---\n## ⚙️ Steps to Follow:\n1. Confirm the contact details for 2FA are correct.\n2. Ask about the issue specifics (e.g., not receiving codes at all, delayed codes).\n3. Provide troubleshooting steps or escalate if unresolved.\n4. If the user request is out of scope, call [@agent:2FA Hub](#mention)\n\n---\n## 🎯 Scope:\n✅ In Scope:\n- Troubleshooting issues with receiving 2FA codes\n\n❌ Out of Scope:\n- Setting up or changing 2FA methods\n- Handling queries outside 2FA Troubleshooting.\n- General knowledge queries.\n\n---\n## 📋 Guidelines:\n✔️ Dos:\n- Verify contact information for accuracy.\n\n🚫 Don'ts:\n- Extend the conversation beyond 2FA change.",
"examples": "- **User** : I haven't received my 2FA code.\n - **Agent response**: Let's ensure your contact details are correct. Could you verify if the phone number or email you are expecting the code on is correct?\n\n- **User** : My 2FA codes are always delayed.\n - **Agent response**: I apologize for the inconvenience. Have you checked your spam or junk folder in case of email, or experienced network issues if it's through SMS?\n\n- **User** : The codes aren't coming to my phone.\n - **Agent response**: Let's confirm the number on file for you. Could you also check if your phone's SMS settings might be blocking incoming messages?\n\n- **User** : I'm facing issues with receiving 2FA codes via email.\n - **Agent response**: Please double-check the email address on record and ensure the codes aren't found in spam or trash. I can assist further if needed.\n\n- **User** : My codes are coming to the wrong email address.\n - **Agent response**: I recommend updating your 2FA contact information. Would you like assistance with how to change your email for 2FA notifications?",
"model": "gpt-4o",
"toggleAble": true,
"outputVisibility": "user_facing"
}
}
```
I'm creating the hub agent 2FA Hub by modifying the Example Agent to manage and direct 2FA-related queries to specific agents:
```copilot_change
// action: edit
// config_type: agent
// name: Example Agent
{
"change_description": "Created a hub agent for 2FA-related queries to manage directing queries to specific agents, with updated fallback actions and clarifying instructions.",
"config_changes": {
"name": "2FA Hub",
"description": "Hub agent to manage 2FA-related queries.",
"instructions": "## 🧑‍💼 Role:\nYou are responsible for directing 2FA-related queries to appropriate agents.\n\n---\n## ⚙️ Steps to Follow:\n1. Greet the user and ask which 2FA-related query they need help with (e.g., 'Are you setting up, changing, or troubleshooting your 2FA?').\n2. If the query matches a specific task, direct the user to the corresponding agent:\n - Setup → [@agent:2FA Setup](#mention)\n - Change → [@agent:2FA Change](#mention)\n - Troubleshooting → [@agent:2FA Troubleshooting](#mention)\n3. If the query doesn't match any specific task, respond with 'I'm sorry, I didn't understand. Could you clarify your request?' or escalate to human support.\n\n---\n## 🎯 Scope:\n✅ In Scope:\n- Initialization of 2FA setup\n- Changing 2FA methods\n- Troubleshooting 2FA issues\n\n❌ Out of Scope:\n- Issues unrelated to 2FA\n- General knowledge queries\n\n---\n## 📋 Guidelines:\n✔️ Dos:\n- Direct queries to specific 2FA agents promptly.\n\n🚫 Don'ts:\n- Engage in detailed support.\n- Extend the conversation beyond 2FA.\n- Provide user-facing text such as 'I will connect you now...' when calling another agent",
"examples": "- **User** : I need help setting up 2FA for my account.\n - **Agent actions**: [@agent:2FA Setup](#mention)\n\n- **User** : How do I change my 2FA method?\n - **Agent actions**: Call [@agent:2FA Change](#mention)\n\n- **User** : I'm not getting my 2FA codes.\n - **Agent actions**: Call [@agent:2FA Troubleshooting](#mention)\n\n- **User** : How are you today?\n - **Agent response**: I'm doing great. What would like help with today?",
"outputVisibility": "user_facing"
}
}
```
Once you review and apply the changes, you can try out a basic chat first. I can then help you better configure each agent.
This concludes my changes. Would you like some more help?
---
### Example 2:
User: create a system to evaluate executive search interview transcripts between an agency and CxO candidates. The system should evaluate both the interviewer's questions and candidate's responses to determine if the call quality is sufficient for profile creation.
Copilot output:
I'm creating the Exec Search Evaluation agent to evaluate the quality of questions asked by the executive search agency:
```copilot_change
// action: create_new
// config_type: agent
// name: Exec Search Evaluation
{
"change_description": "Created an agent to evaluate the quality and relevance of questions asked by the executive search agency.",
"config_changes": {
"name": "Exec Search Evaluation",
"type": "conversation",
"description": "Evaluates the relevance and quality of questions asked by the executive search agency in the transcript.",
"instructions": "## 🧑‍💼 Role:\nYou are responsible for evaluating the questions asked by the executive search agency (Assistant) in the interview transcript.\n\n---\n## ⚙️ Steps to Follow:\n1. Review all 'Assistant' messages in the transcript.\n2. Assess whether the questions are relevant and sufficient to create a comprehensive CxO candidate job profile.\n3. Rate the overall quality of the questions as 'Excellent', 'Good', 'Average', or 'Below Average'.\n4. Provide a brief justification for your rating.\n5. Return your evaluation and justification.\n\n---\n## 🎯 Scope:\n✅ In Scope:\n- Evaluating the relevance and depth of questions asked by the executive search agency.\n\n❌ Out of Scope:\n- Evaluating candidate responses.\n- Creating candidate profiles.\n\n---\n## 📋 Guidelines:\n✔️ Dos:\n- Focus on whether the questions cover key areas: skills, experience, leadership, fit, etc.\n- Be objective and concise in your justification.\n\n🚫 Don'ts:\n- Do not evaluate candidate answers.\n- Do not suggest improvements unless specifically asked.",
"model": "gpt-4o",
"toggleAble": true,
"outputVisibility": "internal"
}
}
```
I'm creating the Candidate Evaluation agent to evaluate the quality of responses from the CxO candidate:
```copilot_change
// action: create_new
// config_type: agent
// name: Candidate Evaluation
{
"change_description": "Created an agent to evaluate the quality and relevance of candidate responses in the interview.",
"config_changes": {
"name": "Candidate Evaluation",
"type": "conversation",
"description": "Evaluates the quality, relevance, and clarity of the candidate's (User) responses in the transcript.",
"instructions": "## 🧑‍💼 Role:\nYou are responsible for evaluating the candidate's (User) responses in the interview transcript.\n\n---\n## ⚙️ Steps to Follow:\n1. Review all 'User' messages in the transcript.\n2. Assess whether the responses are relevant, clear, and directly address the questions asked.\n3. Identify if any responses are meandering, off-topic, or spam.\n4. Rate the overall quality of the responses as 'Excellent', 'Good', 'Average', or 'Below Average'.\n5. Provide a brief justification for your rating.\n6. Return your evaluation and justification.\n\n---\n## 🎯 Scope:\n✅ In Scope:\n- Evaluating the quality and relevance of candidate responses.\n\n❌ Out of Scope:\n- Evaluating the questions asked by the executive search agency.\n- Creating candidate profiles.\n\n---\n## 📋 Guidelines:\n✔️ Dos:\n- Focus on clarity, relevance, and completeness of responses.\n- Be objective and concise in your justification.\n\n🚫 Don'ts:\n- Do not evaluate the questions asked.\n- Do not suggest improvements unless specifically asked.",
"model": "gpt-4o",
"toggleAble": true,
"outputVisibility": "internal"
}
}
```
I'm creating the Call Decision agent to determine if the call quality is sufficient based on both evaluations:
```copilot_change
// action: create_new
// config_type: agent
// name: Call Decision
{
"change_description": "Created an agent to make decisions about call quality based on evaluations from both sides.",
"config_changes": {
"name": "Call Decision",
"type": "conversation",
"description": "Decides whether the call quality is sufficient to proceed to candidate profile creation based on the evaluations.",
"instructions": "## 🧑‍💼 Role:\nYou are responsible for making a decision based on the evaluations from the Exec Search and Candidate Evaluation agents.\n\n---\n## ⚙️ Steps to Follow:\n1. Receive the ratings and justifications from both evaluation agents.\n2. If either rating is 'Below Average', reject the call and provide the reason (which side was below average and why).\n3. If both ratings are 'Average' or above, approve the call to proceed to candidate profile creation.\n4. Return your decision and, if rejected, the reason for rejection.\n\n---\n## 🎯 Scope:\n✅ In Scope:\n- Deciding whether to proceed to profile creation or reject the call.\n\n❌ Out of Scope:\n- Evaluating the transcript directly.\n- Creating candidate profiles.\n\n---\n## 📋 Guidelines:\n✔️ Dos:\n- Be clear and concise in your decision.\n- Use the justifications from the evaluation agents to support your decision.\n\n🚫 Don'ts:\n- Do not override the evaluation agents' ratings.",
"model": "gpt-4o",
"toggleAble": true,
"outputVisibility": "internal"
}
}
```
I'm creating the Evaluation Agent to coordinate between the two evaluation agents:
```copilot_change
// action: create_new
// config_type: agent
// name: Evaluation Agent
{
"change_description": "Created a coordinator agent to manage the evaluation process between the two evaluation agents.",
"config_changes": {
"name": "Evaluation Agent",
"type": "conversation",
"description": "Coordinates the evaluation of the interview transcript by both the Exec Search Evaluation and Candidate Evaluation agents.",
"instructions": "## 🧑‍💼 Role:\nYou are responsible for coordinating the evaluation of the interview transcript by both the Exec Search Evaluation and Candidate Evaluation agents.\n\n---\n## ⚙️ Steps to Follow:\n1. Receive the transcript from the hub agent.\n2. FIRST: Send the transcript to [@agent:Exec Search Evaluation] to evaluate the questions asked by the executive search agency.\n3. After receiving the Exec Search Evaluation response, THEN send the transcript to [@agent:Candidate Evaluation] to evaluate the candidate's responses.\n4. Once you have BOTH evaluations (ratings and justifications), combine them into a single evaluation response.\n5. Return the combined evaluation to the hub agent.\n\n---\n## 🎯 Scope:\n✅ In Scope:\n- Coordinating the sequential evaluation process between the two evaluation agents.\n\n❌ Out of Scope:\n- Making decisions about call quality.\n- Creating candidate profiles.\n- Interacting directly with the user.\n\n---\n## 📋 Guidelines:\n✔️ Dos:\n- Follow the strict sequence: Exec Search first, then Candidate.\n- Wait for each evaluation to complete before proceeding.\n- Combine both evaluations into a single response.\n\n🚫 Don'ts:\n- Do not evaluate the transcript yourself.\n- Do not try to get both evaluations simultaneously.\n- Do not interact with the user.\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.",
"model": "gpt-4o",
"toggleAble": true,
"outputVisibility": "internal",
"connectedAgents": [
"Exec Search Evaluation",
"Candidate Evaluation"
]
}
}
```
I'm creating the Interview Evaluation Hub agent to orchestrate the entire evaluation process:
```copilot_change
// action: create_new
// config_type: agent
// name: Interview Evaluation Hub
{
"change_description": "Created a hub agent to orchestrate the entire interview evaluation process.",
"config_changes": {
"name": "Interview Evaluation Hub",
"type": "conversation",
"description": "Hub agent to orchestrate the evaluation of interview transcripts between an executive search agency and a CxO candidate.",
"instructions": "## 🧑‍💼 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.",
"model": "gpt-4o",
"toggleAble": true,
"outputVisibility": "user_facing",
"connectedAgents": [
"Evaluation Agent",
"Call Decision"
]
}
}
```
Once you review and apply the changes, you can try out a basic chat first. I can then help you better configure each agent.
This concludes my changes. Would you like some more help?

32
apps/rowboat/app/lib/mcp.ts Normal file
View file

@ -0,0 +1,32 @@
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
// Helper to get MCP client
export async function getMcpClient(serverUrl: string, serverName: string): Promise<Client> {
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(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;
}
}

8
apps/rowboat/app/lib/redis.ts
View file

@ -1,7 +1,3 @@
import { createClient } from 'redis';
import Redis from 'ioredis';
export const redisClient = createClient({
url: process.env.REDIS_URL,
});
redisClient.connect();
export const redisClient = new Redis(process.env.REDIS_URL || '');

334
apps/rowboat/app/lib/types/agents_api_types.ts
View file

@ -1,334 +0,0 @@
import { z } from "zod";
import { sanitizeTextWithMentions, Workflow, WorkflowAgent, WorkflowPrompt, WorkflowTool } from "./workflow_types";
import { apiV1 } from "rowboat-shared";
import { ApiMessage } from "./types";
import { TestProfile } from "./testing_types";
import { MCPServer, MCPServerMinimal } from "./types";
import { mergeProjectTools } from "./project_types";
export const AgenticAPIChatMessage = z.object({
role: z.union([z.literal('user'), z.literal('assistant'), z.literal('tool'), z.literal('system')]),
content: z.string().nullable(),
tool_calls: z.array(z.object({
id: z.string(),
function: z.object({
name: z.string(),
arguments: z.string(),
}),
type: z.literal('function'),
})).nullable(),
tool_call_id: z.string().nullable(),
tool_name: z.string().nullable(),
sender: z.string().nullable(),
response_type: z.union([
z.literal('internal'),
z.literal('external'),
]).optional(),
});
export const AgenticAPIAgent = WorkflowAgent
.omit({
disabled: true,
examples: true,
locked: true,
toggleAble: true,
global: true,
})
.extend({
tools: z.array(z.string()),
prompts: z.array(z.string()),
connectedAgents: z.array(z.string()),
});
export const AgenticAPIPrompt = WorkflowPrompt;
export const AgenticAPITool = WorkflowTool
.omit({
autoSubmitMockedResponse: true,
})
export const AgenticAPIChatRequest = z.object({
projectId: z.string(),
messages: z.array(AgenticAPIChatMessage),
state: z.unknown(),
agents: z.array(AgenticAPIAgent),
tools: z.array(AgenticAPITool),
prompts: z.array(WorkflowPrompt),
startAgent: z.string(),
testProfile: TestProfile.optional(),
mcpServers: z.array(MCPServerMinimal),
toolWebhookUrl: z.string(),
});
export const AgenticAPIChatResponse = z.object({
messages: z.array(AgenticAPIChatMessage),
state: z.unknown(),
});
export const AgenticAPIInitStreamResponse = z.object({
streamId: z.string(),
});
export function convertWorkflowToAgenticAPI(workflow: z.infer<typeof Workflow>, projectTools: z.infer<typeof WorkflowTool>[]): {
agents: z.infer<typeof AgenticAPIAgent>[];
tools: z.infer<typeof AgenticAPITool>[];
prompts: z.infer<typeof AgenticAPIPrompt>[];
startAgent: string;
} {
const mergedTools = mergeProjectTools(workflow.tools, projectTools);
return {
agents: workflow.agents
.filter(agent => !agent.disabled)
.map(agent => {
const compiledInstructions = agent.instructions +
(agent.examples ? '\n\n# Examples\n' + agent.examples : '');
const { sanitized, entities } = sanitizeTextWithMentions(compiledInstructions, workflow, mergedTools);
const agenticAgent: z.infer<typeof AgenticAPIAgent> = {
name: agent.name,
type: agent.type,
description: agent.description,
instructions: sanitized,
model: agent.model,
controlType: agent.controlType,
ragDataSources: agent.ragDataSources,
ragK: agent.ragK,
ragReturnType: agent.ragReturnType,
outputVisibility: agent.outputVisibility,
tools: entities.filter(e => e.type == 'tool').map(e => e.name),
prompts: entities.filter(e => e.type == 'prompt').map(e => e.name),
connectedAgents: entities.filter(e => e.type === 'agent').map(e => e.name),
maxCallsPerParentAgent: agent.maxCallsPerParentAgent,
};
return agenticAgent;
}),
tools: mergedTools,
prompts: workflow.prompts
.map(p => {
const { sanitized } = sanitizeTextWithMentions(p.prompt, workflow, mergedTools);
return {
...p,
prompt: sanitized,
};
}),
startAgent: workflow.startAgent,
};
}
export function convertToAgenticAPIChatMessages(messages: z.infer<typeof apiV1.ChatMessage>[]): z.infer<typeof AgenticAPIChatMessage>[] {
const converted: z.infer<typeof AgenticAPIChatMessage>[] = [];
for (const m of messages) {
const baseMessage: z.infer<typeof AgenticAPIChatMessage> = {
content: null,
role: m.role,
sender: null,
tool_calls: null,
tool_call_id: null,
tool_name: null,
};
switch (m.role) {
case 'system':
converted.push({
...baseMessage,
content: m.content,
});
break;
case 'user':
converted.push({
...baseMessage,
content: m.content,
});
break;
case 'assistant':
if ('tool_calls' in m) {
converted.push({
...baseMessage,
tool_calls: m.tool_calls,
sender: m.agenticSender ?? null,
response_type: m.agenticResponseType,
});
} else {
converted.push({
...baseMessage,
content: m.content,
sender: m.agenticSender ?? null,
response_type: m.agenticResponseType,
});
}
break;
case 'tool':
converted.push({
...baseMessage,
content: m.content,
tool_call_id: m.tool_call_id,
tool_name: m.tool_name,
});
break;
default:
continue;
}
}
return converted;
}
export function convertFromAgenticAPIChatMessages(messages: z.infer<typeof AgenticAPIChatMessage>[]): z.infer<typeof apiV1.ChatMessage>[] {
const converted: z.infer<typeof apiV1.ChatMessage>[] = [];
for (const m of messages) {
const baseMessage = {
version: 'v1' as const,
chatId: '',
createdAt: new Date().toISOString(),
};
switch (m.role) {
case 'user':
converted.push({
...baseMessage,
role: 'user',
content: m.content ?? '',
});
break;
case 'assistant':
if (m.tool_calls) {
// TODO: handle tool calls
converted.push({
...baseMessage,
role: 'assistant',
tool_calls: m.tool_calls,
agenticSender: m.sender ?? undefined,
agenticResponseType: m.response_type ?? 'internal',
});
} else {
converted.push({
...baseMessage,
role: 'assistant',
content: m.content ?? '',
agenticSender: m.sender ?? undefined,
agenticResponseType: m.response_type ?? 'internal',
});
}
break;
case 'tool':
converted.push({
...baseMessage,
role: 'tool',
content: m.content ?? '',
tool_call_id: m.tool_call_id ?? '',
tool_name: m.tool_name ?? '',
});
break;
}
}
return converted;
}
export function convertFromApiToAgenticApiMessages(messages: z.infer<typeof ApiMessage>[]): z.infer<typeof AgenticAPIChatMessage>[] {
return messages.map(m => {
switch (m.role) {
case 'system':
return {
role: 'system',
content: m.content,
tool_calls: null,
tool_call_id: null,
tool_name: null,
sender: null,
};
case 'user':
return {
role: 'user',
content: m.content,
tool_calls: null,
tool_call_id: null,
tool_name: null,
sender: null,
};
case 'assistant':
if ('tool_calls' in m) {
return {
role: 'assistant',
content: m.content ?? null,
tool_calls: m.tool_calls,
tool_call_id: null,
tool_name: null,
sender: m.agenticSender ?? null,
response_type: m.agenticResponseType ?? 'external',
};
} else {
return {
role: 'assistant',
content: m.content ?? null,
sender: m.agenticSender ?? null,
response_type: m.agenticResponseType ?? 'external',
tool_call_id: null,
tool_calls: null,
tool_name: null,
};
}
case 'tool':
return {
role: 'tool',
content: m.content ?? null,
tool_calls: null,
tool_call_id: m.tool_call_id ?? null,
tool_name: m.tool_name ?? null,
sender: null,
};
default:
return {
role: "user",
content: "foo",
tool_calls: null,
tool_call_id: null,
tool_name: null,
sender: null,
};
}
});
}
export function convertFromAgenticApiToApiMessages(messages: z.infer<typeof AgenticAPIChatMessage>[]): z.infer<typeof ApiMessage>[] {
const converted: z.infer<typeof ApiMessage>[] = [];
for (const m of messages) {
switch (m.role) {
case 'user':
converted.push({
role: 'user',
content: m.content ?? '',
});
break;
case 'assistant':
if (m.tool_calls) {
converted.push({
role: 'assistant',
tool_calls: m.tool_calls,
agenticSender: m.sender ?? undefined,
agenticResponseType: m.response_type ?? 'internal',
});
} else {
converted.push({
role: 'assistant',
content: m.content ?? '',
agenticSender: m.sender ?? undefined,
agenticResponseType: m.response_type ?? 'internal',
});
}
break;
case 'tool':
converted.push({
role: 'tool',
content: m.content ?? '',
tool_call_id: m.tool_call_id ?? '',
tool_name: m.tool_name ?? '',
});
break;
}
}
return converted;
}

128
apps/rowboat/app/lib/types/copilot_types.ts
View file

@ -1,43 +1,8 @@
import { z } from "zod";
import { Workflow } from "./workflow_types";
import { apiV1 } from "rowboat-shared"
import { AgenticAPIChatMessage } from "./agents_api_types";
import { convertToAgenticAPIChatMessages } from "./agents_api_types";
import { Message } from "./types";
import { DataSource } from "./datasource_types";
// Create a filtered version of DataSource for copilot
export const CopilotDataSource = z.object({
_id: z.string(),
name: z.string(),
description: z.string().optional(),
active: z.boolean().default(true),
status: z.union([
z.literal('pending'),
z.literal('ready'),
z.literal('error'),
z.literal('deleted'),
]),
error: z.string().optional(),
data: z.discriminatedUnion('type', [
z.object({
type: z.literal('urls'),
}),
z.object({
type: z.literal('files_local'),
}),
z.object({
type: z.literal('files_s3'),
}),
z.object({
type: z.literal('text'),
})
]),
}).passthrough();
export const CopilotWorkflow = Workflow.omit({
lastUpdatedAt: true,
projectId: true,
});
export const CopilotUserMessage = z.object({
role: z.literal('user'),
content: z.string(),
@ -63,14 +28,10 @@ export const CopilotAssistantMessage = z.object({
});
export const CopilotMessage = z.union([CopilotUserMessage, CopilotAssistantMessage]);
export const CopilotApiMessage = z.object({
role: z.union([z.literal('assistant'), z.literal('user')]),
content: z.string(),
});
export const CopilotChatContext = z.union([
z.object({
type: z.literal('chat'),
messages: z.array(apiV1.ChatMessage),
messages: z.array(Message),
}),
z.object({
type: z.literal('agent'),
@ -85,31 +46,15 @@ export const CopilotChatContext = z.union([
name: z.string(),
}),
]);
export const CopilotApiChatContext = z.union([
z.object({
type: z.literal('chat'),
messages: z.array(AgenticAPIChatMessage),
}),
z.object({
type: z.literal('agent'),
agentName: z.string(),
}),
z.object({
type: z.literal('tool'),
toolName: z.string(),
}),
z.object({
type: z.literal('prompt'),
promptName: z.string(),
}),
]);
export const CopilotAPIRequest = z.object({
projectId: z.string(),
messages: z.array(CopilotApiMessage),
workflow_schema: z.string(),
current_workflow_config: z.string(),
context: CopilotApiChatContext.nullable(),
dataSources: z.array(CopilotDataSource).optional(),
messages: z.array(CopilotMessage),
workflow: Workflow,
context: CopilotChatContext.nullable(),
dataSources: z.array(DataSource.extend({
_id: z.string(),
})).optional(),
});
export const CopilotAPIResponse = z.union([
z.object({
@ -118,57 +63,4 @@ export const CopilotAPIResponse = z.union([
z.object({
error: z.string(),
}),
]);
export function convertToCopilotApiChatContext(context: z.infer<typeof CopilotChatContext>): z.infer<typeof CopilotApiChatContext> {
switch (context.type) {
case 'chat':
return {
type: 'chat',
messages: convertToAgenticAPIChatMessages(context.messages),
};
case 'agent':
return {
type: 'agent',
agentName: context.name,
};
case 'tool':
return {
type: 'tool',
toolName: context.name,
};
case 'prompt':
return {
type: 'prompt',
promptName: context.name,
};
}
}
export function convertToCopilotApiMessage(message: z.infer<typeof CopilotMessage>): z.infer<typeof CopilotApiMessage> {
return {
role: message.role,
content: JSON.stringify(message.content),
};
}
export function convertToCopilotMessage(message: z.infer<typeof CopilotApiMessage>): z.infer<typeof CopilotMessage> {
switch (message.role) {
case 'assistant':
return CopilotAssistantMessage.parse({
role: 'assistant',
content: JSON.parse(message.content),
});
case 'user':
return {
role: 'user',
content: message.content,
};
default:
throw new Error(`Unknown role: ${message.role}`);
}
}
export function convertToCopilotWorkflow(workflow: z.infer<typeof Workflow>): z.infer<typeof CopilotWorkflow> {
const { lastUpdatedAt, projectId, ...rest } = workflow;
return {
...rest,
};
}
]);

129
apps/rowboat/app/lib/types/types.ts
View file

@ -1,8 +1,52 @@
import { CoreMessage, ToolCallPart } from "ai";
import { z } from "zod";
import { apiV1 } from "rowboat-shared";
import { WorkflowTool } from "./workflow_types";
export const SystemMessage = z.object({
role: z.literal("system"),
content: z.string(),
});
export const UserMessage = z.object({
role: z.literal("user"),
content: z.string(),
});
export const AssistantMessage = z.object({
role: z.literal("assistant"),
content: z.string(),
agentName: z.string().nullable(),
responseType: z.enum(['internal', 'external']),
});
export const AssistantMessageWithToolCalls = z.object({
role: z.literal("assistant"),
content: z.null(),
toolCalls: z.array(z.object({
id: z.string(),
type: z.literal("function"),
function: z.object({
name: z.string(),
arguments: z.string(),
}),
})),
agentName: z.string().nullable(),
});
export const ToolMessage = z.object({
role: z.literal("tool"),
content: z.string(),
toolCallId: z.string(),
toolName: z.string(),
});
export const Message = z.union([
SystemMessage,
UserMessage,
AssistantMessage,
AssistantMessageWithToolCalls,
ToolMessage,
]);
export const McpToolInputSchema = z.object({
type: z.literal('object'),
properties: z.record(z.object({
@ -89,7 +133,7 @@ export const PlaygroundChat = z.object({
createdAt: z.string().datetime(),
projectId: z.string(),
title: z.string().optional(),
messages: z.array(apiV1.ChatMessage),
messages: z.array(Message),
simulated: z.boolean().default(false).optional(),
simulationScenario: z.string().optional(),
simulationComplete: z.boolean().default(false).optional(),
@ -111,90 +155,15 @@ export const ChatClientId = z.object({
export type WithStringId<T> = T & { _id: string };
export function convertToCoreMessages(messages: z.infer<typeof apiV1.ChatMessage>[]): CoreMessage[] {
// convert to core messages
const coreMessages: CoreMessage[] = [];
for (const m of messages) {
switch (m.role) {
case 'system':
coreMessages.push({
role: 'system',
content: m.content,
});
break;
case 'user':
coreMessages.push({
role: 'user',
content: m.content,
});
break;
case 'assistant':
if ('tool_calls' in m) {
const toolCallParts: ToolCallPart[] = m.tool_calls.map((toolCall) => ({
type: 'tool-call',
toolCallId: toolCall.id,
toolName: toolCall.function.name,
args: JSON.parse(toolCall.function.arguments),
}));
if (m.content) {
coreMessages.push({
role: 'assistant',
content: [
{
type: 'text',
text: m.content,
},
...toolCallParts,
]
});
} else {
coreMessages.push({
role: 'assistant',
content: toolCallParts,
});
}
} else {
coreMessages.push({
role: 'assistant',
content: m.content,
});
}
break;
case 'tool':
coreMessages.push({
role: 'tool',
content: [
{
type: 'tool-result',
toolCallId: m.tool_call_id,
toolName: m.tool_name,
result: JSON.parse(m.content),
}
]
});
break;
}
}
return coreMessages;
}
export const ApiMessage = z.union([
apiV1.SystemMessage,
apiV1.UserMessage,
apiV1.AssistantMessage,
apiV1.AssistantMessageWithToolCalls,
apiV1.ToolMessage,
]);
export const ApiRequest = z.object({
messages: z.array(ApiMessage),
messages: z.array(Message),
state: z.unknown(),
workflowId: z.string().nullable().optional(),
testProfileId: z.string().nullable().optional(),
});
export const ApiResponse = z.object({
messages: z.array(ApiMessage),
messages: z.array(Message),
state: z.unknown(),
});

54
apps/rowboat/app/lib/types/workflow_types.ts
View file

@ -2,10 +2,10 @@ import { z } from "zod";
export const WorkflowAgent = z.object({
name: z.string(),
order: z.number().int().optional(),
type: z.union([
z.literal('conversation'),
z.literal('post_process'),
z.literal('escalation'),
type: z.enum([
'conversation',
'post_process',
'escalation',
]),
description: z.string(),
disabled: z.boolean().default(false).optional(),
@ -16,18 +16,22 @@ export const WorkflowAgent = z.object({
toggleAble: z.boolean().default(true).describe('Whether this agent can be enabled or disabled').optional(),
global: z.boolean().default(false).describe('Whether this agent is a global agent, in which case it cannot be connected to other agents').optional(),
ragDataSources: z.array(z.string()).optional(),
ragReturnType: z.union([z.literal('chunks'), z.literal('content')]).default('chunks'),
ragReturnType: z.enum(['chunks', 'content']).default('chunks'),
ragK: z.number().default(3),
outputVisibility: z.union([z.literal('user_facing'), z.literal('internal')]).default('user_facing').optional(),
controlType: z.union([z.literal('retain'), z.literal('relinquish_to_parent'), z.literal('relinquish_to_start')]).default('retain').describe('Whether this agent retains control after a turn, relinquishes to the parent agent, or relinquishes to the start agent'),
outputVisibility: z.enum(['user_facing', 'internal']).default('user_facing').optional(),
controlType: z.enum([
'retain',
'relinquish_to_parent',
'relinquish_to_start',
]).default('retain').describe('Whether this agent retains control after a turn, relinquishes to the parent agent, or relinquishes to the start agent'),
maxCallsPerParentAgent: z.number().default(3).describe('Maximum number of times this agent can be called by a parent agent in a single turn').optional(),
});
export const WorkflowPrompt = z.object({
name: z.string(),
type: z.union([
z.literal('base_prompt'),
z.literal('style_prompt'),
z.literal('greeting'),
type: z.enum([
'base_prompt',
'style_prompt',
'greeting',
]),
prompt: z.string(),
});
@ -39,29 +43,9 @@ export const WorkflowTool = z.object({
mockInstructions: z.string().optional(),
parameters: z.object({
type: z.literal('object'),
properties: z.record(z.object({
type: z.string(),
description: z.string(),
enum: z.array(z.any()).optional(),
default: z.any().optional(),
minimum: z.number().optional(),
maximum: z.number().optional(),
items: z.any().optional(), // For array types
format: z.string().optional(),
pattern: z.string().optional(),
minLength: z.number().optional(),
maxLength: z.number().optional(),
minItems: z.number().optional(),
maxItems: z.number().optional(),
uniqueItems: z.boolean().optional(),
multipleOf: z.number().optional(),
examples: z.array(z.any()).optional(),
})),
required: z.array(z.string()).default([]),
}).default({
type: 'object',
properties: {},
required: [],
properties: z.record(z.string(), z.any()),
required: z.array(z.string()).optional(),
additionalProperties: z.boolean().optional(),
}),
isMcp: z.boolean().default(false).optional(),
isLibrary: z.boolean().default(false).optional(),
@ -90,7 +74,7 @@ export const WorkflowTemplate = Workflow
});
export const ConnectedEntity = z.object({
type: z.union([z.literal('tool'), z.literal('prompt'), z.literal('agent')]),
type: z.enum(['tool', 'prompt', 'agent']),
name: z.string(),
});

55
apps/rowboat/app/lib/utils.ts
View file

@ -1,54 +1,29 @@
import { AgenticAPIChatResponse, AgenticAPIChatRequest, AgenticAPIChatMessage, AgenticAPIInitStreamResponse } from "./types/agents_api_types";
import { z } from "zod";
import { generateObject } from "ai";
import { ApiMessage } from "./types/types";
import { openai } from "@ai-sdk/openai";
import { redisClient } from "./redis";
export async function getAgenticApiResponse(
request: z.infer<typeof AgenticAPIChatRequest>,
): Promise<{
messages: z.infer<typeof AgenticAPIChatMessage>[],
state: unknown,
rawAPIResponse: unknown,
}> {
// call agentic api
console.log(`sending agentic api request`, JSON.stringify(request));
const response = await fetch(process.env.AGENTS_API_URL + '/chat', {
method: 'POST',
body: JSON.stringify(request),
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${process.env.AGENTS_API_KEY || 'test'}`,
},
});
if (!response.ok) {
console.error('Failed to call agentic api', response);
throw new Error(`Failed to call agentic api: ${response.statusText}`);
}
const responseJson = await response.json();
console.log(`received agentic api response`, JSON.stringify(responseJson));
const result: z.infer<typeof AgenticAPIChatResponse> = responseJson;
return {
messages: result.messages,
state: result.state,
rawAPIResponse: result,
};
}
import { Workflow, WorkflowTool } from "./types/workflow_types";
import { Message } from "./types/types";
export async function getAgenticResponseStreamId(
request: z.infer<typeof AgenticAPIChatRequest>,
): Promise<z.infer<typeof AgenticAPIInitStreamResponse>> {
workflow: z.infer<typeof Workflow>,
projectTools: z.infer<typeof WorkflowTool>[],
messages: z.infer<typeof Message>[],
): Promise<{
streamId: string,
}> {
// serialize the request
const payload = JSON.stringify(request);
const payload = JSON.stringify({
workflow,
projectTools,
messages,
});
// create a uuid for the stream
const streamId = crypto.randomUUID();
// store payload in redis
await redisClient.set(`chat-stream-${streamId}`, payload, {
EX: 60 * 10, // expire in 10 minutes
});
await redisClient.set(`chat-stream-${streamId}`, payload, 'EX', 60 * 10); // expire in 10 minutes
return {
streamId,
@ -82,7 +57,7 @@ export class PrefixLogger {
}
}
export async function mockToolResponse(toolId: string, messages: z.infer<typeof ApiMessage>[], mockInstructions: string): Promise<string> {
export async function mockToolResponse(toolId: string, messages: z.infer<typeof Message>[], mockInstructions: string): Promise<string> {
const prompt = `Given below is a chat between a user and a customer support assistant.
The assistant has requested a tool call with ID {{toolID}}.

5
apps/rowboat/app/projects/[projectId]/copilot/app.tsx
View file

@ -14,6 +14,7 @@ import { Messages } from "./components/messages";
import { CopyIcon, CheckIcon, PlusIcon, XIcon, InfoIcon } from "lucide-react";
import { useCopilot } from "./use-copilot";
import { BillingUpgradeModal } from "@/components/common/billing-upgrade-modal";
import { WithStringId } from "@/app/lib/types/types";
const CopilotContext = createContext<{
workflow: z.infer<typeof Workflow> | null;
@ -32,7 +33,7 @@ interface AppProps {
onCopyJson?: (data: { messages: any[] }) => void;
onMessagesChange?: (messages: z.infer<typeof CopilotMessage>[]) => void;
isInitialState?: boolean;
dataSources?: z.infer<typeof DataSource>[];
dataSources?: WithStringId<z.infer<typeof DataSource>>[];
}
const App = forwardRef<{ handleCopyChat: () => void; handleUserMessage: (message: string) => void }, AppProps>(function App({
@ -224,7 +225,7 @@ export const Copilot = forwardRef<{ handleUserMessage: (message: string) => void
chatContext?: z.infer<typeof CopilotChatContext>;
dispatch: (action: WorkflowDispatch) => void;
isInitialState?: boolean;
dataSources?: z.infer<typeof DataSource>[];
dataSources?: WithStringId<z.infer<typeof DataSource>>[];
}>(({
projectId,
workflow,

3
apps/rowboat/app/projects/[projectId]/copilot/use-copilot.tsx
View file

@ -4,12 +4,13 @@ import { CopilotMessage } from "@/app/lib/types/copilot_types";
import { Workflow } from "@/app/lib/types/workflow_types";
import { DataSource } from "@/app/lib/types/datasource_types";
import { z } from "zod";
import { WithStringId } from "@/app/lib/types/types";
interface UseCopilotParams {
projectId: string;
workflow: z.infer<typeof Workflow>;
context: any;
dataSources?: z.infer<typeof DataSource>[];
dataSources?: WithStringId<z.infer<typeof DataSource>>[];
}
interface UseCopilotResult {

3
apps/rowboat/app/projects/[projectId]/entities/agent_config.tsx
View file

@ -1,6 +1,5 @@
"use client";
import { WithStringId } from "../../../lib/types/types";
import { AgenticAPITool } from "../../../lib/types/agents_api_types";
import { WorkflowPrompt, WorkflowAgent, Workflow, WorkflowTool } from "../../../lib/types/workflow_types";
import { DataSource } from "../../../lib/types/datasource_types";
import { z } from "zod";
@ -56,7 +55,7 @@ export function AgentConfig({
agent: z.infer<typeof WorkflowAgent>,
usedAgentNames: Set<string>,
agents: z.infer<typeof WorkflowAgent>[],
tools: z.infer<typeof AgenticAPITool>[],
tools: z.infer<typeof WorkflowTool>[],
projectTools: z.infer<typeof WorkflowTool>[],
prompts: z.infer<typeof WorkflowPrompt>[],
dataSources: WithStringId<z.infer<typeof DataSource>>[],

5
apps/rowboat/app/projects/[projectId]/playground/app.tsx
View file

@ -1,13 +1,12 @@
'use client';
import { useState, useCallback, useRef } from "react";
import { z } from "zod";
import { MCPServer, PlaygroundChat } from "@/app/lib/types/types";
import { MCPServer, Message, PlaygroundChat } from "@/app/lib/types/types";
import { Workflow, WorkflowTool } from "@/app/lib/types/workflow_types";
import { Chat } from "./components/chat";
import { Panel } from "@/components/common/panel-common";
import { Button } from "@/components/ui/button";
import { Tooltip } from "@heroui/react";
import { apiV1 } from "rowboat-shared";
import { TestProfile } from "@/app/lib/types/testing_types";
import { WithStringId } from "@/app/lib/types/types";
import { ProfileSelector } from "@/app/projects/[projectId]/test/[[...slug]]/components/selectors/profile-selector";
@ -31,7 +30,7 @@ export function App({
hidden?: boolean;
projectId: string;
workflow: z.infer<typeof Workflow>;
messageSubscriber?: (messages: z.infer<typeof apiV1.ChatMessage>[]) => void;
messageSubscriber?: (messages: z.infer<typeof Message>[]) => void;
mcpServerUrls: Array<z.infer<typeof MCPServer>>;
toolWebhookUrl: string;
isInitialState?: boolean;

73
apps/rowboat/app/projects/[projectId]/playground/components/chat.tsx
View file

@ -3,14 +3,10 @@ import { useEffect, useRef, useState, useCallback } from "react";
import { getAssistantResponseStreamId } from "@/app/actions/actions";
import { Messages } from "./messages";
import z from "zod";
import { MCPServer, PlaygroundChat } from "@/app/lib/types/types";
import { AgenticAPIChatMessage, convertFromAgenticAPIChatMessages, convertToAgenticAPIChatMessages } from "@/app/lib/types/agents_api_types";
import { convertWorkflowToAgenticAPI } from "@/app/lib/types/agents_api_types";
import { AgenticAPIChatRequest } from "@/app/lib/types/agents_api_types";
import { MCPServer, Message, PlaygroundChat, ToolMessage } from "@/app/lib/types/types";
import { Workflow, WorkflowTool } from "@/app/lib/types/workflow_types";
import { ComposeBoxPlayground } from "@/components/common/compose-box-playground";
import { Button } from "@heroui/react";
import { apiV1 } from "rowboat-shared";
import { TestProfile } from "@/app/lib/types/testing_types";
import { WithStringId } from "@/app/lib/types/types";
import { ProfileContextBox } from "./profile-context-box";
@ -35,7 +31,7 @@ export function Chat({
chat: z.infer<typeof PlaygroundChat>;
projectId: string;
workflow: z.infer<typeof Workflow>;
messageSubscriber?: (messages: z.infer<typeof apiV1.ChatMessage>[]) => void;
messageSubscriber?: (messages: z.infer<typeof Message>[]) => void;
testProfile?: z.infer<typeof TestProfile> | null;
onTestProfileChange: (profile: WithStringId<z.infer<typeof TestProfile>> | null) => void;
systemMessage: string;
@ -46,16 +42,13 @@ export function Chat({
showDebugMessages?: boolean;
projectTools: z.infer<typeof WorkflowTool>[];
}) {
const [messages, setMessages] = useState<z.infer<typeof apiV1.ChatMessage>[]>(chat.messages);
const [messages, setMessages] = useState<z.infer<typeof Message>[]>(chat.messages);
const [loadingAssistantResponse, setLoadingAssistantResponse] = useState<boolean>(false);
const [agenticState, setAgenticState] = useState<unknown>(chat.agenticState || {
last_agent_name: workflow.startAgent,
});
const [fetchResponseError, setFetchResponseError] = useState<string | null>(null);
const [billingError, setBillingError] = useState<string | null>(null);
const [lastAgenticRequest, setLastAgenticRequest] = useState<unknown | null>(null);
const [lastAgenticResponse, setLastAgenticResponse] = useState<unknown | null>(null);
const [optimisticMessages, setOptimisticMessages] = useState<z.infer<typeof apiV1.ChatMessage>[]>(chat.messages);
const [optimisticMessages, setOptimisticMessages] = useState<z.infer<typeof Message>[]>(chat.messages);
const [isLastInteracted, setIsLastInteracted] = useState(false);
const getCopyContent = useCallback(() => {
@ -80,20 +73,17 @@ export function Chat({
}, [messages]);
// collect published tool call results
const toolCallResults: Record<string, z.infer<typeof apiV1.ToolMessage>> = {};
const toolCallResults: Record<string, z.infer<typeof ToolMessage>> = {};
optimisticMessages
.filter((message) => message.role == 'tool')
.forEach((message) => {
toolCallResults[message.tool_call_id] = message;
toolCallResults[message.toolCallId] = message;
});
function handleUserMessage(prompt: string) {
const updatedMessages: z.infer<typeof apiV1.ChatMessage>[] = [...messages, {
const updatedMessages: z.infer<typeof Message>[] = [...messages, {
role: 'user',
content: prompt,
version: 'v1',
chatId: '',
createdAt: new Date().toISOString(),
}];
setMessages(updatedMessages);
setFetchResponseError(null);
@ -103,9 +93,6 @@ export function Chat({
// reset state when workflow changes
useEffect(() => {
setMessages([]);
setAgenticState({
last_agent_name: workflow.startAgent,
});
}, [workflow]);
// publish messages to subscriber
@ -119,7 +106,7 @@ export function Chat({
useEffect(() => {
let ignore = false;
let eventSource: EventSource | null = null;
let msgs: z.infer<typeof apiV1.ChatMessage>[] = [];
let msgs: z.infer<typeof Message>[] = [];
async function process() {
setLoadingAssistantResponse(true);
@ -129,36 +116,19 @@ export function Chat({
setLastAgenticRequest(null);
setLastAgenticResponse(null);
const { agents, tools, prompts, startAgent } = convertWorkflowToAgenticAPI(workflow, projectTools);
const request: z.infer<typeof AgenticAPIChatRequest> = {
projectId,
messages: convertToAgenticAPIChatMessages([{
role: 'system',
content: systemMessage || '',
version: 'v1' as const,
chatId: '',
createdAt: new Date().toISOString(),
}, ...messages]),
state: agenticState,
agents,
tools,
prompts,
startAgent,
mcpServers: mcpServerUrls.map(server => ({
name: server.name,
serverUrl: server.serverUrl || '',
isReady: server.isReady
})),
toolWebhookUrl: toolWebhookUrl,
testProfile: testProfile ?? undefined,
};
// Store the full request object
setLastAgenticRequest(request);
let streamId: string | null = null;
try {
const response = await getAssistantResponseStreamId(request);
const response = await getAssistantResponseStreamId(
workflow,
projectTools,
[
{
role: 'system',
content: systemMessage || '',
},
...messages,
],
);
if (ignore) {
return;
}
@ -190,8 +160,7 @@ export function Chat({
try {
const data = JSON.parse(event.data);
const msg = AgenticAPIChatMessage.parse(data);
const parsedMsg = convertFromAgenticAPIChatMessages([msg])[0];
const parsedMsg = Message.parse(data);
msgs.push(parsedMsg);
setOptimisticMessages(prev => [...prev, parsedMsg]);
} catch (err) {
@ -207,7 +176,6 @@ export function Chat({
}
const parsed = JSON.parse(event.data);
setAgenticState(parsed.state);
// Combine state and collected messages in the response
setLastAgenticResponse({
@ -267,7 +235,6 @@ export function Chat({
}, [
messages,
projectId,
agenticState,
workflow,
systemMessage,
mcpServerUrls,

61
apps/rowboat/app/projects/[projectId]/playground/components/messages.tsx
View file

@ -5,10 +5,10 @@ import z from "zod";
import { Workflow } from "@/app/lib/types/workflow_types";
import { WorkflowTool } from "@/app/lib/types/workflow_types";
import MarkdownContent from "@/app/lib/components/markdown-content";
import { apiV1 } from "rowboat-shared";
import { MessageSquareIcon, EllipsisIcon, CircleCheckIcon, ChevronRightIcon, ChevronDownIcon, ChevronUpIcon, XIcon, PlusIcon, CodeIcon, CheckCircleIcon, FileTextIcon } from "lucide-react";
import { TestProfile } from "@/app/lib/types/testing_types";
import { ProfileContextBox } from "./profile-context-box";
import { Message, ToolMessage, AssistantMessageWithToolCalls } from "@/app/lib/types/types";
function UserMessage({ content }: { content: string }) {
return (
@ -140,10 +140,10 @@ function ToolCalls({
systemMessage,
delta
}: {
toolCalls: z.infer<typeof apiV1.AssistantMessageWithToolCalls>['tool_calls'];
results: Record<string, z.infer<typeof apiV1.ToolMessage>>;
toolCalls: z.infer<typeof AssistantMessageWithToolCalls>['toolCalls'];
results: Record<string, z.infer<typeof ToolMessage>>;
projectId: string;
messages: z.infer<typeof apiV1.ChatMessage>[];
messages: z.infer<typeof Message>[];
sender: string | null | undefined;
workflow: z.infer<typeof Workflow>;
testProfile: z.infer<typeof TestProfile> | null;
@ -171,8 +171,8 @@ function ToolCall({
workflow,
delta
}: {
toolCall: z.infer<typeof apiV1.AssistantMessageWithToolCalls>['tool_calls'][number];
result: z.infer<typeof apiV1.ToolMessage> | undefined;
toolCall: z.infer<typeof AssistantMessageWithToolCalls>['toolCalls'][number];
result: z.infer<typeof ToolMessage> | undefined;
sender: string | null | undefined;
workflow: z.infer<typeof Workflow>;
delta: number;
@ -206,7 +206,7 @@ function TransferToAgentToolCall({
sender,
delta
}: {
result: z.infer<typeof apiV1.ToolMessage> | undefined;
result: z.infer<typeof ToolMessage> | undefined;
sender: string | null | undefined;
delta: number;
}) {
@ -238,8 +238,8 @@ function ClientToolCall({
workflow,
delta
}: {
toolCall: z.infer<typeof apiV1.AssistantMessageWithToolCalls>['tool_calls'][number];
result: z.infer<typeof apiV1.ToolMessage> | undefined;
toolCall: z.infer<typeof AssistantMessageWithToolCalls>['toolCalls'][number];
result: z.infer<typeof ToolMessage> | undefined;
sender: string | null | undefined;
workflow: z.infer<typeof Workflow>;
delta: number;
@ -350,8 +350,8 @@ export function Messages({
showDebugMessages = true,
}: {
projectId: string;
messages: z.infer<typeof apiV1.ChatMessage>[];
toolCallResults: Record<string, z.infer<typeof apiV1.ToolMessage>>;
messages: z.infer<typeof Message>[];
toolCallResults: Record<string, z.infer<typeof ToolMessage>>;
loadingAssistantResponse: boolean;
workflow: z.infer<typeof Workflow>;
testProfile: z.infer<typeof TestProfile> | null;
@ -368,28 +368,28 @@ export function Messages({
messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
}, [messages, loadingAssistantResponse]);
const renderMessage = (message: z.infer<typeof apiV1.ChatMessage>, index: number) => {
const isConsecutive = index > 0 && messages[index - 1].role === message.role;
const renderMessage = (message: z.infer<typeof Message>, index: number) => {
if (message.role === 'assistant') {
let latency = new Date(message.createdAt).getTime() - lastUserMessageTimestamp;
if (!userMessageSeen) {
latency = 0;
}
// TODO: add latency support
// let latency = new Date(message.createdAt).getTime() - lastUserMessageTimestamp;
// if (!userMessageSeen) {
// latency = 0;
// }
let latency = 0;
// First check for tool calls
if ('tool_calls' in message && message.tool_calls) {
if ('toolCalls' in message) {
// Skip tool calls if debug mode is off
if (!showDebugMessages) {
return null;
}
return (
<ToolCalls
toolCalls={message.tool_calls}
toolCalls={message.toolCalls}
results={toolCallResults}
projectId={projectId}
messages={messages}
sender={message.agenticSender ?? ''}
sender={message.agentName ?? ''}
workflow={workflow}
testProfile={testProfile}
systemMessage={systemMessage}
@ -399,7 +399,7 @@ export function Messages({
}
// Then check for internal messages
if (message.agenticResponseType === 'internal') {
if (message.content && message.responseType === 'internal') {
// Skip internal messages if debug mode is off
if (!showDebugMessages) {
return null;
@ -407,7 +407,7 @@ export function Messages({
return (
<InternalAssistantMessage
content={message.content ?? ''}
sender={message.agenticSender ?? ''}
sender={message.agentName ?? ''}
latency={latency}
delta={latency}
/>
@ -418,14 +418,15 @@ export function Messages({
return (
<AssistantMessage
content={message.content ?? ''}
sender={message.agenticSender ?? ''}
sender={message.agentName ?? ''}
latency={latency}
/>
);
}
if (message.role === 'user' && typeof message.content === 'string') {
lastUserMessageTimestamp = new Date(message.createdAt).getTime();
if (message.role === 'user') {
// TODO: add latency support
// lastUserMessageTimestamp = new Date(message.createdAt).getTime();
userMessageSeen = true;
return <UserMessage content={message.content} />;
}
@ -433,12 +434,12 @@ export function Messages({
return null;
};
const isAgentTransition = (message: z.infer<typeof apiV1.ChatMessage>) => {
return message.role === 'assistant' && 'tool_calls' in message && Array.isArray(message.tool_calls) && message.tool_calls.some(tc => tc.function.name.startsWith('transfer_to_'));
const isAgentTransition = (message: z.infer<typeof Message>) => {
return message.role === 'assistant' && 'toolCalls' in message && Array.isArray(message.toolCalls) && message.toolCalls.some(tc => tc.function.name.startsWith('transfer_to_'));
};
const isAssistantMessage = (message: z.infer<typeof apiV1.ChatMessage>) => {
return message.role === 'assistant' && (!('tool_calls' in message) || !Array.isArray(message.tool_calls) || !message.tool_calls.some(tc => tc.function.name.startsWith('transfer_to_')));
const isAssistantMessage = (message: z.infer<typeof Message>) => {
return message.role === 'assistant' && (!('toolCalls' in message) || !Array.isArray(message.toolCalls) || !message.toolCalls.some(tc => tc.function.name.startsWith('transfer_to_')));
};
if (showSystemMessage) {

6
apps/rowboat/app/projects/[projectId]/tools/components/ToolsConfig.tsx
View file

@ -4,7 +4,6 @@ import { useState } from 'react';
import { Tabs, Tab } from '@/components/ui/tabs';
import { HostedServers } from './HostedServers';
import { CustomServers } from './CustomServers';
import { WebhookConfig } from './WebhookConfig';
import type { Key } from 'react';
export function ToolsConfig() {
@ -40,11 +39,6 @@ export function ToolsConfig() {
<CustomServers />
</div>
</Tab>
<Tab key="webhook" title="Webhook">
<div className="mt-4 p-6">
<WebhookConfig />
</div>
</Tab>
</Tabs>
</div>
);

1
apps/rowboat/app/projects/[projectId]/workflow/entity_list.tsx
View file

@ -1,5 +1,4 @@
import { z } from "zod";
import { AgenticAPITool } from "../../../lib/types/agents_api_types";
import { WorkflowPrompt, WorkflowAgent, WorkflowTool } from "../../../lib/types/workflow_types";
import { Dropdown, DropdownItem, DropdownTrigger, DropdownMenu } from "@heroui/react";
import { useRef, useEffect, useState } from "react";

7
apps/rowboat/app/projects/[projectId]/workflow/workflow_editor.tsx
View file

@ -1,6 +1,6 @@
"use client";
import React, { useReducer, Reducer, useState, useCallback, useEffect, useRef, createContext, useContext } from "react";
import { MCPServer, WithStringId } from "../../../lib/types/types";
import { MCPServer, Message, WithStringId } from "../../../lib/types/types";
import { Workflow, WorkflowTool, WorkflowPrompt, WorkflowAgent } from "../../../lib/types/workflow_types";
import { DataSource } from "../../../lib/types/datasource_types";
import { produce, applyPatches, enablePatches, produceWithPatches, Patch } from 'immer';
@ -20,7 +20,6 @@ import {
ResizablePanelGroup,
} from "@/components/ui/resizable"
import { Copilot } from "../copilot/app";
import { apiV1 } from "rowboat-shared";
import { publishWorkflow, renameWorkflow, saveWorkflow } from "../../../actions/workflow_actions";
import { PublishedBadge } from "./published_badge";
import { BackIcon, HamburgerIcon, WorkflowIcon } from "../../../lib/components/icons";
@ -597,8 +596,8 @@ export function WorkflowEditor({
lastUpdatedAt: workflow.lastUpdatedAt,
}
});
const [chatMessages, setChatMessages] = useState<z.infer<typeof apiV1.ChatMessage>[]>([]);
const updateChatMessages = useCallback((messages: z.infer<typeof apiV1.ChatMessage>[]) => {
const [chatMessages, setChatMessages] = useState<z.infer<typeof Message>[]>([]);
const updateChatMessages = useCallback((messages: z.infer<typeof Message>[]) => {
setChatMessages(messages);
}, []);
const saveQueue = useRef<z.infer<typeof Workflow>[]>([]);

266
apps/rowboat/package-lock.json generated
View file

@ -25,6 +25,8 @@
"@langchain/textsplitters": "^0.1.0",
"@mendable/firecrawl-js": "^1.0.3",
"@modelcontextprotocol/sdk": "^1.12.1",
"@openai/agents": "^0.0.9",
"@openai/agents-extensions": "^0.0.9",
"@primer/react": "^37.27.0",
"@qdrant/js-client-rest": "^1.13.0",
"ai": "^4.3.13",
@ -37,6 +39,7 @@
"framer-motion": "^12.19.1",
"fuse.js": "^7.1.0",
"immer": "^10.1.1",
"ioredis": "^5.6.1",
"jose": "^5.9.6",
"lucide-react": "^0.465.0",
"mongodb": "^6.8.0",
@ -50,7 +53,6 @@
"react-dropzone": "^14.3.5",
"react-markdown": "^10.1.0",
"react-resizable-panels": "^2.1.7",
"redis": "^4.7.0",
"remark-gfm": "^4.0.1",
"rowboat-shared": "github:rowboatlabs/shared",
"sharp": "^0.33.4",
@ -4266,6 +4268,12 @@
"@swc/helpers": "^0.5.0"
}
},
"node_modules/@ioredis/commands": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/@ioredis/commands/-/commands-1.2.0.tgz",
"integrity": "sha512-Sx1pU8EM64o2BrqNpEO1CNLtKQwyhuXuqyfH7oGKCk+1a33d2r5saW8zNwm3j6BTExtjrv2BxTgzzkMwts6vGg==",
"license": "MIT"
},
"node_modules/@isaacs/fs-minipass": {
"version": "4.0.1",
"resolved": "https://registry.npmjs.org/@isaacs/fs-minipass/-/fs-minipass-4.0.1.tgz",
@ -4660,6 +4668,155 @@
"integrity": "sha512-iFrvar5SOMtKFOSjYvs4z9UlLqDdJbMx0mgISLcPedv+g0ac5sgeETLGtipHCVIae6HJPclNEH5aCyD1RZaEHw==",
"license": "BSD-3-Clause"
},
"node_modules/@openai/agents": {
"version": "0.0.9",
"resolved": "https://registry.npmjs.org/@openai/agents/-/agents-0.0.9.tgz",
"integrity": "sha512-JAZLqovH4MLGflwm7BZKjqW7ejhfGAoS7eyXkgfXh4oh/DtWbMr5hmK/Ha0jeqb1+xKY5ULbmikKDTPmHflW7g==",
"license": "MIT",
"dependencies": {
"@openai/agents-core": "0.0.9",
"@openai/agents-openai": "0.0.9",
"@openai/agents-realtime": "0.0.9",
"debug": "^4.4.0",
"openai": "^5.0.1"
}
},
"node_modules/@openai/agents-core": {
"version": "0.0.9",
"resolved": "https://registry.npmjs.org/@openai/agents-core/-/agents-core-0.0.9.tgz",
"integrity": "sha512-n7vftCMIBNNbhHSs6SAr0mU99YDD8CH2wRoGZ016nqgl1X9SZsfdQyZvpMMypWrGQ+bqke+jUtXCVnOhKXISFQ==",
"license": "MIT",
"dependencies": {
"@openai/zod": "npm:zod@^3.25.40",
"debug": "^4.4.0",
"openai": "^5.0.1"
},
"optionalDependencies": {
"@modelcontextprotocol/sdk": "^1.12.0"
},
"peerDependencies": {
"zod": "^3.25.40"
},
"peerDependenciesMeta": {
"zod": {
"optional": true
}
}
},
"node_modules/@openai/agents-core/node_modules/openai": {
"version": "5.7.0",
"resolved": "https://registry.npmjs.org/openai/-/openai-5.7.0.tgz",
"integrity": "sha512-zXWawZl6J/P5Wz57/nKzVT3kJQZvogfuyuNVCdEp4/XU2UNrjL7SsuNpWAyLZbo6HVymwmnfno9toVzBhelygA==",
"license": "Apache-2.0",
"bin": {
"openai": "bin/cli"
},
"peerDependencies": {
"ws": "^8.18.0",
"zod": "^3.23.8"
},
"peerDependenciesMeta": {
"ws": {
"optional": true
},
"zod": {
"optional": true
}
}
},
"node_modules/@openai/agents-extensions": {
"version": "0.0.9",
"resolved": "https://registry.npmjs.org/@openai/agents-extensions/-/agents-extensions-0.0.9.tgz",
"integrity": "sha512-r8gSAd9gZOSlY/c79dWToi5e1BnBrCCIY/gZ+j84rWl+hRumhjzMQcXenzbw6y3ng45UkmIubIUK3VBO2SSIPQ==",
"license": "MIT",
"dependencies": {
"@ai-sdk/provider": "^1.1.3",
"@openai/zod": "npm:zod@^3.25.40",
"@types/ws": "^8.18.1",
"debug": "^4.4.0"
},
"peerDependencies": {
"@openai/agents": "0.0.9",
"ws": "^8.18.1"
}
},
"node_modules/@openai/agents-openai": {
"version": "0.0.9",
"resolved": "https://registry.npmjs.org/@openai/agents-openai/-/agents-openai-0.0.9.tgz",
"integrity": "sha512-JfTuFaswJUmzVVEEseH+uQHLeHv3ED+X8E0pNE868FwKe1+vd9elzD9uCqRolMAtkBfk8AemHzkZlYl2nuG1sg==",
"license": "MIT",
"dependencies": {
"@openai/agents-core": "0.0.9",
"@openai/zod": "npm:zod@^3.25.40",
"debug": "^4.4.0",
"openai": "^5.0.1"
}
},
"node_modules/@openai/agents-openai/node_modules/openai": {
"version": "5.7.0",
"resolved": "https://registry.npmjs.org/openai/-/openai-5.7.0.tgz",
"integrity": "sha512-zXWawZl6J/P5Wz57/nKzVT3kJQZvogfuyuNVCdEp4/XU2UNrjL7SsuNpWAyLZbo6HVymwmnfno9toVzBhelygA==",
"license": "Apache-2.0",
"bin": {
"openai": "bin/cli"
},
"peerDependencies": {
"ws": "^8.18.0",
"zod": "^3.23.8"
},
"peerDependenciesMeta": {
"ws": {
"optional": true
},
"zod": {
"optional": true
}
}
},
"node_modules/@openai/agents-realtime": {
"version": "0.0.9",
"resolved": "https://registry.npmjs.org/@openai/agents-realtime/-/agents-realtime-0.0.9.tgz",
"integrity": "sha512-WpAoYG3zOq1U7ljyERxChMXOgnzaRaHqbU4gPMQUmEBD48MHpA0uro6VZTk83Vs6J8JfuS+fGxF11WiR2UlTCg==",
"license": "MIT",
"dependencies": {
"@openai/agents-core": "0.0.9",
"@openai/zod": "npm:zod@^3.25.40",
"@types/ws": "^8.18.1",
"debug": "^4.4.0",
"ws": "^8.18.1"
}
},
"node_modules/@openai/agents/node_modules/openai": {
"version": "5.7.0",
"resolved": "https://registry.npmjs.org/openai/-/openai-5.7.0.tgz",
"integrity": "sha512-zXWawZl6J/P5Wz57/nKzVT3kJQZvogfuyuNVCdEp4/XU2UNrjL7SsuNpWAyLZbo6HVymwmnfno9toVzBhelygA==",
"license": "Apache-2.0",
"bin": {
"openai": "bin/cli"
},
"peerDependencies": {
"ws": "^8.18.0",
"zod": "^3.23.8"
},
"peerDependenciesMeta": {
"ws": {
"optional": true
},
"zod": {
"optional": true
}
}
},
"node_modules/@openai/zod": {
"name": "zod",
"version": "3.25.67",
"resolved": "https://registry.npmjs.org/zod/-/zod-3.25.67.tgz",
"integrity": "sha512-idA2YXwpCdqUSKRCACDE6ItZD9TZzy3OZMtpfLoh6oPR47lipysRrJfjzMqFxQ3uJuUPyUeWe1r9vLH33xO/Qw==",
"license": "MIT",
"funding": {
"url": "https://github.com/sponsors/colinhacks"
}
},
"node_modules/@opentelemetry/api": {
"version": "1.9.0",
"resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz",
@ -6185,6 +6342,7 @@
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/@redis/bloom/-/bloom-1.2.0.tgz",
"integrity": "sha512-HG2DFjYKbpNmVXsa0keLHp/3leGJz1mjh09f2RLGGLQZzSHpkmZWuwJbAvo3QcRY8p80m5+ZdXZdYOSBLlp7Cg==",
"dev": true,
"peerDependencies": {
"@redis/client": "^1.0.0"
}
@ -6193,6 +6351,7 @@
"version": "1.6.0",
"resolved": "https://registry.npmjs.org/@redis/client/-/client-1.6.0.tgz",
"integrity": "sha512-aR0uffYI700OEEH4gYnitAnv3vzVGXCFvYfdpu/CJKvk4pHfLPEy/JSZyrpQ+15WhXe1yJRXLtfQ84s4mEXnPg==",
"dev": true,
"dependencies": {
"cluster-key-slot": "1.1.2",
"generic-pool": "3.9.0",
@ -6205,12 +6364,14 @@
"node_modules/@redis/client/node_modules/yallist": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
"integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="
"integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
"dev": true
},
"node_modules/@redis/graph": {
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/@redis/graph/-/graph-1.1.1.tgz",
"integrity": "sha512-FEMTcTHZozZciLRl6GiiIB4zGm5z5F3F6a6FZCyrfxdKOhFlGkiAqlexWMBzCi4DcRoyiOsuLfW+cjlGWyExOw==",
"dev": true,
"peerDependencies": {
"@redis/client": "^1.0.0"
}
@ -6219,6 +6380,7 @@
"version": "1.0.7",
"resolved": "https://registry.npmjs.org/@redis/json/-/json-1.0.7.tgz",
"integrity": "sha512-6UyXfjVaTBTJtKNG4/9Z8PSpKE6XgSyEb8iwaqDcy+uKrd/DGYHTWkUdnQDyzm727V7p21WUMhsqz5oy65kPcQ==",
"dev": true,
"peerDependencies": {
"@redis/client": "^1.0.0"
}
@ -6227,6 +6389,7 @@
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/@redis/search/-/search-1.2.0.tgz",
"integrity": "sha512-tYoDBbtqOVigEDMAcTGsRlMycIIjwMCgD8eR2t0NANeQmgK/lvxNAvYyb6bZDD4frHRhIHkJu2TBRvB0ERkOmw==",
"dev": true,
"peerDependencies": {
"@redis/client": "^1.0.0"
}
@ -6235,6 +6398,7 @@
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/@redis/time-series/-/time-series-1.1.0.tgz",
"integrity": "sha512-c1Q99M5ljsIuc4YdaCwfUEXsofakb9c8+Zse2qxTadu8TalLXuAESzLvFAvNVbkmSlvlzIQOLpBCmWI9wTOt+g==",
"dev": true,
"peerDependencies": {
"@redis/client": "^1.0.0"
}
@ -7547,6 +7711,15 @@
"@types/webidl-conversions": "*"
}
},
"node_modules/@types/ws": {
"version": "8.18.1",
"resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
"integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
"license": "MIT",
"dependencies": {
"@types/node": "*"
}
},
"node_modules/@typescript-eslint/eslint-plugin": {
"version": "8.35.0",
"resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.35.0.tgz",
@ -9045,6 +9218,15 @@
"node": ">=0.4.0"
}
},
"node_modules/denque": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/denque/-/denque-2.1.0.tgz",
"integrity": "sha512-HVQE3AAb/pxF8fQAoiqpvg9i3evqug3hoiwakOyZAwJm+6vZehbkYXZ0l4JxS+I3QxM97v5aaRNhj8v5oBhekw==",
"license": "Apache-2.0",
"engines": {
"node": ">=0.10"
}
},
"node_modules/depd": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
@ -10476,6 +10658,7 @@
"version": "3.9.0",
"resolved": "https://registry.npmjs.org/generic-pool/-/generic-pool-3.9.0.tgz",
"integrity": "sha512-hymDOu5B53XvN4QT9dBmZxPX4CWhBPPLguTZ9MMFeFa/Kg0xWVfylOVNlJji/E7yTZWFd/q9GO5TxDLq156D7g==",
"dev": true,
"engines": {
"node": ">= 4"
}
@ -10946,6 +11129,30 @@
"tslib": "^2.8.0"
}
},
"node_modules/ioredis": {
"version": "5.6.1",
"resolved": "https://registry.npmjs.org/ioredis/-/ioredis-5.6.1.tgz",
"integrity": "sha512-UxC0Yv1Y4WRJiGQxQkP0hfdL0/5/6YvdfOOClRgJ0qppSarkhneSa6UvkMkms0AkdGimSH3Ikqm+6mkMmX7vGA==",
"license": "MIT",
"dependencies": {
"@ioredis/commands": "^1.1.1",
"cluster-key-slot": "^1.1.0",
"debug": "^4.3.4",
"denque": "^2.1.0",
"lodash.defaults": "^4.2.0",
"lodash.isarguments": "^3.1.0",
"redis-errors": "^1.2.0",
"redis-parser": "^3.0.0",
"standard-as-callback": "^2.1.0"
},
"engines": {
"node": ">=12.22.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/ioredis"
}
},
"node_modules/ipaddr.js": {
"version": "1.9.1",
"resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
@ -11994,11 +12201,23 @@
"resolved": "https://registry.npmjs.org/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz",
"integrity": "sha512-H5ZhCF25riFd9uB5UCkVKo61m3S/xZk1x4wA6yp/L3RFP6Z/eHH1ymQcGLo7J3GMPfm0V/7m1tryHuGVxpqEBQ=="
},
"node_modules/lodash.defaults": {
"version": "4.2.0",
"resolved": "https://registry.npmjs.org/lodash.defaults/-/lodash.defaults-4.2.0.tgz",
"integrity": "sha512-qjxPLHd3r5DnsdGacqOMU6pb/avJzdh9tFX2ymgoZE27BmjXrNy/y4LoaiTeAb+O3gL8AfpJGtqfX/ae2leYYQ==",
"license": "MIT"
},
"node_modules/lodash.includes": {
"version": "4.3.0",
"resolved": "https://registry.npmjs.org/lodash.includes/-/lodash.includes-4.3.0.tgz",
"integrity": "sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w=="
},
"node_modules/lodash.isarguments": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/lodash.isarguments/-/lodash.isarguments-3.1.0.tgz",
"integrity": "sha512-chi4NHZlZqZD18a0imDHnZPrDeBbTtVN7GXMwuGdRH9qotxAjYs3aVLKc7zNOG9eddR5Ksd8rvFEBc9SsggPpg==",
"license": "MIT"
},
"node_modules/lodash.isboolean": {
"version": "3.0.3",
"resolved": "https://registry.npmjs.org/lodash.isboolean/-/lodash.isboolean-3.0.3.tgz",
@ -14553,6 +14772,7 @@
"version": "4.7.0",
"resolved": "https://registry.npmjs.org/redis/-/redis-4.7.0.tgz",
"integrity": "sha512-zvmkHEAdGMn+hMRXuMBtu4Vo5P6rHQjLoHftu+lBqq8ZTA3RCVC/WzD790bkKKiNFp7d5/9PcSD19fJyyRvOdQ==",
"dev": true,
"workspaces": [
"./packages/*"
],
@ -14565,6 +14785,27 @@
"@redis/time-series": "1.1.0"
}
},
"node_modules/redis-errors": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/redis-errors/-/redis-errors-1.2.0.tgz",
"integrity": "sha512-1qny3OExCf0UvUV/5wpYKf2YwPcOqXzkwKKSmKHiE6ZMQs5heeE/c8eXK+PNllPvmjgAbfnsbpkGZWy8cBpn9w==",
"license": "MIT",
"engines": {
"node": ">=4"
}
},
"node_modules/redis-parser": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/redis-parser/-/redis-parser-3.0.0.tgz",
"integrity": "sha512-DJnGAeenTdpMEH6uAJRK/uiyEIH9WVsUmoLwzudwGJUwZPp80PDBWPHXSAGNPwNvIXAbe7MSUB1zQFugFml66A==",
"license": "MIT",
"dependencies": {
"redis-errors": "^1.0.0"
},
"engines": {
"node": ">=4"
}
},
"node_modules/reflect.getprototypeof": {
"version": "1.0.10",
"resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz",
@ -15198,6 +15439,12 @@
"memory-pager": "^1.0.2"
}
},
"node_modules/standard-as-callback": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/standard-as-callback/-/standard-as-callback-2.1.0.tgz",
"integrity": "sha512-qoRRSyROncaz1z0mvYqIE4lCd9p2R90i6GxW3uZv5ucSu8tU7B5HXUP1gG8pVZsYNVaXjk8ClXHPttLyxAL48A==",
"license": "MIT"
},
"node_modules/statuses": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
@ -16368,10 +16615,10 @@
"integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="
},
"node_modules/ws": {
"version": "8.18.0",
"resolved": "https://registry.npmjs.org/ws/-/ws-8.18.0.tgz",
"integrity": "sha512-8VbfWfHLbbwu3+N6OKsOMpBdT4kXPDDB9cJk2bJ6mh9ucxdlnNvH1e+roYkKmN9Nxw2yjz7VzeO9oOz2zJ04Pw==",
"peer": true,
"version": "8.18.2",
"resolved": "https://registry.npmjs.org/ws/-/ws-8.18.2.tgz",
"integrity": "sha512-DMricUmwGZUVr++AEAe2uiVM7UoO9MAVZMDu05UQOaUII0lp+zOzLLU4Xqh/JvTqklB1T4uELaaPBKyjE1r4fQ==",
"license": "MIT",
"engines": {
"node": ">=10.0.0"
},
@ -16416,9 +16663,10 @@
}
},
"node_modules/zod": {
"version": "3.24.2",
"resolved": "https://registry.npmjs.org/zod/-/zod-3.24.2.tgz",
"integrity": "sha512-lY7CDW43ECgW9u1TcT3IoXHflywfVqDYze4waEz812jR/bZ8FHDsl7pFQoSZTz5N+2NqRXs8GBwnAwo3ZNxqhQ==",
"version": "3.25.67",
"resolved": "https://registry.npmjs.org/zod/-/zod-3.25.67.tgz",
"integrity": "sha512-idA2YXwpCdqUSKRCACDE6ItZD9TZzy3OZMtpfLoh6oPR47lipysRrJfjzMqFxQ3uJuUPyUeWe1r9vLH33xO/Qw==",
"license": "MIT",
"funding": {
"url": "https://github.com/sponsors/colinhacks"
}

4
apps/rowboat/package.json
View file

@ -32,6 +32,8 @@
"@langchain/textsplitters": "^0.1.0",
"@mendable/firecrawl-js": "^1.0.3",
"@modelcontextprotocol/sdk": "^1.12.1",
"@openai/agents": "^0.0.9",
"@openai/agents-extensions": "^0.0.9",
"@primer/react": "^37.27.0",
"@qdrant/js-client-rest": "^1.13.0",
"ai": "^4.3.13",
@ -44,6 +46,7 @@
"framer-motion": "^12.19.1",
"fuse.js": "^7.1.0",
"immer": "^10.1.1",
"ioredis": "^5.6.1",
"jose": "^5.9.6",
"lucide-react": "^0.465.0",
"mongodb": "^6.8.0",
@ -57,7 +60,6 @@
"react-dropzone": "^14.3.5",
"react-markdown": "^10.1.0",
"react-resizable-panels": "^2.1.7",
"redis": "^4.7.0",
"remark-gfm": "^4.0.1",
"rowboat-shared": "github:rowboatlabs/shared",
"sharp": "^0.33.4",