@agentuity/runtime 1.0.59 → 2.0.0-beta.1

package/src/version-check.ts

@@ -0,0 +1,155 @@
+/**
+ * Version consistency check for @agentuity/* packages.
+ *
+ * Logs a warning if there are mismatched major versions across SDK packages
+ * at runtime startup. This helps developers catch version conflicts early.
+ */
+
+import type { Logger } from './logger';
+import { isV1Package, showDeprecationWarning } from '@agentuity/core';
+
+/**
+ * Known @agentuity/* packages that should have consistent versions.
+ */
+const KNOWN_PACKAGES = [
+	'@agentuity/core',
+	'@agentuity/runtime',
+	'@agentuity/server',
+	'@agentuity/frontend',
+	'@agentuity/react',
+	'@agentuity/schema',
+	'@agentuity/auth',
+	'@agentuity/postgres',
+	'@agentuity/drizzle',
+	'@agentuity/evals',
+	'@agentuity/workbench',
+	'@agentuity/queue',
+	'@agentuity/webhook',
+	'@agentuity/schedule',
+	'@agentuity/task',
+	'@agentuity/keyvalue',
+	'@agentuity/vector',
+	'@agentuity/stream',
+];
+
+interface PackageVersion {
+	name: string;
+	version: string;
+	major: number;
+}
+
+/**
+ * Extract major version from semver string.
+ */
+function extractMajor(version: string): number {
+	const match = version.match(/^(\d+)\.\d+\.\d+/);
+	return match && match[1] ? parseInt(match[1], 10) : 0;
+}
+
+/**
+ * Get version of a package from its package.json (if importable).
+ */
+function getPackageVersion(packageName: string): string | null {
+	try {
+		// Try to import the package.json
+		// This works for ESM packages that export their package.json
+		const pkg = require(`${packageName}/package.json`);
+		return pkg?.version || null;
+	} catch {
+		// Fallback: try to read from node_modules
+		try {
+			const fs = require('node:fs');
+			const pkgPath = require.resolve(`${packageName}/package.json`);
+			if (typeof pkgPath !== 'string') {
+				return null;
+			}
+			const pkgJson = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+			return pkgJson?.version || null;
+		} catch {
+			return null;
+		}
+	}
+}
+
+/**
+ * Check for version consistency across @agentuity/* packages.
+ *
+ * @param logger - Logger instance to use for warnings
+ */
+export function checkVersionConsistency(logger: Logger): void {
+	// Skip in development if flag is set (for testing)
+	if (process.env.AGENTUITY_SKIP_VERSION_CHECK === 'true') {
+		return;
+	}
+
+	// Show deprecation warning for v1 packages
+	showDeprecationWarning(logger);
+
+	// Collect versions of loaded packages
+	const versions: PackageVersion[] = [];
+
+	for (const name of KNOWN_PACKAGES) {
+		const version = getPackageVersion(name);
+		if (version) {
+			versions.push({
+				name,
+				version,
+				major: extractMajor(version),
+			});
+		}
+	}
+
+	// Need at least 2 packages to check consistency
+	if (versions.length < 2) {
+		return;
+	}
+
+	// Check for major version mismatches
+	const majors = new Set(versions.map((v) => v.major));
+	if (majors.size <= 1) {
+		return; // All packages have the same major version
+	}
+
+	// Find the most common major version
+	const majorCounts = new Map<number, number>();
+	for (const v of versions) {
+		majorCounts.set(v.major, (majorCounts.get(v.major) || 0) + 1);
+	}
+	const sortedMajors = [...majorCounts.entries()].sort((a, b) => b[1] - a[1]);
+	const expectedMajor = sortedMajors[0]?.[0] ?? 2;
+
+	// Find mismatched packages
+	const mismatched = versions.filter((v) => v.major !== expectedMajor);
+
+	if (mismatched.length === 0) {
+		return;
+	}
+
+	// Log warning
+	const mismatchedList = mismatched.map((v) => `${v.name}@${v.version}`).join('\n    ');
+
+	logger.warn(
+		'Version mismatch detected: Some @agentuity/* packages have different major versions.\n' +
+			'    This may cause unexpected behavior.\n' +
+			'\n' +
+			'    Expected: v' +
+			expectedMajor +
+			'\n' +
+			'    Mismatched:\n' +
+			'    ' +
+			mismatchedList +
+			'\n' +
+			'\n' +
+			'    Run `bun install` to sync versions, or pin all @agentuity/* packages\n' +
+			'    to the same major version in your package.json.'
+	);
+}
+
+/**
+ * Check if the project is using v1 SDK packages.
+ *
+ * @returns true if any v1 packages are detected
+ */
+export function hasV1Packages(): boolean {
+	return isV1Package();
+}

package/src/workbench.ts

@@ -1,5 +1,6 @@
 import type { Context, Handler, MiddlewareHandler } from 'hono';
 import { toJSONSchema } from '@agentuity/server';
+import type { JSONSchema } from '@agentuity/schema';
 import { getAgents, createAgentMiddleware } from './agent';
 import { createRouter } from './router';
 import { websocket, type WebSocketConnection } from './handlers/websocket';
@@ -519,24 +520,31 @@ export const createWorkbenchMetadataRoute = (): Handler => {
 				// Try to find runtime agent by name to get JSON schemas
 				const runtimeAgent = agentsByName.get(agent.name);
 
+				const inputJsonSchema = runtimeAgent?.inputSchema
+					? toJSONSchema(runtimeAgent.inputSchema)
+					: undefined;
+				const outputJsonSchema = runtimeAgent?.outputSchema
+					? toJSONSchema(runtimeAgent.outputSchema)
+					: undefined;
+
 				schemas.agents[agent.id] = {
 					schema: {
-						input: agent.schema?.input
+						input: inputJsonSchema
 							? {
-									code: agent.schema.input,
-									json: runtimeAgent?.inputSchema
-										? toJSONSchema(runtimeAgent.inputSchema)
-										: undefined,
+									code: jsonSchemaToTypeScript(inputJsonSchema),
+									json: inputJsonSchema,
 								}
-							: undefined,
-						output: agent.schema?.output
+							: agent.schema?.input
+								? { code: agent.schema.input, json: undefined }
+								: undefined,
+						output: outputJsonSchema
 							? {
-									code: agent.schema.output,
-									json: runtimeAgent?.outputSchema
-										? toJSONSchema(runtimeAgent.outputSchema)
-										: undefined,
+									code: jsonSchemaToTypeScript(outputJsonSchema),
+									json: outputJsonSchema,
 								}
-							: undefined,
+							: agent.schema?.output
+								? { code: agent.schema.output, json: undefined }
+								: undefined,
 					},
 					metadata: {
 						id: agent.id,
@@ -600,3 +608,118 @@ export const createWorkbenchWebsocketHandler = () => {
  * @deprecated Use createWorkbenchWebsocketHandler instead
  */
 export const createWorkbenchWebsocketRoute = createWorkbenchWebsocketHandler;
+
+/**
+ * Convert a JSON Schema object to a TypeScript type string for display.
+ * Produces clean, readable type notation for the workbench schema panel.
+ *
+ * @example
+ * ```typescript
+ * jsonSchemaToTypeScript({
+ *   type: 'object',
+ *   properties: { name: { type: 'string' }, age: { type: 'number' } },
+ *   required: ['name', 'age'],
+ * });
+ * // "{\n  name: string;\n  age: number;\n}"
+ * ```
+ */
+/** Escape a string for use inside a double-quoted TypeScript string literal. */
+function escapeString(s: string): string {
+	return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r');
+}
+
+/** Check if a property key is a valid unquoted TypeScript identifier. */
+function isValidIdentifier(key: string): boolean {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key);
+}
+
+function jsonSchemaToTypeScript(schema: JSONSchema, indent = 0): string {
+	const pad = '  '.repeat(indent);
+	const inner = '  '.repeat(indent + 1);
+
+	// Handle const (literal type)
+	if (schema.const !== undefined) {
+		return typeof schema.const === 'string'
+			? `"${escapeString(schema.const)}"`
+			: String(schema.const);
+	}
+
+	// Handle enum (union of literals)
+	if (schema.enum) {
+		return schema.enum
+			.map((v) => (typeof v === 'string' ? `"${escapeString(String(v))}"` : String(v)))
+			.join(' | ');
+	}
+
+	// Handle anyOf / oneOf (union types)
+	const unionSchemas = schema.anyOf ?? schema.oneOf;
+	if (unionSchemas) {
+		// Nullable pattern: anyOf with one type and one null
+		if (unionSchemas.length === 2) {
+			const nullIdx = unionSchemas.findIndex((s) => s.type === 'null');
+			if (nullIdx !== -1) {
+				const other = unionSchemas[nullIdx === 0 ? 1 : 0];
+				if (other) {
+					return `${jsonSchemaToTypeScript(other, indent)} | null`;
+				}
+			}
+		}
+		return unionSchemas.map((s) => jsonSchemaToTypeScript(s, indent)).join(' | ');
+	}
+
+	// Handle allOf (intersection types)
+	if (schema.allOf) {
+		return schema.allOf.map((s) => jsonSchemaToTypeScript(s, indent)).join(' & ');
+	}
+
+	switch (schema.type) {
+		case 'string':
+			return 'string';
+		case 'number':
+		case 'integer':
+			return 'number';
+		case 'boolean':
+			return 'boolean';
+		case 'null':
+			return 'null';
+
+		case 'array': {
+			if (!schema.items) return 'unknown[]';
+			const itemType = jsonSchemaToTypeScript(schema.items, indent);
+			// Wrap union types in parens: (A | B)[]
+			return itemType.includes(' | ') ? `(${itemType})[]` : `${itemType}[]`;
+		}
+
+		case 'object': {
+			if (!schema.properties || Object.keys(schema.properties).length === 0) {
+				if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+					return `Record<string, ${jsonSchemaToTypeScript(schema.additionalProperties, indent)}>`;
+				}
+				return 'Record<string, unknown>';
+			}
+
+			const required = new Set(schema.required ?? []);
+			const lines: string[] = ['{'];
+
+			for (const [key, propSchema] of Object.entries(schema.properties)) {
+				const optional = !required.has(key);
+				const propType = jsonSchemaToTypeScript(propSchema, indent + 1);
+				const desc = propSchema.description ? ` // ${propSchema.description}` : '';
+				const quotedKey = isValidIdentifier(key) ? key : `"${escapeString(key)}"`;
+				lines.push(`${inner}${quotedKey}${optional ? '?' : ''}: ${propType};${desc}`);
+			}
+
+			lines.push(`${pad}}`);
+			return lines.join('\n');
+		}
+
+		default:
+			if (schema.properties) {
+				return jsonSchemaToTypeScript({ ...schema, type: 'object' }, indent);
+			}
+			if (schema.items) {
+				return jsonSchemaToTypeScript({ ...schema, type: 'array' }, indent);
+			}
+			return 'unknown';
+	}
+}