@tjamescouch/gro 1.3.4 → 1.3.6

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@tjamescouch/gro",
-  "version": "1.3.4",
+  "version": "1.3.6",
   "description": "Provider-agnostic LLM runtime with context management",
+  "bin": {
+    "gro": "./gro"
+  },
   "type": "module",
   "scripts": {
     "start": "npx tsx src/main.ts",

package/src/main.ts

@@ -25,8 +25,9 @@ import type { ChatDriver, ChatMessage, ChatOutput, TokenUsage } from "./drivers/
 import type { AgentMemory } from "./memory/agent-memory.js";
 import { bashToolDefinition, executeBash } from "./tools/bash.js";
 import { agentpatchToolDefinition, executeAgentpatch } from "./tools/agentpatch.js";
+import { groVersionToolDefinition, executeGroVersion, getGroVersion } from "./tools/version.js";
 
-const VERSION = "0.3.1";
+const VERSION = getGroVersion();
 
 // ---------------------------------------------------------------------------
 // Graceful shutdown state — module-level so signal handlers can save sessions.
@@ -497,6 +498,7 @@ async function executeTurn(
   const tools = mcp.getToolDefinitions();
   tools.push(agentpatchToolDefinition());
   if (cfg.bash) tools.push(bashToolDefinition());
+  tools.push(groVersionToolDefinition());
   let finalText = "";
   let turnTokensIn = 0;
   let turnTokensOut = 0;
@@ -579,6 +581,8 @@ async function executeTurn(
           result = executeAgentpatch(fnArgs);
         } else if (fnName === "bash" && cfg.bash) {
           result = executeBash(fnArgs);
+        } else if (fnName === "gro_version") {
+          result = executeGroVersion({ provider: cfg.provider, model: cfg.model, persistent: cfg.persistent });
         } else {
           result = await mcp.callTool(fnName, fnArgs);
         }

package/src/tools/version.ts

@@ -0,0 +1,98 @@
+/**
+ * Built-in version/identity tool for gro.
+ *
+ * Lets agents (and humans) introspect the gro runtime — version, provider,
+ * model, uptime, process info. This is the canonical way to confirm an
+ * agent is running on gro.
+ */
+import { readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const startTime = Date.now();
+
+interface GroRuntimeInfo {
+  runtime: "gro";
+  version: string;
+  provider: string;
+  model: string;
+  pid: number;
+  uptime_seconds: number;
+  node_version: string;
+  platform: string;
+  persistent: boolean;
+}
+
+/** Read version from package.json — single source of truth. */
+function readVersion(): string {
+  // In ESM, __dirname isn't available — derive from import.meta.url
+  let selfDir: string;
+  try {
+    selfDir = dirname(fileURLToPath(import.meta.url));
+  } catch {
+    selfDir = process.cwd();
+  }
+
+  const candidates = [
+    join(selfDir, "..", "package.json"),       // from dist/tools/ or src/tools/
+    join(selfDir, "..", "..", "package.json"),  // from deeper nesting
+    join(process.cwd(), "package.json"),
+  ];
+  for (const p of candidates) {
+    if (existsSync(p)) {
+      try {
+        const pkg = JSON.parse(readFileSync(p, "utf-8"));
+        if (pkg.name === "@tjamescouch/gro" && pkg.version) {
+          return pkg.version;
+        }
+      } catch {
+        // try next candidate
+      }
+    }
+  }
+  return "unknown";
+}
+
+// Cache version at module load
+const GRO_VERSION = readVersion();
+
+export function getGroVersion(): string {
+  return GRO_VERSION;
+}
+
+export function groVersionToolDefinition(): any {
+  return {
+    type: "function",
+    function: {
+      name: "gro_version",
+      description:
+        "Report gro runtime identity and version. Returns runtime name, version, provider, model, uptime, and process info. Use this to confirm an agent is running on gro.",
+      parameters: {
+        type: "object",
+        properties: {},
+      },
+    },
+  };
+}
+
+/**
+ * Execute the version tool. Requires runtime config to report provider/model.
+ */
+export function executeGroVersion(cfg: {
+  provider: string;
+  model: string;
+  persistent: boolean;
+}): string {
+  const info: GroRuntimeInfo = {
+    runtime: "gro",
+    version: GRO_VERSION,
+    provider: cfg.provider,
+    model: cfg.model,
+    pid: process.pid,
+    uptime_seconds: Math.floor((Date.now() - startTime) / 1000),
+    node_version: process.version,
+    platform: process.platform,
+    persistent: cfg.persistent,
+  };
+  return JSON.stringify(info, null, 2);
+}