@forwardimpact/svcagent 0.1.111 → 0.1.114

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "@forwardimpact/svcagent",
-  "version": "0.1.111",
+  "version": "0.1.114",
   "description": "Core orchestration service for Guide",
   "license": "Apache-2.0",
   "author": "D. Olsson <hi@senzilla.io>",
   "type": "module",
   "main": "index.js",
   "engines": {
-    "bun": ">=1.2.0"
+    "bun": ">=1.2.0",
+    "node": ">=18.0.0"
   },
   "scripts": {
-    "dev": "bun --watch server.js",
+    "dev": "node --watch server.js",
     "start": "bunx download && bun server.js",
     "test": "bun run node --test test/*.test.js"
   },
@@ -22,5 +23,11 @@
   },
   "devDependencies": {
     "@forwardimpact/libharness": "^0.1.5"
+  },
+  "files": [
+    "proto/"
+  ],
+  "publishConfig": {
+    "access": "public"
   }
 }

package/proto/agent.proto

@@ -0,0 +1,48 @@
+syntax = "proto3";
+
+package agent;
+
+import "common.proto";
+import "tool.proto";
+
+service Agent {
+  rpc ProcessStream(AgentRequest) returns (stream AgentResponse);
+  rpc ProcessUnary(AgentRequest) returns (AgentResponse);
+  rpc ListSubAgents(common.Empty) returns (tool.ToolCallResult);
+  rpc RunSubAgent(RunSubAgentRequest) returns (tool.ToolCallResult);
+  rpc ListHandoffs(ListHandoffsRequest) returns (tool.ToolCallResult);
+  rpc RunHandoff(RunHandoffRequest) returns (tool.ToolCallResult);
+}
+
+message AgentRequest {
+  repeated common.Message messages = 1;
+  optional string resource_id = 2;
+  optional string llm_token = 3;
+  optional string agent = 4;
+}
+
+message AgentResponse {
+  string object = 1;
+  int64 created = 2;
+  string model = 3;
+  common.Usage usage = 5;
+  string resource_id = 6;
+  repeated common.Message messages = 7;
+}
+
+message RunSubAgentRequest {
+  string resource_id = 1;
+  string agent_id = 2;
+  string prompt = 3;
+  optional string llm_token = 4;
+}
+
+message ListHandoffsRequest {
+  string resource_id = 1;
+  bool void = 2;  // Ensures non-empty schema for OpenAI function calling
+}
+
+message RunHandoffRequest {
+  string resource_id = 1;
+  string label = 2;
+}

package/server.js

@@ -1,48 +0,0 @@
-import { Server, createClient } from "@forwardimpact/librpc";
-import { createServiceConfig } from "@forwardimpact/libconfig";
-import { createResourceIndex } from "@forwardimpact/libresource";
-import { AgentMind, AgentHands } from "@forwardimpact/libagent";
-import { createTracer } from "@forwardimpact/librpc";
-import { createLogger } from "@forwardimpact/libtelemetry";
-
-import { AgentService } from "./index.js";
-
-const agentConfig = await createServiceConfig("agent");
-
-// Initialize observability
-const logger = createLogger("agent");
-const tracer = await createTracer("agent");
-
-const memoryClient = await createClient("memory", logger, tracer);
-const llmClient = await createClient("llm", logger, tracer);
-const toolClient = await createClient("tool", logger, tracer);
-
-const resourceIndex = createResourceIndex("resources");
-
-// Create callbacks for AgentHands and AgentMind
-const callbacks = {
-  memory: {
-    append: memoryClient.AppendMemory.bind(memoryClient),
-    get: memoryClient.GetWindow.bind(memoryClient),
-  },
-  llm: {
-    createCompletions: llmClient.CreateCompletions.bind(llmClient),
-  },
-  tool: {
-    call: toolClient.CallTool.bind(toolClient),
-  },
-};
-
-const agentHands = new AgentHands(callbacks, resourceIndex);
-const agentMind = new AgentMind(
-  agentConfig,
-  callbacks,
-  resourceIndex,
-  agentHands,
-);
-
-const service = new AgentService(agentConfig, agentMind, resourceIndex);
-
-const server = new Server(service, agentConfig, logger, tracer);
-
-await server.start();

package/test/agent.test.js

@@ -1,137 +0,0 @@
-import { test, describe, beforeEach } from "node:test";
-import assert from "node:assert";
-
-// Module under test
-import { AgentService } from "../index.js";
-import {
-  createMockServiceConfig,
-  createSilentLogger,
-  createMockResourceIndex,
-} from "@forwardimpact/libharness";
-
-describe("agent service", () => {
-  describe("AgentService", () => {
-    test("exports AgentService class", () => {
-      assert.strictEqual(typeof AgentService, "function");
-      assert.ok(AgentService.prototype);
-    });
-
-    test("AgentService has ProcessStream method", () => {
-      assert.strictEqual(
-        typeof AgentService.prototype.ProcessStream,
-        "function",
-      );
-    });
-
-    test("AgentService has ProcessUnary method", () => {
-      assert.strictEqual(
-        typeof AgentService.prototype.ProcessUnary,
-        "function",
-      );
-    });
-
-    test("AgentService constructor accepts expected parameters", () => {
-      // Test constructor signature by checking parameter count
-      assert.strictEqual(AgentService.length, 3); // config, agentMind, resourceIndex
-    });
-
-    test("AgentService has proper method signatures", () => {
-      const methods = Object.getOwnPropertyNames(AgentService.prototype);
-      assert(methods.includes("ProcessStream"));
-      assert(methods.includes("ProcessUnary"));
-      assert(methods.includes("constructor"));
-    });
-  });
-
-  describe("AgentService business logic", () => {
-    let mockConfig;
-    let mockAgentMind;
-    let mockResourceIndex;
-    let _mockLogger;
-
-    beforeEach(() => {
-      mockConfig = createMockServiceConfig("agent", {
-        assistant: "common.Assistant.test-assistant",
-      });
-
-      mockAgentMind = {
-        process: async () => ({
-          resource_id: "test-conversation",
-          choices: [
-            { message: { role: "assistant", content: "Test response" } },
-          ],
-        }),
-      };
-
-      mockResourceIndex = createMockResourceIndex();
-
-      _mockLogger = createSilentLogger();
-    });
-
-    test("constructor validates required dependencies", () => {
-      assert.throws(
-        () => new AgentService(mockConfig, null, mockResourceIndex),
-        /agentMind is required/,
-      );
-      assert.throws(
-        () => new AgentService(mockConfig, mockAgentMind, null),
-        /resourceIndex is required/,
-      );
-    });
-
-    test("ProcessStream throws error for missing user message", async () => {
-      const mockAgentMindWithError = {
-        process: async () => {
-          throw new Error("No user message found in request");
-        },
-      };
-
-      const service = new AgentService(
-        mockConfig,
-        mockAgentMindWithError,
-        mockResourceIndex,
-      );
-
-      const mockCall = {
-        request: { messages: [], llm_token: "test-token" },
-        write: () => {},
-        end: () => {},
-      };
-
-      await assert.rejects(
-        () => service.ProcessStream(mockCall),
-        /No user message found in request/,
-      );
-    });
-
-    test("creates service instance with all dependencies", () => {
-      const service = new AgentService(
-        mockConfig,
-        mockAgentMind,
-        mockResourceIndex,
-      );
-
-      assert.ok(service);
-      assert.strictEqual(service.config, mockConfig);
-    });
-
-    test("ProcessStream calls agentMind and returns response", async () => {
-      const service = new AgentService(
-        mockConfig,
-        mockAgentMind,
-        mockResourceIndex,
-      );
-
-      const mockCall = {
-        request: {
-          messages: [{ role: "user", content: "Hello" }],
-          llm_token: "test-token",
-        },
-        write: () => {},
-        end: () => {},
-      };
-
-      await service.ProcessStream(mockCall);
-    });
-  });
-});