@hilbras/omninode 0.2.0 → 0.4.0

package/dist/index.js

@@ -123,6 +123,8 @@ var agentConfigSchema = z.object({
   args: z.array(z.string()).optional(),
   cwd: z.string().optional(),
   env: z.record(z.string()).optional(),
+  input_mode: z.enum(["stdin", "arg", "protocol"]).default("stdin"),
+  timeout_ms: z.number().int().positive().optional(),
   metadata: z.record(z.unknown()).optional()
 }).strict();
 var roleConfigSchema = z.object({
@@ -234,6 +236,8 @@ function toAgentConfig(raw) {
     args: raw.args,
     cwd: raw.cwd,
     env: raw.env,
+    inputMode: raw.input_mode,
+    timeoutMs: raw.timeout_ms,
     metadata: raw.metadata
   };
 }
@@ -482,6 +486,49 @@ function inferHealth(error) {
   return status !== void 0 && status >= 500 ? "degraded" : "unreachable";
 }
 
+// src/providers/omnihilbras/index.ts
+var OmniHilbrasProvider = class extends OpenAICompatibleProvider {
+  /**
+   * Run the full connect flow. Throws on authentication or transport failure
+   * (use healthCheck() for a non-throwing probe).
+   */
+  async connect(registry) {
+    const apiKey = resolveApiKey(this.config);
+    const discovered = await this.listModels();
+    const seen = /* @__PURE__ */ new Set();
+    const models = [];
+    const duplicates = [];
+    for (const model of discovered) {
+      if (seen.has(model.id)) {
+        duplicates.push(model.id);
+        continue;
+      }
+      seen.add(model.id);
+      models.push({
+        ...model,
+        provider: this.config.name,
+        status: "available",
+        metadata: { ...model.metadata, gateway: "omnihilbras" }
+      });
+    }
+    if (registry) {
+      for (const model of models) registry.register(model);
+    }
+    const message = `Authenticated${apiKey ? " with API key" : " (no API key configured)"}; validated ${models.length} unique model(s)` + (duplicates.length > 0 ? `, skipped ${duplicates.length} duplicate(s)` : "") + ".";
+    const status = {
+      name: this.config.name,
+      type: this.config.type,
+      baseUrl: this.config.baseUrl,
+      health: "healthy",
+      connected: true,
+      modelCount: models.length,
+      lastCheckedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      message
+    };
+    return { status, models, duplicates, registered: registry ? models.length : 0 };
+  }
+};
+
 // src/providers/factory.ts
 var OPENAI_COMPATIBLE_TYPES = [
   "openai-compatible",
@@ -490,15 +537,12 @@ var OPENAI_COMPATIBLE_TYPES = [
   "custom"
 ];
 function createProvider(config) {
+  if (config.type === "omnihilbras") {
+    return new OmniHilbrasProvider(config);
+  }
   if (OPENAI_COMPATIBLE_TYPES.includes(config.type)) {
     return new OpenAICompatibleProvider(config);
   }
-  if (config.type === "omnihilbras") {
-    throw new OmniNodeError(
-      "NOT_IMPLEMENTED",
-      `Provider type "omnihilbras" is planned for Phase 2 (OmniHilbras Integration). If your OmniHilbras endpoint is OpenAI-compatible, use type "openai-compatible" for now.`
-    );
-  }
   throw new OmniNodeError("NOT_IMPLEMENTED", `Provider type "${config.type}" has no adapter yet.`);
 }
 
@@ -551,10 +595,290 @@ var ModelRegistry = class {
   }
 };
 
+// src/agents/process/index.ts
+import { spawn } from "child_process";
+var DEFAULT_TIMEOUT_MS2 = 6e5;
+var KILL_GRACE_MS = 5e3;
+function composeTaskText(input) {
+  const sections = [`# Objective
+${input.objective}`];
+  if (input.role) {
+    const lines = ["# Role", `${input.role.name} (${input.role.id})`];
+    if (input.role.responsibilities.length > 0) {
+      lines.push("", "Responsibilities:", ...input.role.responsibilities.map((r) => `- ${r}`));
+    }
+    if (input.role.expectedOutputs.length > 0) {
+      lines.push("", "Expected outputs:", ...input.role.expectedOutputs.map((o) => `- ${o}`));
+    }
+    sections.push(lines.join("\n"));
+  }
+  if (input.context) sections.push(`# Context
+${input.context}`);
+  if (input.instruction) sections.push(`# Instruction
+${input.instruction}`);
+  return sections.join("\n\n");
+}
+function buildProtocolMessages(input, agentName) {
+  const meta = {
+    taskId: input.taskId,
+    agent: agentName,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const messages = [
+    { type: "TASK", payload: { taskId: input.taskId, objective: input.objective } }
+  ];
+  if (input.role) messages.push({ type: "ROLE", payload: input.role });
+  if (input.context) messages.push({ type: "CONTEXT", payload: { body: input.context } });
+  if (input.instruction) messages.push({ type: "INSTRUCTION", payload: { text: input.instruction } });
+  return messages.map((message) => JSON.stringify({ meta, message }));
+}
+var ProcessAgent = class {
+  config;
+  info;
+  log;
+  running = /* @__PURE__ */ new Map();
+  constructor(config, log = logger) {
+    if (!config.command) {
+      throw new AgentError("AGENT_NOT_FOUND", `Agent "${config.name}" has no command configured.`);
+    }
+    this.config = config;
+    this.log = log.child({ agent: config.name });
+    this.info = {
+      name: config.name,
+      integration: "process",
+      command: config.command,
+      cwd: config.cwd,
+      status: "ready",
+      capabilities: [config.inputMode ?? "stdin"]
+    };
+  }
+  async run(input) {
+    const command = this.config.command;
+    if (!command) {
+      throw new AgentError("AGENT_NOT_FOUND", `Agent "${this.config.name}" has no command configured.`);
+    }
+    const mode = this.config.inputMode ?? "stdin";
+    const timeoutMs = this.config.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+    return new Promise((resolve, reject) => {
+      const child = spawn(
+        command,
+        [...this.config.args ?? [], ...mode === "arg" ? [composeTaskText(input)] : []],
+        {
+          cwd: this.config.cwd,
+          env: { ...process.env, ...this.config.env },
+          stdio: ["pipe", "pipe", "pipe"]
+        }
+      );
+      this.running.set(input.taskId, child);
+      let stdout = "";
+      let stderr = "";
+      let timedOut = false;
+      let settled = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        this.log.warn(`Task ${input.taskId} exceeded ${timeoutMs}ms \u2014 killing process.`);
+        child.kill("SIGTERM");
+        setTimeout(() => child.kill("SIGKILL"), KILL_GRACE_MS).unref();
+      }, timeoutMs);
+      const settle = (finish) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        this.running.delete(input.taskId);
+        finish();
+      };
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      child.stdin?.on("error", () => {
+      });
+      if (mode !== "arg") {
+        const payload = mode === "protocol" ? buildProtocolMessages(input, this.config.name).join("\n") + "\n" : composeTaskText(input) + "\n";
+        child.stdin?.write(payload);
+        child.stdin?.end();
+      }
+      child.on("error", (error) => {
+        settle(() => {
+          if (error.code === "ENOENT") {
+            reject(
+              new AgentError(
+                "AGENT_NOT_FOUND",
+                `Agent "${this.config.name}": command "${command}" was not found. Is it installed and on PATH?`,
+                { cause: error }
+              )
+            );
+            return;
+          }
+          reject(
+            new AgentError("AGENT_FAILED", `Agent "${this.config.name}" failed to start: ${error.message}.`, {
+              cause: error
+            })
+          );
+        });
+      });
+      child.on("close", (code, signal) => {
+        settle(() => {
+          if (timedOut) {
+            reject(
+              new AgentError(
+                "AGENT_TIMEOUT",
+                `Agent "${this.config.name}" timed out after ${timeoutMs}ms and was killed.`,
+                { details: { taskId: input.taskId, stdout: stdout.slice(0, 4e3), stderr: stderr.slice(0, 2e3) } }
+              )
+            );
+            return;
+          }
+          const logs = stderr.trim().length > 0 ? stderr.split("\n") : void 0;
+          if (mode === "protocol") {
+            try {
+              resolve(
+                interpretProtocolRun({
+                  input,
+                  agentName: this.config.name,
+                  stdout,
+                  exitCode: code,
+                  logs
+                })
+              );
+            } catch (error) {
+              reject(error);
+            }
+            return;
+          }
+          const trimmed = stdout.trim();
+          resolve({
+            taskId: input.taskId,
+            status: code === 0 ? "completed" : "failed",
+            summary: trimmed.length > 0 ? firstLine(trimmed) : void 0,
+            rawOutput: trimmed.length > 0 ? trimmed : void 0,
+            exitCode: code ?? void 0,
+            logs,
+            error: code === 0 ? void 0 : `Process exited with code ${code ?? "unknown"}${signal ? ` (signal: ${signal})` : ""}`
+          });
+        });
+      });
+    });
+  }
+  /** Ask the agent to stop current work (SIGTERM). */
+  async cancel(taskId) {
+    const child = this.running.get(taskId);
+    if (child) child.kill("SIGTERM");
+  }
+  runningTaskIds() {
+    return [...this.running.keys()];
+  }
+};
+function interpretProtocolRun({ input, agentName, stdout, exitCode, logs }) {
+  const reports = [];
+  let summary;
+  let error;
+  let sawProtocolMessage = false;
+  for (const line of stdout.split("\n")) {
+    const trimmed2 = line.trim();
+    if (trimmed2.length === 0) continue;
+    const message = parseAgentMessage(trimmed2);
+    if (!message) continue;
+    sawProtocolMessage = true;
+    if (message.type === "REPORT") {
+      const report = normalizeReport(message.payload, input.taskId, agentName, reports.length);
+      if (report) reports.push(report);
+    } else if (message.type === "COMPLETION") {
+      const payload = message.payload;
+      if (typeof payload?.summary === "string") summary = payload.summary;
+    } else if (message.type === "ERROR") {
+      const payload = message.payload;
+      const detail = typeof payload?.message === "string" ? payload.message : "unknown error";
+      const code = typeof payload?.code === "string" ? ` [${payload.code}]` : "";
+      error = `Agent error${code}: ${detail}`;
+    }
+  }
+  if (!sawProtocolMessage && exitCode === 0) {
+    throw new ProtocolError(
+      `Agent "${agentName}" produced no protocol messages on stdout (input mode "protocol").`,
+      { details: { taskId: input.taskId, stdout: stdout.slice(0, 2e3) } }
+    );
+  }
+  const trimmed = stdout.trim();
+  return {
+    taskId: input.taskId,
+    status: error !== void 0 || exitCode !== 0 ? "failed" : "completed",
+    summary: summary ?? reports[0]?.summary,
+    rawOutput: trimmed.length > 0 ? trimmed : void 0,
+    exitCode: exitCode ?? void 0,
+    logs,
+    reports: reports.length > 0 ? reports : void 0,
+    error: error ?? (exitCode !== 0 ? `Process exited with code ${exitCode ?? "unknown"}` : void 0)
+  };
+}
+function parseAgentMessage(line) {
+  try {
+    const parsed = JSON.parse(line);
+    if (typeof parsed.type === "string") {
+      return { type: parsed.type, payload: parsed.payload };
+    }
+    const inner = parsed.message;
+    if (inner && typeof inner.type === "string") {
+      return { type: inner.type, payload: inner.payload };
+    }
+  } catch {
+  }
+  return void 0;
+}
+function normalizeReport(payload, taskId, agentName, index) {
+  if (payload === null || typeof payload !== "object") return void 0;
+  const raw = payload;
+  if (typeof raw.summary !== "string") return void 0;
+  return {
+    id: typeof raw.id === "string" ? raw.id : `${taskId}-report-${index}`,
+    taskId: typeof raw.taskId === "string" ? raw.taskId : taskId,
+    agent: typeof raw.agent === "string" ? raw.agent : agentName,
+    summary: raw.summary,
+    findings: Array.isArray(raw.findings) ? raw.findings : [],
+    recommendations: Array.isArray(raw.recommendations) ? raw.recommendations : [],
+    createdAt: typeof raw.createdAt === "string" ? raw.createdAt : (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function firstLine(text, maxLength = 200) {
+  const line = text.split("\n", 1)[0] ?? text;
+  return line.length > maxLength ? `${line.slice(0, maxLength)}\u2026` : line;
+}
+
+// src/agents/factory.ts
+function createAgent(config) {
+  if (config.integration === "process") {
+    return new ProcessAgent(config);
+  }
+  if (config.integration === "native") {
+    throw new OmniNodeError(
+      "NOT_IMPLEMENTED",
+      `Native agent adapters are planned for a later phase. Use input over stdin/stdout (type "cli") for "${config.name}" for now.`
+    );
+  }
+  throw new OmniNodeError("NOT_IMPLEMENTED", `Agent integration "${config.integration}" has no adapter yet.`);
+}
+
+// src/agents/registry.ts
+var AgentRegistry = class {
+  agents = /* @__PURE__ */ new Map();
+  register(agent) {
+    this.agents.set(agent.info.name, agent);
+  }
+  get(name) {
+    return this.agents.get(name);
+  }
+  list() {
+    return [...this.agents.values()].sort((a, b) => a.info.name.localeCompare(b.info.name));
+  }
+};
+
 // src/version.ts
-var OMNINODE_VERSION = "0.2.0";
+var OMNINODE_VERSION = "0.4.0";
 export {
   AgentError,
+  AgentRegistry,
   ConfigError,
   ConsoleLogSink,
   Logger,
@@ -562,15 +886,19 @@ export {
   ModelRegistry,
   OMNINODE_VERSION,
   OPENAI_COMPATIBLE_TYPES,
+  OmniHilbrasProvider,
   OmniNodeError,
   OpenAICompatibleProvider,
   PipelineError,
+  ProcessAgent,
   ProtocolError,
   ProviderError,
   TaskError,
   agentConfigSchema,
   appConfigSchema,
   authHeaders,
+  composeTaskText,
+  createAgent,
   createProvider,
   defaultProjectConfigYaml,
   expandEnvRefs,