@pool4t9/server 1.0.0 → 1.0.1

package/README.md

@@ -1,7 +1,7 @@
-# @your-username/ai-chatbot-server
+# pool4t9ai-chatbot-server
 
 AI chatbot server package for building intelligent chat interfaces.
 
 ## Installation
 
-npm install @your-username/ai-chatbot-server
+npm install pool4t9ai-chatbot-server

package/dist/initAI.d.ts

@@ -1,6 +1,6 @@
 export declare function initAI(config: any): {
-    registerQuery(name: string, fn: Function): void;
-    query(message: string, ctx?: {}): Promise<{
+    registerQuery(name: string, fn: Function, schema: any): void;
+    query(message: string, ctx?: any): Promise<{
         message: any;
     }>;
 };

package/dist/initAI.js

@@ -4,26 +4,54 @@ exports.initAI = initAI;
 const llm_1 = require("./llm");
 const prompt_1 = require("./prompt");
 const executor_1 = require("./executor");
+const messages_1 = require("@langchain/core/messages");
+const toolBuilder_1 = require("./toolBuilder");
 function initAI(config) {
-    const llm = (0, llm_1.createLLM)(config.llm);
+    const baseLLM = (0, llm_1.createLLM)(config.llm);
     const queries = {};
+    const tools = [];
+    let llm = baseLLM.bindTools(tools);
+    const memory = config.memoryAdapter;
     return {
-        registerQuery(name, fn) {
+        registerQuery(name, fn, schema) {
+            if (queries[name]) {
+                throw new Error(`Query "${name}" already registered`);
+            }
             queries[name] = fn;
+            tools.push((0, toolBuilder_1.createToolBuilder)(name, fn, schema)); // 👈 build ONCE
+            llm = baseLLM.bindTools(tools);
         },
         async query(message, ctx = {}) {
-            const prompt = (0, prompt_1.buildPrompt)(config.schema);
-            const ai = await llm.chat({
-                system: prompt,
-                user: message,
-                tools: Object.keys(queries)
-            });
-            if (ai === "NOT_SUPPORTED") {
-                return { message: "Sorry, I can't help with that." };
+            const conversationId = ctx.conversationId ?? "default";
+            const history = await memory.load(conversationId);
+            const systemPrompt = (0, prompt_1.buildPrompt)(config.schema);
+            const ai = await llm.invoke([
+                new messages_1.SystemMessage(systemPrompt),
+                ...history,
+                new messages_1.HumanMessage(message),
+            ]);
+            // save user message
+            await memory.save(conversationId, [
+                ...history,
+                new messages_1.HumanMessage(message)
+            ]);
+            // 1️⃣ Tool call path
+            if (ai.tool_calls?.length) {
+                const toolCall = ai.tool_calls[0];
+                const result = await (0, executor_1.executeQuery)(toolCall.name, toolCall.args, queries, config.db, ctx);
+                await memory.save(conversationId, [
+                    ...history,
+                    new messages_1.AIMessage(ai.content)
+                ]);
+                return {
+                    message: result
+                };
             }
-            const result = await (0, executor_1.executeQuery)(ai.name, ai.args, queries, config.db, ctx);
+            // 2️⃣ Normal text response
             return {
-                message: ai.toText(result)
+                message: typeof ai.content === "string"
+                    ? ai.content
+                    : ai.content[0]?.text
             };
         }
     };

package/dist/llm.d.ts

@@ -1,3 +1,3 @@
-export declare function createLLM(config: any): {
-    chat(payload: any): Promise<any>;
-};
+import { ChatOpenAI } from "@langchain/openai";
+import { AIConfig } from "./type";
+export declare function createLLM(config: AIConfig): ChatOpenAI<import("@langchain/openai").ChatOpenAICallOptions>;

package/dist/llm.js

@@ -1,21 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLLM = createLLM;
+const openai_1 = require("@langchain/openai");
 function createLLM(config) {
-    if (config.provider === "openai") {
-        return {
-            async chat(payload) {
-                // call OpenAI here (pseudo)
-                return payload.__mockResponse;
-            }
-        };
-    }
-    if (config.provider === "gemini") {
-        return {
-            async chat(payload) {
-                return payload.__mockResponse;
-            }
-        };
+    if (config.llm.provider === "openai") {
+        const openai = new openai_1.ChatOpenAI({
+            apiKey: config.llm.apiKey,
+            model: config.llm.model || "gpt-4o-mini",
+        });
+        return openai;
     }
     throw new Error("Unsupported LLM provider");
 }

package/dist/memory/dbMemoryAdapter.d.ts

@@ -0,0 +1,2 @@
+import { MemoryAdapter } from "./types";
+export declare function createDbMemoryAdapter(db: any): MemoryAdapter;

package/dist/memory/dbMemoryAdapter.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDbMemoryAdapter = createDbMemoryAdapter;
+const messages_1 = require("@langchain/core/messages");
+function createDbMemoryAdapter(db) {
+    return {
+        async load(conversationId) {
+            const rows = await db.chat_messages.findMany({
+                where: { conversation_id: conversationId },
+                orderBy: { created_at: "asc" }
+            });
+            return rows.map((row) => {
+                if (row.role === "human")
+                    return new messages_1.HumanMessage(row.content);
+                if (row.role === "ai")
+                    return new messages_1.AIMessage(row.content);
+                return new messages_1.SystemMessage(row.content);
+            });
+        },
+        async save(conversationId, messages) {
+            const last = messages[messages.length - 1];
+            await db.chat_messages.create({
+                data: {
+                    conversation_id: conversationId,
+                    role: last._getType(),
+                    content: last.content
+                }
+            });
+        }
+    };
+}

package/dist/memory/types.d.ts

@@ -0,0 +1,5 @@
+import { BaseMessage } from "@langchain/core/messages";
+export interface MemoryAdapter {
+    load(conversationId: string): Promise<BaseMessage[]>;
+    save(conversationId: string, messages: BaseMessage[]): Promise<void>;
+}

package/dist/memory/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/toolBuilder.d.ts

@@ -0,0 +1,3 @@
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { ZodSchema } from "zod";
+export declare function createToolBuilder(name: string, handler: Function, schema: ZodSchema): DynamicStructuredTool<ZodSchema<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>, unknown, unknown, any, string>;

package/dist/toolBuilder.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createToolBuilder = createToolBuilder;
+const tools_1 = require("@langchain/core/tools");
+function createToolBuilder(name, handler, schema) {
+    return new tools_1.DynamicStructuredTool({
+        name,
+        description: `Execute ${name}`,
+        schema: schema, // tighten later
+        func: async (args) => handler(args),
+    });
+}

package/dist/type.d.ts

@@ -1,4 +1,39 @@
-export type LLMProvider = "openai" | "gemini";
+import { z } from "zod";
+import { MemoryAdapter } from "./memory/types";
+/**
+ * LLM config
+ */
+export declare const llmConfigSchema: z.ZodObject<{
+    provider: z.ZodEnum<{
+        openai: "openai";
+        gemini: "gemini";
+        anthropic: "anthropic";
+    }>;
+    apiKey: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Memory adapter (user provided)
+ */
+export declare const memoryAdapterSchema: z.ZodCustom<MemoryAdapter, MemoryAdapter>;
+/**
+ * Main AI config
+ */
+export declare const aiConfigSchema: z.ZodObject<{
+    llm: z.ZodObject<{
+        provider: z.ZodEnum<{
+            openai: "openai";
+            gemini: "gemini";
+            anthropic: "anthropic";
+        }>;
+        apiKey: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    db: z.ZodAny;
+    schema: z.ZodAny;
+    memoryAdapter: z.ZodCustom<MemoryAdapter, MemoryAdapter>;
+}, z.core.$strip>;
+export type LLMProvider = "openai" | "gemini" | "anthropic";
 export type AIConfig = {
     llm: {
         provider: LLMProvider;
@@ -6,8 +41,15 @@ export type AIConfig = {
         model?: string;
     };
     db: {
-        type: "postgres" | "mysql";
+        type: "postgres" | "mysql" | "mongodb";
         url: string;
+        database?: string;
+        username?: string;
+        password?: string;
+        port?: number;
+        host?: string;
+        ssl?: boolean;
+        schema?: string;
     };
     schema: Record<string, {
         description?: string;

package/dist/type.js

@@ -1,2 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.aiConfigSchema = exports.memoryAdapterSchema = exports.llmConfigSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * LLM config
+ */
+exports.llmConfigSchema = zod_1.z.object({
+    provider: zod_1.z.enum(["openai", "gemini", "anthropic"]),
+    apiKey: zod_1.z.string().min(1, "API key is required"),
+    model: zod_1.z.string().optional(),
+});
+/**
+ * Memory adapter (user provided)
+ */
+exports.memoryAdapterSchema = zod_1.z.custom((val) => typeof val === "object" &&
+    typeof val.load === "function" &&
+    typeof val.save === "function", {
+    message: "memoryAdapter must implement load(conversationId) and save(conversationId, messages)",
+});
+/**
+ * Main AI config
+ */
+exports.aiConfigSchema = zod_1.z.object({
+    llm: exports.llmConfigSchema,
+    db: zod_1.z.any(), // intentionally open
+    schema: zod_1.z.any(), // db schema / tables user wants AI to know
+    memoryAdapter: exports.memoryAdapterSchema,
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pool4t9/server",
-    "version": "1.0.0",
+    "version": "1.0.1",
     "description": "AI chatbot server package for building intelligent chat interfaces",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -34,5 +34,11 @@
     },
     "devDependencies": {
         "typescript": "^5.9.3"
+    },
+    "dependencies": {
+        "@langchain/core": "^1.1.17",
+        "@langchain/openai": "^1.2.3",
+        "langchain": "^1.2.13",
+        "zod": "^4.3.6"
     }
 }