@rubixkube/rubix 0.0.4 → 0.0.6

package/CHANGELOG.md

@@ -5,6 +5,20 @@ 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.6] - 2025-03-08
+
+### Added
+
+- Workflow event timeline
+- Added Personality
+- Bugfixes and performance improvements
+
+## [0.0.5] - 2025-03-06
+
+### Added
+
+- Bugfixes and performance improvements
+
 ## [0.0.4] - 2025-03-03
 
 ### Added

package/dist/core/rubix-api.js

@@ -1,7 +1,8 @@
 import { getConfig } from "../config/env.js";
 import { refreshAccessToken } from "./device-auth.js";
 import { saveAuthConfig } from "./auth-store.js";
-const DEFAULT_APP_NAME = "SRI Agent";
+import { pushTextSegment, pushWorkflowSegment } from "./segments.js";
+const DEFAULT_APP_NAME = "Rubix";
 export class StreamError extends Error {
     reason;
     status;
@@ -87,7 +88,8 @@ export async function refreshAndUpdateAuth(auth) {
     }
     catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
-        throw new StreamError(`Token refresh failed: ${msg}. Please run /login again.`, {
+        const fullMsg = msg.includes("Token refresh failed") ? msg : `Token refresh failed: ${msg}`;
+        throw new StreamError(`${fullMsg}. Please run /login again.`, {
             reason: "http_error",
             status: 401,
         });
@@ -129,17 +131,20 @@ 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;
+        return existing; // duplicate smaller resend
     if (add.includes(existing))
-        return add;
+        return add; // cumulative with prefix text
     if (existing.includes(add))
-        return existing;
+        return existing; // already included
+    // Find maximal overlap where existing ends with the prefix of add
+    // Matches console/opel handling: no guard that could drop partial chunks
     const maxK = Math.min(existing.length, add.length);
     for (let k = maxK; k > 0; k -= 1) {
         if (existing.endsWith(add.slice(0, k))) {
-            return existing + add.slice(k);
+            const newPart = add.slice(k);
+            return newPart ? existing + newPart : existing;
         }
     }
     return existing + add;
@@ -470,9 +475,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),
@@ -482,65 +494,103 @@ 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);
         for (const part of parts) {
+            // Thought
             if (part.thought === true) {
                 if (typeof part.text === "string" && part.text.trim()) {
-                    workflow.push({
-                        id: `hist-th-${idx}-${workflow.length}`,
+                    const wev = {
+                        id: `th-${invId}-${eIdx}-${turn.workflow.length}`,
                         type: "thought",
                         content: part.text.trim(),
                         ts,
-                    });
+                    };
+                    turn.workflow.push(wev);
+                    pushWorkflowSegment(turn.segments, wev);
                 }
                 continue;
             }
+            // 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;
             }
+            // Plain text — user bubble if author === "user", otherwise assistant bubble
             if (typeof part.text === "string" && part.text.trim()) {
-                text = text ? `${text}\n${part.text}` : part.text;
+                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,
-        });
     }
-    return messages;
+    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, hasMore };
 }
 export async function streamChat(input, callbacks = {}) {
     const { userId } = ensureAuth(input.auth);
@@ -622,6 +672,8 @@ 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)
+        let visibleChunk = "";
         for (const part of parts) {
             const partText = typeof part.text === "string" ? part.text : "";
             if ((part.thought === true || isThoughtType) && partText.trim()) {
@@ -656,13 +708,18 @@ export async function streamChat(input, callbacks = {}) {
                 }));
                 continue;
             }
+            // Visible text (non-thought): accumulate for batch merge
             if (partText && part.thought !== true) {
-                const merged = mergeChunks(accumulatedText, partText);
-                if (merged !== accumulatedText) {
-                    accumulatedText = merged;
-                    hasContent = accumulatedText.trim().length > 0;
-                    callbacks.onText?.(accumulatedText);
-                }
+                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) {
@@ -723,7 +780,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];
+}