frinus-mcp 3.1.0

package/dist/client/agent-client.js

@@ -0,0 +1,71 @@
+/**
+ * HTTP client for the Frinus Agent Service.
+ */
+import axios from "axios";
+import { getResolvedTenantOrgId } from "./memory-client.js";
+export class AgentClient {
+    client;
+    constructor(baseURL, apiKey) {
+        this.client = axios.create({
+            baseURL,
+            timeout: 30000,
+        });
+        this.client.interceptors.request.use((config) => {
+            config.headers = config.headers || {};
+            config.headers['X-API-Key'] = apiKey;
+            const orgId = getResolvedTenantOrgId();
+            if (orgId)
+                config.headers['X-Tenant-ID'] = orgId;
+            return config;
+        });
+    }
+    async createAgent(data) {
+        const response = await this.client.post("/api/v1/agents", data);
+        return response.data;
+    }
+    async listAgents(orgId) {
+        const params = orgId ? { org_id: orgId } : {};
+        const response = await this.client.get("/api/v1/agents", { params });
+        return response.data;
+    }
+    async getAgent(agentId) {
+        const response = await this.client.get(`/api/v1/agents/${agentId}`);
+        return response.data;
+    }
+    async updateAgentPersona(agentId, data) {
+        const response = await this.client.put(`/api/v1/agents/${agentId}/persona`, data);
+        return response.data;
+    }
+    async deleteAgent(agentId) {
+        const response = await this.client.delete(`/api/v1/agents/${agentId}`);
+        if (response.status === 204) {
+            return { deleted: true };
+        }
+        return response.data;
+    }
+    async bootstrapAgent(agentId) {
+        const response = await this.client.post(`/api/v1/agents/${agentId}/bootstrap`);
+        return response.data;
+    }
+    async invokeAgent(data) {
+        // Resolve agent_id from name if needed
+        let agentId = data.agent_id;
+        if (!agentId && data.agent_name) {
+            const agents = await this.listAgents();
+            const found = agents.find((a) => a.name?.toLowerCase() === data.agent_name.toLowerCase());
+            if (found)
+                agentId = found.id;
+            else
+                throw new Error(`Agent '${data.agent_name}' not found`);
+        }
+        if (!agentId)
+            throw new Error("Either agent_id or agent_name is required");
+        const response = await this.client.post(`/api/v1/agents/${agentId}/invoke`, {
+            task_id: data.task_id || "00000000-0000-0000-0000-000000000000",
+            message: data.message,
+            context: data.context,
+            timeout_seconds: data.timeout_seconds || 120,
+        }, { timeout: (data.timeout_seconds || 120) * 1000 + 5000 });
+        return response.data;
+    }
+}

package/dist/client/cp-client.d.ts

@@ -0,0 +1,20 @@
+import type { CpClientInterface } from "../types/index.js";
+export declare class CpClient implements CpClientInterface {
+    private client;
+    constructor(baseURL: string, apiKey: string);
+    createUniverse(orgId: string, data: {
+        name: string;
+        slug: string;
+        description?: string;
+    }): Promise<any>;
+    listUniverses(orgId: string): Promise<any>;
+    updateUniverse(orgId: string, universeId: string, data: {
+        name?: string;
+        description?: string;
+    }): Promise<any>;
+    deleteUniverse(orgId: string, universeId: string): Promise<void>;
+    storeCredential(integrationRef: string, data: Record<string, unknown>, metadata?: Record<string, unknown>): Promise<any>;
+    getCredential(integrationRef: string): Promise<any>;
+    listCredentials(): Promise<any>;
+    deleteCredential(integrationRef: string): Promise<void>;
+}

package/dist/client/cp-client.js

@@ -0,0 +1,58 @@
+/**
+ * HTTP client for the Frinus Control Plane.
+ */
+import axios from "axios";
+import { getResolvedTenantOrgId } from "./memory-client.js";
+export class CpClient {
+    client;
+    constructor(baseURL, apiKey) {
+        this.client = axios.create({
+            baseURL,
+            timeout: 30000,
+        });
+        this.client.interceptors.request.use((config) => {
+            config.headers = config.headers || {};
+            config.headers['X-API-Key'] = apiKey;
+            const orgId = getResolvedTenantOrgId();
+            if (orgId)
+                config.headers['X-Tenant-ID'] = orgId;
+            return config;
+        });
+    }
+    async createUniverse(orgId, data) {
+        const response = await this.client.post(`/api/v1/orgs/${orgId}/universes`, data);
+        return response.data;
+    }
+    async listUniverses(orgId) {
+        const response = await this.client.get(`/api/v1/orgs/${orgId}/universes`);
+        return response.data;
+    }
+    async updateUniverse(orgId, universeId, data) {
+        const response = await this.client.put(`/api/v1/orgs/${orgId}/universes/${universeId}`, data);
+        return response.data;
+    }
+    async deleteUniverse(orgId, universeId) {
+        await this.client.delete(`/api/v1/orgs/${orgId}/universes/${universeId}`);
+    }
+    // =========================================================================
+    // Credential Vault
+    // =========================================================================
+    async storeCredential(integrationRef, data, metadata) {
+        const response = await this.client.post(`/api/v1/credentials/${integrationRef}`, {
+            data,
+            metadata: metadata || {},
+        });
+        return response.data;
+    }
+    async getCredential(integrationRef) {
+        const response = await this.client.get(`/api/v1/credentials/${integrationRef}`);
+        return response.data;
+    }
+    async listCredentials() {
+        const response = await this.client.get(`/api/v1/credentials`);
+        return response.data;
+    }
+    async deleteCredential(integrationRef) {
+        await this.client.delete(`/api/v1/credentials/${integrationRef}`);
+    }
+}

package/dist/client/memory-client.d.ts

@@ -0,0 +1,200 @@
+import type { MemoryClientInterface } from "../types/index.js";
+export declare function getResolvedTenantOrgId(): string | null;
+export declare function setResolvedTenantOrgId(v: string | null): void;
+export declare function getResolvedUserEmail(): string | null;
+export declare function setResolvedUserEmail(v: string | null): void;
+export declare function getResolvedUserId(): string | null;
+export declare function setResolvedUserId(v: string | null): void;
+/** Reset all mutable module state. Useful for tests or server reinitialization. */
+export declare function resetState(): void;
+export declare class MemoryClient implements MemoryClientInterface {
+    private client;
+    constructor(baseURL: string, apiKey: string);
+    /** Return the current tenant org ID (if resolved). */
+    getTenantOrgId(): string | null;
+    getAuthMe(): Promise<any>;
+    startSession(data: {
+        agent_id?: string;
+        parent_session_id?: string;
+    }): Promise<any>;
+    endSession(sessionId: string): Promise<any>;
+    getSessionContext(data: {
+        session_id: string;
+        query: string;
+        agent_id?: string;
+        max_working_memory?: number;
+        max_long_term?: number;
+        include_topics?: boolean;
+    }): Promise<any>;
+    getSessionSummary(sessionId: string): Promise<any>;
+    clearSession(sessionId: string): Promise<any>;
+    storeMemory(data: {
+        agent_id: string;
+        content: string;
+        memory_type?: string;
+        scope?: string;
+        importance?: number;
+        user_id?: string;
+        created_by_user_id?: string;
+        metadata?: Record<string, unknown>;
+        context_id?: string;
+        credential_ref?: string;
+    }): Promise<any>;
+    searchMemories(data: {
+        query_text: string;
+        agent_id?: string;
+        memory_types?: string[];
+        limit?: number;
+    }): Promise<any>;
+    getMemory(memoryId: string): Promise<any>;
+    getAgentMemories(agentId: string, memoryType?: string, limit?: number): Promise<any>;
+    deleteMemory(memoryId: string): Promise<any>;
+    buildContext(data: {
+        agent_id: string;
+        task_description: string;
+        max_tokens?: number;
+    }): Promise<any>;
+    reinforceMemory(memoryId: string, boost?: number): Promise<any>;
+    weakenMemory(memoryId: string, penalty?: number): Promise<any>;
+    getWorkingMemory(contextId: string): Promise<any>;
+    addWorkingMemory(data: {
+        context_id: string;
+        content: string;
+        agent_id?: string;
+        task_id?: string;
+        ttl_seconds?: number;
+    }): Promise<any>;
+    clearWorkingMemory(contextId: string): Promise<any>;
+    captureStream(data: {
+        session_id: string;
+        content: string;
+        direction: string;
+        agent_id?: string;
+        importance?: number;
+        metadata?: Record<string, unknown>;
+    }): Promise<any>;
+    getSessionItems(sessionId: string, limit?: number): Promise<any>;
+    getRecentStreamItems(agentId?: string, limit?: number, includeForgotten?: boolean): Promise<any>;
+    processStream(batchSize?: number): Promise<any>;
+    searchWithAttention(data: {
+        query_text: string;
+        task_type?: string;
+        limit?: number;
+        agent_id?: string;
+        user_id?: string;
+    }): Promise<any>;
+    getUserContext(taskDescription: string, userEmail?: string): Promise<any>;
+    heartbeatTick(data: {
+        agent_id?: string;
+        context_id?: string;
+        session_id?: string;
+    }): Promise<any>;
+    reorientAgent(agentId: string, focus?: string): Promise<any>;
+    runSleepCycle(phases?: string[]): Promise<any>;
+    detectConflicts(similarityThreshold?: number, limit?: number): Promise<any>;
+    resolveConflict(data: {
+        keep_id: string;
+        supersede_id: string;
+        resolution_note: string;
+    }): Promise<any>;
+    detectRedundant(similarityThreshold?: number, limit?: number): Promise<any>;
+    hierarchyConsolidate(data: {
+        memory_ids: string[];
+        summary_content?: string;
+        agent_id?: string;
+    }): Promise<any>;
+    getHierarchyTree(memoryId: string): Promise<any>;
+    createConcept(data: {
+        name: string;
+        universe_id: string;
+        description?: string;
+    }): Promise<any>;
+    listUniverseConcepts(universeId: string): Promise<any>;
+    updateConcept(conceptId: string, data: {
+        name?: string;
+        description?: string;
+    }): Promise<any>;
+    deleteConcept(conceptId: string): Promise<any>;
+    createTheme(data: {
+        name: string;
+        concept_id: string;
+        description?: string;
+    }): Promise<any>;
+    listConceptThemes(conceptId: string): Promise<any>;
+    updateTheme(themeId: string, data: {
+        name?: string;
+        description?: string;
+    }): Promise<any>;
+    deleteTheme(themeId: string): Promise<any>;
+    createTopic(data: {
+        name: string;
+        theme_id: string;
+        description?: string;
+        status?: string;
+    }): Promise<any>;
+    listThemeTopics(themeId: string): Promise<any>;
+    updateTopic(topicId: string, data: {
+        name?: string;
+        description?: string;
+    }): Promise<any>;
+    updateTopicStatus(topicId: string, status: string): Promise<any>;
+    deleteTopic(topicId: string): Promise<any>;
+    createPoint(data: {
+        name: string;
+        topic_id: string;
+        description?: string;
+        status?: string;
+    }): Promise<any>;
+    listTopicPoints(topicId: string): Promise<any>;
+    updatePoint(pointId: string, data: {
+        name?: string;
+        description?: string;
+        content?: string;
+    }): Promise<any>;
+    updatePointStatus(pointId: string, status: string): Promise<any>;
+    deletePoint(pointId: string): Promise<any>;
+    getUniverseHierarchy(universeId: string): Promise<any>;
+    trainingTeach(data: {
+        content: string;
+        type?: string;
+        importance?: number;
+        universe_id?: string;
+    }): Promise<any>;
+    trainingQa(data: {
+        pairs: Array<{
+            question: string;
+            answer: string;
+        }>;
+        importance?: number;
+        universe_id?: string;
+    }): Promise<any>;
+    trainingStats(): Promise<any>;
+    trainingGaps(): Promise<any>;
+    trainingRecent(data?: {
+        limit?: number;
+    }): Promise<any>;
+    createTask(data: {
+        title: string;
+        description?: string;
+        assigned_agent_id?: string;
+        parent_task_id?: string;
+        priority?: number;
+        input_data?: Record<string, unknown>;
+    }): Promise<any>;
+    getTask(taskId: string): Promise<any>;
+    listTasks(data?: {
+        status?: string;
+        assigned_agent_id?: string;
+        parent_task_id?: string;
+        limit?: number;
+    }): Promise<any>;
+    updateTask(taskId: string, data: {
+        status?: string;
+        output_data?: Record<string, unknown>;
+        error_message?: string;
+    }): Promise<any>;
+    listSkills(category?: string): Promise<any>;
+    getAgentSkills(agentId: string): Promise<any>;
+    assignSkill(agentId: string, skillId: string, permission?: string): Promise<any>;
+    removeSkill(agentId: string, skillId: string): Promise<any>;
+}