memorix 1.9.7 → 1.9.9

package/src/config/resolved-config.ts

@@ -96,6 +96,7 @@ export function getResolvedConfig(options: ResolvedLaneOptions = {}): ResolvedMe
   const legacy = loadFileConfig(homeDir);
   const embeddingBaseUrl = first(process.env.MEMORIX_EMBEDDING_BASE_URL, toml.embedding?.base_url, yaml.embedding?.baseUrl, legacy.embeddingApi?.baseUrl);
   const openRouterEmbeddingApiKey = isOpenRouterUrl(embeddingBaseUrl) ? process.env.OPENROUTER_API_KEY : undefined;
+  const requestyEmbeddingApiKey = isRequestyUrl(embeddingBaseUrl) ? process.env.REQUESTY_API_KEY : undefined;
   const memoryLlmProvider = first(
     process.env.MEMORIX_LLM_PROVIDER,
     toml.memory?.llm?.provider,
@@ -118,16 +119,18 @@ export function getResolvedConfig(options: ResolvedLaneOptions = {}): ResolvedMe
     ? process.env.OPENROUTER_API_KEY
     : undefined;
   const isAtlasCloud = memoryLlmProvider === 'atlascloud';
+  const isRequesty = memoryLlmProvider === 'requesty';
+  const usesPresetKeyOnly = isAtlasCloud || isRequesty;
   const memoryLlmApiKey = first(
     process.env.MEMORIX_LLM_API_KEY,
     process.env.MEMORIX_API_KEY,
     toml.memory?.llm?.api_key,
     yaml.llm?.apiKey,
     legacy.llm?.apiKey,
-    // Never borrow another provider's credentials for the Atlas Cloud preset.
-    isAtlasCloud ? process.env.ATLASCLOUD_API_KEY : process.env.OPENAI_API_KEY,
-    isAtlasCloud ? undefined : process.env.ANTHROPIC_API_KEY,
-    isAtlasCloud ? undefined : openRouterMemoryLlmApiKey,
+    // Never borrow another provider's credentials for the Atlas Cloud or Requesty presets.
+    isAtlasCloud ? process.env.ATLASCLOUD_API_KEY : isRequesty ? process.env.REQUESTY_API_KEY : process.env.OPENAI_API_KEY,
+    usesPresetKeyOnly ? undefined : process.env.ANTHROPIC_API_KEY,
+    usesPresetKeyOnly ? undefined : openRouterMemoryLlmApiKey,
   );
 
   const resolved: ResolvedMemorixConfig = {
@@ -177,7 +180,7 @@ export function getResolvedConfig(options: ResolvedLaneOptions = {}): ResolvedMe
       provider: first(process.env.MEMORIX_EMBEDDING, toml.embedding?.provider, yaml.embedding?.provider, legacy.embedding, 'off'),
       model: first(process.env.MEMORIX_EMBEDDING_MODEL, toml.embedding?.model, yaml.embedding?.model, legacy.embeddingApi?.model),
       baseUrl: embeddingBaseUrl,
-      apiKey: first(process.env.MEMORIX_EMBEDDING_API_KEY, toml.embedding?.api_key, yaml.embedding?.apiKey, legacy.embeddingApi?.apiKey, openRouterEmbeddingApiKey),
+      apiKey: first(process.env.MEMORIX_EMBEDDING_API_KEY, toml.embedding?.api_key, yaml.embedding?.apiKey, legacy.embeddingApi?.apiKey, openRouterEmbeddingApiKey, requestyEmbeddingApiKey),
       dimensions: firstNumber(parseNumber(process.env.MEMORIX_EMBEDDING_DIMENSIONS), toml.embedding?.dimensions, yaml.embedding?.dimensions, legacy.embeddingApi?.dimensions),
     },
     rerank: resolveRerankLane({
@@ -323,6 +326,7 @@ function getEnvSourceNames(): string[] {
     'MEMORIX_CODEGRAPH_EXTERNAL_COMMAND',
     'MEMORIX_CODEGRAPH_EXTERNAL_TIMEOUT_MS',
     'OPENROUTER_API_KEY',
+    'REQUESTY_API_KEY',
     'ATLASCLOUD_API_KEY',
   ].filter((name) => process.env[name]);
 }
@@ -337,6 +341,16 @@ function isOpenRouterUrl(value: string | undefined): boolean {
   }
 }
 
+function isRequestyUrl(value: string | undefined): boolean {
+  if (!value) return false;
+  try {
+    const url = new URL(value);
+    return url.hostname.toLowerCase() === 'requesty.ai' || url.hostname.toLowerCase().endsWith('.requesty.ai');
+  } catch {
+    return /(^|\.)requesty\.ai(?::|\/|$)/i.test(value);
+  }
+}
+
 function isOpenRouterMemoryLane(provider: string | undefined, baseUrl: string | undefined): boolean {
   return provider?.trim().toLowerCase() === 'openrouter' || isOpenRouterUrl(baseUrl);
 }

package/src/config/yaml-loader.ts

@@ -25,7 +25,7 @@ import { getGlobalYamlPath, getProjectYamlPath } from './config-paths.js';
 export interface MemorixYamlConfig {
   /** LLM provider configuration */
   llm?: {
-    provider?: 'openai' | 'anthropic' | 'openrouter' | string;
+    provider?: 'openai' | 'anthropic' | 'openrouter' | 'requesty' | string;
     model?: string;
     apiKey?: string;
     baseUrl?: string;
@@ -33,7 +33,7 @@ export interface MemorixYamlConfig {
 
   /** TUI / chat agent LLM provider configuration */
   agent?: {
-    provider?: 'openai' | 'anthropic' | 'openrouter' | string;
+    provider?: 'openai' | 'anthropic' | 'openrouter' | 'requesty' | string;
     model?: string;
     apiKey?: string;
     baseUrl?: string;

package/src/config.ts

@@ -93,7 +93,8 @@ export function getEmbeddingModel(): string {
 /**
  * Provider-aware embedding model default: OpenRouter serves many providers,
  * and the OpenAI-only default does not fit it. Qwen3-Embedding-8B is a
- * strong multilingual default there; everywhere else keep the OpenAI model.
+ * strong multilingual default there. Requesty expects vendor-prefixed ids,
+ * so it gets the prefixed OpenAI model. Everywhere else keep the OpenAI model.
  * An explicitly configured model always wins.
  */
 export function defaultEmbeddingModelFor(
@@ -106,6 +107,9 @@ export function defaultEmbeddingModelFor(
     if (url && (url.hostname === 'openrouter.ai' || url.hostname.endsWith('.openrouter.ai'))) {
       return 'qwen/qwen3-embedding-8b';
     }
+    if (url && (url.hostname === 'requesty.ai' || url.hostname.endsWith('.requesty.ai'))) {
+      return 'openai/text-embedding-3-small';
+    }
   } catch { /* treat unparsable base URLs as non-OpenRouter */ }
   return 'text-embedding-3-small';
 }

package/src/dashboard/server.ts

@@ -682,6 +682,9 @@ async function handleApi(
                     ...(resolved.memory.llm.provider === 'openrouter' || resolved.memory.llm.baseUrl?.includes('openrouter.ai')
                         ? ['OPENROUTER_API_KEY']
                         : []),
+                    ...(resolved.memory.llm.provider === 'requesty'
+                        ? ['REQUESTY_API_KEY']
+                        : []),
                 ];
                 if (llmKey) {
                     const src = resolveDashboardKeySource({ value: llmKey, envKeys: memoryKeyEnv, configSource });

package/src/hooks/installers/index.ts

@@ -449,8 +449,10 @@ function generateKiroHookFiles(): Array<{ filename: string; content: string }> {
  * Format: .opencode/plugins/memorix.js — Bun-compatible JS module
  * See: https://opencode.ai/docs/plugins/
  *
- * Plugin contract (verified against official docs Apr 2026):
- *   - Named export: export const MemorixPlugin = async (ctx) => { return { ... } }
+ * Plugin contracts:
+ *   - OpenCode v1: named export `MemorixPlugin` returns an event-hook map.
+ *   - OpenCode v2: default export contains `id` and `setup(ctx)`, with event
+ *     subscriptions and tool hooks registered through the context.
  *   - Return object keys are EVENT NAMES (e.g. "session.created", "file.edited")
  *   - Each key maps to an async handler: (input, output) => { ... }
  *   - Session/file/command events: handler receives ({ event }) for event-style hooks
@@ -464,7 +466,7 @@ function generateKiroHookFiles(): Array<{ filename: string; content: string }> {
  * protocol used by all agents. spawnSync works in both Node.js and Bun
  * runtimes (OpenCode may fall back to Node.js on Windows).
  */
-const OPENCODE_PLUGIN_VERSION = 7;
+const OPENCODE_PLUGIN_VERSION = 8;
 
 const AGENT_SKILL_DIRS: Partial<Record<AgentName, { project: string; global?: string }>> = {
   cursor: { project: path.join('.cursor', 'skills'), global: path.join('.cursor', 'skills') },
@@ -716,6 +718,161 @@ export const MemorixPlugin = async ({ project, client, $, directory, worktree })
     },
   };
 };
+
+/**
+ * OpenCode v2 compatibility layer. Keep this beside the v1 export so one
+ * generated file can be loaded by both host generations during migration.
+ */
+const v2HookCommand = ${hookCommand};
+
+function v2ReportHookFailure(eventName, detail) {
+  if (process.env.MEMORIX_HOOK_DEBUG !== '1') return;
+  console.error('[memorix-plugin] v2 hook delivery failed:', eventName, detail);
+}
+
+function v2EventData(event) {
+  return event && typeof event.data === 'object' && event.data !== null ? event.data : {};
+}
+
+function v2SessionId(event) {
+  const data = v2EventData(event);
+  const value = data.sessionID ?? data.sessionId ?? data.session_id
+    ?? event?.sessionID ?? event?.sessionId;
+  return typeof value === 'string' ? value : '';
+}
+
+function v2RunHook(payload, directory, sessionId) {
+  const nextPayload = { agent: 'opencode', cwd: directory, ...payload };
+  if (sessionId) nextPayload.session_id = sessionId;
+  const eventName = nextPayload.hook_event_name || 'unknown';
+  try {
+    const result = spawnSync(v2HookCommand, ['hook'], {
+      input: JSON.stringify(nextPayload),
+      timeout: 10_000,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      shell: process.platform === 'win32',
+      windowsHide: true,
+    });
+    if (result.status !== 0) {
+      v2ReportHookFailure(eventName, {
+        exit: result.status,
+        stderr: (result.stderr || '').slice(0, 200),
+        error: result.error?.message,
+      });
+    }
+  } catch (error) {
+    v2ReportHookFailure(eventName, error?.message ?? error);
+  }
+}
+
+function v2SessionState(states, sessionId) {
+  const key = sessionId || '__unknown__';
+  let state = states.get(key);
+  if (!state) {
+    state = { pendingText: '', lastDeliveredKey: '' };
+    states.set(key, state);
+  }
+  return state;
+}
+
+function v2FlushAssistant(state, directory, sessionId) {
+  const text = state.pendingText.trim();
+  if (!text || text === state.lastDeliveredKey) return;
+  v2RunHook({ hook_event_name: 'message.updated', ai_response: text }, directory, sessionId);
+  state.lastDeliveredKey = text;
+  state.pendingText = '';
+}
+
+function v2FilePath(file) {
+  if (typeof file === 'string') return file;
+  if (!file || typeof file !== 'object') return '';
+  return file.path ?? file.file ?? file.name ?? '';
+}
+
+function v2HandleEvent(event, directory, states) {
+  if (!event || typeof event !== 'object') return;
+  const type = typeof event.type === 'string' ? event.type : '';
+  const data = v2EventData(event);
+  const sessionId = v2SessionId(event);
+  const state = v2SessionState(states, sessionId);
+  const run = (payload) => v2RunHook(payload, directory, sessionId);
+
+  switch (type) {
+    case 'session.created':
+      run({ hook_event_name: 'session.created' });
+      break;
+    case 'session.text.delta':
+      state.pendingText += typeof data.delta === 'string' ? data.delta : (typeof data.text === 'string' ? data.text : '');
+      break;
+    case 'session.message.updated':
+    case 'message.updated':
+      if (data.role === 'assistant' && typeof data.text === 'string') state.pendingText = data.text;
+      break;
+    case 'session.step.ended': {
+      const files = Array.isArray(data.files) ? data.files : [];
+      for (const file of files) {
+        const filePath = v2FilePath(file);
+        if (filePath) run({ hook_event_name: 'file.edited', file_path: filePath });
+      }
+      if (typeof data.text === 'string') state.pendingText += data.text;
+      break;
+    }
+    case 'session.idle':
+      v2FlushAssistant(state, directory, sessionId);
+      run({ hook_event_name: 'session.idle' });
+      break;
+    case 'session.compacted':
+      run({ hook_event_name: 'session.compacted' });
+      break;
+    default:
+      break;
+  }
+}
+
+function setup(ctx) {
+  const directory = ctx?.location?.directory || ctx?.location?.worktree || process.cwd();
+  const controller = new AbortController();
+  const states = new Map();
+
+  if (ctx?.tool?.hook) {
+    try {
+      Promise.resolve(ctx.tool.hook('execute.after', async (event) => {
+        const sessionId = v2SessionId(event);
+        const data = event && typeof event.input === 'object' ? event.input : {};
+        const tool = event?.tool ?? event?.name ?? '';
+        v2RunHook({
+          hook_event_name: 'tool.execute.after',
+          tool_name: tool,
+          tool_input: data,
+        }, directory, sessionId);
+        if (tool === 'shell') {
+          v2RunHook({
+            hook_event_name: 'command.executed',
+            command: data.command ?? data.cmd ?? '',
+          }, directory, sessionId);
+        }
+      })).catch((error) => v2ReportHookFailure('execute.after', error?.message ?? error));
+    } catch (error) {
+      v2ReportHookFailure('execute.after', error?.message ?? error);
+    }
+  }
+
+  if (ctx?.event?.subscribe) {
+    void (async () => {
+      try {
+        const stream = ctx.event.subscribe({ signal: controller.signal });
+        for await (const event of stream) v2HandleEvent(event, directory, states);
+      } catch (error) {
+        if (!controller.signal.aborted) v2ReportHookFailure('event.subscribe', error?.message ?? error);
+      }
+    })();
+  }
+
+  return () => controller.abort();
+}
+
+export default { id: 'memorix', setup };
 `;
 }
 

package/src/llm/provider.ts

@@ -20,7 +20,7 @@ import {
 } from '../config.js';
 
 export interface LLMConfig {
-  provider: 'openai' | 'anthropic' | 'openrouter' | 'atlascloud' | 'custom';
+  provider: 'openai' | 'anthropic' | 'openrouter' | 'requesty' | 'atlascloud' | 'custom';
   apiKey: string;
   model?: string;
   baseUrl?: string;
@@ -201,6 +201,7 @@ const PROVIDER_DEFAULTS: Record<string, { baseUrl: string; model: string }> = {
   openai: { baseUrl: 'https://api.openai.com/v1', model: 'gpt-4.1-nano' },
   anthropic: { baseUrl: 'https://api.anthropic.com/v1', model: 'claude-3-5-haiku-latest' },
   openrouter: { baseUrl: 'https://openrouter.ai/api/v1', model: 'openai/gpt-4.1-nano' },
+  requesty: { baseUrl: 'https://router.requesty.ai/v1', model: 'openai/gpt-4.1-nano' },
   atlascloud: { baseUrl: 'https://api.atlascloud.ai/v1', model: 'deepseek-ai/deepseek-v3.2' },
   custom: { baseUrl: 'http://localhost:11434/v1', model: 'llama3' },
 };

package/src/multimodal/image-loader.ts

@@ -19,7 +19,7 @@ import {
 } from './image-payload.js';
 
 // Providers that use the OpenAI-compatible /chat/completions Vision endpoint
-const OPENAI_COMPATIBLE_PROVIDERS = new Set(['openai', 'openrouter', 'custom']);
+const OPENAI_COMPATIBLE_PROVIDERS = new Set(['openai', 'openrouter', 'requesty', 'custom']);
 const MAX_VISION_PROMPT_CHARS = 12_000;
 const MAX_VISION_DESCRIPTION_CHARS = 12_000;
 const MAX_VISION_LABELS = 50;
@@ -137,7 +137,7 @@ export async function analyzeImage(input: ImageInput): Promise<ImageAnalysisResu
   const config = getLLMConfig()!;
   if (!OPENAI_COMPATIBLE_PROVIDERS.has(config.provider)) {
     throw new Error(
-      `Image analysis requires an OpenAI-compatible provider (openai, openrouter, or custom). ` +
+      `Image analysis requires an OpenAI-compatible provider (openai, openrouter, requesty, or custom). ` +
       `Current provider "${config.provider}" uses a different API shape. ` +
       `Set MEMORIX_LLM_PROVIDER=openai or configure an OpenAI-compatible base URL.`,
     );