A TypeScript toolkit for integrating Large Language Models with tool execution capabilities.

A toolkit for integrating LLM applications with tool execution capabilities. Provides functionality for handling tool calls, managing chat sessions, and executing operations.

• 🎯 Clean API: Simple interface with minimal setup required
• 📐 Type Safety: Full TypeScript support with type definitions
• 📱 Session Management: Session handling with abort controls and permission inheritance
• 🧠 Context: System prompts with environment-aware ContextSys integration
• 🔧 Tool Execution: Tool registration with error handling and validation
• 🔒 Permission System: Approval controls for tool execution with approve, deny, and allow_all options
• 🛡️ Security: Security measures with tool usage restrictions and validation
• 🌊 Streaming Support: API for both streaming and standard responses
• ⚡ Event-Driven: Real-time callbacks for thinking, messages, tool calls, and results

sequenceDiagram participant User participant Orchestrator participant ContextSys participant ChatManager participant ToolExecutor participant LLM participant Tools User->>Orchestrator: Send chat request Orchestrator->>ContextSys: Get system prompt ContextSys-->>Orchestrator: Return context Orchestrator->>ChatManager: Add user message + system context Orchestrator->>LLM: Send request with tools LLM-->>Orchestrator: Response with tool calls loop For each tool call Orchestrator->>User: Request permission User-->>Orchestrator: Approve/Deny/Allow All alt Permission Granted Orchestrator->>ToolExecutor: Execute tool ToolExecutor->>Tools: Run tool logic Tools-->>ToolExecutor: Return result ToolExecutor-->>Orchestrator: Tool result Orchestrator->>ChatManager: Add tool result to session else Permission Denied Orchestrator->>User: Abort session end end Orchestrator->>LLM: Send updated context LLM-->>Orchestrator: Final response Orchestrator->>ChatManager: Add final message Orchestrator-->>User: Return session with abort capability 

• Core: Tool execution logic and validation
• Integrator: Chat orchestration, session management, and permission handling
• Interfaces: TypeScript type definitions for all components
• Schemas: Tool schema definitions for LLM integration
• Utils: Utility functions for ID generation and common operations

1. 👤 Create Ollama Account

   • Sign up at ollama.com
   • Create an API key by visiting ollama.com/settings/keys

2. 📦 Clone Repository

   git clone https://github.com/NeaByteLab/LLM-Toolkit.git cd LLM-Toolkit

3. ⚙️ Environment Setup

   # Create environment file echo "OLLAMA_KEY=your_api_key_here" > .env # Edit .env and replace with your actual API key # OLLAMA_KEY=your_actual_api_key_here

4. 📦 Install Dependencies

   npm install

npx tsx ./src/index.ts

This demonstrates the complete toolkit with:

• Permission system (denies TerminalCmd, approves FileCreate/FileEdit)
• Streaming responses
• Auto-abort after 3 seconds
• All event callbacks

src/ ├── schemas/ # Tool schema definitions ├── core/ │ ├── base/ # Tool implementation logic │ └── ToolExecutor.ts # Tool registration & execution 

1. Create Schema (/src/schemas/YourTool.ts)

   export default { type: 'function', function: { name: 'your_tool_name', description: 'What your tool does', parameters: { type: 'object', properties: { param1: { type: 'string', description: 'Description' } }, required: ['param1'] } } }

2. Implement Logic (/src/core/base/YourTool.ts)

   export default class YourTool { private readonly param1: string constructor(args: SchemaYourTool) { const { param1 } = args this.param1 = param1 } async execute(): Promise<string> { const resValidate = this.validate() if (resValidate !== 'ok') { return resValidate } // Your logic here return 'Success message' } private validate(): string { if (typeof this.param1 !== 'string') { return '`param1` must be a string.' } return 'ok' } }

3. Register in ToolExecutor.ts

   // Add import import YourTool from '@core/base/YourTool' import type { SchemaYourTool } from '@root/interfaces/index' // Add to switch statement case 'your_tool_name': return new YourTool(args as SchemaYourTool).execute()

To edit the AI's behavior and personality:

• 🔧 Modify getSystemPrompt() method
• ➕➖ Add/remove capabilities, guidelines, or instructions
• 🎭 Customize the AI agent's behavior and personality
• 🔒 Update security guidelines or tool usage rules

To edit the environment context:

• 🔧 Modify getContext() to change format or add/remove information
• ➕ Add new methods to gather additional system information
• ⏰ Customize time format in getTimeInfo()
• 💻 Add more OS details in getOSInfo()
• 📁 Include additional path information in getPathInfo()

The toolkit includes a permission system for controlling tool execution:

• approve: Allow this specific tool call
• deny: Block this tool call and abort session
• allow_all: Approve this call and all future calls in this session

const session = await orchestrator.chat(message, { onAskPermission: (data) => { console.log(`Permission requested for: ${data.toolName}`) // Custom permission logic if (data.toolName === 'TerminalCmd') { return { action: 'deny' } // Block terminal commands } return { action: 'approve' } // Allow everything else }, // ... other options })

// Abort specific session session.abort() // Check if session is active const isActive = session.isActive() // Abort all sessions orchestrator.abort()

1. Auto-creation: Sessions are created when you call chat()
2. Context injection: System prompt is added on first message
3. Permission tracking: Session remembers "allow all" settings
4. Termination: Abort stops all operations

• Embedding README: Text vectorization and similarity search using transformer models
• Provides semantic search, text similarity, and content clustering capabilities
• Independent module for advanced text processing features

This project is licensed under the MIT license. See the LICENSE file for more info.