tune-sdk 0.2.4 → 0.2.5

package/tools/openai_imgen.tool.mjs

@@ -1,83 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-
-export default async function openaiImgen({ text, filename, images, quality, size }, ctx) {
-  const key = await ctx.read('OPENAI_KEY');
-  let body;
-  let headers = {
-    'Authorization': `Bearer ${key}`
-  };
-  let apiUrl;
-  switch(size) {
-    case "square":
-      size = "1024x1024";
-      break;
-    case "landscape":
-      size = "1536x1024";
-      break;
-    case "portrait":
-      size = "1024x1536";
-      break;
-  }
-
-  // If images exist and length > 0, use FormData and the edits endpoint
-  if (images && images.length > 0) {
-    apiUrl = 'https://api.openai.com/v1/images/edits';
-    const formData = new FormData();
-    formData.append('model', 'gpt-image-1');
-    formData.append('prompt', text);
-    formData.append('quality', quality || "auto");
-
-
-    // For each image, read its contents and attach it to the form
-    for (let i = 0; i < images.length; i++) {
-      const imageContent = await ctx.read(images[i]);
-      // Attach image content with the filename
-      const ext = path.extname(images[i])
-      let mimeType = 'application/octet-stream'
-      switch (ext) {
-        case ".png":
-          mimeType = "image/png";
-          break;
-        case ".jpg":
-          mimeType = "image/jpeg";
-          break
-        case ".webp":
-          mimeType = "image/webp";
-          break
-
-      }
-      formData.append('image', new Blob([imageContent], { type: mimeType }), images[i]);
-    }
-    body = formData;
-    // Note: Do not manually set the Content-Type header. FormData will handle it.
-  } else {
-    // No images provided: use JSON payload and the generations endpoint
-    apiUrl = 'https://api.openai.com/v1/images/generations';
-    body = JSON.stringify({
-      model: 'gpt-image-1',
-      prompt: text,
-      quality: quality || "auto",
-      size: size || "auto"
-    });
-    headers['Content-Type'] = 'application/json';
-  }
-
-  const response = await fetch(apiUrl, {
-    method: 'POST',
-    headers,
-    body
-  });
-
-  if (!response.ok) {
-    const { error } = await response.json();
-    throw new Error(`Error: ${response.status} ${response.statusText}\n${error.message}`);
-  }
-
-  const res = await response.json();
-
-  // Assuming the API returns the image data in a b64_json field
-  const data = res.data[0].b64_json;
-  await ctx.write(filename, Buffer.from(data, 'base64'));
-  return 'image generated';
-}

package/tools/openai_stt.schema.json

@@ -1,49 +0,0 @@
-{
-  "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

@@ -1,66 +0,0 @@
-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();
-    }
-  }
-}

package/tools/openai_tts.schema.json

@@ -1,26 +0,0 @@
-{
-  "description": "Fetch audio from OpenAI's TTS",
-  "parameters": {
-    "type": "object",
-    "properties": {
-      "text": {
-        "type": "string",
-        "description": "Text input to convert to speech"
-      },
-      "voice": {
-        "type": "string",
-        "enum": ["alloy", "echo", "fable", "onyx", "nova", "shimmer"],
-        "description": "Voice type to use for TTS"
-      },
-      "filename": {
-        "type": "string",
-        "description": "mp3 filename to save the audio to"
-      },
-      "instructions": {
-        "type": "string",
-        "description": "describe a way to create a speech, example:\n voice: Warm, relaxed, and friendly, with a steady cowboy drawl that feels approachable.\n\nPunctuation: Light and natural, with gentle pauses that create a conversational rhythm without feeling rushed.\n\nDelivery: Smooth and easygoing, with a laid-back pace that reassures the listener while keeping things clear.\n\nPhrasing: Simple, direct, and folksy, using casual, familiar language to make technical support feel more personable.\n\nTone: Lighthearted and welcoming, with a calm confidence that puts the caller at ease."
-      }
-    },
-    "required": ["text", "voice", "filename"]
-  }
-}

package/tools/openai_tts.tool.mjs

@@ -1,26 +0,0 @@
-import fs from 'fs';
-export default async function openaiTTS({ text, voice, instructions, filename }, ctx) {
-  const key = await ctx.read("OPENAI_KEY");
-  const response = await fetch("https://api.openai.com/v1/audio/speech", {
-    method: "POST",
-    headers: {
-      "Authorization": `Bearer ${key}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({
-      "model": "gpt-4o-mini-tts",
-      input: text,
-      instructions,
-      voice: voice
-    }),
-  });
-
-
-  if (!response.ok) {
-    const { error } = await response.json()
-    throw new Error(`Error: ${response.status} ${response.statusText}\n${error.message}`);
-  }
-  const buf = await response.arrayBuffer();
-  await ctx.write(filename, Buffer.from(buf));
-  return "speech generated"
-}

package/tools/osa.schema.json

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

package/tools/osa.tool.mjs

@@ -1,12 +0,0 @@
-import { execSync } from 'node:child_process';
-import util from 'node:util'
-
-export default async function osa({ text }) {
-  let result = ""
-  try {
-    result = execSync("osascript -", { input: text, encoding: "utf8" })
-  } catch (e) {
-    result = e.stderr + e.stdout
-  }
-  return (result || "").replaceAll("@", "\\@");
-}

package/tools/package.json

@@ -1,7 +0,0 @@
-{
-  "dependencies": {
-    "escodegen": "^2.1.0",
-    "esprima": "^4.0.1",
-    "mime-types": "^3.0.1"
-  }
-}

package/tools/patch.schema.json

@@ -1,17 +0,0 @@
-{
-  "description": "Apply patches to a specified file based on the given text",
-  "parameters": {
-    "type": "object",
-    "properties": {
-      "text": {
-        "type": "string",
-        "description": "The text containing patches to apply, formated:\n```\n<<<<<<< ORIGINAL\nold code\n=======\nnew code\n>>>>>>> UPDATED\n```"
-      },
-      "filename": {
-        "type": "string",
-        "description": "The path to the file that needs to be patched."
-      }
-    },
-    "required": ["text", "filename"]
-  }
-}

package/tools/patch.tool.mjs

@@ -1,38 +0,0 @@
-import fs from "node:fs/promises";
-
-// Patch tool to apply custom diffs marked with <<<<<<< ORIGINAL and >>>>>>> UPDATED
-// Handles patches with context and applies only the segments between markers.
-
-export default async function patch({ text, filename }, ctx) {
-  // Regex to match each patch block
-  const patchRegex = /<<<<<<< ORIGINAL[^\n]*\n([\s\S]*?)=======\n([\s\S]*?)>>>>>>> UPDATED[^\n]*(?:\n|$)/g;
-  const patches = [];
-  let match;
-
-  // Extract all old/new segments
-  while ((match = patchRegex.exec(text)) !== null) {
-    const oldPart = match[1].replace(/^\n+|\n+$/g, "");
-    const newPart = match[2].replace(/^\n+|\n+$/g, "");
-    patches.push({ oldPart, newPart });
-  }
-
-  if (patches.length === 0) {
-    throw new Error("No valid patch segments found");
-  }
-
-  let fileContent = await ctx.read(filename);
-
-  for (const { oldPart, newPart } of patches) {
-    // Escape regex special chars in oldPart, then allow flexible whitespace
-    const escaped = oldPart
-      .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-      .replace(/\s+/g, "\\s+");
-    const oldRegex = new RegExp(escaped, "g");
-
-    // Perform replacement using a function to avoid replacement string ambiguities
-    fileContent = fileContent.replace(oldRegex, () => newPart);
-  }
-
-  await ctx.write(filename, fileContent);
-  return "patched";
-}

package/tools/prop.proc.mjs

@@ -1,34 +0,0 @@
-function parseVal(value) {
-  try {
-    return JSON.parse(value)
-  } catch (e) { }
-  return value
-}
-export default async function prop(node, args, ctx) {
-  if (!node || node.type !== 'llm') {
-    return node
-  }
-
-  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] = parseVal(text.slice(0, m.index).trim())
-    }
-    text = text.slice(m.index + m[0].length)
-    lastName = name
-  }
-
-  if (lastName) {
-    vars[lastName] = parseVal(text.trim())
-  }
-  return {
-    ...node,
-    exec: async (payload, ctx) => node.exec({ ...payload, ...vars }, ctx)
-  }
-}

package/tools/py.schema.json

@@ -1,17 +0,0 @@
- {
-  "description": "Execute Python code using a Node.js child process",
-  "parameters": {
-    "type": "object",
-    "properties": {
-      "text": {
-        "type": "string",
-        "description": "The Python code to execute"
-      },
-      "filename": {
-        "type": "string",
-        "description": "filename to save script to"
-      }
-    },
-    "required": ["text"]
-  }
-}

package/tools/py.tool.py

@@ -1,22 +0,0 @@
-import ast
-import sys
-
-def main(params):
-    if 'filename' in params:
-        with open(params['filename'], 'w') as file:
-            file.write(params['text'])
-
-    parsed = ast.parse(params['text'])
-    last_stmt = parsed.body[-1]
-    if isinstance(last_stmt, ast.Expr):
-        parsed.body[-1] = ast.Assign(
-                targets=[ast.Name(id='myvariable', ctx=ast.Store())],
-                value=last_stmt.value)
-
-    ast.fix_missing_locations(parsed)
-    compiled = compile(parsed, filename="cell.py", mode="exec")
-    namespace = {}
-    exec(compiled, namespace)
-
-    return namespace.get('myvariable', None) 
-    

package/tools/queryimage.schema.json

@@ -1,17 +0,0 @@
-{
-  "description": "Answer questions based on the provided image",
-  "parameters": {
-    "type": "object",
-    "properties": {
-      "filename": {
-        "type": "string",
-        "description": "filename of the image"
-      },
-      "text": {
-        "type": "string",
-        "description": "Question to ask about the image"
-      }
-    },
-    "required": ["filename", "text"]
-  }
-}

package/tools/queryimage.tool.chat

@@ -1,4 +0,0 @@
-s: @mistral-small-latest
-You help answer questions about an image
-u: @{ filename | resolve }
-@text

package/tools/resolve.proc.js

@@ -1,10 +0,0 @@
-module.exports = async function resolve(node, args, ctx) {
-  if (!node) {
-    return
-  }
-  if (node.type !== "text") {
-    throw Error(`can resolve only text nodes, got ${node.type}`)
-  }
-  const filename = await node.read()
-  return ctx.resolve(filename.trim())
-}

package/tools/rf.schema.json

@@ -1,17 +0,0 @@
-{
-  "description": "Read the contents of a specified file",
-  "parameters": {
-    "type": "object",
-    "properties": {
-      "filename": {
-        "type": "string",
-        "description": "The name of the file to read"
-      },
-      "linenum": {
-        "type": "boolean",
-        "description": "prepend every line with linenumber"
-      }
-    },
-    "required": ["filename"]
-  }
-}

package/tools/rf.tool.mjs

@@ -1,21 +0,0 @@
-import { relative, dirname } from 'path' 
-
-export default async function readFile({ filename, linenum }, ctx) {
-  const resolved = await ctx.resolve(filename)
-  if (!resolved) {
-    return "File not found"
-  }
-  const relFile = relative(process.cwd(), filename)
-  const path = [ relFile ]
-  if (resolved.type !== 'text') {
-    path.push('text')
-  }
-  if (linenum) {
-    path.push('linenum')
-  }
-  if (path.length > 1) {
-    return`@\{ ${path.join(" | ")} \}`;
-  }
-  return `@${relFile}`;
-
-}

package/tools/schema.schema.json

@@ -1,13 +0,0 @@
-{
-  "description": "generate tool schema file based on source content",
-  "parameters": {
-    "type": "object",
-    "properties": {
-      "text": {
-        "type": "string",
-        "description": "content of a script for the schema"
-      }
-    },
-    "required": ["text"]
-  }
-}

package/tools/schema.tool.chat

@@ -1,81 +0,0 @@
-s: @{ gpt-4.1-mini | prop response_format={ "type": "json_object" \} }
-You're given chat with \@expansion variables or code or http request provide schema for it
-Your output json schema for tool calling like:
-```json
-{
-  "description": "Calculate number result based on user input",
-  "parameters": {
-    "type": "object",
-    "properties": {
-      "text": {
-        "type": "string",
-        "description": "math expression to calculate"
-      }
-    },
-    "required": ["text"]
-  }
-}
-```
-u: 
- s: You're calculator
- u: \@text
-a: {
-  "description": "Calculate number result based on user input",
-  "parameters": {
-    "type": "object",
-    "properties": {
-      "text": {
-        "type": "string",
-        "description": "math expression to calculate"
-      }
-    },
-    "required": ["text"]
-  }
-}
-u: get_weather({ location }, ctx)
-a: 
-{
-  "description": "Get the current weather in a given location",
-   "parameters": {
-      "type": "object",
-      "properties": {
-         "location": {
-           "type": "string",
-           "description": "The city and state, e.g. San Francisco, CA"
-          }
-       },
-       "required": ["location"]
-    }
-}
-u: 
-{
-  url: "https://api.openai.com/v1/audio/transcription",
-  method: "POST",
-  headers: { 
-    content-type: "multiform/form-data",
-    authorization: "Bearer ${openai_secret}" 
-  },
-  body: { 
-    file: {audio},
-    model: "whisper1",
-    response_format: "text"
-  }
-}
-a: {
-  "description": "transcribe audio",
-  "parameters": {
-    "type": "object",
-    "properties": {
-      "audio": {
-        "type": "buffer",
-        "description": "audio file to transcribe"
-      },
-      "openai_secret": {
-        "type": "string",
-        "description": "openai secret"
-      }
-    },
-    "required": ["audio", "openai_secret"]
-  }
-}
-u: @text

package/tools/sh.schema.json

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

package/tools/sh.tool.mjs

@@ -1,12 +0,0 @@
-import { execSync } from 'node:child_process';
-import util from 'node:util'
-
-export default async function sh({ text }) {
-  let result = ""
-  try {
-    result =  execSync(text, { encoding: "utf8" })
-  } catch (e) {
-    result = e.stderr + e.stdout
-  }
-  return (result || "").replaceAll("@", "\\@");
-}

package/tools/short.txt

@@ -1 +0,0 @@
-be short and precise, down to the point

package/tools/shp.proc.mjs

@@ -1,31 +0,0 @@
-import { execSync, spawnSync } from 'node:child_process';
-
-const shp = async (node, args, ctx) => ({
-  type: 'text',
-  read: async () => {
-    let input = null;
-
-    if (node && node.type === 'text') {
-      input = await node.read();
-    }
-
-    let result;
-    try {
-      if (input !== null) {
-        const res = spawnSync(args.trim(), {
-          input,
-          encoding: 'utf8',
-          shell: true
-        });
-        result = (res.stdout || '') + (res.stderr || '');
-      } else {
-        result = execSync(args.trim(), { encoding: 'utf8' });
-      }
-    } catch (e) {
-      result = e.stderr + e.stdout;
-    }
-    return result.replaceAll('@', '\\@');
-  }
-});
-
-export default shp;