@reminix/runtime 0.5.0 → 0.6.1

package/README.md

@@ -1,6 +1,6 @@
 # @reminix/runtime
 
-Reminix runtime for building handlers that run on Reminix.
+Agent runtime for building AI agents that integrate with the Reminix API.
 
 ## Installation
 
@@ -8,48 +8,227 @@ Reminix runtime for building handlers that run on Reminix.
 npm install @reminix/runtime
 # or
 pnpm add @reminix/runtime
-# or
-yarn add @reminix/runtime
 ```
 
-## Usage
+## Quick Start
+
+```typescript
+import { Agent, serve } from '@reminix/runtime';
+
+// Create an agent with optional metadata for dashboard display
+const agent = new Agent('my-agent', {
+  metadata: {
+    framework: 'custom',
+    model: 'gpt-4',
+    description: 'My first agent',
+  },
+});
+
+agent.onInvoke(async (input) => {
+  return { output: `Processed: ${input.message}` };
+});
+
+agent.onChat(async (messages) => {
+  const lastMessage = messages[messages.length - 1];
+  return {
+    message: { role: 'assistant', content: `Reply: ${lastMessage.content}` },
+  };
+});
+
+serve(agent, { port: 8080 });
+```
+
+## API Reference
+
+### Agent Class
+
+Create an agent with a unique name and optional metadata:
+
+```typescript
+import { Agent } from '@reminix/runtime';
+
+const agent = new Agent('my-agent');
+
+// With metadata (optional)
+const agentWithMeta = new Agent('my-agent', {
+  metadata: {
+    framework: 'langchain',
+    model: 'gpt-4',
+    description: 'Customer support agent',
+  },
+});
+```
+
+The `metadata` is available via the `/_discover` endpoint and displayed in the Reminix dashboard.
+
+#### `agent.onInvoke(handler)`
+
+Register an invoke handler:
 
 ```typescript
-import type { AgentHandler, Context, Request, Response } from '@reminix/runtime';
+agent.onInvoke(async (input, ctx) => {
+  // input is Record<string, unknown>
+  // ctx has: conversationId, userId, custom
+  return { output: 'result' };
+});
+```
+
+#### `agent.onChat(handler)`
 
-const myAgent: AgentHandler = async (context: Context, request: Request): Promise<Response> => {
-  // Your handler logic here
+Register a chat handler:
+
+```typescript
+agent.onChat(async (messages, ctx) => {
+  // messages is ChatMessage[]
+  // ctx has: conversationId, userId, custom
   return {
-    messages: [
-      {
-        role: 'assistant',
-        content: 'Hello from my handler!',
-      },
-    ],
+    message: { role: 'assistant', content: `Hello, user ${ctx?.userId}!` },
+  };
+});
+```
+
+The `ctx` parameter is optional and contains request context:
+
+- `conversationId`: Track multi-turn conversations
+- `userId`: Identify the user
+- `custom`: Any additional custom fields
+
+### Streaming Responses
+
+Return an async generator to stream responses:
+
+```typescript
+agent.onInvoke(async function* (input) {
+  yield { chunk: 'Hello ' };
+  yield { chunk: 'World!' };
+});
+
+agent.onChat(async function* (messages) {
+  yield { chunk: 'Streaming ' };
+  yield { chunk: 'response...' };
+});
+```
+
+### Serve Function
+
+Start a server hosting your agents:
+
+```typescript
+import { serve } from '@reminix/runtime';
+
+// Single agent
+serve(agent, { host: '0.0.0.0', port: 8080 });
+
+// Multiple agents
+serve([agent1, agent2], { port: 8080 });
+```
+
+### Endpoints
+
+| Method | Path                   | Description                 |
+| ------ | ---------------------- | --------------------------- |
+| GET    | `/health`              | Runtime health status       |
+| GET    | `/_discover`           | Runtime and agent discovery |
+| GET    | `/agent/{name}/health` | Agent capabilities          |
+| POST   | `/agent/{name}/invoke` | Invoke agent                |
+| POST   | `/agent/{name}/chat`   | Chat with agent             |
+
+### Discovery Endpoint
+
+The `/_discover` endpoint returns runtime and agent information:
+
+```bash
+curl http://localhost:8080/_discover
+```
+
+```json
+{
+  "runtime": {
+    "version": "0.6.0",
+    "language": "typescript",
+    "framework": "hono"
+  },
+  "agents": [
+    {
+      "name": "my-agent",
+      "invoke": true,
+      "chat": true,
+      "metadata": {
+        "framework": "langchain",
+        "model": "gpt-4"
+      }
+    }
+  ]
+}
+```
+
+### Request/Response Types
+
+#### Invoke Request
+
+```typescript
+{
+  input: Record<string, unknown>;
+  stream?: boolean;  // default: false
+}
+```
+
+#### Invoke Response
+
+```typescript
+{
+  output: unknown;
+}
+```
+
+#### Chat Request
+
+```typescript
+{
+  messages: Array<{
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | unknown[] | null;
+    name?: string;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+  }>;
+  stream?: boolean;  // default: false
+}
+```
+
+#### Chat Response
+
+```typescript
+{
+  message: {
+    role: 'assistant';
+    content: string | unknown[] | null;
+    tool_calls?: ToolCall[];
   };
-};
+}
 ```
 
-## Components
+#### Streaming Response (SSE)
+
+When `stream: true`, responses are Server-Sent Events:
 
-### Types
+```
+data: {"chunk": "Hello "}
+
+data: {"chunk": "World!"}
+
+data: [DONE]
+```
 
-- `Message` - Conversation message
-- `ToolCall` - Tool call made by an agent
-- `Context` - Persistent resources provided to handlers
-- `Request` - Current invocation request
-- `Response` - Handler response
-- `MemoryStore` - Memory store interface
-- `KnowledgeBase` - Knowledge base interface
-- `ToolRegistry` - Tool registry interface
-- `AgentHandler` - Agent handler function type
-- `ToolHandler` - Tool handler function type
+## Error Handling
 
-### Utilities
+The runtime handles errors appropriately:
 
-- `load_handler(handlerPath)` - Load a handler from a file
-- `discover_registry(handlerPath)` - Auto-discover handlers from a directory structure
-- `execute_handler(handler, context, request)` - Execute a handler with context and request
+- `404` - Agent not found
+- `400` - Invalid request (missing input/messages, validation errors)
+- `501` - Handler not implemented
+- `502` - Agent handler returned invalid response
+- `500` - Internal server error
 
 ## License
 

package/dist/agent.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Agent class for building AI agents that integrate with Reminix.
+ */
+import type { AgentInfo, ChatHandler, ChatMessage, ChatResponse, Context, InvokeHandler, InvokeInput, InvokeResponse, StreamChunk } from './types';
+/**
+ * Options for creating an Agent.
+ */
+export interface AgentOptions {
+    /**
+     * Optional metadata for the agent (e.g., framework, model, description).
+     */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Agent class for defining invoke and chat handlers.
+ *
+ * Handlers can optionally receive a context parameter with conversation
+ * and user information.
+ *
+ * @example
+ * ```typescript
+ * const agent = new Agent('my-agent');
+ *
+ * agent.onInvoke(async (input, ctx) => {
+ *   // ctx has: conversationId, userId, custom
+ *   return { output: `Processed: ${input.message}` };
+ * });
+ *
+ * agent.onChat(async (messages, ctx) => {
+ *   return {
+ *     message: { role: 'assistant', content: `Hello, user ${ctx?.userId}!` }
+ *   };
+ * });
+ * ```
+ */
+export declare class Agent {
+    readonly name: string;
+    private readonly _metadata;
+    private invokeHandler;
+    private chatHandler;
+    /**
+     * Create a new Agent.
+     *
+     * @param name - Unique identifier for the agent (lowercase letters, numbers, hyphens, underscores)
+     * @param options - Optional configuration including metadata
+     * @throws {Error} If name is empty or contains invalid characters
+     */
+    constructor(name: string, options?: AgentOptions);
+    /**
+     * Get the agent's metadata.
+     */
+    get metadata(): Record<string, unknown>;
+    /**
+     * Get agent information for discovery.
+     */
+    toInfo(): AgentInfo;
+    /**
+     * Whether an invoke handler is registered.
+     */
+    get hasInvoke(): boolean;
+    /**
+     * Whether a chat handler is registered.
+     */
+    get hasChat(): boolean;
+    /**
+     * Register an invoke handler.
+     *
+     * @param handler - Function that processes invoke requests
+     * @returns The agent instance for chaining
+     *
+     * @example
+     * ```typescript
+     * agent.onInvoke(async (input) => {
+     *   return { output: processData(input) };
+     * });
+     * ```
+     */
+    onInvoke(handler: InvokeHandler): this;
+    /**
+     * Register a chat handler.
+     *
+     * @param handler - Function that processes chat requests
+     * @returns The agent instance for chaining
+     *
+     * @example
+     * ```typescript
+     * agent.onChat(async (messages) => {
+     *   return {
+     *     message: { role: 'assistant', content: 'Hello!' }
+     *   };
+     * });
+     * ```
+     */
+    onChat(handler: ChatHandler): this;
+    /**
+     * Handle an invoke request.
+     *
+     * @param input - The input data from the request
+     * @param ctx - Optional request context
+     * @returns The response or an async generator for streaming
+     * @throws {Error} If no invoke handler is registered
+     * @throws {Error} If the response is invalid
+     */
+    handleInvoke(input: InvokeInput, ctx?: Context): Promise<InvokeResponse | AsyncGenerator<StreamChunk, void, unknown>>;
+    /**
+     * Handle a chat request.
+     *
+     * @param messages - The conversation messages
+     * @param ctx - Optional request context
+     * @returns The response or an async generator for streaming
+     * @throws {Error} If no chat handler is registered
+     * @throws {Error} If the response is invalid
+     */
+    handleChat(messages: ChatMessage[], ctx?: Context): Promise<ChatResponse | AsyncGenerator<StreamChunk, void, unknown>>;
+    /**
+     * String representation for debugging.
+     */
+    toString(): string;
+}
+/**
+ * Error thrown when a handler is not implemented.
+ */
+export declare class NotImplementedError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown when an agent handler returns invalid data.
+ */
+export declare class AgentError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=agent.d.ts.map

package/dist/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,WAAW,EACX,WAAW,EACX,YAAY,EAEZ,OAAO,EACP,aAAa,EACb,WAAW,EACX,cAAc,EAEd,WAAW,EACZ,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAmBD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,KAAK;IAChB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;IACpD,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,WAAW,CAA4B;IAE/C;;;;;;OAMG;gBACS,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;IAgBhD;;OAEG;IACH,IAAI,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEtC;IAED;;OAEG;IACH,MAAM,IAAI,SAAS;IASnB;;OAEG;IACH,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAKtC;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAKlC;;;;;;;;OAQG;IACG,YAAY,CAChB,KAAK,EAAE,WAAW,EAClB,GAAG,CAAC,EAAE,OAAO,GACZ,OAAO,CAAC,cAAc,GAAG,cAAc,CAAC,WAAW,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAoBvE;;;;;;;;OAQG;IACG,UAAU,CACd,QAAQ,EAAE,WAAW,EAAE,EACvB,GAAG,CAAC,EAAE,OAAO,GACZ,OAAO,CAAC,YAAY,GAAG,cAAc,CAAC,WAAW,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAyBrE;;OAEG;IACH,QAAQ,IAAI,MAAM;CAMnB;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,qBAAa,UAAW,SAAQ,KAAK;gBACvB,OAAO,EAAE,MAAM;CAI5B"}

package/dist/agent.js

@@ -0,0 +1,207 @@
+/**
+ * Agent class for building AI agents that integrate with Reminix.
+ */
+/**
+ * Pattern for valid agent names: lowercase letters, numbers, hyphens, underscores.
+ */
+const VALID_NAME_PATTERN = /^[a-z0-9_-]+$/;
+/**
+ * Check if a value is an async generator.
+ */
+function isAsyncGenerator(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        Symbol.asyncIterator in value &&
+        typeof value.next === 'function');
+}
+/**
+ * Agent class for defining invoke and chat handlers.
+ *
+ * Handlers can optionally receive a context parameter with conversation
+ * and user information.
+ *
+ * @example
+ * ```typescript
+ * const agent = new Agent('my-agent');
+ *
+ * agent.onInvoke(async (input, ctx) => {
+ *   // ctx has: conversationId, userId, custom
+ *   return { output: `Processed: ${input.message}` };
+ * });
+ *
+ * agent.onChat(async (messages, ctx) => {
+ *   return {
+ *     message: { role: 'assistant', content: `Hello, user ${ctx?.userId}!` }
+ *   };
+ * });
+ * ```
+ */
+export class Agent {
+    /**
+     * Create a new Agent.
+     *
+     * @param name - Unique identifier for the agent (lowercase letters, numbers, hyphens, underscores)
+     * @param options - Optional configuration including metadata
+     * @throws {Error} If name is empty or contains invalid characters
+     */
+    constructor(name, options) {
+        this.invokeHandler = null;
+        this.chatHandler = null;
+        if (!name || name.trim() === '') {
+            throw new Error('Agent name cannot be empty');
+        }
+        if (!VALID_NAME_PATTERN.test(name)) {
+            throw new Error(`Agent name "${name}" contains invalid characters. ` +
+                'Use only lowercase letters, numbers, hyphens, and underscores.');
+        }
+        this.name = name;
+        this._metadata = options?.metadata ?? {};
+    }
+    /**
+     * Get the agent's metadata.
+     */
+    get metadata() {
+        return this._metadata;
+    }
+    /**
+     * Get agent information for discovery.
+     */
+    toInfo() {
+        return {
+            name: this.name,
+            invoke: this.hasInvoke,
+            chat: this.hasChat,
+            metadata: this._metadata,
+        };
+    }
+    /**
+     * Whether an invoke handler is registered.
+     */
+    get hasInvoke() {
+        return this.invokeHandler !== null;
+    }
+    /**
+     * Whether a chat handler is registered.
+     */
+    get hasChat() {
+        return this.chatHandler !== null;
+    }
+    /**
+     * Register an invoke handler.
+     *
+     * @param handler - Function that processes invoke requests
+     * @returns The agent instance for chaining
+     *
+     * @example
+     * ```typescript
+     * agent.onInvoke(async (input) => {
+     *   return { output: processData(input) };
+     * });
+     * ```
+     */
+    onInvoke(handler) {
+        this.invokeHandler = handler;
+        return this;
+    }
+    /**
+     * Register a chat handler.
+     *
+     * @param handler - Function that processes chat requests
+     * @returns The agent instance for chaining
+     *
+     * @example
+     * ```typescript
+     * agent.onChat(async (messages) => {
+     *   return {
+     *     message: { role: 'assistant', content: 'Hello!' }
+     *   };
+     * });
+     * ```
+     */
+    onChat(handler) {
+        this.chatHandler = handler;
+        return this;
+    }
+    /**
+     * Handle an invoke request.
+     *
+     * @param input - The input data from the request
+     * @param ctx - Optional request context
+     * @returns The response or an async generator for streaming
+     * @throws {Error} If no invoke handler is registered
+     * @throws {Error} If the response is invalid
+     */
+    async handleInvoke(input, ctx) {
+        if (!this.invokeHandler) {
+            throw new NotImplementedError('Invoke handler not implemented');
+        }
+        const result = await this.invokeHandler(input, ctx ?? {});
+        // If it's a generator, return it for streaming
+        if (isAsyncGenerator(result)) {
+            return result;
+        }
+        // Validate non-streaming response
+        if (!('output' in result)) {
+            throw new AgentError('Invoke handler must return an object with "output" field');
+        }
+        return result;
+    }
+    /**
+     * Handle a chat request.
+     *
+     * @param messages - The conversation messages
+     * @param ctx - Optional request context
+     * @returns The response or an async generator for streaming
+     * @throws {Error} If no chat handler is registered
+     * @throws {Error} If the response is invalid
+     */
+    async handleChat(messages, ctx) {
+        if (!this.chatHandler) {
+            throw new NotImplementedError('Chat handler not implemented');
+        }
+        const result = await this.chatHandler(messages, ctx ?? {});
+        // If it's a generator, return it for streaming
+        if (isAsyncGenerator(result)) {
+            return result;
+        }
+        // Validate non-streaming response
+        if (!('message' in result)) {
+            throw new AgentError('Chat handler must return an object with "message" field');
+        }
+        const message = result.message;
+        if (!message || message.role !== 'assistant') {
+            throw new AgentError('Chat handler must return a message with role "assistant"');
+        }
+        return result;
+    }
+    /**
+     * String representation for debugging.
+     */
+    toString() {
+        const capabilities = [];
+        if (this.hasInvoke)
+            capabilities.push('invoke');
+        if (this.hasChat)
+            capabilities.push('chat');
+        return `Agent(${this.name}, ${capabilities.length > 0 ? capabilities.join(', ') : 'no handlers'})`;
+    }
+}
+/**
+ * Error thrown when a handler is not implemented.
+ */
+export class NotImplementedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NotImplementedError';
+    }
+}
+/**
+ * Error thrown when an agent handler returns invalid data.
+ */
+export class AgentError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AgentError';
+    }
+}
+//# sourceMappingURL=agent.js.map

package/dist/agent.js.map

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

package/dist/index.d.ts

@@ -1,9 +1,31 @@
 /**
- * Reminix Runtime Types
- * @packageDocumentation
+ * Reminix Agent Runtime
+ *
+ * Build AI agents that integrate seamlessly with the Reminix API.
+ *
+ * @example
+ * ```typescript
+ * import { Agent, serve } from '@reminix/runtime';
+ *
+ * const agent = new Agent('my-agent');
+ *
+ * agent.onInvoke(async (input) => {
+ *   return { output: `Processed: ${input.message}` };
+ * });
+ *
+ * agent.onChat(async (messages) => {
+ *   const lastMessage = messages[messages.length - 1];
+ *   return {
+ *     message: { role: 'assistant', content: `Reply to: ${lastMessage.content}` }
+ *   };
+ * });
+ *
+ * serve(agent, { port: 8080 });
+ * ```
  */
-export type { Message, ToolCall, Context, Request, Response, MemoryStore, KnowledgeBase, ToolRegistry, ToolHandler, AgentHandler, } from './types';
-export { loadHandler, isFile, type LoadedHandler } from './loader';
-export { discoverRegistry, type Registry } from './registry';
-export { executeAgent, executeTool, executeHandler } from './executor';
+export type { ToolCallFunction, ToolCall, MessageRole, ChatMessage, AssistantMessage, InvokeRequest, ChatRequest, InvokeResponse, ChatResponse, StreamChunk, Context, InvokeInput, InvokeResult, ChatResult, InvokeHandler, ChatHandler, AgentHealth, HealthResponse, AgentMetadata, AgentInfo, RuntimeInfo, DiscoverResponse, } from './types';
+export { ToolCallFunctionSchema, ToolCallSchema, MessageRoleSchema, ChatMessageSchema, AssistantMessageSchema, InvokeRequestSchema, ChatRequestSchema, InvokeResponseSchema, ChatResponseSchema, StreamChunkSchema, } from './types';
+export { Agent, NotImplementedError, AgentError, type AgentOptions } from './agent';
+export { serve, createApp, type ServeOptions } from './server';
+export { formatSseEvent, formatSseDone, streamToSse } from './streaming';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,YAAY,EACV,OAAO,EACP,QAAQ,EACR,OAAO,EACP,OAAO,EACP,QAAQ,EACR,WAAW,EACX,aAAa,EACb,YAAY,EACZ,WAAW,EACX,YAAY,GACb,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC;AACnE,OAAO,EAAE,gBAAgB,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,YAAY,EAEV,gBAAgB,EAChB,QAAQ,EACR,WAAW,EACX,WAAW,EACX,gBAAgB,EAEhB,aAAa,EACb,WAAW,EAEX,cAAc,EACd,YAAY,EACZ,WAAW,EAEX,OAAO,EAEP,WAAW,EACX,YAAY,EACZ,UAAU,EACV,aAAa,EACb,WAAW,EAEX,WAAW,EACX,cAAc,EAEd,aAAa,EACb,SAAS,EACT,WAAW,EACX,gBAAgB,GACjB,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,sBAAsB,EACtB,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,sBAAsB,EACtB,mBAAmB,EACnB,iBAAiB,EACjB,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,KAAK,EAAE,mBAAmB,EAAE,UAAU,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAGpF,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,YAAY,EAAE,MAAM,UAAU,CAAC;AAG/D,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}