@kadi.build/core 0.0.1-alpha.8 → 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,573 @@
+/**
+ * KadiClient for kadi-core v0.1.0
+ *
+ * The main entry point for building KADI agents.
+ * This client handles:
+ * - Broker connections (WebSocket with Ed25519 authentication)
+ * - Tool registration (local tools that can be invoked remotely)
+ * - Ability loading (native, stdio, broker transports)
+ * - Remote invocation (call tools on other agents)
+ * - Serve modes (stdio server, broker server)
+ *
+ * Design principles:
+ * - Named brokers with optional defaultBroker
+ * - Explicit over implicit (no proxy magic)
+ * - Readable, traceable code flow
+ */
+import type { ClientConfig, BrokerState, ToolDefinition, ZodToolDefinition, ToolHandler, LoadedAbility, RegisterToolOptions, LoadNativeOptions, LoadStdioOptions, LoadBrokerOptions, InvokeRemoteOptions, BrokerEventHandler, PublishOptions, SubscribeOptions } from './types.js';
+/**
+ * The main client for building KADI agents.
+ *
+ * @example
+ * ```typescript
+ * // Create a client with named brokers
+ * const client = new KadiClient({
+ *   name: 'my-agent',
+ *   brokers: {
+ *     production: 'ws://broker-prod:8080',
+ *     internal: 'ws://broker-internal:8080',
+ *   },
+ *   defaultBroker: 'production',
+ * });
+ *
+ * // Register a tool
+ * client.registerTool({
+ *   name: 'add',
+ *   description: 'Add two numbers',
+ *   input: z.object({ a: z.number(), b: z.number() }),
+ * }, async ({ a, b }) => ({ result: a + b }));
+ *
+ * // Connect to brokers
+ * await client.connect();
+ *
+ * // Load and use abilities
+ * const calc = await client.loadNative('calculator');
+ * const result = await calc.invoke('multiply', { x: 5, y: 3 });
+ * ```
+ */
+export declare class KadiClient {
+    /** Resolved configuration with defaults applied */
+    private readonly config;
+    /** Registered tools (local tools this agent provides) */
+    private readonly tools;
+    /** Broker connections by name */
+    private readonly brokers;
+    /** Counter for generating unique request IDs */
+    private nextRequestId;
+    /** Event handler callback (set by native transport) */
+    private eventHandler;
+    /** Whether we're serving via stdio (set by serve('stdio')) */
+    private isServingStdio;
+    constructor(config: ClientConfig);
+    /**
+     * Connect to all configured brokers.
+     * Call this after registering tools.
+     *
+     * @example
+     * ```typescript
+     * await client.connect(); // Connects to all brokers
+     * await client.connect('production'); // Connect to specific broker
+     * ```
+     */
+    connect(brokerName?: string): Promise<void>;
+    /**
+     * Connect to a specific broker by name.
+     *
+     * Protocol:
+     * 1. Generate Ed25519 keypair
+     * 2. Open WebSocket connection
+     * 3. Send kadi.session.hello
+     * 4. Receive nonce from broker
+     * 5. Send kadi.session.authenticate with signed nonce
+     * 6. Receive agentId from broker
+     * 7. Register tools with broker
+     * 8. Start heartbeat
+     */
+    private connectToBroker;
+    private buildHelloMessage;
+    private buildAuthMessage;
+    private buildRegisterMessage;
+    private buildHeartbeatMessage;
+    /**
+     * Open WebSocket connection to broker.
+     */
+    private openWebSocket;
+    /**
+     * Perform handshake: hello → authenticate.
+     *
+     * Protocol:
+     * 1. Client sends kadi.session.hello
+     * 2. Broker responds with { nonce: "..." }
+     * 3. Client signs nonce and sends kadi.session.authenticate
+     * 4. Broker responds with { agentId: "..." }
+     */
+    private performHandshake;
+    /**
+     * Register with broker after authentication.
+     *
+     * This transitions the session from "authenticated" to "ready" state.
+     * Must be called even if no tools are registered - the broker requires
+     * the agent to be in "ready" state before it can invoke remote tools.
+     */
+    private registerWithBroker;
+    /**
+     * Send a JSON-RPC request and wait for the response.
+     *
+     * Design: Returns the result directly (not the full JSON-RPC response).
+     *
+     * Why? The JSON-RPC envelope (jsonrpc, id) is transport metadata.
+     * Once we've matched the response to the pending request, that metadata
+     * has served its purpose. Callers care about the result, not the envelope.
+     *
+     * Errors are handled via Promise rejection in handleBrokerResponse,
+     * so by the time this resolves, we know it's a successful response.
+     *
+     * IMPORTANT: The type parameter T is NOT validated at runtime.
+     * It provides TypeScript type hints but the broker could return any shape.
+     * Callers MUST validate critical fields before using them.
+     *
+     * @template T - Expected type of the result (defaults to unknown for safety)
+     * @param state - Broker connection state
+     * @param request - JSON-RPC request to send
+     * @returns Promise resolving to the typed result
+     *
+     * @example
+     * ```typescript
+     * // Caller specifies expected result type
+     * const result = await this.sendRequest<{ nonce: string }>(state, helloMessage);
+     * // IMPORTANT: Validate before using - the type is not runtime-enforced
+     * if (!result.nonce) throw new Error('Missing nonce');
+     * console.log(result.nonce);
+     * ```
+     */
+    private sendRequest;
+    /**
+     * Handle incoming messages from broker.
+     */
+    private handleBrokerMessage;
+    /**
+     * Handle kadi.ability.response notification.
+     *
+     * This is the second part of the async tool invocation pattern:
+     * 1. Client sends kadi.ability.request → gets { status: 'pending', requestId }
+     * 2. Provider executes tool and sends result back to broker
+     * 3. Broker sends this notification with the actual result
+     *
+     * The notification contains:
+     * - requestId: matches what we got in step 1
+     * - result: the tool's return value (if successful)
+     * - error: error message (if failed)
+     */
+    private handleAbilityResponse;
+    /**
+     * Handle kadi.event.delivery notification from broker.
+     *
+     * When an event is published to a channel that matches one of our subscribed
+     * patterns, the broker sends us this notification with the event data.
+     *
+     * Flow:
+     * 1. Some agent calls publish('user.login', data)
+     * 2. Broker routes to all subscribers matching 'user.*' or 'user.#' etc.
+     * 3. We receive this notification and dispatch to local handlers
+     *
+     * The notification params contain:
+     * - channel: The exact channel name (e.g., 'user.login')
+     * - data: The event payload
+     * - networkId: Which network the event was published to
+     * - source: Session ID of the publisher
+     * - timestamp: When the event was published
+     */
+    private handleEventDelivery;
+    /**
+     * Check if a subscription pattern matches an event channel.
+     *
+     * Pattern matching follows RabbitMQ topic exchange rules:
+     * - '*' matches exactly one word (between dots)
+     * - '#' matches zero or more words
+     * - Literal strings match exactly
+     *
+     * Examples:
+     * - 'user.*' matches 'user.login', 'user.logout', NOT 'user.profile.update'
+     * - 'user.#' matches 'user.login', 'user.profile.update', even just 'user'
+     * - 'user.login' matches only 'user.login'
+     *
+     * @param pattern - The subscription pattern (e.g., 'user.*')
+     * @param channel - The event channel (e.g., 'user.login')
+     */
+    private patternMatchesChannel;
+    /**
+     * Recursive pattern matcher (RabbitMQ topic exchange style).
+     *
+     * Example: pattern "user.#.status" vs channel "user.profile.settings.status"
+     *          → # eats "profile.settings" → match!
+     */
+    private matchPatternRecursive;
+    /**
+     * Subscribe to events matching a pattern.
+     *
+     * Pattern matching follows RabbitMQ topic exchange rules:
+     * - '*' matches exactly one word (between dots)
+     * - '#' matches zero or more words
+     *
+     * @param pattern - Pattern to subscribe to (e.g., 'user.*', 'order.#')
+     * @param handler - Function called when matching event is received
+     * @param options - Optional: which broker to subscribe through
+     *
+     * @example
+     * ```typescript
+     * // Subscribe to all user events
+     * client.subscribe('user.*', (event) => {
+     *   console.log(`User event: ${event.channel}`, event.data);
+     * });
+     *
+     * // Subscribe to all order events at any depth
+     * client.subscribe('order.#', (event) => {
+     *   console.log(`Order event: ${event.channel}`, event.data);
+     * });
+     * ```
+     */
+    subscribe(pattern: string, handler: BrokerEventHandler, options?: SubscribeOptions): Promise<void>;
+    /**
+     * Unsubscribe from events.
+     *
+     * Removes the specified handler from the pattern. If no handlers remain
+     * for a pattern, the broker subscription is also removed.
+     *
+     * @param pattern - Pattern to unsubscribe from
+     * @param handler - The handler function to remove
+     * @param options - Optional: which broker to unsubscribe from
+     *
+     * @example
+     * ```typescript
+     * const handler = (event) => console.log(event);
+     * client.subscribe('user.*', handler);
+     * // ... later
+     * client.unsubscribe('user.*', handler);
+     * ```
+     */
+    unsubscribe(pattern: string, handler: BrokerEventHandler, options?: SubscribeOptions): Promise<void>;
+    /**
+     * Publish an event to a channel.
+     *
+     * Events are published to a specific network. All agents subscribed to
+     * matching patterns on that network will receive the event.
+     *
+     * @param channel - Channel/topic to publish to (e.g., 'user.login')
+     * @param data - Event payload (any JSON-serializable data)
+     * @param options - Optional: network and broker to publish through
+     *
+     * @example
+     * ```typescript
+     * // Publish to default network
+     * await client.publish('user.login', { userId: '123', timestamp: Date.now() });
+     *
+     * // Publish to specific network
+     * await client.publish('order.created', orderData, { network: 'internal' });
+     * ```
+     */
+    publish(channel: string, data: unknown, options?: PublishOptions): Promise<void>;
+    /**
+     * Handle incoming request from broker (tool invocation).
+     */
+    private handleBrokerRequest;
+    /**
+     * Handle incoming tool invocation request from broker.
+     *
+     * When callerProtocol is 'mcp', responses are formatted for MCP clients:
+     * - If result is already MCP-shaped (has valid content array), pass through unchanged
+     * - Otherwise, wrap as text: { content: [{ type: 'text', text: '...' }], isError: false }
+     *
+     * This allows tools to return images, audio, or other MCP content types directly,
+     * while plain JSON results are automatically wrapped as text.
+     *
+     * When callerProtocol is 'kadi' or undefined, raw structured data is returned.
+     */
+    private handleInvokeRequest;
+    /**
+     * Handle response to a pending request.
+     */
+    private handleBrokerResponse;
+    /**
+     * Send heartbeat to keep connection alive.
+     */
+    private sendHeartbeat;
+    /**
+     * Cleanup broker connection state.
+     * Called on disconnect or connection failure.
+     */
+    private cleanupBroker;
+    /**
+     * Handle WebSocket close event.
+     *
+     * Decides whether to attempt reconnection based on:
+     * - Was the connection ever established? (don't reconnect on initial failure)
+     * - autoReconnect config setting
+     * - Whether this was an intentional disconnect (user called disconnect())
+     */
+    private handleWebSocketClose;
+    /**
+     * Calculate reconnection delay using exponential backoff with jitter.
+     *
+     * Formula: min(baseDelay * 2^attempt, maxDelay) ± 20% jitter
+     *
+     * Examples (with maxDelay=30s):
+     * - Attempt 0: ~1s (1000ms ± 200ms)
+     * - Attempt 1: ~2s (2000ms ± 400ms)
+     * - Attempt 2: ~4s (4000ms ± 800ms)
+     * - Attempt 3: ~8s
+     * - Attempt 4: ~16s
+     * - Attempt 5+: ~30s (capped)
+     *
+     * Why jitter? When a broker restarts and 100 agents try to reconnect,
+     * jitter spreads them out so they don't all hit at once (thundering herd).
+     */
+    private getReconnectDelay;
+    /**
+     * Schedule a reconnection attempt.
+     *
+     * Logs the attempt number and delay for visibility.
+     *
+     * Note: Reconnection continues indefinitely until successful or
+     * disconnect() is called. There is no max attempt limit - only
+     * the delay is capped at maxReconnectDelay.
+     */
+    private scheduleReconnect;
+    /**
+     * Attempt to reconnect to the broker.
+     *
+     * This reuses the existing keypair (agentId stays the same) and
+     * re-registers tools with the broker.
+     *
+     * On failure, schedules another attempt with increased delay.
+     */
+    private attemptReconnect;
+    /**
+     * Disconnect from broker(s).
+     *
+     * @param brokerName - If provided, disconnect only from that broker.
+     *                     If not provided, disconnect from all brokers.
+     */
+    disconnect(brokerName?: string): Promise<void>;
+    /**
+     * Internal helper to disconnect a single broker.
+     *
+     * IMPORTANT: The order of operations matters!
+     * 1. Set intentionalDisconnect BEFORE closing WebSocket
+     * 2. ws.close() triggers handleWebSocketClose(), which checks this flag
+     * 3. If the flag isn't set first, reconnection would be triggered
+     */
+    private disconnectBroker;
+    /**
+     * Set the event handler callback.
+     * Called by native/stdio transport when loading this ability.
+     * @internal
+     */
+    setEventHandler(handler: (event: string, data: unknown) => void): void;
+    /**
+     * Emit an event to the consumer that loaded this ability.
+     *
+     * Events are fire-and-forget notifications - the consumer does not
+     * send a response. Use this for real-time updates, state changes,
+     * or any notification that doesn't require a response.
+     *
+     * @param event - Event name (e.g., 'file.changed', 'user.login')
+     * @param data - Event payload
+     *
+     * @example
+     * ```typescript
+     * // Emit an event when something happens
+     * client.emit('file.changed', { path: '/tmp/foo.txt', action: 'modified' });
+     *
+     * // Emit progress updates
+     * client.emit('job.progress', { percent: 50, message: 'Halfway done' });
+     * ```
+     */
+    emit(event: string, data: unknown): void;
+    /**
+     * Register a tool with this agent.
+     *
+     * @param definition - Tool definition (with Zod schemas)
+     * @param handler - Function to handle invocations
+     * @param options - Registration options (broker targeting)
+     *
+     * @example
+     * ```typescript
+     * client.registerTool({
+     *   name: 'add',
+     *   description: 'Add two numbers',
+     *   input: z.object({ a: z.number(), b: z.number() }),
+     *   output: z.object({ result: z.number() }),
+     * }, async ({ a, b }) => ({ result: a + b }));
+     *
+     * // Register only on specific broker
+     * client.registerTool(def, handler, { brokers: ['internal'] });
+     * ```
+     */
+    registerTool<TInput, TOutput>(definition: ZodToolDefinition<TInput, TOutput>, handler: ToolHandler<TInput, TOutput>, options?: RegisterToolOptions): void;
+    /**
+     */
+    /**
+     * Get tool definitions, optionally filtered for a specific broker.
+     *
+     * @param forBroker - If provided, only return tools targeted for this broker.
+     *                    Tools with empty targetBrokers are included for all brokers.
+     */
+    private getToolDefinitions;
+    /**
+     * Invoke a local tool by name.
+     */
+    invoke(toolName: string, params: unknown): Promise<unknown>;
+    /**
+     * Load an in-process ability via dynamic import.
+     *
+     * @param name - Ability name (resolved from agent-lock.json)
+     * @param options - Optional explicit path
+     *
+     * @example
+     * ```typescript
+     * // Load by name (resolves from agent-lock.json)
+     * const calc = await client.loadNative('calculator');
+     *
+     * // Load by explicit path
+     * const calc = await client.loadNative('calculator', { path: './abilities/calc' });
+     * ```
+     */
+    loadNative(name: string, options?: LoadNativeOptions): Promise<LoadedAbility>;
+    /**
+     * Load a child process ability via stdio.
+     *
+     * Three modes of operation:
+     *
+     * 1. **Explicit mode** — Provide `command` and `args` directly (bypasses agent.json):
+     *    ```typescript
+     *    await client.loadStdio('analyzer', {
+     *      command: 'python3',
+     *      args: ['./analyzer/main.py', '--verbose'],
+     *    });
+     *    ```
+     *
+     * 2. **Script selection mode** — Choose which script from ability's agent.json:
+     *    ```typescript
+     *    await client.loadStdio('analyzer', { script: 'dev' });
+     *    // Uses scripts.dev from the ability's agent.json
+     *    ```
+     *
+     * 3. **Default mode** — Uses scripts.start from ability's agent.json:
+     *    ```typescript
+     *    await client.loadStdio('analyzer');
+     *    // Resolves from agent-lock.json, reads scripts.start from agent.json
+     *    ```
+     *
+     * @param name - Ability name (used for error messages and lock file lookup)
+     * @param options - Command/args override, or script selection
+     */
+    loadStdio(name: string, options?: LoadStdioOptions): Promise<LoadedAbility>;
+    /**
+     * Load a remote ability via broker.
+     *
+     * @param name - Ability name to discover on broker
+     * @param options - Broker to use, networks to filter
+     *
+     * @example
+     * ```typescript
+     * // Load from default broker
+     * const ai = await client.loadBroker('text-analyzer');
+     *
+     * // Load from specific broker
+     * const ai = await client.loadBroker('text-analyzer', { broker: 'internal' });
+     * ```
+     */
+    loadBroker(name: string, options?: LoadBrokerOptions): Promise<LoadedAbility>;
+    /**
+     * Invoke a tool on a remote agent directly (without loading the ability).
+     *
+     * This uses the KADI async invocation pattern:
+     * 1. Send kadi.ability.request → broker immediately returns { status: 'pending', requestId }
+     * 2. Broker forwards request to provider agent
+     * 3. Provider executes tool and sends result back to broker
+     * 4. Broker sends kadi.ability.response notification with the actual result
+     *
+     * @param toolName - Tool name (e.g., "add"). Broker routes to any provider.
+     * @param params - Tool parameters
+     * @param options - Broker to use, timeout
+     *
+     * @example
+     * ```typescript
+     * // Invoke on default broker (broker finds any provider)
+     * const result = await client.invokeRemote('add', { a: 5, b: 3 });
+     *
+     * // Invoke on specific broker
+     * const result = await client.invokeRemote('analyze', { text: 'hi' }, {
+     *   broker: 'internal',
+     * });
+     * ```
+     */
+    invokeRemote<T = unknown>(toolName: string, params: unknown, options?: InvokeRemoteOptions): Promise<T>;
+    /**
+     * Start serving this agent.
+     *
+     * @param mode - 'stdio' for JSON-RPC over stdin/stdout, 'broker' for broker connection
+     *
+     * @example
+     * ```typescript
+     * // Serve as a stdio server (for loadStdio)
+     * await client.serve('stdio');
+     *
+     * // Serve via broker (connects and waits)
+     * await client.serve('broker');
+     * ```
+     */
+    serve(mode: 'stdio' | 'broker'): Promise<void>;
+    /**
+     * Serve as a stdio server (JSON-RPC over stdin/stdout).
+     *
+     * Steps:
+     * 1. Redirect console.log to stderr (keeps stdout clean for JSON-RPC)
+     * 2. Set up binary-safe buffer for message parsing
+     * 3. Set up signal handlers for graceful shutdown
+     * 4. Process incoming messages
+     */
+    private serveStdio;
+    /**
+     * Handle a stdio message.
+     */
+    private handleStdioMessage;
+    /**
+     * Send a response via stdio.
+     */
+    private sendStdioResponse;
+    /**
+     * Send an error response via stdio.
+     */
+    private sendStdioError;
+    /**
+     * Serve via broker (connect and wait for requests).
+     *
+     * Connects to configured brokers and waits for incoming tool requests.
+     * Sets up graceful shutdown to disconnect loaded abilities.
+     */
+    private serveBroker;
+    /**
+     * Get agent information (for readAgentJson protocol).
+     */
+    readAgentJson(): {
+        name: string;
+        version: string;
+        tools: ToolDefinition[];
+    };
+    /**
+     * Get broker connection state (for broker transport).
+     */
+    getBrokerState(brokerName: string): BrokerState | undefined;
+    /**
+     * Check if connected to a specific broker or any broker.
+     *
+     * @param brokerName - Optional broker name to check. If not specified, checks any.
+     */
+    isConnected(brokerName?: string): boolean;
+    /**
+     * Get list of connected broker names.
+     */
+    getConnectedBrokers(): string[];
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}