@fw_dxs/openclaw-puter-ai 2.0.3 → 2.1.1

package/README.md

@@ -1,18 +1,194 @@
 # OpenClaw Puter AI Plugin
 
-Adds AI capabilities to OpenClaw using Puter.
+![npm](https://img.shields.io/npm/v/@fw_dxs/openclaw-puter-ai)
+![license](https://img.shields.io/npm/l/@fw_dxs/openclaw-puter-ai)
 
-Commands:
+An advanced AI assistant plugin for **OpenClaw**, powered by **Puter AI** with dynamic model routing, autonomous tools, and image generation.
 
-/ai chat
-/ai summarize
-/ai image
-/ai code
-/ai analyze
-/ai search
+This plugin adds a powerful AI agent to OpenClaw capable of chat, coding assistance, web search, and image generation.
 
-Install:
+---
 
-1. Place folder in /plugins
-2. Run npm install
-3. Restart OpenClaw
+# Features
+
+- GPT-5.3 chat support
+- GPT-5.3 Codex routing for coding tasks
+- Autonomous AI agent with tool calling
+- Web search integration
+- Code generation assistance
+- AI image generation
+- Conversation memory
+- Streaming responses
+- Automatic Puter authentication
+- Token caching (no repeated login)
+
+---
+
+# Commands
+
+## Chat
+
+```
+/ai <prompt>
+```
+
+Example:
+
+```
+/ai explain how transformers work
+```
+
+---
+
+## Memory Chat
+
+Stores conversation history for the user.
+
+```
+/ai chat <prompt>
+```
+
+Example:
+
+```
+/ai chat remember my project name is Atlas
+```
+
+---
+
+## Code Generation
+
+Automatically routes to **GPT-5.3 Codex** for coding tasks.
+
+```
+/ai code build a nodejs api
+```
+
+---
+
+## Web Search
+
+```
+/ai search latest AI models
+```
+
+---
+
+## Image Generation
+
+```
+/ai image futuristic city at sunset
+```
+
+Images are generated using Puter and saved locally.
+
+---
+
+## Autonomous Agent
+
+The agent can automatically decide which tools to use.
+
+```
+/ai research how to build a discord bot
+```
+
+The AI may automatically:
+
+- search the web
+- generate code
+- create images
+- answer directly
+
+---
+
+# Installation
+
+Install the plugin via npm:
+
+```
+npm install @fw_dxs/openclaw-puter-ai
+```
+
+Then enable it in your OpenClaw configuration.
+
+---
+
+# Requirements
+
+- Node.js 18+
+- OpenClaw
+- Puter account (for AI access)
+
+The plugin will automatically prompt for Puter authentication on first use.
+
+---
+
+# Model Routing
+
+The plugin automatically selects models depending on the task.
+
+| Task | Model |
+|------|------|
+| General chat | GPT-5.3 Chat |
+| Coding tasks | GPT-5.3 Codex |
+| Image generation | GPT Image |
+
+---
+
+# Project Structure
+
+```
+openclaw-puter-ai
+│
+├── index.js
+├── agent.js
+├── puterClient.js
+├── openclaw.plugin.json
+├── README.md
+│
+├── tools
+│   ├── webSearch.js
+│   └── codeGen.js
+│
+├── memory
+│   └── conversation.js
+│
+└── generated
+```
+
+---
+
+# Security Notes
+
+Do **not publish or share** these files:
+
+```
+.puter-token.json
+memory.json
+generated/
+```
+
+These files contain local runtime data.
+
+---
+
+# License
+
+MIT License
+
+---
+
+# Author
+
+fw_dxs
+
+---
+
+# Future Improvements
+
+Planned features include:
+
+- filesystem tools for autonomous development agents
+- code execution tools
+- multi-image generation
+- improved OpenClaw UI integration

package/agent.js

@@ -1,23 +1,194 @@
+const ai = require("./puterClient");
 const webSearch = require("./tools/webSearch");
 const codeGen = require("./tools/codeGen");
 
+function getToolSpecs() {
+  return [
+    {
+      type: "function",
+      function: {
+        name: "web_search",
+        description: "Search the internet for information.",
+        parameters: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string"
+            }
+          },
+          required: ["query"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "generate_code",
+        description: "Generate or fix code.",
+        parameters: {
+          type: "object",
+          properties: {
+            prompt: {
+              type: "string"
+            }
+          },
+          required: ["prompt"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "generate_image",
+        description: "Generate an image from a prompt.",
+        parameters: {
+          type: "object",
+          properties: {
+            prompt: {
+              type: "string"
+            }
+          },
+          required: ["prompt"]
+        }
+      }
+    }
+  ];
+}
+
+function getToolCalls(resp) {
+  return (
+    resp?.choices?.[0]?.message?.tool_calls ||
+    resp?.message?.tool_calls ||
+    resp?.tool_calls ||
+    []
+  );
+}
+
+function getAssistantMessage(resp, toolCalls) {
+  return (
+    resp?.choices?.[0]?.message ||
+    resp?.message || {
+      role: "assistant",
+      content: null,
+      tool_calls: toolCalls
+    }
+  );
+}
+
+function getText(resp) {
+  if (!resp) return "";
+
+  const content =
+    resp?.choices?.[0]?.message?.content ||
+    resp?.message?.content ||
+    resp?.text ||
+    resp;
+
+  if (typeof content === "string") return content;
+  if (content == null) return "";
+
+  return JSON.stringify(content, null, 2);
+}
+
+async function runToolCall(toolCall) {
+  const fn = toolCall?.function?.name;
+  let args = {};
+
+  try {
+    args = JSON.parse(toolCall?.function?.arguments || "{}");
+  } catch (err) {
+    console.error("[Agent] Failed parsing tool args:", err);
+    args = {};
+  }
+
+  console.log("[Agent] Tool requested:", fn, args);
+
+  if (fn === "web_search") {
+    return String(await webSearch(args.query || ""));
+  }
+
+  if (fn === "generate_code") {
+    return String(await codeGen(args.prompt || ""));
+  }
+
+  if (fn === "generate_image") {
+    return String(await ai.image(args.prompt || ""));
+  }
+
+  return "Unknown tool";
+}
+
+function isImagePrompt(prompt) {
+  const text = String(prompt || "").toLowerCase();
+  return (
+    text.includes("make an image") ||
+    text.includes("generate an image") ||
+    text.includes("create an image") ||
+    text.includes("draw ") ||
+    text.includes("illustration") ||
+    text.includes("picture of") ||
+    text.includes("image of")
+  );
+}
+
 async function runAgent(prompt) {
+  console.log("[Agent] Starting run");
+  console.log("[Agent] Prompt:", prompt);
+
+  // Hard shortcut for image requests so they do not go back into chat at all.
+  if (isImagePrompt(prompt)) {
+    console.log("[Agent] Direct image shortcut triggered");
+    return await ai.image(prompt);
+  }
+
+  const messages = [
+    {
+      role: "system",
+      content:
+        "You are an autonomous AI assistant. Use web_search for current information, generate_code for coding tasks, and generate_image for image requests. If no tool is needed, answer directly."
+    },
+    {
+      role: "user",
+      content: prompt
+    }
+  ];
+
+  const firstResponse = await ai.chatWithTools(messages, getToolSpecs());
+  const toolCalls = getToolCalls(firstResponse);
+
+  console.log("[Agent] Tool calls found:", toolCalls.length);
+
+  if (!toolCalls.length) {
+    return getText(firstResponse) || "No response.";
+  }
+
+  // If the tool call is image generation, return it directly.
+  if (
+    toolCalls.length === 1 &&
+    toolCalls[0]?.function?.name === "generate_image"
+  ) {
+    return await runToolCall(toolCalls[0]);
+  }
 
-  const systemPrompt = `
-You are an AI agent with tools:
+  const assistantMessage = getAssistantMessage(firstResponse, toolCalls);
+  const toolMessages = [];
 
-webSearch(query) → search the internet
-codeGen(prompt) → generate code
+  for (const call of toolCalls) {
+    const result = await runToolCall(call);
 
-Use them when helpful.
-`;
+    toolMessages.push({
+      role: "tool",
+      tool_call_id: call.id,
+      content: String(result)
+    });
+  }
 
-  const response = await puter.ai.chat([
-    { role: "system", content: systemPrompt },
-    { role: "user", content: prompt }
-  ]);
+  const finalResponse = await ai.chatWithTools(
+    [...messages, assistantMessage, ...toolMessages],
+    getToolSpecs()
+  );
 
-  return response;
+  return getText(finalResponse) || "No final response.";
 }
 
 module.exports = { runAgent };

package/index.js

@@ -1,61 +1,135 @@
 console.log("Puter AI plugin loaded");
+
 const ai = require("./puterClient");
 const memory = require("./memory/conversation");
 const agent = require("./agent");
 
-module.exports = {
+module.exports = function register(api) {
+  console.log("REGISTER FUNCTION CALLED");
+
+  api.registerCommand({
+    name: "ai",
+    description: "Puter AI assistant",
+    acceptsArgs: true,
+
+    handler: async (ctx) => {
+      console.log("COMMAND RECEIVED:", ctx);
+
+      try {
+        const rawArgs =
+          Array.isArray(ctx.args) ? ctx.args.join(" ") : String(ctx.args || "");
+
+        const trimmed = rawArgs.trim();
+        const [sub, ...rest] = trimmed.split(/\s+/);
+        const prompt = rest.join(" ");
+        const user = ctx.senderId || ctx.userId || "default";
 
-  name: "puter-ai",
+        // plain /ai hello -> autonomous agent mode
+        if (!trimmed) {
+          return {
+            text:
+              "Usage: /ai <prompt> | /ai chat <prompt> | /ai summarize <text> | /ai image <prompt> | /ai agent <prompt> | /ai code <prompt> | /ai search <prompt> | /ai analyze <text>"
+          };
+        }
 
-  async handleCommand(command, args, user, stream) {
+        // default agent mode when user does /ai something
+        const knownSubs = new Set([
+          "chat",
+          "summarize",
+          "image",
+          "agent",
+          "code",
+          "search",
+          "analyze"
+        ]);
+
+        if (!knownSubs.has(sub)) {
+          console.log("[Index] Defaulting to autonomous agent mode");
+          const response = await agent.runAgent(trimmed);
+          return { text: response };
+        }
 
-    const prompt = args.join(" ");
+        if (sub === "chat") {
+          const history = memory.getHistory(user);
+          let result = "";
 
-    if (command === "/ai chat") {
+          const response = await ai.chat(
+            [...history, { role: "user", content: prompt }],
+            (token) => {
+              result += token;
+            }
+          );
 
-      const history = memory.getHistory(user);
+          if (!result && typeof response === "string") {
+            result = response;
+          }
 
-      let result = "";
+          memory.addMessage(user, "user", prompt);
+          memory.addMessage(user, "assistant", result);
 
-      await ai.chat(
-        [...history, { role: "user", content: prompt }],
-        token => {
-          result += token;
-          if (stream) stream(token);
+          return { text: result || "No response from Puter." };
         }
-      );
 
-      memory.addMessage(user, "user", prompt);
-      memory.addMessage(user, "assistant", result);
+        if (sub === "summarize") {
+          const response = await ai.chat([
+            {
+              role: "system",
+              content: "Summarize the following text clearly and concisely."
+            },
+            {
+              role: "user",
+              content: prompt
+            }
+          ]);
+
+          return { text: response };
+        }
 
-      return result;
-    }
+        if (sub === "image") {
+          console.log("[Index] Image branch hit:", prompt);
 
-    if (command === "/ai summarize") {
+          const response = await ai.image(prompt);
 
-      const response = await ai.chat([
-        { role: "system", content: "Summarize the following text." },
-        { role: "user", content: prompt }
-      ]);
+          console.log("[Index] Image branch response type:", typeof response);
+          console.log("[Index] Image branch response preview:", String(response).slice(0, 120));
 
-      return response;
-    }
+          return {
+            text: typeof response === "string" ? response : JSON.stringify(response, null, 2)
+          };
+        }
 
-    if (command === "/ai image") {
-      return await ai.image(prompt);
-    }
+        if (sub === "agent") {
+          const response = await agent.runAgent(prompt);
+          return { text: response };
+        }
 
-    if (command === "/ai code") {
-      return await agent.runAgent("Write code for: " + prompt);
-    }
+        if (sub === "code") {
+          const response = await agent.runAgent(`Write code for: ${prompt}`);
+          return { text: response };
+        }
 
-    if (command === "/ai search") {
-      return await agent.runAgent(prompt);
-    }
+        if (sub === "search") {
+          const response = await agent.runAgent(`Search for: ${prompt}`);
+          return { text: response };
+        }
 
-    if (command === "/ai analyze") {
-      return await agent.runAgent("Analyze the following content:\n" + prompt);
-    }
+        if (sub === "analyze") {
+          const response = await agent.runAgent(
+            `Analyze the following content:\n${prompt}`
+          );
+          return { text: response };
+        }
 
-  }
+        return {
+          text:
+            "Usage: /ai <prompt> | /ai chat <prompt> | /ai summarize <text> | /ai image <prompt> | /ai agent <prompt> | /ai code <prompt> | /ai search <prompt> | /ai analyze <text>"
+        };
+      } catch (err) {
+        console.error("PLUGIN ERROR:", err);
+        return {
+          text: `Plugin error: ${err.message || String(err)}`
+        };
+      }
+    }
+  });
 };

package/memory/conversation.js

@@ -1,35 +1,40 @@
 const fs = require("fs");
+const path = require("path");
 
-const FILE = "./plugins/openclaw-puter-ai/memory.json";
+const FILE = path.join(__dirname, "..", "memory.json");
 
-function load() {
+function ensureFile() {
+  const dir = path.dirname(FILE);
+
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
 
   if (!fs.existsSync(FILE)) {
-    fs.writeFileSync(FILE, JSON.stringify({}));
+    fs.writeFileSync(FILE, JSON.stringify({}, null, 2), "utf8");
   }
+}
 
-  return JSON.parse(fs.readFileSync(FILE));
+function load() {
+  ensureFile();
+  return JSON.parse(fs.readFileSync(FILE, "utf8"));
 }
 
 function save(data) {
-  fs.writeFileSync(FILE, JSON.stringify(data, null, 2));
+  ensureFile();
+  fs.writeFileSync(FILE, JSON.stringify(data, null, 2), "utf8");
 }
 
 function getHistory(user) {
-
   const data = load();
-
   if (!data[user]) data[user] = [];
-
   return data[user];
 }
 
 function addMessage(user, role, content) {
-
   const data = load();
 
   if (!data[user]) data[user] = [];
-
   data[user].push({ role, content });
 
   if (data[user].length > 20) {

package/openclaw.plugin.json

@@ -1,17 +1,12 @@
 {
   "id": "openclaw-puter-ai",
-  "name": "OpenClaw Puter AI",
-  "version": "2.0.3",
-  "description": "Advanced AI plugin for OpenClaw using Puter",
+  "name": "Puter AI Assistant",
+  "version": "2.1.0",
+  "description": "Advanced AI assistant for OpenClaw powered by Puter with GPT-5.3 routing and autonomous tools.",
   "main": "./index.js",
-  "commands": [
-    "/ai chat",
-    "/ai summarize",
-    "/ai image",
-    "/ai code",
-    "/ai analyze",
-    "/ai search"
-  ],
-  "author": "fw_dxs",
-  "configSchema": {}
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
 }

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@fw_dxs/openclaw-puter-ai",
-  "version": "2.0.3",
+  "version": "2.1.1",
   "description": "Advanced AI plugin for OpenClaw using Puter",
   "main": "index.js",
   "type": "commonjs",
   "dependencies": {
-    "eventemitter3": "^5.0.1",
-    "node-fetch": "^3.3.2"
+    "@heyputer/puter.js": "^2.2.11",
+    "eventemitter3": "^5.0.1"
   },
   "openclaw": {
-    "extensions": ["./index.js"]
+    "extensions": [
+      "./index.js"
+    ]
   }
-}
+}

package/plugin.json

@@ -1,13 +1,27 @@
 {
-  "name": "puter-ai",
-  "version": "2.0.0",
-  "description": "Adds AI commands powered by Puter",
+  "id": "openclaw-puter-ai",
+  "name": "Puter AI Assistant",
+  "version": "2.1.0",
+  "description": "Advanced AI assistant for OpenClaw powered by Puter with GPT-5.3 dynamic routing and autonomous tools.",
+  "author": "fw_dxs",
+  "main": "./index.js",
   "commands": [
-    "/ai chat",
-    "/ai summarize",
-    "/ai image",
-    "/ai code",
-    "/ai analyze",
-    "/ai search"
+    {
+      "name": "ai",
+      "description": "AI assistant powered by Puter",
+      "usage": "/ai <prompt>"
+    }
+  ],
+  "features": [
+    "dynamic-model-routing",
+    "gpt-5.3-codex",
+    "autonomous-agent",
+    "tool-calling",
+    "conversation-memory",
+    "streaming-responses"
+  ],
+  "permissions": [
+    "network",
+    "filesystem"
   ]
 }

package/puterClient.js

@@ -1,20 +1,259 @@
+console.log("puterClient.js loaded");
+
+const fs = require("fs");
+const path = require("path");
+const { init, getAuthToken } = require("@heyputer/puter.js/src/init.cjs");
+
+let puterInstance = null;
+
+const MODELS = {
+  chat: "gpt-5.3-chat",
+  code: "openai/gpt-5.3-codex",
+  image: "openai/gpt-image-1"
+};
+
+const TOKEN_FILE = path.join(__dirname, ".puter-token.json");
+const OUTPUT_DIR = path.join(__dirname, "generated");
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function loadSavedToken() {
+  try {
+    if (!fs.existsSync(TOKEN_FILE)) return null;
+    const raw = fs.readFileSync(TOKEN_FILE, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed?.token || null;
+  } catch (err) {
+    console.error("[Puter] Failed loading token:", err);
+    return null;
+  }
+}
+
+function saveToken(token) {
+  try {
+    fs.writeFileSync(TOKEN_FILE, JSON.stringify({ token }, null, 2), "utf8");
+    console.log("[Puter] Token saved");
+  } catch (err) {
+    console.error("[Puter] Failed saving token:", err);
+  }
+}
+
+async function getPuter() {
+  if (puterInstance) return puterInstance;
+
+  let token = process.env.puterAuthToken || loadSavedToken();
+
+  if (!token) {
+    console.log("[Puter] Starting auth flow");
+    token = await getAuthToken();
+    if (!token) {
+      throw new Error("Failed to get Puter auth token.");
+    }
+    saveToken(token);
+  }
+
+  puterInstance = init(token);
+  console.log("[Puter] Initialized");
+
+  return puterInstance;
+}
+
+function pickChatModel(messages) {
+  const combined = Array.isArray(messages)
+    ? messages.map((m) => m?.content || "").join(" ")
+    : String(messages || "");
+
+  const text = combined.toLowerCase();
+
+  const codeSignals = [
+    "code",
+    "debug",
+    "bug",
+    "function",
+    "class",
+    "javascript",
+    "typescript",
+    "python",
+    "api",
+    "error",
+    "stack trace",
+    "plugin",
+    "openclaw"
+  ];
+
+  const shouldUseCodex = codeSignals.some((s) => text.includes(s));
+  const model = shouldUseCodex ? MODELS.code : MODELS.chat;
+
+  console.log("[Model Router] Selected:", model);
+  return model;
+}
+
+function extractText(resp) {
+  if (!resp) return "";
+
+  if (typeof resp === "string") return resp;
+  if (typeof resp?.text === "string") return resp.text;
+  if (typeof resp?.message?.content === "string") return resp.message.content;
+  if (typeof resp?.choices?.[0]?.message?.content === "string") {
+    return resp.choices[0].message.content;
+  }
+
+  return JSON.stringify(resp, null, 2);
+}
+
 async function chat(messages, streamCallback) {
+  const puter = await getPuter();
+  const model = pickChatModel(messages);
+  let fullText = "";
+
+  console.log("[Puter Chat] Starting with model:", model);
 
   const response = await puter.ai.chat(messages, {
-    stream: true,
-    onToken: token => {
-      if (streamCallback) streamCallback(token);
-    }
+    model,
+    stream: true
+  });
+
+  for await (const token of response) {
+    const chunk =
+      typeof token === "string"
+        ? token
+        : token?.text || token?.content || token?.delta || "";
+
+    fullText += chunk;
+    if (streamCallback) streamCallback(chunk);
+  }
+
+  return fullText || "No response from Puter.";
+}
+
+async function chatWithTools(messages, tools) {
+  const puter = await getPuter();
+  const model = pickChatModel(messages);
+
+  console.log("[Puter Tools] Starting with model:", model);
+
+  const response = await puter.ai.chat(messages, {
+    model,
+    tools,
+    stream: false
   });
 
   return response;
 }
 
+function saveDataUrlToFile(src) {
+  if (typeof src !== "string" || !src.startsWith("data:image")) {
+    return null;
+  }
+
+  ensureDir(OUTPUT_DIR);
+
+  const match = src.match(/^data:(image\/[a-zA-Z0-9.+-]+);base64,(.+)$/);
+  if (!match) {
+    throw new Error("Unsupported image data format.");
+  }
+
+  const mimeType = match[1];
+  const base64 = match[2];
+
+  let ext = "png";
+  if (mimeType.includes("webp")) ext = "webp";
+  else if (mimeType.includes("jpeg")) ext = "jpg";
+  else if (mimeType.includes("jpg")) ext = "jpg";
+  else if (mimeType.includes("png")) ext = "png";
+
+  const buffer = Buffer.from(base64, "base64");
+  const filename = `ai-image-${Date.now()}.${ext}`;
+  const filepath = path.join(OUTPUT_DIR, filename);
+
+  fs.writeFileSync(filepath, buffer);
+  return filepath;
+}
+
 async function image(prompt) {
-  return await puter.ai.image(prompt);
+  const puter = await getPuter();
+
+  console.log("[Puter Image] Prompt:", prompt);
+
+  const response = await puter.ai.txt2img(prompt, {
+    model: MODELS.image
+  });
+
+  console.log("[Puter Image] Raw response keys:", Object.keys(response || {}));
+
+  let src = null;
+
+  if (typeof response === "string") {
+    src = response;
+  } else if (response?.src) {
+    src = response.src;
+  } else if (response?.url) {
+    src = response.url;
+  } else if (response?.image?.src) {
+    src = response.image.src;
+  } else if (response?.image?.url) {
+    src = response.image.url;
+  } else if (response?.data?.src) {
+    src = response.data.src;
+  } else if (response?.data?.url) {
+    src = response.data.url;
+  } else if (Array.isArray(response) && response[0]?.src) {
+    src = response[0].src;
+  } else if (Array.isArray(response) && response[0]?.url) {
+    src = response[0].url;
+  }
+
+  if (!src) {
+    console.log("[Puter Image] Full response:", response);
+    throw new Error("Image response did not contain a usable src/url field.");
+  }
+
+  console.log("[Puter Image] src preview:", src.slice(0, 80));
+
+  // normal URL
+  if (!src.startsWith("data:")) {
+    return `Image generated:\n${src}`;
+  }
+
+  ensureDir(OUTPUT_DIR);
+
+  // accept data:image/... OR data:undefined;base64,...
+  const match = src.match(/^data:([^;,]*)?;base64,(.+)$/);
+
+  if (!match) {
+    throw new Error("Unsupported data URL format.");
+  }
+
+  const mimeType = match[1] || "";
+  const base64 = match[2];
+
+  let ext = "png";
+  if (mimeType.includes("webp")) ext = "webp";
+  else if (mimeType.includes("jpeg")) ext = "jpg";
+  else if (mimeType.includes("jpg")) ext = "jpg";
+  else if (mimeType.includes("png")) ext = "png";
+  else if (mimeType.includes("gif")) ext = "gif";
+
+  const filename = `ai-image-${Date.now()}.${ext}`;
+  const filepath = path.join(OUTPUT_DIR, filename);
+
+  fs.writeFileSync(filepath, Buffer.from(base64, "base64"));
+
+  console.log("[Puter Image] Saved file:", filepath);
+
+  return `Image generated:\n${filepath}`;
 }
 
 module.exports = {
   chat,
-  image
+  chatWithTools,
+  image,
+  getPuter,
+  pickChatModel,
+  extractText,
+  MODELS
 };

package/tools/codeGen.js

@@ -1,6 +1,7 @@
-async function codeGen(prompt) {
+const ai = require("../puterClient");
 
-  const response = await puter.ai.chat([
+async function codeGen(prompt) {
+  return await ai.chat([
     {
       role: "system",
       content: "You generate clean, working code."
@@ -10,8 +11,6 @@ async function codeGen(prompt) {
       content: prompt
     }
   ]);
-
-  return response;
 }
 
 module.exports = codeGen;

package/tools/webSearch.js

@@ -1,7 +1,4 @@
-const fetch = require("node-fetch");
-
 async function webSearch(query) {
-
   const url = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json`;
 
   const res = await fetch(url);