@roj-ai/sdk 0.0.2

package/src/transport/http/routes/rpc.test.ts

@@ -0,0 +1,372 @@
+/**
+ * RPC Routes Tests
+ */
+import { beforeEach, describe, expect, it } from 'bun:test'
+import { Hono } from 'hono'
+import { ModelId } from '~/core/llm/schema.js'
+import type { Preset } from '~/core/preset/index.js'
+import { createSessionManager } from '../../../bootstrap.js'
+import { bootstrapForTesting } from '../../../testing/bootstrap-for-testing.js'
+import type { AppEnv, AppServices } from '../app.js'
+import { createRpcRoutes } from './rpc.js'
+
+/** Minimal preset for testing */
+const echoTestPreset: Preset = {
+	id: 'echo-test',
+	name: 'Echo Test',
+	orchestrator: {
+		system: 'Test',
+		tools: [],
+		agents: ['echo'],
+		model: ModelId('mock'),
+	},
+	agents: [{
+		name: 'echo',
+		system: 'Echo',
+		tools: [],
+		agents: [],
+		model: ModelId('mock'),
+	}],
+}
+
+// Helper type for RPC responses (new { ok, value/error } format)
+interface RpcOkResponse<T> {
+	ok: true
+	value: T
+}
+
+interface RpcErrResponse {
+	ok: false
+	error: { type: string; message: string }
+}
+
+type RpcResponse<T> = RpcOkResponse<T> | RpcErrResponse
+
+// Helper to parse JSON response with proper typing
+async function parseJson<T>(res: Response): Promise<RpcResponse<T>> {
+	return res.json() as Promise<RpcResponse<T>>
+}
+
+describe('RPC Routes', () => {
+	let app: Hono<AppEnv>
+	let services: AppServices
+
+	beforeEach(() => {
+		const baseServices = bootstrapForTesting(undefined, [echoTestPreset])
+
+		const sessionManager = createSessionManager(baseServices)
+
+		services = {
+			...baseServices,
+			sessionRuntime: sessionManager,
+		}
+
+		// Create Hono app with RPC routes
+		app = new Hono<AppEnv>()
+		app.use('*', async (c, next) => {
+			c.set('services', services)
+			await next()
+		})
+		app.route('/rpc', createRpcRoutes())
+	})
+
+	describe('Request validation', () => {
+		it('should return error for invalid JSON', async () => {
+			const res = await app.request('/rpc', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: 'invalid json',
+			})
+
+			expect(res.status).toBe(400)
+			const json = await parseJson<never>(res)
+			expect(json.ok).toBe(false)
+			expect(!json.ok && json.error.type).toBe('invalid_json')
+		})
+
+		it('should return error for missing method', async () => {
+			const res = await app.request('/rpc', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({ input: {} }),
+			})
+
+			expect(res.status).toBe(400)
+			const json = await parseJson<never>(res)
+			expect(json.ok).toBe(false)
+			expect(!json.ok && json.error.type).toBe('missing_method')
+		})
+
+		it('should return error for unknown method', async () => {
+			const res = await app.request('/rpc', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({ method: 'unknown.method', input: {} }),
+			})
+
+			expect(res.status).toBe(400)
+			const json = await parseJson<never>(res)
+			expect(json.ok).toBe(false)
+			expect(!json.ok && json.error.type).toBe('method_not_found')
+		})
+
+		it('should return validation error for invalid input', async () => {
+			const res = await app.request('/rpc', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					method: 'sessions.list',
+					input: { limit: 'not a number' },
+				}),
+			})
+
+			expect(res.status).toBe(200)
+			const json = await parseJson<never>(res)
+			expect(json.ok).toBe(false)
+			expect(!json.ok && json.error.type).toBe('validation_error')
+		})
+	})
+
+	describe('sessions.list', () => {
+		it('should return empty list initially', async () => {
+			const res = await app.request('/rpc', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({ method: 'sessions.list', input: {} }),
+			})
+
+			expect(res.status).toBe(200)
+			const json = await parseJson<{ sessions: unknown[]; total: number }>(res)
+			expect(json.ok).toBe(true)
+			expect(json.ok && json.value.sessions).toEqual([])
+			expect(json.ok && json.value.total).toBe(0)
+		})
+	})
+
+	describe('sessions.create', () => {
+		it('should create a session', async () => {
+			const res = await app.request('/rpc', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					method: 'sessions.create',
+					input: { presetId: 'echo-test' },
+				}),
+			})
+
+			expect(res.status).toBe(200)
+			const json = await parseJson<{ sessionId: string }>(res)
+			expect(json.ok).toBe(true)
+			expect(json.ok && json.value.sessionId).toBeDefined()
+			expect(json.ok && typeof json.value.sessionId).toBe('string')
+		})
+
+		it('should return error for unknown preset', async () => {
+			const res = await app.request('/rpc', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					method: 'sessions.create',
+					input: { presetId: 'unknown-preset' },
+				}),
+			})
+
+			expect(res.status).toBe(200)
+			const json = await parseJson<never>(res)
+			expect(json.ok).toBe(false)
+			expect(!json.ok && json.error.type).toBe('preset_not_found')
+		})
+	})
+
+	describe('sessions.get', () => {
+		it('should get session info', async () => {
+			// Create session first
+			const createRes = await app.request('/rpc', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					method: 'sessions.create',
+					input: { presetId: 'echo-test' },
+				}),
+			})
+			const createJson = await parseJson<{ sessionId: string }>(createRes)
+			const sessionId = createJson.ok ? createJson.value.sessionId : ''
+
+			// Get session
+			const res = await app.request('/rpc', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					method: 'sessions.get',
+					input: { sessionId },
+				}),
+			})
+
+			expect(res.status).toBe(200)
+			const json = await parseJson<{ sessionId: string; presetId: string; status: string }>(res)
+			expect(json.ok).toBe(true)
+			expect(json.ok && json.value.sessionId).toBe(sessionId)
+			expect(json.ok && json.value.presetId).toBe('echo-test')
+			expect(json.ok && json.value.status).toBe('active')
+		})
+
+		it('should return error for unknown session', async () => {
+			const res = await app.request('/rpc', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					method: 'sessions.get',
+					input: { sessionId: 'nonexistent-session' },
+				}),
+			})
+
+			expect(res.status).toBe(200)
+			const json = await parseJson<never>(res)
+			expect(json.ok).toBe(false)
+			expect(!json.ok && json.error.type).toBe('session_not_found')
+		})
+	})
+
+	describe('user-chat.sendMessage', () => {
+		it('should send a message', async () => {
+			// Create session first
+			const createRes = await app.request('/rpc', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					method: 'sessions.create',
+					input: { presetId: 'echo-test' },
+				}),
+			})
+			const createJson = await parseJson<{ sessionId: string }>(createRes)
+			const sessionId = createJson.ok ? createJson.value.sessionId : ''
+
+			// Get session to find entry agent ID
+			const getRes = await app.request('/rpc', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					method: 'sessions.get',
+					input: { sessionId },
+				}),
+			})
+			const getJson = await parseJson<{ entryAgentId: string }>(getRes)
+			const agentId = getJson.ok ? getJson.value.entryAgentId : ''
+
+			// Send message
+			const res = await app.request('/rpc', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					method: 'user-chat.sendMessage',
+					input: { sessionId, agentId, content: 'Hello' },
+				}),
+			})
+
+			expect(res.status).toBe(200)
+			const json = await parseJson<{ messageId: string }>(res)
+			expect(json.ok).toBe(true)
+			expect(json.ok && json.value.messageId).toBeDefined()
+		})
+
+		it('should return error for non-existent session', async () => {
+			const res = await app.request('/rpc', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					method: 'user-chat.sendMessage',
+					input: { sessionId: 'test', agentId: 'test', content: '' },
+				}),
+			})
+
+			expect(res.status).toBe(200)
+			const json = await parseJson<never>(res)
+			expect(json.ok).toBe(false)
+			expect(!json.ok && json.error.type).toBe('session_not_found')
+		})
+	})
+
+	describe('sessions.close', () => {
+		it('should close a session', async () => {
+			// Create session first
+			const createRes = await app.request('/rpc', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					method: 'sessions.create',
+					input: { presetId: 'echo-test' },
+				}),
+			})
+			const createJson = await parseJson<{ sessionId: string }>(createRes)
+			const sessionId = createJson.ok ? createJson.value.sessionId : ''
+
+			// Close session
+			const res = await app.request('/rpc', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					method: 'sessions.close',
+					input: { sessionId },
+				}),
+			})
+
+			expect(res.status).toBe(200)
+			const json = await parseJson<Record<string, never>>(res)
+			expect(json.ok).toBe(true)
+
+			// Verify it's closed
+			const getRes = await app.request('/rpc', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					method: 'sessions.get',
+					input: { sessionId },
+				}),
+			})
+			const getJson = await parseJson<{ status: string }>(getRes)
+			expect(getJson.ok).toBe(true)
+			expect(getJson.ok && getJson.value.status).toBe('closed')
+		})
+	})
+
+	describe('sessions.getEvents', () => {
+		it('should return events for a session', async () => {
+			// Create session first
+			const createRes = await app.request('/rpc', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					method: 'sessions.create',
+					input: { presetId: 'echo-test' },
+				}),
+			})
+			const createJson = await parseJson<{ sessionId: string }>(createRes)
+			const sessionId = createJson.ok ? createJson.value.sessionId : ''
+
+			// Get events
+			const res = await app.request('/rpc', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					method: 'sessions.getEvents',
+					input: { sessionId },
+				}),
+			})
+
+			expect(res.status).toBe(200)
+			const json = await parseJson<{ events: { type: string }[]; total: number; lastIndex: number }>(res)
+			expect(json.ok).toBe(true)
+			if (json.ok) {
+				expect(Array.isArray(json.value.events)).toBe(true)
+				expect(typeof json.value.total).toBe('number')
+				expect(typeof json.value.lastIndex).toBe('number')
+
+				// Should have session_created event
+				const hasSessionCreated = json.value.events.some(
+					(e) => e.type === 'session_created',
+				)
+				expect(hasSessionCreated).toBe(true)
+			}
+		})
+	})
+})

package/src/transport/http/routes/rpc.ts

@@ -0,0 +1,156 @@
+/**
+ * RPC Routes — Generic Dispatcher
+ *
+ * Single POST /rpc endpoint that auto-routes to plugin methods.
+ * No hardcoded handlers — all business logic lives in plugins.
+ *
+ * Supports both single calls and batch calls:
+ * - Single: { method, input } → { ok: true, value } | { ok: false, error }
+ * - Batch:  { batch: [{ method, input }, ...] } → { results: [{ ok: true, value } | { ok: false, error }, ...] }
+ *
+ * Routing order:
+ * 1. Manager methods (session creation, listing, etc.)
+ * 2. Session plugin methods (require sessionId in input)
+ * 3. 404 if not found
+ */
+
+import { Hono } from 'hono'
+import type { ContentfulStatusCode } from 'hono/utils/http-status'
+import { AgentId } from '~/core/agents/schema.js'
+import type { DomainError } from '~/core/errors.js'
+import { type CallerContext, DEFAULT_CALLER } from '~/core/plugins/plugin-builder.js'
+import { SessionId } from '~/core/sessions/schema.js'
+import type { SessionManager } from '~/core/sessions/session-manager.js'
+import { getServices } from '../app.js'
+import type { AppEnv } from '../app.js'
+
+type MethodResult =
+	| { ok: true; value: unknown }
+	| { ok: false; error: { type: string; message: string } }
+
+function formatError(error: DomainError): { ok: false; error: { type: string; message: string } } {
+	return { ok: false, error: { type: error.type, message: error.message } }
+}
+
+/**
+ * Dispatch a single RPC method call and return the result envelope.
+ */
+async function dispatchMethod(
+	sessionRuntime: SessionManager,
+	method: string,
+	input: unknown,
+): Promise<{ httpStatus: ContentfulStatusCode; body: MethodResult }> {
+	// 1. Try manager methods (session lifecycle, presets)
+	const managerMethods = sessionRuntime.getManagerMethods()
+	if (managerMethods.has(method)) {
+		const result = await sessionRuntime.callManagerMethod(method, input)
+
+		if (!result.ok) {
+			return { httpStatus: 200, body: formatError(result.error) }
+		}
+
+		return { httpStatus: 200, body: { ok: true, value: result.value } }
+	}
+
+	// 2. Try session plugin methods (require sessionId in input)
+	if (typeof input === 'object' && input !== null && 'sessionId' in input && typeof input.sessionId === 'string') {
+		const sessionId = SessionId(input.sessionId)
+		const agentId = 'agentId' in input && typeof input.agentId === 'string' ? AgentId(input.agentId) : undefined
+
+		// Extract caller context injected by worker, strip from input
+		const caller: CallerContext = '_caller' in input && typeof input._caller === 'object' && input._caller !== null
+			? input._caller as CallerContext
+			: DEFAULT_CALLER
+		const { _caller: _, ...cleanInput } = input as Record<string, unknown>
+
+		const sessionResult = await sessionRuntime.getSession(sessionId)
+		if (sessionResult.ok) {
+			const session = sessionResult.value
+			const pluginMethods = session.getPluginMethods()
+
+			if (pluginMethods.has(method)) {
+				const result = await sessionRuntime.callPluginMethod(sessionId, method, cleanInput, agentId, caller)
+
+				if (!result.ok) {
+					return { httpStatus: 200, body: formatError(result.error) }
+				}
+
+				return { httpStatus: 200, body: { ok: true, value: result.value } }
+			}
+		} else if (sessionResult.error.type === 'session_not_found') {
+			return { httpStatus: 200, body: formatError(sessionResult.error) }
+		}
+	}
+
+	// 3. Method not found — transport error, use 400
+	return { httpStatus: 400, body: { ok: false, error: { type: 'method_not_found', message: `Unknown method: ${method}` } } }
+}
+
+interface BatchRequest {
+	batch: Array<{ method: string; input?: unknown }>
+}
+
+function isBatchRequest(body: unknown): body is BatchRequest {
+	return typeof body === 'object' && body !== null && 'batch' in body && Array.isArray(body.batch)
+}
+
+/**
+ * Creates the RPC routes.
+ */
+export function createRpcRoutes(): Hono<AppEnv> {
+	const app = new Hono<AppEnv>()
+
+	app.post('/', async (c) => {
+		let body: unknown
+
+		try {
+			body = await c.req.json()
+		} catch {
+			return c.json(
+				{ ok: false, error: { type: 'invalid_json', message: 'Invalid JSON in request body' } },
+				400,
+			)
+		}
+
+		const { sessionRuntime } = getServices(c)
+
+		// Batch request
+		if (isBatchRequest(body)) {
+			const results: MethodResult[] = []
+
+			for (const call of body.batch) {
+				if (!call.method || typeof call.method !== 'string') {
+					results.push({ ok: false, error: { type: 'missing_method', message: "Missing 'method' field in batch call" } })
+					break
+				}
+
+				const { body: resultBody } = await dispatchMethod(sessionRuntime, call.method, call.input)
+
+				if (!resultBody.ok) {
+					results.push(resultBody)
+					break
+				}
+
+				results.push(resultBody)
+			}
+
+			return c.json({ results })
+		}
+
+		// Single request — extract method from body via narrowing
+		const method = typeof body === 'object' && body !== null && 'method' in body ? body.method : undefined
+		const input = typeof body === 'object' && body !== null && 'input' in body ? body.input : undefined
+
+		if (!method || typeof method !== 'string') {
+			return c.json(
+				{ ok: false, error: { type: 'missing_method', message: "Missing 'method' field in request" } },
+				400,
+			)
+		}
+
+		const { httpStatus, body: resultBody } = await dispatchMethod(sessionRuntime, method, input)
+		return c.json(resultBody, httpStatus)
+	})
+
+	return app
+}