@tjamescouch/gro 1.3.8 → 1.3.10

package/dist/main.js

@@ -22,6 +22,7 @@ import { groError, asError, isGroError, errorLogFields } from "./errors.js";
 import { bashToolDefinition, executeBash } from "./tools/bash.js";
 import { agentpatchToolDefinition, executeAgentpatch } from "./tools/agentpatch.js";
 import { groVersionToolDefinition, executeGroVersion, getGroVersion } from "./tools/version.js";
+import { createMarkerParser } from "./stream-markers.js";
 const VERSION = getGroVersion();
 // ---------------------------------------------------------------------------
 // Graceful shutdown state — module-level so signal handlers can save sessions.
@@ -480,6 +481,24 @@ function formatOutput(text, format) {
 // ---------------------------------------------------------------------------
 // Tool execution loop
 // ---------------------------------------------------------------------------
+/**
+ * Resolve short model aliases to full model identifiers.
+ * Allows stream markers like @@model-change('haiku')@@ without
+ * the model needing to know the full versioned name.
+ */
+const MODEL_ALIASES = {
+    "haiku": "claude-haiku-4-20250514",
+    "sonnet": "claude-sonnet-4-20250514",
+    "opus": "claude-opus-4-20250514",
+    "gpt4": "gpt-4o",
+    "gpt4o": "gpt-4o",
+    "gpt4o-mini": "gpt-4o-mini",
+    "o3": "o3",
+};
+function resolveModelAlias(alias) {
+    const lower = alias.trim().toLowerCase();
+    return MODEL_ALIASES[lower] ?? alias;
+}
 /**
  * Execute a single turn: call the model, handle tool calls, repeat until
  * the model produces a final text response or we hit maxRounds.
@@ -493,17 +512,37 @@ async function executeTurn(driver, memory, mcp, cfg, sessionId) {
     let finalText = "";
     let turnTokensIn = 0;
     let turnTokensOut = 0;
-    const onToken = cfg.outputFormat === "stream-json"
+    const rawOnToken = cfg.outputFormat === "stream-json"
         ? (t) => process.stdout.write(JSON.stringify({ type: "token", token: t }) + "\n")
         : (t) => process.stdout.write(t);
+    // Mutable model reference — stream markers can switch this mid-turn
+    let activeModel = cfg.model;
     let brokeCleanly = false;
     let idleNudges = 0;
     for (let round = 0; round < cfg.maxToolRounds; round++) {
+        // Create a fresh marker parser per round so partial state doesn't leak
+        const markerParser = createMarkerParser({
+            onToken: rawOnToken,
+            onMarker(marker) {
+                if (marker.name === "model-change") {
+                    const newModel = resolveModelAlias(marker.arg);
+                    Logger.info(`Stream marker: model-change '${marker.arg}' → ${newModel}`);
+                    activeModel = newModel;
+                    cfg.model = newModel; // persist across turns
+                    memory.setModel(newModel); // persist in session metadata on save
+                }
+                else {
+                    Logger.debug(`Stream marker: ${marker.name}('${marker.arg}')`);
+                }
+            },
+        });
         const output = await driver.chat(memory.messages(), {
-            model: cfg.model,
+            model: activeModel,
             tools: tools.length > 0 ? tools : undefined,
-            onToken,
+            onToken: markerParser.onToken,
         });
+        // Flush any remaining buffered tokens from the marker parser
+        markerParser.flush();
         // Track token usage for niki budget enforcement
         if (output.usage) {
             turnTokensIn += output.usage.inputTokens;
@@ -511,12 +550,13 @@ async function executeTurn(driver, memory, mcp, cfg, sessionId) {
             // Log cumulative usage to stderr — niki parses these patterns for budget enforcement
             process.stderr.write(`"input_tokens": ${turnTokensIn}, "output_tokens": ${turnTokensOut}\n`);
         }
-        // Accumulate text
-        if (output.text)
-            finalText += output.text;
-        // Store assistant message — must include tool_calls when present
-        // so OpenAI sees the required assistant→tool message sequence.
-        const assistantMsg = { role: "assistant", from: "Assistant", content: output.text || "" };
+        // Accumulate clean text (markers stripped) for the return value
+        const cleanText = markerParser.getCleanText();
+        if (cleanText)
+            finalText += cleanText;
+        // Store clean text in memory — markers are runtime directives, not conversation content.
+        // The original output.text is preserved in case we need it for debugging.
+        const assistantMsg = { role: "assistant", from: "Assistant", content: cleanText || "" };
         if (output.toolCalls.length > 0) {
             assistantMsg.tool_calls = output.toolCalls;
         }
@@ -607,8 +647,8 @@ async function executeTurn(driver, memory, mcp, cfg, sessionId) {
     if (!brokeCleanly && tools.length > 0) {
         Logger.debug("Max tool rounds reached — final turn with no tools");
         const finalOutput = await driver.chat(memory.messages(), {
-            model: cfg.model,
-            onToken,
+            model: activeModel,
+            onToken: rawOnToken,
         });
         if (finalOutput.usage) {
             turnTokensIn += finalOutput.usage.inputTokens;
@@ -646,6 +686,12 @@ async function singleShot(cfg, driver, mcp, sessionId, positionalArgs) {
     // Resume existing session if requested
     if (cfg.continueSession || cfg.resumeSession) {
         await memory.load(sessionId);
+        const sess = loadSession(sessionId);
+        if (sess?.meta.model && sess.meta.model !== cfg.model) {
+            Logger.info(`Restoring model from session: ${cfg.model} → ${sess.meta.model}`);
+            cfg.model = sess.meta.model;
+            memory.setModel(sess.meta.model);
+        }
     }
     await memory.add({ role: "user", from: "User", content: prompt });
     let text;
@@ -695,6 +741,12 @@ async function interactive(cfg, driver, mcp, sessionId) {
         if (sess) {
             const msgCount = sess.messages.filter((m) => m.role !== "system").length;
             Logger.info(C.gray(`Resumed session ${sessionId} (${msgCount} messages)`));
+            // Restore model from session metadata (e.g. after a stream marker model-change)
+            if (sess.meta.model && sess.meta.model !== cfg.model) {
+                Logger.info(`Restoring model from session: ${cfg.model} → ${sess.meta.model}`);
+                cfg.model = sess.meta.model;
+                memory.setModel(sess.meta.model);
+            }
         }
     }
     const rl = readline.createInterface({

package/dist/memory/advanced-memory.js

@@ -24,6 +24,9 @@ export class AdvancedMemory extends AgentMemory {
         this.keepRecentPerLane = Math.max(1, Math.floor(args.keepRecentPerLane ?? 4));
         this.keepRecentTools = Math.max(0, Math.floor(args.keepRecentTools ?? 3));
     }
+    setModel(model) {
+        this.model = model;
+    }
     async load(id) {
         const session = loadSession(id);
         if (session) {

package/dist/memory/agent-memory.js

@@ -22,6 +22,8 @@ export class AgentMemory {
             await this.onAfterAdd();
         }
     }
+    /** Update the active model (used by stream markers to persist model changes across turns). */
+    setModel(_model) { }
     messages() {
         return [...this.messagesBuffer];
     }

package/dist/memory/simple-memory.js

@@ -15,6 +15,9 @@ export class SimpleMemory extends AgentMemory {
         this.provider = provider;
         this.model = model;
     }
+    setModel(model) {
+        this.model = model;
+    }
     async load(id) {
         const session = loadSession(id);
         if (session) {

package/dist/package.json

@@ -1,11 +1,22 @@
 {
   "name": "@tjamescouch/gro",
-  "version": "1.3.2",
+  "version": "1.3.10",
   "description": "Provider-agnostic LLM runtime with context management",
+  "bin": {
+    "gro": "./dist/main.js"
+  },
+  "files": [
+    "dist/",
+    "gro",
+    "providers/",
+    "_base.md",
+    "owl"
+  ],
   "type": "module",
   "scripts": {
     "start": "npx tsx src/main.ts",
-    "build": "npx tsc && cp package.json dist/",
+    "build": "npx tsc && chmod +x dist/main.js && cp package.json dist/",
+    "prepublishOnly": "npm run build",
     "build:bun": "bun build src/main.ts --outdir dist --target bun",
     "test": "npx tsx --test tests/*.test.ts",
     "test:bun": "bun test"

package/dist/stream-markers.js

@@ -0,0 +1,113 @@
+/**
+ * Stream Marker Parser
+ *
+ * Intercepts @@name('arg')@@ patterns in the token stream.
+ * Generic architecture — any marker type can register a handler.
+ *
+ * Markers are stripped from the output text that reaches the user.
+ * When a complete marker is detected, the registered handler fires.
+ *
+ * Built-in marker types:
+ *   @@model-change('sonnet')@@  — switch the active model mid-stream
+ *   @@callback('name')@@       — fire a named callback
+ *   @@emotion('happy')@@       — set facial expression / emotion state
+ *
+ * Usage:
+ *   const parser = createMarkerParser({ onMarker: (name, arg) => { ... } });
+ *   // Wrap your onToken callback:
+ *   driver.chat(messages, { onToken: parser.onToken });
+ *   // After the response, get clean text:
+ *   const cleanText = parser.getCleanText();
+ */
+import { Logger } from "./logger.js";
+/**
+ * Regex for matching complete markers.
+ * Supports: @@name('arg')@@ and @@name("arg")@@ and @@name(arg)@@
+ */
+const MARKER_RE = /@@([a-zA-Z][a-zA-Z0-9_-]*)\((?:'([^']*)'|"([^"]*)"|([^)]*?))\)@@/g;
+/** Partial marker detection — we might be mid-stream in a marker */
+const PARTIAL_MARKER_RE = /@@[a-zA-Z][a-zA-Z0-9_-]*(?:\([^)]*)?$/;
+export function createMarkerParser(opts) {
+    const { onMarker, onToken } = opts;
+    let buffer = "";
+    let cleanText = "";
+    const markers = [];
+    function processBuffer(isFinal) {
+        // Try to match complete markers in the buffer
+        let lastIndex = 0;
+        const regex = new RegExp(MARKER_RE.source, "g");
+        let match;
+        while ((match = regex.exec(buffer)) !== null) {
+            // Emit any text before this marker
+            const before = buffer.slice(lastIndex, match.index);
+            if (before) {
+                cleanText += before;
+                if (onToken)
+                    onToken(before);
+            }
+            // Parse the marker
+            const name = match[1];
+            const arg = match[2] ?? match[3] ?? match[4] ?? "";
+            const raw = match[0];
+            const marker = { name, arg, raw };
+            markers.push(marker);
+            Logger.debug(`Stream marker detected: ${raw}`);
+            try {
+                onMarker(marker);
+            }
+            catch (e) {
+                Logger.warn(`Marker handler error for ${name}: ${e}`);
+            }
+            lastIndex = match.index + match[0].length;
+        }
+        // Whatever's left after all matches
+        const remainder = buffer.slice(lastIndex);
+        if (isFinal) {
+            // End of stream — flush everything remaining as text
+            if (remainder) {
+                cleanText += remainder;
+                if (onToken)
+                    onToken(remainder);
+            }
+            buffer = "";
+        }
+        else {
+            // Check if the remainder could be a partial marker
+            const partialMatch = PARTIAL_MARKER_RE.exec(remainder);
+            if (partialMatch) {
+                // Hold back the potential partial marker, emit what's before it
+                const safe = remainder.slice(0, partialMatch.index);
+                if (safe) {
+                    cleanText += safe;
+                    if (onToken)
+                        onToken(safe);
+                }
+                buffer = remainder.slice(partialMatch.index);
+            }
+            else {
+                // No partial marker — emit all remaining text
+                if (remainder) {
+                    cleanText += remainder;
+                    if (onToken)
+                        onToken(remainder);
+                }
+                buffer = "";
+            }
+        }
+    }
+    return {
+        onToken(s) {
+            buffer += s;
+            processBuffer(false);
+        },
+        getCleanText() {
+            return cleanText;
+        },
+        getMarkers() {
+            return [...markers];
+        },
+        flush() {
+            processBuffer(true);
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tjamescouch/gro",
-  "version": "1.3.8",
+  "version": "1.3.10",
   "description": "Provider-agnostic LLM runtime with context management",
   "bin": {
     "gro": "./dist/main.js"
@@ -15,7 +15,7 @@
   "type": "module",
   "scripts": {
     "start": "npx tsx src/main.ts",
-    "build": "npx tsc && chmod +x dist/main.js",
+    "build": "npx tsc && chmod +x dist/main.js && cp package.json dist/",
     "prepublishOnly": "npm run build",
     "build:bun": "bun build src/main.ts --outdir dist --target bun",
     "test": "npx tsx --test tests/*.test.ts",