@agentuity/workbench 0.0.104 → 0.0.106

package/src/hooks/useAgentSchemas.ts

@@ -1,5 +1,5 @@
-import { JSONSchema7 } from 'ai';
-import { useState, useEffect, useCallback } from 'react';
+import type { JSONSchema7 } from 'ai';
+import { useCallback, useEffect, useState } from 'react';
 
 export interface AgentSchema {
 	input?: {
@@ -13,18 +13,18 @@ export interface AgentSchema {
 }
 
 export interface AgentMetadata {
-	id: string;
-	name: string;
+	agentId: string;
 	description?: string;
-	version?: string;
 	filename?: string;
+	id: string;
 	identifier?: string;
-	agentId: string;
+	name: string;
+	version?: string;
 }
 
 export interface AgentSchemaData {
-	schema: AgentSchema;
 	metadata: AgentMetadata;
+	schema: AgentSchema;
 }
 
 export interface AgentSchemasResponse {
@@ -32,15 +32,15 @@ export interface AgentSchemasResponse {
 }
 
 export interface UseAgentSchemasOptions {
-	baseUrl?: string;
 	apiKey?: string;
+	baseUrl?: string;
 	enabled?: boolean;
 }
 
 export interface UseAgentSchemasResult {
 	data: AgentSchemasResponse | null;
-	isLoading: boolean;
 	error: Error | null;
+	isLoading: boolean;
 	refetch: () => void;
 }
 
@@ -84,7 +84,7 @@ export function useAgentSchemas(options: UseAgentSchemasOptions = {}): UseAgentS
 			};
 
 			if (apiKey) {
-				headers['Authorization'] = `Bearer ${apiKey}`;
+				headers.Authorization = `Bearer ${apiKey}`;
 			}
 
 			const response = await fetch(url, {
@@ -96,26 +96,35 @@ export function useAgentSchemas(options: UseAgentSchemasOptions = {}): UseAgentS
 				// Handle 404/500 gracefully without throwing
 				if (response.status === 401) {
 					setError(new Error('Unauthorized: Invalid or missing API key'));
+
 					return;
 				}
+
 				if (response.status === 404 || response.status >= 500) {
 					setError(new Error(`Server error: ${response.status} ${response.statusText}`));
+
 					return;
 				}
+
 				setError(new Error(`HTTP ${response.status}: ${response.statusText}`));
+
 				return;
 			}
 
 			try {
 				const result = (await response.json()) as AgentSchemasResponse;
+
 				setData(result);
 			} catch (jsonError) {
 				setError(new Error('Invalid JSON response from server'));
+
 				console.error('Failed to parse JSON response:', jsonError);
 			}
 		} catch (err) {
 			const error = err instanceof Error ? err : new Error('Unknown error occurred');
+
 			setError(error);
+
 			console.error('Failed to fetch agent schemas:', error);
 		} finally {
 			setIsLoading(false);
@@ -132,8 +141,8 @@ export function useAgentSchemas(options: UseAgentSchemasOptions = {}): UseAgentS
 
 	return {
 		data,
-		isLoading,
 		error,
+		isLoading,
 		refetch,
 	};
 }
@@ -148,10 +157,10 @@ export function useAgentSchema(agentName: string, options: UseAgentSchemasOption
 
 	return {
 		data: agentData,
-		isLoading,
 		error,
+		isLoading,
+		metadata: agentData?.metadata || null,
 		refetch,
 		schema: agentData?.schema || null,
-		metadata: agentData?.metadata || null,
 	};
 }

package/src/hooks/useLogger.ts

@@ -12,9 +12,11 @@ interface Logger {
 const getLogLevel = (): LogLevel | null => {
 	try {
 		const level = localStorage.getItem('AGENTUITY_LOG_LEVEL');
+
 		if (level && ['debug', 'info', 'warn', 'error'].includes(level)) {
 			return level as LogLevel;
 		}
+
 		return null;
 	} catch {
 		return null;
@@ -23,6 +25,7 @@ const getLogLevel = (): LogLevel | null => {
 
 const shouldLog = (messageLevel: LogLevel): boolean => {
 	const currentLevel = getLogLevel();
+
 	if (!currentLevel) return false;
 
 	const levels: Record<LogLevel, number> = {
@@ -39,10 +42,13 @@ export function useLogger(component?: string): Logger {
 	const createLogFunction = useCallback(
 		(level: LogLevel) =>
 			(...args: unknown[]) => {
-				if (!shouldLog(level)) return;
+				if (!shouldLog(level)) {
+					return;
+				}
 
 				const prefix = component ? `[${component}]` : '[Workbench]';
 				const consoleFn = console[level] || console.log;
+
 				consoleFn(prefix, ...args);
 			},
 		[component]

package/src/hooks/useWorkbenchWebsocket.ts

@@ -1,22 +1,22 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
 
 interface ReconnectOptions {
-	onReconnect: () => void;
-	threshold?: number;
 	baseDelay?: number;
+	enabled?: () => boolean;
 	factor?: number;
-	maxDelay?: number;
 	jitter?: number;
-	enabled?: () => boolean;
+	maxDelay?: number;
+	onReconnect: () => void;
+	threshold?: number;
 }
 
 interface ReconnectManager {
-	recordFailure: () => { scheduled: boolean; delay: number | null };
-	recordSuccess: () => void;
 	cancel: () => void;
-	reset: () => void;
 	dispose: () => void;
 	getAttempts: () => number;
+	recordFailure: () => { scheduled: boolean; delay: number | null };
+	recordSuccess: () => void;
+	reset: () => void;
 }
 
 function createReconnectManager(opts: ReconnectOptions): ReconnectManager {
@@ -26,12 +26,14 @@ function createReconnectManager(opts: ReconnectOptions): ReconnectManager {
 	const cancel = () => {
 		if (timer) {
 			clearTimeout(timer);
+
 			timer = null;
 		}
 	};
 
 	const reset = () => {
 		attempts = 0;
+
 		cancel();
 	};
 
@@ -42,14 +44,17 @@ function createReconnectManager(opts: ReconnectOptions): ReconnectManager {
 		const factor = opts.factor ?? 2;
 		const max = opts.maxDelay ?? 30000;
 		const jitterMax = opts.jitter ?? 250;
-		const backoff = Math.min(base * Math.pow(factor, attemptAfterThreshold), max);
+		const backoff = Math.min(base * factor ** attemptAfterThreshold, max);
 		const jitter = jitterMax > 0 ? Math.random() * jitterMax : 0;
+
 		return backoff + jitter;
 	};
 
 	const recordFailure = () => {
 		attempts += 1;
+
 		const threshold = opts.threshold ?? 0;
+
 		if (opts.enabled && !opts.enabled()) {
 			return { scheduled: false, delay: null };
 		}
@@ -57,13 +62,18 @@ function createReconnectManager(opts: ReconnectOptions): ReconnectManager {
 		if (attempts - threshold >= 0) {
 			const after = Math.max(0, attempts - threshold);
 			const delay = computeDelay(after);
+
 			cancel();
+
 			timer = setTimeout(() => {
 				if (opts.enabled && !opts.enabled()) return;
+
 				opts.onReconnect();
 			}, delay);
+
 			return { scheduled: true, delay };
 		}
+
 		return { scheduled: false, delay: null };
 	};
 
@@ -75,12 +85,12 @@ function createReconnectManager(opts: ReconnectOptions): ReconnectManager {
 }
 
 export interface UseWorkbenchWebsocketOptions {
-	baseUrl?: string;
 	apiKey?: string;
+	baseUrl?: string;
 	enabled?: boolean;
+	onAlive?: () => void;
 	onConnect?: () => void;
 	onReconnect?: () => void;
-	onAlive?: () => void;
 	onRestarting?: () => void;
 }
 
@@ -94,47 +104,59 @@ export function useWorkbenchWebsocket(
 ): UseWorkbenchWebsocketResult {
 	const { baseUrl, apiKey, onConnect, onReconnect, onAlive, onRestarting } = options;
 
+	const [connected, setConnected] = useState(false);
+	const [error, setError] = useState<Error | null>(null);
+
+	const hasConnectedOnce = useRef(false);
 	const manualClose = useRef(false);
-	const wsRef = useRef<WebSocket | undefined>(undefined);
-	const reconnectManagerRef = useRef<ReturnType<typeof createReconnectManager> | undefined>(
-		undefined
-	);
+	const onAliveRef = useRef(onAlive);
 	const onConnectRef = useRef(onConnect);
 	const onReconnectRef = useRef(onReconnect);
-	const onAliveRef = useRef(onAlive);
 	const onRestartingRef = useRef(onRestarting);
-	const hasConnectedOnce = useRef(false);
-
-	const [connected, setConnected] = useState(false);
-	const [error, setError] = useState<Error | null>(null);
+	const reconnectManagerRef = useRef<ReturnType<typeof createReconnectManager> | undefined>(
+		undefined
+	);
+	const wsRef = useRef<WebSocket | undefined>(undefined);
 
 	// Update refs when callbacks change
 	useEffect(() => {
+		onAliveRef.current = onAlive;
 		onConnectRef.current = onConnect;
 		onReconnectRef.current = onReconnect;
-		onAliveRef.current = onAlive;
 		onRestartingRef.current = onRestarting;
 	}, [onConnect, onReconnect, onAlive, onRestarting]);
 
 	const wsUrl = useCallback(() => {
-		if (!baseUrl) return null;
+		if (!baseUrl) {
+			return null;
+		}
+
 		const wsBase = baseUrl.replace(/^http(s?):/, 'ws$1:');
 		const url = new URL(`${wsBase}/_agentuity/workbench/ws`);
+
 		if (apiKey) {
 			url.searchParams.set('apiKey', apiKey);
 		}
+
 		return url.toString();
 	}, [baseUrl, apiKey]);
 
 	const connect = useCallback(() => {
-		if (manualClose.current || !options.enabled) return;
+		if (manualClose.current || !options.enabled) {
+			return;
+		}
+
 		const url = wsUrl();
-		if (!url) return;
+
+		if (!url) {
+			return;
+		}
 
 		wsRef.current = new WebSocket(url);
 
 		wsRef.current.onopen = () => {
 			reconnectManagerRef.current?.recordSuccess();
+
 			setConnected(true);
 			setError(null);
 
@@ -153,13 +175,17 @@ export function useWorkbenchWebsocket(
 
 		wsRef.current.onclose = (evt) => {
 			wsRef.current = undefined;
+
 			setConnected(false);
+
 			if (manualClose.current) {
 				return;
 			}
+
 			if (evt.code !== 1000) {
 				setError(new Error(`WebSocket closed: ${evt.code} ${evt.reason || ''}`));
 			}
+
 			reconnectManagerRef.current?.recordFailure();
 		};
 
@@ -172,41 +198,50 @@ export function useWorkbenchWebsocket(
 				onRestartingRef.current?.();
 			}
 		};
-	}, [wsUrl]);
+	}, [wsUrl, options.enabled]);
 
 	useEffect(() => {
 		reconnectManagerRef.current = createReconnectManager({
-			onReconnect: connect,
-			threshold: 0,
 			baseDelay: 500,
+			enabled: () => !manualClose.current && !!baseUrl,
 			factor: 2,
-			maxDelay: 30000,
 			jitter: 500,
-			enabled: () => !manualClose.current && !!baseUrl,
+			maxDelay: 30000,
+			onReconnect: connect,
+			threshold: 0,
 		});
+
 		return () => reconnectManagerRef.current?.dispose();
 	}, [connect, baseUrl]);
 
 	const cleanup = useCallback(() => {
 		manualClose.current = true;
+
 		reconnectManagerRef.current?.dispose();
+
 		const ws = wsRef.current;
+
 		if (ws) {
-			ws.onopen = null;
-			ws.onerror = null;
+			ws.close();
 			ws.onclose = null;
+			ws.onerror = null;
 			ws.onmessage = null;
-			ws.close();
+			ws.onopen = null;
 		}
+
 		wsRef.current = undefined;
+
 		setConnected(false);
 		// Don't reset hasConnectedOnce here - we want to track if we've ever connected
 	}, []);
 
 	useEffect(() => {
-		if (!baseUrl) return;
+		if (!baseUrl) {
+			return;
+		}
 
 		manualClose.current = false;
+
 		connect();
 
 		return () => {

package/src/index.ts

@@ -1,12 +1,8 @@
-// Export types
+export { default as App } from './components/App';
+export { Chat } from './components/internal/chat';
+export { StatusIndicator } from './components/internal/header';
+export { Schema } from './components/internal/schema';
+export { useWorkbench, WorkbenchProvider } from './components/internal/workbench-provider';
 export type { WorkbenchInstance } from './types';
 export type { ConnectionStatus } from './types/config';
-
-// Export components
-export { default as App } from './components/App';
-export { Chat } from './components/internal/Chat';
-export { Schema } from './components/internal/Schema';
-export { StatusIndicator } from './components/internal/Header';
-export { WorkbenchProvider, useWorkbench } from './components/internal/WorkbenchProvider';
-// Export workbench functions
 export { createWorkbench } from './workbench';

package/src/lib/utils.ts

@@ -1,5 +1,6 @@
 import { type ClassValue, clsx } from 'clsx';
 import { twMerge } from 'tailwind-merge';
+import type { ErrorInfo } from '@/types/config';
 
 export function cn(...inputs: ClassValue[]) {
 	return twMerge(clsx(inputs));
@@ -19,8 +20,10 @@ export function parseTokensHeader(header: string): Record<string, number> {
 
 	for (const entry of entries) {
 		const [model, countStr] = entry.split(':').map((s) => s.trim());
+
 		if (model && countStr) {
 			const count = Number.parseInt(countStr, 10);
+
 			if (!Number.isNaN(count)) {
 				result[model] = count;
 			}
@@ -44,9 +47,11 @@ export const getProcessEnv = (key: string): string | undefined => {
 	if (typeof import.meta.env !== 'undefined') {
 		return import.meta.env[key];
 	}
+
 	if (typeof process !== 'undefined' && process.env) {
 		return process.env[key];
 	}
+
 	return undefined;
 };
 
@@ -57,14 +62,19 @@ export const buildUrl = (
 	query?: URLSearchParams
 ): string => {
 	path = path.startsWith('/') ? path : `/${path}`;
+
 	let url = base.replace(/\/$/, '') + path;
+
 	if (subpath) {
 		subpath = subpath.startsWith('/') ? subpath : `/${subpath}`;
+
 		url += subpath;
 	}
+
 	if (query) {
 		url += `?${query.toString()}`;
 	}
+
 	return url;
 };
 
@@ -80,3 +90,81 @@ export const defaultBaseUrl: string =
 	getProcessEnv('AGENTUITY_URL') ||
 	tryOrigin() ||
 	'http://localhost:3500';
+
+type SchemaLike = {
+	type?: string | string[];
+	properties?: Record<string, unknown>;
+	[key: string]: unknown;
+};
+
+function generateEmptyValueForSchema(schema: unknown): unknown {
+	if (typeof schema === 'boolean') {
+		return schema ? {} : undefined;
+	}
+
+	if (typeof schema !== 'object' || schema === null) {
+		return '';
+	}
+
+	const s = schema as SchemaLike;
+	const type = s.type;
+
+	if (Array.isArray(type)) {
+		return generateEmptyValueForSchema({ ...s, type: type[0] });
+	}
+
+	switch (type) {
+		case 'string':
+			return '';
+		case 'number':
+		case 'integer':
+			return 0;
+		case 'boolean':
+			return false;
+		case 'null':
+			return null;
+		case 'array':
+			return [];
+		case 'object': {
+			const result: Record<string, unknown> = {};
+
+			if (s.properties) {
+				for (const [key, propSchema] of Object.entries(s.properties)) {
+					result[key] = generateEmptyValueForSchema(propSchema);
+				}
+			}
+
+			return result;
+		}
+		default:
+			if (s.properties) {
+				const result: Record<string, unknown> = {};
+
+				for (const [key, propSchema] of Object.entries(s.properties)) {
+					result[key] = generateEmptyValueForSchema(propSchema);
+				}
+
+				return result;
+			}
+
+			return '';
+	}
+}
+
+export function generateTemplateFromSchema(schema?: unknown): string {
+	if (!schema) return '{}';
+
+	const template = generateEmptyValueForSchema(schema);
+
+	return JSON.stringify(template, null, 2);
+}
+
+export function formatErrorForCopy(error: ErrorInfo): string {
+	return [
+		error.code ? `[${error.code}] ${error.message}` : error.message,
+		error.stack,
+		error.cause ? `Cause: ${JSON.stringify(error.cause, null, 2)}` : null,
+	]
+		.filter(Boolean)
+		.join('\n\n');
+}

package/src/server.ts

@@ -2,5 +2,5 @@
 // This file exports only the server-side createWorkbench function
 // without pulling in browser-side React components
 
-export { createWorkbench } from './workbench';
 export type { WorkbenchInstance } from './types';
+export { createWorkbench } from './workbench';

package/src/types/config.ts

@@ -1,39 +1,46 @@
-import type { UIMessage } from 'ai';
 import type { WorkbenchConfig } from '@agentuity/core/workbench';
+import type { UIMessage } from 'ai';
 import type { AgentSchemaData, AgentSchemasResponse } from '../hooks/useAgentSchemas';
 
 export interface Agent {
+	avatar?: string;
+	description?: string;
 	id: string;
 	name: string;
-	description?: string;
-	avatar?: string;
 }
 
 export type ConnectionStatus = 'connected' | 'restarting' | 'disconnected';
 
 // Context type for the provider
 export interface WorkbenchContextType {
-	config: WorkbenchConfig;
 	agents: Record<string, AgentSchemaData>;
-	suggestions: string[];
-	messages: UIMessage[];
-	setMessages: (messages: UIMessage[] | ((prev: UIMessage[]) => UIMessage[])) => void;
-	selectedAgent: string;
-	setSelectedAgent: (agentId: string) => void;
-	inputMode: 'text' | 'form';
-	setInputMode: (mode: 'text' | 'form') => void;
-	isLoading: boolean;
-	submitMessage: (value: string, mode?: 'text' | 'form') => Promise<void>;
+	clearAgentState: (agentId: string) => Promise<void>;
+	config: WorkbenchConfig;
+	connectionStatus: ConnectionStatus;
+	env: {
+		agentuity: boolean;
+		authenticated: boolean;
+		cloud: boolean;
+	};
 	generateSample: (agentId: string) => Promise<string>;
+	inputMode: 'text' | 'form';
 	isGeneratingSample: boolean;
-	isAuthenticated: boolean;
-	// Schema data from API
+	isLoading: boolean;
+	messages: UIMessage[];
+	refetchSchemas: () => void;
 	schemas: AgentSchemasResponse | null;
-	schemasLoading: boolean;
 	schemasError: Error | null;
-	refetchSchemas: () => void;
-	// Connection status
-	connectionStatus: ConnectionStatus;
-	// Clear agent state
-	clearAgentState: (agentId: string) => Promise<void>;
+	schemasLoading: boolean;
+	selectedAgent: string;
+	setInputMode: (mode: 'text' | 'form') => void;
+	setMessages: (messages: UIMessage[] | ((prev: UIMessage[]) => UIMessage[])) => void;
+	setSelectedAgent: (agentId: string) => void;
+	submitMessage: (value: string, mode?: 'text' | 'form') => Promise<void>;
+}
+
+export interface ErrorInfo {
+	message: string;
+	stack?: string;
+	code?: string;
+	cause?: unknown;
 }

package/dist/components/internal/Chat.d.ts

@@ -1,14 +0,0 @@
-import React from 'react';
-export interface ChatProps {
-    className?: string;
-    schemaOpen: boolean;
-    onSchemaToggle: () => void;
-    emptyState?: React.ReactNode;
-}
-/**
- * Chat component - conversation and input area (everything except header)
- * Must be used within WorkbenchProvider
- */
-export declare function Chat({ className: _className, schemaOpen, onSchemaToggle, emptyState }: ChatProps): import("react/jsx-runtime").JSX.Element;
-export default Chat;
-//# sourceMappingURL=Chat.d.ts.map

package/dist/components/internal/Chat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Chat.d.ts","sourceRoot":"","sources":["../../../src/components/internal/Chat.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAmB,MAAM,OAAO,CAAC;AAexC,MAAM,WAAW,SAAS;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;IACpB,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,UAAU,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC7B;AAED;;;GAGG;AACH,wBAAgB,IAAI,CAAC,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,cAAc,EAAE,UAAU,EAAE,EAAE,SAAS,2CA0KhG;AAED,eAAe,IAAI,CAAC"}