llmjs2 1.7.1 → 2.0.1

package/package.json

@@ -1,67 +1,41 @@
 {
   "name": "llmjs2",
-  "version": "1.7.1",
-  "description": "A unified Node.js library for connecting to multiple Large Language Model (LLM) providers: OpenAI, Ollama, and OpenRouter.",
-  "main": "core/index.js",
-  "bin": {
-    "llmjs2": "core/cli.js"
+  "version": "2.0.1",
+  "description": "A simple lightweight library for LLM completions and Agentic workflow",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "chat:router": "node core/examples/chat-router-sequential-app.js",
-    "chat:router:guardrail": "node core/examples/chat-router-guardrail.js",
-    "test": "node core/test.js",
-    "test:completion": "node core/test-completion.js",
-    "start": "node core/cli.js",
-    "lint": "echo 'No linting configured'",
-    "typecheck": "echo 'No type checking configured'"
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
   },
-  "keywords": [
-    "llm",
-    "ai",
-    "openai",
-    "ollama",
-    "openrouter",
-    "chatgpt",
-    "gpt",
-    "llmjs2",
-    "llmjs",
-    "language-model",
-    "unified-api"
-  ],
+  "keywords": [],
   "author": "",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": ""
+  "license": "ISC",
+  "type": "commonjs",
+  "devDependencies": {
+    "@types/node": "^25.8.0",
+    "dotenv": "^17.4.2",
+    "pino-pretty": "^13.1.3",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.6"
   },
   "dependencies": {
-    "@prompy/prompy": "^1.0.2",
-    "yaml": "^2.0.0"
-  },
-  "engines": {
-    "node": ">=14.0.0"
-  },
-  "files": [
-    "chain/index.js",
-    "chain/lib/",
-    "chain/docs/",
-    "chain/examples.js",
-    "chain/agent-step-example.js",
-    "chain/simple-agent-step-example.js",
-    "chain/workflow-example-usage.js",
-    "chain/workflow-example.json",
-    "chain/AGENT_STEP_README.md",
-    "chain/WORKFLOW_README.md",
-    "chain/README.md",
-    "core/cli.js",
-    "core/config.yaml",
-    "core/index.js",
-    "core/logger.js",
-    "core/router.js",
-    "core/server.js",
-    "core/providers/",
-    "core/docs/",
-    "core/README.md",
-    "README.md"
-  ]
+    "any-markdown": "latest",
+    "pino": "^10.3.1",
+    "promappjs": "^1.2.12"
+  }
 }

package/chain/AGENT_STEP_README.md

@@ -1,102 +0,0 @@
-# AgentStep Examples
-
-This directory contains example programs demonstrating how to use AgentStep in llmjs-chain workflows.
-
-## Files
-
-- **`simple-agent-step-example.js`** - Complete example with mock agents (fast execution)
-- **`agent-step-example.js`** - Advanced example with real AI agents (slower but comprehensive)
-
-## Running the Examples
-
-### Simple Example (Recommended for Testing)
-```bash
-node simple-agent-step-example.js
-```
-
-**Features Demonstrated:**
-- ✅ Function-based input/output mapping
-- ✅ Template-based input mapping (`{{variable}}` syntax)
-- ✅ Default mapping behavior
-- ✅ Sequential workflow execution
-- ✅ Parallel agent execution
-- ✅ Context passing between steps
-- ✅ Mock agents for fast testing
-
-### Advanced Example (Real AI)
-```bash
-node agent-step-example.js
-```
-
-**Features Demonstrated:**
-- ✅ Real AI agent integration
-- ✅ Multi-agent content creation pipeline
-- ✅ Complex input/output mapping
-- ✅ Tool usage within agents
-- ✅ Error handling
-
-## Key AgentStep Features
-
-### Input Mapping Options
-
-```javascript
-// 1. Function mapper - full control
-inputMapper: (context) => `Process: ${JSON.stringify(context.data)}`
-
-// 2. Template mapper - simple interpolation
-inputMapper: 'Analyze {{data}} from step {{stepName}}'
-
-// 3. Default mapper - automatic context conversion
-// (no inputMapper specified)
-```
-
-### Output Mapping Options
-
-```javascript
-// Custom transformation
-outputMapper: (agentResponse, context) => ({
-  result: agentResponse,
-  processedAt: new Date(),
-  confidence: 0.95
-})
-
-// Default mapping returns: { response, agent, timestamp }
-```
-
-### Workflow Integration
-
-```javascript
-const workflow = new Graph({ name: 'ai-workflow' })
-  .step(agentStep1, agentStep2, regularStep)
-  .edge(agentStep1, agentStep2)
-  .edge(agentStep2, regularStep)
-  .compile();
-
-const result = await workflow.run(initialContext);
-```
-
-## Use Cases
-
-- **Content Creation**: Multi-agent writing and editing pipelines
-- **Data Analysis**: Specialized agents for different analysis stages
-- **Quality Assurance**: AI-powered validation and testing
-- **Decision Making**: Agent-based routing and recommendations
-- **Integration Workflows**: Mix of AI and traditional processing steps
-
-## Performance Notes
-
-- **Mock Agents**: Use for development and testing (fast)
-- **Real Agents**: Production use with proper rate limiting
-- **Parallel Execution**: Multiple agents can run simultaneously
-- **Context Size**: Large contexts may impact performance
-
-## Integration with Existing Workflows
-
-AgentStep is fully compatible with:
-- Regular Step classes
-- Graph.load() JSON workflows
-- Conditional edges
-- Parallel execution
-- Memory systems
-
-Start with the simple example to understand the API, then move to real agents for production use!

package/chain/README.md

@@ -1,257 +0,0 @@
-# llmjs-chain
-
-An extension of llmjs2 that provides chaining capabilities for building complex LLM workflows with Agents, Graphs, Steps, and Flows.
-
-## Features
-
-- **Step**: Basic unit of work that can execute LLM calls or custom processing
-- **Flow**: Linear sequence of steps that execute in order
-- **Agent**: Intelligent entity that can make decisions and use tools
-- **Graph**: Complex execution graph with branching and parallelism
-- **Full llmjs2 compatibility**: All llmjs2 features are available
-
-## Installation
-
-```bash
-npm install llmjs-chain
-```
-
-This will automatically install llmjs2 as a dependency.
-
-## Quick Start
-
-```javascript
-import { Step, Flow, Agent, Graph, completion } from 'llmjs-chain';
-
-// Set API keys (same as llmjs2)
-process.env.OPENAI_API_KEY = 'your-openai-key';
-
-// Basic completion (from llmjs2)
-const response = await completion('Hello, how are you?');
-console.log(response);
-```
-
-## Terminal Chat App
-
-Experience llmjs-chain with an interactive terminal chat interface that automatically detects available API keys and models:
-
-```bash
-npm run chat
-```
-
-Features:
-- Conversational chat with memory persistence
-- Built-in tools: `get_current_time`, `calculate`
-- Commands: `/help`, `/history`, `/memory`, `/clear`, `/exit`
-- Automatic API key and model detection (no configuration needed)
-- Automatic model routing and tool execution
-
-The chat app will automatically use whichever API keys are available in your environment variables, following the same auto-detection logic as llmjs2.
-
-## Components
-
-### Step
-
-A Step is the basic unit of work in a chain. It can execute an LLM call or custom processing logic.
-
-```javascript
-import { Step } from 'llmjs-chain';
-
-const step = new Step('my-step', {
-  processor: async (context, inputs) => {
-    // Custom processing logic
-    return { result: `Processed: ${inputs.data}` };
-  }
-});
-
-const result = await step.execute({}, { data: 'Hello World' });
-```
-
-### Flow
-
-A Flow executes steps in a linear sequence.
-
-```javascript
-import { Step, Flow } from 'llmjs-chain';
-
-const step1 = new Step('step1', {
-  processor: async (context, inputs) => {
-    return { data: inputs.input.toUpperCase() };
-  }
-});
-
-const step2 = new Step('step2', {
-  processor: async (context, inputs) => {
-    return { result: `Final: ${inputs.step1.data}` };
-  }
-});
-
-const flow = new Flow('my-flow');
-flow.addStep(step1);
-flow.addStep(step2);
-
-const result = await flow.execute({ input: 'hello' });
-console.log(result); // { result: 'Final: HELLO' }
-```
-
-### Agent
-
-An Agent is an intelligent entity that can make decisions and use tools.
-
-```javascript
-import { Agent } from 'llmjs-chain';
-
-const agent = new Agent({
-  model: 'openai/gpt-4',
-  instruction: 'You are a helpful coding assistant.',
-  tools: [
-    {
-      name: 'run_code',
-      description: 'Execute JavaScript code',
-      parameters: {
-        type: 'object',
-        properties: {
-          code: { type: 'string' }
-        }
-      },
-      execute: async ({ code }) => {
-        return eval(code);
-      }
-    }
-  ]
-});
-
-// Execute task
-const result = await agent.generate('Calculate 2 + 2 and tell me the result');
-```
-
-### Memory Factory
-
-llmjs-chain provides a memory factory for creating different types of memory storage:
-
-```javascript
-import { memory } from 'llmjs-chain';
-
-// In-memory storage (default)
-const inMemory = memory.create();
-
-// LanceDB vector storage
-const lanceMemory = memory.create({ type: 'lancedb', config: { db: 'my_db', dir: './data' } });
-
-// SQLite storage with vector support
-const sqliteMemory = memory.create({ type: 'sqlite', config: { db: './memory.db' } });
-
-// Direct class instantiation (alternative)
-import { InMemory, LanceMemory, SQLiteMemory } from 'llmjs-chain';
-const directMemory = new InMemory();
-```
-
-### Memory Classes
-
-#### InMemory
-Basic in-memory storage for conversation history:
-
-```javascript
-const memory = new InMemory();
-
-// Save messages
-await memory.save('Hello!', 'user123', 'thread456', 'user', 'text');
-await memory.save('Hi there!', 'user123', 'thread456', 'assistant', 'text');
-
-// Get session history
-const history = await memory.getSessionHistory('user123', 'thread456', 10);
-
-// Search messages
-const results = await memory.search('hello', 'user123', 5);
-```
-
-### Graph
-
-A Graph allows complex execution with branching and parallelism.
-
-```javascript
-import { Step, Graph } from 'llmjs-chain';
-
-const graph = new Graph('my-graph');
-
-// Create nodes
-const start = new Step('start', {
-  processor: async (context, inputs) => ({ value: inputs.number })
-});
-
-const double = new Step('double', {
-  processor: async (context, inputs) => ({ result: inputs.start.value * 2 })
-});
-
-const square = new Step('square', {
-  processor: async (context, inputs) => ({ result: inputs.start.value ** 2 })
-});
-
-// Add nodes and edges
-graph.addNode(start);
-graph.addNode(double);
-graph.addNode(square);
-
-graph.addEdge('start', 'double');
-graph.addEdge('start', 'square');
-
-// Execute graph
-const results = await graph.execute(['start'], { number: 5 });
-console.log(results);
-// {
-//   start: { value: 5 },
-//   double: { result: 10 },
-//   square: { result: 25 }
-// }
-```
-
-## Advanced Usage
-
-### Conditional Graph Execution
-
-```javascript
-graph.addEdge('start', 'path-a', (result, context) => result.value > 10);
-graph.addEdge('start', 'path-b', (result, context) => result.value <= 10);
-```
-
-### Agent with Memory
-
-```javascript
-agent.remember({ role: 'user', content: 'Remember that I like coffee' });
-agent.remember({ role: 'assistant', content: 'Got it, you like coffee!' });
-
-// Later conversations will include this memory
-const response = await agent.execute('What do I like to drink?');
-```
-
-### Step Dependencies
-
-```javascript
-const step = new Step('dependent-step', {
-  dependencies: ['previous-step'],
-  processor: async (context, inputs) => {
-    // This step will only execute after 'previous-step' has completed
-    return { result: inputs['previous-step'].data };
-  }
-});
-```
-
-## API Keys Setup
-
-Same as llmjs2:
-
-```bash
-export OPENAI_API_KEY=your_openai_api_key
-export OLLAMA_API_KEY=your_ollama_api_key
-export OPEN_ROUTER_API_KEY=your_openrouter_api_key
-```
-
-## Testing
-
-```bash
-npm test
-```
-
-## License
-
-MIT

package/chain/WORKFLOW_README.md

@@ -1,85 +0,0 @@
-# Workflow Example
-
-This directory contains a complete example of defining and running workflows using llmjs-chain's Graph system.
-
-## Files
-
-- **`workflow-example.json`** - JSON definition of a sample workflow
-- **`workflow-example-usage.js`** - Usage example showing how to load and run the workflow
-
-## Running the Example
-
-```bash
-node workflow-example-usage.js
-```
-
-## Workflow Description
-
-The example workflow demonstrates:
-
-1. **Input Validation** - Validates that input data exists and is valid
-2. **Parallel Processing** - Two different processing paths run simultaneously
-   - Path A: Multiplies each value by 2
-   - Path B: Adds 10 to each value
-3. **Result Checking** - Sums all processed values and checks if total exceeds threshold
-4. **Conditional Branching** - Routes to success or warning handler based on result size
-
-## Workflow Structure
-
-```
-validate → [process-a, process-b] → check-result → [success-handler | warning-handler]
-```
-
-## JSON Configuration Format
-
-```json
-{
-  "name": "workflow-name",
-  "description": "Workflow description",
-  "steps": [
-    {
-      "name": "step-name",
-      "description": "Step description",
-      "execute": "async (context) => { /* step logic as string */ }"
-    }
-  ],
-  "edges": [
-    { "from": "step1", "to": "step2" },
-    { "from": "step2", "to": "step3", "condition": "(result) => result.success" }
-  ]
-}
-```
-
-## Key Features Demonstrated
-
-- ✅ **JSON Workflow Definition** - Define complete workflows in JSON
-- ✅ **Parallel Execution** - Multiple steps can run simultaneously
-- ✅ **Conditional Edges** - Branch workflow based on step results
-- ✅ **Context Passing** - Steps can access results from previous steps
-- ✅ **Error Handling** - Validation and error propagation
-- ✅ **Dynamic Loading** - Load workflows from files at runtime
-
-## Customizing the Example
-
-1. **Modify Steps**: Edit the `execute` functions in `workflow-example.json`
-2. **Change Logic**: Update conditions and processing logic
-3. **Add Steps**: Extend the workflow with additional processing steps
-4. **Create New Workflows**: Use this as a template for your own workflows
-
-## Integration with Agents
-
-This workflow system can be combined with AI agents for intelligent processing:
-
-```javascript
-// Agent step that uses AI for decision making
-{
-  "name": "analyze-data",
-  "execute": "async (context) => {
-    const agent = new Agent({ instruction: 'Analyze this data...' });
-    const result = await agent.generate(context.previousStep.data);
-    return { analysis: result };
-  }"
-}
-```
-
-The JSON-based workflow system makes it easy to define, version, and deploy complex processing pipelines with conditional logic and parallel execution.