@rubixkube/rubix 0.0.5 → 0.0.7

package/CHANGELOG.md

@@ -5,6 +5,21 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com),
 and this project adheres to [Semantic Versioning](https://semver.org).
 
+## [0.0.7] - 2025-03-18
+
+### Added
+
+- Bugfixes and performance improvements
+- Introducing Sarvam 105B support
+
+## [0.0.6] - 2025-03-08
+
+### Added
+
+- Workflow event timeline
+- Added Personality
+- Bugfixes and performance improvements
+
 ## [0.0.5] - 2025-03-06
 
 ### Added

package/dist/core/device-auth.js

@@ -130,24 +130,51 @@ async function getUserProfile(idToken) {
     }
     return (await response.json());
 }
-function openUrlInBrowser(url) {
+/** Detect headless environment (SSH, CI, no display server) */
+export function isHeadlessEnvironment() {
+    if (process.env.CI === "true" || process.env.CI === "1")
+        return true;
+    if (process.platform === "linux") {
+        if (!process.env.DISPLAY && !process.env.WAYLAND_DISPLAY)
+            return true;
+    }
+    return false;
+}
+/**
+ * Open URL in browser. No-op in headless environments.
+ * Handles spawn errors (e.g. ENOENT for missing xdg-open) without crashing.
+ */
+export function openUrlSafely(url) {
     const urlStr = String(url).trim();
     if (!urlStr.startsWith("http://") && !urlStr.startsWith("https://"))
         return;
+    if (isHeadlessEnvironment())
+        return;
+    let proc;
     if (process.platform === "darwin") {
-        spawn("open", [urlStr], { stdio: "ignore" });
+        proc = spawn("open", [urlStr], { stdio: "ignore" });
     }
     else if (process.platform === "win32") {
-        spawn("cmd", ["/c", "start", "", urlStr], { stdio: "ignore" });
+        proc = spawn("cmd", ["/c", "start", "", urlStr], { stdio: "ignore" });
     }
     else {
-        spawn("xdg-open", [urlStr], { stdio: "ignore" });
+        proc = spawn("xdg-open", [urlStr], { stdio: "ignore" });
     }
+    proc.on("error", () => {
+        /* Swallow ENOENT and other spawn errors to avoid process crash */
+    });
 }
 export async function authenticateWithDeviceFlow(log) {
     const start = await startDeviceAuth();
-    openUrlInBrowser(start.verificationUrl);
-    log?.(`Opening ${start.verificationUrl} in browser`);
+    const headless = isHeadlessEnvironment();
+    openUrlSafely(start.verificationUrl);
+    if (headless) {
+        log?.("No display detected (SSH/headless). Open this URL in a browser on another device:");
+        log?.(start.verificationUrl);
+    }
+    else {
+        log?.(`Opening ${start.verificationUrl} in browser`);
+    }
     log?.(`Enter code: ${start.userCode}`);
     const tokens = await pollForTokens(start, log);
     const validation = await validateAuth0Token(tokens.id_token);

package/dist/core/rubix-api.js

@@ -1,6 +1,7 @@
 import { getConfig } from "../config/env.js";
 import { refreshAccessToken } from "./device-auth.js";
 import { saveAuthConfig } from "./auth-store.js";
+import { pushTextSegment, pushWorkflowSegment } from "./segments.js";
 const DEFAULT_APP_NAME = "Rubix";
 export class StreamError extends Error {
     reason;
@@ -130,21 +131,29 @@ function mergeChunks(existing, add) {
     if (add === existing)
         return existing;
     if (add.startsWith(existing))
-        return add;
+        return add; // cumulative resend
     if (existing.startsWith(add))
-        return existing;
-    if (add.includes(existing))
-        return add;
-    if (existing.includes(add))
-        return existing;
-    const maxK = Math.min(existing.length, add.length);
+        return existing; // duplicate smaller resend
+    // Never use includes() — e.g. "I'" matches inside "I'm", "|" matches in markdown; would silently eat content.
+    // Find maximal overlap where existing ends with the prefix of add.
+    // Use trimEnd when checking so "Investigate " + "igate..." merges correctly
+    // (trailing space would otherwise block suffix overlap).
+    const existingTrimmed = existing.replace(/\s+$/, "");
+    const maxK = Math.min(existingTrimmed.length, add.length);
     for (let k = maxK; k > 0; k -= 1) {
-        if (existing.endsWith(add.slice(0, k))) {
-            return existing + add.slice(k);
+        if (existingTrimmed.endsWith(add.slice(0, k))) {
+            const newPart = add.slice(k);
+            if (!newPart)
+                return existing;
+            return existingTrimmed + newPart;
         }
     }
     return existing + add;
 }
+/** Exported for thought accumulation in UI (overlap-aware merge). */
+export function mergeTextChunks(existing, add) {
+    return mergeChunks(existing, add);
+}
 function asText(value) {
     if (typeof value === "string")
         return value;
@@ -471,9 +480,16 @@ function parseParts(content) {
     }
     return content.parts ?? [];
 }
-export async function fetchChatHistory(auth, sessionId, limit = 50) {
+function parseContentRole(content) {
+    if (!content || typeof content === "string")
+        return "";
+    return content.role ?? "";
+}
+export async function fetchChatHistory(auth, sessionId, pageSize = 20, appName = DEFAULT_APP_NAME, offset = 0) {
     const { userId } = ensureAuth(auth);
-    const url = `${opelBase()}/sessions/${encodeURIComponent(sessionId)}/chat-history?user_id=${encodeURIComponent(userId)}&limit=${limit}&offset=0&format=detailed&order_desc=false`;
+    // Fetch newest-first so we always get the most recent N messages.
+    // offset > 0 means "load older": skip the N most-recent events we already have.
+    const url = `${opelBase()}/sessions/${encodeURIComponent(sessionId)}/chat-history?user_id=${encodeURIComponent(userId)}&limit=${pageSize}&offset=${offset}&format=detailed&order_desc=true&app_name=${encodeURIComponent(appName)}`;
     const response = await fetchWithAutoRefresh(auth, url, {
         method: "GET",
         headers: headers(auth),
@@ -483,65 +499,121 @@ export async function fetchChatHistory(auth, sessionId, limit = 50) {
         throw new Error(`Failed to load chat history (${response.status}): ${text}`);
     }
     const payload = (await response.json());
-    const messages = [];
-    for (const [idx, msg] of (payload.chat_history ?? []).entries()) {
-        const role = msg.author === "user" ? "user" : "assistant";
-        const parts = parseParts(msg.content);
-        const ts = msg.timestamp ? new Date(msg.timestamp).getTime() : Date.now();
-        let text = "";
-        const workflow = [];
+    const raw = payload.chat_history ?? [];
+    // If we got a full page there are likely more older events beyond this batch.
+    const hasMore = raw.length === pageSize;
+    // Events come newest-first from the API — reverse to get chronological order.
+    const events = raw.reverse();
+    const turns = new Map();
+    const turnOrder = [];
+    for (const [eIdx, event] of events.entries()) {
+        const invId = event.invocation_id ?? `anon-${eIdx}`;
+        const ts = event.timestamp ? new Date(event.timestamp).getTime() : Date.now();
+        if (!turns.has(invId)) {
+            turns.set(invId, { userText: "", assistantText: "", workflow: [], segments: [], ts, assistantTs: ts });
+            turnOrder.push(invId);
+        }
+        const turn = turns.get(invId);
+        const parts = parseParts(event.content);
+        let thoughtBuffer = ""; // Accumulate consecutive thought parts (raw concat) for token-based storage
         for (const part of parts) {
-            if (part.thought === true) {
-                if (typeof part.text === "string" && part.text.trim()) {
-                    workflow.push({
-                        id: `hist-th-${idx}-${workflow.length}`,
-                        type: "thought",
-                        content: part.text.trim(),
-                        ts,
-                    });
-                }
+            const partText = typeof part.text === "string" ? part.text : "";
+            const isThoughtPart = part.thought === true || part.type === "thought";
+            // Thought: accumulate consecutive parts into one entry (LiteLLM stores 100 tokens = 100 parts)
+            if (isThoughtPart) {
+                thoughtBuffer += partText;
                 continue;
             }
+            // Flush accumulated thoughts before processing non-thought part
+            if (thoughtBuffer.length > 0) {
+                const wev = {
+                    id: `th-${invId}-${eIdx}-${turn.workflow.length}`,
+                    type: "thought",
+                    content: thoughtBuffer,
+                    ts,
+                };
+                turn.workflow.push(wev);
+                pushWorkflowSegment(turn.segments, wev);
+                thoughtBuffer = "";
+            }
+            // Tool call
             const fc = part.functionCall ?? part.function_call;
             if (fc) {
                 const name = typeof fc.name === "string" ? fc.name : "tool";
-                const argsStr = fc.args && Object.keys(fc.args).length > 0 ? JSON.stringify(fc.args) : "";
-                workflow.push({
-                    id: `hist-fc-${idx}-${name}`,
+                const wev = {
+                    id: `fc-${invId}-${eIdx}-${name}`,
                     type: "function_call",
-                    content: argsStr,
+                    content: fc.args && Object.keys(fc.args).length > 0 ? JSON.stringify(fc.args) : "",
                     ts,
                     details: { name, id: fc.id },
-                });
+                };
+                turn.workflow.push(wev);
+                pushWorkflowSegment(turn.segments, wev);
                 continue;
             }
+            // Tool response (ADK sends these as author="user" — they belong to the assistant bubble)
             const fr = part.functionResponse ?? part.function_response;
             if (fr) {
                 const name = typeof fr.name === "string" ? fr.name : "tool";
-                workflow.push({
-                    id: `hist-fr-${idx}-${name}`,
+                const wev = {
+                    id: `fr-${invId}-${eIdx}-${name}`,
                     type: "function_response",
-                    content: typeof fr.response === "string" ? fr.response : (fr.response ? JSON.stringify(fr.response) : `[${name}]`),
+                    content: extractFunctionResult(fr.response) || (fr.response ? JSON.stringify(fr.response) : `[${name}]`),
                     ts,
                     details: { name, id: fr.id },
-                });
+                };
+                turn.workflow.push(wev);
+                pushWorkflowSegment(turn.segments, wev);
                 continue;
             }
-            if (typeof part.text === "string" && part.text.trim()) {
-                text = text ? `${text}\n${part.text}` : part.text;
+            // Plain text — user bubble if author === "user", otherwise assistant bubble.
+            // Skip whitespace-only parts (separators in stored data).
+            if (typeof part.text === "string" && part.text.trim().length > 0) {
+                if (event.author === "user") {
+                    turn.userText = turn.userText ? `${turn.userText}\n${part.text}` : part.text;
+                }
+                else {
+                    turn.assistantText = turn.assistantText ? `${turn.assistantText}\n${part.text}` : part.text;
+                    turn.assistantTs = ts;
+                    pushTextSegment(turn.segments, part.text);
+                }
             }
         }
-        if (!text.trim() && workflow.length === 0)
-            continue;
-        messages.push({
-            id: msg.invocation_id ? `${msg.invocation_id}-${idx}` : `hist-${idx}`,
-            role,
-            content: text,
-            ts,
-            workflow: workflow.length > 0 ? workflow : undefined,
-        });
+        // Flush any remaining thought buffer after last part
+        if (thoughtBuffer.length > 0) {
+            const wev = {
+                id: `th-${invId}-${eIdx}-${turn.workflow.length}`,
+                type: "thought",
+                content: thoughtBuffer,
+                ts,
+            };
+            turn.workflow.push(wev);
+            pushWorkflowSegment(turn.segments, wev);
+        }
+    }
+    const messages = [];
+    for (const invId of turnOrder) {
+        const turn = turns.get(invId);
+        if (turn.userText.trim()) {
+            messages.push({
+                id: `${invId}:user`,
+                role: "user",
+                content: turn.userText,
+                ts: turn.ts,
+            });
+        }
+        if (turn.assistantText.trim() || turn.workflow.length > 0) {
+            messages.push({
+                id: `${invId}:assistant`,
+                role: "assistant",
+                content: turn.assistantText,
+                ts: turn.assistantTs,
+                workflow: turn.workflow.length > 0 ? turn.workflow : undefined,
+                segments: turn.segments.length > 0 ? turn.segments : undefined,
+            });
+        }
     }
-    return messages;
+    return { messages, hasMore };
 }
 export async function streamChat(input, callbacks = {}) {
     const { userId } = ensureAuth(input.auth);
@@ -623,11 +695,17 @@ export async function streamChat(input, callbacks = {}) {
         }
         const parts = event.content?.parts ?? [];
         const isThoughtType = normalizedEventType === "thought" || normalizedEventType === "thoughts";
+        // Accumulate all visible text from this event (console pattern: batch per event).
+        // Use mergeChunks per part to avoid duplicates when backend sends overlapping parts.
+        let visibleChunk = "";
         for (const part of parts) {
             const partText = typeof part.text === "string" ? part.text : "";
-            if ((part.thought === true || isThoughtType) && partText.trim()) {
+            // Thought: check both part.thought and part.type for safety (LiteLLM vs Gemini).
+            // Pass raw tokens — do not trim; BPE tokens carry their own whitespace.
+            const isThoughtPart = part.thought === true || part.type === "thought" || isThoughtType;
+            if (isThoughtPart && partText.length > 0) {
                 hasWorkflowEvents = true;
-                callbacks.onWorkflow?.(normalizeWorkflowEvent("thought", partText.trim(), {
+                callbacks.onWorkflow?.(normalizeWorkflowEvent("thought", partText, {
                     partial: event.partial === true,
                 }));
                 continue;
@@ -657,13 +735,20 @@ export async function streamChat(input, callbacks = {}) {
                 }));
                 continue;
             }
-            if (partText && part.thought !== true) {
-                const merged = mergeChunks(accumulatedText, partText);
-                if (merged !== accumulatedText) {
-                    accumulatedText = merged;
-                    hasContent = accumulatedText.trim().length > 0;
-                    callbacks.onText?.(accumulatedText);
-                }
+            // Visible text (non-thought): accumulate with overlap detection.
+            // Skip whitespace-only parts (e.g. {text: "\n"}) used as separators in stored data.
+            const isVisibleText = part.thought !== true && part.type !== "thought";
+            if (isVisibleText && partText.trim().length > 0) {
+                visibleChunk = mergeChunks(visibleChunk, partText);
+            }
+        }
+        // Merge accumulated visible text once per event (handles partial/cumulative chunks)
+        if (visibleChunk) {
+            const merged = mergeChunks(accumulatedText, visibleChunk);
+            if (merged !== accumulatedText) {
+                accumulatedText = merged;
+                hasContent = accumulatedText.trim().length > 0;
+                callbacks.onText?.(accumulatedText);
             }
         }
         if (parts.length === 0) {
@@ -724,7 +809,9 @@ export async function streamChat(input, callbacks = {}) {
                 }));
             }
         }
-        if (event.text && parts.length === 0) {
+        // Merge top-level event.text even when content.parts has workflow events (e.g. function_call).
+        // Some events mix workflow parts with top-level text; we were dropping text when parts.length > 0.
+        if (typeof event.text === "string" && event.text.trim()) {
             const merged = mergeChunks(accumulatedText, event.text);
             if (merged !== accumulatedText) {
                 accumulatedText = merged;

package/dist/core/segments.js

@@ -0,0 +1,93 @@
+/**
+ * Pure utility functions for building and updating MessageSegment arrays.
+ *
+ * All mutable helpers operate on arrays that the caller owns (history parsing).
+ * All immutable helpers return new arrays (streaming state updates).
+ */
+// ─── Mutable helpers (history parsing) ──────────────────────────────────────
+/** Append a workflow event, merging into the last workflow segment when possible. */
+export function pushWorkflowSegment(segments, event) {
+    const last = segments[segments.length - 1];
+    if (last?.kind === "workflow") {
+        last.events.push(event);
+    }
+    else {
+        segments.push({ kind: "workflow", events: [event] });
+    }
+}
+/** Append text, merging into the last text segment when possible. */
+export function pushTextSegment(segments, text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return;
+    const last = segments[segments.length - 1];
+    if (last?.kind === "text") {
+        last.content = `${last.content}\n${trimmed}`;
+    }
+    else {
+        segments.push({ kind: "text", content: trimmed });
+    }
+}
+// ─── Immutable helpers (streaming state updates) ─────────────────────────────
+/**
+ * Return a new segment list with the workflow event appended.
+ * Merges consecutive workflow events into one segment.
+ *
+ * When a thought arrives after the text (late from stream), prepend it before the
+ * text so it appears above the response — better UX when ADK sends thought last.
+ */
+export function addWorkflowEvent(segments, event) {
+    // Late-arriving thought: segments are [text] only → prepend so thought appears above
+    const first = segments[0];
+    if (event.type === "thought" &&
+        segments.length === 1 &&
+        first?.kind === "text" &&
+        first.content.trim().length > 0) {
+        return [{ kind: "workflow", events: [event] }, first];
+    }
+    const last = segments[segments.length - 1];
+    if (last?.kind === "workflow") {
+        return [
+            ...segments.slice(0, -1),
+            { kind: "workflow", events: [...last.events, event] },
+        ];
+    }
+    return [...segments, { kind: "workflow", events: [event] }];
+}
+/**
+ * Return a new segment list where the last workflow segment's final thought is replaced.
+ * Used when streaming sends an updated/extended thought.
+ */
+export function replaceLastThought(segments, updated) {
+    const last = segments[segments.length - 1];
+    if (last?.kind !== "workflow")
+        return segments;
+    const events = last.events.map((e, i) => i === last.events.length - 1 && e.type === "thought" ? updated : e);
+    return [...segments.slice(0, -1), { kind: "workflow", events }];
+}
+/**
+ * Return a new segment list with the streaming text slice updated.
+ * `fullText` is the full accumulated assistant text; `startOffset` marks where the
+ * current text segment begins within that string (set each time a workflow event arrives).
+ */
+export function updateStreamingText(segments, fullText, startOffset) {
+    const slice = fullText.slice(startOffset).trim();
+    if (!slice)
+        return segments;
+    const last = segments[segments.length - 1];
+    if (last?.kind === "text") {
+        return [...segments.slice(0, -1), { kind: "text", content: slice }];
+    }
+    return [...segments, { kind: "text", content: slice }];
+}
+/**
+ * Merge older segments (from a Ctrl+U load) in front of existing segments.
+ * Used when an invocation spans two page-load batches.
+ */
+export function mergeOlderSegments(existing, older) {
+    if (!older?.length)
+        return existing;
+    if (!existing?.length)
+        return older;
+    return [...older, ...existing];
+}