Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

3.7 KB
Raw Blame
import type { QueryConfigContext } from "../query-config.js";
import {
  createSessionAgentResolver,
  openClawSessionToOvStorageId,
  resolveOpenVikingActorPeerId,
  sanitizeOpenVikingPeerId,
  type OpenVikingPeerRole,
} from "../routing/identity-routing.js";

type Logger = {
  info: (message: string) => void;
  warn: (message: string) => void;
};

export type SessionAgentLookup = {
  agentId?: string;
  senderId?: string;
  requesterSenderId?: string;
  sessionId?: string;
  sessionKey?: string;
  ovSessionId?: string;
};

export type PluginSessionRouting = {
  sessionId?: string;
  sessionKey?: string;
  ovSessionId?: string;
  agentId: string;
  actorPeerId?: string;
};

export function createOpenVikingSessionRoutingRuntime(options: {
  peerRole?: OpenVikingPeerRole;
  peerPrefix: string;
  logFindRequests: boolean;
  logger: Logger;
}) {
  const peerRole = options.peerRole ?? "none";
  const sessionAgentResolver = createSessionAgentResolver(options.peerPrefix);

  const rememberSessionAgentId = (ctx: SessionAgentLookup) => {
    sessionAgentResolver.remember(ctx);
  };

  const resolveAgentId = (
    sessionId?: string,
    sessionKey?: string,
    ovSessionId?: string,
  ): string => {
    const sid = typeof sessionId === "string" ? sessionId.trim() : "";
    const sk = typeof sessionKey === "string" ? sessionKey.trim() : "";
    const ovSid = typeof ovSessionId === "string" ? ovSessionId.trim() : "";
    const result = sessionAgentResolver.resolve(sid, sk, ovSid);
    if (options.logFindRequests) {
      options.logger.info(
        `openviking: resolveAgentId ${JSON.stringify({
          sessionId: sid || "(empty)",
          sessionKey: sk || "(empty)",
          ovSessionId: ovSid || "(empty)",
          parsedConfigPeerPrefix: options.peerPrefix,
          mappedResolvedAgentId: result.mappedResolvedAgentId,
          resolvedBeforeSanitize: result.resolvedBeforeSanitize,
          resolved: result.resolved,
          branch: result.branch,
          aliases: result.aliases,
          fromExplicitBinding: result.fromExplicitBinding,
        })}`,
      );
    }
    return result.resolved;
  };

  const resolvePluginSessionRouting = (ctx?: SessionAgentLookup): PluginSessionRouting => {
    const sessionId = typeof ctx?.sessionId === "string" ? ctx.sessionId.trim() : "";
    const sessionKey = typeof ctx?.sessionKey === "string" ? ctx.sessionKey.trim() : "";
    let ovSessionId = typeof ctx?.ovSessionId === "string" ? ctx.ovSessionId.trim() : "";

    if (!ovSessionId && (sessionId || sessionKey)) {
      ovSessionId = openClawSessionToOvStorageId(
        sessionId || undefined,
        sessionKey || undefined,
      );
    }

    const session = {
      agentId: ctx?.agentId,
      sessionId: sessionId || undefined,
      sessionKey: sessionKey || undefined,
      ovSessionId: ovSessionId || undefined,
    };
    rememberSessionAgentId(session);

    const agentId = resolveAgentId(session.sessionId, session.sessionKey, session.ovSessionId);
    return {
      sessionId: session.sessionId,
      sessionKey: session.sessionKey,
      ovSessionId: session.ovSessionId,
      agentId,
      actorPeerId: resolveOpenVikingActorPeerId({
        peerRole,
        senderPeerId: sanitizeOpenVikingPeerId(ctx?.requesterSenderId ?? ctx?.senderId),
        assistantPeerId: agentId,
        warn: (message) => options.logger.warn(message),
      }),
    };
  };

  const toQueryConfigContext = (session: PluginSessionRouting): QueryConfigContext => ({
    peerId: session.agentId,
    sessionId: session.sessionId,
    sessionKey: session.sessionKey,
    ovSessionId: session.ovSessionId,
  });

  return {
    rememberSessionAgentId,
    resolveAgentId,
    resolvePluginSessionRouting,
    toQueryConfigContext,
  };
}