openaxies 0.4.0 → 0.5.1

package/src/components/ComposerDock.js

@@ -1,105 +1,54 @@
 import React from 'react';
-import { Box, Text } from 'ink';
+import { Box, Text, useInput, useStdout } from 'ink';
 import TextInput from 'ink-text-input';
 import { hex } from '../config/theme.js';
 
 const h = React.createElement;
 
 export const DOCK_HEIGHT = 3;
-const MAX_FRAME_WIDTH = 80;
-const PROMPT = 'openaxies@root:~$ ';
 
-function checkString(value) {
-  if (typeof value !== 'string') {
-    return '';
-  }
-  return value;
-}
+const PROMPT = '> ';
 
-function checkCallback(fn, label) {
-  if (fn !== null && fn !== undefined && typeof fn !== 'function') {
-    throw new Error(label + ' must be a function');
-  }
-}
-
-// ComposerDock — 3 rows, permanently at the bottom of the layout.
-//
-// Layout:
-//   ┌──────────────────────────────────────────────────────────────────────────────┐
-//   │ openaxies@root:~$ [TextInput]                                                │
-//   └──────────────────────────────────────────────────────────────────────────────┘
-//
-// The frame is capped at 80 columns for narrow terminal clients.
-// flexShrink: 0 prevents Ink from ever yielding these rows to the viewport.
-//
-// config.inputActive (bool, default true):
-//   Set to false when SlashOverlay is open so TextInput releases keyboard
-//   focus and arrow keys don't corrupt the input buffer.
 export function createComposerDock(config) {
   if (config === null || config === undefined || typeof config !== 'object') {
     throw new Error('createComposerDock requires a config object');
   }
 
-  const value = checkString(config.value);
+  const value = typeof config.value === 'string' ? config.value : '';
   const onChange = config.onChange;
   const onSubmit = config.onSubmit;
   const inputActive = config.inputActive !== false;
   const isStreaming = config.isStreaming === true;
-  const terminalWidth = Number.isFinite(config.terminalWidth)
-    ? Math.floor(config.terminalWidth)
-    : MAX_FRAME_WIDTH;
-
-  checkCallback(onChange, 'onChange');
-  checkCallback(onSubmit, 'onSubmit');
+  const modelLabel = typeof config.modelLabel === 'string' ? config.modelLabel : '';
+  const modelStatus = config.modelStatus === true;
 
-  const placeholder = isStreaming
-    ? 'Ctrl+C to interrupt...'
-    : '/ commands';
-  const frameWidth = Math.max(2, Math.min(MAX_FRAME_WIDTH, terminalWidth));
-  const innerWidth = frameWidth - 2;
-  const inputWidth = Math.max(1, innerWidth - PROMPT.length);
-  const horizontalRule = '\u2500'.repeat(innerWidth);
+  const placeholder = isStreaming ? 'Ctrl+C to interrupt...' : 'type a message...';
 
   return h(Box, {
     width: '100%',
     height: DOCK_HEIGHT,
     flexDirection: 'column',
-    alignItems: 'center',
     flexShrink: 0,
   },
-    h(Box, { width: frameWidth, height: 1, flexShrink: 0 },
-      h(Text, { color: hex.border }, '\u250C' + horizontalRule + '\u2510')
-    ),
-    h(Box, {
-      width: frameWidth,
-      height: 1,
-      flexDirection: 'row',
-      flexShrink: 0,
-      overflow: 'hidden',
-    },
-      h(Text, { color: hex.border }, '\u2502'),
-      h(Box, {
-        width: innerWidth,
-        height: 1,
-        flexDirection: 'row',
-        overflow: 'hidden',
-      },
-        h(Text, { color: inputActive ? hex.greenOnline : hex.muted, bold: true }, PROMPT),
-        h(Box, { width: inputWidth, height: 1, overflow: 'hidden' },
-          h(TextInput, {
-            value: value,
-            onChange: onChange,
-            onSubmit: onSubmit,
-            placeholder: placeholder,
-            focus: inputActive,
-            showCursor: true,
-          })
-        )
+    h(Box, { height: 1, paddingLeft: 1, paddingRight: 1 },
+      h(Text, { color: inputActive ? hex.primary : '#444466' }, PROMPT),
+      h(Box, { flexGrow: 1, height: 1, overflow: 'hidden' },
+        h(TextInput, {
+          value: value,
+          onChange: onChange,
+          onSubmit: onSubmit,
+          placeholder: placeholder,
+          focus: inputActive,
+          showCursor: true,
+        })
       ),
-      h(Text, { color: hex.border }, '\u2502')
+      h(Text, { color: '#444466' }, '  '),
+      h(Text, { color: modelStatus ? hex.greenOnline : '#444466', bold: modelStatus }, modelLabel || '')
     ),
-    h(Box, { width: frameWidth, height: 1, flexShrink: 0 },
-      h(Text, { color: hex.border }, '\u2514' + horizontalRule + '\u2518')
+    h(Box, { height: 1, paddingLeft: 1, paddingRight: 1 },
+      h(Text, { color: '#333344' }, '/help  /clear  /model  /exit'),
+      h(Box, { flexGrow: 1 }),
+      h(Text, { color: '#333344' }, isStreaming ? 'Ctrl+C to stop' : '')
     )
   );
 }

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')
-    ),
-  );
-}