tide-commander 1.148.0 → 1.150.0

package/dist/src/packages/server/opencode/json-event-parser.js

@@ -1,6 +1,16 @@
 /**
  * OpenCode JSON Event Parser
- * Maps OpenCode NDJSON events to StandardEvent format
+ * Maps OpenCode NDJSON events to StandardEvent format.
+ *
+ * Streaming model (mirrors Claude/Grok):
+ *  - `message.part.delta` → append delta with isStreaming:true + stable partID uuid
+ *  - progressive `text` / `reasoning` snapshots (same part.id, growing text) →
+ *    emit only the new suffix as a streaming chunk
+ *  - final text (part.time.end set, or step_finish) → isStreaming:false same uuid
+ *
+ * Note: current `opencode run --format json` often emits a single complete `text`
+ * event per turn (no token deltas). This parser still assigns stable uuids and is
+ * ready for delta / progressive events when the CLI surfaces them.
  */
 import { createLogger } from '../utils/logger.js';
 const log = createLogger('OpencodeParser');
@@ -34,6 +44,12 @@ export class OpencodeJsonEventParser {
     textEventEmittedInTurn = false;
     lastThinkingContent;
     thinkingEventEmittedInTurn = false;
+    /** Full text seen so far per part id — used to derive deltas from snapshots. */
+    streamedTextByPart = new Map();
+    streamedThinkingByPart = new Map();
+    /** Open text/thinking stream uuids awaiting isStreaming:false finalize. */
+    openTextStreamUuids = new Set();
+    openThinkingStreamUuids = new Set();
     parseEvent(rawEvent) {
         const event = rawEvent;
         if (!event || typeof event !== 'object' || !event.type) {
@@ -51,42 +67,166 @@ export class OpencodeJsonEventParser {
                 return this.parseToolUse(event);
             case 'step_finish':
                 return this.parseStepFinish(event);
+            // Server/SDK event names — surface token deltas when present.
+            case 'message.part.delta':
+                return this.parseMessagePartDelta(event);
+            case 'message.part.updated':
+                return this.parseMessagePartUpdated(event);
             default:
                 log.log(`parseEvent: unknown event type '${event.type}' - skipping`);
                 return [];
         }
     }
     parseStepStart(event) {
+        // New step — allow streams again.
+        this.openTextStreamUuids.clear();
+        this.openThinkingStreamUuids.clear();
+        this.streamedTextByPart.clear();
+        this.streamedThinkingByPart.clear();
         return [{
                 type: 'init',
                 sessionId: event.sessionID,
             }];
     }
-    parseText(event) {
-        const text = event.part?.text;
-        if (!text)
+    streamUuid(kind, partId, messageId) {
+        if (partId)
+            return `opencode-${kind}-${partId}`;
+        if (messageId)
+            return `opencode-${kind}-msg-${messageId}`;
+        return `opencode-${kind}-anon`;
+    }
+    /**
+     * Emit streaming text from a full snapshot: only the new suffix is sent as a
+     * delta so the client can append. Returns [] when the snapshot is unchanged.
+     */
+    emitProgressive(kind, fullText, partId, messageId, isFinal) {
+        const map = kind === 'text' ? this.streamedTextByPart : this.streamedThinkingByPart;
+        const openSet = kind === 'text' ? this.openTextStreamUuids : this.openThinkingStreamUuids;
+        const key = partId || messageId || 'anon';
+        const prev = map.get(key) || '';
+        const uuid = this.streamUuid(kind, partId, messageId);
+        if (kind === 'text') {
+            this.lastTextContent = fullText;
+            this.textEventEmittedInTurn = true;
+        }
+        else {
+            this.lastThinkingContent = fullText;
+            this.thinkingEventEmittedInTurn = true;
+        }
+        // Unchanged snapshot (common re-broadcast) — only finalize if needed.
+        if (fullText === prev) {
+            if (isFinal && openSet.has(uuid)) {
+                openSet.delete(uuid);
+                return [{
+                        type: kind === 'text' ? 'text' : 'thinking',
+                        text: fullText,
+                        isStreaming: false,
+                        uuid,
+                    }];
+            }
             return [];
-        // Track last text for resultText in step_complete (boss delegation parsing)
-        this.lastTextContent = text;
-        this.textEventEmittedInTurn = true;
+        }
+        map.set(key, fullText);
+        // Growing prefix → emit suffix as streaming chunk.
+        if (fullText.startsWith(prev) && !isFinal) {
+            const delta = fullText.slice(prev.length);
+            if (!delta)
+                return [];
+            openSet.add(uuid);
+            return [{
+                    type: kind === 'text' ? 'text' : 'thinking',
+                    text: delta,
+                    isStreaming: true,
+                    uuid,
+                }];
+        }
+        // Non-prefix rewrite or final: replace with full text.
+        if (isFinal) {
+            openSet.delete(uuid);
+            return [{
+                    type: kind === 'text' ? 'text' : 'thinking',
+                    text: fullText,
+                    isStreaming: false,
+                    uuid,
+                }];
+        }
+        openSet.add(uuid);
+        // Client merge appends when isStreaming; for rewrites send full text with
+        // isStreaming:false then... no, that finalizes early. Prefer replace path:
+        // emit as streaming full text only if prev empty; else finalize+restart.
+        if (!prev) {
+            return [{
+                    type: kind === 'text' ? 'text' : 'thinking',
+                    text: fullText,
+                    isStreaming: true,
+                    uuid,
+                }];
+        }
+        // Rare rewrite: finalize with new full content.
+        openSet.delete(uuid);
         return [{
-                type: 'text',
-                text,
+                type: kind === 'text' ? 'text' : 'thinking',
+                text: fullText,
                 isStreaming: false,
+                uuid,
             }];
     }
+    parseText(event) {
+        const part = event.part;
+        const text = part?.text;
+        if (!text)
+            return [];
+        // CLI format marks completion with time.end; absence → treat as progressive.
+        const isFinal = typeof part?.time?.end === 'number';
+        return this.emitProgressive('text', text, part?.id, part?.messageID, isFinal);
+    }
     parseReasoning(event) {
-        const text = event.part?.text;
+        const part = event.part;
+        const text = part?.text;
         if (!text)
             return [];
-        this.lastThinkingContent = text;
-        this.thinkingEventEmittedInTurn = true;
+        const isFinal = typeof part?.time?.end === 'number';
+        return this.emitProgressive('thinking', text, part?.id, part?.messageID, isFinal);
+    }
+    parseMessagePartDelta(event) {
+        const props = event.properties || {};
+        const delta = props.delta ?? event.part?.delta;
+        const field = props.field || event.part?.field || 'text';
+        const partId = props.partID || event.part?.id;
+        const messageId = props.messageID || event.part?.messageID;
+        if (typeof delta !== 'string' || !delta)
+            return [];
+        const kind = field === 'reasoning' || field === 'thinking' ? 'thinking' : 'text';
+        const map = kind === 'text' ? this.streamedTextByPart : this.streamedThinkingByPart;
+        const openSet = kind === 'text' ? this.openTextStreamUuids : this.openThinkingStreamUuids;
+        const key = partId || messageId || 'anon';
+        const next = (map.get(key) || '') + delta;
+        map.set(key, next);
+        if (kind === 'text') {
+            this.lastTextContent = next;
+            this.textEventEmittedInTurn = true;
+        }
+        else {
+            this.lastThinkingContent = next;
+            this.thinkingEventEmittedInTurn = true;
+        }
+        const uuid = this.streamUuid(kind, partId, messageId);
+        openSet.add(uuid);
         return [{
-                type: 'thinking',
-                text,
-                isStreaming: false,
+                type: kind === 'text' ? 'text' : 'thinking',
+                text: delta,
+                isStreaming: true,
+                uuid,
             }];
     }
+    parseMessagePartUpdated(event) {
+        const part = event.properties?.part || event.part;
+        if (!part?.text)
+            return [];
+        const kind = part.type === 'reasoning' || part.type === 'thinking' ? 'thinking' : 'text';
+        const isFinal = typeof part.time?.end === 'number';
+        return this.emitProgressive(kind, part.text, part.id, part.messageID, isFinal);
+    }
     parseToolUse(event) {
         const part = event.part;
         if (!part)
@@ -103,6 +243,7 @@ export class OpencodeJsonEventParser {
         };
         if (callId) {
             toolStart.toolUseId = callId;
+            toolStart.uuid = callId;
         }
         events.push(toolStart);
         // Emit tool_result if state is present (completed tool)
@@ -114,6 +255,7 @@ export class OpencodeJsonEventParser {
             };
             if (callId) {
                 toolResult.toolUseId = callId;
+                toolResult.uuid = callId;
             }
             events.push(toolResult);
         }
@@ -125,6 +267,31 @@ export class OpencodeJsonEventParser {
             return [];
         const events = [];
         const tokens = part.tokens;
+        // Finalize any open streaming rows so the UI stops the "live" cursor.
+        for (const uuid of this.openTextStreamUuids) {
+            const text = this.lastTextContent || '';
+            if (text) {
+                events.push({
+                    type: 'text',
+                    text,
+                    isStreaming: false,
+                    uuid,
+                });
+            }
+        }
+        this.openTextStreamUuids.clear();
+        for (const uuid of this.openThinkingStreamUuids) {
+            const text = this.lastThinkingContent || '';
+            if (text) {
+                events.push({
+                    type: 'thinking',
+                    text,
+                    isStreaming: false,
+                    uuid,
+                });
+            }
+        }
+        this.openThinkingStreamUuids.clear();
         // Emit usage_snapshot if token info is available
         if (tokens) {
             events.push({
@@ -174,6 +341,8 @@ export class OpencodeJsonEventParser {
         this.textEventEmittedInTurn = false;
         this.lastThinkingContent = undefined;
         this.thinkingEventEmittedInTurn = false;
+        this.streamedTextByPart.clear();
+        this.streamedThinkingByPart.clear();
         return events;
     }
 }

package/dist/src/packages/server/routes/agents.js

@@ -22,6 +22,7 @@ import { getSystemPrompt, setSystemPrompt, clearSystemPrompt, isEchoPromptEnable
 import { markInstructionsDirtyForAll } from '../services/instruction-refresh.js';
 import { startAgentTerminal, stopAgentTerminal } from '../services/agent-terminal-service.js';
 import { buildClaudeUsageByAgentSummary, buildClaudeUsageByDaySummary, buildClaudeUsageSnapshot } from '../services/claude-usage-service.js';
+import { buildGrokUsageSnapshot } from '../services/grok-usage-service.js';
 import { getBackupStatus, setBackupEnabled } from '../services/backup-service.js';
 const log = createLogger('Routes');
 const router = Router();
@@ -503,14 +504,17 @@ router.post('/bulk/change-model', async (req, res) => {
         else if (provider === 'opencode') {
             sanitized = agentService.sanitizeOpencodeModel(model);
         }
+        else if (provider === 'grok') {
+            sanitized = agentService.sanitizeGrokModel(model);
+        }
         if (!sanitized) {
             res.status(400).json({ error: `Invalid model "${model}" for provider "${provider}"` });
             return;
         }
-        // Effort is Claude-only. `null` means "clear back to default"; undefined means "leave unchanged".
+        // Effort is Claude/Grok. `null` means "clear back to default"; undefined means "leave unchanged".
         const VALID_EFFORTS = new Set(['low', 'medium', 'high', 'xHigh', 'max']);
         let effortUpdate = { set: false };
-        if (effort !== undefined && provider === 'claude') {
+        if (effort !== undefined && (provider === 'claude' || provider === 'grok')) {
             if (effort === null) {
                 effortUpdate = { set: true, value: undefined };
             }
@@ -547,6 +551,8 @@ router.post('/bulk/change-model', async (req, res) => {
                     modelUpdates.codexModel = sanitized;
                 else if (provider === 'opencode')
                     modelUpdates.opencodeModel = sanitized;
+                else if (provider === 'grok')
+                    modelUpdates.grokModel = sanitized;
                 if (effortUpdate.set)
                     modelUpdates.effort = effortUpdate.value;
                 agentService.updateAgent(agentId, modelUpdates);
@@ -943,30 +949,32 @@ router.delete('/:id', (req, res) => {
     }
     res.status(204).end();
 });
-// GET /api/agents/:id/usage - Claude usage snapshot for a single agent
+// GET /api/agents/:id/usage - Claude or Grok usage snapshot for a single agent
 //
-// Mirrors what the Claude CLI's `/usage` slash command surfaces: local agent
-// stats plus the live rate-limit gauges fetched with the CLI's own OAuth
-// credentials. See services/claude-usage-service.ts for the source list.
+// Claude: local agent stats + Anthropic OAuth rate-limit gauges (CLI `/usage`).
+// Grok: local agent stats + CLI chat-proxy billing/credit gauges (CLI `/usage`).
 router.get('/:id/usage', async (req, res) => {
     const agent = agentService.getAgent(req.params.id);
     if (!agent) {
         res.status(404).json({ error: 'Agent not found' });
         return;
     }
-    if (agent.provider !== 'claude') {
+    const provider = agent.provider ?? 'claude';
+    if (provider !== 'claude' && provider !== 'grok') {
         res.status(400).json({
-            error: 'Usage data is only available for Claude agents',
-            provider: agent.provider,
+            error: 'Usage data is only available for Claude and Grok agents',
+            provider,
         });
         return;
     }
     try {
-        const snapshot = await buildClaudeUsageSnapshot(agent);
+        const snapshot = provider === 'grok'
+            ? await buildGrokUsageSnapshot(agent)
+            : await buildClaudeUsageSnapshot(agent);
         res.json(snapshot);
     }
     catch (err) {
-        log.error('Failed to build Claude usage snapshot:', err);
+        log.error(`Failed to build ${provider} usage snapshot:`, err);
         res.status(500).json({ error: err?.message ?? 'Failed to build usage snapshot' });
     }
 });

package/dist/src/packages/server/runtime/grok-runtime-provider.js

@@ -0,0 +1,11 @@
+import { ClaudeRunner } from '../claude/runner.js';
+import { GrokBackend } from '../grok/backend.js';
+class GrokRuntimeProvider {
+    name = 'grok';
+    createRunner(callbacks) {
+        return new ClaudeRunner(callbacks, new GrokBackend());
+    }
+}
+export function createGrokRuntimeProvider() {
+    return new GrokRuntimeProvider();
+}

package/dist/src/packages/server/runtime/index.js

@@ -1,3 +1,4 @@
 export { createClaudeRuntimeProvider } from './claude-runtime-provider.js';
 export { createCodexRuntimeProvider } from './codex-runtime-provider.js';
 export { createOpencodeRuntimeProvider } from './opencode-runtime-provider.js';
+export { createGrokRuntimeProvider } from './grok-runtime-provider.js';

package/dist/src/packages/server/services/agent-service.js

@@ -5,7 +5,7 @@
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import { CLAUDE_MODELS as CLAUDE_MODEL_METADATA } from '../../shared/agent-types.js';
+import { CLAUDE_MODELS as CLAUDE_MODEL_METADATA, GROK_MODELS, DEFAULT_GROK_MODEL } from '../../shared/agent-types.js';
 import { loadAgents, saveAgents, saveAgentsAsync, getDataDir, loadAreas, saveAreas, loadSessionHistory, saveSessionHistory, addSessionHistoryEntry, getSessionHistoryForAgent } from '../data/index.js';
 import { listSessions, getSessionSummary, getProjectDir, loadSession, loadToolHistory, searchSession, } from '../claude/session-loader.js';
 import { loadSubagentHistory } from '../claude/subagent-history-loader.js';
@@ -16,11 +16,19 @@ const VALID_CLAUDE_MODELS = new Set(Object.keys(CLAUDE_MODEL_METADATA));
 const DEFAULT_CLAUDE_CONTEXT_LIMIT = 200000;
 const DEFAULT_CODEX_CONTEXT_LIMIT = 258400;
 const DEFAULT_OPENCODE_CONTEXT_LIMIT = 200000;
-function getDefaultContextLimit(provider, model) {
+/** Matches live Grok Build signals.json contextWindowTokens (catalog may list 2M). */
+const DEFAULT_GROK_CONTEXT_LIMIT = 500000;
+function getDefaultContextLimit(provider, model, grokModel) {
     if (provider === 'codex')
         return DEFAULT_CODEX_CONTEXT_LIMIT;
     if (provider === 'opencode')
         return DEFAULT_OPENCODE_CONTEXT_LIMIT;
+    if (provider === 'grok') {
+        if (grokModel && GROK_MODELS[grokModel]?.contextWindow) {
+            return GROK_MODELS[grokModel].contextWindow;
+        }
+        return DEFAULT_GROK_CONTEXT_LIMIT;
+    }
     if (model && CLAUDE_MODEL_METADATA[model]) {
         return CLAUDE_MODEL_METADATA[model].contextWindow;
     }
@@ -61,6 +69,12 @@ export function sanitizeOpencodeModel(model) {
     const trimmed = model.trim();
     return trimmed.length > 0 ? trimmed : undefined;
 }
+export function sanitizeGrokModel(model) {
+    if (typeof model !== 'string')
+        return undefined;
+    const trimmed = model.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
 function findFileRecursively(rootDir, pattern) {
     if (!fs.existsSync(rootDir))
         return null;
@@ -215,6 +229,7 @@ export function initAgents() {
                 codexModel: sanitizeCodexModel(stored.codexModel),
                 codexConfig: stored.codexConfig,
                 opencodeModel: sanitizeOpencodeModel(stored.opencodeModel),
+                grokModel: sanitizeGrokModel(stored.grokModel),
                 // Boss field - fallback to checking class for backward compatibility
                 isBoss: stored.isBoss ?? stored.class === 'boss',
             };
@@ -278,7 +293,7 @@ export function getAgent(id) {
 export function getAllAgents() {
     return Array.from(agents.values());
 }
-export async function createAgent(name, agentClass, cwd, position, sessionId, useChrome, permissionMode = 'bypass', initialSkillIds, isBoss, model, codexModel, customInstructions, provider = 'claude', codexConfig, effort, opencodeModel) {
+export async function createAgent(name, agentClass, cwd, position, sessionId, useChrome, permissionMode = 'bypass', initialSkillIds, isBoss, model, codexModel, customInstructions, provider = 'claude', codexConfig, effort, opencodeModel, grokModel) {
     log.log('🎆 [CREATE_AGENT] Starting agent creation:', {
         name,
         agentClass,
@@ -290,6 +305,8 @@ export async function createAgent(name, agentClass, cwd, position, sessionId, us
         model,
         codexModel,
         codexConfig,
+        opencodeModel,
+        grokModel,
         customInstructions: customInstructions ? `${customInstructions.length} chars` : undefined,
     });
     const id = generateId();
@@ -301,6 +318,9 @@ export async function createAgent(name, agentClass, cwd, position, sessionId, us
         throw new Error(`Directory does not exist: ${cwd}`);
     }
     log.log(`  ✅ Directory exists`);
+    const sanitizedGrokModel = provider === 'grok'
+        ? (sanitizeGrokModel(grokModel) || DEFAULT_GROK_MODEL)
+        : undefined;
     // Create agent object
     // SessionId can be provided to link to an existing Claude session
     const agent = {
@@ -318,13 +338,14 @@ export async function createAgent(name, agentClass, cwd, position, sessionId, us
         useChrome,
         permissionMode,
         model: sanitizeModelForProvider(provider, model),
-        effort: provider === 'claude' ? effort : undefined,
+        effort: provider === 'claude' || provider === 'grok' ? effort : undefined,
         codexModel: provider === 'codex' ? sanitizeCodexModel(codexModel) : undefined,
         codexConfig,
         opencodeModel: provider === 'opencode' ? sanitizeOpencodeModel(opencodeModel) : undefined,
+        grokModel: sanitizedGrokModel,
         tokensUsed: 0,
         contextUsed: 0,
-        contextLimit: getDefaultContextLimit(provider, sanitizeModelForProvider(provider, model)),
+        contextLimit: getDefaultContextLimit(provider, sanitizeModelForProvider(provider, model), sanitizedGrokModel),
         taskCount: 0, // Initialize task counter
         createdAt: Date.now(),
         lastActivity: Date.now(),