@agent-smith/core 0.0.1

package/README.md

@@ -0,0 +1,378 @@
+[![npm version](https://img.shields.io/npm/v/@agent-smith/core)](https://www.npmjs.com/package/@agent-smith/core)
+
+# @agent-smith/core — Runtime Engine
+
+The central runtime engine for the [Agent Smith toolkit](https://github.com/lynxai-team/agent-smith). Provides SQLite-backed configuration management, filesystem-based feature discovery, a unified tool execution engine, and Model Context Protocol (MCP) client integration.
+
+## ✨ Features
+
+- 🗄️ **SQLite Configuration** — 17-table database for features, backends, plugins, settings, and workspaces
+- 🔍 **Feature Discovery** — Scans directories for agents, actions, workflows, commands, adaptaters, and skills
+- ⚡ **Unified Tool Execution** — Execute actions (JS/Python/YAML), agents, workflows, and commands through a common interface
+- 🌐 **MCP Client** — Connect to external MCP servers and expose their tools as `ToolSpec` objects
+- 🔧 **Multi-Language Support** — JavaScript (ESM), Python (`python-shell`), and YAML/shell actions
+- 📡 **Reactive State** — Vue `ref`/`reactive` for cross-module state management
+- 🔄 **Backend Agnostic** — Multiple inference backends (OpenAI-compatible, local llamacpp) with per-agent selection
+
+## Documentation
+
+### For AI Agents
+- [Codebase Summary](.agents/documentation/codebase-summary.md) — Architecture, key files, and patterns for the core package
+- [Configuration](https://raw.githubusercontent.com/lynxai-team/agent-smith/refs/heads/main/docsite/public/doc/libraries/core/2.configuration.md) — Configuration file format, loading, and management
+- [Feature Discovery](https://raw.githubusercontent.com/lynxai-team/agent-smith/refs/heads/main/docsite/public/doc/libraries/core/3.feature-discovery.md) — Directory structure, discovery process, and SQLite registration
+- [Tool Execution](https://raw.githubusercontent.com/lynxai-team/agent-smith/refs/heads/main/docsite/public/doc/libraries/core/4.tool-execution.md) — Execution functions, multi-language support, and error handling
+- [MCP Client](https://raw.githubusercontent.com/lynxai-team/agent-smith/refs/heads/main/docsite/public/doc/libraries/core/5.mcp.md) — MCP server connection, tool extraction, and agent integration
+
+### For Humans
+- [Get Started](https://lynxai-team.github.io/agent-smith/libraries/core/get_started) — Installation and basic usage
+- [Configuration](https://lynxai-team.github.io/agent-smith/libraries/core/configuration) — Configuration file format, loading, and management
+- [Feature Discovery](https://lynxai-team.github.io/agent-smith/libraries/core/feature-discovery) — Directory structure, discovery process, and SQLite registration
+- [Tool Execution](https://lynxai-team.github.io/agent-smith/libraries/core/tool-execution) — Execution functions, multi-language support, and error handling
+- [MCP Client](https://lynxai-team.github.io/agent-smith/libraries/core/mcp) — MCP server connection, tool extraction, and agent integration
+
+## 📦 Installation
+
+```bash
+npm install @agent-smith/core
+```
+
+**Dependencies:** `@agent-smith/types`, `better-sqlite3`, `@vue/reactivity`, `yaml`, `@modelcontextprotocol/sdk`, `python-shell`
+
+## 🚀 Quick Start
+
+```typescript
+import { conf, db, executeAction, executeWorkflow, McpClient } from "@agent-smith/core";
+
+// Initialize the database and process configuration
+await conf.updateConfCmd(["conf"]);
+
+// Discover and register features from configured paths
+await conf.updateFeaturesCmd({});
+
+// Execute an action by name
+const result = await executeAction("read", ["./file.txt"], {});
+
+// Or run a workflow that chains multiple steps
+const workflowResult = await executeWorkflow("my-workflow", ["arg1"], {});
+```
+
+## 📖 Usage
+
+### Configuration Management
+
+Load and manage configuration from YAML files:
+
+```typescript
+import { conf } from "@agent-smith/core";
+
+// Process an existing config file
+const { paths, pf, dd } = await conf.processConfPath("~/.config/agent-smith/config.yml");
+// paths: Array<string> — all feature search paths
+// pf: string — prompt file path
+// dd: string — data directory path
+
+// Create a default config if none exists
+const fp = conf.createConfigFileIfNotExists();
+
+// Get platform-specific config paths
+const { confDir, dbPath } = conf.getConfigPath("agent-smith", "config.db");
+```
+
+### Feature Discovery
+
+Discover and register features from filesystem directories:
+
+```typescript
+import { getFeatureSpec, conf } from "@agent-smith/core";
+
+// Re-scan all registered feature paths
+await conf.updateFeaturesCmd({});
+
+// Look up a feature by name and type
+const spec = getFeatureSpec("writer", "agent");
+if (spec.found) {
+  console.log(spec.path);   // Full file path
+  console.log(spec.ext);    // File extension
+  console.log(spec.variables); // Variable definitions
+}
+```
+
+### Tool Execution
+
+Execute actions, workflows, and agents:
+
+```typescript
+import { executeAction, executeWorkflow, executeAgent } from "@agent-smith/core";
+
+// Execute a JavaScript action
+const result = await executeAction("read", ["./file.txt"], {});
+
+// Execute a YAML action (shell command)
+const grepResult = await executeAction("grep", ["error"], {});
+
+// Execute a Python action
+const pythonResult = await executeAction("analyze", ["data.csv"], {});
+
+// Run a workflow chaining multiple steps
+const pipelineResult = await executeWorkflow("data-pipeline", ["input.csv"], {
+  verbose: true,
+  debug: false
+});
+
+// Execute an agent with inference
+const agentResult = await executeAgent("writer", ["AI trends"], {
+  model: "llama3",
+  temperature: 0.7
+});
+```
+
+### Agent Executor
+
+Create a full agent execution context:
+
+```typescript
+import { useAgentExecutor } from "@agent-smith/core";
+
+const executor = await useAgentExecutor("researcher", { prompt: "Analyze the data" }, {});
+const result = await executor.execute();
+// Returns: InferenceResult
+```
+
+The executor handles backend resolution, MCP server initialization, grammar compilation, and streaming.
+
+### Reactive State
+
+Access and manage reactive state:
+
+```typescript
+import { state } from "@agent-smith/core";
+
+// List all inference backends
+const backends = state.listBackends();
+
+// Set the default backend
+await state.setBackend("openai");
+
+// Get per-agent inference settings
+const settings = state.getAgentSettings();
+```
+
+### MCP Client
+
+Connect to external MCP servers:
+
+```typescript
+import { McpClient } from "@agent-smith/core";
+
+const client = new McpClient(
+  "filesystem",                    // server name
+  "npx",                           // command
+  ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"], // args
+  null,                            // authorizedTools (null = all allowed)
+  null                             // askUserTools (null = no confirmation needed)
+);
+
+// Start the server connection
+await client.start();
+
+// Extract tools as ToolSpec objects
+const tools = await client.extractTools({ confirmToolUsage });
+
+// Stop the connection
+await client.stop();
+```
+
+## 🔧 Complete Example
+
+A full working example demonstrating configuration, feature discovery, and execution:
+
+```typescript
+import {
+  conf,
+  db,
+  state,
+  executeAction,
+  executeWorkflow,
+  useAgentExecutor,
+  getFeatureSpec,
+  McpClient
+} from "@agent-smith/core";
+
+async function main() {
+  // Step 1: Initialize database and configuration
+  console.log("Initializing...");
+  await conf.updateConfCmd(["conf"]);
+  
+  // Verify state readiness
+  if (!state.isStateReady()) {
+    throw new Error("Configuration not loaded");
+  }
+
+  // Step 2: Discover features from all registered paths
+  console.log("Discovering features...");
+  await conf.updateFeaturesCmd({});
+
+  // Step 3: Look up a feature
+  const agentSpec = getFeatureSpec("writer", "agent");
+  if (!agentSpec.found) {
+    throw new Error("Writer agent not found");
+  }
+  console.log(`Found agent at: ${agentSpec.path}`);
+
+  // Step 4: Execute an action
+  console.log("Executing read action...");
+  const fileContent = await executeAction("read", ["./README.md"], {});
+  console.log(`File content length: ${fileContent.length}`);
+
+  // Step 5: Run a workflow
+  console.log("Running workflow...");
+  try {
+    const result = await executeWorkflow("my-pipeline", ["input.txt"], {
+      verbose: true
+    });
+    console.log("Workflow completed:", result);
+  } catch (e) {
+    console.error("Workflow failed:", e.message);
+  }
+
+  // Step 6: Execute an agent
+  console.log("Running agent...");
+  try {
+    const executor = await useAgentExecutor("writer", { prompt: "Write about AI" }, {});
+    const inferenceResult = await executor.execute();
+    console.log("Agent response:", inferenceResult.content);
+  } catch (e) {
+    console.error("Agent execution failed:", e.message);
+  }
+
+  // Step 7: Use MCP client for external tools
+  console.log("Setting up MCP client...");
+  const mcpClient = new McpClient(
+    "filesystem",
+    "npx",
+    ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
+  );
+  
+  try {
+    await mcpClient.start();
+    const tools = await mcpClient.extractTools({ confirmToolUsage: async () => true });
+    console.log(`Loaded ${tools.length} MCP tools`);
+  } finally {
+    await mcpClient.stop();
+  }
+
+  console.log("Done!");
+}
+
+main().catch(console.error);
+```
+
+## 📋 API Reference
+
+### Named Exports
+
+| Export | Type | Description |
+|--------|------|-------------|
+| `db` | `object` | Database operations: `init`, `...readOps`, `...writeOps`, `db` (raw better-sqlite3) |
+| `fs` | `object` | Filesystem helpers: `openAgentSpec`, `readWorkflow` |
+| `conf` | `object` | Configuration management: `getConfigPath`, `processConfPath`, `updateConfigFile`, etc. |
+| `utils` | `object` | Utilities: `execute`, `runShellCmd`, `deleteFileIfExists`, `readAgent`, etc. |
+| `state` | `object` | Reactive state: `init`, `initState`, `setBackend`, `listBackends`, `agentSettings`, etc. |
+| `executeAction` | `function` | Execute an action by name |
+| `executeWorkflow` | `function` | Execute a workflow by name |
+| `executeAgent` | `function` | Execute an agent by name |
+| `useAgentExecutor` | `function` | Create an agent execution context |
+| `getFeatureSpec` | `function` | Look up a feature by name and type |
+| `extractToolDoc` | `function` | Extract tool specification from a feature file |
+| `McpClient` | `class` | MCP server client for external tool integration |
+
+### `executeAction(name, payload, options)`
+
+Executes an action by name, resolving it from the SQLite database.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `name` | `string` | Action name (matches registered feature) |
+| `payload` | `Array<string>` | Arguments passed to the action |
+| `options` | `object` | Execution options (`debug`, `verbose`) |
+
+**Returns:** `Promise<any>` — Action result
+
+**Dispatch by extension:**
+- `.js`: Dynamically imports and calls exported `action(args, options)`
+- `.yml`: Executes YAML-defined shell command with args
+- `.py`: Runs via `python-shell` package
+
+### `executeWorkflow(name, args, options)`
+
+Executes a workflow as a sequence of steps (agent/action/adaptater/cmd).
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `name` | `string` | Workflow name |
+| `args` | `Array<string>` | Initial arguments for the first step |
+| `options` | `object` | Execution options (`verbose`, `debug`) |
+
+**Returns:** `Promise<any>` — Result of the final step
+
+### `executeAgent(name, args, options)`
+
+Executes an agent by resolving its prompt and running inference.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `name` | `string` | Agent name |
+| `args` | `Array<string>` | Arguments for prompt generation |
+| `options` | `object` | Inference options (`model`, `temperature`, etc.) |
+
+**Returns:** `Promise<InferenceResult>` — Agent inference result
+
+### `useAgentExecutor(name, payload, options)`
+
+Creates an agent execution context with full setup.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `name` | `string` | Agent name |
+| `payload` | `object` | Payload including `prompt` and optional context |
+| `options` | `object` | Execution options |
+
+**Returns:** `Promise<{ execute: () => Promise<InferenceResult> }>`
+
+### `getFeatureSpec(name, type)`
+
+Looks up a feature in the SQLite database.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `name` | `string` | Feature name |
+| `type` | `"agent" \| "action" \| "workflow" \| "adaptater" \| "cmd" \| "skill"` | Feature type |
+
+**Returns:** `{ found: boolean; path?: string; ext?: string; variables?: Record<string, any> }`
+
+### `McpClient` Class
+
+| Constructor | `(servername: string, command: string, args: Array<string>, authorizedTools?: Array<string> \| null, askUserTools?: Array<string> \| null)` |
+|-------------|--------------------------------------------------------------------------------------------------------------------------|
+| `start()` | `async () => Promise<void>` — Connect to the MCP server via stdio transport |
+| `stop()` | `async () => Promise<void>` — Close the connection |
+| `extractTools(options)` | `async (options: { confirmToolUsage?: Function }) => Promise<Array<ToolSpec>>` — Extract tools as ToolSpec objects |
+
+## ⚠️ Important Notes
+
+- **Node.js Environment**: This package is designed for Node.js environments. It depends on `better-sqlite3` which requires native compilation.
+- **SQLite First Run**: The database is initialized automatically on first use with 17 tables. No manual migration needed.
+- **Feature Discovery Required**: Before executing features, you must call `conf.updateConfCmd()` and `conf.updateFeaturesCmd()` to discover and register them.
+- **Python Actions**: Require `python-shell` package and a working Python installation.
+- **MCP Servers**: External MCP servers are spawned as child processes. Ensure required binaries (e.g., `npx`) are available.
+- **Related Packages**: See `@agent-smith/types` for shared interfaces, `@agent-smith/agent` for the Agent class, `@agent-smith/cli` for CLI usage.
+
+## 📖 Documentation Links
+
+- [Full docsite](https://lynxai-team.github.io/agent-smith/) — Complete project documentation
+- [Architecture Overview](https://lynxai-team.github.io/agent-smith/architecture/overview) — System architecture and design principles
+- [Tool Abstraction](https://lynxai-team.github.io/agent-smith/architecture/tool-abstraction) — Unified `ToolSpec` interface
+
+## 📄 License
+
+MIT

package/dist/actions/cmd.d.ts

@@ -0,0 +1,5 @@
+import { FeatureExecutor } from "@agent-smith/types";
+declare function executeAction(name: string, payload: any, options: Record<string, any>, quiet?: boolean): Promise<any>;
+declare function systemAction(path: string): FeatureExecutor<Array<string>, any>;
+declare function pythonAction(path: string, options: Record<string, any>): FeatureExecutor<Array<string>>;
+export { executeAction, pythonAction, systemAction };

package/dist/actions/cmd.js

@@ -0,0 +1,135 @@
+import { pathToFileURL } from 'url';
+import { getFeatureSpec } from '../state/features.js';
+import { pyShell } from "../state/state.js";
+import { getInputFromOptions, processOutput } from "../utils/io.js";
+import { execute } from "../utils/sys/execute.js";
+import { readYmlFile } from "../utils/sys/read_yml_file.js";
+import { runPyScript } from "../utils/sys/run_python.js";
+import { runtimeError } from "../utils/user_msgs.js";
+import { createJsAction } from "./read.js";
+async function executeAction(name, payload, options, quiet = false) {
+    let run;
+    //console.log("GET ACTION", name, payload);
+    const inputData = await getInputFromOptions(options);
+    if (inputData) {
+        if (Array.isArray(payload)) {
+            payload.push(inputData);
+        }
+    }
+    const { found, path, ext } = getFeatureSpec(name, "action");
+    if (!found) {
+        throw new Error(`Action ${name} not found at ${path}`);
+    }
+    //console.log("CREATE ACTION", name, ext, path);
+    switch (ext) {
+        case "js":
+            const url = pathToFileURL(path).href;
+            //console.log("CR JSA", url);
+            const mjsa = await import(/* @vite-ignore */ url);
+            run = createJsAction(mjsa.action);
+            //console.log("END CR JSA")
+            break;
+        case "yml":
+            run = systemAction(path);
+            break;
+        case "py":
+            run = pythonAction(path, options);
+            break;
+        default:
+            throw new Error(`Action ext ${ext} not implemented`);
+    }
+    //console.log("RUN", payload);
+    const res = await run(payload, options);
+    if (!quiet) {
+        if (res) {
+            console.log(res);
+        }
+    }
+    await processOutput(res);
+    return res;
+}
+function systemAction(path) {
+    const run = async (params) => {
+        //console.log("SYS ACTION PARAMS", params);
+        let runArgs = new Array();
+        // convert args for tool calls
+        if (!Array.isArray(params)) {
+            try {
+                // obviously a tool call
+                if (typeof params == "string") {
+                    runArgs.push(params);
+                }
+                else {
+                    runArgs = Object.values(params);
+                }
+            }
+            catch (e) {
+                throw new Error(`wrong python action args: ${e}`);
+            }
+        }
+        else {
+            runArgs = params;
+        }
+        const actionSpec = readYmlFile(path);
+        if (!actionSpec.found) {
+            runtimeError("System action yml file", path, "not found");
+        }
+        //console.log("Yml action", JSON.stringify(actionSpec.data, null, "  "));
+        //console.log("Args", args)
+        if (!actionSpec.data?.args) {
+            actionSpec.data.args = [];
+        }
+        //console.log("EXEC", actionSpec.data.cmd, [...actionSpec.data.args, ...runArgs]);
+        const out = await execute(actionSpec.data.cmd, [...actionSpec.data.args, ...runArgs]);
+        return out.trim();
+    };
+    return run;
+}
+function pythonAction(path, options) {
+    const run = async (params) => {
+        //console.log("PY ACTION PARAMS", params);
+        let runArgs = new Array();
+        if (!Array.isArray(params)) {
+            try {
+                // obviously a tool call
+                if (typeof params == "string") {
+                    runArgs.push(params);
+                }
+                else {
+                    runArgs = Object.values(params);
+                }
+            }
+            catch (e) {
+                throw new Error(`wrong python action args: ${e}`);
+            }
+        }
+        else {
+            runArgs = params;
+        }
+        //console.log("Py action", path);
+        const { data, error } = await runPyScript(pyShell, "python3", path, runArgs);
+        /*console.log("----------------");
+        console.log("PYOUT", data);
+        console.log("----------------");*/
+        if (error) {
+            throw new Error(`python error: ${error}`);
+        }
+        let txt = data[0];
+        if (data.length > 1) {
+            txt = data.join("\n");
+        }
+        let final = txt;
+        /*if ((txt.startsWith("{") || txt.startsWith("[")) && !options?.isToolCall) {
+            try {
+                final = JSON.parse(txt)
+            } catch (e) {
+                console.warn("Can not parse json from python action", path, e)
+                //throw new Error(`python error: ${error}`)
+            }
+        }*/
+        console.log("PYTC TXT", final);
+        return final;
+    };
+    return run;
+}
+export { executeAction, pythonAction, systemAction };

package/dist/actions/read.d.ts

@@ -0,0 +1,3 @@
+import { FeatureExecutor } from "@agent-smith/types";
+declare function createJsAction(action: CallableFunction): FeatureExecutor;
+export { createJsAction };

package/dist/actions/read.js

@@ -0,0 +1,17 @@
+function createJsAction(action) {
+    const run = async (args, options) => {
+        //console.log("JS ACTION PARAMS", args);
+        try {
+            const res = await action(args, options);
+            return res;
+        }
+        catch (e) {
+            /*if (e?.text) {
+                throw new Error(`executing action:${e.text()}. Args: ${args}`);
+            }*/
+            throw new Error(`executing js action:${e}. Args: ${JSON.stringify(args, null, 2)}`);
+        }
+    };
+    return run;
+}
+export { createJsAction };

package/dist/adaptaters/cmd.d.ts

@@ -0,0 +1,2 @@
+declare function executeAdaptater(name: string, params: any, options: Record<string, any>): Promise<any>;
+export { executeAdaptater, };

package/dist/adaptaters/cmd.js

@@ -0,0 +1,39 @@
+import { getFeatureSpec } from "../state/features.js";
+import { createJsAction } from "../actions/read.js";
+import { pathToFileURL } from 'url';
+import { getInputFromOptions } from "../utils/io.js";
+async function executeAdaptater(name, params, options) {
+    /*if (params?.args) {
+        params = params.args;
+    }*/
+    const { found, path } = getFeatureSpec(name, "adaptater");
+    if (!found) {
+        throw new Error(`adaptater ${name} not found`);
+    }
+    const inputData = await getInputFromOptions(options);
+    if (inputData) {
+        if (Array.isArray(params)) {
+            params.push(inputData);
+        }
+    }
+    let run;
+    const url = pathToFileURL(path).href;
+    const jsa = await import(/* @vite-ignore */ url);
+    run = createJsAction(jsa.action);
+    let res;
+    try {
+        //console.log("ADAPT RUN PARAMS", params);
+        res = await run(params, options);
+        //console.log("ADAPT RES", res);
+    }
+    catch (e) {
+        throw new Error(`adaptater ${name}: ${e}`);
+    }
+    if (res?.error) {
+        throw res.error;
+    }
+    //await processOutput(res);
+    //console.log("ADRES", res);
+    return res;
+}
+export { executeAdaptater, };

package/dist/agents/cmd.d.ts

@@ -0,0 +1,3 @@
+import type { AgentInferenceOptions, InferenceResult } from "@agent-smith/types";
+declare function executeAgent(name: string, args: Array<any> | Record<string, any>, options: AgentInferenceOptions & Record<string, any>): Promise<InferenceResult>;
+export { executeAgent, };

package/dist/agents/cmd.js

@@ -0,0 +1,10 @@
+import { getAgentPrompt } from "../utils/io.js";
+import { useAgentExecutor } from "./useagent.js";
+async function executeAgent(name, args, options) {
+    //console.log("EXEC AGENT", args, "\n", options);
+    const prompt = await getAgentPrompt(name, args, options);
+    const exec = await useAgentExecutor(name, { prompt: prompt }, options);
+    const res = exec.execute();
+    return res;
+}
+export { executeAgent, };

package/dist/agents/conf.d.ts

@@ -0,0 +1,3 @@
+import type { InferenceParams } from "@agent-smith/types";
+declare function mergeInferParams(userInferParams: Record<string, any>, taskInferParams: InferenceParams): InferenceParams;
+export { mergeInferParams, };

package/dist/agents/conf.js

@@ -0,0 +1,9 @@
+function mergeInferParams(userInferParams, taskInferParams) {
+    const ip = taskInferParams;
+    //console.log("IP", ip);
+    for (const [k, v] of Object.entries(userInferParams)) {
+        ip[k] = v;
+    }
+    return ip;
+}
+export { mergeInferParams, };

package/dist/agents/files.d.ts

@@ -0,0 +1,3 @@
+import { type AgentSpec } from '@agent-smith/types';
+declare function applyFilePlaceholders(def: AgentSpec, baseDir: string): void;
+export { applyFilePlaceholders };

package/dist/agents/files.js

@@ -0,0 +1,40 @@
+import * as fs from 'fs';
+import * as path from 'path';
+function _replaceFilePlaceholders(text, baseDir) {
+    const fileRegex = /\{file:(.*?)\}/g;
+    // The replace function is called for each match
+    const resultText = text.replace(fileRegex, (match, filePath) => {
+        if (!baseDir) {
+            if (!path.isAbsolute(filePath)) {
+                throw new Error(`Can not replace relative file placeholder ${filePath} without a baseDir set. Use absolute paths or set a baseDir in options`);
+            }
+        }
+        // Resolve the absolute path relative to the baseDir (or current working directory)
+        const fullPath = path.resolve(baseDir, filePath);
+        try {
+            const fileContent = fs.readFileSync(fullPath, 'utf8');
+            return fileContent;
+        }
+        catch (error) {
+            const msg = `Error reading file placeholder at ${fullPath}: ${error}`;
+            throw new Error(msg);
+        }
+    });
+    return resultText;
+}
+function applyFilePlaceholders(def, baseDir) {
+    def.prompt = _replaceFilePlaceholders(def.prompt, baseDir);
+    if (def.template) {
+        if (def.template?.system) {
+            def.template.system = _replaceFilePlaceholders(def.template.system, baseDir);
+        }
+    }
+    if (def?.shots) {
+        def.shots.forEach(s => {
+            if (s?.assistant) {
+                s.assistant = _replaceFilePlaceholders(def.prompt, baseDir);
+            }
+        });
+    }
+}
+export { applyFilePlaceholders };

package/dist/agents/read.d.ts

@@ -0,0 +1,11 @@
+import type { AgentInferenceOptions, AgentSpec } from "@agent-smith/types";
+import { McpClient } from "../mcp.js";
+declare function readAgent(name: string, payload: {
+    prompt: string;
+} & Record<string, any>, options: AgentInferenceOptions & Record<string, any>): Promise<{
+    agentSpec: AgentSpec;
+    vars: Record<string, any>;
+    mcpServers: Array<McpClient>;
+    agentDir: string;
+}>;
+export { readAgent };