@cuylabs/agent-core 0.3.0 → 0.5.0

package/dist/chunk-VEKUXUVF.js

@@ -0,0 +1,41 @@
+// src/tracking/file-tracking.ts
+function extractFilePathsFromArgs(args, meta) {
+  if (!meta.pathArgs || meta.pathArgs.length === 0) {
+    return [];
+  }
+  const paths = [];
+  for (const argName of meta.pathArgs) {
+    const value = args[argName];
+    if (typeof value === "string") {
+      paths.push(value);
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        if (typeof item === "string") {
+          paths.push(item);
+        }
+      }
+    }
+  }
+  return paths;
+}
+function shouldCaptureBaseline(meta) {
+  return meta.operationType !== "read";
+}
+function withFileTracking(tracker, meta, execute) {
+  return (async (...args) => {
+    const params = args[0];
+    if (params && shouldCaptureBaseline(meta)) {
+      const paths = extractFilePathsFromArgs(params, meta);
+      for (const path of paths) {
+        await tracker.beforeWrite(path);
+      }
+    }
+    return await execute(...args);
+  });
+}
+
+export {
+  extractFilePathsFromArgs,
+  shouldCaptureBaseline,
+  withFileTracking
+};

package/dist/chunk-X635CM2F.js

@@ -0,0 +1,305 @@
+import {
+  extractModelId,
+  extractProvider,
+  getDefaultResolver,
+  likelySupportsReasoning
+} from "./chunk-QWFMX226.js";
+
+// src/reasoning/types.ts
+var STANDARD_LEVELS = ["off", "low", "medium", "high"];
+var EXTENDED_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
+var FIXED_LEVELS = ["medium"];
+function shouldIncludeReasoningSummary() {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env.CODE_AGENT_DISABLE_REASONING_SUMMARY !== "true";
+  }
+  return true;
+}
+
+// src/reasoning/providers.ts
+function buildOpenAIOptions(level, compat) {
+  if (level === "off") return void 0;
+  const options = {};
+  if (compat?.supportsReasoningEffort !== false) {
+    options.reasoningEffort = level;
+  }
+  if (shouldIncludeReasoningSummary()) {
+    options.reasoningSummary = "auto";
+  }
+  return options;
+}
+var ANTHROPIC_BUDGETS = {
+  off: 0,
+  minimal: 2e3,
+  low: 4e3,
+  medium: 8e3,
+  high: 16e3,
+  xhigh: 31999
+};
+function buildAnthropicOptions(level) {
+  if (level === "off") return void 0;
+  return {
+    thinking: {
+      type: "enabled",
+      budgetTokens: ANTHROPIC_BUDGETS[level]
+    }
+  };
+}
+var GOOGLE_BUDGETS = {
+  off: 0,
+  minimal: 2e3,
+  low: 4e3,
+  medium: 8e3,
+  high: 16e3,
+  xhigh: 24576
+};
+function buildGoogleOptions(level, modelId) {
+  if (level === "off") return void 0;
+  if (modelId?.includes("gemini-3") || modelId?.includes("gemini-4")) {
+    return {
+      thinkingConfig: {
+        includeThoughts: true,
+        thinkingLevel: level === "high" || level === "xhigh" ? "high" : "low"
+      }
+    };
+  }
+  return {
+    thinkingConfig: {
+      includeThoughts: true,
+      thinkingBudget: GOOGLE_BUDGETS[level]
+    }
+  };
+}
+function buildXAIOptions(level) {
+  if (level === "off") return void 0;
+  return { reasoningEffort: level };
+}
+function buildGroqOptions(level) {
+  if (level === "off") return void 0;
+  return {
+    includeThoughts: true,
+    thinkingLevel: level === "high" || level === "xhigh" ? "high" : "low"
+  };
+}
+var BEDROCK_ANTHROPIC_BUDGETS = {
+  off: 0,
+  minimal: 2e3,
+  low: 4e3,
+  medium: 8e3,
+  high: 16e3,
+  xhigh: 31999
+};
+function buildBedrockOptions(level, modelId) {
+  if (level === "off") return void 0;
+  if (modelId?.includes("anthropic") || modelId?.includes("claude")) {
+    return {
+      reasoningConfig: {
+        type: "enabled",
+        budgetTokens: BEDROCK_ANTHROPIC_BUDGETS[level]
+      }
+    };
+  }
+  return {
+    reasoningConfig: {
+      type: "enabled",
+      maxReasoningEffort: level
+    }
+  };
+}
+function buildOpenRouterOptions(level) {
+  if (level === "off") return void 0;
+  return {
+    reasoning: { effort: level }
+  };
+}
+var PROVIDER_KEY_MAP = {
+  "openai.chat": "openai",
+  "openai.responses": "openai",
+  "anthropic.messages": "anthropic",
+  "google.generative-ai": "google",
+  "bedrock": "bedrock",
+  "azure": "azure",
+  "xai": "xai",
+  "deepinfra": "deepinfra",
+  "togetherai": "togetherai",
+  "groq": "groq",
+  "mistral": "mistral"
+};
+function getProviderOptionsKey(provider) {
+  return PROVIDER_KEY_MAP[provider] || provider.split(".")[0] || "unknown";
+}
+
+// src/reasoning/config.ts
+async function getReasoningConfig(model) {
+  const resolver = getDefaultResolver();
+  const result = await resolver.resolve(model);
+  const { capabilities, compatibility } = result.entry;
+  const provider = extractProvider(model);
+  const modelId = extractModelId(model).toLowerCase();
+  if (!capabilities.reasoning) {
+    return {
+      supportsReasoning: false,
+      availableLevels: ["off"],
+      getProviderOptions: () => void 0
+    };
+  }
+  if (provider?.includes("openai") || modelId.includes("gpt") || modelId.match(/^o[134]/)) {
+    if (modelId === "o1-mini") {
+      return {
+        supportsReasoning: true,
+        availableLevels: FIXED_LEVELS,
+        getProviderOptions: () => void 0
+      };
+    }
+    const isAdvanced = modelId.includes("gpt-5") || modelId.includes("o3") || modelId.includes("o4");
+    return {
+      supportsReasoning: true,
+      availableLevels: isAdvanced ? EXTENDED_LEVELS : STANDARD_LEVELS,
+      getProviderOptions: (level) => buildOpenAIOptions(level, compatibility)
+    };
+  }
+  if (provider?.includes("anthropic") || modelId.includes("claude")) {
+    return {
+      supportsReasoning: true,
+      availableLevels: ["off", "low", "medium", "high"],
+      getProviderOptions: buildAnthropicOptions
+    };
+  }
+  if (provider?.includes("google") || modelId.includes("gemini")) {
+    return {
+      supportsReasoning: true,
+      availableLevels: STANDARD_LEVELS,
+      getProviderOptions: (level) => buildGoogleOptions(level, modelId)
+    };
+  }
+  if (provider?.includes("xai") || modelId.includes("grok")) {
+    return {
+      supportsReasoning: true,
+      availableLevels: STANDARD_LEVELS,
+      getProviderOptions: buildXAIOptions
+    };
+  }
+  if (provider?.includes("bedrock")) {
+    return {
+      supportsReasoning: true,
+      availableLevels: STANDARD_LEVELS,
+      getProviderOptions: (level) => buildBedrockOptions(level, modelId)
+    };
+  }
+  if (provider?.includes("groq")) {
+    return {
+      supportsReasoning: true,
+      availableLevels: ["off", "low", "high"],
+      getProviderOptions: buildGroqOptions
+    };
+  }
+  if (provider?.includes("openrouter")) {
+    return {
+      supportsReasoning: true,
+      availableLevels: STANDARD_LEVELS,
+      getProviderOptions: buildOpenRouterOptions
+    };
+  }
+  if (modelId.includes("r1") || modelId.includes("deepseek")) {
+    return {
+      supportsReasoning: true,
+      availableLevels: FIXED_LEVELS,
+      getProviderOptions: () => void 0
+    };
+  }
+  return {
+    supportsReasoning: true,
+    availableLevels: STANDARD_LEVELS,
+    getProviderOptions: (level) => buildOpenAIOptions(level, compatibility)
+  };
+}
+function getReasoningConfigSync(model) {
+  const modelId = extractModelId(model).toLowerCase();
+  const provider = extractProvider(model) || "";
+  const supportsReasoning2 = modelId.match(/^o[134]/) !== null || modelId.includes("gpt-5") || modelId.includes("r1") || modelId.includes("thinking") || modelId.includes("reasoning") || modelId.includes("grok") && modelId.includes("mini");
+  if (!supportsReasoning2) {
+    return {
+      supportsReasoning: false,
+      availableLevels: ["off"],
+      getProviderOptions: () => void 0
+    };
+  }
+  const isOpenAI = provider.includes("openai") || !!modelId.match(/^o[134]/) || modelId.includes("gpt");
+  const isAnthropic = provider.includes("anthropic") || modelId.includes("claude");
+  const isGoogle = provider.includes("google") || modelId.includes("gemini");
+  const isXAI = provider.includes("xai") || modelId.includes("grok");
+  const isBedrock = provider.includes("bedrock");
+  const isGroq = provider.includes("groq");
+  const isOpenRouter = provider.includes("openrouter");
+  return {
+    supportsReasoning: true,
+    availableLevels: STANDARD_LEVELS,
+    getProviderOptions: (level) => {
+      if (level === "off") return void 0;
+      if (isOpenAI) {
+        const opts = { reasoningEffort: level };
+        if (shouldIncludeReasoningSummary()) opts.reasoningSummary = "auto";
+        return opts;
+      }
+      if (isAnthropic) return buildAnthropicOptions(level);
+      if (isGoogle) return buildGoogleOptions(level, modelId);
+      if (isXAI) return buildXAIOptions(level);
+      if (isBedrock) return buildBedrockOptions(level, modelId);
+      if (isGroq) return buildGroqOptions(level);
+      if (isOpenRouter) return buildOpenRouterOptions(level);
+      const defaultOpts = { reasoningEffort: level };
+      if (shouldIncludeReasoningSummary()) defaultOpts.reasoningSummary = "auto";
+      return defaultOpts;
+    }
+  };
+}
+async function buildReasoningOptions(model, level) {
+  if (level === "off") return void 0;
+  const config = await getReasoningConfig(model);
+  if (!config.supportsReasoning) return void 0;
+  const effectiveLevel = config.availableLevels.includes(level) ? level : config.availableLevels[config.availableLevels.length - 1];
+  const options = config.getProviderOptions(effectiveLevel);
+  if (!options) return void 0;
+  const provider = extractProvider(model) || "";
+  const providerKey = getProviderOptionsKey(provider);
+  return { [providerKey]: options };
+}
+function buildReasoningOptionsSync(model, level) {
+  if (level === "off") return void 0;
+  const config = getReasoningConfigSync(model);
+  if (!config.supportsReasoning) return void 0;
+  const effectiveLevel = config.availableLevels.includes(level) ? level : config.availableLevels[config.availableLevels.length - 1];
+  const options = config.getProviderOptions(effectiveLevel);
+  if (!options) return void 0;
+  const provider = extractProvider(model) || "";
+  const providerKey = getProviderOptionsKey(provider);
+  return { [providerKey]: options };
+}
+async function supportsReasoning(model) {
+  const resolver = getDefaultResolver();
+  return resolver.supportsReasoning(model);
+}
+function supportsReasoningSync(model) {
+  return likelySupportsReasoning(extractModelId(model));
+}
+
+export {
+  STANDARD_LEVELS,
+  EXTENDED_LEVELS,
+  FIXED_LEVELS,
+  shouldIncludeReasoningSummary,
+  buildOpenAIOptions,
+  buildAnthropicOptions,
+  buildGoogleOptions,
+  buildXAIOptions,
+  buildGroqOptions,
+  buildBedrockOptions,
+  buildOpenRouterOptions,
+  getProviderOptionsKey,
+  getReasoningConfig,
+  getReasoningConfigSync,
+  buildReasoningOptions,
+  buildReasoningOptionsSync,
+  supportsReasoning,
+  supportsReasoningSync
+};

package/dist/chunk-YUUJK53A.js

@@ -0,0 +1,91 @@
+import {
+  Tool
+} from "./chunk-P6YF7USR.js";
+
+// src/skill/tools.ts
+import { z } from "zod";
+function createSkillTool(registry) {
+  return Tool.define("skill", () => {
+    const skills = registry.list();
+    const skillList = skills.length > 0 ? skills.map((s) => `  - "${s.name}": ${s.description}`).join("\n") : "  (no skills available)";
+    return {
+      description: `Load a skill's full instructions to gain specialized knowledge for a task.
+
+Available skills:
+${skillList}
+
+Only load a skill when the current task clearly matches its description. Skills provide detailed workflows, reference material, and scripts.`,
+      parameters: z.object({
+        name: z.string().describe("The name of the skill to load (must match one of the available skills)")
+      }),
+      execute: async ({ name }) => {
+        const content = await registry.loadContent(name);
+        if (!content) {
+          const available = registry.names.join(", ");
+          return {
+            title: `Skill not found: ${name}`,
+            output: `No skill named "${name}" exists.
+
+Available skills: ${available || "(none)"}`,
+            metadata: {}
+          };
+        }
+        const formatted = registry.formatContent(content);
+        let depNote = "";
+        if (content.dependencies && content.dependencies.length > 0) {
+          const unloaded = content.dependencies.filter(
+            (dep) => registry.has(dep) && !registry.isContentLoaded(dep)
+          );
+          if (unloaded.length > 0) {
+            depNote = `
+
+Note: This skill works best with these additional skills: ${unloaded.join(", ")}. Consider loading them if relevant.`;
+          }
+        }
+        return {
+          title: `Loaded skill: ${content.name}`,
+          output: formatted + depNote,
+          metadata: {}
+        };
+      }
+    };
+  });
+}
+function createSkillResourceTool(registry) {
+  return Tool.define("skill_resource", {
+    description: "Read a specific file bundled with a skill (scripts, references, examples, assets). The skill must be loaded first via the `skill` tool to see available resources.",
+    parameters: z.object({
+      skill: z.string().describe("The skill name"),
+      path: z.string().describe("Relative path to the resource file within the skill")
+    }),
+    execute: async ({ skill, path }) => {
+      try {
+        const content = await registry.loadResource(skill, path);
+        return {
+          title: `${skill}/${path}`,
+          output: content,
+          metadata: {}
+        };
+      } catch (err) {
+        return {
+          title: `Error reading resource`,
+          output: err instanceof Error ? err.message : String(err),
+          metadata: {}
+        };
+      }
+    }
+  });
+}
+function createSkillTools(registry) {
+  if (registry.size === 0) return [];
+  return [
+    createSkillTool(registry),
+    createSkillResourceTool(registry)
+  ];
+}
+
+export {
+  createSkillTool,
+  createSkillResourceTool,
+  createSkillTools
+};