@easynet/agent-runtime 1.0.2 → 1.0.4

package/src/core/context.ts

@@ -0,0 +1,266 @@
+import { createAgentModelRegistry } from "@easynet/agent-model";
+import { createAgentMemory as createMemoryClient } from "@easynet/agent-memory/internal";
+import { createLangChainAgentTools } from "@easynet/agent-tool/api";
+import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import {
+  createAgentEventBus,
+  loadYamlFile,
+  asObject,
+  type AgentEventBus,
+} from "@easynet/agent-common";
+import type { SkillConfig } from "@easynet/agent-skill";
+import { createSkills, type EmbedFn, type SkillSet } from "@easynet/agent-skill";
+import { getSkillsConfig } from "../config/index.js";
+import type { BaseAgentConfig, ConfigApi } from "../config/types.js";
+import { resolve, dirname } from "node:path";
+export type { BaseAgentConfig } from "../config/types.js";
+export type { ConfigApi } from "../config/types.js";
+
+export type AgentName = string;
+
+export type BotTool = ReturnType<typeof createLangChainAgentTools>[number];
+
+/** Minimal memory interface used by the runtime. */
+export interface AgentMemory {
+  memorize(namespace: string, type: string, contentOrUrl: string | URL, metadata?: Record<string, unknown>): Promise<unknown>;
+  recall(req: { namespace: string; query?: string; types?: string[]; topK?: number; budgetTokens?: number }): Promise<{ items: unknown[]; injectedText: string; traceId: string }>;
+  deleteByNamespace(namespace: string): Promise<void>;
+  getByKey(namespace: string, key: string): Promise<unknown>;
+  deleteByKey(namespace: string, key: string): Promise<void>;
+}
+
+export interface BotContext<TConfig extends BaseAgentConfig = BaseAgentConfig, TTool = BotTool> {
+  llm: BaseChatModel;
+  memory: AgentMemory;
+  tools: TTool[];
+  config: TConfig;
+  events: AgentEventBus;
+  skillSet?: SkillSet;
+}
+
+export interface CreateContextOptions<TTool = BotTool> {
+  configPath?: string;
+  agentName?: AgentName;
+  events?: AgentEventBus;
+  llm?: BaseChatModel;
+  memory?: AgentMemory;
+  tools?: TTool[];
+}
+
+function publishEvent(
+  events: AgentEventBus,
+  name: string,
+  from: string,
+  to: string,
+  payload?: unknown
+): void {
+  events.publish({ name, from, to, payload });
+}
+
+function injectSkillsRuntimeConfig(
+  config: BaseAgentConfig,
+  agentName: string,
+  values: Pick<SkillConfig, "mode" | "inject_metadata" | "embedding_threshold" | "keyword_threshold">
+): void {
+  const agentConfig = config.app?.agent?.[agentName];
+  if (!agentConfig) return;
+  agentConfig.skills = {
+    ...(agentConfig.skills ?? {}),
+    ...values,
+  };
+}
+
+export function createContextBuilders<TConfig extends BaseAgentConfig>(params: {
+  configApi: ConfigApi<TConfig>;
+}) {
+  const {
+    loadAgentConfig,
+    getModelsConfigPath,
+    getMemoryConfigPath,
+    getToolConfigPath,
+  } = params.configApi;
+
+  const pickDefaultAgentName = (config: TConfig): AgentName | undefined => {
+    const names = Object.keys(config.app?.agent ?? {});
+    return names[0];
+  };
+
+  async function getAgentLlm(
+    config: TConfig,
+    events: AgentEventBus,
+    agentName?: AgentName
+  ): Promise<BaseChatModel> {
+    const modelsPath = getModelsConfigPath(config, agentName ?? pickDefaultAgentName(config));
+    publishEvent(events, "llm.init.start", "app", "llm", { configPath: modelsPath });
+    const modelRegistry = await createAgentModelRegistry(modelsPath);
+    const llm = await modelRegistry.getChatModel();
+    publishEvent(events, "llm.init.done", "llm", "app");
+    return llm;
+  }
+
+  async function getAgentMemory(
+    config: TConfig,
+    events: AgentEventBus,
+    agentName?: AgentName
+  ): Promise<AgentMemory> {
+    const memoryPath = getMemoryConfigPath(config, agentName ?? pickDefaultAgentName(config));
+    publishEvent(events, "memory.init.start", "app", "memory", { configPath: memoryPath });
+    const memory = await createMemoryClient({ configPath: memoryPath });
+    publishEvent(events, "memory.init.done", "memory", "app");
+    return memory;
+  }
+
+  async function getAgentTools(
+    config: TConfig,
+    events: AgentEventBus,
+    agentName?: AgentName
+  ): Promise<BotTool[]> {
+    const toolPath = getToolConfigPath(config, agentName ?? pickDefaultAgentName(config));
+    publishEvent(events, "tools.init.start", "app", "tools", { configPath: toolPath });
+    const tools = createLangChainAgentTools({ configFilePath: toolPath });
+    publishEvent(events, "tools.init.done", "tools", "app", { count: tools.length });
+    return tools;
+  }
+
+  async function createAgent(options: CreateContextOptions<BotTool> = {}): Promise<BotContext<TConfig, BotTool>> {
+    const config = await loadAgentConfig(options.configPath);
+    const agentName = options.agentName ?? pickDefaultAgentName(config);
+    const events = options.events ?? createAgentEventBus();
+    publishEvent(events, "agent.context.init.start", "app", "runtime");
+
+    const [llm, memory, tools] = await Promise.all([
+      options.llm ?? getAgentLlm(config, events, agentName),
+      options.memory ?? getAgentMemory(config, events, agentName),
+      options.tools ?? getAgentTools(config, events, agentName),
+    ]);
+
+    const appConfig = config as unknown as BaseAgentConfig;
+    const skillSet = await initializeSkills({
+      appConfig,
+      config,
+      agentName,
+      events,
+      getModelsConfigPath: (c, name) => getModelsConfigPath(c as TConfig, name),
+      pickDefaultAgentName: (c) => pickDefaultAgentName(c as TConfig),
+    });
+
+    publishEvent(events, "agent.context.init.done", "runtime", "app");
+    return { llm, memory, tools, config, events, skillSet };
+  }
+
+  async function createBotContext(
+    configPath?: string,
+    agentName?: AgentName
+  ): Promise<BotContext<TConfig, BotTool>> {
+    return createAgent({ configPath, agentName });
+  }
+
+  return {
+    getAgentLlm,
+    getAgentMemory,
+    getAgentTools,
+    // Backward-compatible aliases
+    createAgentLlm: getAgentLlm,
+    createAgentMemory: getAgentMemory,
+    createAgentTools: getAgentTools,
+    createAgent,
+    createBotContext,
+  };
+}
+
+async function initializeSkills(input: {
+  appConfig: BaseAgentConfig;
+  config: BaseAgentConfig;
+  agentName?: AgentName;
+  events: AgentEventBus;
+  getModelsConfigPath: (config: BaseAgentConfig, agentName?: AgentName) => string;
+  pickDefaultAgentName: (config: BaseAgentConfig) => AgentName | undefined;
+}): Promise<SkillSet | undefined> {
+  const skillsConfig = await getSkillsConfig(input.appConfig, input.agentName);
+  if (!skillsConfig) return undefined;
+  publishEvent(input.events, "skills.init.start", "app", "skills", { path: skillsConfig.path });
+  const embedFn = buildSkillsEmbedFn(input.config, input.agentName, input.getModelsConfigPath, input.pickDefaultAgentName);
+  const skillsDir = await resolveSkillsDir(skillsConfig.path);
+  const skillSet = await createSkills({ path: skillsDir, embed: embedFn });
+  const mode = applySkillsPromptAndMetadata(input.appConfig, input.agentName, skillsConfig, skillSet);
+  publishEvent(input.events, "skills.init.done", "skills", "app", { count: skillSet.list().length, mode });
+  return skillSet;
+}
+
+function buildSkillsEmbedFn(
+  config: BaseAgentConfig,
+  agentName: AgentName | undefined,
+  getModelsConfigPath: (config: BaseAgentConfig, agentName?: AgentName) => string,
+  pickDefaultAgentName: (config: BaseAgentConfig) => AgentName | undefined,
+): EmbedFn | undefined {
+  const modelsPath = getModelsConfigPath(config, agentName ?? pickDefaultAgentName(config));
+  const lazyEmbed: EmbedFn = async (input: string | string[]) => {
+    const modelRegistry = await createAgentModelRegistry(modelsPath);
+    const embeddings = modelRegistry.getEmbeddingModel();
+    if (Array.isArray(input)) return embeddings.embedDocuments(input);
+    const one = await embeddings.embedQuery(input);
+    return [one];
+  };
+  return lazyEmbed;
+}
+
+function applySkillsPromptAndMetadata(
+  appConfig: BaseAgentConfig,
+  agentName: AgentName | undefined,
+  skillsConfig: SkillConfig,
+  skillSet: SkillSet,
+): string {
+  const mode = skillsConfig.mode ?? "prompt";
+  if (agentName) {
+    injectSkillsRuntimeConfig(appConfig, agentName, {
+      mode: skillsConfig.mode,
+      inject_metadata: skillsConfig.inject_metadata,
+      embedding_threshold: skillsConfig.embedding_threshold,
+      keyword_threshold: skillsConfig.keyword_threshold,
+    });
+  }
+  if (mode === "prompt" && skillsConfig.inject_metadata !== false) {
+    injectSkillsPromptSection(appConfig, agentName, skillSet.promptSection());
+  }
+  return mode;
+}
+
+function injectSkillsPromptSection(
+  appConfig: BaseAgentConfig,
+  agentName: AgentName | undefined,
+  section: string | undefined,
+): void {
+  if (!section || !agentName) return;
+  const agentConfig = appConfig.app?.agent?.[agentName];
+  if (!agentConfig) return;
+  const currentPrompt = agentConfig.systemPrompt ?? "";
+  agentConfig.systemPrompt = currentPrompt.trimEnd() + "\n\n" + section;
+}
+
+export interface AppContextBuilders {
+  getAgentLlm: (config: BaseAgentConfig, events: AgentEventBus, agentName?: AgentName) => Promise<BaseChatModel>;
+  getAgentMemory: (config: BaseAgentConfig, events: AgentEventBus, agentName?: AgentName) => Promise<AgentMemory>;
+  getAgentTools: (config: BaseAgentConfig, events: AgentEventBus, agentName?: AgentName) => Promise<BotTool[]>;
+  createAgentLlm: (config: BaseAgentConfig, events: AgentEventBus, agentName?: AgentName) => Promise<BaseChatModel>;
+  createAgentMemory: (config: BaseAgentConfig, events: AgentEventBus, agentName?: AgentName) => Promise<AgentMemory>;
+  createAgentTools: (config: BaseAgentConfig, events: AgentEventBus, agentName?: AgentName) => Promise<BotTool[]>;
+  createAgent: (options?: CreateContextOptions<BotTool>) => Promise<BotContext>;
+  createBotContext: (configPath?: string, agentName?: AgentName) => Promise<BotContext>;
+}
+
+/**
+ * Resolve skills directory path from either a YAML config file or a direct path.
+ * If the path ends with .yaml/.yml, loads the YAML and extracts the `path:` field.
+ */
+async function resolveSkillsDir(skillsPath: string): Promise<string> {
+  if (/\.ya?ml$/i.test(skillsPath)) {
+    const raw = await loadYamlFile<{ path?: string }>(skillsPath);
+    const spec = asObject((raw as { spec?: unknown } | undefined)?.spec);
+    const pathRef = typeof spec?.path === "string" ? spec.path : raw?.path;
+    if (!pathRef) {
+      throw new Error(`skills config missing "path" field: ${skillsPath}`);
+    }
+    return resolve(dirname(skillsPath), pathRef);
+  }
+  return skillsPath;
+}

package/src/index.ts

@@ -1,37 +1,39 @@
 export {
   createContextBuilders,
-  createAppContext,
   type AppContextBuilders,
-  type BaseAppConfig,
+  type BaseAgentConfig,
   type BotContext,
   type BotTool,
   type CreateContextOptions,
   type ConfigApi,
-} from "./context.js";
+} from "./core/context.js";
 
 export {
   createReactAgent,
   printReactSteps,
   type ReactAgentOptions,
   type ReactAgentRuntime,
-} from "./react-agent.js";
+} from "./agents/react-agent.js";
 
 export {
   createDeepAgent,
   type DeepAgentOptions,
   type DeepAgentRuntime,
-} from "./deep-agent.js";
+} from "./agents/deep-agent.js";
 
 export {
   createConfigApi,
-  loadAppConfig,
+  createRuntimeConfig,
+  loadAgentConfig,
   getModelsConfigPath,
   getMemoryConfigPath,
   getToolConfigPath,
-  type AppConfig,
-  type AppConfigDefaults,
+  resolveDefaultAgentName,
+  type CreateRuntimeConfigOptions,
+  type AgentRuntimeConfig,
+  type AgentConfigDefaults,
   type AgentProfileConfig,
-} from "./config.js";
+} from "./config/index.js";
 
 export {
   runAppCli,
@@ -43,11 +45,11 @@ export {
 export {
   malformedToolCallMiddleware,
   type MalformedToolCallMiddlewareConfig,
-} from "./malformed-tool-call-middleware.js";
+} from "./middleware/malformed-tool-call-middleware.js";
 
 export {
   createSubAgentRunner,
   type SubAgentRunner,
   type SubAgentOptions,
   type SubAgentResult,
-} from "./sub-agent.js";
+} from "./agents/sub-agent.js";

package/src/middleware/malformed-tool-call-middleware.ts

@@ -0,0 +1,239 @@
+/**
+ * Middleware that recovers from malformed tool call errors produced by OSS LLMs.
+ *
+ * When models like Ollama-hosted open-source LLMs mix chain-of-thought reasoning
+ * into tool call JSON arguments, the server returns a 500 parsing error.
+ * This middleware catches those errors, extracts the valid JSON from the raw text,
+ * and constructs a proper AIMessage so the agent loop can continue.
+ */
+import { createMiddleware } from "langchain";
+import { AIMessage } from "@langchain/core/messages";
+
+export interface MalformedToolCallMiddlewareConfig {
+  /** Maximum retry attempts after JSON extraction fails. Default: 1 */
+  maxRetries?: number;
+  /** Log recovery attempts to stderr. Default: true */
+  verbose?: boolean;
+}
+
+interface OllamaToolCallError {
+  rawText: string;
+}
+
+interface ExtractedToolCall {
+  toolName: string;
+  args: Record<string, unknown>;
+  id?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Detect Ollama "500 error parsing tool call" errors and extract the raw text.
+ * Error format: `500 error parsing tool call: raw='<raw_text>', err=invalid character...`
+ */
+function parseOllamaToolCallError(err: Error): OllamaToolCallError | null {
+  const msg = err.message;
+  const rawMatch = msg.match(/error parsing tool call.*?raw='(.+?)',\s*err=/s);
+  if (!rawMatch) return null;
+  return { rawText: rawMatch[1] };
+}
+
+/**
+ * Extract valid JSON object from a string that may contain leading non-JSON text.
+ * Uses brace-depth counting to find matching `{...}` blocks.
+ */
+function extractJsonObject(text: string): Record<string, unknown> | null {
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] !== "{") continue;
+
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    let end = -1;
+
+    for (let j = i; j < text.length; j++) {
+      const ch = text[j];
+      if (escape) {
+        escape = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escape = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = !inString;
+        continue;
+      }
+      if (inString) continue;
+      if (ch === "{") depth++;
+      else if (ch === "}") {
+        depth--;
+        if (depth === 0) {
+          end = j;
+          break;
+        }
+      }
+    }
+    if (end === -1) continue;
+
+    const candidate = text.slice(i, end + 1);
+    try {
+      const parsed = JSON.parse(candidate) as unknown;
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        return parsed as Record<string, unknown>;
+      }
+    } catch {
+      // not valid JSON from this position, try next '{'
+    }
+  }
+  return null;
+}
+
+/**
+ * Match extracted JSON keys against available tool schemas to infer the tool name.
+ */
+function matchToolByArgs(
+  args: Record<string, unknown>,
+  tools: ReadonlyArray<{ name: string; schema?: unknown }>,
+): string | null {
+  const argKeys = new Set(Object.keys(args));
+  let bestMatch: string | null = null;
+  let bestScore = 0;
+
+  for (const tool of tools) {
+    const schema = tool.schema as
+      | { properties?: Record<string, unknown> }
+      | { shape?: Record<string, unknown> }
+      | null
+      | undefined;
+    const propKeys =
+      (schema && "properties" in schema && schema.properties
+        ? Object.keys(schema.properties)
+        : schema && "shape" in schema && schema.shape
+          ? Object.keys(schema.shape)
+          : null);
+    if (!propKeys) continue;
+
+    let score = 0;
+    for (const key of argKeys) {
+      if (propKeys.includes(key)) score++;
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      bestMatch = tool.name;
+    }
+  }
+  return bestMatch;
+}
+
+function generateToolCallId(): string {
+  return `call_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// ---------------------------------------------------------------------------
+// Middleware
+// ---------------------------------------------------------------------------
+
+export function malformedToolCallMiddleware(
+  config?: MalformedToolCallMiddlewareConfig,
+) {
+  const maxRetries = config?.maxRetries ?? 1;
+  const verbose = config?.verbose ?? true;
+
+  const log = verbose
+    ? (msg: string) => console.error(`[malformedToolCallRecovery] ${msg}`)
+    : () => {};
+
+  function tryExtract(
+    rawText: string,
+    tools: ReadonlyArray<{ name: string; schema?: unknown }>,
+  ): ExtractedToolCall | null {
+    const args = extractJsonObject(rawText);
+    if (!args) return null;
+
+    const toolName =
+      matchToolByArgs(args, tools) ?? tools[0]?.name ?? "unknown_tool";
+    return { toolName, args, id: generateToolCallId() };
+  }
+
+  function buildAIMessage(tc: ExtractedToolCall): AIMessage {
+    return new AIMessage({
+      content: "",
+      tool_calls: [{ name: tc.toolName, args: tc.args, id: tc.id }],
+    });
+  }
+
+  return createMiddleware({
+    name: "malformedToolCallRecovery",
+
+    wrapModelCall: async (request, handler) => {
+      // --- Normal call ---
+      try {
+        return await handler(request);
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        const parsed = parseOllamaToolCallError(err);
+        if (!parsed) throw err; // not our error type
+
+        log("Caught malformed tool call error. Attempting JSON extraction...");
+
+        // Cast tools to access name/schema for matching
+        const req = request as unknown as Record<string, unknown>;
+        const tools = (req.tools ?? []) as ReadonlyArray<{
+          name: string;
+          schema?: unknown;
+        }>;
+        const systemPrompt = req.systemPrompt as string | undefined;
+
+        // --- Strategy A: extract JSON directly from the error text ---
+        const extracted = tryExtract(parsed.rawText, tools);
+        if (extracted) {
+          log(`Extracted JSON for tool "${extracted.toolName}".`);
+          return buildAIMessage(extracted);
+        }
+
+        // --- Strategy B: retry with enhanced prompt ---
+        log(`JSON extraction failed. Retrying (${maxRetries} attempts)...`);
+
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+          try {
+            const retryRequest = {
+              ...request,
+              systemPrompt:
+                (systemPrompt ?? "") +
+                "\n\nCRITICAL: Tool call arguments MUST be a single valid JSON object. " +
+                "Do NOT include any reasoning text before or after the JSON.",
+            };
+            return await handler(retryRequest);
+          } catch (retryError) {
+            const retryErr =
+              retryError instanceof Error
+                ? retryError
+                : new Error(String(retryError));
+            const retryParsed = parseOllamaToolCallError(retryErr);
+            if (retryParsed) {
+              const retryExtracted = tryExtract(retryParsed.rawText, tools);
+              if (retryExtracted) {
+                log(`Extracted JSON on retry ${attempt + 1} for tool "${retryExtracted.toolName}".`);
+                return buildAIMessage(retryExtracted);
+              }
+            }
+            log(`Retry ${attempt + 1}/${maxRetries} failed.`);
+          }
+        }
+
+        // --- All strategies exhausted ---
+        log("All recovery attempts failed. Returning error to agent loop.");
+        return new AIMessage({
+          content:
+            "Tool call failed due to malformed output from the model. " +
+            "Please try a simpler command or rephrase your request.",
+        });
+      }
+    },
+  });
+}

package/src/types/markdown-it-terminal.d.ts

@@ -0,0 +1,4 @@
+declare module "markdown-it-terminal" {
+  const plugin: (...args: unknown[]) => void;
+  export default plugin;
+}

package/src/types/marked-terminal.d.ts

@@ -0,0 +1,16 @@
+declare module "marked-terminal" {
+  import type { MarkedExtension } from "marked";
+
+  export interface MarkedTerminalOptions {
+    [key: string]: unknown;
+  }
+
+  export interface HighlightOptions {
+    [key: string]: unknown;
+  }
+
+  export function markedTerminal(
+    options?: MarkedTerminalOptions,
+    highlightOptions?: HighlightOptions,
+  ): MarkedExtension;
+}

package/dist/config.d.ts

@@ -1,86 +0,0 @@
-import type { ConfigApi, BaseAppConfig } from "./context.js";
-/** Resolved skills configuration for an agent. */
-export interface SkillsConfig {
-    path: string;
-    mode?: "prompt" | "subagent";
-    inject_metadata?: boolean;
-    embedding_threshold?: number;
-    keyword_threshold?: number;
-}
-export type AgentProfileConfig = {
-    path?: string;
-    models?: {
-        path?: string;
-    };
-    llm?: {
-        path?: string;
-    };
-    memory?: {
-        path?: string;
-        namespace?: string;
-        top_k?: number;
-        budget_tokens?: number;
-        auto_write?: boolean;
-        auto_write_scope?: "thread" | "cross_thread" | "knowledge" | "auto";
-        auto_write_max_chars?: number;
-        auto_write_user?: boolean;
-        auto_write_assistant?: boolean;
-    };
-    tools?: {
-        path?: string;
-        development?: string;
-        production?: string;
-    };
-    skills?: {
-        path?: string;
-        mode?: "prompt" | "subagent";
-        inject_metadata?: boolean;
-        embedding_threshold?: number;
-        keyword_threshold?: number;
-    };
-    system_prompt?: string;
-    max_steps?: number;
-    print_steps?: boolean;
-    fallback_text?: string;
-    command_window_label?: string;
-    recursion_limit?: number;
-    memories_path?: string;
-};
-export interface AppConfig extends BaseAppConfig {
-    app?: {
-        name?: string;
-        env?: string;
-        memory?: {
-            namespace_mode?: "thread" | "fixed";
-            namespace?: string;
-        };
-        agent?: Record<string, AgentProfileConfig>;
-    };
-}
-export interface AppConfigDefaults {
-    /** Default models config path, e.g. "config/agents/shared/models.yaml" */
-    modelsPath?: string;
-    /** Default memory config path, e.g. "config/agents/shared/memory.yaml" */
-    memoryPath?: string;
-    /** Default tool config path, e.g. "config/agents/shared/tool.yaml" */
-    toolPath?: string;
-    /** Default tool config path for development */
-    toolDevPath?: string;
-    /** Default tool config path for production */
-    toolProdPath?: string;
-}
-export declare function loadAppConfig(configPath?: string): Promise<AppConfig>;
-export declare function getModelsConfigPath(config?: AppConfig, agentName?: string, defaults?: AppConfigDefaults): string;
-export declare function getMemoryConfigPath(config?: AppConfig, agentName?: string, defaults?: AppConfigDefaults): string;
-export declare function getToolConfigPath(config: AppConfig | undefined, agentName: string | undefined, defaults?: AppConfigDefaults): string;
-/**
- * Create a ConfigApi suitable for `createContextBuilders`.
- * Apps can supply defaults (e.g. custom tool paths) or use the built-in ones.
- */
-export declare function createConfigApi(defaults?: AppConfigDefaults): ConfigApi<AppConfig>;
-/**
- * Resolve the SkillsConfig for a given agent, if configured.
- * Resolves relative `path` to absolute using APP_ROOT.
- */
-export declare function getSkillsConfig(config: AppConfig | undefined, agentName?: string): SkillsConfig | undefined;
-//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"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"}