tune-sdk 0.1.11 → 0.1.13

package/bin/cli.js

@@ -1,115 +1,133 @@
-#!/usr/bin/env node
+var tune, rpc;
 
-// Minimal inline argument parser
-const args = {};
-let currentKey = null;
-
-process.argv.slice(2).forEach(arg => {
-  if (arg.startsWith('--')) {
-    const [key, value] = arg.substring(2).split('=');
-    if (typeof value !== 'undefined') {
-      args[key] = value;
-      currentKey = null;
+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 {
-      currentKey = key;
-      args[currentKey] = true
+      res1[key] = value;
     }
-  } else if (currentKey) {
-    args[currentKey] = arg;
-    currentKey = null;
   }
-});
-
-const tune = require('../dist/tune.js');
-const { fsctx } = require('../dist/fsctx.js');
-const fs = require("fs"); 
-const path = require("path");
-
+  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() {
-  try {
-    let chat = ""
-    // where to search for inclusions
-    let dirs = [];
-
-    if (args.filename && fs.existsSync(args.filename)) {
-      chat = fs.readFileSync(args.filename, "utf8")
-      dirs.push(path.dirname(path.resolve(args.filename)))
-    }
-
-    if (!chat && args.system) {
-      chat = `system:\n${args.system}`
-    }
-
-    if (args.user) {
-      chat = `${chat}\nuser:\n${args.user}`
-    }
-
-    if(process.env.TUNE_PATH) {
-      dirs = dirs.concat(process.env.TUNE_PATH.split(path.delimiter))
-    }
-
-    dirs.push(process.cwd())
-
-    const ctx = tune.makeContext(process.env)
-    if (args.filename) {
-      ctx.stack.push({ 
-        filename: args.filename,
-        name: path.basename(args.filename),
-        dirname: path.dirname(path.resolve(args.filename))
-      })
+  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;
     }
-    ctx.use(fsctx(dirs))
-
-    for (const dir of dirs) {
-      let filename = ["default.ctx.js", "default.ctx.cjs", "default.ctx.mjs"].find(name  => fs.existsSync(path.join(dir, name)));
-      if (!filename) continue;
-      filename = path.join(dir, filename);
-      let ext = path.extname(filename);
-      let module
-      if ((ext === ".js" || ext === ".cjs")) {
-        module = require(filename);
-      } else {
-        module = await import(filename);
-        module = module.default;
-      }
-      if (typeof module === "function") {
-        ctx.use(module);
-      } else if (Array.isArray(module)) {
-        for (const m of module) {
-          if (typeof m === "function") {
-            ctx.use(m)
-          } else {
-            throw(Error(`err: Context file export is not an array of functions or function ${filename}`))
-          }
+    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));
         }
-      } else {
-        throw(Error(`err: Context file export is not an array of functions or function ${filename}`))
+        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));
     }
-    let stopVal = args.stop || "assistant";
-    if (stopVal !== "step" && stopVal != "assistant") {
-      stopVal = function(msgs) {
-        if (!msgs.length) return false
-        const lastMsg = msgs[msgs.length - 1]
-        if (!lastMsg.content) return false
-        return (lastMsg.content.indexOf(args.stop) !== -1)
-      }
-    }
-
-    let res = await tune.text2run(chat, ctx, { stop: stopVal })
-
-    const longFormatRegex = /^(system|user|tool_call|tool_result|assistant|error):/;
-    res = tune.msg2text(res, longFormatRegex.test(chat))
-    if (args.filename && args.save) {
-      chat += "\n" + res 
-      fs.writeFileSync(args.filename, chat)
-    }
-    if (!args.save) {
-      console.log(res)
-    }
-  } catch (e) {
-    console.error(e)
+    if (typeof _ref0 !== 'undefined') _res.push(_ref0);
   }
+  return _res;
 }
-
-main()
+main;
+exports.parseArgs = parseArgs;
+exports.rpc = rpc;
+exports.main = main;
+exports.run = run;

package/dist/fsctx.js

@@ -1,4 +1,4 @@
-var path, tune, envmd, TuneError, text2run, file2run;
+var path, tune, fs, envmd, TuneError, text2run, file2run;
 
 function extend() {
   var _i;
@@ -616,6 +616,7 @@ if (typeof window !== "undefined") {
 }
 path = require("path");
 tune = require("./tune");
+fs = require("fs");
 envmd = tune.envmd;
 TuneError = tune.TuneError;
 text2run = tune.text2run;
@@ -1062,6 +1063,53 @@ function fsMix(paths, opts, fs) {
   });
 }
 fsMix;
+async function curFile(name, params) {
+  var filename, value, _ref;
+  if ((!this.stack || !this.stack.length)) return;
+  filename = this.stack[0].filename;
+  switch (name) {
+    case "__filename":
+      _ref = filename;
+      break;
+    case "__dirname":
+      _ref = path.dirname(filename);
+      break;
+    case "__basename":
+      _ref = path.basename(filename);
+      break;
+    case "__name":
+      _ref = path.parse(filename).name;
+      break;
+    case "__ext":
+      _ref = path.parse(filename).ext;
+      break;
+    default:
+      _ref = undefined;
+  }
+  value = _ref;
+  return (value ? {
+    type: "text",
+    read: (async function() {
+      return value;
+    })
+  } : undefined);
+}
+curFile;
+
+function defaultWrite(opts) {
+  async function write(filename, data) {
+    var directory;
+    var directory;
+    directory = path.dirname(filename);
+    fs.mkdirSync(directory, {
+      recursive: true
+    });
+    fs.writeFileSync(filename, data);
+    return true;
+  }
+  return write;
+}
+defaultWrite;
 
 function tpl(str) {
   var _i;
@@ -1086,4 +1134,6 @@ exports.runFile = runFile;
 exports.fsMix = fsMix;
 exports.fsMod = fsMod;
 exports.fsText = fsText;
+exports.defaultWrite = defaultWrite;
+exports.curFile = curFile;
 exports.pparse = pparse;

package/dist/rpc.js

@@ -0,0 +1,211 @@
+function AsyncIter() {
+  return (this[Symbol.asyncIterator] = this);
+}
+AsyncIter;
+AsyncIter.prototype.next = (async function() {
+  var self, result;
+  var self;
+  self = this;
+  await _once((function() {
+    return (!!self.err || !!self.result);
+  }), (function() {
+    return undefined;
+  }));
+  var result;
+  result = self.result;
+  self.result = undefined;
+  if (self.err) throw self.err;
+  return result;
+});
+
+function jsonrpc(params, exports) {
+  var client;
+  var client;
+  client = new JSONRPC(params, exports);
+  return new Proxy({}, {
+    get: (function(target, prop, receiver) {
+      return (function(params, stream) {
+        return client._call(prop, params, stream);
+      });
+    }),
+    set: (function(obj, prop, value) {
+      return (client[prop] = value);
+    })
+  });
+}
+jsonrpc;
+
+function concatU8A(u8arrays) {
+  var totalLen, res, offset, arr, _i, _ref, _len;
+  var totalLen;
+  var res;
+  var offset;
+  totalLen = u8arrays.reduce((function(acc, arr) {
+    return (acc + arr.length);
+  }), 0);
+  res = new Uint8Array(totalLen);
+  offset = 0;
+  _ref = u8arrays;
+  for (_i = 0, _len = _ref.length; _i < _len; ++_i) {
+    arr = _ref[_i];
+    res.set(arr, offset);
+    offset = offset + arr.length;
+  }
+  return res;
+}
+concatU8A;
+
+function JSONRPC(params, exports) {
+  var self;
+  this.msgId = 1;
+  this.chunks = [];
+  this.debug = params.debug;
+  this.name = params.name;
+  this.exports = exports || params.exports || {}
+  this.callbacks = {};
+  this.iterators = {};
+  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");
+  async function pump() {
+    var res, value, done, buf, newlineIdx, line, msg, cb, iter, err, m, r, chunk, _res, _ref, _ref0;
+    var res;
+    res = await self.reader.read();
+    var value;
+    var done;
+    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))) {
+      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);
+      var msg;
+      msg = JSON.parse(line);
+      if (!msg.id) {
+        console.log("message has no id, skipping", msg);
+        continue;
+      }
+      var cb;
+      var iter;
+      cb = self.callbacks[msg.id];
+      iter = self.iterators[msg.id];
+      if (((cb || iter) && (((typeof msg !== 'undefined') && (typeof msg.result !== 'undefined')) || msg.error))) {
+        if ((cb && ((typeof msg !== 'undefined') && (typeof msg.result !== 'undefined')))) {
+          cb.resolve(msg.result);
+        } else if (iter && ((typeof msg !== 'undefined') && (typeof msg.result !== 'undefined'))) {
+          iter.result = {
+            value: msg.result
+          };
+          if (msg.done) {
+            iter.result.done = true;
+            delete self.iterators[msg.id];
+          }
+        } else if (cb && msg.error) {
+          var err;
+          err = new Error(msg.error.message);
+          err.stack = msg.error.stack;
+          cb.reject(err);
+        } else if (iter && msg.error) {
+          iter.err = new Error(msg.error.message);
+          iter.err.stack = msg.error.stack;
+        }
+        if (cb) delete self.callbacks[msg.id];
+      } else if (msg.method) {
+        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);
+          }
+          _ref0;
+        } catch (e) {
+          self._error(m.id, e.message, e.stack);
+        }
+      }
+    }
+    return pump();
+  }
+  pump;
+  pump();
+  return this;
+}
+JSONRPC;
+JSONRPC.prototype._write = (async function(payload) {
+  var encoder, data;
+  var encoder;
+  var data;
+  encoder = new TextEncoder();
+  data = encoder.encode(JSON.stringify(payload) + "\n");
+  return await this.writer.write(data);
+});
+JSONRPC.prototype._error = (function(msgId, message, stack) {
+  return this._write({
+    jsonrpc: "2.0",
+    id: msgId,
+    error: {
+      message: message,
+      stack: stack
+    }
+  });
+});
+JSONRPC.prototype._result = (function(msgId, result, done) {
+  return (function(self, payload) {
+    if (done) payload.done = true;
+    return self._write(payload);
+  })(this, {
+    jsonrpc: "2.0",
+    id: msgId,
+    result: ((typeof result !== 'undefined') ? result : null)
+  });
+});
+JSONRPC.prototype._call = (async function(method, params, stream) {
+  var self, msgId;
+  var self;
+  var msgId;
+  self = this;
+  msgId = self.msgId;
+  self.msgId++;
+  self._write({
+    jsonrpc: "2.0",
+    id: msgId,
+    method: method,
+    params: params,
+    stream: stream
+  });
+  if (!stream) return new Promise((function(resolve, reject) {
+    return (self.callbacks[msgId] = {
+      resolve: resolve,
+      reject: reject
+    });
+  }));
+  return (self.iterators[msgId] = new AsyncIter());
+});
+exports.jsonrpc = jsonrpc;

package/dist/tune.js

@@ -2099,12 +2099,12 @@ function text2run(text, ctx, opts) {
 }
 text2run;
 async function file2run(args, params, ctx) {
-  var lctx, text, node, res, longFormatRegex, response, _ref;
+  var lctx, uext, node, text, res, longFormatRegex, response, _ref;
   var lctx;
   lctx = ctx.clone();
   lctx.ms.unshift(envmd(params));
-  var text;
-  text = "";
+  var uext;
+  uext = "";
   if (args.filename) {
     node = await ctx.resolve(args.filename);
     if (node) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tune-sdk",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "tune - your everyday LLM toolkit.",
   "main": "dist/tune.js",
   "module": "dist/tune.mjs",
@@ -9,6 +9,9 @@
     ".": {
       "require": "./dist/tune.js",
       "import": "./dist/tune.mjs"
+    },
+    "./fsctx": {
+      "require": "./dist/fsctx.js"
     }
   },
   "keywords": [

package/tools/default.ctx.js

@@ -1,51 +1,20 @@
 const fs = require('fs') 
 const path = require('path')
 
-const { runFile, fsMix } = require("../dist/fsctx.js");
+const { curFile, fsMix, defaultWrite } = require("../dist/fsctx.js");
+const { file2run, makeContext } = require("../dist/tune.js");
 
 async function makeSchema(params, ctx) {
-  return runFile(path.join(__dirname, "schema.tool.chat"), ctx, params);
+  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);
 }
-
+console.log(defaultWrite())
 
 module.exports = [
-  async function filename(name, params) {
-    if (!this.stack || !this.stack.length) {
-      return
-    }
-    const { filename } = this.stack[0];
-    let value
-    switch(name) {
-      case "__filename": 
-        value = filename
-        break
-      case "__dirname":
-        value = path.dirname(filename)
-        break
-      case "__basename":
-        value = path.basename(filename)
-        break
-      case "__name":
-        value = path.parse(filename).name
-        break
-      case "__ext":
-        value = path.parse(filename).ext
-        break
-      default:
-        break
-    }
-    if (value) {
-      return {
-        type: "text",
-        read: async () => value
-      }
-    }
-    return
-  },
+  curFile,
   fsMix(dirs, { makeSchema }),
   require("./openai.ctx.js"),
   require("./openrouter.ctx.js"),
@@ -53,9 +22,5 @@ module.exports = [
   require("./gemini.ctx.js"),
   require("./mistral.ctx.js"),
   require("./groq.ctx.js"),
-  async function write(filename, data) {
-    const directory = path.dirname(filename);
-    fs.mkdirSync(directory, { recursive: true });
-    fs.writeFileSync(filename, data)
-  }
-];
+  defaultWrite()
+]

package/tools/groq_whisper.schema.json

@@ -0,0 +1,48 @@
+{
+  "description": "Transcribe audio using Groq Whisper API",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "file": {
+        "type": "string",
+        "description": "Path to the audio file to transcribe"
+      },
+      "url": {
+        "type": "string",
+        "description": "URL of the audio file to transcribe"
+      },
+      "model": {
+        "type": "string",
+        "description": "Model to use for transcription",
+        "default": "whisper-large-v3-turbo"
+      },
+      "language": {
+        "type": "string",
+        "description": "Language spoken in the audio"
+      },
+      "text": {
+        "type": "string",
+        "description": "Optional text prompt to guide transcription"
+      },
+      "response_format": {
+        "type": "string",
+        "description": "Format of the transcription response",
+        "enum": ["json", "verbose_json", "text"],
+        "default": "json"
+      },
+      "temperature": {
+        "type": "number",
+        "description": "Sampling temperature for transcription",
+        "default": 0
+      },
+      "timestamp_granularities": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        },
+        "description": "Timestamp granularities to include if response_format is verbose_json",
+        "default": ["segment"]
+      }
+    }
+  }
+}

package/tools/groq_whisper.tool.mjs

@@ -0,0 +1,59 @@
+import fs from 'fs';
+
+export default async function groqWhisper({ 
+  file, 
+  url, 
+  model = "whisper-large-v3-turbo", 
+  language, 
+  text, 
+  response_format = "json", 
+  temperature = 0,
+  timestamp_granularities = ["segment"]
+}, ctx) {
+  const key = await ctx.read("GROQ_KEY");
+  
+  const formData = new FormData();
+  
+  // Add file or url
+  if (file) {
+    if (!fs.existsSync(file)) {
+        return "file not found"
+    }
+    const fileBlob = await fs.openAsBlob(file);
+    formData.append('file', fileBlob, file);
+  } else if (url) {
+    formData.append('url', url);
+  } else {
+    throw new Error('Either file or url parameter is required');
+  }
+  
+  // Add required model
+  formData.append('model', model);
+  
+  // Add optional parameters
+  if (language) formData.append('language', language);
+  if (text) formData.append('prompt', text);
+  if (response_format) formData.append('response_format', response_format);
+  if (temperature !== undefined) formData.append('temperature', temperature.toString());
+  if (timestamp_granularities && response_format === 'verbose_json') {
+    timestamp_granularities.forEach(granularity => {
+      formData.append('timestamp_granularities[]', granularity);
+    });
+  }
+
+  const response = await fetch("https://api.groq.com/openai/v1/audio/transcriptions", {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${key}`,
+    },
+    body: formData,
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Error: ${response.status} ${response.statusText}\n${errorText}`);
+  }
+  
+  const result = await response.json();
+  return result;
+}

package/tools/openai_stt.schema.json

@@ -0,0 +1,49 @@
+{
+  "description": "Convert audio file to text using OpenAI's transcription API with advanced options",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "file": {
+        "type": "string",
+        "description": "Path or identifier of the audio file to transcribe"
+      },
+      "model": {
+        "type": "string",
+        "description": "Model to use for transcription",
+        "default": "gpt-4o-transcribe"
+      },
+      "language": {
+        "type": "string",
+        "description": "Language spoken in the audio, optional"
+      },
+      "prompt": {
+        "type": "string",
+        "description": "Prompt to guide transcription, optional"
+      },
+      "response_format": {
+        "type": "string",
+        "enum": ["json", "verbose_json", "text"],
+        "description": "Format of the transcription response",
+        "default": "json"
+      },
+      "temperature": {
+        "type": "number",
+        "description": "Sampling temperature for transcription",
+        "default": 0
+      },
+      "timestamp_granularities": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        },
+        "description": "Timestamp granularities for detailed transcription, supported only for whisper-1 model with verbose_json response_format"
+      },
+      "stream": {
+        "type": "boolean",
+        "description": "Whether to return a streaming response",
+        "default": false
+      }
+    },
+    "required": ["file"]
+  }
+}

package/tools/openai_stt.tool.mjs

@@ -0,0 +1,66 @@
+import fs from 'fs';
+
+export default async function openaiSTT({ 
+  file, 
+  model = "gpt-4o-transcribe", 
+  language, 
+  prompt, 
+  response_format = "json", 
+  temperature = 0,
+  timestamp_granularities,
+  stream = false
+}, ctx) {
+  const key = await ctx.read("OPENAI_KEY");
+  
+  if (!file) {
+    throw new Error('File parameter is required');
+  }
+  
+  const formData = new FormData();
+  
+  // Add file
+  const fileBlob = await fs.openAsBlob(file);
+  formData.append('file', fileBlob, file);
+  
+  // Add required model
+  formData.append('model', model);
+  
+  // Add optional parameters
+  if (language) formData.append('language', language);
+  if (prompt) formData.append('prompt', prompt);
+  if (response_format) formData.append('response_format', response_format);
+  if (temperature !== undefined) formData.append('temperature', temperature.toString());
+  if (stream) formData.append('stream', stream.toString());
+  
+  // Timestamp granularities (only supported for whisper-1 with verbose_json)
+  if (timestamp_granularities && model === 'whisper-1' && response_format === 'verbose_json') {
+    timestamp_granularities.forEach(granularity => {
+      formData.append('timestamp_granularities[]', granularity);
+    });
+  }
+
+  const response = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${key}`,
+    },
+    body: formData,
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Error: ${response.status} ${response.statusText}\n${errorText}`);
+  }
+  
+  if (stream) {
+    // For streaming responses, return the response stream
+    return response.body;
+  } else {
+    // For non-streaming responses, parse JSON or return text based on response_format
+    if (response_format === 'text') {
+      return await response.text();
+    } else {
+      return await response.json();
+    }
+  }
+}