@vibesdotdev/client 0.1.0

package/src/sse-client.ts

@@ -0,0 +1,155 @@
+/**
+ * Client-side SSE (Server-Sent Events) client.
+ *
+ * Provides a typed interface for connecting to SSE endpoints,
+ * handling reconnection, and dispatching events.
+ */
+
+export type SSEConnectionStatus =
+	| 'connecting'
+	| 'connected'
+	| 'reconnecting'
+	| 'disconnected'
+	| 'error';
+
+export interface SSEClientOptions {
+	url: string;
+	reconnectDelay?: number;
+	maxReconnectAttempts?: number;
+	onStatusChange?: (status: SSEConnectionStatus) => void;
+	onError?: (error: string) => void;
+}
+
+type EventHandler = (data: unknown) => void;
+
+export class SSEClient {
+	private url: string;
+	private reconnectDelay: number;
+	private maxReconnectAttempts: number;
+	private onStatusChange?: (status: SSEConnectionStatus) => void;
+	private onError?: (error: string) => void;
+
+	private eventSource: EventSource | null = null;
+	private handlers = new Map<string, Set<EventHandler>>();
+	private reconnectAttempts = 0;
+	private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+	private _status: SSEConnectionStatus = 'disconnected';
+
+	constructor(options: SSEClientOptions) {
+		this.url = options.url;
+		this.reconnectDelay = options.reconnectDelay ?? 5000;
+		this.maxReconnectAttempts = options.maxReconnectAttempts ?? 5;
+		this.onStatusChange = options.onStatusChange;
+		this.onError = options.onError;
+	}
+
+	get status(): SSEConnectionStatus {
+		return this._status;
+	}
+
+	connect(): void {
+		this.setStatus('connecting');
+
+		try {
+			const EventSourceCtor = globalThis.EventSource as {
+				new (url: string): EventSource;
+			};
+			this.eventSource = new EventSourceCtor(this.url);
+
+			this.eventSource.onopen = () => {
+				this.reconnectAttempts = 0;
+				this.setStatus('connected');
+			};
+
+			this.eventSource.onerror = () => {
+				const error = `SSE connection error`;
+				this.onError?.(error);
+
+				if (this.reconnectAttempts < this.maxReconnectAttempts) {
+					this.setStatus('reconnecting');
+					this.reconnectAttempts++;
+					this.scheduleReconnect();
+				} else {
+					this.setStatus('error');
+					this.cleanup();
+				}
+			};
+
+			// Dispatch events to registered handlers
+			this.eventSource.onmessage = (event) => {
+				this.dispatch('message', event.data);
+			};
+
+			// Listen for named events by iterating registered handlers
+			for (const eventName of this.handlers.keys()) {
+				if (eventName === 'message') continue;
+				this.eventSource.addEventListener(eventName, (event) => {
+					try {
+						const data = JSON.parse((event as MessageEvent).data);
+						this.dispatch(eventName, data);
+					} catch {
+						this.dispatch(eventName, (event as MessageEvent).data);
+					}
+				});
+			}
+		} catch (e) {
+			const error = e instanceof Error ? e.message : 'Failed to create SSE connection';
+			this.onError?.(error);
+			this.setStatus('error');
+		}
+	}
+
+	disconnect(): void {
+		this.cleanup();
+		this.setStatus('disconnected');
+	}
+
+	on(event: string, handler: EventHandler): () => void {
+		if (!this.handlers.has(event)) {
+			this.handlers.set(event, new Set());
+		}
+		this.handlers.get(event)!.add(handler);
+
+		// Return unsubscribe function
+		return () => {
+			this.handlers.get(event)?.delete(handler);
+		};
+	}
+
+	private dispatch(event: string, data: unknown): void {
+		this.handlers.get(event)?.forEach((handler) => {
+			try {
+				handler(data);
+			} catch (e) {
+				console.error(`[SSEClient] Error in handler for "${event}":`, e);
+			}
+		});
+	}
+
+	private setStatus(status: SSEConnectionStatus): void {
+		this._status = status;
+		this.onStatusChange?.(status);
+	}
+
+	private scheduleReconnect(): void {
+		if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+		this.reconnectTimer = setTimeout(() => {
+			this.connect();
+		}, this.reconnectDelay);
+	}
+
+	private cleanup(): void {
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		if (this.eventSource) {
+			this.eventSource.close();
+			this.eventSource = null;
+		}
+	}
+}
+
+export function createSSEClient(options: SSEClientOptions): SSEClient {
+	return new SSEClient(options);
+}

package/src/tools/api-request/api-request.descriptor.ts

@@ -0,0 +1,28 @@
+/**
+ * api-request Tool Descriptor
+ *
+ * Metadata for the api-request tool. Safe to import anywhere.
+ */
+
+import { createRuntimeAsset } from '@vibesdotdev/runtime/factory';
+import { apiRequestInputSchema, apiRequestOutputSchema } from './schemas/index.ts';
+
+export default createRuntimeAsset({
+	kind: 'tools/tool',
+	id: 'api-request',
+	name: 'API Request',
+	description: 'Make an authenticated API request to any Vibes endpoint.',
+	mcpDescription: 'Make authenticated API request to Vibes endpoints. Ex: {method:"GET",path:"/api/health"}.',
+	hardware: ['consumer'],
+	purpose: ['direct', 'worker', 'mcp', 'agent'],
+	category: 'execution',
+	subcategory: 'api-request',
+	tags: ['api', 'network'],
+	safety: 'write',
+	requiresApproval: true,
+	permissions: ['canAccessNetwork'],
+	schemas: {
+		input: apiRequestInputSchema,
+		output: apiRequestOutputSchema
+	}
+});

package/src/tools/api-request/api-request.impl.consumer.ts

@@ -0,0 +1,66 @@
+/**
+ * api-request Tool Implementation (Consumer)
+ *
+ * Consumer-scoped implementation for making authenticated API requests.
+ * Resolves the `api/client` runtime kind and delegates to its `.request()`.
+ */
+
+import type { VibesRuntime, ToolCallContext } from '@vibesdotdev/runtime';
+import type { ApiClientImplementation } from '../../schemas.ts';
+import type { ApiRequestInput, ApiRequestOutput } from './schemas/index.ts';
+
+async function resolveApiClient(runtime: VibesRuntime): Promise<ApiClientImplementation> {
+	try {
+		const apiClient = (await runtime.query('api/client').resolve()) as
+			| ApiClientImplementation
+			| undefined;
+		if (apiClient) {
+			return apiClient;
+		}
+	} catch {
+		// Query failed, fall through
+	}
+
+	throw new Error(
+		'API client not available in runtime context. Ensure api/client kind is registered.'
+	);
+}
+
+export default {
+	async execute(
+		input: ApiRequestInput,
+		runtime: VibesRuntime,
+		_ctx: ToolCallContext
+	): Promise<ApiRequestOutput> {
+		const method = input.method;
+		const path = input.path;
+		const query = input.query ?? {};
+		const body = input.body ?? undefined;
+		const headers = input.headers ?? {};
+
+		try {
+			const apiClient = await resolveApiClient(runtime);
+
+			const response = await apiClient.request(path, {
+				method,
+				query,
+				body,
+				headers
+			});
+
+			return {
+				status: 'success',
+				response
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return {
+				status: 'error',
+				error: {
+					message,
+					code: 'API_REQUEST_FAILED'
+				}
+			};
+		}
+	}
+};

package/src/tools/api-request/index.ts

@@ -0,0 +1,4 @@
+export { default as apiRequestToolDescriptor } from './api-request.descriptor.ts';
+export { default as apiRequestToolImplementation } from './api-request.impl.consumer.ts';
+export { apiRequestInputSchema, apiRequestOutputSchema } from './schemas/index.ts';
+export type { ApiRequestInput, ApiRequestOutput } from './schemas/index.ts';

package/src/tools/api-request/schemas/index.ts

@@ -0,0 +1,29 @@
+/**
+ * API Request Tool Schemas
+ *
+ * Input/output schemas for the api-request tool.
+ */
+
+import * as z from 'zod/v4';
+
+export const apiRequestInputSchema = z.object({
+	method: z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']),
+	path: z.string().min(1),
+	query: z.record(z.string(), z.any()).optional(),
+	body: z.any().optional(),
+	headers: z.record(z.string(), z.string()).optional()
+});
+
+export const apiRequestOutputSchema = z.object({
+	status: z.enum(['success', 'error']),
+	response: z.unknown().optional(),
+	error: z
+		.object({
+			message: z.string(),
+			code: z.string().optional()
+		})
+		.optional()
+});
+
+export type ApiRequestInput = z.infer<typeof apiRequestInputSchema>;
+export type ApiRequestOutput = z.infer<typeof apiRequestOutputSchema>;