@ai.ntellect/core 0.4.1 → 0.6.0

package/t.py

@@ -1,79 +0,0 @@
-import os
-import platform
-import subprocess
-import urllib.request
-import sys
-
-def download_meilisearch():
-    """Download the Meilisearch binary for the current OS."""
-    print("Checking operating system...")
-    os_name = platform.system().lower()
-    if os_name == "windows":
-        binary_url = "https://github.com/meilisearch/meilisearch/releases/latest/download/meilisearch-windows-amd64.exe"
-        binary_name = "meilisearch.exe"
-    elif os_name == "darwin":  # macOS
-        binary_url = "https://github.com/meilisearch/meilisearch/releases/latest/download/meilisearch-macos-amd64"
-        binary_name = "meilisearch"
-    elif os_name == "linux":
-        binary_url = "https://github.com/meilisearch/meilisearch/releases/latest/download/meilisearch-linux-amd64"
-        binary_name = "meilisearch"
-    else:
-        print(f"Unsupported operating system: {os_name}")
-        sys.exit(1)
-
-    # Download the binary
-    if not os.path.exists(binary_name):
-        print(f"Downloading Meilisearch binary for {os_name}...")
-        try:
-            urllib.request.urlretrieve(binary_url, binary_name)
-            print("Download complete.")
-        except Exception as e:
-            print(f"Failed to download Meilisearch: {e}")
-            sys.exit(1)
-
-        # Add execute permissions for Linux/macOS
-        if os_name != "windows":
-            os.chmod(binary_name, 0o755)
-    else:
-        print("Meilisearch binary already exists.")
-
-    return binary_name
-
-
-def create_data_directory():
-    """Create a directory for Meilisearch data if it doesn't exist."""
-    data_dir = "./data"
-    if not os.path.exists(data_dir):
-        print("Creating data directory...")
-        os.makedirs(data_dir)
-    else:
-        print("Data directory already exists.")
-    return data_dir
-
-def launch_meilisearch(binary_name, data_dir):
-    """Launch the Meilisearch server."""
-    print("Launching Meilisearch...")
-    try:
-        process = subprocess.Popen(
-            [
-                f"./{binary_name}" if platform.system().lower() != "windows" else binary_name,
-                "--db-path",
-                data_dir,
-                "--master-key",
-                "DEFAULT_MASTER_KEY",
-            ],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-        )
-        print("Meilisearch is running! Access it at http://localhost:7700")
-        for line in iter(process.stdout.readline, b""):
-            print("Meilisearch Log:", line.decode().strip())
-    except Exception as e:
-        print(f"Failed to launch Meilisearch: {e}")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    binary = download_meilisearch()
-    data_directory = create_data_directory()
-    launch_meilisearch(binary, data_directory)

package/t.spec

@@ -1,38 +0,0 @@
-# -*- mode: python ; coding: utf-8 -*-
-
-
-a = Analysis(
-    ['t.py'],
-    pathex=[],
-    binaries=[],
-    datas=[],
-    hiddenimports=[],
-    hookspath=[],
-    hooksconfig={},
-    runtime_hooks=[],
-    excludes=[],
-    noarchive=False,
-    optimize=0,
-)
-pyz = PYZ(a.pure)
-
-exe = EXE(
-    pyz,
-    a.scripts,
-    a.binaries,
-    a.datas,
-    [],
-    name='t',
-    debug=False,
-    bootloader_ignore_signals=False,
-    strip=False,
-    upx=True,
-    upx_exclude=[],
-    runtime_tmpdir=None,
-    console=True,
-    disable_windowed_traceback=False,
-    argv_emulation=False,
-    target_arch=None,
-    codesign_identity=None,
-    entitlements_file=None,
-)

package/t.ts

@@ -1,133 +0,0 @@
-export interface NetworkConfig {
-  name: string;
-  id?: number;
-  rpc: string;
-  explorerUrl: string;
-  nativeToken: string; // WETH
-}
-export const networkConfigs: Record<string, NetworkConfig> = {
-  ethereum: {
-    name: "Ethereum Mainnet",
-    id: 1,
-    rpc: "https://eth.llamarpc.com",
-    explorerUrl: "https://etherscan.io",
-    nativeToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-  },
-  polygon: {
-    name: "Polygon Mainnet",
-    id: 137,
-    rpc: "https://polygon.llamarpc.com",
-    explorerUrl: "https://polygonscan.com",
-    nativeToken: "0x0000000000000000000000000000000000001010",
-  },
-  arbitrum: {
-    name: "Arbitrum Mainnet",
-    id: 42161,
-    rpc: "https://arbitrum.llamarpc.com",
-    explorerUrl: "https://arbiscan.io",
-    nativeToken: "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
-  },
-  base: {
-    name: "Base Mainnet",
-    id: 8453,
-    rpc: "https://base.llamarpc.com",
-    explorerUrl: "https://basescan.org",
-    nativeToken: "0x4200000000000000000000000000000000000006",
-  },
-  solana: {
-    name: "Solana Mainnet",
-    rpc: "https://api.mainnet-beta.solana.com",
-    explorerUrl: "https://solscan.io",
-    nativeToken: "So11111111111111111111111111111111111111112",
-  },
-  sepolia: {
-    name: "Sepolia Testnet",
-    id: 11155111,
-    rpc: "https://sepolia.llamarpc.com",
-    explorerUrl: "https://sepolia.etherscan.io",
-    nativeToken: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14",
-  },
-  baseSepolia: {
-    name: "Base Sepolia Testnet",
-    id: 84532,
-    rpc: "https://base-sepolia-rpc.publicnode.com",
-    explorerUrl: "https://sepolia.basescan.org",
-    nativeToken: "0x4200000000000000000000000000000000000006",
-  },
-};
-
-export const getNetworkProvider = (networkName: string) => {
-  const config = networkConfigs[networkName.toLowerCase()];
-  if (!config) {
-    throw new Error(`Network ${networkName} not supported`);
-  }
-  return { config };
-};
-
-import { parseEther } from "ethers";
-import { z } from "zod";
-
-export type TransactionPrepared = {
-  to: string;
-  value: string;
-  data?: string;
-  chain: {
-    id: number;
-    rpc: string;
-  };
-  type: "transfer" | "approve" | "swap";
-  method?: string;
-  params?: any[];
-};
-
-export const prepareEvmTransaction = {
-  name: "prepare-evm-transaction",
-  description: "Prepare a transaction for the user to sign.",
-  parameters: z.object({
-    walletAddress: z.string(),
-    amount: z
-      .string()
-      .describe("Ask the user for the amount to send, if not specified"),
-    network: z
-      .string()
-      .describe(
-        "Examples networks: ethereum, arbitrum, base. IMPORTANT: You must respect the network name."
-      ),
-  }),
-  execute: async ({
-    walletAddress,
-    amount,
-    network,
-  }: {
-    walletAddress: string;
-    amount: string;
-    network: string;
-  }): Promise<TransactionPrepared> => {
-    try {
-      console.log("💰 Preparing transaction", {
-        to: walletAddress,
-        amount,
-        network,
-      });
-
-      const networkConfig = networkConfigs[network.toLowerCase()];
-
-      if (!networkConfig) {
-        throw new Error(`Network ${network} not found`);
-      }
-
-      return {
-        to: walletAddress,
-        value: parseEther(amount).toString(),
-        chain: {
-          id: networkConfig.id || 0,
-          rpc: networkConfig.rpc,
-        },
-        type: "transfer",
-      };
-    } catch (error) {
-      console.error("💰 Error sending transaction:", error);
-      throw new Error("An error occurred while sending the transaction");
-    }
-  },
-};

package/test/llm/orchestrator.test.ts

@@ -1,47 +0,0 @@
-import { expect } from "chai";
-import { z } from "zod";
-import { Orchestrator } from "../../llm/orchestrator";
-import { ActionSchema } from "../../types";
-
-describe("Orchestrator", () => {
-  let orchestrator: Orchestrator;
-
-  const mockAction: ActionSchema = {
-    name: "prepare-transaction",
-    description: "Prepare a transfer transaction",
-    parameters: z.object({
-      walletAddress: z.string(),
-      amount: z.string(),
-      networkId: z.string(),
-    }),
-    execute: async ({ walletAddress, amount, networkId }) => {
-      return { walletAddress, amount, networkId };
-    },
-  };
-
-  beforeEach(() => {
-    orchestrator = new Orchestrator([mockAction]);
-  });
-
-  it("should process a prompt and return just the answer", async function () {
-    this.timeout(10000);
-
-    const prompt = "Hello how are you?";
-    const result = await orchestrator.process(prompt);
-
-    expect(result).to.have.property("answer").that.is.a("string");
-  });
-
-  it("should process a prompt and return valid actions", async function () {
-    this.timeout(10000);
-
-    const prompt = "Send 0.1 ETH to 0x123...456 on ethereum";
-    const result = await orchestrator.process(prompt);
-    console.dir(result, { depth: null });
-    expect(result).to.have.property("actions").that.is.an("array");
-    expect(result).to.have.property("answer").that.is.a("string");
-    expect(result.actions[0])
-      .to.have.property("parameters")
-      .that.is.an("object");
-  });
-});

package/test/llm/synthesizer.test.ts

@@ -1,31 +0,0 @@
-// import { expect } from "chai";
-// import { Summarizer } from "../../llm/synthesizer";
-
-// describe("Synthesizer", () => {
-//   let synthesizer: Summarizer;
-
-//   beforeEach(() => {
-//     synthesizer = new Summarizer();
-//   });
-
-//   it("should process results and return a summary", async function () {
-//     this.timeout(10000);
-
-//     const mockResults = JSON.stringify({
-//       result: [
-//         {
-//           name: "prepare-transaction",
-//           result: {
-//             to: "0x123...456",
-//             value: "0.1",
-//             chain: { id: 1, name: "ethereum" },
-//           },
-//         },
-//       ],
-//       initialPrompt: "Send 0.1 ETH to 0x123...456 on ethereum",
-//     });
-
-//     const result = await synthesizer.process(mockResults);
-//     expect(result).to.have.property("response").that.is.a("string");
-//   });
-// });

package/types.ts

@@ -1,288 +0,0 @@
-import { Embedding, EmbeddingModel, StreamTextResult } from "ai";
-import { z } from "zod";
-
-export interface BaseLLM {
-  process: (prompt: string) => Promise<string | object>;
-  streamProcess?: (
-    prompt: string
-  ) => Promise<StreamTextResult<Record<string, any>>>;
-}
-
-export type User = {
-  id: string;
-};
-
-export interface QueueItem {
-  name: string;
-  parameters: QueueItemParameter[];
-}
-
-export interface IEventHandler {
-  emitQueueStart(actions: QueueItem[]): void;
-  emitActionStart(action: QueueItem): void;
-  emitActionComplete(action: QueueResult): void;
-  emitQueueComplete(): void;
-}
-
-export type AgentEvent = {
-  onMessage?: (data: any) => void;
-  onQueueStart?: (actions: QueueItem[]) => void;
-  onActionStart?: (action: QueueItem) => void;
-  onActionComplete?: (action: QueueResult) => void;
-  onQueueComplete?: (actions: QueueResult[]) => void;
-  onConfirmationRequired?: (message: string) => Promise<boolean>;
-};
-
-export interface QueueResult {
-  name: string;
-  parameters: Record<string, string>;
-  result: any;
-  error: string | null;
-  cancelled?: boolean;
-}
-
-export interface QueueCallbacks {
-  onActionStart?: (action: QueueItem) => void;
-  onActionComplete?: (result: QueueResult) => void;
-  onQueueComplete?: (results: QueueResult[]) => void;
-  onConfirmationRequired?: (message: string) => Promise<boolean>;
-}
-
-export interface ProcessPromptCallbacks {
-  onQueueStart?: (actions: QueueItem[]) => void | Promise<void>;
-  onActionStart?: (action: QueueItem) => void | Promise<void>;
-  onActionComplete?: (action: QueueResult) => void | Promise<void>;
-  onQueueComplete?: (actions: QueueResult[]) => void | Promise<void>;
-  onConfirmationRequired?: (message: string) => Promise<boolean>;
-}
-
-export type Behavior = {
-  role: string;
-  language: string;
-  guidelines: {
-    important: string[];
-    warnings: string[];
-    steps?: string[];
-  };
-  examplesMessages?: {
-    role: string;
-    content: string;
-  }[];
-};
-
-export type State = {
-  userRequest: string;
-  results: string;
-};
-
-export interface ActionSchema {
-  name: string;
-  description: string;
-  parameters: z.ZodObject<{
-    [key: string]: z.ZodType;
-  }>;
-  execute: (args: any) => Promise<any>;
-  examples?: {
-    role: string;
-    content: string;
-    parameters?: Record<string, any>;
-  }[];
-  confirmation?: {
-    requireConfirmation: boolean;
-    message: string;
-  };
-}
-
-export type ProcessPromptResult = {
-  type: "success" | "clarification" | "confirmation";
-  data:
-    | QueueResult[]
-    | {
-        validationErrors: string[];
-        prompt: string;
-      }
-    | {
-        actions: QueueItem[];
-      };
-  initialPrompt: string;
-};
-
-export interface ActionPattern {
-  id: string;
-  actions: QueueResult[];
-  embeddings: number[][];
-  queries: string[];
-  purpose: string;
-}
-
-export interface MatchOptions {
-  similarityThreshold?: number;
-  maxResults?: number;
-}
-
-export interface MatchResult {
-  data: any;
-  similarityPercentage: number;
-  purpose: string;
-  name?: string;
-  parameters?: Record<string, any>;
-}
-
-export interface SummarizerAgent {
-  process: (
-    results: object,
-    onFinish?: (event: any) => void
-  ) => Promise<
-    | {
-        actions: { name: string; reasoning: string }[];
-        response: string;
-      }
-    | StreamTextResult<Record<string, any>>
-  >;
-  streamProcess: (
-    results: object,
-    onFinish?: (event: any) => void
-  ) => Promise<StreamTextResult<Record<string, any>>>;
-}
-
-export interface CacheMemoryOptions {
-  embeddingModel: EmbeddingModel<string>;
-  cacheTTL?: number;
-  redisUrl?: string;
-  cachePrefix?: string;
-}
-
-export type GenerateObjectResponse = {
-  shouldContinue: boolean;
-  actions: Array<{
-    name: string;
-    parameters: Array<{
-      name: string;
-      value: any;
-    }>;
-    scheduler?: {
-      isScheduled: boolean;
-      cronExpression: string;
-      reason?: string;
-    };
-  }>;
-  socialResponse?: {
-    shouldRespond: boolean;
-    response?: string;
-    isPartialResponse?: boolean;
-  };
-  interpreter?: string;
-};
-
-export interface CreateMemoryInput {
-  query: string;
-  data: any;
-  userId?: string;
-  scope?: MemoryScope;
-  ttl?: number;
-}
-
-export interface CacheMemoryType {
-  id: string;
-  data: any;
-  query: string;
-  embedding: Embedding;
-  userId?: string;
-  scope: MemoryScope;
-  createdAt: Date;
-}
-
-export interface PersistentMemoryOptions {
-  host: string;
-  apiKey: string;
-  indexPrefix?: string;
-}
-
-export interface MemoryChunk {
-  content: string;
-  embedding: number[];
-}
-
-export type MemoryScopeType = (typeof MemoryScope)[keyof typeof MemoryScope];
-
-export interface LongTermMemory {
-  id: string;
-  query: string;
-  category: string;
-  data: any;
-  roomId: string;
-  createdAt: Date;
-  chunks?: MemoryChunk[];
-  tags: string[];
-}
-
-export const ActionSchema = z.array(
-  z.object({
-    name: z.string(),
-    parameters: z.array(
-      z.object({
-        name: z.string(),
-        value: z.string(),
-      })
-    ),
-  })
-);
-
-export enum MemoryType {
-  ACTION = "action",
-  CONVERSATION = "conversation",
-  KNOWLEDGE = "knowledge",
-}
-
-export enum MemoryScope {
-  GLOBAL = "global",
-  USER = "user",
-}
-
-export interface ActionData {
-  name?: string;
-  parameters?: Record<string, any>;
-}
-
-export interface QueueItemParameter {
-  name: string;
-  value: string;
-}
-
-export interface TransformedQueueItem {
-  name: string;
-  parameters: QueueItemParameter[];
-}
-
-export interface ScheduledAction {
-  id: string;
-  action: {
-    name: string;
-    parameters: QueueItemParameter[];
-  };
-  scheduledTime: Date;
-  userId: string;
-  status: "pending" | "completed" | "failed";
-  recurrence?: {
-    type: "daily" | "weekly" | "monthly";
-    interval: number;
-  };
-}
-
-export interface ScheduledActionEvents {
-  onActionStart?: (action: ScheduledAction) => void;
-  onActionComplete?: (action: ScheduledAction, result: any) => void;
-  onActionFailed?: (action: ScheduledAction, error: Error) => void;
-  onActionScheduled?: (action: ScheduledAction) => void;
-  onActionCancelled?: (actionId: string) => void;
-}
-
-export interface WorkflowPattern {
-  query: string;
-  actions: Array<{
-    done: boolean;
-    name: string;
-    result: string;
-  }>;
-  success: boolean;
-}