openaxies 0.4.0 → 0.5.0

package/src/components/ModelBar.js

@@ -0,0 +1,42 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import { hex } from '../config/theme.js';
+import { getModels } from '../config/models.js';
+
+const h = React.createElement;
+
+const BAR_COLOR = '#1A1A2E';
+
+export function createModelBar(activeId, cols) {
+  const models = getModels();
+  const safeCols = typeof cols === 'number' && cols > 0 ? cols : 80;
+  const parts = [];
+
+  for (let i = 0; i < models.length; i++) {
+    const m = models[i];
+    const isActive = m.id === activeId;
+    if (i > 0) {
+      parts.push(h(Text, { key: 'sp-' + i, color: BAR_COLOR }, '  \u2502  '));
+    }
+    const prefix = isActive ? '\u25B8 ' : '  ';
+    const dot = isActive ? '\u25CF' : '\u25CB';
+    const dotColor = isActive ? hex.greenOnline : '#333355';
+    const nameColor = isActive ? hex.neonBlue : '#555577';
+    const badgeColor = isActive ? hex.muted : '#333344';
+
+    parts.push(
+      h(Text, { key: 'pre-' + i, color: hex.primary }, prefix)
+    );
+    parts.push(
+      h(Text, { key: 'nm-' + i, color: nameColor, bold: isActive }, m.label)
+    );
+    parts.push(
+      h(Text, { key: 'bd-' + i, color: badgeColor }, ' [' + m.badge + ']')
+    );
+    parts.push(
+      h(Text, { key: 'dt-' + i, color: dotColor }, ' ' + dot)
+    );
+  }
+
+  return h(Box, { width: '100%', height: 1, paddingLeft: 1 }, ...parts);
+}

package/src/components/Particles.js

@@ -0,0 +1,47 @@
+import React from 'react';
+import { Text } from 'ink';
+import { hex } from '../config/theme.js';
+
+const h = React.createElement;
+
+const CHAR_SET = [
+  '\u2726', '\u00B7', '\u2727', '\u00B7', '\u2605', '\u00B7',
+  '\u2726', '\u00B7', '\u2219', '\u2727', '\u00B7', '\u2726',
+  '\u2219', '\u2605', '\u2219', '\u2727', '\u2219', '\u2726',
+  '\u00B7', '\u2727', '\u2605', '\u00B7', '\u2726', '\u00B7',
+  '\u2219', '\u2727',
+];
+
+const COLORS = [
+  '#00F0FF', '#FF9F43', '#00FF88', '#FF6B9D', '#8B5CF6',
+  '#00F0FF', '#FFD700', '#00FF88',
+];
+
+function getColor(frame, index, total) {
+  const phase = Math.floor((index / total) * 52);
+  const idx = (frame + phase) % COLORS.length;
+  return COLORS[idx];
+}
+
+export function createParticleRow(frame, cols, key) {
+  const safeCols = typeof cols === 'number' && cols > 0 ? cols : 80;
+  const safeFrame = typeof frame === 'number' ? frame : 0;
+  const parts = [];
+
+  for (let i = 0; i < 26; i++) {
+    const color = getColor(safeFrame, i, 52);
+    const ch = CHAR_SET[i % CHAR_SET.length];
+    parts.push(
+      h(Text, { key: key + '-' + i, color: color }, ch)
+    );
+  }
+
+  return h(Text, null, parts);
+}
+
+export function createParticlePair(frame, cols) {
+  return [
+    createParticleRow(frame, cols, 'top'),
+    createParticleRow(frame, cols, 'bot'),
+  ];
+}

package/src/config/models.js

@@ -35,16 +35,22 @@ function checkModels(arr) {
 
 const MODELS = Object.freeze([
   {
-    id: 'openaxis/openaxis-flash',
+    id: 'openaxis/openaxis-llama',
     provider: 'openaxis',
-    label: 'OpenAxies Flash',
+    label: 'OpenAxies Llama',
     badge: 'Fast',
   },
   {
-    id: 'openaxis/openaxis-heavy',
+    id: 'openaxis/openaxis-gpt',
     provider: 'openaxis',
-    label: 'OpenAxies Heavy',
-    badge: 'Quality',
+    label: 'OpenAxies GPT',
+    badge: 'Balanced',
+  },
+  {
+    id: 'openaxis/openaxis-deepseek',
+    provider: 'openaxis',
+    label: 'OpenAxies DeepSeek',
+    badge: 'Reasoning',
   },
 ]);
 

package/src/providers/index.js

@@ -1,18 +1,17 @@
 import { streamResponse } from './streaming.js';
 import { runWebSearchGraph, shouldUseWebSearch } from './websearch.js';
 
-// Primary + two warm fallbacks per model.
-// HF Spaces cold-start on first request (30–120 s model download).
-// If the primary is waking up, we fall through to the next Space.
 const MODEL_ROUTES = Object.freeze({
-  'openaxis/openaxis-flash': Object.freeze([
+  'openaxis/openaxis-llama': Object.freeze([
     'https://universal-618-clarity-main.hf.space/v1/chat/completions',
-    'https://universal-618-clarity-2.hf.space/v1/chat/completions',
-    'https://universal-618-clarity-3.hf.space/v1/chat/completions',
-  ]),
-  'openaxis/openaxis-heavy': Object.freeze([
     'https://universal-618-clarity-4.hf.space/v1/chat/completions',
+  ]),
+  'openaxis/openaxis-gpt': Object.freeze([
+    'https://universal-618-clarity-2.hf.space/v1/chat/completions',
     'https://universal-618-clarity-5.hf.space/v1/chat/completions',
+  ]),
+  'openaxis/openaxis-deepseek': Object.freeze([
+    'https://universal-618-clarity-3.hf.space/v1/chat/completions',
     'https://universal-618-clarity-6.hf.space/v1/chat/completions',
   ]),
 });
@@ -53,11 +52,17 @@ export async function* callModel(modelConfig, messages, signal) {
 
   const modelShort = modelConfig.id.replace(/^[^/]+\//, '');
   let modelMessages = messages;
+  let webUsed = false;
+  let webSites = 0;
+  let webQuery = '';
 
   if (shouldUseWebSearch(messages) === true) {
     try {
       const webResult = await runWebSearchGraph(messages, signal);
       if (webResult.used === true && webResult.sites > 0) {
+        webUsed = true;
+        webSites = webResult.sites;
+        webQuery = webResult.query || '';
         modelMessages = [{
           role: 'system',
           content:
@@ -70,6 +75,8 @@ export async function* callModel(modelConfig, messages, signal) {
     }
   }
 
+  yield { type: 'tool', tool: 'websearch', used: webUsed, sites: webSites, query: webQuery };
+
   const body = {
     model: modelShort,
     messages: modelMessages,
@@ -79,7 +86,6 @@ export async function* callModel(modelConfig, messages, signal) {
 
   let lastError = null;
 
-  // Try each endpoint in order — fall through if one throws or returns an error.
   for (let i = 0; i < endpoints.length; i++) {
     const endpoint = endpoints[i];
     try {
@@ -87,16 +93,14 @@ export async function* callModel(modelConfig, messages, signal) {
       for await (const event of stream) {
         yield event;
       }
-      return; // clean exit — stream completed
+      return;
     } catch (err) {
       lastError = err;
-      // Only retry on genuine failures, not on user-initiated abort
       if (signal !== null && signal !== undefined && signal.aborted === true) {
         return;
       }
     }
   }
 
-  // All endpoints failed
   throw lastError !== null ? lastError : new Error('All endpoints failed for ' + modelConfig.id);
 }

package/src/providers/streaming.js

@@ -1,20 +1,12 @@
-const CONNECT_TIMEOUT = 20000;
-const READ_TIMEOUT = 8000;
-
-function readWithTimeout(reader, timeoutMs) {
-  return Promise.race([
-    reader.read(),
-    new Promise(function (_, reject) {
-      setTimeout(function () {
-        reject(new Error('stream_read_timeout'));
-      }, timeoutMs);
-    }),
-  ]);
-}
+const CONNECT_TIMEOUT = 120000;
+const READ_TIMEOUT = 60000;
 
-function checkEndpoint(url) {
-  if (typeof url !== 'string' || url.length === 0) {
-    throw new Error('endpoint must be a non-empty URL string');
+function checkEndpoint(endpoint) {
+  if (typeof endpoint !== 'string') {
+    throw new Error('endpoint must be a string');
+  }
+  if (endpoint.length === 0) {
+    throw new Error('endpoint must not be empty');
   }
 }
 
@@ -24,120 +16,124 @@ function checkBody(body) {
   }
 }
 
+function checkSignal(signal) {
+  if (signal !== null && signal !== undefined && !(signal instanceof AbortSignal)) {
+    throw new Error('signal must be an AbortSignal or null');
+  }
+}
+
 export async function* streamResponse(endpoint, body, signal) {
   checkEndpoint(endpoint);
   checkBody(body);
+  checkSignal(signal);
 
   const controller = new AbortController();
-
-  function onAbort() {
-    try {
-      controller.abort();
-    } catch (_) {
-    }
-  }
-
-  if (signal !== null && signal !== undefined) {
-    signal.addEventListener('abort', onAbort, { once: true });
-  }
+  const combinedSignal = signal !== null && signal !== undefined
+    ? AbortSignal.any ? AbortSignal.any([signal, controller.signal]) : controller.signal
+    : controller.signal;
 
   const connectTimeout = setTimeout(function () {
-    try {
-      controller.abort();
-    } catch (_) {
-    }
+    controller.abort(new Error('Connect timeout: ' + CONNECT_TIMEOUT + 'ms'));
   }, CONNECT_TIMEOUT);
 
+  let response;
+
   try {
-    const res = await fetch(endpoint, {
+    response = await fetch(endpoint, {
       method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(Object.assign({}, body, { stream: true })),
-      signal: controller.signal,
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'text/event-stream',
+      },
+      body: JSON.stringify(body),
+      signal: combinedSignal,
     });
-
+  } catch (err) {
     clearTimeout(connectTimeout);
+    throw err;
+  }
 
-    if (res.ok === false) {
-      let errorText = '';
-      try {
-        errorText = await res.text();
-      } catch (_) {
-        errorText = 'unknown error';
-      }
-      throw new Error('HTTP ' + res.status + ': ' + errorText.slice(0, 300));
+  clearTimeout(connectTimeout);
+
+  if (response.ok === false) {
+    const text = await response.text().catch(function () { return ''; });
+    throw new Error('HTTP ' + response.status + ': ' + text.slice(0, 200));
+  }
+
+  if (response.body === null || response.body === undefined) {
+    throw new Error('Response body is null');
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let readTimeout = null;
+
+  function resetReadTimeout() {
+    if (readTimeout !== null) {
+      clearTimeout(readTimeout);
     }
+    readTimeout = setTimeout(function () {
+      controller.abort(new Error('Read timeout: ' + READ_TIMEOUT + 'ms'));
+    }, READ_TIMEOUT);
+  }
 
-    const reader = res.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
+  resetReadTimeout();
 
+  try {
     while (true) {
-      let result;
-      try {
-        result = await readWithTimeout(reader, READ_TIMEOUT);
-      } catch (err) {
-        if (err.message === 'stream_read_timeout') {
-          yield { type: 'timeout' };
-          return;
-        }
-        throw err;
-      }
+      const result = await reader.read();
+      resetReadTimeout();
 
-      const done = result.done;
-      const value = result.value;
-
-      if (done === true) {
-        break;
+      if (result.done === true) {
+        yield { type: 'done' };
+        return;
       }
 
-      buffer = buffer + decoder.decode(value, { stream: true });
+      const chunk = decoder.decode(result.value, { stream: true });
+      buffer = buffer + chunk;
       const lines = buffer.split('\n');
       buffer = lines.pop() || '';
 
       for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
-        if (line.startsWith('data: ') === false) {
-          continue;
-        }
-        const data = line.slice(6).trim();
-        if (data === '[DONE]') {
-          yield { type: 'done' };
-          return;
-        }
-        try {
-          const json = JSON.parse(data);
-          const choices = json.choices;
-          if (choices === null || choices === undefined || choices.length < 1) {
-            continue;
-          }
-          const choice = choices[0];
-          const delta = choice.delta;
-          if (delta === null || delta === undefined) {
-            continue;
-          }
-          if (delta.content !== null && delta.content !== undefined && delta.content !== '') {
-            yield { type: 'token', content: delta.content };
+        if (line.startsWith('data: ') === true) {
+          const data = line.slice(6).trim();
+          if (data === '[DONE]') {
+            yield { type: 'done' };
+            return;
           }
-          if (choice.finish_reason !== null && choice.finish_reason !== undefined) {
-            yield { type: 'done', reason: choice.finish_reason };
+          try {
+            const parsed = JSON.parse(data);
+            const choice = parsed.choices && parsed.choices[0];
+            if (choice !== null && choice !== undefined) {
+              const delta = choice.delta;
+              if (delta !== null && delta !== undefined) {
+                if (typeof delta.content === 'string') {
+                  yield { type: 'token', content: delta.content };
+                }
+                if (typeof delta.reasoning_content === 'string') {
+                  yield { type: 'token', content: delta.reasoning_content };
+                }
+              }
+            }
+          } catch (_) {
           }
-        } catch (_) {
         }
       }
     }
-
-    yield { type: 'done' };
+  } catch (err) {
+    if (err !== null && err !== undefined && err.name === 'AbortError') {
+      yield { type: 'timeout' };
+      return;
+    }
+    throw err;
   } finally {
-    clearTimeout(connectTimeout);
-    if (signal !== null && signal !== undefined) {
-      try {
-        signal.removeEventListener('abort', onAbort);
-      } catch (_) {
-      }
+    if (readTimeout !== null) {
+      clearTimeout(readTimeout);
     }
     try {
-      controller.abort();
+      await reader.cancel();
     } catch (_) {
     }
   }

package/src/components/BrandHeader.js

@@ -1,60 +0,0 @@
-import React from 'react';
-import { Box, Text } from 'ink';
-import { hex } from '../config/theme.js';
-
-const h = React.createElement;
-
-export const BRAND_HEIGHT = 5;
-
-function checkColumns(cols) {
-  if (typeof cols !== 'number' || cols < 20) {
-    return 80;
-  }
-  return Math.max(20, Math.floor(cols));
-}
-
-function padLine(content, innerWidth) {
-  const safeContent = typeof content === 'string' ? content : '';
-  const clipped = safeContent.length > innerWidth
-    ? safeContent.slice(0, innerWidth)
-    : safeContent;
-  return clipped + ' '.repeat(Math.max(0, innerWidth - clipped.length));
-}
-
-export function createBrandHeader(cols) {
-  const width = checkColumns(cols);
-  const innerWidth = Math.max(1, width - 2);
-  const rule = '\u2500'.repeat(innerWidth);
-  const statusLine = '  [STATUS: ACTIVE] [ENGINE: 32B-OLLAMA] [WEBSEARCH: READY]';
-
-  return h(Box, {
-    flexDirection: 'column',
-    width: '100%',
-    height: BRAND_HEIGHT,
-    backgroundColor: hex.black,
-    flexShrink: 0,
-    overflow: 'hidden',
-  },
-    h(Box, { height: 1 },
-      h(Text, { color: hex.primary, bold: true }, '\u250C' + rule + '\u2510')
-    ),
-    h(Box, { height: 1 },
-      h(Text, { color: hex.primary, bold: true },
-        '\u2502' + padLine('  OPEN', innerWidth) + '\u2502'
-      )
-    ),
-    h(Box, { height: 1 },
-      h(Text, { color: hex.primary, bold: true },
-        '\u2502' + padLine('  AXIES', innerWidth) + '\u2502'
-      )
-    ),
-    h(Box, { height: 1 },
-      h(Text, { color: hex.greenOnline, bold: true },
-        '\u2502' + padLine(statusLine, innerWidth) + '\u2502'
-      )
-    ),
-    h(Box, { height: 1 },
-      h(Text, { color: hex.primary, bold: true }, '\u2514' + rule + '\u2518')
-    ),
-  );
-}

package/src/components/ChatViewport.js

@@ -1,193 +0,0 @@
-import React from 'react';
-import { Box, Text } from 'ink';
-import { hex } from '../config/theme.js';
-
-const h = React.createElement;
-
-const THINK_OPEN = '<think>';
-const THINK_CLOSE = '</think>';
-
-function checkArray(arr) {
-  if (Array.isArray(arr) === false) {
-    return [];
-  }
-  return arr;
-}
-
-function clampWidth(width) {
-  if (typeof width !== 'number' || width < 20) {
-    return 80;
-  }
-  return Math.max(20, width - 2);
-}
-
-function pushLine(lines, text, color, bold) {
-  lines.push({
-    text: typeof text === 'string' ? text : '',
-    color: color,
-    bold: bold === true,
-  });
-}
-
-function wrapText(text, width) {
-  const safeWidth = Math.max(1, width);
-  const raw = typeof text === 'string' ? text : '';
-  const sourceLines = raw.split('\n');
-  const wrapped = [];
-
-  for (let i = 0; i < sourceLines.length; i++) {
-    let line = sourceLines[i];
-    if (line.length === 0) {
-      wrapped.push('');
-      continue;
-    }
-
-    while (line.length > safeWidth) {
-      let cut = line.lastIndexOf(' ', safeWidth);
-      if (cut < Math.floor(safeWidth / 2)) {
-        cut = safeWidth;
-      }
-      wrapped.push(line.slice(0, cut));
-      line = line.slice(cut).trimStart();
-    }
-
-    wrapped.push(line);
-  }
-
-  return wrapped;
-}
-
-function pushWrapped(lines, text, width, color, bold) {
-  const wrapped = wrapText(text, width);
-  for (let i = 0; i < wrapped.length; i++) {
-    pushLine(lines, wrapped[i], color, bold);
-  }
-}
-
-function stripThinkTags(text) {
-  if (typeof text !== 'string') {
-    return '';
-  }
-  return text.split(THINK_OPEN).join('').split(THINK_CLOSE).join('');
-}
-
-function extractThinkContent(text) {
-  if (typeof text !== 'string') {
-    return '';
-  }
-  const openIdx = text.indexOf(THINK_OPEN);
-  if (openIdx === -1) {
-    return '';
-  }
-  const closeIdx = text.indexOf(THINK_CLOSE, openIdx + THINK_OPEN.length);
-  if (closeIdx === -1) {
-    return text.slice(openIdx + THINK_OPEN.length);
-  }
-  return text.slice(openIdx + THINK_OPEN.length, closeIdx);
-}
-
-function extractAfterThink(text) {
-  if (typeof text !== 'string') {
-    return '';
-  }
-  const closeIdx = text.lastIndexOf(THINK_CLOSE);
-  if (closeIdx === -1) {
-    return '';
-  }
-  return text.slice(closeIdx + THINK_CLOSE.length);
-}
-
-function pushRawMessage(lines, msg, safeCols) {
-  if (msg === null || msg === undefined || typeof msg !== 'object') {
-    return;
-  }
-
-  const content = typeof msg.content === 'string' ? msg.content : '';
-  if (content.length === 0) {
-    return;
-  }
-
-  const clean = stripThinkTags(content);
-  if (clean.length === 0) {
-    return;
-  }
-
-  if (msg.role === 'user') {
-    pushWrapped(lines, clean, safeCols, hex.neonBlue, false);
-    return;
-  }
-
-  pushWrapped(lines, clean, safeCols, hex.primary, false);
-}
-
-function pushSpinnerLine(lines, spinnerChar, safeCols) {
-  const safeChar = typeof spinnerChar === 'string' && spinnerChar.length > 0
-    ? spinnerChar
-    : '◐';
-  pushLine(lines, ' ' + safeChar + ' thinking', '#FF9F43', true);
-}
-
-export function createChatViewport(messages, streamText, availLines, cols, scrollOffset, isThinking, spinnerChar) {
-  const safeMessages = checkArray(messages);
-  const safeAvail = typeof availLines === 'number' && availLines > 0 ? availLines : 1;
-  const safeCols = clampWidth(cols);
-  const rawOffset = typeof scrollOffset === 'number' && scrollOffset > 0
-    ? Math.floor(scrollOffset)
-    : 0;
-  const hasStream = typeof streamText === 'string' && streamText.length > 0;
-  const isStreamingThink = isThinking === true && hasStream === true;
-  const transcriptLines = [];
-
-  for (let i = 0; i < safeMessages.length; i++) {
-    pushRawMessage(transcriptLines, safeMessages[i], safeCols);
-  }
-
-  if (hasStream === true) {
-    if (isStreamingThink === true) {
-      pushSpinnerLine(transcriptLines, spinnerChar, safeCols);
-      const thinkContent = extractThinkContent(streamText);
-      if (thinkContent.length > 0) {
-        pushWrapped(transcriptLines, thinkContent, safeCols, '#FF9F43', false);
-      }
-    } else {
-      const clean = stripThinkTags(streamText);
-      if (clean.length > 0) {
-        pushWrapped(transcriptLines, clean, safeCols, hex.primary, false);
-      }
-    }
-  }
-
-  if (transcriptLines.length === 0) {
-    pushLine(transcriptLines, '  awaiting input...', '#333355', false);
-  }
-
-  const visibleHeight = Math.max(1, safeAvail - 1);
-  const maxOffset = Math.max(0, transcriptLines.length - visibleHeight);
-  const safeOffset = Math.min(rawOffset, maxOffset);
-  const endIndex = transcriptLines.length - safeOffset;
-  const startIndex = Math.max(0, endIndex - visibleHeight);
-  const visibleLines = transcriptLines.slice(startIndex, endIndex);
-  const elements = [];
-
-  for (let i = 0; i < visibleLines.length; i++) {
-    const line = visibleLines[i];
-    elements.push(
-      h(Text, {
-        key: 'line-' + (startIndex + i),
-        color: line.color,
-        bold: line.bold,
-      }, line.text)
-    );
-  }
-
-  return h(Box, {
-    flexGrow: 1,
-    height: safeAvail,
-    flexDirection: 'column',
-    overflow: 'hidden',
-    paddingLeft: 1,
-    paddingRight: 1,
-    paddingTop: 0,
-    paddingBottom: 1,
-  }, ...elements);
-}