tune-sdk 0.1.13 → 0.2.1

package/README.md

@@ -54,7 +54,7 @@ npx tune-sdk --user "hi how are you?" --filename newchat.chat  --save
 npx tune-sdk --system "You are Groot" --user "Hi how are you?"
 
 #set context variable
-npx tune-sdk --set "test=hello" --user "@test" --system "You are echo you print everythting back"  
+npx tune-sdk --set-test "hello" --user "@test" --system "You are echo you print everythting back"  
 ```
 
 

package/bin/cli.js

@@ -1,133 +1,4 @@
-var tune, rpc;
+#!/usr/bin/env node
 
-function parseArgs(args) {
-  var curKey, res, res1, key, value, _ref, _len;
-  var curKey;
-  curKey = null;
-  var res;
-  res = args.reduce((function(memo, arg) {
-    var key, value, _ref, _i;
-    if (arg.startsWith("--")) {
-      _ref = arg.substring(2)
-        .split("=");
-      key = _ref[0];
-      value = _ref[1];
-      if (!!value) {
-        memo[key] = value;
-        curKey = null;
-      } else {
-        curKey = key;
-        memo[key] = true;
-      }
-    } else if (curKey) {
-      memo[curKey] = arg;
-      curKey = null;
-    }
-    return memo;
-  }), {});
-  var res1;
-  res1 = {};
-  _ref = res;
-  for (key in _ref) {
-    value = _ref[key];
-    if (key.startsWith("set-")) {
-      res1.params = res1.params || {}
-      res1.params[key.substr(4)] = value;
-    } else {
-      res1[key] = value;
-    }
-  }
-  return res1;
-}
-parseArgs;
-tune = require("../dist/tune.js");
-rpc = require("../dist/rpc.js");
-async function rpc(args, ctx) {
-  var server;
-  var server;
-  return (server = jsonrpc());
-}
-rpc;
-async function run(args, ctx) {
-  var stopVal, params;
-  var stopVal;
-  stopVal = args.stop || "assistant";
-  if ((stopVal !== "step" && stopVal !== "assistant")) stopVal = (function(msgs) {
-    var lastMsg;
-    if (!msgs.length) return false;
-    var lastMsg;
-    lastMsg = msgs["slice"](-1)[0];
-    if (!lastMsg.content) return false;
-    return (-1 !== lastMsg.content.inexOf(args.stop || "assistant"));
-  });
-  var params;
-  params = args.params;
-  delete args.params;
-  return ctx.file2run(args, params);
-}
-run;
-async function main() {
-  var dirs, args, ctx, dir, ctxName, ext, module, m, _i, _res, _ref, _len, _ref0, _i0, _res0, _ref1, _len0, _ref2;
-  var dirs;
-  var args;
-  dirs = [];
-  args = parseArgs(process.argv.slice(2));
-  if (args.path) {
-    dirs = args.path.split(path.delimiter);
-  } else {
-    if (process.env.TUNE_PATH) dirs = process.env.TUNE_PATH.split(path.delimiter);
-    dirs.push(process.cwd());
-  }
-  ctx = tune.makeContext(process.env);
-  _res = [];
-  _ref = dirs;
-  for (_i = 0, _len = _ref.length; _i < _len; ++_i) {
-    dir = _ref[_i];
-    var ctxName;
-    ctxName = ["default.ctx.js", "default.ctx.cjs", "default.ctx.mjs"]
-      .map((function(name) {
-        return path.join(dir, name);
-      }))
-      .find((function(name) {
-        return fs.existsSync(name);
-      }));
-    if (!ctxName) continue;
-    var ext;
-    var module;
-    ext = path.extname(filename);
-    module = null;
-    if ((ext === ".js" || ext === ".cjs")) {
-      module = require(ctxName);
-    } else {
-      module = await import(ctxName);
-      module = module.default;
-    }
-    if ((typeof module === "function")) {
-      _ref0 = ctx.use(module);
-    } else if (Array.isArray(module)) {
-      _res0 = [];
-      _ref1 = module;
-      for (_i0 = 0, _len0 = _ref1.length; _i0 < _len0; ++_i0) {
-        m = _ref1[_i0];
-        if ((typeof m === "function")) {
-          _ref2 = ctx.use(module);
-        } else {
-          _ref2 = undefined;
-          throw Error(tpl("err: Context file export is not an array of functions or function {}", ctxName));
-        }
-        if (typeof _ref2 !== 'undefined') _res0.push(_ref2);
-      }
-      _ref0 = _res0;
-    } else {
-      _ref0 = undefined;
-      throw Error(tpl("err: Context file export is not an array of functions or function {}", ctxName));
-    }
-    if (typeof _ref0 !== 'undefined') _res.push(_ref0);
-  }
-  return _res;
-}
-main;
-exports.parseArgs = parseArgs;
-exports.rpc = rpc;
-exports.main = main;
-exports.run = run;
+const cli = require("../dist/cli.js")
+cli.main()

package/config/default.ctx.js

@@ -0,0 +1,22 @@
+const fs = require('fs') 
+const path = require('path')
+
+const models = require("tune-models")
+const { curFile, fsMix, defaultWrite } = require("tune-sdk/fsctx");
+const { file2run, makeContext } = require("tune-sdk");
+
+async function makeSchema(params, ctx) {
+  return file2run({ filename:  path.join(__dirname, "schema.tool.chat")}, params, ctx);
+}
+let dirs = [];
+if (process.env.TUNE_PATH) {
+  dirs = process.env.TUNE_PATH.split(path.delimiter);
+}
+
+
+module.exports = [
+  curFile,
+  fsMix(dirs, { makeSchema }),
+  models(),
+  defaultWrite()
+]

package/config/package.json

@@ -0,0 +1,6 @@
+{
+  "dependencies": {
+    "tune-models": "/Users/iovdin/projects/tune-models",
+    "tune-sdk": "/Users/iovdin/projects/tune"
+  }
+}

package/config/package.prod.json

@@ -0,0 +1,7 @@
+{
+  "dependencies": {
+    "tune-sdk": "latest",
+    "tune-models": "latest",
+    "tune-toolset": "latest"
+  }
+}

package/dist/cli.js

@@ -0,0 +1,288 @@
+var tune, rpc, path, fs, os, cp, stream;
+
+function parseArgs(args) {
+  var curKey, res, res1, key, value, stop, _ref, _len;
+  var curKey;
+  curKey = null;
+  var res;
+  res = args.reduce((function(memo, arg) {
+    var key, value, _ref, _i;
+    if (arg.startsWith("--")) {
+      _ref = arg.substring(2)
+        .split("=");
+      key = _ref[0];
+      value = _ref[1];
+      if (!!value) {
+        memo[key] = value;
+        curKey = null;
+      } else {
+        curKey = key;
+        memo[key] = true;
+      }
+    } else if (curKey) {
+      memo[curKey] = arg;
+      curKey = null;
+    }
+    return memo;
+  }), {});
+  var res1;
+  res1 = {};
+  _ref = res;
+  for (key in _ref) {
+    value = _ref[key];
+    if (key.startsWith("set-")) {
+      res1.params = res1.params || {}
+      res1.params[key.substr(4)] = value;
+    } else {
+      res1[key] = value;
+    }
+  }
+  stop = res1.stop;
+  if ((!!stop && (stop !== "step" && stop !== "assistant"))) res1.stop = (function(msgs) {
+    var lastMsg;
+    if (!msgs.length) return false;
+    var lastMsg;
+    lastMsg = msgs["slice"](-1)[0];
+    if (!lastMsg.content) return false;
+    return (-1 !== lastMsg.content.inexOf(stop));
+  });
+  return res1;
+}
+parseArgs;
+tune = require("../dist/tune.js");
+rpc = require("../dist/rpc.js");
+path = require("path");
+fs = require("fs");
+os = require("os");
+cp = require("child_process");
+stream = require("stream");
+
+function getHomedir(args) {
+  return path.resolve(path.normalize((args.home || process.env.TUNE_HOME || "~/.tune")
+    .replace("~", os.homedir())));
+}
+getHomedir;
+async function initConfig(args) {
+  var homedir, stdout, stderr, _ref, _i;
+  var homedir;
+  homedir = getHomedir(args);
+  if ((!args.forceInit && fs.existsSync(homedir))) return;
+  console.error("[tune-sdk] initialize " + homedir);
+  fs.mkdirSync(homedir, {
+    recursive: true
+  });
+  console.error("[tune-sdk] copying files");
+  fs.copyFileSync(path.resolve(__dirname, "../config/default.ctx.js"), path.resolve(homedir, "default.ctx.js"));
+  fs.copyFileSync(path.resolve(__dirname, "../config/package.json"), path.resolve(homedir, "package.json"));
+  console.error("[tune-sdk] installing npm");
+  try {
+    _ref = cp.execSync("npm i", {
+      cwd: homedir,
+      encoding: "utf8"
+    });
+    stdout = _ref[0];
+    stderr = _ref[1];
+    if (stdout.trim()) console.error("[tune-sdk]", stdout.trim());
+    stderr.trim() ? console.error("[tune-sdk]", stderr.trim()) : undefined;
+  } catch (err) {}
+  return console.error("[tune-sdk] done");
+}
+initConfig;
+async function suggest(params, ctx) {
+  var node, _ref;
+  var node;
+  node = await ctx.resolve(params.query, {
+    output: "all",
+    match: "regex"
+  });
+  if (!node) {
+    _ref = [];
+  } else if (!Array.isArray(node)) {
+    _ref = Array(node);
+  } else {
+    _ref = node;
+  }
+  node = _ref;
+  return node.map((function(item) {
+    return {
+      name: item.name,
+      dirname: item.dirname,
+      fullname: item.fullname,
+      basename: (item.fullname ? path.basename(item.fullname) : undefined),
+      type: item.type
+    }
+  }));
+}
+suggest;
+async function remoteContext(name, params) {
+  var server, node;
+  var server;
+  server = this;
+  var node;
+  node = await server.resolve({
+    name: name,
+    params: params
+  });
+  if ((((typeof node !== "undefined") && (node !== null) && !Number.isNaN(node) && (typeof node.error !== "undefined") && (node.error !== null) && !Number.isNaN(node.error)) ? node.error : undefined)) return;
+  node.read = (function() {
+    return server.read({
+      name: name,
+      params: params
+    });
+  });
+  node.exec = (function() {
+    return server.exec({
+      name: name,
+      params: params
+    });
+  });
+  return node;
+}
+remoteContext;
+async function runRpc(args) {
+  var inStream, outStream, ctx, server;
+  var inStream;
+  var outStream;
+  var ctx;
+  var server;
+  inStream = stream.Readable.toWeb(process.stdin);
+  outStream = stream.Writable.toWeb(process.stdout);
+  ctx = await initContext(args);
+  server = rpc.jsonrpc({
+    inStream: inStream,
+    outStream: outStream,
+    debug: args.debug,
+    name: "server"
+  }, {
+    init: (async function(methods) {
+      return ((-1 !== methods.indexOf("resolve")) ? ctx.use(remoteContext.bind(server)) : undefined);
+    }),
+    file2run: (async function(params, stream) {
+      return tune.file2run({
+        filename: params.filename,
+        response: params.response,
+        stream: stream,
+        stop: params.stop,
+        text: params.text,
+        system: params.system,
+        user: params.user,
+        save: params.save
+      }, {}, ctx);
+    }),
+    suggest: (async function(params) {
+      return suggest(params, ctx);
+    })
+  });
+  return null;
+}
+runRpc;
+async function run(args) {
+  var ctx, stop, params, res;
+  ctx = await initContext(args);
+  var stop;
+  stop = args.stop || "assistant";
+  var params;
+  params = args.params || {}
+  delete args.params;
+  var res;
+  res = await ctx.file2run(args, params);
+  return (!args.filename ? console.log(res) : undefined);
+}
+run;
+async function initContext(args) {
+  var dirs, pwd, ctx, dir, ctxName, ext, module, m, _i, _ref, _len, _i0, _ref0, _len0;
+  var dirs;
+  var pwd;
+  dirs = [];
+  pwd = process.cwd();
+  args.path ? dirs = args.path.split(path.delimiter)
+    .map((function(dir) {
+      return path.resolve(pwd, dir);
+    })) : dirs.push(getHomedir(args));
+  dirs.push(pwd);
+  process.env.TUNE_PATH = dirs.join(path.delimiter);
+  ctx = tune.makeContext(process.env);
+  _ref = dirs;
+  for (_i = 0, _len = _ref.length; _i < _len; ++_i) {
+    dir = _ref[_i];
+    var ctxName;
+    ctxName = ["default.ctx.js", "default.ctx.cjs", "default.ctx.mjs"]
+      .map((function(name) {
+        return path.join(dir, name);
+      }))
+      .find((function(name) {
+        return fs.existsSync(name);
+      }));
+    if (!ctxName) continue;
+    var ext;
+    var module;
+    ext = path.extname(ctxName);
+    module = null;
+    if ((ext === ".js" || ext === ".cjs")) {
+      module = require(ctxName);
+    } else {
+      module = await import(ctxName);
+      module = module.default;
+    }
+    if ((typeof module === "function")) {
+      ctx.use(module);
+    } else if (Array.isArray(module)) {
+      _ref0 = module;
+      for (_i0 = 0, _len0 = _ref0.length; _i0 < _len0; ++_i0) {
+        m = _ref0[_i0];
+        if ((typeof m === "function")) {
+          ctx.use(m);
+        } else {
+          throw Error(tpl("err: Context file export is not an array of functions or function {name}: {module}", {
+            name: ctxName,
+            module: m
+          }));
+        }
+      }
+    } else {
+      throw Error(tpl("err: Context file export is not an array of functions or function {name}: {module}", {
+        name: ctxName,
+        module: module
+      }));
+    }
+  }
+  return ctx;
+}
+initContext;
+async function main() {
+  var args, _ref;
+  try {
+    var args;
+    args = parseArgs(process.argv.slice(2));
+    await initConfig(args);
+    _ref = args.rpc ? await runRpc(args) : await run(args);
+  } catch (e) {
+    _ref = console.error(e);
+  }
+  return _ref;
+}
+main;
+
+function tpl(str) {
+  var _i;
+  var params = 2 <= arguments.length ? [].slice.call(arguments, 1, _i = arguments.length - 0) : (_i = 1, []);
+  return (function(paramIndex, params) {
+    var _ref;
+    try {
+      _ref = str.replace(/{(\W*)(\w*)(\W*)}/gm, (function(_, pre, name, post) {
+        return (function(res) {
+          paramIndex += 1;
+          return ((typeof res !== 'undefined') ? ((pre || "") + res + (post || "")) : "");
+        })(params[name || paramIndex]);
+      }));
+    } catch (e) {
+      _ref = console.log.apply(console, [].concat([e, str]).concat(params));
+    }
+    return _ref;
+  })(0, (((typeof params[0] === "object") && (params.length === 1)) ? params[0] : params));
+}
+tpl;
+exports.parseArgs = parseArgs;
+exports.rpc = rpc;
+exports.main = main;
+exports.run = run;

package/dist/rpc.js

@@ -35,8 +35,9 @@ function jsonrpc(params, exports) {
 }
 jsonrpc;
 
-function concatU8A(u8arrays) {
-  var totalLen, res, offset, arr, _i, _ref, _len;
+function concatU8A() {
+  var totalLen, res, offset, arr, _i, _i0, _ref, _len;
+  var u8arrays = 1 <= arguments.length ? [].slice.call(arguments, 0, _i = arguments.length - 0) : (_i = 0, []);
   var totalLen;
   var res;
   var offset;
@@ -46,8 +47,8 @@ function concatU8A(u8arrays) {
   res = new Uint8Array(totalLen);
   offset = 0;
   _ref = u8arrays;
-  for (_i = 0, _len = _ref.length; _i < _len; ++_i) {
-    arr = _ref[_i];
+  for (_i0 = 0, _len = _ref.length; _i0 < _len; ++_i0) {
+    arr = _ref[_i0];
     res.set(arr, offset);
     offset = offset + arr.length;
   }
@@ -55,10 +56,21 @@ function concatU8A(u8arrays) {
 }
 concatU8A;
 
+function assert(cond, msg) {
+  var _ref;
+  if (!cond) {
+    _ref = undefined;
+    throw Error, msg;
+  } else {
+    _ref = undefined;
+  }
+  return _ref;
+}
+assert;
+
 function JSONRPC(params, exports) {
   var self;
   this.msgId = 1;
-  this.chunks = [];
   this.debug = params.debug;
   this.name = params.name;
   this.exports = exports || params.exports || {}
@@ -67,35 +79,34 @@ function JSONRPC(params, exports) {
   this.reader = params.inStream.getReader();
   this.writer = params.outStream.getWriter();
   self = this;
-  this.decoder = new TextDecoder();
-  assert.ok(params.inStream, "inStream has to be defined and be a ReadableStream");
-  assert.ok(params.outStream, "outStream has to be defined and be a WritableStream");
+  assert(params.inStream, "inStream has to be defined and be a ReadableStream");
+  assert(params.outStream, "outStream has to be defined and be a WritableStream");
   async function pump() {
-    var res, value, done, buf, newlineIdx, line, msg, cb, iter, err, m, r, chunk, _res, _ref, _ref0;
+    var res, value, done, newlineIdx, line, msg, cb, iter, err, _ref, _err;
     var res;
-    res = await self.reader.read();
     var value;
     var done;
+    res = await self.reader.read();
     value = res.value;
     done = res.done;
     if (done) return;
-    self.chunks.push(value);
-    var buf;
     var newlineIdx;
-    buf = concatU8A(self.chunks);
     newlineIdx = 0;
-    while (-1 !== (newlineIdx = buf.indexOf(10))) {
+    self.buf = (self.buf ? concatU8A(self.buf, value) : value);
+    while (-1 !== (newlineIdx = self.buf.indexOf(10))) {
       var line;
-      line = self.decoder.decode(buf.subarray(0, newlineIdx));
-      buf = buf.subarray(newlineIdx + 1);
-      self.chunks = [buf];
-      if (self.debug) console.log(self.name, line);
+      line = new TextDecoder().decode(self.buf.subarray(0, newlineIdx));
+      self.buf = self.buf.subarray(newlineIdx + 1);
+      if (self.debug) console.error(self.name, "<==", line);
       var msg;
-      msg = JSON.parse(line);
-      if (!msg.id) {
-        console.log("message has no id, skipping", msg);
-        continue;
+      try {
+        _ref = JSON.parse(line);
+      } catch (_err) {
+        console.error(self.name, ":", line);
+        _ref = {}
       }
+      msg = _ref;
+      if (!msg.id) continue;
       var cb;
       var iter;
       cb = self.callbacks[msg.id];
@@ -125,30 +136,33 @@ function JSONRPC(params, exports) {
         if (!self.exports[msg.method]) {
           self._error(msg.id, "method not found: " + msg.method);
           continue;
-        }
-        var m;
-        var r;
-        var chunk;
-        m = msg;
-        r = undefined;
-        chunk = {};
-        try {
-          r = await self.exports[m.method](msg.params, msg.stream);
-          if (((typeof r !== 'undefined') && !!r[Symbol.asyncIterator])) {
-            _res = [];
-            while (!chunk.done) {
-              chunk = await r.next();
-              if (chunk.err) throw chunk.err;
-              if (typeof(_ref = !!chunk.value ? self._result(m.id, chunk.value, chunk.done) : undefined) !== 'undefined') _res.push(_ref);
-            }
-            _ref0 = _res;
-          } else {
-            _ref0 = self._result(m.id, r, true);
+        }(function(m, r, chunk) {
+          var _ref0;
+          try {
+            _ref0 = self.exports[m.method](msg.params, msg.stream)
+              .then((async function(r) {
+                var _res, _ref0, _ref1;
+                if (((typeof r !== 'undefined') && !!r[Symbol.asyncIterator])) {
+                  _res = [];
+                  while (!chunk.done) {
+                    chunk = await r.next();
+                    if (chunk.err) throw chunk.err;
+                    if (typeof(_ref0 = (!!chunk.value ? self._result(m.id, chunk.value, chunk.done) : undefined)) !== 'undefined') _res.push(_ref0);
+                  }
+                  _ref1 = _res;
+                } else {
+                  _ref1 = self._result(m.id, r, true);
+                }
+                return _ref1;
+              }))
+              .catch((function(e) {
+                return self._error(m.id, e.message, e.stack);
+              }));
+          } catch (e) {
+            _ref0 = self._error(m.id, e.message, e.stack);
           }
-          _ref0;
-        } catch (e) {
-          self._error(m.id, e.message, e.stack);
-        }
+          return _ref0;
+        })(msg, undefined, {});
       }
     }
     return pump();
@@ -164,6 +178,7 @@ JSONRPC.prototype._write = (async function(payload) {
   var data;
   encoder = new TextEncoder();
   data = encoder.encode(JSON.stringify(payload) + "\n");
+  if (this.debug) console.error(this.name, "==>", JSON.stringify(payload));
   return await this.writer.write(data);
 });
 JSONRPC.prototype._error = (function(msgId, message, stack) {
@@ -208,4 +223,21 @@ JSONRPC.prototype._call = (async function(method, params, stream) {
   }));
   return (self.iterators[msgId] = new AsyncIter());
 });
+
+function _once(cond, body) {
+  return new Promise((function(resolve, reject) {
+    function handler() {
+      var _ref;
+      try {
+        _ref = cond() ? resolve(body()) : setTimeout(handler, 10);
+      } catch (err) {
+        _ref = reject(err);
+      }
+      return _ref;
+    }
+    setTimeout(handler, 10);
+    return "";
+  }));
+}
+_once;
 exports.jsonrpc = jsonrpc;

package/dist/tune.js

@@ -1057,11 +1057,19 @@ Context.prototype.clone = (function() {
   return res;
 });
 Context.prototype.use = (function(middleware) {
-  return ((middleware.name === "write") ? this.ws.push(middleware) : this.ms.push(middleware));
+  var _ref;
+  if ((typeof middleware !== "function")) {
+    _ref = undefined;
+    throw Error(tpl("middleware {} is not a function", util.inspect(middleware)));
+  } else {
+    _ref = ((middleware.name === "write") ? this.ws.push(middleware) : this.ms.push(middleware));
+  }
+  return _ref;
 });
-Context.prototype.resolve = (async function(name, args) {
+async function resolve(ctx, name, args, middlewares) {
   var i, output, match, type, result, res, md;
-  if (!this.ms.length) return;
+  middlewares = middlewares || ctx.ms;
+  if (!middlewares.length) return;
   var i;
   var output;
   var match;
@@ -1074,10 +1082,10 @@ Context.prototype.resolve = (async function(name, args) {
   type = (((typeof args !== "undefined") && (args !== null) && !Number.isNaN(args) && (typeof args.type !== "undefined") && (args.type !== null) && !Number.isNaN(args.type)) ? args.type : (((typeof "any" !== "undefined") && ("any" !== null) && !Number.isNaN("any")) ? "any" : undefined));
   result = ((output === "all") ? [] : undefined);
   res = undefined;
-  while (i < this.ms.length) {
+  while (i < middlewares.length) {
     var md;
-    md = this.ms[i];
-    res = await md.call(this, name, {
+    md = middlewares[i];
+    res = await md.call(ctx, name, {
       output: output,
       match: match,
       type: type
@@ -1106,6 +1114,10 @@ Context.prototype.resolve = (async function(name, args) {
     i++;
   }
   return result;
+}
+resolve;
+Context.prototype.resolve = (async function(name, args) {
+  return resolve(this, name, args);
 });
 Context.prototype.text2run = (function(text, opts) {
   return text2run(text, this, opts);
@@ -2099,45 +2111,96 @@ function text2run(text, ctx, opts) {
 }
 text2run;
 async function file2run(args, params, ctx) {
-  var lctx, uext, node, text, res, longFormatRegex, response, _ref;
+  var lctx, text, stop, node, response, res, r, chunk, itergQageqc, _ref;
   var lctx;
   lctx = ctx.clone();
   lctx.ms.unshift(envmd(params));
-  var uext;
-  uext = "";
+  var text;
+  var stop;
+  text = args.text;
+  stop = (((typeof args !== "undefined") && (args !== null) && !Number.isNaN(args) && (typeof args.stop !== "undefined") && (args.stop !== null) && !Number.isNaN(args.stop)) ? args.stop : (((typeof "assistant" !== "undefined") && ("assistant" !== null) && !Number.isNaN("assistant")) ? "assistant" : undefined));
   if (args.filename) {
     node = await ctx.resolve(args.filename);
     if (node) {
       lctx.stack.push(node);
-      text = await node.read();
+      if (!text) text = await node.read();
     }
   }
   if ((!text && args.system)) text = tpl("system:\n{system}", args);
   if (args.user) text += tpl("\nuser:\n{user}", args);
-  var res;
-  res = await lctx.text2run(text, {
-    stop: (((typeof args !== "undefined") && (args !== null) && !Number.isNaN(args) && (typeof args.stop !== "undefined") && (args.stop !== null) && !Number.isNaN(args.stop)) ? args.stop : (((typeof "assistant" !== "undefined") && ("assistant" !== null) && !Number.isNaN("assistant")) ? "assistant" : undefined))
-  });
-  if ((args.filename && (((typeof args !== "undefined") && (args !== null) && !Number.isNaN(args) && (typeof args.save !== "undefined") && (args.save !== null) && !Number.isNaN(args.save)) ? args.save : undefined))) {
-    var longFormatRegex;
-    longFormatRegex = /^(system|user|tool_call|tool_result|assistant|error):/;
-    await ctx.write(args.filename, text + "\n" + msg2text(res, longFormatRegex.test(text)));
-  }
   var response;
   response = (((typeof args !== "undefined") && (args !== null) && !Number.isNaN(args) && (typeof args.response !== "undefined") && (args.response !== null) && !Number.isNaN(args.response)) ? args.response : (((typeof "content" !== "undefined") && ("content" !== null) && !Number.isNaN("content")) ? "content" : undefined));
-  switch (response) {
-    case "content":
-      _ref = res["slice"](-1)[0].content;
-      break;
-    case "json":
-      _ref = JSON.parse(res["slice"](-1)[0].content);
-      break;
-    case "messages":
-      _ref = res;
-      break;
-    default:
+
+  function transformOutput(res) {
+    var _ref;
+    switch (response) {
+      case "content":
+        _ref = res["slice"](-1)[0].content;
+        break;
+      case "json":
+        _ref = JSON.parse(res["slice"](-1)[0].content);
+        break;
+      case "messages":
+        _ref = res;
+        break;
+      case "chat":
+        _ref = msg2text(res, true);
+        break;
+      default:
+        _ref = undefined;
+        throw new TuneError(tpl("Invalid response type '{}'", response));
+    }
+    return _ref;
+  }
+  transformOutput;
+  async function save() {
+    var longFormatRegex, _ref;
+    if ((args.filename && (((typeof args !== "undefined") && (args !== null) && !Number.isNaN(args) && (typeof args.save !== "undefined") && (args.save !== null) && !Number.isNaN(args.save)) ? args.save : undefined))) {
+      var longFormatRegex;
+      longFormatRegex = /^(system|user|tool_call|tool_result|assistant|error):/;
+      _ref = await ctx.write(args.filename, text + "\n" + msg2text(res, longFormatRegex.test(text)));
+    } else {
       _ref = undefined;
-      throw new TuneError(tpl("Invalid response type '{}'", response));
+    }
+    return _ref;
+  }
+  save;
+  if (!args.stream) {
+    var res;
+    res = await lctx.text2run(text, {
+      stop: stop
+    });
+    await save();
+    _ref = transformOutput(res);
+  } else {
+    r = await lctx.text2run(text, {
+      stop: stop,
+      stream: true
+    });
+    chunk = {};
+    itergQageqc = new AsyncIter();
+    (async function($lastRes) {
+      var _ref;
+      try {
+        while (!chunk.done) {
+          chunk = await r.next();
+          res = (chunk.value || "");
+          if (chunk.done) await save();
+          $lastRes = transformOutput(res) || $lastRes;
+          itergQageqc.result = {
+            value: $lastRes
+          }
+        }
+        _ref = itergQageqc.result = {
+          value: $lastRes,
+          done: true
+        }
+      } catch (e) {
+        _ref = (itergQageqc.err = e);
+      }
+      return _ref;
+    })();
+    _ref = itergQageqc;
   }
   return _ref;
 }
@@ -2414,4 +2477,5 @@ exports.text2payload = text2payload;
 exports.payload2http = payload2http;
 exports.envmd = envmd;
 exports.unescape = unescape;
-exports.escape = escape;
+exports.escape = escape;
+exports.resolve = resolve;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tune-sdk",
-  "version": "0.1.13",
-  "description": "tune - your everyday LLM toolkit.",
+  "version": "0.2.1",
+  "description": "tune - LLM chat in text file",
   "main": "dist/tune.js",
   "module": "dist/tune.mjs",
   "bin": "bin/cli.js",
@@ -12,6 +12,12 @@
     },
     "./fsctx": {
       "require": "./dist/fsctx.js"
+    },
+    "./cli": {
+      "require": "./dist/cli.js"
+    },
+    "./rpc": {
+      "require": "./dist/rpc.js"
     }
   },
   "keywords": [

package/tools/default.ctx.js

@@ -11,7 +11,6 @@ let dirs = [];
 if (process.env.TUNE_PATH) {
   dirs = process.env.TUNE_PATH.split(path.delimiter);
 }
-console.log(defaultWrite())
 
 module.exports = [
   curFile,

package/tools/yandex_tts.schema.json

@@ -0,0 +1,41 @@
+{
+  "description": "Fetch audio from Yandex's TTS",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "text": {
+        "type": "string",
+        "description": "Text input to convert to speech. + Set stress/accent e.g. 'h+ello'\nSpecify context-dependent pause: <[small]>, allowed: tiny, small, medium, large, huge\nHighlight emcented]> or **emphasized word**"
+      },
+      "voice": {
+        "type": "string",
+        "enum": [ "alena-neutral", "alena-good",
+  "filipp",
+  "ermil-neutral", "ermil-good",
+  "jane-neutral", "jane-good", "jane-evil",
+  "omazh-neutral", "omazh-evil",
+  "zahar-neutral", "zahar-good",
+  "dasha-neutral", "dasha-good", "dasha-friendly",
+  "julia-neutral", "julia-strict",
+  "lera-neutral", "lera-friendly",
+  "masha-good", "masha-strict", "masha-friendly",
+  "marina-neutral", "marina-whisper", "marina-friendly",
+  "alexander-neutral", "alexander-good",
+  "kirill-neutral", "kirill-strict", "kirill-good",
+  "anton-neutral", "anton-good",
+  "madi_ru",
+  "saule_ru-neutral", "saule_ru-strict", "saule_ru-whisper",
+  "zamira_ru-neutral", "zamira_ru-strict", "zamira_ru-friendly",
+  "zhanar_ru-neutral", "zhanar_ru-strict", "zhanar_ru-friendly",
+  "yulduz_ru-neutral", "yulduz_ru-strict", "yulduz_ru-friendly", "yulduz_ru-whisper"
+],
+        "description": "Voice type to use for TTS"
+      },
+      "filename": {
+        "type": "string",
+        "description": "wav filename to save the audio to"
+      }
+    },
+    "required": ["text", "voice", "filename"]
+  }
+}

package/tools/yandex_tts.tool.mjs

@@ -0,0 +1,31 @@
+import fs from 'fs';
+export default async function yandexTTS({ text, voice, filename }, ctx) {
+  const key = await ctx.read("YC_TOKEN");
+  const folderId = await ctx.read("YC_FOLDER_ID")
+  const [v, r] = voice.split("-")
+  const hints = [{ voice: v}]
+  if (r) {
+    hints.push({ role: r})
+  }
+  const response = await fetch("https://tts.api.cloud.yandex.net/tts/v3/utteranceSynthesis", {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${key}`,
+      "x-folder-id": folderId,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      text,
+      hints
+    }),
+  });
+
+
+  if (!response.ok) {
+    const { error } = await response.json()
+    throw new Error(`Error: ${response.status} ${response.statusText}\n${error.message}`);
+  }
+  const result =  await response.json()
+  await ctx.write(filename, Buffer.from(result.result.audioChunk.data, 'base64'));
+  return "speech generated"
+}