zidane 1.8.0 → 2.0.1

package/dist/{chunk-4N5ADW7A.js → chunk-PASFWG7S.js}

@@ -1,20 +1,23 @@
 import {
   buildCatalog,
+  createSkillActivationState,
+  installAllowedToolsGate,
   interpolateShellCommands,
   mergeSkillsConfig,
-  resolveSkills
-} from "./chunk-4C6Y56CC.js";
+  resolveSkills,
+  validateResourcePath
+} from "./chunk-BCXXXJ3G.js";
 import {
   createProcessContext
 } from "./chunk-SZA4FKW5.js";
 import {
   connectMcpServers
-} from "./chunk-TBC6MSVK.js";
+} from "./chunk-PJUUYBKF.js";
 import {
   AgentAbortedError,
   AgentProviderError,
   toTypedError
-} from "./chunk-FFFDQHMA.js";
+} from "./chunk-7JTBBZ2U.js";
 
 // src/tools/glob.ts
 var DEFAULT_LIMIT = 1e3;
@@ -157,6 +160,227 @@ ${result.stderr}`.trim();
   }
 };
 
+// src/tools/skills-read.ts
+var SNIFF_BYTES = 8192;
+function looksBinary(text) {
+  const len = Math.min(text.length, SNIFF_BYTES);
+  for (let i = 0; i < len; i++) {
+    if (text.charCodeAt(i) === 0)
+      return true;
+  }
+  return false;
+}
+function createSkillsReadTool(options) {
+  const byName = new Map(options.catalog.map((s) => [s.name, s]));
+  return {
+    spec: {
+      name: "skills_read",
+      description: `Read a bundled resource file from an active skill. The skill must have been activated via skills_use first. Path is relative to the skill's directory (e.g. "references/REFERENCE.md", "assets/template.txt").`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            enum: options.catalog.map((s) => s.name),
+            description: "The name of the active skill."
+          },
+          path: {
+            type: "string",
+            description: "Path to the resource, relative to the skill root. Cannot escape the skill directory."
+          }
+        },
+        required: ["name", "path"],
+        additionalProperties: false
+      }
+    },
+    async execute(input, ctx) {
+      const skillName = input.name;
+      const relPath = input.path;
+      const skill = byName.get(skillName);
+      if (!skill)
+        return `Error: unknown skill "${skillName}".`;
+      if (!options.state.isActive(skillName))
+        return `Error: skill "${skillName}" is not active. Call skills_use with name: "${skillName}" first.`;
+      if (!skill.baseDir) {
+        return `Error: skill "${skillName}" has no base directory (likely an inline skill without bundled resources); cannot read files.`;
+      }
+      const validated = validateResourcePath(relPath, skill.baseDir);
+      if (!validated.valid)
+        return `Error: ${validated.error}`;
+      let content;
+      try {
+        content = await ctx.execution.readFile(ctx.handle, validated.absolutePath);
+      } catch (err) {
+        return `Error reading "${relPath}" in skill "${skillName}": ${err.message}`;
+      }
+      if (looksBinary(content)) {
+        return JSON.stringify({
+          kind: "binary-unsupported",
+          path: validated.absolutePath,
+          note: "This file appears to be binary. The skills_read tool returns text only; binary files are not delivered through the execution context's text-based readFile API."
+        });
+      }
+      return content;
+    }
+  };
+}
+
+// src/tools/skills-run-script.ts
+var SINGLE_QUOTE_RE = /'/g;
+var ABS_WINDOWS_RE = /^[a-z]:[\\/]/i;
+var COLLAPSE_SLASHES_RE = /\/+/g;
+function quoteShellArg(arg) {
+  return `'${arg.replace(SINGLE_QUOTE_RE, `'\\''`)}'`;
+}
+function createSkillsRunScriptTool(options) {
+  const byName = new Map(options.catalog.map((s) => [s.name, s]));
+  const timeoutMs = options.scriptTimeoutMs ?? 6e4;
+  return {
+    spec: {
+      name: "skills_run_script",
+      description: "Execute a script bundled with an active skill (from its scripts/ directory). The skill must have been activated via skills_use first. Returns stdout, stderr, and the exit code. Honors the script's shebang.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            enum: options.catalog.map((s) => s.name),
+            description: "The name of the active skill."
+          },
+          script: {
+            type: "string",
+            description: `Path to the script relative to the skill's scripts/ directory (e.g. "extract.py", "merge.sh").`
+          },
+          args: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional argv array passed to the script."
+          }
+        },
+        required: ["name", "script"],
+        additionalProperties: false
+      }
+    },
+    async execute(input, ctx) {
+      const skillName = input.name;
+      const scriptRel = input.script;
+      const args = input.args ?? [];
+      const skill = byName.get(skillName);
+      if (!skill)
+        return `Error: unknown skill "${skillName}".`;
+      if (!options.state.isActive(skillName))
+        return `Error: skill "${skillName}" is not active. Call skills_use with name: "${skillName}" first.`;
+      if (!skill.baseDir)
+        return `Error: skill "${skillName}" has no base directory (likely an inline skill); cannot run scripts.`;
+      if (scriptRel.startsWith("/") || ABS_WINDOWS_RE.test(scriptRel))
+        return `Error: Absolute paths are not allowed ("${scriptRel}").`;
+      const joinedPath = `scripts/${scriptRel}`.replace(COLLAPSE_SLASHES_RE, "/");
+      const validated = validateResourcePath(joinedPath, skill.baseDir);
+      if (!validated.valid)
+        return `Error: ${validated.error}`;
+      const cmd = [validated.absolutePath, ...args].map(quoteShellArg).join(" ");
+      try {
+        const result = await ctx.execution.exec(ctx.handle, cmd, {
+          timeout: Math.max(1, Math.round(timeoutMs / 1e3))
+        });
+        return JSON.stringify({
+          exitCode: result.exitCode,
+          stdout: result.stdout,
+          stderr: result.stderr
+        });
+      } catch (err) {
+        return `Error running script "${scriptRel}" for skill "${skillName}": ${err.message}`;
+      }
+    }
+  };
+}
+
+// src/tools/skills-use.ts
+var MAX_RESOURCE_LIST = 50;
+var AMP_RE = /&/g;
+var LT_RE = /</g;
+var GT_RE = />/g;
+var QUOT_RE = /"/g;
+function escapeXml(str) {
+  return str.replace(AMP_RE, "&amp;").replace(LT_RE, "&lt;").replace(GT_RE, "&gt;").replace(QUOT_RE, "&quot;");
+}
+function buildSkillContentWrapper(skill, body) {
+  const parts = [];
+  parts.push(`<skill_content name="${escapeXml(skill.name)}" spec_version="0.1">`);
+  parts.push(body);
+  if (skill.baseDir) {
+    parts.push("");
+    parts.push(`Skill directory: ${skill.baseDir}`);
+    parts.push("Relative paths resolve against this directory.");
+  }
+  if (skill.resources?.length) {
+    parts.push("");
+    parts.push("<skill_resources>");
+    const shown = skill.resources.slice(0, MAX_RESOURCE_LIST);
+    for (const res of shown) {
+      parts.push(`  <file type="${res.type}">${escapeXml(res.path)}</file>`);
+    }
+    if (skill.resources.length > MAX_RESOURCE_LIST) {
+      parts.push(`  <!-- \u2026(${skill.resources.length - MAX_RESOURCE_LIST} more) -->`);
+    }
+    parts.push("</skill_resources>");
+  }
+  if (skill.compatibility) {
+    parts.push("");
+    parts.push(`Compatibility: ${skill.compatibility}`);
+  }
+  if (skill.allowedTools?.length) {
+    parts.push(`Allowed tools: ${skill.allowedTools.join(" ")}`);
+  }
+  parts.push("</skill_content>");
+  return parts.join("\n");
+}
+function createSkillsUseTool(options) {
+  const byName = new Map(options.catalog.map((s) => [s.name, s]));
+  const interpolatedBodyCache = /* @__PURE__ */ new Map();
+  return {
+    spec: {
+      name: "skills_use",
+      description: "Activate a specialized skill and load its full instructions. Call this when a task matches a skill's description from the catalog. After calling, follow the returned instructions; use skills_read to load referenced files and skills_run_script to execute bundled scripts.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            enum: options.catalog.map((s) => s.name),
+            description: "The name of the skill to activate (must be in the available skills catalog)."
+          }
+        },
+        required: ["name"],
+        additionalProperties: false
+      }
+    },
+    async execute(input, ctx) {
+      const skillName = input.name;
+      const skill = byName.get(skillName);
+      if (!skill) {
+        const available = [...byName.keys()].join(", ") || "<none>";
+        return `Error: unknown skill "${skillName}". Available skills: ${available}.`;
+      }
+      const wasActive = options.state.isActive(skillName);
+      if (!wasActive) {
+        const outcome = options.state.activate(skill, "model");
+        if (outcome === "cap-reached") {
+          const activeNames = options.state.active().map((a) => a.skill.name).join(", ");
+          return `Error: cannot activate "${skillName}" \u2014 the maxActive skill cap has been reached. Currently active: ${activeNames}. Deactivate an existing skill first.`;
+        }
+        await options.hooks.callHook("skills:activate", { skill, via: "model" });
+      }
+      let body = interpolatedBodyCache.get(skillName);
+      if (body === void 0) {
+        body = skill.instructions.includes("!`") ? await interpolateShellCommands(skill.instructions, ctx.execution, ctx.handle) : skill.instructions;
+        interpolatedBodyCache.set(skillName, body);
+      }
+      return buildSkillContentWrapper(skill, body);
+    }
+  };
+}
+
 // src/agent.ts
 import { createHooks } from "hookable";
 
@@ -241,9 +465,25 @@ function validateToolArgs(input, schema) {
 }
 
 // src/loop.ts
+var IMAGE_OMITTED_MARKER = "[image omitted \u2014 model does not support vision]";
 function turnsToMessages(turns) {
   return turns.filter((t) => t.role !== "system").map((t) => ({ role: t.role, content: t.content }));
 }
+function sanitizeStoredToolResults(provider, messages) {
+  if (provider.meta.capabilities?.vision !== false)
+    return messages;
+  return messages.map((msg) => {
+    let changed = false;
+    const newContent = msg.content.map((block) => {
+      if (block.type !== "tool_result" || typeof block.output === "string")
+        return block;
+      changed = true;
+      const flattened = block.output.map((b) => b.type === "image" ? IMAGE_OMITTED_MARKER : b.text).join("\n");
+      return { ...block, output: flattened };
+    });
+    return changed ? { ...msg, content: newContent } : msg;
+  });
+}
 async function runLoop(ctx) {
   let totalIn = 0;
   let totalOut = 0;
@@ -338,11 +578,12 @@ async function executeTurn(ctx, turn) {
   const turnId = await ctx.generateTurnId();
   const canonicalMessages = turnsToMessages(ctx.turns);
   const wireMessages = rewriteMessagesToWire(canonicalMessages, ctx.aliasMaps);
+  const sanitizedMessages = sanitizeStoredToolResults(ctx.provider, wireMessages);
   const streamOptions = {
     model: ctx.model,
     system: ctx.system,
     tools: ctx.formattedTools,
-    messages: wireMessages,
+    messages: sanitizedMessages,
     maxTokens: ctx.maxTokens ?? 16384,
     thinking: ctx.thinking,
     thinkingBudget: ctx.thinkingBudget,
@@ -474,6 +715,13 @@ async function executeTurn(ctx, turn) {
   });
   return { ended: false, turnId, usage: result.usage };
 }
+function stripImagesForNonVision(provider, output) {
+  if (typeof output === "string")
+    return output;
+  if (provider.meta.capabilities?.vision !== false)
+    return output;
+  return output.map((b) => b.type === "image" ? IMAGE_OMITTED_MARKER : b.text).join("\n");
+}
 async function executeSingleTool(ctx, call, turnId) {
   const toolDef = ctx.tools[call.name];
   const callId = call.id;
@@ -553,6 +801,7 @@ async function executeSingleTool(ctx, call, turnId) {
   await ctx.hooks.callHook("tool:transform", transformCtx);
   output = transformCtx.result;
   isError = transformCtx.isError;
+  output = stripImagesForNonVision(ctx.provider, output);
   await ctx.hooks.callHook("tool:after", {
     turnId,
     callId,
@@ -701,6 +950,9 @@ function createAgent({ harness: harnessOption, provider, behavior: agentBehavior
   const skillsDisabled = skillsEnabledValue === false || Array.isArray(skillsEnabledValue) && skillsEnabledValue.length === 0;
   let resolvedSkills = null;
   let skillsCatalog = null;
+  const skillActivationState = createSkillActivationState({
+    maxActive: mergedSkillsConfig?.maxActive
+  });
   async function run(options) {
     if (running) {
       throw new Error("Agent is already running. Use steer() or followUp() to queue messages, or waitForIdle().");
@@ -763,34 +1015,32 @@ function createAgent({ harness: harnessOption, provider, behavior: agentBehavior
     if (!skillsDisabled && mergedSkillsConfig && !resolvedSkills) {
       resolvedSkills = await resolveSkills(mergedSkillsConfig);
       await hooks.callHook("skills:resolve", { skills: resolvedSkills });
-      if (executionHandle) {
-        for (const skill of resolvedSkills) {
-          if (skill.instructions.includes("!`")) {
-            skill.instructions = await interpolateShellCommands(
-              skill.instructions,
-              executionContext,
-              executionHandle
-            );
-          }
-        }
-      }
-      const readToolName = mergedSkillsConfig.readToolName ?? "read_file";
-      const catalogCtx = { catalog: buildCatalog(resolvedSkills, readToolName), skills: resolvedSkills };
+      const skillsToolRegistered = mergedSkillsConfig?.tool !== false && resolvedSkills.length > 0;
+      const catalogCtx = {
+        catalog: buildCatalog(resolvedSkills, { skillsToolRegistered }),
+        skills: resolvedSkills
+      };
       await hooks.callHook("skills:catalog", catalogCtx);
       skillsCatalog = catalogCtx.catalog;
-      const fsSkills = resolvedSkills.filter((s) => s.location);
-      if (fsSkills.length > 0) {
-        const skillByLocation = new Map(fsSkills.map((s) => [s.location, s]));
-        hooks.hook("tool:after", (ctx) => {
-          if (ctx.name !== readToolName)
-            return;
-          const path = ctx.input.path;
-          if (!path)
-            return;
-          const matched = skillByLocation.get(path) ?? fsSkills.find((s) => s.location.endsWith(path));
-          if (matched)
-            hooks.callHook("skills:activate", { skill: matched });
-        });
+    }
+    if (resolvedSkills && session && session.turns.length > 0 && skillActivationState.active().length === 0) {
+      const skillsByName = new Map(resolvedSkills.map((s) => [s.name, s]));
+      for (const turn of session.turns) {
+        if (turn.role !== "assistant")
+          continue;
+        for (const block of turn.content) {
+          if (block.type !== "tool_call" || block.name !== "skills_use")
+            continue;
+          const skillName = block.input?.name;
+          if (!skillName)
+            continue;
+          const skill = skillsByName.get(skillName);
+          if (!skill)
+            continue;
+          if (skillActivationState.activate(skill, "resume") === "ok") {
+            await hooks.callHook("skills:activate", { skill, via: "resume" });
+          }
+        }
       }
     }
     const thinking = options.thinking ?? "off";
@@ -803,8 +1053,27 @@ function createAgent({ harness: harnessOption, provider, behavior: agentBehavior
 ${skillsCatalog}`;
     }
     const baseTools = options.tools !== void 0 ? options.tools : mcpConnection ? { ...harness.tools, ...mcpConnection.tools } : harness.tools;
+    const shouldInjectSkillTools = options.tools === void 0 && !!resolvedSkills && resolvedSkills.length > 0 && mergedSkillsConfig?.tool !== false;
+    const mergedWithSkills = shouldInjectSkillTools ? {
+      // Auto-injected first so harness + MCP tools can override by name.
+      skills_use: createSkillsUseTool({
+        catalog: resolvedSkills,
+        state: skillActivationState,
+        hooks
+      }),
+      skills_read: createSkillsReadTool({
+        catalog: resolvedSkills,
+        state: skillActivationState
+      }),
+      skills_run_script: createSkillsRunScriptTool({
+        catalog: resolvedSkills,
+        state: skillActivationState,
+        scriptTimeoutMs: mergedSkillsConfig?.scriptTimeoutMs
+      }),
+      ...baseTools
+    } : baseTools;
     const tools = {};
-    for (const tool of Object.values(baseTools)) {
+    for (const tool of Object.values(mergedWithSkills)) {
       tools[tool.spec.name] = tool;
     }
     const aliasMaps = buildAliasMaps(harness.toolAliases, Object.keys(tools));
@@ -856,6 +1125,10 @@ ${skillsCatalog}`;
         await hooks.callHook("session:turns", { sessionId: session.id, turns: remaining, count: turns.length });
       }
     }
+    async function deactivateAllSkills() {
+      for (const record of skillActivationState.clear())
+        await hooks.callHook("skills:deactivate", { skill: record.skill, reason: "run-end" });
+    }
     async function finalizeSession(status) {
       if (!session)
         return;
@@ -865,6 +1138,7 @@ ${skillsCatalog}`;
       await session.updateStatus(status === "aborted" ? "idle" : status);
       await hooks.callHook("session:end", { sessionId: session.id, runId, status, turnRange: [runTurnStart, turns.length - 1] });
     }
+    const uninstallAllowedToolsGate = installAllowedToolsGate(hooks, skillActivationState);
     const runStartMs = Date.now();
     try {
       const stats = await runLoop({
@@ -929,6 +1203,8 @@ ${skillsCatalog}`;
       await finalizeSession("error");
       throw err;
     } finally {
+      await deactivateAllSkills();
+      uninstallAllowedToolsGate();
       unregisterSpawnHook();
       unregisterSessionSync?.();
       for (const unregister of perRunUnregisters)
@@ -958,6 +1234,33 @@ ${skillsCatalog}`;
     conversationTurns = [];
     steeringQueue.length = 0;
     followUpQueue.length = 0;
+    for (const record of skillActivationState.clear())
+      void hooks.callHook("skills:deactivate", { skill: record.skill, reason: "reset" });
+  }
+  async function activateSkill(name) {
+    if (!resolvedSkills) {
+      throw new Error(
+        `Cannot activate skill "${name}" \u2014 skills have not been resolved yet. Call activateSkill after the first \`run()\`, or pass a skills config that resolves at agent-creation time.`
+      );
+    }
+    const skill = resolvedSkills.find((s) => s.name === name);
+    if (!skill) {
+      const available = resolvedSkills.map((s) => s.name).join(", ") || "<none>";
+      throw new Error(`Unknown skill "${name}". Available skills: ${available}.`);
+    }
+    const outcome = skillActivationState.activate(skill, "explicit");
+    if (outcome === "cap-reached") {
+      throw new Error(
+        `Cannot activate skill "${name}" \u2014 the maxActive cap of ${mergedSkillsConfig?.maxActive} has been reached.`
+      );
+    }
+    if (outcome === "ok")
+      await hooks.callHook("skills:activate", { skill, via: "explicit" });
+  }
+  async function deactivateSkill(name) {
+    const removed = skillActivationState.deactivate(name);
+    if (removed)
+      await hooks.callHook("skills:deactivate", { skill: removed.skill, reason: "explicit" });
   }
   if (session) {
     const originalSave = session.save.bind(session);
@@ -990,6 +1293,8 @@ ${skillsCatalog}`;
     waitForIdle,
     reset,
     destroy,
+    activateSkill,
+    deactivateSkill,
     get isRunning() {
       return running;
     },
@@ -1005,6 +1310,9 @@ ${skillsCatalog}`;
     get session() {
       return session ?? null;
     },
+    get activeSkills() {
+      return skillActivationState.active();
+    },
     meta: provider.meta
   };
 }
@@ -1134,6 +1442,9 @@ var writeFile = {
 
 export {
   validateToolArgs,
+  createSkillsReadTool,
+  createSkillsRunScriptTool,
+  createSkillsUseTool,
   createAgent,
   glob,
   createInteractionTool,

package/dist/{chunk-TBC6MSVK.js → chunk-PJUUYBKF.js}

@@ -1,7 +1,7 @@
 // src/mcp/index.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { getDefaultEnvironment, StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 function inferTransport(raw) {
   if (raw.transport === "stdio" || raw.transport === "sse" || raw.transport === "streamable-http")
@@ -28,6 +28,8 @@ function normalizeOne(name, raw) {
     config.args = raw.args;
   if (raw.env)
     config.env = raw.env;
+  if (raw.strictEnv === true)
+    config.strictEnv = true;
   if (url)
     config.url = url;
   if (raw.headers)
@@ -72,14 +74,60 @@ function resultToString(content) {
     return JSON.stringify(block);
   }).join("\n");
 }
+function normalizeMcpBlocks(content) {
+  if (!Array.isArray(content))
+    return null;
+  const out = [];
+  for (const raw of content) {
+    if (!raw || typeof raw !== "object")
+      continue;
+    const block = raw;
+    if (block.type === "text" && typeof block.text === "string") {
+      out.push({ type: "text", text: block.text });
+      continue;
+    }
+    if (block.type === "image" && typeof block.data === "string") {
+      const mediaType = typeof block.mimeType === "string" ? block.mimeType : typeof block.mediaType === "string" ? block.mediaType : "image/png";
+      out.push({ type: "image", mediaType, data: block.data });
+      continue;
+    }
+    if (block.type === "resource" && block.resource && typeof block.resource === "object") {
+      const res = block.resource;
+      if (typeof res.text === "string") {
+        out.push({ type: "text", text: res.text });
+        continue;
+      }
+      if (typeof res.blob === "string" && typeof res.mimeType === "string" && res.mimeType.startsWith("image/")) {
+        out.push({ type: "image", mediaType: res.mimeType, data: res.blob });
+        continue;
+      }
+    }
+    out.push({ type: "text", text: JSON.stringify(block) });
+  }
+  return out;
+}
+function packMcpResult(content) {
+  const normalized = normalizeMcpBlocks(content);
+  if (!normalized || normalized.length === 0)
+    return "";
+  const parts = [];
+  for (const block of normalized) {
+    if (block.type !== "text")
+      return normalized;
+    parts.push(block.text);
+  }
+  return parts.join("\n");
+}
 function createTransport(config) {
   switch (config.transport) {
-    case "stdio":
+    case "stdio": {
+      const mergedEnv = config.env && !config.strictEnv ? { ...getDefaultEnvironment(), ...config.env } : config.env;
       return new StdioClientTransport({
         command: config.command,
         args: config.args,
-        env: config.env
+        env: mergedEnv
       });
+    }
     case "sse":
       return new SSEClientTransport(new URL(config.url), {
         requestInit: config.headers ? { headers: config.headers } : void 0
@@ -147,7 +195,7 @@ async function connectMcpServers(configs, _clientFactory, hooks) {
                   timer = setTimeout(() => reject(new Error(`MCP tool "${tool.name}" on server "${config.name}" timed out after ${timeout}ms`)), timeout);
                 })
               ]).finally(() => clearTimeout(timer));
-              let output = resultToString(result.content);
+              let output = packMcpResult(result.content);
               const transformCtx = {
                 turnId,
                 callId,
@@ -223,5 +271,6 @@ async function connectMcpServers(configs, _clientFactory, hooks) {
 export {
   normalizeMcpServers,
   resultToString,
+  normalizeMcpBlocks,
   connectMcpServers
 };