openaxies 0.1.0

package/src/providers/index.js

@@ -0,0 +1,110 @@
+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([
+    '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',
+    'https://universal-618-clarity-5.hf.space/v1/chat/completions',
+    'https://universal-618-clarity-6.hf.space/v1/chat/completions',
+  ]),
+});
+
+function checkMessages(messages) {
+  if (Array.isArray(messages) === false) {
+    throw new Error('messages must be an array');
+  }
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg === null || msg === undefined || typeof msg !== 'object') {
+      throw new Error('message at index ' + i + ' must be an object');
+    }
+    if (typeof msg.role !== 'string' || msg.role.length === 0) {
+      throw new Error('message at index ' + i + ' must have a non-empty role');
+    }
+    if (typeof msg.content !== 'string') {
+      throw new Error('message at index ' + i + ' content must be a string');
+    }
+  }
+  return messages;
+}
+
+export async function* callModel(modelConfig, messages, signal) {
+  if (modelConfig === null || modelConfig === undefined || typeof modelConfig !== 'object') {
+    throw new Error('modelConfig must be an object');
+  }
+  if (typeof modelConfig.id !== 'string') {
+    throw new Error('modelConfig.id must be a string');
+  }
+
+  checkMessages(messages);
+
+  const endpoints = MODEL_ROUTES[modelConfig.id];
+  if (endpoints === null || endpoints === undefined) {
+    throw new Error('No endpoints configured for model: ' + modelConfig.id);
+  }
+
+  const modelShort = modelConfig.id.replace(/^[^/]+\//, '');
+  let modelMessages = messages;
+
+  if (shouldUseWebSearch(messages) === true) {
+    yield { type: 'thinking', content: 'OpenAxies thinking > [Internal reasoning]' };
+    yield { type: 'thinking', content: 'Checking tools...' };
+    yield { type: 'thinking', content: 'Let me do websearch' };
+    yield { type: 'thinking', content: 'Doing websearch' };
+
+    try {
+      const webResult = await runWebSearchGraph(messages, signal);
+      if (webResult.used === true) {
+        yield { type: 'thinking', content: 'Searched ' + webResult.sites + ' sites' };
+        yield { type: 'thinking', content: 'Thinking...' };
+        modelMessages = [{
+          role: 'system',
+          content:
+            'Use these websearch results when they are relevant. Cite URLs inline when possible.\n\n' +
+            webResult.summary,
+        }].concat(messages);
+      }
+    } catch (err) {
+      yield { type: 'thinking', content: 'Searched 0 sites' };
+      yield { type: 'thinking', content: 'Thinking...' };
+    }
+  }
+
+  const body = {
+    model: modelShort,
+    messages: modelMessages,
+    max_tokens: 4096,
+    temperature: 0.7,
+  };
+
+  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 {
+      const stream = streamResponse(endpoint, body, signal);
+      for await (const event of stream) {
+        yield event;
+      }
+      return; // clean exit — stream completed
+    } 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

@@ -0,0 +1,144 @@
+const CONNECT_TIMEOUT = 120000;
+const READ_TIMEOUT = 15000;
+
+function readWithTimeout(reader, timeoutMs) {
+  return Promise.race([
+    reader.read(),
+    new Promise(function (_, reject) {
+      setTimeout(function () {
+        reject(new Error('stream_read_timeout'));
+      }, timeoutMs);
+    }),
+  ]);
+}
+
+function checkEndpoint(url) {
+  if (typeof url !== 'string' || url.length === 0) {
+    throw new Error('endpoint must be a non-empty URL string');
+  }
+}
+
+function checkBody(body) {
+  if (body === null || body === undefined || typeof body !== 'object') {
+    throw new Error('body must be an object');
+  }
+}
+
+export async function* streamResponse(endpoint, body, signal) {
+  checkEndpoint(endpoint);
+  checkBody(body);
+
+  const controller = new AbortController();
+
+  function onAbort() {
+    try {
+      controller.abort();
+    } catch (_) {
+    }
+  }
+
+  if (signal !== null && signal !== undefined) {
+    signal.addEventListener('abort', onAbort, { once: true });
+  }
+
+  const connectTimeout = setTimeout(function () {
+    try {
+      controller.abort();
+    } catch (_) {
+    }
+  }, CONNECT_TIMEOUT);
+
+  try {
+    const res = await fetch(endpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(Object.assign({}, body, { stream: true })),
+      signal: controller.signal,
+    });
+
+    clearTimeout(connectTimeout);
+
+    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));
+    }
+
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    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 done = result.done;
+      const value = result.value;
+
+      if (done === true) {
+        break;
+      }
+
+      buffer = buffer + decoder.decode(value, { stream: true });
+      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 (choice.finish_reason !== null && choice.finish_reason !== undefined) {
+            yield { type: 'done', reason: choice.finish_reason };
+          }
+        } catch (_) {
+        }
+      }
+    }
+
+    yield { type: 'done' };
+  } finally {
+    clearTimeout(connectTimeout);
+    if (signal !== null && signal !== undefined) {
+      try {
+        signal.removeEventListener('abort', onAbort);
+      } catch (_) {
+      }
+    }
+    try {
+      controller.abort();
+    } catch (_) {
+    }
+  }
+}

package/src/providers/websearch.js

@@ -0,0 +1,152 @@
+const SEARCH_ENDPOINT = 'https://api.search.brave.com/res/v1/web/search';
+
+function latestUserText(messages) {
+  if (Array.isArray(messages) === false) {
+    return '';
+  }
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg !== null && msg !== undefined && msg.role === 'user') {
+      return typeof msg.content === 'string' ? msg.content : '';
+    }
+  }
+  return '';
+}
+
+function getWebSearchKey() {
+  if (typeof process === 'undefined' || process.env === null || process.env === undefined) {
+    return '';
+  }
+  return process.env.OPENAXIES_WEBSEARCH_KEY || process.env.WEBSEARCH_API_KEY || '';
+}
+
+export function shouldUseWebSearch(messages) {
+  const text = latestUserText(messages).toLowerCase();
+  if (text.length === 0) {
+    return false;
+  }
+
+  const unstablePatterns = [
+    'latest', 'current', 'today', 'tonight', 'tomorrow', 'yesterday', 'recent',
+    'news', 'price', 'stock', 'weather', 'score', 'schedule', 'release',
+    'version', 'update', '2025', '2026', 'now', 'right now', 'web', 'search',
+    'source', 'sources', 'cite', 'citation', 'verify', 'lookup', 'look up',
+  ];
+
+  for (let i = 0; i < unstablePatterns.length; i++) {
+    if (text.indexOf(unstablePatterns[i]) !== -1) {
+      return true;
+    }
+  }
+
+  const asksExternalFact = /^(who|what|when|where|why|how)\b/.test(text.trim());
+  const hasNamedThing = /[A-Z][a-z]+/.test(latestUserText(messages));
+  return asksExternalFact === true && hasNamedThing === true;
+}
+
+async function searchWeb(query, signal) {
+  const key = getWebSearchKey();
+  if (key.length === 0) {
+    return {
+      sites: 0,
+      summary: 'Websearch skipped: set OPENAXIES_WEBSEARCH_KEY or WEBSEARCH_API_KEY.',
+    };
+  }
+
+  const url = SEARCH_ENDPOINT + '?q=' + encodeURIComponent(query) + '&count=5';
+  const response = await fetch(url, {
+    method: 'GET',
+    headers: {
+      'Accept': 'application/json',
+      'X-Subscription-Token': key,
+    },
+    signal: signal,
+  });
+
+  if (response.ok === false) {
+    throw new Error('websearch_http_' + response.status);
+  }
+
+  const json = await response.json();
+  const results = json && json.web && Array.isArray(json.web.results)
+    ? json.web.results
+    : [];
+  const lines = [];
+
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    const title = typeof result.title === 'string' ? result.title : 'Untitled';
+    const urlValue = typeof result.url === 'string' ? result.url : '';
+    const description = typeof result.description === 'string' ? result.description : '';
+    lines.push('- ' + title + ' | ' + urlValue + ' | ' + description);
+  }
+
+  return {
+    sites: results.length,
+    summary: lines.length > 0 ? lines.join('\n') : 'No web results returned.',
+  };
+}
+
+async function runFallbackGraph(messages, signal) {
+  const query = latestUserText(messages);
+  if (shouldUseWebSearch(messages) === false) {
+    return { used: false, sites: 0, summary: '' };
+  }
+  const result = await searchWeb(query, signal);
+  return { used: true, sites: result.sites, summary: result.summary };
+}
+
+export async function runWebSearchGraph(messages, signal) {
+  const query = latestUserText(messages);
+
+  try {
+    const langGraph = await import('@langchain/langgraph');
+    const Annotation = langGraph.Annotation;
+    const StateGraph = langGraph.StateGraph;
+    const START = langGraph.START;
+    const END = langGraph.END;
+
+    if (!Annotation || !StateGraph || !START || !END) {
+      return runFallbackGraph(messages, signal);
+    }
+
+    const SearchState = Annotation.Root({
+      query: Annotation(),
+      shouldSearch: Annotation(),
+      result: Annotation(),
+    });
+
+    const graph = new StateGraph(SearchState)
+      .addNode('classify', async function (state) {
+        return { shouldSearch: shouldUseWebSearch([{ role: 'user', content: state.query }]) };
+      })
+      .addNode('websearch', async function (state) {
+        const result = await searchWeb(state.query, signal);
+        return { result: result };
+      })
+      .addEdge(START, 'classify')
+      .addConditionalEdges('classify', function (state) {
+        return state.shouldSearch === true ? 'websearch' : END;
+      })
+      .addEdge('websearch', END)
+      .compile();
+
+    const state = await graph.invoke({
+      query: query,
+      shouldSearch: false,
+      result: { sites: 0, summary: '' },
+    });
+
+    if (state.shouldSearch !== true) {
+      return { used: false, sites: 0, summary: '' };
+    }
+
+    return {
+      used: true,
+      sites: state.result.sites,
+      summary: state.result.summary,
+    };
+  } catch (_) {
+    return runFallbackGraph(messages, signal);
+  }
+}