@elisym/sdk 0.12.4 → 0.13.0

package/dist/skills.cjs

@@ -2,8 +2,9 @@
 
 var child_process = require('child_process');
 var string_decoder = require('string_decoder');
-var fs = require('fs');
+var promises = require('fs/promises');
 var path = require('path');
+var fs = require('fs');
 var YAML = require('yaml');
 var Decimal = require('decimal.js-light');
 
@@ -29,9 +30,9 @@ function sleepWithSignal(ms, signal) {
     return Promise.reject(createAbortError());
   }
   if (!signal) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
   }
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const cleanup = () => {
       clearTimeout(timer);
       signal.removeEventListener("abort", onAbort);
@@ -42,7 +43,7 @@ function sleepWithSignal(ms, signal) {
     };
     const timer = setTimeout(() => {
       cleanup();
-      resolve();
+      resolve2();
     }, ms);
     signal.addEventListener("abort", onAbort, { once: true });
   });
@@ -309,14 +310,62 @@ function createLlmClient(config) {
   }
   return createAnthropicClient(config);
 }
-var MAX_TOOL_OUTPUT = 1e6;
-var TOOL_TIMEOUT_MS = 6e4;
+var MAX_SCRIPT_OUTPUT = 1e6;
+var DEFAULT_SCRIPT_TIMEOUT_MS = 6e4;
+function runScript(cmd, args, opts) {
+  return new Promise((resolveResult) => {
+    const maxOutput = opts.maxOutput ?? MAX_SCRIPT_OUTPUT;
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_SCRIPT_TIMEOUT_MS;
+    const child = child_process.spawn(cmd, args, {
+      cwd: opts.cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: timeoutMs,
+      killSignal: "SIGKILL",
+      signal: opts.signal
+    });
+    let stdout = "";
+    let stderr = "";
+    const stdoutDecoder = new string_decoder.StringDecoder("utf8");
+    const stderrDecoder = new string_decoder.StringDecoder("utf8");
+    child.stdout?.on("data", (data) => {
+      if (stdout.length < maxOutput) {
+        stdout += stdoutDecoder.write(data);
+        if (stdout.length > maxOutput) {
+          stdout = stdout.slice(0, maxOutput);
+        }
+      }
+    });
+    child.stderr?.on("data", (data) => {
+      if (stderr.length < maxOutput) {
+        stderr += stderrDecoder.write(data);
+        if (stderr.length > maxOutput) {
+          stderr = stderr.slice(0, maxOutput);
+        }
+      }
+    });
+    child.on("close", (code) => {
+      stdout += stdoutDecoder.end();
+      stderr += stderrDecoder.end();
+      resolveResult({ stdout, stderr, code });
+    });
+    child.on("error", (err) => {
+      resolveResult({ stdout, stderr, code: null, spawnError: err });
+    });
+    if (child.stdin) {
+      child.stdin.on("error", () => {
+      });
+      child.stdin.end(opts.stdin ?? "");
+    }
+  });
+}
 var ScriptSkill = class {
   name;
   description;
   capabilities;
   priceSubunits;
   asset;
+  mode = "llm";
+  llmOverride;
   image;
   imageFile;
   skillDir;
@@ -330,6 +379,7 @@ var ScriptSkill = class {
     this.capabilities = params.capabilities;
     this.priceSubunits = params.priceSubunits;
     this.asset = params.asset;
+    this.llmOverride = params.llmOverride;
     this.image = params.image;
     this.imageFile = params.imageFile;
     this.skillDir = params.skillDir;
@@ -339,11 +389,9 @@ var ScriptSkill = class {
     this.logger = params.logger ?? {};
   }
   async execute(input, ctx) {
-    if (!ctx.llm) {
-      throw new Error("LLM client not configured for skill runtime");
-    }
+    const llm = this.resolveLlmClient(ctx);
     if (this.tools.length === 0) {
-      const result = await ctx.llm.complete(this.systemPrompt, input.data, ctx.signal);
+      const result = await llm.complete(this.systemPrompt, input.data, ctx.signal);
       return { data: result };
     }
     const toolDefs = this.tools.map((tool) => ({
@@ -356,7 +404,6 @@ var ScriptSkill = class {
       }))
     }));
     const messages = [{ role: "user", content: input.data }];
-    const llm = ctx.llm;
     for (let round = 0; round < this.maxToolRounds; round++) {
       if (ctx.signal?.aborted) {
         throw new Error("Job aborted");
@@ -388,76 +435,191 @@ var ScriptSkill = class {
     }
     throw new Error(`Max tool rounds (${this.maxToolRounds}) exceeded`);
   }
-  runTool(toolDef, call, signal) {
-    return new Promise((resolve) => {
-      const args = [...toolDef.command];
-      const cmd = args.shift();
-      if (!cmd) {
-        resolve(`Error: tool "${toolDef.name}" has an empty command`);
-        return;
+  /**
+   * Resolve the LLM client for this skill from the runtime context.
+   *
+   * Contract:
+   * - When `llmOverride` is set, `ctx.getLlm` MUST be wired. Falling back to
+   *   `ctx.llm` (the agent default) would silently use the wrong configuration
+   *   for max-tokens-only overrides.
+   * - When no override is set, prefer `ctx.getLlm()` (returns the agent
+   *   default), then fall back to `ctx.llm` for legacy callers that wire only
+   *   a single client.
+   */
+  resolveLlmClient(ctx) {
+    let client;
+    if (this.llmOverride) {
+      client = ctx.getLlm?.(this.llmOverride);
+      if (!client) {
+        throw new Error(
+          `Skill "${this.name}" requires ctx.getLlm to be configured (llmOverride is set)`
+        );
       }
-      const params = toolDef.parameters ?? [];
-      for (let index = 0; index < params.length; index++) {
-        const param = params[index];
-        if (!param) {
-          continue;
-        }
-        const value = call.arguments[param.name];
-        if (value === void 0) {
-          continue;
-        }
-        if (param.required && index === 0) {
-          args.push(String(value));
-        } else {
-          args.push(`--${param.name}`, String(value));
-        }
+      return client;
+    }
+    client = ctx.getLlm?.() ?? ctx.llm;
+    if (!client) {
+      throw new Error("LLM client not configured for skill runtime");
+    }
+    return client;
+  }
+  async runTool(toolDef, call, signal) {
+    const args = [...toolDef.command];
+    const cmd = args.shift();
+    if (!cmd) {
+      return `Error: tool "${toolDef.name}" has an empty command`;
+    }
+    const params = toolDef.parameters ?? [];
+    for (let index = 0; index < params.length; index++) {
+      const param = params[index];
+      if (!param) {
+        continue;
       }
-      const child = child_process.spawn(cmd, args, {
-        cwd: this.skillDir,
-        stdio: ["pipe", "pipe", "pipe"],
-        timeout: TOOL_TIMEOUT_MS,
-        killSignal: "SIGKILL",
-        signal
-      });
-      let stdout = "";
-      let stderr = "";
-      const stdoutDecoder = new string_decoder.StringDecoder("utf8");
-      const stderrDecoder = new string_decoder.StringDecoder("utf8");
-      child.stdout?.on("data", (data) => {
-        if (stdout.length < MAX_TOOL_OUTPUT) {
-          stdout += stdoutDecoder.write(data);
-          if (stdout.length > MAX_TOOL_OUTPUT) {
-            stdout = stdout.slice(0, MAX_TOOL_OUTPUT);
-          }
-        }
-      });
-      child.stderr?.on("data", (data) => {
-        if (stderr.length < MAX_TOOL_OUTPUT) {
-          stderr += stderrDecoder.write(data);
-          if (stderr.length > MAX_TOOL_OUTPUT) {
-            stderr = stderr.slice(0, MAX_TOOL_OUTPUT);
-          }
-        }
-      });
-      child.on("close", (code) => {
-        stdout += stdoutDecoder.end();
-        stderr += stderrDecoder.end();
-        if (code === 0) {
-          resolve(stdout.trim());
-          return;
-        }
-        this.logger.debug?.(
-          { tool: toolDef.name, code, stderrLen: stderr.length },
-          "skill tool exited non-zero"
-        );
-        resolve(`Error (exit ${code}): ${stderr.trim() || stdout.trim()}`);
-      });
-      child.on("error", (err) => {
-        resolve(`Error: ${err.message}`);
-      });
+      const value = call.arguments[param.name];
+      if (value === void 0) {
+        continue;
+      }
+      if (param.required && index === 0) {
+        args.push(String(value));
+      } else {
+        args.push(`--${param.name}`, String(value));
+      }
+    }
+    const result = await runScript(cmd, args, { cwd: this.skillDir, signal });
+    if (result.spawnError) {
+      return `Error: ${result.spawnError.message}`;
+    }
+    if (result.code === 0) {
+      return result.stdout.trim();
+    }
+    this.logger.debug?.(
+      { tool: toolDef.name, code: result.code, stderrLen: result.stderr.length },
+      "skill tool exited non-zero"
+    );
+    return `Error (exit ${result.code}): ${result.stderr.trim() || result.stdout.trim()}`;
+  }
+};
+var MAX_STATIC_FILE_SIZE = 256 * 1024;
+var StaticFileSkill = class {
+  name;
+  description;
+  capabilities;
+  priceSubunits;
+  asset;
+  mode = "static-file";
+  image;
+  imageFile;
+  outputFilePath;
+  constructor(params) {
+    this.name = params.name;
+    this.description = params.description;
+    this.capabilities = params.capabilities;
+    this.priceSubunits = params.priceSubunits;
+    this.asset = params.asset;
+    this.image = params.image;
+    this.imageFile = params.imageFile;
+    this.outputFilePath = params.outputFilePath;
+  }
+  async execute(_input, _ctx) {
+    const buffer = await promises.readFile(this.outputFilePath);
+    if (buffer.length > MAX_STATIC_FILE_SIZE) {
+      throw new Error(
+        `static-file output exceeds ${MAX_STATIC_FILE_SIZE} bytes (got ${buffer.length})`
+      );
+    }
+    return { data: buffer.toString("utf-8") };
+  }
+};
+var StaticScriptSkill = class {
+  name;
+  description;
+  capabilities;
+  priceSubunits;
+  asset;
+  mode = "static-script";
+  image;
+  imageFile;
+  scriptPath;
+  scriptArgs;
+  scriptTimeoutMs;
+  constructor(params) {
+    this.name = params.name;
+    this.description = params.description;
+    this.capabilities = params.capabilities;
+    this.priceSubunits = params.priceSubunits;
+    this.asset = params.asset;
+    this.image = params.image;
+    this.imageFile = params.imageFile;
+    this.scriptPath = params.scriptPath;
+    this.scriptArgs = params.scriptArgs;
+    this.scriptTimeoutMs = params.scriptTimeoutMs;
+  }
+  async execute(_input, ctx) {
+    const result = await runScript(this.scriptPath, this.scriptArgs, {
+      cwd: path.dirname(this.scriptPath),
+      signal: ctx.signal,
+      timeoutMs: this.scriptTimeoutMs
     });
+    if (result.spawnError) {
+      throw new Error(`script spawn failed: ${result.spawnError.message}`);
+    }
+    if (result.code !== 0) {
+      const detail = result.stderr.trim() || result.stdout.trim() || "(no output)";
+      throw new Error(`script failed (exit ${result.code}): ${detail}`);
+    }
+    return { data: result.stdout.trim() };
   }
 };
+var DynamicScriptSkill = class {
+  name;
+  description;
+  capabilities;
+  priceSubunits;
+  asset;
+  mode = "dynamic-script";
+  image;
+  imageFile;
+  scriptPath;
+  scriptArgs;
+  scriptTimeoutMs;
+  constructor(params) {
+    this.name = params.name;
+    this.description = params.description;
+    this.capabilities = params.capabilities;
+    this.priceSubunits = params.priceSubunits;
+    this.asset = params.asset;
+    this.image = params.image;
+    this.imageFile = params.imageFile;
+    this.scriptPath = params.scriptPath;
+    this.scriptArgs = params.scriptArgs;
+    this.scriptTimeoutMs = params.scriptTimeoutMs;
+  }
+  async execute(input, ctx) {
+    const result = await runScript(this.scriptPath, this.scriptArgs, {
+      cwd: path.dirname(this.scriptPath),
+      stdin: input.data,
+      signal: ctx.signal,
+      timeoutMs: this.scriptTimeoutMs
+    });
+    if (result.spawnError) {
+      throw new Error(`script spawn failed: ${result.spawnError.message}`);
+    }
+    if (result.code !== 0) {
+      const detail = result.stderr.trim() || result.stdout.trim() || "(no output)";
+      throw new Error(`script failed (exit ${result.code}): ${detail}`);
+    }
+    return { data: result.stdout.trim() };
+  }
+};
+function resolveInsidePath(rootDir, value) {
+  const root = path.resolve(rootDir);
+  const candidate = path.resolve(root, value);
+  const rel = path.relative(root, candidate);
+  if (rel === "" || rel.startsWith("..") || rel.includes(`..${path.sep}`)) {
+    return null;
+  }
+  return candidate;
+}
 var LAMPORTS_PER_SOL = 1e9;
 var NATIVE_SOL = {
   chain: "solana",
@@ -526,7 +688,15 @@ function parseAssetAmount(asset, human) {
 Decimal__default.default.clone({ toExpNeg: -100, toExpPos: 100, precision: 50 });
 
 // src/skills/loader.ts
+var VALID_PROVIDERS = ["anthropic", "openai"];
+var MAX_TOKENS_LIMIT = 2e5;
 var DEFAULT_MAX_TOOL_ROUNDS = 10;
+var VALID_MODES = [
+  "llm",
+  "static-file",
+  "static-script",
+  "dynamic-script"
+];
 function solToLamports(sol) {
   const asNumber = typeof sol === "string" ? Number(sol) : sol;
   if (!Number.isFinite(asNumber) || asNumber < 0) {
@@ -643,6 +813,86 @@ function validateTool(raw, skillName, index) {
     parameters
   };
 }
+function validateMode(skillName, raw) {
+  if (raw === void 0 || raw === null) {
+    return "llm";
+  }
+  if (typeof raw !== "string") {
+    throw new Error(`SKILL.md "${skillName}": "mode" must be a string`);
+  }
+  if (!VALID_MODES.includes(raw)) {
+    throw new Error(
+      `SKILL.md "${skillName}": invalid mode "${raw}". Allowed: ${VALID_MODES.join(", ")}`
+    );
+  }
+  return raw;
+}
+function validateScriptArgs(skillName, raw) {
+  if (raw === void 0 || raw === null) {
+    return [];
+  }
+  if (!Array.isArray(raw)) {
+    throw new Error(`SKILL.md "${skillName}": "script_args" must be an array of strings`);
+  }
+  for (const part of raw) {
+    if (typeof part !== "string") {
+      throw new Error(`SKILL.md "${skillName}": "script_args" entries must be strings`);
+    }
+  }
+  return raw;
+}
+function validateLlmOverride(skillName, frontmatter, mode) {
+  const hasProvider = frontmatter.provider !== void 0 && frontmatter.provider !== null;
+  const hasModel = frontmatter.model !== void 0 && frontmatter.model !== null;
+  const hasMaxTokens = frontmatter.max_tokens !== void 0 && frontmatter.max_tokens !== null;
+  if (!hasProvider && !hasModel && !hasMaxTokens) {
+    return void 0;
+  }
+  if (mode !== "llm") {
+    throw new Error(
+      `SKILL.md "${skillName}": "provider"/"model"/"max_tokens" are only valid in mode 'llm' (got '${mode}')`
+    );
+  }
+  if (hasProvider !== hasModel) {
+    throw new Error(
+      `SKILL.md "${skillName}": "provider" and "model" must be set together (declare both, or neither)`
+    );
+  }
+  const override = {};
+  if (hasProvider && hasModel) {
+    if (typeof frontmatter.provider !== "string") {
+      throw new Error(`SKILL.md "${skillName}": "provider" must be a string`);
+    }
+    if (!VALID_PROVIDERS.includes(frontmatter.provider)) {
+      throw new Error(
+        `SKILL.md "${skillName}": invalid provider "${frontmatter.provider}". Allowed: ${VALID_PROVIDERS.join(", ")}`
+      );
+    }
+    if (typeof frontmatter.model !== "string" || frontmatter.model.length === 0) {
+      throw new Error(`SKILL.md "${skillName}": "model" must be a non-empty string`);
+    }
+    override.provider = frontmatter.provider;
+    override.model = frontmatter.model;
+  }
+  if (hasMaxTokens) {
+    if (typeof frontmatter.max_tokens !== "number" || !Number.isInteger(frontmatter.max_tokens) || frontmatter.max_tokens <= 0 || frontmatter.max_tokens > MAX_TOKENS_LIMIT) {
+      throw new Error(
+        `SKILL.md "${skillName}": "max_tokens" must be a positive integer <= ${MAX_TOKENS_LIMIT}`
+      );
+    }
+    override.maxTokens = frontmatter.max_tokens;
+  }
+  return override;
+}
+function validateScriptTimeoutMs(skillName, raw) {
+  if (raw === void 0 || raw === null) {
+    return void 0;
+  }
+  if (typeof raw !== "number" || !Number.isInteger(raw) || raw <= 0) {
+    throw new Error(`SKILL.md "${skillName}": "script_timeout_ms" must be a positive integer`);
+  }
+  return raw;
+}
 function validateSkillFrontmatter(frontmatter, systemPrompt, options = {}) {
   if (typeof frontmatter.name !== "string" || frontmatter.name.length === 0) {
     throw new Error('SKILL.md: missing or invalid "name" field');
@@ -694,8 +944,14 @@ function validateSkillFrontmatter(frontmatter, systemPrompt, options = {}) {
       );
     }
   }
+  const mode = validateMode(frontmatter.name, frontmatter.mode);
   const tools = [];
   if (frontmatter.tools !== void 0) {
+    if (mode !== "llm") {
+      throw new Error(
+        `SKILL.md "${frontmatter.name}": "tools" is only valid in mode 'llm' (got '${mode}')`
+      );
+    }
     if (!Array.isArray(frontmatter.tools)) {
       throw new Error(`SKILL.md "${frontmatter.name}": "tools" must be an array`);
     }
@@ -705,6 +961,11 @@ function validateSkillFrontmatter(frontmatter, systemPrompt, options = {}) {
   }
   let maxToolRounds = DEFAULT_MAX_TOOL_ROUNDS;
   if (frontmatter.max_tool_rounds !== void 0) {
+    if (mode !== "llm") {
+      throw new Error(
+        `SKILL.md "${frontmatter.name}": "max_tool_rounds" is only valid in mode 'llm' (got '${mode}')`
+      );
+    }
     if (typeof frontmatter.max_tool_rounds !== "number" || !Number.isInteger(frontmatter.max_tool_rounds) || frontmatter.max_tool_rounds <= 0) {
       throw new Error(
         `SKILL.md "${frontmatter.name}": "max_tool_rounds" must be a positive integer`
@@ -712,21 +973,146 @@ function validateSkillFrontmatter(frontmatter, systemPrompt, options = {}) {
     }
     maxToolRounds = frontmatter.max_tool_rounds;
   }
+  let outputFile;
+  let script;
+  let scriptArgs = [];
+  let scriptTimeoutMs;
+  if (mode === "static-file") {
+    if (typeof frontmatter.output_file !== "string" || frontmatter.output_file.length === 0) {
+      throw new Error(
+        `SKILL.md "${frontmatter.name}": mode 'static-file' requires "output_file" (string)`
+      );
+    }
+    if (frontmatter.script !== void 0) {
+      throw new Error(
+        `SKILL.md "${frontmatter.name}": "script" is not valid in mode 'static-file'`
+      );
+    }
+    outputFile = frontmatter.output_file;
+  } else if (mode === "static-script" || mode === "dynamic-script") {
+    if (typeof frontmatter.script !== "string" || frontmatter.script.length === 0) {
+      throw new Error(`SKILL.md "${frontmatter.name}": mode '${mode}' requires "script" (string)`);
+    }
+    if (frontmatter.output_file !== void 0) {
+      throw new Error(
+        `SKILL.md "${frontmatter.name}": "output_file" is only valid in mode 'static-file'`
+      );
+    }
+    script = frontmatter.script;
+    scriptArgs = validateScriptArgs(frontmatter.name, frontmatter.script_args);
+    scriptTimeoutMs = validateScriptTimeoutMs(frontmatter.name, frontmatter.script_timeout_ms);
+  } else {
+    if (frontmatter.output_file !== void 0) {
+      throw new Error(
+        `SKILL.md "${frontmatter.name}": "output_file" is only valid in mode 'static-file'`
+      );
+    }
+    if (frontmatter.script !== void 0) {
+      throw new Error(
+        `SKILL.md "${frontmatter.name}": "script" is only valid in script modes (static-script, dynamic-script)`
+      );
+    }
+    if (frontmatter.script_args !== void 0) {
+      throw new Error(
+        `SKILL.md "${frontmatter.name}": "script_args" is only valid in script modes`
+      );
+    }
+    if (frontmatter.script_timeout_ms !== void 0) {
+      throw new Error(
+        `SKILL.md "${frontmatter.name}": "script_timeout_ms" is only valid in script modes`
+      );
+    }
+  }
   const image = typeof frontmatter.image === "string" ? frontmatter.image : void 0;
   const imageFile = typeof frontmatter.image_file === "string" ? frontmatter.image_file : void 0;
+  const llmOverride = validateLlmOverride(frontmatter.name, frontmatter, mode);
   return {
     name: frontmatter.name,
     description: frontmatter.description,
     capabilities,
     priceSubunits,
     asset,
+    mode,
     systemPrompt,
     tools,
     maxToolRounds,
+    llmOverride,
     image,
-    imageFile
+    imageFile,
+    outputFile,
+    script,
+    scriptArgs,
+    scriptTimeoutMs
   };
 }
+function buildSkillFromParsed(parsed, skillDir, logger) {
+  switch (parsed.mode) {
+    case "llm":
+      return new ScriptSkill({
+        name: parsed.name,
+        description: parsed.description,
+        capabilities: parsed.capabilities,
+        priceSubunits: parsed.priceSubunits,
+        asset: parsed.asset,
+        skillDir,
+        systemPrompt: parsed.systemPrompt,
+        tools: parsed.tools,
+        maxToolRounds: parsed.maxToolRounds,
+        llmOverride: parsed.llmOverride,
+        image: parsed.image,
+        imageFile: parsed.imageFile,
+        logger
+      });
+    case "static-file": {
+      if (parsed.outputFile === void 0) {
+        throw new Error(
+          `SKILL.md "${parsed.name}": internal error - outputFile missing for mode 'static-file'`
+        );
+      }
+      const outputFilePath = resolveInsidePath(skillDir, parsed.outputFile);
+      if (!outputFilePath) {
+        throw new Error(
+          `SKILL.md "${parsed.name}": "output_file" must stay inside the skill directory`
+        );
+      }
+      return new StaticFileSkill({
+        name: parsed.name,
+        description: parsed.description,
+        capabilities: parsed.capabilities,
+        priceSubunits: parsed.priceSubunits,
+        asset: parsed.asset,
+        outputFilePath,
+        image: parsed.image,
+        imageFile: parsed.imageFile
+      });
+    }
+    case "static-script":
+    case "dynamic-script": {
+      if (parsed.script === void 0) {
+        throw new Error(
+          `SKILL.md "${parsed.name}": internal error - script missing for mode '${parsed.mode}'`
+        );
+      }
+      const scriptPath = resolveInsidePath(skillDir, parsed.script);
+      if (!scriptPath) {
+        throw new Error(`SKILL.md "${parsed.name}": "script" must stay inside the skill directory`);
+      }
+      const Ctor = parsed.mode === "static-script" ? StaticScriptSkill : DynamicScriptSkill;
+      return new Ctor({
+        name: parsed.name,
+        description: parsed.description,
+        capabilities: parsed.capabilities,
+        priceSubunits: parsed.priceSubunits,
+        asset: parsed.asset,
+        scriptPath,
+        scriptArgs: parsed.scriptArgs,
+        scriptTimeoutMs: parsed.scriptTimeoutMs ?? DEFAULT_SCRIPT_TIMEOUT_MS,
+        image: parsed.image,
+        imageFile: parsed.imageFile
+      });
+    }
+  }
+}
 function loadSkillsFromDir(skillsDir, options = {}) {
   const logger = options.logger ?? {};
   const skills = [];
@@ -751,22 +1137,7 @@ function loadSkillsFromDir(skillsDir, options = {}) {
       const content = fs.readFileSync(skillMdPath, "utf-8");
       const { frontmatter, systemPrompt } = parseSkillMd(content);
       const parsed = validateSkillFrontmatter(frontmatter, systemPrompt, options);
-      skills.push(
-        new ScriptSkill({
-          name: parsed.name,
-          description: parsed.description,
-          capabilities: parsed.capabilities,
-          priceSubunits: parsed.priceSubunits,
-          asset: parsed.asset,
-          skillDir: entryPath,
-          systemPrompt: parsed.systemPrompt,
-          tools: parsed.tools,
-          maxToolRounds: parsed.maxToolRounds,
-          image: parsed.image,
-          imageFile: parsed.imageFile,
-          logger
-        })
-      );
+      skills.push(buildSkillFromParsed(parsed, entryPath, logger));
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       logger.warn?.({ dir: entry, err: message }, "skipping malformed skill directory");
@@ -776,12 +1147,20 @@ function loadSkillsFromDir(skillsDir, options = {}) {
 }
 
 exports.DEFAULT_MAX_TOOL_ROUNDS = DEFAULT_MAX_TOOL_ROUNDS;
+exports.DEFAULT_SCRIPT_TIMEOUT_MS = DEFAULT_SCRIPT_TIMEOUT_MS;
+exports.DynamicScriptSkill = DynamicScriptSkill;
+exports.MAX_SCRIPT_OUTPUT = MAX_SCRIPT_OUTPUT;
+exports.MAX_STATIC_FILE_SIZE = MAX_STATIC_FILE_SIZE;
 exports.ScriptSkill = ScriptSkill;
+exports.StaticFileSkill = StaticFileSkill;
+exports.StaticScriptSkill = StaticScriptSkill;
 exports.createAnthropicClient = createAnthropicClient;
 exports.createLlmClient = createLlmClient;
 exports.createOpenAIClient = createOpenAIClient;
 exports.loadSkillsFromDir = loadSkillsFromDir;
 exports.parseSkillMd = parseSkillMd;
+exports.resolveInsidePath = resolveInsidePath;
+exports.runScript = runScript;
 exports.validateSkillFrontmatter = validateSkillFrontmatter;
 //# sourceMappingURL=skills.cjs.map
 //# sourceMappingURL=skills.cjs.map