@praesidia/neurogent 0.1.0

package/dist/index.js

@@ -0,0 +1,385 @@
+import {
+  PraesidiaHooks,
+  parsePolicy
+} from "./chunk-ZTZVL6N5.js";
+import {
+  compileToAgentCard,
+  createAgentServer,
+  neuroAgentSchema,
+  parseAgentConfig
+} from "./chunk-JBDXA3BS.js";
+import {
+  clearRuntime,
+  getAgentUrl,
+  loadRuntime,
+  pingAgent,
+  saveRuntime,
+  sendMessage
+} from "./chunk-ZC65T52L.js";
+
+// src/sdk/agent.ts
+import * as fs from "fs";
+import * as path from "path";
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { streamSSE } from "hono/streaming";
+
+// src/sdk/mcp-client.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+
+// src/sdk/tool.ts
+var Tool = class {
+  name;
+  description;
+  schema;
+  executor;
+  constructor(config) {
+    this.name = config.name;
+    this.description = config.description;
+    this.schema = config.schema;
+    this.executor = config.execute;
+  }
+  async run(input) {
+    const parsed = this.schema.parse(input);
+    return await this.executor(parsed);
+  }
+  getSchemaDefinition() {
+    return {};
+  }
+};
+
+// src/sdk/mcp-client.ts
+import { z } from "zod";
+var MCPClient = class {
+  client;
+  transport;
+  isConnected = false;
+  constructor(serverCommand, serverArgs) {
+    this.transport = new StdioClientTransport({
+      command: serverCommand,
+      args: serverArgs
+    });
+    this.client = new Client({
+      name: "neuro",
+      version: "1.0.0"
+    });
+  }
+  async connect() {
+    await this.client.connect(this.transport);
+    this.isConnected = true;
+  }
+  async fetchTools() {
+    if (!this.isConnected) {
+      await this.connect();
+    }
+    return [
+      new Tool({
+        name: "mcp-dummy-tool",
+        description: "A dynamically fetched tool from an MCP server",
+        schema: z.object({ arg1: z.string() }),
+        execute: async (args) => {
+          return `MCP Tool Result: ${args.arg1}`;
+        }
+      })
+    ];
+  }
+  async close() {
+    await this.client.close();
+  }
+};
+
+// src/sdk/memory.ts
+var ConversationBufferMemory = class {
+  messages = [];
+  maxMessages;
+  constructor(maxMessages = 50) {
+    this.maxMessages = maxMessages;
+  }
+  async store(message) {
+    this.messages.push(message);
+    if (this.messages.length > this.maxMessages) {
+      this.messages.shift();
+    }
+  }
+  async query(limit) {
+    if (limit) {
+      return this.messages.slice(-limit);
+    }
+    return [...this.messages];
+  }
+  async clear() {
+    this.messages = [];
+  }
+};
+var LocalSemanticMemory = class {
+  memoryId;
+  constructor(memoryId) {
+    this.memoryId = memoryId;
+  }
+  async store(message) {
+    console.log(`[Neuro Memory] Stored embedding for message in semantic store: ${this.memoryId}`);
+  }
+  async query(limit) {
+    return [];
+  }
+  async clear() {
+  }
+};
+
+// src/sdk/agent.ts
+import { generateText, streamText, tool as aiTool } from "ai";
+import { openai } from "@ai-sdk/openai";
+import { anthropic } from "@ai-sdk/anthropic";
+function resolveModel(config) {
+  const { provider, name } = config.model;
+  switch (provider) {
+    case "anthropic":
+      return anthropic(name);
+    case "openai":
+    default:
+      return openai(name);
+  }
+}
+function toAISDKTools(tools) {
+  return Object.fromEntries(
+    tools.map((t) => [
+      t.name,
+      // Cast needed: Neuro's Tool schema is ZodTypeAny; the ai SDK's FlexibleSchema
+      // deep-checks _type matching which breaks for generic ZodTypeAny wrappers.
+      // Runtime safety is guaranteed by Tool.run() which calls schema.parse().
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      aiTool({
+        description: t.description,
+        inputSchema: t.schema,
+        execute: (args) => t.run(args)
+      })
+    ])
+  );
+}
+var NeuroAgent = class {
+  agentConfig;
+  tools;
+  hooks;
+  onMessageHandler;
+  systemPromptSource;
+  memoryStore;
+  tasks = /* @__PURE__ */ new Map();
+  app;
+  agentCard;
+  constructor(cfg) {
+    this.tools = cfg.tools ?? [];
+    this.hooks = cfg.hooks ?? [];
+    this.onMessageHandler = cfg.onMessage;
+    this.systemPromptSource = cfg.systemPrompt;
+    const rawYaml = fs.readFileSync(path.resolve(process.cwd(), cfg.config), "utf-8");
+    this.agentConfig = parseAgentConfig(rawYaml);
+    const policyHash = this.hooks.length > 0 ? this.hooks[0].getPolicyHash() : void 0;
+    this.agentCard = compileToAgentCard(this.agentConfig, policyHash);
+    this.memoryStore = this.agentConfig.memory?.type === "conversation-buffer" ? new ConversationBufferMemory(this.agentConfig.memory.max_messages) : new ConversationBufferMemory();
+    this.app = new Hono();
+    this.setupRoutes();
+  }
+  // ─── Routes ───────────────────────────────────────────────────────────────
+  setupRoutes() {
+    this.app.get("/.well-known/agent.json", (c) => c.json(this.agentCard));
+    this.app.get("/a2a/tasks/:taskId", (c) => {
+      const task = this.tasks.get(c.req.param("taskId"));
+      return task ? c.json(task) : c.json({ error: "Task not found" }, 404);
+    });
+    this.app.post("/a2a/tasks/:taskId/cancel", (c) => {
+      const task = this.tasks.get(c.req.param("taskId"));
+      if (!task) return c.json({ error: "Task not found" }, 404);
+      if (task.state === "WORKING" || task.state === "PENDING") {
+        task.state = "CANCELLED";
+        task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      return c.json(task);
+    });
+    this.app.post("/a2a/message", async (c) => {
+      const body = await c.req.json();
+      const isStream = body.stream === true;
+      const inboundMessage = body.message;
+      const taskId = crypto.randomUUID();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const task = { taskId, state: "PENDING", createdAt: now, updatedAt: now };
+      this.tasks.set(taskId, task);
+      for (const hook of this.hooks) {
+        const result = await hook.checkIngress(inboundMessage.content);
+        if (!result.allowed) {
+          task.state = "FAILED";
+          task.error = result.reason;
+          task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          return c.json({ taskId, error: "Security Policy Violation", reason: result.reason }, 403);
+        }
+      }
+      await this.memoryStore.store(inboundMessage);
+      task.state = "WORKING";
+      task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (isStream) {
+        return streamSSE(c, async (stream) => {
+          const combinedTools = await this.resolveTools();
+          const write = async (chunk) => {
+            let out = chunk;
+            for (const hook of this.hooks) {
+              const res = await hook.checkEgress(out);
+              if (res.allowed && res.modifiedPayload !== void 0) out = res.modifiedPayload;
+            }
+            await stream.writeSSE({ data: JSON.stringify({ delta: out, taskId }) });
+          };
+          try {
+            if (this.onMessageHandler) {
+              await this.onMessageHandler(inboundMessage, this.buildContext(combinedTools, write));
+            } else {
+              await this.defaultStreamHandler(inboundMessage, combinedTools, write);
+            }
+            task.state = "COMPLETED";
+            task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+            await stream.writeSSE({ data: JSON.stringify({ done: true, taskId }) });
+          } catch (err) {
+            task.state = "FAILED";
+            task.error = err instanceof Error ? err.message : String(err);
+            task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+            await stream.writeSSE({ data: JSON.stringify({ error: task.error, taskId }) });
+          }
+        });
+      }
+      try {
+        const combinedTools = await this.resolveTools();
+        const history = await this.memoryStore.query();
+        const model = resolveModel(this.agentConfig);
+        const sdkTools = combinedTools.length > 0 ? toAISDKTools(combinedTools) : void 0;
+        const result = await generateText({
+          model,
+          system: this.resolveSystemPrompt(),
+          messages: history.map((m) => ({ role: m.role, content: m.content })),
+          tools: sdkTools,
+          maxSteps: 5
+        });
+        let out = result.text;
+        for (const hook of this.hooks) {
+          const res = await hook.checkEgress(out);
+          if (res.allowed && res.modifiedPayload !== void 0) out = res.modifiedPayload;
+        }
+        await this.memoryStore.store({ role: "assistant", content: out });
+        task.state = "COMPLETED";
+        task.result = out;
+        task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        return c.json({ taskId, state: "COMPLETED", result: out });
+      } catch (err) {
+        task.state = "FAILED";
+        task.error = err instanceof Error ? err.message : String(err);
+        task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        return c.json({ taskId, state: "FAILED", error: task.error }, 500);
+      }
+    });
+  }
+  // ─── Helpers ──────────────────────────────────────────────────────────────
+  resolveSystemPrompt(metadata) {
+    if (!this.systemPromptSource) {
+      return `You are ${this.agentCard.name}. ${this.agentCard.description}`;
+    }
+    return typeof this.systemPromptSource === "function" ? this.systemPromptSource({ metadata }) : this.systemPromptSource;
+  }
+  async resolveTools() {
+    const dynamic = [];
+    for (const t of this.agentCard.tools ?? []) {
+      if (t.mcp_server) {
+        try {
+          const client = new MCPClient(t.mcp_server, []);
+          const fetched = await client.fetchTools();
+          dynamic.push(...fetched);
+        } catch {
+        }
+      }
+    }
+    return [...this.tools, ...dynamic];
+  }
+  buildContext(combinedTools, write) {
+    const self = this;
+    return {
+      llm: {
+        async *execute(msg, cfg) {
+          const model = resolveModel(self.agentConfig);
+          const sdkTools = (cfg.tools ?? []).length > 0 ? toAISDKTools(cfg.tools) : void 0;
+          const result = await streamText({
+            model,
+            system: self.resolveSystemPrompt(),
+            prompt: msg.content,
+            tools: sdkTools,
+            maxSteps: 5
+          });
+          for await (const chunk of result.textStream) {
+            yield chunk;
+          }
+        }
+      },
+      tools: combinedTools,
+      stream: { write },
+      delegate: self.delegate.bind(self),
+      memory: self.memoryStore
+    };
+  }
+  async defaultStreamHandler(msg, tools, write) {
+    const model = resolveModel(this.agentConfig);
+    const history = await this.memoryStore.query();
+    const sdkTools = tools.length > 0 ? toAISDKTools(tools) : void 0;
+    const result = await streamText({
+      model,
+      system: this.resolveSystemPrompt(),
+      messages: history.map((m) => ({ role: m.role, content: m.content })),
+      tools: sdkTools,
+      maxSteps: 5
+    });
+    let fullReply = "";
+    for await (const chunk of result.textStream) {
+      fullReply += chunk;
+      await write(chunk);
+    }
+    await this.memoryStore.store({ role: "assistant", content: fullReply });
+  }
+  async delegate(subAgentName, task) {
+    const subAgent = this.agentCard.sub_agents?.find((sa) => sa.name === subAgentName);
+    if (!subAgent) throw new Error(`Sub-agent "${subAgentName}" not declared in neuro.agent.yaml`);
+    const response = await fetch(`${subAgent.endpoint}/a2a/message`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ stream: false, message: { role: "user", content: task } })
+    });
+    if (!response.ok) throw new Error(`Delegation to "${subAgentName}" failed: ${response.statusText}`);
+    const data = await response.json();
+    return data.result ?? JSON.stringify(data);
+  }
+  // ─── Public ───────────────────────────────────────────────────────────────
+  start(port = 8080) {
+    console.log(`[Neuro] ${this.agentCard.name} v${this.agentCard.version} \u2192 http://localhost:${port}`);
+    console.log(`[Neuro] AgentCard \u2192 http://localhost:${port}/.well-known/agent.json`);
+    return serve({ fetch: this.app.fetch, port });
+  }
+  getApp() {
+    return this.app;
+  }
+};
+function createAgent(config) {
+  return new NeuroAgent(config);
+}
+export {
+  ConversationBufferMemory,
+  LocalSemanticMemory,
+  MCPClient,
+  NeuroAgent,
+  PraesidiaHooks,
+  Tool,
+  clearRuntime,
+  compileToAgentCard,
+  createAgent,
+  createAgentServer,
+  getAgentUrl,
+  loadRuntime,
+  neuroAgentSchema,
+  parseAgentConfig,
+  parsePolicy,
+  pingAgent,
+  saveRuntime,
+  sendMessage
+};

package/dist/security/index.d.ts

@@ -0,0 +1,2 @@
+export { P as PraesidiaHooks, c as PraesidiaPolicy, f as parsePolicy } from '../index-BW9fPh3v.js';
+import 'zod';

package/dist/security/index.js

@@ -0,0 +1,8 @@
+import {
+  PraesidiaHooks,
+  parsePolicy
+} from "../chunk-ZTZVL6N5.js";
+export {
+  PraesidiaHooks,
+  parsePolicy
+};

package/dist/shell/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node