tarsk 0.2.4 → 0.2.6

package/dist/agent/agent.js

@@ -1,4 +1,4 @@
-import { logWrite, logEnd, logError, logStart } from "../log/log.js";
+import { logWrite, logEnd, logError, logStart, logStep } from "../log/log.js";
 export async function completion(request, options) {
     const tools = request.tools.map(tool => JSON.parse(JSON.stringify(tool.definition)) ?? []);
     const req = {
@@ -14,8 +14,16 @@ export async function completion(request, options) {
         repeating = false;
         count++;
         logStart({ type: `completion_request_${count}`, args: request });
-        response = await call(options, req);
-        logEnd(`completion_request_${count}`);
+        try {
+            response = await call(options, req);
+        }
+        catch (error) {
+            logWrite({ type: 'completion_error', args: { error } });
+            throw new Error(`Error calling completion: ${error}`);
+        }
+        finally {
+            logEnd(`completion_request_${count}`);
+        }
         if (response.error) {
             const message = JSON.stringify(response.error.metadata);
             logError({ type: 'completion_error', message, args: { ...response.error } });
@@ -73,6 +81,7 @@ export async function callTools(toolCalls, request) {
         logStart({ type: `tool_call_${toolName}`, args: { toolName, toolArgs } });
         logWrite({ type: 'tool_call', args: { functionMap, toolArgs } });
         try {
+            logStep(`Calling tool ${toolName} with args ${JSON.stringify(toolArgs)}`);
             const toolResponse = await functionMap[toolName](...Object.values(toolArgs));
             newMessages.push({
                 role: 'tool',
@@ -100,7 +109,8 @@ export async function callFunction(_function, args) {
     }
     catch (error) {
         var err = new Error();
-        logWrite({ type: 'test_call_error', args: { functionName: _function.name, error: `${error}` },
+        logWrite({
+            type: 'test_call_error', args: { functionName: _function.name, error: `${error}` },
         });
         return { error: `Error calling ${_function.name}: ${error}` };
     }

package/dist/api/models.js

@@ -1,5 +1,12 @@
+import { getSettings } from "./settings.js";
 export async function api_get_models(c) {
-    const res = await fetch("https://openrouter.ai/api/v1/models");
+    const setttings = await getSettings();
+    const res = await fetch("https://api.tarsk.io/api/v1/models", {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${setttings.tarskApiKey}`
+        }
+    });
     const data = await res.json();
     const models = [];
     for (const model of data.data) {

package/dist/api/prompt.js

@@ -1,5 +1,5 @@
 import { prompt } from "../prompt.js";
-import { logWrite } from "../log/log.js";
+import { logAi, logUser, logWrite } from "../log/log.js";
 export async function api_prompt(c) {
     const body = await c.req.json();
     logWrite({ type: 'prompt', args: body });
@@ -7,6 +7,8 @@ export async function api_prompt(c) {
     if (!question) {
         return c.json({ error: 'Prompt is required' }, 400);
     }
+    logUser(question);
     const answer = await prompt(question);
+    logAi('Returned answer to user');
     return c.json({ answer });
 }

package/dist/api/settings.js

@@ -1,40 +1,43 @@
 import {} from "../interfaces/settings.js";
 import { getJSON, setJSON } from "../utils/json-file.js";
 import { httpValidationErrror as httpValidationError, isEmpty } from "./utils.js";
-const defaultOpenRouterURL = "https://openrouter.ai/api/v1";
+const defaultTarskURL = "https://api.tarsk.io/api/v1";
 export const defaultModel = "meta-llama/llama-3.3-70b-instruct";
 export async function api_get_settings(c) {
     return c.json(getSettings());
 }
 export async function api_save_settings(c) {
     const settings = await c.req.json();
-    if (settings.openRouterApiKey == undefined) {
-        httpValidationError("openRouterApiKey is required");
+    if (isEmpty(settings.tarskApiKey)) {
+        httpValidationError("tarskApiKey is required");
     }
-    if (isEmpty(settings.openRouterURL)) {
-        settings.openRouterURL = defaultOpenRouterURL;
+    if (isEmpty(settings.apiURL)) {
+        settings.apiURL = defaultTarskURL;
     }
     if (isEmpty(settings.defaultModel) || settings.defaultModel == 'Select a Model') {
         settings.defaultModel = defaultModel;
     }
-    if (settings.openRouterURL == undefined) {
-        httpValidationError("openRouterURL is required");
+    if (settings.apiURL == undefined) {
+        httpValidationError("apiURL is required");
     }
-    if (!settings.openRouterURL.startsWith("https://")) {
-        httpValidationError("openRouterURL must start with https://");
+    if (!settings.apiURL.startsWith("https://")) {
+        httpValidationError("apiURL must start with https://");
     }
-    if (settings.openRouterURL.endsWith("/")) {
-        settings.openRouterURL = settings.openRouterURL.slice(0, -1);
+    if (settings.apiURL.endsWith("/")) {
+        settings.apiURL = settings.apiURL.slice(0, -1);
     }
     setJSON('settings', settings);
     return c.json(getSettings());
 }
 export function getSettings() {
     const defaultSettings = {
-        openRouterApiKey: "",
-        openRouterURL: defaultOpenRouterURL,
+        tarskApiKey: "",
+        apiURL: defaultTarskURL,
         defaultModel: defaultModel
     };
     const settings = getJSON("settings", defaultSettings);
+    if (isEmpty(settings.tarskApiKey)) {
+        settings.tarskApiKey = 'aedf201d-bf05-4fa0-912c-15a924f32c65';
+    }
     return settings;
 }

package/dist/api/tools.js

@@ -17,8 +17,8 @@ export async function api_run_tool(c) {
     try {
         const toolToRun = await getTool(tool.name);
         const tools = await loadTools(toolJavascriptFilenames(true));
-        const d = tools.find((t) => t.name == toolToRun.name + '.test');
-        const functionName = 'test';
+        const d = tools.find((t) => t.name == toolToRun.name + ".test");
+        const functionName = "test";
         if (!d) {
             throw new Error(`${tool.name} not found`);
         }
@@ -26,10 +26,10 @@ export async function api_run_tool(c) {
             throw new Error(`${tool.name} function "${functionName}" not found (reload?)`);
         }
         const output = await callFunction(d.functionMap[functionName]);
-        return c.json({ output, js: 'test();' });
+        return c.json({ output, js: "test();" });
     }
     catch (e) {
-        return c.json({ output: `${e}`, js: '' });
+        return c.json({ output: `${e}`, js: "" });
     }
 }
 export async function api_save_tool(c) {
@@ -39,12 +39,13 @@ export async function api_save_tool(c) {
     }
     const title = tool.title;
     const code = tool.code;
+    const description = tool.description;
     let test = tool.test ?? "";
     const name = tool.name.toLowerCase().replaceAll(" ", "_");
     if (!title || !code || !name) {
         return c.json({ error: "Title and code are required" }, 400);
     }
-    const meta = { title, name };
+    const meta = { title, name, description };
     const jsCode = tsBlankSpace(tool.code ?? "", (e) => {
         logError({ type: "failed_ts_to_js_code", args: e });
     });
@@ -64,7 +65,7 @@ export async function api_save_tool(c) {
     }
     const missingData = {
         missingParameters: [],
-        missingFunctions: []
+        missingFunctions: [],
     };
     const definition = await inspectCode(srcPath, missingData);
     logWrite({ type: "api_save_tool_check_test", args: { test } });
@@ -77,7 +78,10 @@ export async function api_save_tool(c) {
     writeFileSync(testPath, test, "utf-8");
     writeFileSync(jsCodePath, jsCode, "utf-8");
     writeFileSync(jsTestPath, testCode, "utf-8");
-    logWrite({ type: "api_save_tool", args: { test: testPath, code: srcPath, meta: metaPath } });
+    logWrite({
+        type: "api_save_tool",
+        args: { test: testPath, code: srcPath, meta: metaPath },
+    });
     return c.json({
         message: `Tool saved successfully (${jsCodePath})`,
         missingParameters: missingData.missingParameters,
@@ -147,12 +151,12 @@ export async function getTool(name) {
     const test = await readOrEmpty(join(toolsFolder, `${name}.test.ts`));
     const meta = await readOrEmpty(join(toolsFolder, `${name}.json`));
     try {
-        const json = meta == '' ? { tile: '', name: '' } : JSON.parse(meta);
-        return { code, title: json.title, name: json.name, test };
+        const json = meta == "" ? { tile: "", name: "" } : JSON.parse(meta);
+        return { code, title: json.title, name: json.name, test, description: json.description };
     }
     catch (e) {
         console.error(`Failed to parse ${name}.json`, e);
-        return { code, title: "", name, test };
+        return { code, title: "", name, test, description: "" };
     }
 }
 function toolsSrcFolder() {
@@ -168,36 +172,48 @@ async function readOrEmpty(filename) {
     }
     return await promises.readFile(filename, "utf-8");
 }
+function isNodeExported(node) {
+    const modifiers = ts.getCombinedModifierFlags(node);
+    if ((modifiers & ts.ModifierFlags.Export) == ts.ModifierFlags.Export) {
+        return true;
+    }
+    return false;
+}
 export async function inspectCode(filename, missingData) {
     const code = await readOrEmpty(filename);
     const tools = [];
-    const sourceFile = ts.createSourceFile('temp.ts', code, ts.ScriptTarget.Latest, true);
+    const sourceFile = ts.createSourceFile("temp.ts", code, ts.ScriptTarget.Latest, true);
     function visit(node) {
-        if ((ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node)) && node.name) {
+        if ((ts.isFunctionDeclaration(node) ||
+            ts.isFunctionExpression(node) ||
+            ts.isArrowFunction(node)) &&
+            node.name &&
+            isNodeExported(node)) {
             const parsed = parseJSDoc(node);
-            console.log("Parsed function", parsed);
             const properties = {};
             const required = [];
-            node.parameters.forEach(param => {
+            node.parameters.forEach((param) => {
                 const isOptional = !!param.questionToken || !!param.initializer;
                 if (!isOptional) {
                     required.push(param.name.getText());
                 }
                 let type = typeName(param.type?.getText());
                 if (param.type?.kind == SyntaxKind.TypeReference) {
-                    type = 'object';
+                    type = "object";
                 }
                 parsed.params;
                 const hasDescription = Object.keys(parsed.params).includes(param.name.getText());
-                const description = hasDescription ? parsed.params[param.name.getText()] : '';
+                const description = hasDescription
+                    ? parsed.params[param.name.getText()]
+                    : "";
                 if (!hasDescription) {
                     missingData.missingParameters.push(param.name.escapedText);
                 }
                 properties[param.name.getText()] = {
                     type,
-                    description
+                    description,
                 };
-                if (type == 'array') {
+                if (type == "array") {
                     properties[param.name.getText()].items = {
                         type: arrayType(param.type?.getText()),
                     };
@@ -208,16 +224,16 @@ export async function inspectCode(filename, missingData) {
                 missingData.missingFunctions.push(node.name.getText());
             }
             tools.push({
-                type: 'function',
+                type: "function",
                 function: {
-                    name: node.name?.text ?? '',
+                    name: node.name?.text ?? "",
                     description: functionDescription,
                     parameters: {
-                        type: 'object',
+                        type: "object",
                         properties,
                         required,
-                    }
-                }
+                    },
+                },
             });
         }
         ts.forEachChild(node, visit);
@@ -233,7 +249,7 @@ function parseJSDoc(node) {
         description: "",
         params: {},
     };
-    let info = '';
+    let info = "";
     for (const doc of jsDoc) {
         if (ts.isJSDoc(doc)) {
             if (doc.comment) {
@@ -241,15 +257,15 @@ function parseJSDoc(node) {
             }
             if (doc.tags) {
                 for (const tag of doc.tags) {
-                    info += ' ' + tag.comment;
+                    info += " " + tag.comment;
                     if (tag.kind == SyntaxKind.JSDocTag && tag.comment) {
                         let txt = tag.comment ? tag.comment.toString() : "";
-                        const lines = txt.split(' ');
+                        const lines = txt.split(" ");
                         const paramName = lines[0];
                         if (txt.startsWith(paramName)) {
                             txt = txt.substring(paramName.length).trim();
                         }
-                        if (txt.startsWith('-')) {
+                        if (txt.startsWith("-")) {
                             txt = txt.substring(1).trim();
                         }
                         parsed.params[paramName] = txt;
@@ -261,7 +277,7 @@ function parseJSDoc(node) {
                         if (txt.startsWith(paramName)) {
                             txt = txt.substring(paramName.length).trim();
                         }
-                        if (txt.startsWith('-')) {
+                        if (txt.startsWith("-")) {
                             txt = txt.substring(1).trim();
                         }
                         parsed.params[paramName] = txt;
@@ -274,14 +290,14 @@ function parseJSDoc(node) {
 }
 function typeName(name) {
     if (!name)
-        return 'any';
-    if (name.endsWith('[]')) {
-        return 'array';
+        return "any";
+    if (name.endsWith("[]")) {
+        return "array";
     }
     return name;
 }
 function arrayType(name) {
     if (!name)
-        return 'any';
-    return name.replace('[]', '');
+        return "any";
+    return name.replace("[]", "");
 }

package/dist/log/log.js

@@ -1,4 +1,4 @@
-let logLevel = "debug";
+let logLevel = process.argv.slice(2).includes('debug') ? "debug" : "none";
 export function logWrite(l, additionalMessage) {
     if (logLevel == "none")
         return;
@@ -28,6 +28,15 @@ export function logError(l) {
         return;
     console.error(l);
 }
+export function logUser(message) {
+    console.log(`[user] ${message}`);
+}
+export function logStep(message) {
+    console.log(` - ${message}`);
+}
+export function logAi(message) {
+    console.log(`[ai] ${message}`);
+}
 function id() {
     return Math.random().toString().replace(".", "");
 }

package/dist/prompt.js

@@ -6,12 +6,10 @@ import { isEmpty } from "./api/utils.js";
 import { logWrite, logEnd, logStart } from "./log/log.js";
 export async function prompt(content, promptOptions) {
     const settings = await getSettings();
-    if (settings.openRouterApiKey == "") {
-        return "You need to set the OpenRouter API key in the settings.";
-    }
+    let apiKey = settings.tarskApiKey;
     const options = {
-        baseUrl: settings.openRouterURL,
-        apiKey: settings.openRouterApiKey,
+        baseUrl: isEmpty(settings.apiURL) ? "https://api.tarsk.io/api/v1" : settings.apiURL,
+        apiKey,
     };
     const messages = [];
     if (promptOptions?.firstMessage) {
@@ -45,7 +43,7 @@ function friendlyError(e, settings) {
         return `The model "${settings.defaultModel}" does not support tool use. Please select a different model (A good default is ${defaultModel}).`;
     }
     if (e.startsWith("Error: No auth credentials found")) {
-        return `The OpenRouter API key is invalid. Please check your account at https://openrouter.ai and get a new key.`;
+        return `The API key is invalid. Please check your account and get a new key.`;
     }
     return e;
 }

package/dist/tools.js

@@ -1,4 +1,4 @@
-import { logWrite, logEnd, logError, logStart } from "./log/log.js";
+import { logWrite, logEnd, logError, logStart, logStep } from "./log/log.js";
 import { getPathWithoutExtension, readAsJSONIfExists } from "./utils/files.js";
 export async function loadTools(modulePaths) {
     const tools = [];
@@ -14,6 +14,7 @@ export async function loadTools(modulePaths) {
         }
         else {
             const tool = await inspectTool(modulePath);
+            logStep(`Loaded tool "${tool.name}"`);
             tools.push(tool);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tarsk",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "author": "WebNative LLC",
   "description": "Tarsk is a AI tool available at https://tarsk.io",
   "license": "MIT",
@@ -12,7 +12,8 @@
     "restart": "npm unlink tarsk && rm -rf dist && npm run build && npm link && tarsk",
     "test": "vitest",
     "test2": "bun test/test-get-definition.ts",
-    "dev": "tsx watch src/index.ts"
+    "dev": "tsx watch src/index.ts",
+    "dev:debug": "tsx watch src/index.ts debug=true"
   },
   "bin": {
     "tarsk": "dist/index.js"