tune-sdk 0.2.4 → 0.2.6

package/tools/js.tool.mjs

@@ -1,60 +0,0 @@
-import { parseScript } from 'esprima';
-import { generate } from 'escodegen';
-import { spawnSync } from 'node:child_process';
-import { writeFileSync, unlinkSync }  from 'node:fs';
-import { randomBytes } from 'crypto';
-
-export default async function execute({ text, inputType }, ctx) {
-  // Parse the code into an Abstract Syntax Tree (AST)
-  const ast = parseScript(text, { range: true });
-
-  if (ast.body.length === 0) {
-    return null;
-  }
-
-  const lastNode = ast.body[ast.body.length - 1];
-  let modified = false;
-
-  // If the last statement is an expression, replace it with an assignment
-  if (lastNode.type === 'ExpressionStatement') {
-    const assignExpression = {
-      type: 'ExpressionStatement',
-      expression: {
-        type: 'AssignmentExpression',
-        operator: '=',
-        left: {
-          type: 'Identifier',
-          name: 'myVariable'
-        },
-        right: lastNode.expression
-      }
-    };
-    ast.body[ast.body.length - 1] = assignExpression;
-    modified = true;
-  }
-
-  const rand = randomBytes(50).toString('hex').substring(0, 10);
-  const filename = (inputType === "module") ? `tune${rand}.mjs`:`tune${rand}.js`;
-
-  let modifiedCode = generate(ast);
-  if (modified) {
-    if (inputType === "module") {
-      modifiedCode = `${modifiedCode}\nimport util from 'util';\nconsole.log(util.inspect(myVariable)) `
-    } else  {
-      modifiedCode = `${modifiedCode}\nconsole.log(require("util").inspect(myVariable))`
-    }
-  }
-  writeFileSync(filename, modifiedCode)
-
-  try {
-    const res = spawnSync("node", [filename], 
-      { 
-        encoding: "utf8",
-        input: modifiedCode, 
-      });
-
-    return (res.stderr + res.stdout).trim().replace(/@/g, "\\@");
-  } finally {
-    unlinkSync(filename)
-  }
-}

package/tools/json_format.proc.mjs

@@ -1,22 +0,0 @@
-import path from 'path';
-
-export default async function json_format(node, args, ctx) {
-  if (!node) {
-    return 
-  }
-  let response_format = { "type": "json_object" }
-  if (args.trim()) {
-
-    let schema = await ctx.resolve(args.trim());
-    if (!schema) throw Error(`schema file not found ${args.trim()}`)
-    schema = await schema.read();
-    response_format = { 
-      "type": "json_schema", 
-      "json_schema": JSON.parse(schema),
-    }
-  }
-  return {
-    ...node,
-    exec: async (payload, ctx) => node.exec({ ...payload, response_format }, ctx)
-  }
-}

package/tools/linenum.proc.js

@@ -1,21 +0,0 @@
-/*
-  *  { type: "text" | "image" | "llm" | "tool" | "processor" }
-  *  name
-  *  read (afn )
-  */
-module.exports = async function(node, args) {
-  if (! node) {
-    return node
-  }
-  const res = Object.assign({}, node);
-  res.read = async function(args) {
-    let contents = await node.read(args);
-    contents = contents.split("\n");
-    const pad = `${contents.length}`.length;
-    return contents.map((item, index) => {
-      const lineNum = `${index + 1}`.padEnd(pad + 1, " ") + "|";
-      return `${lineNum} ${item}`
-    }).join("\n")
-  }
-  return res
-}

package/tools/list.schema.json

@@ -1,19 +0,0 @@
-{
-  "description": "Manages todo lists",
-  "strict": true,
-  "parameters": {
-    "type": "object",
-    "properties": {
-      "text": {
-        "type": "string",
-        "description": "lines in format 'status - item', they'll be used to update list or to insert to the list, to delete item change its status to deleted or cancelled\nThe lines should contain only those items that needs to be changed - inserted/updated/deleted"
-      },
-      "filename": {
-        "type": "string",
-        "description": "location of the todo list file"
-      }
-    },
-    "required": ["text", "filename"],
-    "additionalProperties": false
-  }
-}

package/tools/list.tool.mjs

@@ -1,20 +0,0 @@
-function parse(text) {
-  const lines = text.split("\n").map(item => item.trim()).filter(item => item);
-  return lines.reduce((memo, line) => { 
-    const idx = line.indexOf("-")
-    if (idx === -1) return memo
-    const status = line.slice(0, idx).trim()
-    const task = line.slice(idx+1).trim()
-    memo[task] = status
-    return memo
-  }, 
-    {})
-}
-export default async function list({text, filename}, ctx) {
-  let todo = parse(await ctx.read(filename) || "")
-  const changes = parse(text)
-  todo = { ...todo, ...changes }
-  todo = Object.keys(todo).map(key => `${todo[key]} - ${key}`).join("\n")
-  await ctx.write(filename, todo)
-  return "list updated"
-}

package/tools/llm-utils.js

@@ -1,150 +0,0 @@
-const path = require("path");
-const fs = require("fs");
-
-// Create cache directory if it doesn't exist
-const cacheDir = path.join(__dirname, ".cache");
-if (!fs.existsSync(cacheDir)) {
-  fs.mkdirSync(cacheDir, { recursive: true });
-}
-
-/**
- * Creates a model cache manager for a specific provider
- * @param {string} providerName - Name of the provider (used for cache file)
- * @param {function} fetchModelsFunction - Function to fetch models from API
- * @returns {function} getModels function that handles caching
- */
-function createModelCache(providerName, fetchModelsFunction) {
-  const cacheFile = path.join(cacheDir, `${providerName}_models.json`);
-  let cache;
-
-  return async function getModels(...args) {
-    if (cache) {
-      return cache;
-    }
-    
-    // Check if cache exists and is less than an hour old
-    if (fs.existsSync(cacheFile)) {
-      const stats = fs.statSync(cacheFile);
-      const cacheAge = Date.now() - stats.mtimeMs;
-      const oneHourMs = 60 * 60 * 1000; // 1 hour in milliseconds
-
-      if (cacheAge < oneHourMs) {
-        try {
-          const cachedData = fs.readFileSync(cacheFile, "utf8");
-          cache = JSON.parse(cachedData);
-          return cache;
-        } catch (error) {
-          console.warn(`Error reading cache for ${providerName}:`, error);
-          // Continue to fetch from API if cache reading fails
-        }
-      }
-    }
-
-    // Fetch from API if cache doesn't exist, is too old, or couldn't be read
-    try {
-      const models = await fetchModelsFunction(...args);
-      cache = models;
-      fs.writeFileSync(cacheFile, JSON.stringify(models, null, "  "), "utf8");
-      return models;
-    } catch (error) {
-      console.error(`Error fetching models for ${providerName}:`, error);
-      throw error;
-    }
-  };
-}
-
-/**
- * Creates a context provider function with standard environment and regex matching
- * @param {string} providerName - Name of the provider
- * @param {Object} options - Configuration options
- * @returns {function} Provider context function
- */
-function createProviderContext(providerName, options) {
-  const {
-    apiKeyEnv,
-    modelMatcher,
-    modelFilter,
-    createExecFunction,
-    apiModelFetcher
-  } = options;
-  
-  const getModels = createModelCache(providerName, apiModelFetcher);
-  const envr = /^[A-Z_0-9]+$/;
-
-  return async function providerContext(name, args) {
-    // respond only to llm request or if type is 'any'
-    if (args.type !== 'any' && args.type !== 'llm') {
-      return;
-    }
-    
-    const context = this;
-    if (envr.test(name)) {
-      return;
-    }
-    
-    // Check if this model name should be handled by this provider
-    if (modelMatcher && !modelMatcher(name)) {
-      return;
-    }
-    
-    const apiKey = await context.read(apiKeyEnv);
-    if (!apiKey) {
-      return;
-    }
-
-    try {
-      const models = await getModels(apiKey);
-
-      // Filter models based on name and args
-      let matchedModels = [];
-      if (modelFilter) {
-        matchedModels = modelFilter(models, name, args);
-      } else {
-        // Default filter by exact match or regex
-        let re;
-        if (args.match === "regex") {
-          re = new RegExp(name);
-        }
-
-        matchedModels = models.filter((item) => {
-          if (args.match === "exact" && item.id === name) {
-            return true;
-          }
-          if (re) {
-            return re.test(item.id);
-          }
-          return false;
-        });
-      }
-
-      if (!matchedModels.length) {
-        return;
-      }
-
-      if (args.output === 'all') {
-        return matchedModels.map(model => ({ 
-          type: "llm", 
-          name: model.id || model.name 
-        }));
-      }
-
-      const model = matchedModels[0];
-      return {
-        type: "llm",
-        exec: async (payload) => {
-          // Get a fresh key in case it's rotated
-          const key = await this.read(apiKeyEnv);
-          return createExecFunction(model, payload, key, this);
-        },
-      };
-    } catch (e ) {
-      console.log(e)
-      return
-    }
-  };
-}
-
-module.exports = {
-  createModelCache,
-  createProviderContext
-};

package/tools/log.proc.js

@@ -1,15 +0,0 @@
-const fs = require("fs")
-const path = require("path")
-
-module.exports = async (node, args, ctx)  => ({
-  ...node,
-  exec: async function(payload, ctx) {
-    const res = await node.exec(payload, ctx)
-    const body = JSON.parse(res.body)
-    payload = {...res, body};
-    const filename = args.trim() || "log.json"
-    const content =  path.extname(filename) == ".chat" ? ctx.msg2text(payload.body.messages, true) : JSON.stringify(payload, null, "  ") 
-    fs.writeFileSync(filename, content);
-    return res
-  }
-})

package/tools/mcp.proc.mjs

@@ -1,174 +0,0 @@
-import { fileURLToPath } from 'url';
-import path from 'path';
-import fs from 'fs';
-import { spawn } from "node:child_process";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-/*
-const client = new Client({
-  name: "Tune",
-  version: "1.0.0"
-})
-*/
-
-async function makeEnv(ctx) {
-  const TUNE_PATH = await ctx.read('TUNE_PATH');
-  if (!TUNE_PATH) {
-    throw Error('TUNE_PATH not set')
-
-  }
-
-  return ctx.stack
-    .filter(item => item.dirname)
-    .map(item => item.dirname)
-    .reverse()
-    .concat(TUNE_PATH.split(path.delimiter))
-    .reduce((env, dir, index, arr) => {
-      if (arr.indexOf(dir)  < index) {
-        return env
-      }
-
-      const envFile = path.join(dir, ".env")
-
-      if (!fs.existsSync(envFile)) {
-        return env
-      }
-      fs.readFileSync(envFile, 'utf8')
-        .split('\n')
-      .forEach(line => {
-          const m = line.match(/^\s*(\w+)\s*=\s*["']?(.*?)\s*["']?$/)
-          if (!m) return
-          env[m[1]] = m[2]
-        })
-      return env
-
-    }, process.env)
-}
-
-async function getMcpClient(args, env) {
-  const client = {}
-  const [command, ...rest] = args.trim().split(/\s+/);
-  const process = spawn(command, rest, { env })
-  let chunks = []
-  const nodes = []
-  const callbacks = {}
-  function onError(err ) {
-    console.log("onError", err)
-    if (client.onError) {
-      client.onError(err)
-    }
-    Object.keys(callbacks).forEach(mid=> {
-      callbacks[mid].reject(err)
-    })
-  }
-  process.stdout.on('data', (data) => {
-    try {
-      chunks.push(data)
-      let buf = Buffer.concat(chunks)
-      let index
-      while ((index = buf.indexOf('\n')) !== -1) {
-        const line = buf.toString("utf8", 0, index);
-        buf = buf.subarray(index + 1);
-        const msg = JSON.parse(line)
-        if (msg.id && callbacks[msg.id]) {
-          const { resolve, reject} = callbacks[msg.id]
-          if (msg.result) { 
-            resolve(msg.result) 
-          }
-          if (msg.error) { 
-            reject(msg.error)
-          }
-          delete callbacks[msg.id]
-        }
-      }
-      chunks = [buf]
-    } catch (e) {
-      onError(e)
-      process.kill()
-    }
-  });
-
-  let msgId = 1
-  client.request = async (params) =>  
-    new Promise((resolve, reject) => {
-      const payload = JSON.stringify({
-        ...params,
-        jsonrpc: "2.0",
-        id: msgId,
-      })
-      process.stdin.write(`${payload}\n`)
-      callbacks[msgId] = {resolve, reject} 
-      msgId++
-    })
-
-  const errChunks = []
-  process.stderr.on('data', (data) => {
-    errChunks.push(data)
-    console.log(data.toString('utf8'))
-  });
-  process.on('error', onError);
-  process.on('close', (code) => {
-    client.err = Buffer.concat(errChunks).toString('utf8')
-    client.data = Buffer.concat(chunks).toString('utf8')
-    if (code !== 0) {
-      return onError(new Error(client.err))
-    }
-  });
-  let res = await client.request({
-    method: "initialize",
-    params: {
-      protocolVersion: "2024-11-05",
-      capabilities: { tools: {} },
-      clientInfo: { name: "Tune", version: "1.0.0"}
-    }
-  })
-  client.server = res
-
-  client.close = () => process.kill()
-  return client
-}
-
-export default async function mcp(node, args, ctx) {
-  const env = await makeEnv(ctx)
-  const client = await getMcpClient(args, env)
-  if (! client.server.capabilities.tools) {
-    throw Error(`${args} does not support tools`)
-  }
-  //client.onError()
-
-  let res = await client.request({ method: "tools/list"})
-  //const name = args.trim().toLowerCase().replace(/\W+/g, "_")
-  //fs.writeFileSync(path.join(__dirname, `${name}-mcp.json` ), JSON.stringify(res.tools, null, "  "))
-  return res.tools.map(item => ({
-    type: "tool",
-    name: item.name,
-    schema: { 
-      name: item.name,
-      description: item.description,
-      parameters: item.inputSchema
-    },
-    exec: async (args) => { 
-      let res = await client.request({method: "tools/call", params: {
-        name: item.name, 
-        arguments: args 
-      }}) 
-      res = res.toolResult || res
-      const content = res.content
-        .map(item => {
-          if (item.type == "text") {
-            return item.text.replaceAll("@", "\\@")
-          }
-          // not supported yet
-          return ""
-        })
-      .join("\n")
-
-      if (res.isError) {
-        throw Error(`error calling ${item.name}\n${content}`)
-      }
-      return content
-    }
-  }))
-}

package/tools/message.schema.json

@@ -1,21 +0,0 @@
-{
-  "description": "this tool sends a message to another ai chat as 'user' role, result of the tool is an 'assistant' reply",
-  "parameters": {
-    "type": "object",
-    "properties": {
-      "filename": {
-        "type": "string",
-        "description": "File name to read/write chat history, should have .chat extension"
-      },
-      "system": {
-        "type": "string",
-        "description": "Filename that contains system prompt, required once at the beginning of simulation"
-      },
-      "text": {
-        "type": "string",
-        "description": "User message to send"
-      }
-    },
-    "required": ["filename", "text"]
-  }
-}

package/tools/message.tool.js

@@ -1,14 +0,0 @@
-module.exports = async function message({ filename, system, text, stop }, ctx) {
-  let chat = await ctx.read(filename);
-  if (!chat && system) {
-    chat = `system: @@${system}`
-  }
-  chat = `${chat}\nuser:\n${text}`
-  const messages = await ctx.text2run(chat, {stop: "assistant" })
-  chat = `${chat}\n${ctx.msg2text(messages, true)}`
-  await ctx.write(filename, chat)
-  if (messages.length) {
-    return messages[messages.length - 1].content
-  }
-  return ""
-}

package/tools/mock.proc.js

@@ -1,35 +0,0 @@
-module.exports = async function mock(node, args, ctx) {
-  const re = /(?<name>\w+)\s*=/
-  let lastName;
-  let m;
-  let text = args;
-  const vars = {};
-  while ((m = re.exec(text)) !== null) {
-    const { name } = m.groups
-
-    if (lastName) {
-      vars[lastName] = text.slice(0, m.index).trim()
-    }
-    text = text.slice(m.index + m[0].length)
-    lastName = name
-  }
-  if (lastName) {
-    vars[lastName] = text.trim()
-  }
-  ctx.use((name, ctx, args)=> {
-    if (!vars.hasOwnProperty(name)) {
-      return 
-    }
-    return {
-      ...node,
-      type: "text",
-      name,
-      read: async () => vars[name]
-    }
-  })
-  return { 
-    ...node,
-    type: "text", 
-    read: async() => ""
-  }
-}

package/tools/nu.schema.json

@@ -1,13 +0,0 @@
-  {
-  "description": "Execute a nushell command",
-  "parameters": {
-    "type": "object",
-    "properties": {
-      "text": {
-        "type": "string",
-        "description": "The nushell command to execute"
-      }
-    },
-    "required": ["text"]
-  }
-}

package/tools/nu.tool.mjs

@@ -1,14 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import util from 'node:util'
-
-export default async function nu({ text }) {
-  let result = ""
-  try {
-    result =  spawnSync("nu", 
-      ["-c", text, "--error-style", "plain"], 
-      { encoding: "utf8", shell: false })
-  } catch (e) {
-    result = e.stderr + e.stdout
-  }
-  return (result.stdout || result.stderr || "").replaceAll("@", "\\@");
-}

package/tools/openai.js

@@ -1,27 +0,0 @@
-module.exports = function(props, transform) {
-  const { auth_key, url } = props;
-  delete props.auth_key;
-  delete props.url;
-  return async function(payload, ctx) {
-    const key = auth_key || await ctx.read('OPENAI_KEY');
-    if (typeof(transform) === 'function') {
-      payload = transform(payload)
-    }
-
-    const result =  ({
-      url: url || "https://api.openai.com/v1/chat/completions",
-      method: "POST",
-      headers: { 
-        "content-type": "application/json",
-        authorization: `Bearer ${key}` 
-      },
-      body: JSON.stringify({ 
-        ...props,
-        ...payload,
-        messages: payload.messages.filter(msg => msg.role !== 'comment'),
-      })
-    })
-    // console.log(result)
-    return result
-  }
-}

package/tools/openai_imgen.schema.json

@@ -1,35 +0,0 @@
-
-{
-  "description": "generate or change an image using openai image generation",
-  "parameters": {
-    "type": "object",
-    "properties": {
-      "text": {
-        "type": "string",
-        "description": "The prompt text for image generation. or details on what to change on existing images."
-      },
-      "filename": {
-        "type": "string",
-        "description": "The filename where the generated image will be saved."
-      },
-      "quality": {
-        "type": "string",
-        "enum": ["auto", "low", "medium", "high"],
-        "description": "Quality of the result, auto is default"
-      },
-      "size": {
-        "type": "string",
-        "enum": ["auto", "square", "landscape", "portrait"],
-        "description": "size of the image, auto is default"
-      },
-      "images": {
-        "type": "array",
-        "description": "Use it if you want to change existing image, or provide more context to newly generated image. If provided, the API will use the edits endpoint instead of generations. ",
-        "items": {
-          "type": "string"
-        }
-      }
-    },
-    "required": ["text", "filename"]
-  }
-}