@agentuity/runtime 0.0.94 → 0.0.96

package/src/workbench.ts

@@ -5,6 +5,9 @@ import { getAgents, createAgentMiddleware } from './agent';
 import { createRouter } from './router';
 import type { WebSocketConnection } from './router';
 import { privateContext } from './_server';
+import { getThreadProvider } from './_services';
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
 
 export const createWorkbenchExecutionRoute = (): Handler => {
 	const authHeader = process.env.AGENTUITY_WORKBENCH_APIKEY
@@ -28,6 +31,12 @@ export const createWorkbenchExecutionRoute = (): Handler => {
 			}
 		}
 
+		// Content-type validation
+		const contentType = ctx.req.header('Content-Type');
+		if (!contentType || !contentType.includes('application/json')) {
+			return ctx.json({ error: 'Content-Type must be application/json' }, { status: 400 });
+		}
+
 		try {
 			let agentId: string;
 			let input: unknown;
@@ -39,20 +48,25 @@ export const createWorkbenchExecutionRoute = (): Handler => {
 				return ctx.json({ error: 'Invalid JSON in request body' }, { status: 400 });
 			}
 
-			// Get agents registry and find the agent
-			const allAgents = getAgents();
+			// Read metadata to find agent name by agentId
+			const metadataPath = join(process.cwd(), '.agentuity', 'agentuity.metadata.json');
+			if (!existsSync(metadataPath)) {
+				return ctx.json({ error: 'Metadata file not found' }, { status: 500 });
+			}
 
-			let agentObj;
-			let agentName;
+			const fileContent = readFileSync(metadataPath, 'utf-8');
+			const metadata = JSON.parse(fileContent);
+			const agentMeta = metadata.agents?.find((a: { agentId: string }) => a.agentId === agentId);
 
-			for (const [name, agent] of allAgents) {
-				if (agent.metadata.agentId === agentId) {
-					agentObj = agent;
-					agentName = name;
-					break;
-				}
+			if (!agentMeta) {
+				return ctx.text('Agent not found', { status: 404 });
 			}
 
+			// Get runtime agent by name
+			const allAgents = getAgents();
+			const agentName = agentMeta.name;
+			const agentObj = allAgents.get(agentName);
+
 			if (!agentObj || !agentName) {
 				return ctx.text('Agent not found', { status: 404 });
 			}
@@ -76,6 +90,32 @@ export const createWorkbenchExecutionRoute = (): Handler => {
 				result = await (agentObj as any).handler();
 			}
 
+			// Store input and output in thread state, keyed by agentId
+			// This allows multiple agents to have separate message histories in the same thread
+			if (ctx.var.thread) {
+				const agentMessagesKey = `messages_${agentId}`;
+				const existingMessages = ctx.var.thread.state.get(agentMessagesKey);
+				const messages = (existingMessages as unknown[] | undefined) || [];
+
+				messages.push({ type: 'input', data: input });
+
+				if (result !== undefined && result !== null) {
+					messages.push({ type: 'output', data: result });
+				}
+
+				ctx.var.thread.state.set(agentMessagesKey, messages);
+
+				// Manually save the thread to ensure state persists
+				try {
+					const threadProvider = getThreadProvider();
+					await threadProvider.save(ctx.var.thread);
+				} catch {
+					ctx.var.logger?.warn('Failed to save thread state');
+				}
+			} else {
+				ctx.var.logger?.warn('Thread not available in workbench execution route');
+			}
+
 			// Handle cases where result might be undefined/null
 			if (result === undefined || result === null) {
 				return ctx.json({ success: true, result: null });
@@ -94,6 +134,97 @@ export const createWorkbenchExecutionRoute = (): Handler => {
 	};
 };
 
+export const createWorkbenchClearStateRoute = (): Handler => {
+	const authHeader = process.env.AGENTUITY_WORKBENCH_APIKEY
+		? `Bearer ${process.env.AGENTUITY_WORKBENCH_APIKEY}`
+		: undefined;
+	return async (ctx: Context) => {
+		// Authentication check
+		if (authHeader) {
+			try {
+				const authValue = ctx.req.header('Authorization');
+				if (
+					!authValue ||
+					!timingSafeEqual(Buffer.from(authValue, 'utf-8'), Buffer.from(authHeader, 'utf-8'))
+				) {
+					return ctx.text('Unauthorized', { status: 401 });
+				}
+			} catch {
+				// timing safe equals will throw if the input/output lengths are mismatched
+				// so we treat all exceptions as invalid
+				return ctx.text('Unauthorized', { status: 401 });
+			}
+		}
+
+		const agentId = ctx.req.query('agentId');
+
+		if (!agentId) {
+			return ctx.json({ error: 'agentId query parameter is required' }, { status: 400 });
+		}
+
+		if (!ctx.var.thread) {
+			return ctx.json({ error: 'Thread not available' }, { status: 404 });
+		}
+
+		const agentMessagesKey = `messages_${agentId}`;
+
+		// Remove the messages for this agent
+		ctx.var.thread.state.delete(agentMessagesKey);
+
+		// Save the thread to persist the cleared state
+		try {
+			const threadProvider = getThreadProvider();
+			await threadProvider.save(ctx.var.thread);
+		} catch {
+			return ctx.json({ error: 'Failed to save thread state' }, { status: 500 });
+		}
+
+		return ctx.json({ success: true, message: `State cleared for agent ${agentId}` });
+	};
+};
+
+export const createWorkbenchStateRoute = (): Handler => {
+	const authHeader = process.env.AGENTUITY_WORKBENCH_APIKEY
+		? `Bearer ${process.env.AGENTUITY_WORKBENCH_APIKEY}`
+		: undefined;
+	return async (ctx: Context) => {
+		// Authentication check
+		if (authHeader) {
+			try {
+				const authValue = ctx.req.header('Authorization');
+				if (
+					!authValue ||
+					!timingSafeEqual(Buffer.from(authValue, 'utf-8'), Buffer.from(authHeader, 'utf-8'))
+				) {
+					return ctx.text('Unauthorized', { status: 401 });
+				}
+			} catch {
+				// timing safe equals will throw if the input/output lengths are mismatched
+				// so we treat all exceptions as invalid
+				return ctx.text('Unauthorized', { status: 401 });
+			}
+		}
+
+		const agentId = ctx.req.query('agentId');
+		if (!agentId) {
+			return ctx.json({ error: 'agentId query parameter is required' }, { status: 400 });
+		}
+
+		if (!ctx.var.thread) {
+			return ctx.json({ error: 'Thread not available' }, { status: 404 });
+		}
+
+		const agentMessagesKey = `messages_${agentId}`;
+		const messages = ctx.var.thread.state.get(agentMessagesKey);
+
+		return ctx.json({
+			threadId: ctx.var.thread.id,
+			agentId,
+			messages: Array.isArray(messages) ? messages : [],
+		});
+	};
+};
+
 /**
  * Creates a workbench router with proper agent middleware for execution routes
  */
@@ -130,15 +261,173 @@ export const createWorkbenchRouter = () => {
 	// Add workbench routes
 	router.websocket('/_agentuity/workbench/ws', createWorkbenchWebsocketRoute());
 	router.get('/_agentuity/workbench/metadata.json', createWorkbenchMetadataRoute());
+	router.get('/_agentuity/workbench/sample', createWorkbenchSampleRoute());
+	router.get('/_agentuity/workbench/state', createWorkbenchStateRoute());
+	router.delete('/_agentuity/workbench/state', createWorkbenchClearStateRoute());
 	router.post('/_agentuity/workbench/execute', createWorkbenchExecutionRoute());
 	return router;
 };
 
+export const createWorkbenchSampleRoute = (): Handler => {
+	const authHeader = process.env.AGENTUITY_WORKBENCH_APIKEY
+		? `Bearer ${process.env.AGENTUITY_WORKBENCH_APIKEY}`
+		: undefined;
+	return async (ctx: Context) => {
+		// Authentication check
+		if (authHeader) {
+			try {
+				const authValue = ctx.req.header('Authorization');
+				if (
+					!authValue ||
+					!timingSafeEqual(Buffer.from(authValue, 'utf-8'), Buffer.from(authHeader, 'utf-8'))
+				) {
+					return ctx.text('Unauthorized', { status: 401 });
+				}
+			} catch {
+				return ctx.text('Unauthorized', { status: 401 });
+			}
+		}
+
+		try {
+			const agentId = ctx.req.query('agentId');
+			if (!agentId) {
+				return ctx.json({ error: 'Missing agentId query parameter' }, { status: 400 });
+			}
+
+			// Read metadata to find agent name by agentId
+			const metadataPath = join(process.cwd(), '.agentuity', 'agentuity.metadata.json');
+			if (!existsSync(metadataPath)) {
+				return ctx.json({ error: 'Metadata file not found' }, { status: 500 });
+			}
+
+			const fileContent = readFileSync(metadataPath, 'utf-8');
+			const metadata = JSON.parse(fileContent);
+			const agentMeta = metadata.agents?.find((a: { agentId: string }) => a.agentId === agentId);
+
+			if (!agentMeta) {
+				return ctx.text('Agent not found', { status: 404 });
+			}
+
+			// Get runtime agent by name
+			const allAgents = getAgents();
+			const agentObj = allAgents.get(agentMeta.name);
+
+			if (!agentObj) {
+				return ctx.text('Agent not found', { status: 404 });
+			}
+
+			// Check if agent has input schema
+			if (!agentObj.inputSchema) {
+				return ctx.json({ error: 'Agent has no input schema' }, { status: 400 });
+			}
+
+			// Convert schema to JSON Schema
+			const jsonSchema = toJSONSchema(agentObj.inputSchema);
+
+			// Get Agentuity SDK key and gateway URL
+			const sdkKey = process.env.AGENTUITY_SDK_KEY;
+			const gatewayUrl =
+				process.env.AGENTUITY_AIGATEWAY_URL ||
+				process.env.AGENTUITY_TRANSPORT_URL ||
+				(sdkKey ? 'https://agentuity.ai' : '');
+
+			if (!sdkKey || !gatewayUrl) {
+				return ctx.json(
+					{
+						error: 'AGENTUITY_SDK_KEY and gateway URL must be configured',
+						message:
+							'Set AGENTUITY_SDK_KEY and either AGENTUITY_AIGATEWAY_URL, AGENTUITY_TRANSPORT_URL, or use https://agentuity.ai',
+					},
+					{ status: 500 }
+				);
+			}
+
+			// Generate sample using Groq via Agentuity Gateway
+			const prompt = `Generate a realistic sample data object that matches this JSON schema. Return only valid JSON, no markdown code blocks or explanations.
+
+JSON Schema:
+${JSON.stringify(jsonSchema, null, 2)}
+
+Return a JSON object that matches this schema with realistic values.`;
+
+			const gatewayEndpoint = `${gatewayUrl}/gateway/groq/openai/v1/chat/completions`;
+			const groqResponse = await fetch(gatewayEndpoint, {
+				method: 'POST',
+				headers: {
+					Authorization: `Bearer ${sdkKey}`,
+					'Content-Type': 'application/json',
+				},
+				body: JSON.stringify({
+					model: 'llama-3.3-70b-versatile',
+					messages: [
+						{
+							role: 'user',
+							content: prompt,
+						},
+					],
+				}),
+			});
+
+			if (!groqResponse.ok) {
+				const errorText = await groqResponse.text();
+				return ctx.json(
+					{
+						error: 'Groq API request failed',
+						message: `Status ${groqResponse.status}: ${errorText}`,
+					},
+					{ status: 500 }
+				);
+			}
+
+			const groqData = (await groqResponse.json()) as {
+				choices?: Array<{ message?: { content?: string } }>;
+			};
+			const text = groqData.choices?.[0]?.message?.content;
+			if (!text) {
+				return ctx.json(
+					{ error: 'Invalid response from Groq API', response: groqData },
+					{ status: 500 }
+				);
+			}
+
+			// Parse the JSON response
+			let sample: unknown;
+			try {
+				// Remove markdown code blocks if present
+				const cleanedText = text
+					.trim()
+					.replace(/^```json\s*|\s*```$/g, '')
+					.replace(/^```\s*|\s*```$/g, '');
+				sample = JSON.parse(cleanedText);
+			} catch (parseError) {
+				return ctx.json(
+					{
+						error: 'Failed to parse generated JSON',
+						message: parseError instanceof Error ? parseError.message : String(parseError),
+						generatedText: text,
+					},
+					{ status: 500 }
+				);
+			}
+
+			return ctx.json(sample);
+		} catch (error) {
+			return ctx.json(
+				{
+					error: 'Internal server error',
+					message: error instanceof Error ? error.message : String(error),
+				},
+				{ status: 500 }
+			);
+		}
+	};
+};
+
 export const createWorkbenchMetadataRoute = (): Handler => {
 	const authHeader = process.env.AGENTUITY_WORKBENCH_APIKEY
 		? `Bearer ${process.env.AGENTUITY_WORKBENCH_APIKEY}`
 		: undefined;
-	const agents = getAgents();
+
 	return async (ctx) => {
 		if (authHeader) {
 			try {
@@ -155,27 +444,75 @@ export const createWorkbenchMetadataRoute = (): Handler => {
 				return ctx.text('Unauthorized', { status: 401 });
 			}
 		}
-		const schemas: { agents: Record<string, unknown> } = { agents: {} };
-		for (const [, agent] of agents) {
-			schemas.agents[agent.metadata.id] = {
-				schema: {
-					input: agent.inputSchema
-						? {
-								code: agent.metadata.inputSchemaCode || undefined,
-								json: toJSONSchema(agent.inputSchema),
-							}
-						: undefined,
-					output: agent.outputSchema
-						? {
-								code: agent.metadata.outputSchemaCode || undefined,
-								json: toJSONSchema(agent.outputSchema),
-							}
-						: undefined,
+
+		// Read metadata from agentuity.metadata.json file
+		const metadataPath = join(process.cwd(), '.agentuity', 'agentuity.metadata.json');
+
+		if (!existsSync(metadataPath)) {
+			return ctx.json(
+				{ error: 'Metadata file not found. Run build to generate metadata.' },
+				{ status: 500 }
+			);
+		}
+
+		try {
+			const fileContent = readFileSync(metadataPath, 'utf-8');
+			const metadata = JSON.parse(fileContent);
+
+			// Get runtime agents for JSON schema generation
+			const agents = getAgents();
+			const agentsByName = new Map();
+			for (const [name, agent] of agents) {
+				agentsByName.set(name, agent);
+			}
+
+			// Transform metadata structure to workbench format
+			const schemas: { agents: Record<string, unknown> } = { agents: {} };
+
+			for (const agent of metadata.agents || []) {
+				// Try to find runtime agent by name to get JSON schemas
+				const runtimeAgent = agentsByName.get(agent.name);
+
+				schemas.agents[agent.id] = {
+					schema: {
+						input: agent.schema?.input
+							? {
+									code: agent.schema.input,
+									json: runtimeAgent?.inputSchema
+										? toJSONSchema(runtimeAgent.inputSchema)
+										: undefined,
+								}
+							: undefined,
+						output: agent.schema?.output
+							? {
+									code: agent.schema.output,
+									json: runtimeAgent?.outputSchema
+										? toJSONSchema(runtimeAgent.outputSchema)
+										: undefined,
+								}
+							: undefined,
+					},
+					metadata: {
+						id: agent.id,
+						agentId: agent.agentId,
+						name: agent.name,
+						description: agent.description,
+						filename: agent.filename,
+						version: agent.version,
+					},
+				};
+			}
+
+			return ctx.json(schemas);
+		} catch (error) {
+			return ctx.json(
+				{
+					error: 'Failed to read metadata file',
+					message: error instanceof Error ? error.message : String(error),
 				},
-				metadata: agent.metadata,
-			};
+				{ status: 500 }
+			);
 		}
-		return ctx.json(schemas);
 	};
 };