@praesidia/neurogent 0.1.0

package/dist/index-BW9fPh3v.d.ts

@@ -0,0 +1,372 @@
+import { z } from 'zod';
+
+/**
+ * Represents the fundamental A2A message types.
+ */
+interface A2AMessage {
+    jsonrpc: '2.0';
+    method: string;
+    params: Record<string, any>;
+    id?: string | number;
+}
+/**
+ * Common roles for standard conversational tasks.
+ */
+type Role = 'user' | 'assistant' | 'system' | 'tool';
+/**
+ * Message payload within the A2A specification.
+ */
+interface ConversationMessage {
+    role: Role;
+    content: string;
+    name?: string;
+    tool_call_id?: string;
+}
+/**
+ * A2A Standard Task states.
+ */
+type TaskState = 'PENDING' | 'WORKING' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'ESCALATION_REQUIRED';
+interface TaskStatus {
+    taskId: string;
+    state: TaskState;
+    createdAt: string;
+    updatedAt: string;
+    result?: any;
+    error?: string;
+}
+/**
+ * Generic hook result used by ingress/egress guards.
+ */
+interface HookResult {
+    allowed: boolean;
+    reason?: string;
+    modifiedPayload?: string;
+}
+/**
+ * Pluggable security/policy hook interface.
+ * Implement this to add ingress filtering, egress redaction,
+ * or tool-level authorization without coupling to any specific provider.
+ */
+interface AgentHook {
+    getPolicyHash(): string;
+    checkIngress(payload: string): Promise<HookResult>;
+    checkEgress(chunk: string): Promise<HookResult>;
+    checkTool(toolName: string): Promise<HookResult>;
+}
+/**
+ * A2A AgentCard representation.
+ * Exposed at /.well-known/agent.json
+ */
+interface AgentCard {
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    license: string;
+    capabilities: string[];
+    tools?: Array<{
+        name: string;
+        description: string;
+        type?: string;
+        mcp_server?: string;
+    }>;
+    endpoints: {
+        message: string;
+        tasks: string;
+    };
+    sub_agents?: Array<{
+        name: string;
+        description: string;
+        endpoint: string;
+    }>;
+    'x-praesidia-policy-hash'?: string;
+}
+
+declare const neuroAgentSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodString;
+    author: z.ZodString;
+    license: z.ZodString;
+    capabilities: z.ZodArray<z.ZodString, "many">;
+    model: z.ZodObject<{
+        provider: z.ZodString;
+        name: z.ZodString;
+        temperature: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        max_tokens: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        provider: string;
+        temperature: number;
+        max_tokens: number;
+    }, {
+        name: string;
+        provider: string;
+        temperature?: number | undefined;
+        max_tokens?: number | undefined;
+    }>;
+    memory: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<["conversation-buffer", "redis", "none"]>;
+        max_messages: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "conversation-buffer" | "redis" | "none";
+        max_messages: number;
+    }, {
+        type: "conversation-buffer" | "redis" | "none";
+        max_messages?: number | undefined;
+    }>>>;
+    tools: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["inline", "mcp"]>>>;
+        mcp_server: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        type: "inline" | "mcp";
+        mcp_server?: string | undefined;
+    }, {
+        name: string;
+        description: string;
+        type?: "inline" | "mcp" | undefined;
+        mcp_server?: string | undefined;
+    }>, "many">>>;
+    praesidia: z.ZodOptional<z.ZodObject<{
+        policy: z.ZodOptional<z.ZodString>;
+        enforce_on: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        enforce_on: string[];
+        policy?: string | undefined;
+    }, {
+        policy?: string | undefined;
+        enforce_on?: string[] | undefined;
+    }>>;
+    sub_agents: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        endpoint: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        endpoint: string;
+    }, {
+        name: string;
+        description: string;
+        endpoint: string;
+    }>, "many">>>;
+    auth: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<["bearer", "none", "oauth2"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "none" | "bearer" | "oauth2";
+    }, {
+        type: "none" | "bearer" | "oauth2";
+    }>>>;
+    endpoint: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    license: string;
+    capabilities: string[];
+    model: {
+        name: string;
+        provider: string;
+        temperature: number;
+        max_tokens: number;
+    };
+    memory: {
+        type: "conversation-buffer" | "redis" | "none";
+        max_messages: number;
+    };
+    tools: {
+        name: string;
+        description: string;
+        type: "inline" | "mcp";
+        mcp_server?: string | undefined;
+    }[];
+    endpoint: string;
+    sub_agents: {
+        name: string;
+        description: string;
+        endpoint: string;
+    }[];
+    auth: {
+        type: "none" | "bearer" | "oauth2";
+    };
+    praesidia?: {
+        enforce_on: string[];
+        policy?: string | undefined;
+    } | undefined;
+}, {
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    license: string;
+    capabilities: string[];
+    model: {
+        name: string;
+        provider: string;
+        temperature?: number | undefined;
+        max_tokens?: number | undefined;
+    };
+    memory?: {
+        type: "conversation-buffer" | "redis" | "none";
+        max_messages?: number | undefined;
+    } | undefined;
+    tools?: {
+        name: string;
+        description: string;
+        type?: "inline" | "mcp" | undefined;
+        mcp_server?: string | undefined;
+    }[] | undefined;
+    praesidia?: {
+        policy?: string | undefined;
+        enforce_on?: string[] | undefined;
+    } | undefined;
+    endpoint?: string | undefined;
+    sub_agents?: {
+        name: string;
+        description: string;
+        endpoint: string;
+    }[] | undefined;
+    auth?: {
+        type: "none" | "bearer" | "oauth2";
+    } | undefined;
+}>;
+type NeuroAgentConfig = z.infer<typeof neuroAgentSchema>;
+/**
+ * Parses raw YAML string into a validated NeuroAgentConfig
+ */
+declare function parseAgentConfig(yamlContent: string): NeuroAgentConfig;
+/**
+ * Compiles a NeuroAgentConfig into a standard A2A AgentCard
+ */
+declare function compileToAgentCard(config: NeuroAgentConfig, praesidiaHash?: string): AgentCard;
+
+declare const praesidiaPolicySchema: z.ZodObject<{
+    schema_version: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
+    enforcement: z.ZodDefault<z.ZodEnum<["strict", "permissive"]>>;
+    rules: z.ZodObject<{
+        ingress: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            rule: z.ZodString;
+            action: z.ZodEnum<["reject", "allow", "log"]>;
+        }, "strip", z.ZodTypeAny, {
+            action: "reject" | "allow" | "log";
+            rule: string;
+        }, {
+            action: "reject" | "allow" | "log";
+            rule: string;
+        }>, "many">>>;
+        egress: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            rule: z.ZodString;
+            types: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            action: z.ZodEnum<["modify", "reject", "allow"]>;
+        }, "strip", z.ZodTypeAny, {
+            action: "reject" | "allow" | "modify";
+            rule: string;
+            types?: string[] | undefined;
+        }, {
+            action: "reject" | "allow" | "modify";
+            rule: string;
+            types?: string[] | undefined;
+        }>, "many">>>;
+        tools: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            match: z.ZodString;
+            action: z.ZodEnum<["allow", "reject"]>;
+            require_human_approval: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            action: "reject" | "allow";
+            match: string;
+            require_human_approval?: boolean | undefined;
+        }, {
+            action: "reject" | "allow";
+            match: string;
+            require_human_approval?: boolean | undefined;
+        }>, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        tools: {
+            action: "reject" | "allow";
+            match: string;
+            require_human_approval?: boolean | undefined;
+        }[];
+        ingress: {
+            action: "reject" | "allow" | "log";
+            rule: string;
+        }[];
+        egress: {
+            action: "reject" | "allow" | "modify";
+            rule: string;
+            types?: string[] | undefined;
+        }[];
+    }, {
+        tools?: {
+            action: "reject" | "allow";
+            match: string;
+            require_human_approval?: boolean | undefined;
+        }[] | undefined;
+        ingress?: {
+            action: "reject" | "allow" | "log";
+            rule: string;
+        }[] | undefined;
+        egress?: {
+            action: "reject" | "allow" | "modify";
+            rule: string;
+            types?: string[] | undefined;
+        }[] | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    schema_version: string | number;
+    enforcement: "strict" | "permissive";
+    rules: {
+        tools: {
+            action: "reject" | "allow";
+            match: string;
+            require_human_approval?: boolean | undefined;
+        }[];
+        ingress: {
+            action: "reject" | "allow" | "log";
+            rule: string;
+        }[];
+        egress: {
+            action: "reject" | "allow" | "modify";
+            rule: string;
+            types?: string[] | undefined;
+        }[];
+    };
+}, {
+    schema_version: string | number;
+    rules: {
+        tools?: {
+            action: "reject" | "allow";
+            match: string;
+            require_human_approval?: boolean | undefined;
+        }[] | undefined;
+        ingress?: {
+            action: "reject" | "allow" | "log";
+            rule: string;
+        }[] | undefined;
+        egress?: {
+            action: "reject" | "allow" | "modify";
+            rule: string;
+            types?: string[] | undefined;
+        }[] | undefined;
+    };
+    enforcement?: "strict" | "permissive" | undefined;
+}>;
+type PraesidiaPolicy = z.infer<typeof praesidiaPolicySchema>;
+declare function parsePolicy(yamlContent: string): PraesidiaPolicy;
+
+declare class PraesidiaHooks implements AgentHook {
+    private policy;
+    private isPermissive;
+    constructor(policy?: PraesidiaPolicy);
+    static withPolicy(filePath: string): PraesidiaHooks;
+    getPolicyHash(): string;
+    checkIngress(payload: string): Promise<HookResult>;
+    checkEgress(chunk: string): Promise<HookResult>;
+    checkTool(toolName: string): Promise<HookResult>;
+}
+
+export { type AgentHook as A, type ConversationMessage as C, type HookResult as H, type NeuroAgentConfig as N, PraesidiaHooks as P, type Role as R, type TaskState as T, type A2AMessage as a, type AgentCard as b, type PraesidiaPolicy as c, type TaskStatus as d, compileToAgentCard as e, parsePolicy as f, neuroAgentSchema as n, parseAgentConfig as p };

package/dist/index.d.ts

@@ -0,0 +1,175 @@
+import { Hono } from 'hono';
+import { serve } from '@hono/node-server';
+import { C as ConversationMessage, A as AgentHook } from './index-BW9fPh3v.js';
+export { a as A2AMessage, b as AgentCard, H as HookResult, N as NeuroAgentConfig, P as PraesidiaHooks, c as PraesidiaPolicy, R as Role, T as TaskState, d as TaskStatus, e as compileToAgentCard, n as neuroAgentSchema, p as parseAgentConfig, f as parsePolicy } from './index-BW9fPh3v.js';
+import { z } from 'zod';
+
+interface ToolConfig<T extends z.ZodTypeAny> {
+    name: string;
+    description: string;
+    schema: T;
+    execute: (input: z.infer<T>) => Promise<any>;
+}
+declare class Tool<T extends z.ZodTypeAny = z.ZodTypeAny> {
+    name: string;
+    description: string;
+    schema: T;
+    private executor;
+    constructor(config: ToolConfig<T>);
+    run(input: any): Promise<any>;
+    getSchemaDefinition(): any;
+}
+type ToolDef = Tool;
+
+interface MemoryStore {
+    store(message: ConversationMessage): Promise<void>;
+    query(limit?: number): Promise<ConversationMessage[]>;
+    clear(): Promise<void>;
+}
+declare class ConversationBufferMemory implements MemoryStore {
+    private messages;
+    private maxMessages;
+    constructor(maxMessages?: number);
+    store(message: ConversationMessage): Promise<void>;
+    query(limit?: number): Promise<ConversationMessage[]>;
+    clear(): Promise<void>;
+}
+declare class LocalSemanticMemory implements MemoryStore {
+    private memoryId;
+    constructor(memoryId: string);
+    store(message: ConversationMessage): Promise<void>;
+    query(limit?: number): Promise<ConversationMessage[]>;
+    clear(): Promise<void>;
+}
+
+interface AgentContext {
+    llm: {
+        execute: (msg: ConversationMessage, config: {
+            tools?: Tool[];
+        }) => AsyncIterable<string>;
+    };
+    tools: Tool[];
+    stream: {
+        write: (chunk: string) => Promise<void>;
+    };
+    delegate: (subAgentName: string, task: string) => Promise<string>;
+    memory: MemoryStore;
+}
+interface AgentBuilderConfig {
+    config: string;
+    tools?: Tool[];
+    systemPrompt?: string | ((context: {
+        metadata?: Record<string, string>;
+    }) => string);
+    hooks?: AgentHook[];
+    onMessage?: (msg: ConversationMessage, ctx: AgentContext) => Promise<void>;
+}
+declare class NeuroAgent {
+    private agentConfig;
+    private tools;
+    private hooks;
+    private onMessageHandler?;
+    private systemPromptSource;
+    private memoryStore;
+    private tasks;
+    private app;
+    private agentCard;
+    constructor(cfg: AgentBuilderConfig);
+    private setupRoutes;
+    private resolveSystemPrompt;
+    private resolveTools;
+    private buildContext;
+    private defaultStreamHandler;
+    private delegate;
+    start(port?: number): ReturnType<typeof serve>;
+    getApp(): Hono;
+}
+declare function createAgent(config: AgentBuilderConfig): NeuroAgent;
+
+declare class MCPClient {
+    private client;
+    private transport;
+    private isConnected;
+    constructor(serverCommand: string, serverArgs: string[]);
+    connect(): Promise<void>;
+    fetchTools(): Promise<Tool<z.ZodTypeAny>[]>;
+    close(): Promise<void>;
+}
+
+type AgentId = string;
+interface AgentModel {
+    provider: 'openai' | 'anthropic' | 'ollama';
+    name: string;
+    maxTokens?: number;
+    temperature?: number;
+    baseUrl?: string;
+}
+interface AgentDef {
+    id: AgentId;
+    name: string;
+    role: string;
+    emoji: string;
+    inkColor: string;
+    expertise: string[];
+    systemPrompt: string;
+    model?: AgentModel;
+    zeroClawUrl?: string;
+}
+
+/**
+ * ZeroClaw Runtime — Hono HTTP server that exposes a Neurogent agent
+ * as a persistent, A2A-compatible service.
+ *
+ * Each agent gets its own server on a dedicated port:
+ *   GET  /health                  — liveness probe
+ *   GET  /.well-known/agent.json  — A2A AgentCard
+ *   POST /webhook                 — receive task/message
+ *   GET  /a2a/tasks/:taskId       — task status
+ */
+
+interface ZeroClawInstance {
+    agent: AgentDef;
+    port: number;
+    url: string;
+    startedAt: string;
+}
+declare function createAgentServer(agent: AgentDef, port: number, globalModel?: AgentModel): {
+    start: () => Promise<ZeroClawInstance>;
+    stop: () => void;
+};
+
+/**
+ * ZeroClaw Client — talks to running ZeroClaw agent servers.
+ * Used by the shell executor to route messages to persistent agents.
+ */
+interface ZeroClawRegistration {
+    agents: Array<{
+        id: string;
+        name: string;
+        url: string;
+        port: number;
+        pid?: number;
+        startedAt: string;
+    }>;
+    startedAt: string;
+}
+declare function loadRuntime(): ZeroClawRegistration | null;
+declare function saveRuntime(reg: ZeroClawRegistration): void;
+declare function clearRuntime(): void;
+declare function getAgentUrl(agentId: string): string | null;
+/**
+ * Health-checks a ZeroClaw instance.
+ */
+declare function pingAgent(url: string): Promise<{
+    alive: boolean;
+    agent?: string;
+    uptime?: number;
+    error?: string;
+}>;
+/**
+ * Send a message to a ZeroClaw agent and stream the response back.
+ * Falls back to non-streaming if the server doesn't support it.
+ */
+declare function sendMessage(url: string, message: string): AsyncGenerator<string>;
+
+export { type AgentBuilderConfig, type AgentContext, AgentHook, ConversationBufferMemory, ConversationMessage, LocalSemanticMemory, MCPClient, type MemoryStore, NeuroAgent, Tool, type ToolConfig, type ToolDef, type ZeroClawInstance, type ZeroClawRegistration, clearRuntime, createAgent, createAgentServer, getAgentUrl, loadRuntime, pingAgent, saveRuntime, sendMessage };