ocuclaw 0.1.0

package/dist/even-ai/even-ai-model-hook.js

@@ -0,0 +1,80 @@
+import { normalizeEvenAiDefaultModel } from "./even-ai-settings-store.js";
+
+const THROWAWAY_SESSION_PREFIX = "ocuclaw:even-ai:";
+const DEFAULT_DEDICATED_SESSION_KEY = "ocuclaw:even-ai";
+
+function trimString(value) {
+  if (typeof value !== "string") {
+    return "";
+  }
+  return value.trim();
+}
+
+function normalizeSessionKey(value) {
+  return trimString(value).toLowerCase();
+}
+
+function parseModelRef(value) {
+  const normalized = normalizeEvenAiDefaultModel(value);
+  if (!normalized) {
+    return null;
+  }
+  const slash = normalized.indexOf("/");
+  if (slash <= 0 || slash >= normalized.length - 1) {
+    return {
+      modelOverride: normalized,
+    };
+  }
+  const providerOverride = normalized.slice(0, slash).trim();
+  const modelOverride = normalized.slice(slash + 1).trim();
+  if (!providerOverride || !modelOverride) {
+    return {
+      modelOverride: normalized,
+    };
+  }
+  return {
+    providerOverride,
+    modelOverride,
+  };
+}
+
+export function isEvenAiModelHookSession(sessionKey, dedicatedSessionKey) {
+  const normalizedSessionKey = normalizeSessionKey(sessionKey);
+  if (!normalizedSessionKey) {
+    return false;
+  }
+  if (
+    normalizedSessionKey === DEFAULT_DEDICATED_SESSION_KEY ||
+    normalizedSessionKey.startsWith(THROWAWAY_SESSION_PREFIX)
+  ) {
+    return true;
+  }
+  const normalizedDedicatedKey = normalizeSessionKey(dedicatedSessionKey);
+  return !!normalizedDedicatedKey && normalizedSessionKey === normalizedDedicatedKey;
+}
+
+export function createEvenAiModelHook(opts = {}) {
+  const getSettingsSnapshot =
+    typeof opts.getSettingsSnapshot === "function"
+      ? opts.getSettingsSnapshot
+      : () => ({});
+  const getDedicatedSessionKey =
+    typeof opts.getDedicatedSessionKey === "function"
+      ? opts.getDedicatedSessionKey
+      : () => opts.dedicatedSessionKey;
+
+  return function evenAiBeforeModelResolve(_event, ctx) {
+    const sessionKey = ctx && typeof ctx.sessionKey === "string" ? ctx.sessionKey : "";
+    if (!isEvenAiModelHookSession(sessionKey, getDedicatedSessionKey())) {
+      return;
+    }
+    const settings = getSettingsSnapshot() || {};
+    const parsed = parseModelRef(settings.defaultModel);
+    if (!parsed || !parsed.modelOverride) {
+      return;
+    }
+    return parsed;
+  };
+}
+
+export default createEvenAiModelHook;

package/dist/even-ai/even-ai-router.js

@@ -0,0 +1,98 @@
+import { normalizeEvenAiRoutingMode } from "./even-ai-settings-store.js";
+
+export const DEFAULT_EVEN_AI_DEDICATED_SESSION_KEY = "ocuclaw:even-ai";
+
+function normalizeSessionKey(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+
+function normalizeDedicatedSessionKey(value) {
+  const normalized = normalizeSessionKey(value);
+  if (!normalized) {
+    return DEFAULT_EVEN_AI_DEDICATED_SESSION_KEY;
+  }
+  return normalized.toLowerCase().startsWith("ocuclaw:")
+    ? normalized
+    : DEFAULT_EVEN_AI_DEDICATED_SESSION_KEY;
+}
+
+export function createEvenAiRouter(opts = {}) {
+  const sessionService = opts.sessionService;
+  if (!sessionService || typeof sessionService.ensureSessionKey !== "function") {
+    throw new Error("Even AI router requires sessionService.ensureSessionKey()");
+  }
+
+  const getRoutingMode =
+    typeof opts.getRoutingMode === "function"
+      ? opts.getRoutingMode
+      : () => opts.routingMode;
+  const dedicatedSessionKey = normalizeDedicatedSessionKey(
+    opts.dedicatedSessionKey,
+  );
+
+  async function resolveTargetSession() {
+    const routingMode = normalizeEvenAiRoutingMode(getRoutingMode());
+    const previousSessionKey =
+      typeof sessionService.peekSessionKey === "function"
+        ? normalizeSessionKey(sessionService.peekSessionKey())
+        : null;
+
+    if (routingMode === "background") {
+      return {
+        routingMode,
+        sessionKey: dedicatedSessionKey,
+        previousSessionKey,
+        sessionChanged: false,
+      };
+    }
+
+    if (routingMode === "background_new") {
+      if (typeof sessionService.createDetachedSessionKey !== "function") {
+        throw new Error(
+          "Even AI router requires sessionService.createDetachedSessionKey()",
+        );
+      }
+      const sessionKey = normalizeSessionKey(
+        await Promise.resolve(
+          sessionService.createDetachedSessionKey("ocuclaw:even-ai:"),
+        ),
+      );
+      if (!sessionKey) {
+        throw new Error("Even AI router failed to create a detached session key.");
+      }
+      return {
+        routingMode,
+        sessionKey,
+        previousSessionKey,
+        sessionChanged: false,
+      };
+    }
+
+    return {
+      routingMode: normalizeEvenAiRoutingMode(),
+      sessionKey: normalizeSessionKey(sessionService.ensureSessionKey()) || "main",
+      previousSessionKey,
+      sessionChanged: false,
+    };
+  }
+
+  return {
+    getRoutingMode() {
+      return normalizeEvenAiRoutingMode(getRoutingMode());
+    },
+
+    getDedicatedSessionKey() {
+      return dedicatedSessionKey;
+    },
+
+    resolveActiveSession() {
+      return normalizeSessionKey(sessionService.ensureSessionKey()) || "main";
+    },
+
+    resolveTargetSession,
+  };
+}
+
+export default createEvenAiRouter;

package/dist/even-ai/even-ai-run-waiter.js

@@ -0,0 +1,265 @@
+function normalizeLogger(logger) {
+  if (!logger || typeof logger !== "object") {
+    return console;
+  }
+  return {
+    info: typeof logger.info === "function" ? logger.info.bind(logger) : console.log,
+    warn: typeof logger.warn === "function" ? logger.warn.bind(logger) : console.warn,
+    error: typeof logger.error === "function" ? logger.error.bind(logger) : console.error,
+    debug:
+      typeof logger.debug === "function" ? logger.debug.bind(logger) : console.debug,
+  };
+}
+
+function normalizeRunId(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+
+function normalizeSessionKey(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+
+function normalizeSessionKeyForCompare(value) {
+  const normalized = normalizeSessionKey(value);
+  if (!normalized) return "";
+  const lowered = normalized.toLowerCase();
+  const prefixIndex = lowered.indexOf("ocuclaw:");
+  return (prefixIndex >= 0 ? normalized.slice(prefixIndex) : normalized).toLowerCase();
+}
+
+function sessionKeysMatch(expected, actual) {
+  const normalizedExpected = normalizeSessionKeyForCompare(expected);
+  const normalizedActual = normalizeSessionKeyForCompare(actual);
+  if (!normalizedExpected || !normalizedActual) return false;
+  return (
+    normalizedExpected === normalizedActual ||
+    normalizedExpected.endsWith(`:${normalizedActual}`) ||
+    normalizedActual.endsWith(`:${normalizedExpected}`)
+  );
+}
+
+function extractAssistantText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content
+    .filter((block) => {
+      return (
+        block &&
+        block.type === "text" &&
+        typeof block.text === "string"
+      );
+    })
+    .map((block) => block.text)
+    .join("");
+}
+
+function createRunWaiterError(code, message, extras = {}) {
+  const err = new Error(message);
+  err.code = code;
+  Object.assign(err, extras);
+  return err;
+}
+
+export function createEvenAiRunWaiter(opts = {}) {
+  const gatewayBridge = opts.gatewayBridge;
+  if (!gatewayBridge || typeof gatewayBridge.on !== "function") {
+    throw new Error("Even AI run waiter requires gatewayBridge.on()");
+  }
+
+  const logger = normalizeLogger(opts.logger);
+  const emitDebug = typeof opts.emitDebug === "function" ? opts.emitDebug : () => {};
+  const setTimeoutFn =
+    typeof opts.setTimeout === "function" ? opts.setTimeout : setTimeout;
+  const clearTimeoutFn =
+    typeof opts.clearTimeout === "function" ? opts.clearTimeout : clearTimeout;
+
+  /** @type {Map<string, {resolve: Function, reject: Function, sessionKey: string|null, timer: any, timeoutMs: number|null}>} */
+  const pendingRuns = new Map();
+
+  function cleanupPending(runId) {
+    const pending = pendingRuns.get(runId);
+    if (!pending) return null;
+    pendingRuns.delete(runId);
+    if (pending.timer) {
+      clearTimeoutFn(pending.timer);
+    }
+    return pending;
+  }
+
+  function rejectRun(runId, err, eventName) {
+    const pending = cleanupPending(runId);
+    if (!pending) return false;
+    emitDebug(
+      "evenai",
+      eventName,
+      err && err.code === "evenai_timeout" ? "warn" : "error",
+      {
+        sessionKey: pending.sessionKey || undefined,
+        runId,
+      },
+      () => ({
+        timeoutMs: pending.timeoutMs,
+        code: err && err.code ? err.code : null,
+        message: err && err.message ? err.message : String(err),
+      }),
+    );
+    pending.reject(err);
+    return true;
+  }
+
+  function resolveRun(runId, text) {
+    const pending = cleanupPending(runId);
+    if (!pending) return false;
+    emitDebug(
+      "evenai",
+      "run_wait_resolved",
+      "debug",
+      {
+        sessionKey: pending.sessionKey || undefined,
+        runId,
+      },
+      () => ({
+        timeoutMs: pending.timeoutMs,
+        textChars: text.length,
+      }),
+    );
+    pending.resolve(text);
+    return true;
+  }
+
+  const offMessage = gatewayBridge.on("message", (data) => {
+    const runId = normalizeRunId(data && data.runId);
+    if (!runId || !pendingRuns.has(runId)) return;
+    const pending = pendingRuns.get(runId);
+    const sessionKey = normalizeSessionKey(data && data.sessionKey);
+    if (
+      pending &&
+      pending.sessionKey &&
+      sessionKey &&
+      !sessionKeysMatch(pending.sessionKey, sessionKey)
+    ) {
+      return;
+    }
+    if (data && typeof data.role === "string" && data.role !== "assistant") {
+      return;
+    }
+    resolveRun(runId, extractAssistantText(data && data.content));
+  });
+
+  const offActivity = gatewayBridge.on("activity", (data) => {
+    const runId = normalizeRunId(data && data.runId);
+    if (!runId || !pendingRuns.has(runId)) return;
+    const phase = typeof data.phase === "string" ? data.phase.trim().toLowerCase() : "";
+    if (phase !== "error") return;
+    rejectRun(
+      runId,
+      createRunWaiterError(
+        "evenai_upstream_error",
+        "Even AI run failed before completing.",
+      ),
+      "run_wait_failed",
+    );
+  });
+
+  const offDisconnected = gatewayBridge.on("disconnected", () => {
+    for (const runId of Array.from(pendingRuns.keys())) {
+      rejectRun(
+        runId,
+        createRunWaiterError(
+          "evenai_disconnected",
+          "Gateway disconnected while waiting for Even AI completion.",
+        ),
+        "run_wait_disconnected",
+      );
+    }
+  });
+
+  return {
+    waitForRun(request = {}) {
+      const runId = normalizeRunId(request.runId);
+      if (!runId) {
+        return Promise.reject(
+          createRunWaiterError(
+            "evenai_missing_run_id",
+            "Even AI run waiter requires a runId.",
+          ),
+        );
+      }
+      if (pendingRuns.has(runId)) {
+        return Promise.reject(
+          createRunWaiterError(
+            "evenai_duplicate_wait",
+            `Even AI run ${runId} is already being awaited.`,
+          ),
+        );
+      }
+
+      const sessionKey = normalizeSessionKey(request.sessionKey);
+      const timeoutMs =
+        Number.isFinite(request.timeoutMs) && request.timeoutMs > 0
+          ? Math.floor(request.timeoutMs)
+          : null;
+
+      return new Promise((resolve, reject) => {
+        const pending = {
+          resolve,
+          reject,
+          sessionKey,
+          timer: null,
+          timeoutMs,
+        };
+
+        if (timeoutMs !== null) {
+          pending.timer = setTimeoutFn(() => {
+            rejectRun(
+              runId,
+              createRunWaiterError(
+                "evenai_timeout",
+                "Even AI request timed out.",
+                { timeoutMs },
+              ),
+              "run_wait_timeout",
+            );
+          }, timeoutMs);
+        }
+
+        pendingRuns.set(runId, pending);
+        emitDebug(
+          "evenai",
+          "run_wait_started",
+          "debug",
+          { sessionKey: sessionKey || undefined, runId },
+          () => ({ timeoutMs }),
+        );
+      });
+    },
+
+    close() {
+      if (typeof offMessage === "function") offMessage();
+      if (typeof offActivity === "function") offActivity();
+      if (typeof offDisconnected === "function") offDisconnected();
+
+      for (const runId of Array.from(pendingRuns.keys())) {
+        rejectRun(
+          runId,
+          createRunWaiterError(
+            "evenai_waiter_closed",
+            "Even AI run waiter stopped.",
+          ),
+          "run_wait_closed",
+        );
+      }
+      logger.debug("[evenai] run waiter closed");
+    },
+  };
+}
+
+export default createEvenAiRunWaiter;