agentx-kit 0.4.0__tar.gz → 0.5.1__tar.gz

agentx_kit-0.5.1/.claude-plugin/marketplace.json

@@ -0,0 +1,15 @@
+{
+  "name": "agentx-kit",
+  "owner": { "name": "AgentX", "url": "https://github.com/muhammadyahiya/agentx-kit" },
+  "metadata": {
+    "description": "AgentX-Kit — scaffold agent projects from a prompt, in Claude Code.",
+    "version": "0.1.0"
+  },
+  "plugins": [
+    {
+      "name": "agentx-kit",
+      "source": "./integrations/claude-plugin",
+      "description": "Scaffold complete LangChain/CrewAI agent projects from a single problem statement via AgentX-Kit's MCP tools."
+    }
+  ]
+}

{agentx_kit-0.4.0 → agentx_kit-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentx-kit
-Version: 0.4.0
+Version: 0.5.1
 Summary: An open-source, provider-agnostic agentic framework + interactive project scaffolder for LangChain and CrewAI. Pick your LLM provider, agents, RAG, memory, MCP tools and skills — generate a ready-to-run uv project.
 Project-URL: Homepage, https://github.com/muhammadyahiya/agentx-kit
 Project-URL: Repository, https://github.com/muhammadyahiya/agentx-kit
@@ -123,6 +123,53 @@ agentx new                 # interactive wizard → scaffolds a uv project
 > The PyPI distribution is **`agentx-kit`**; the import name and CLI are **`agentx`**
 > (`pip install agentx-kit` → `import agentx` / `agentx --help`).
 
+## 🚀 60-second walkthrough
+```bash
+# 1. Install
+pip install "agentx-kit[all]"
+
+# 2. See what you can target
+agentx providers                      # 9 LLM providers + the env vars each needs
+
+# 3. Scaffold a complete project from one line (no keys needed to generate)
+agentx new --yes --name my-bot \
+  --provider openai \
+  --prompt "You are a support agent that answers from our docs."
+
+# 4. Run it
+cd my-bot && cp .env.example .env      # add your API key
+uv sync && uv run my-bot
+
+# 5. Tune prompts live (tokens, cost, quality, optimize) — optional UI
+pip install "agentx-kit[dashboard]" && agentx dashboard
+
+# 6. Use it from Claude / Copilot / Codex
+claude mcp add agentx-kit -- agentx mcp
+```
+Prefer guided? Just run `agentx new` (interactive wizard) or
+`agentx new --enterprise` for the full production stack
+(tracing, guardrails, FastAPI, Docker, CI, evals, caching).
+
+### 🧭 Command cheat-sheet
+| Command | What it does |
+|---|---|
+| `agentx new` | Interactive wizard → scaffold a uv project |
+| `agentx new --yes [opts]` | Non-interactive scaffold (`--enterprise` for the full pack) |
+| `agentx providers` | List LLM providers + required env vars |
+| `agentx prompt list/set/add/remove` | Manage an existing project's prompts (`-d` opens the dashboard) |
+| `agentx dashboard` | Prompt observability + optimization UI (`[dashboard]` extra) |
+| `agentx cache stats / clear` | Inspect/clear the LLM response cache |
+| `agentx mcp` | Run as an MCP server for Claude/Copilot/Codex |
+| `agentx mcp --print-config` | Print the client config for those tools |
+| `agentx version` | Show the installed version |
+
+### ▶️ Try the demos (no API keys needed)
+```bash
+bash examples/demo_local.sh     # verify local setup end-to-end
+python examples/demo_mcp.py     # test the Claude/Copilot MCP path (real handshake)
+```
+See [`examples/`](examples/) for details.
+
 ## 📦 Installation
 
 ### From PyPI (recommended)
@@ -291,6 +338,43 @@ The assistant calls AgentX-Kit's tools and you get a complete, runnable project:
 
 So from one sentence the assistant produces a pre-wired project (prompts already seeded from your use case), ready to `uv sync && uv run`.
 
+## 🧩 Editor & assistant integrations
+The same connector powers ready-made integrations (see [`integrations/`](integrations/)):
+
+- **VS Code extension** ([`integrations/vscode`](integrations/vscode)) — commands for
+  *New Agent Project*, *Open Prompt Dashboard*, *Add Prompt*, *Cache Stats*, and
+  *Register MCP Server for Copilot* (writes `.vscode/mcp.json`). Build with `vsce package`.
+- **GitHub Copilot** (agent mode) — add the MCP server via `.vscode/mcp.json`:
+  ```jsonc
+  { "servers": { "agentx-kit": { "command": "agentx", "args": ["mcp"] } } }
+  ```
+  (the VS Code command above writes this for you), then ask Copilot to build an agent.
+- **Claude Code plugin** ([`integrations/claude-plugin`](integrations/claude-plugin)):
+  ```text
+  /plugin marketplace add muhammadyahiya/agentx-kit
+  /plugin install agentx-kit@agentx-kit
+  /agentx-kit:new-agent a support agent that answers from our docs and serves an API
+  ```
+- **Claude Desktop / Codex** — add the connector config from `agentx mcp --print-config`.
+
+## 💾 Response caching (cost & latency saver)
+Caching is the top 2026 token-optimization lever. Turn on a **global LLM response
+cache** and every provider call is served from a local store on repeat — no code changes:
+
+```python
+from agentx import enable_caching, cache_stats
+enable_caching()                 # all get_chat_model(...) calls are cached
+...
+print(cache_stats())             # {'hit_rate': 0.6, 'tokens_saved': 12000, 'est_usd_saved': 0.024, ...}
+```
+```bash
+agentx cache stats               # hit rate + estimated tokens/$ saved
+agentx cache clear
+```
+Generated projects can enable it automatically (it's part of `--enterprise`), and the
+**dashboard's Trends tab shows live hit-rate and $ saved**. TTL-capable, SQLite-backed
+at `.agentx/llm_cache.sqlite`.
+
 ## 🏢 Enterprise pack
 Generate a production-shaped project with one flag — informed by a survey of
 CrewAI/LangGraph/create-llama/AgentStack/agno/pydantic-ai (see [RESEARCH.md](RESEARCH.md)):

{agentx_kit-0.4.0 → agentx_kit-0.5.1}/README.md

@@ -19,6 +19,53 @@ agentx new                 # interactive wizard → scaffolds a uv project
 > The PyPI distribution is **`agentx-kit`**; the import name and CLI are **`agentx`**
 > (`pip install agentx-kit` → `import agentx` / `agentx --help`).
 
+## 🚀 60-second walkthrough
+```bash
+# 1. Install
+pip install "agentx-kit[all]"
+
+# 2. See what you can target
+agentx providers                      # 9 LLM providers + the env vars each needs
+
+# 3. Scaffold a complete project from one line (no keys needed to generate)
+agentx new --yes --name my-bot \
+  --provider openai \
+  --prompt "You are a support agent that answers from our docs."
+
+# 4. Run it
+cd my-bot && cp .env.example .env      # add your API key
+uv sync && uv run my-bot
+
+# 5. Tune prompts live (tokens, cost, quality, optimize) — optional UI
+pip install "agentx-kit[dashboard]" && agentx dashboard
+
+# 6. Use it from Claude / Copilot / Codex
+claude mcp add agentx-kit -- agentx mcp
+```
+Prefer guided? Just run `agentx new` (interactive wizard) or
+`agentx new --enterprise` for the full production stack
+(tracing, guardrails, FastAPI, Docker, CI, evals, caching).
+
+### 🧭 Command cheat-sheet
+| Command | What it does |
+|---|---|
+| `agentx new` | Interactive wizard → scaffold a uv project |
+| `agentx new --yes [opts]` | Non-interactive scaffold (`--enterprise` for the full pack) |
+| `agentx providers` | List LLM providers + required env vars |
+| `agentx prompt list/set/add/remove` | Manage an existing project's prompts (`-d` opens the dashboard) |
+| `agentx dashboard` | Prompt observability + optimization UI (`[dashboard]` extra) |
+| `agentx cache stats / clear` | Inspect/clear the LLM response cache |
+| `agentx mcp` | Run as an MCP server for Claude/Copilot/Codex |
+| `agentx mcp --print-config` | Print the client config for those tools |
+| `agentx version` | Show the installed version |
+
+### ▶️ Try the demos (no API keys needed)
+```bash
+bash examples/demo_local.sh     # verify local setup end-to-end
+python examples/demo_mcp.py     # test the Claude/Copilot MCP path (real handshake)
+```
+See [`examples/`](examples/) for details.
+
 ## 📦 Installation
 
 ### From PyPI (recommended)
@@ -187,6 +234,43 @@ The assistant calls AgentX-Kit's tools and you get a complete, runnable project:
 
 So from one sentence the assistant produces a pre-wired project (prompts already seeded from your use case), ready to `uv sync && uv run`.
 
+## 🧩 Editor & assistant integrations
+The same connector powers ready-made integrations (see [`integrations/`](integrations/)):
+
+- **VS Code extension** ([`integrations/vscode`](integrations/vscode)) — commands for
+  *New Agent Project*, *Open Prompt Dashboard*, *Add Prompt*, *Cache Stats*, and
+  *Register MCP Server for Copilot* (writes `.vscode/mcp.json`). Build with `vsce package`.
+- **GitHub Copilot** (agent mode) — add the MCP server via `.vscode/mcp.json`:
+  ```jsonc
+  { "servers": { "agentx-kit": { "command": "agentx", "args": ["mcp"] } } }
+  ```
+  (the VS Code command above writes this for you), then ask Copilot to build an agent.
+- **Claude Code plugin** ([`integrations/claude-plugin`](integrations/claude-plugin)):
+  ```text
+  /plugin marketplace add muhammadyahiya/agentx-kit
+  /plugin install agentx-kit@agentx-kit
+  /agentx-kit:new-agent a support agent that answers from our docs and serves an API
+  ```
+- **Claude Desktop / Codex** — add the connector config from `agentx mcp --print-config`.
+
+## 💾 Response caching (cost & latency saver)
+Caching is the top 2026 token-optimization lever. Turn on a **global LLM response
+cache** and every provider call is served from a local store on repeat — no code changes:
+
+```python
+from agentx import enable_caching, cache_stats
+enable_caching()                 # all get_chat_model(...) calls are cached
+...
+print(cache_stats())             # {'hit_rate': 0.6, 'tokens_saved': 12000, 'est_usd_saved': 0.024, ...}
+```
+```bash
+agentx cache stats               # hit rate + estimated tokens/$ saved
+agentx cache clear
+```
+Generated projects can enable it automatically (it's part of `--enterprise`), and the
+**dashboard's Trends tab shows live hit-rate and $ saved**. TTL-capable, SQLite-backed
+at `.agentx/llm_cache.sqlite`.
+
 ## 🏢 Enterprise pack
 Generate a production-shaped project with one flag — informed by a survey of
 CrewAI/LangGraph/create-llama/AgentStack/agno/pydantic-ai (see [RESEARCH.md](RESEARCH.md)):

agentx_kit-0.5.1/examples/README.md

@@ -0,0 +1,28 @@
+# AgentX-Kit demos
+
+Two runnable demos to confirm your setup — **no API keys required** (scaffolding
+and insights are offline; LLM calls are optional).
+
+## 1. Local setup test
+Verifies the install, lists providers, scaffolds a demo project, and exercises
+prompt insights + the response cache.
+
+```bash
+pip install "agentx-kit[all]"
+bash examples/demo_local.sh
+```
+
+## 2. MCP connector test (the Claude / Copilot / Codex path)
+Spawns `agentx mcp` over stdio, does a real MCP handshake, lists the tools, and
+scaffolds a complete project from a one-line problem statement — exactly what an
+assistant does when connected.
+
+```bash
+pip install "agentx-kit[connector]"
+python examples/demo_mcp.py
+```
+
+Then wire it into Claude for real:
+```bash
+claude mcp add agentx-kit -- agentx mcp
+```

agentx_kit-0.5.1/examples/demo_local.sh

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+# AgentX-Kit — local setup smoke test. No API keys required.
+# Verifies the install, lists providers, scaffolds a demo project, and exercises
+# the prompt-insights + cache so you know everything works end-to-end.
+#
+#   bash examples/demo_local.sh
+set -euo pipefail
+
+# Resolve the CLI: prefer `agentx` on PATH, else `python -m agentx.cli`.
+if command -v agentx >/dev/null 2>&1; then
+  AGENTX="agentx"
+else
+  AGENTX="python -m agentx.cli"
+fi
+echo "▶ using: $AGENTX"
+
+echo; echo "==> 1) version"
+$AGENTX version
+
+echo; echo "==> 2) providers (no keys needed to list)"
+$AGENTX providers
+
+WORK="$(mktemp -d)"; trap 'echo; echo "demo project left at: $WORK"' EXIT
+echo; echo "==> 3) scaffold a demo project (local Ollama provider, no key)"
+( cd "$WORK" && $AGENTX new --yes --name demo-agent --provider ollama \
+    --prompt "You are a helpful onboarding assistant." --no-venv )
+echo "files:"
+find "$WORK/demo-agent" -maxdepth 3 -type f | sed "s|$WORK/||" | sort
+
+echo; echo "==> 4) prompt insights (offline)"
+python - <<'PY'
+from agentx import analyze_prompt, count_tokens
+a = analyze_prompt("You are a support agent. Goal: answer in JSON. Do not invent policy.", "gpt-4o-mini")
+print(f"  quality={a.quality_score}/100  tokens={a.tokens}  suggestions={len(a.suggestions)}")
+PY
+
+echo; echo "==> 5) response cache stats"
+$AGENTX cache stats || true
+
+echo; echo "✅ Local setup looks good."
+echo "Next: cd $WORK/demo-agent && uv sync && uv run demo-agent"
+echo "      $AGENTX dashboard           # prompt observability UI (needs [dashboard] extra)"

agentx_kit-0.5.1/examples/demo_mcp.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+"""AgentX-Kit — MCP connector demo (the same path Claude / Copilot / Codex use).
+
+Spawns `agentx mcp` over stdio, performs a real MCP handshake, lists tools, and
+calls them to scaffold a complete project from a one-line problem statement —
+exactly what an MCP client (Claude) does. No API keys required (scaffolding is
+template generation).
+
+    pip install "agentx-kit[connector]"
+    python examples/demo_mcp.py
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+import tempfile
+
+
+def _extract(result) -> dict:
+    """Pull a dict out of an MCP CallToolResult (structured or text content)."""
+    structured = getattr(result, "structuredContent", None)
+    if isinstance(structured, dict):
+        return structured.get("result", structured)
+    for block in getattr(result, "content", []) or []:
+        text = getattr(block, "text", None)
+        if text:
+            try:
+                return json.loads(text)
+            except json.JSONDecodeError:
+                return {"text": text}
+    return {}
+
+
+async def main() -> int:
+    try:
+        from mcp import ClientSession, StdioServerParameters
+        from mcp.client.stdio import stdio_client
+    except ImportError:
+        print("Install the connector extra first:  pip install 'agentx-kit[connector]'")
+        return 1
+
+    # Launch the same server Claude would (use this interpreter for portability).
+    params = StdioServerParameters(command=sys.executable, args=["-m", "agentx.cli", "mcp"])
+
+    print("▶ connecting to `agentx mcp` over stdio …")
+    async with stdio_client(params) as (read, write):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+
+            tools = await session.list_tools()
+            print("✓ connected. tools:", [t.name for t in tools.tools])
+
+            problem = "Build a customer-support agent that answers from our product docs and serves a REST API."
+            print(f"\n▶ recommend_project('{problem[:50]}…')")
+            rec = _extract(await session.call_tool("recommend_project", {"problem_statement": problem}))
+            print(f"  framework={rec.get('framework')}  features={rec.get('features')}")
+
+            out_dir = tempfile.mkdtemp(prefix="agentx-mcp-demo-")
+            print("\n▶ create_agent_project(…)")
+            res = _extract(await session.call_tool(
+                "create_agent_project",
+                {"problem_statement": problem, "output_dir": out_dir + "/support-bot"},
+            ))
+            if not res.get("ok"):
+                print("  ✗ failed:", res.get("error"))
+                return 1
+            print(f"  ✓ generated {len(res['file_tree'])} files at {res['target_dir']}")
+            print("    features:", res["features"])
+            print("    run:", res["next_steps"][-1])
+
+    print("\n✅ MCP connector works — Claude/Copilot/Codex can drive this exact flow.")
+    print("   Add it to Claude:  claude mcp add agentx-kit -- agentx mcp")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(asyncio.run(main()))

agentx_kit-0.5.1/integrations/claude-plugin/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "agentx-kit",
+  "version": "0.1.0",
+  "description": "Scaffold complete provider-agnostic LangChain/CrewAI agent projects from a single problem statement, via AgentX-Kit's MCP tools.",
+  "author": { "name": "AgentX" },
+  "homepage": "https://github.com/muhammadyahiya/agentx-kit",
+  "license": "MIT",
+  "keywords": ["agents", "scaffold", "langchain", "crewai", "mcp"]
+}

agentx_kit-0.5.1/integrations/claude-plugin/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "agentx-kit": {
+      "command": "agentx",
+      "args": ["mcp"]
+    }
+  }
+}

agentx_kit-0.5.1/integrations/claude-plugin/README.md

@@ -0,0 +1,29 @@
+# AgentX-Kit — Claude Code plugin
+
+Bundles AgentX-Kit's MCP server + a `/agentx-kit:new-agent` slash command so you
+can scaffold a complete agent project from a single problem statement inside
+Claude Code.
+
+## Prerequisite
+```bash
+pip install "agentx-kit[connector]"   # provides `agentx mcp`
+```
+
+## Install (from this repo's marketplace)
+```text
+/plugin marketplace add muhammadyahiya/agentx-kit
+/plugin install agentx-kit@agentx-kit
+```
+Then use it:
+```text
+/agentx-kit:new-agent a customer-support agent that answers from our docs and serves an API
+```
+
+## Or just add the MCP server (no plugin)
+```bash
+claude mcp add agentx-kit -- agentx mcp
+```
+
+The plugin ships:
+- `.mcp.json` — registers the `agentx-kit` MCP server (`agentx mcp`).
+- `commands/new-agent.md` — the `/agentx-kit:new-agent` workflow.

agentx_kit-0.5.1/integrations/claude-plugin/commands/new-agent.md

@@ -0,0 +1,14 @@
+---
+description: Scaffold a complete AgentX-Kit agent project from a problem statement
+argument-hint: <describe the agent / use case you want to build>
+---
+Build a complete, runnable agent project for this request using the AgentX-Kit MCP tools:
+
+**$ARGUMENTS**
+
+Steps:
+1. Call `recommend_project` with the problem statement and briefly show the recommended stack (framework, provider, agents, features) + rationale.
+2. Ask the user to confirm or adjust (provider/framework/enterprise), then call `create_agent_project` with the problem statement and any overrides.
+3. Report the target directory, the generated file tree, and the exact run steps it returns. Offer to open key files (main.py, agents.py, prompts.json).
+
+Keep it concise; the tools do the heavy lifting.

agentx_kit-0.5.1/integrations/vscode/.vscodeignore

@@ -0,0 +1,4 @@
+.vscode/**
+**/*.map
+.gitignore
+node_modules/**

agentx_kit-0.5.1/integrations/vscode/README.md

@@ -0,0 +1,34 @@
+# AgentX-Kit — VS Code extension
+
+Scaffold agent projects, open the prompt dashboard, and wire AgentX-Kit into
+**GitHub Copilot** (agent mode) — without leaving VS Code.
+
+## Prerequisite
+```bash
+pip install "agentx-kit[all]"   # provides the `agentx` CLI the extension calls
+```
+
+## Commands (⇧⌘P)
+- **AgentX: New Agent Project** — name + use case → `agentx new`
+- **AgentX: Open Prompt Dashboard** — `agentx dashboard`
+- **AgentX: Add Agent Prompt** — `agentx prompt set … -d`
+- **AgentX: Show Response-Cache Stats** — `agentx cache stats`
+- **AgentX: Register MCP Server for Copilot** — writes `.vscode/mcp.json` so Copilot
+  agent mode can call AgentX-Kit's tools (e.g. *"build a support agent over our docs"*).
+
+Set a custom CLI path with the `agentx.command` setting.
+
+## Build / install locally
+```bash
+npm install -g @vscode/vsce
+cd integrations/vscode
+vsce package           # -> agentx-kit-0.1.0.vsix
+code --install-extension agentx-kit-0.1.0.vsix
+```
+
+## Publish (needs a Marketplace publisher + PAT)
+```bash
+vsce login <publisher>
+vsce publish
+```
+See https://code.visualstudio.com/api/working-with-extensions/publishing-extension.

agentx_kit-0.5.1/integrations/vscode/extension.js

@@ -0,0 +1,87 @@
+// AgentX-Kit VS Code extension.
+// Thin wrapper over the `agentx` CLI + MCP registration for Copilot/agent mode.
+// Pure JS (no build step). Requires `pip install agentx-kit` on PATH.
+const vscode = require("vscode");
+const fs = require("fs");
+const path = require("path");
+
+function cli() {
+  return vscode.workspace.getConfiguration("agentx").get("command", "agentx");
+}
+
+function runInTerminal(name, commandLine) {
+  const term = vscode.window.createTerminal({ name });
+  term.show();
+  term.sendText(commandLine);
+}
+
+function workspaceRoot() {
+  const folders = vscode.workspace.workspaceFolders;
+  return folders && folders.length ? folders[0].uri.fsPath : process.cwd();
+}
+
+async function newProject() {
+  const name = await vscode.window.showInputBox({
+    prompt: "Project name", value: "my-agent",
+  });
+  if (!name) return;
+  const problem = await vscode.window.showInputBox({
+    prompt: "Describe the use case (optional — seeds the agent's prompt)", value: "",
+  });
+  const enterprise = await vscode.window.showQuickPick(["No", "Yes (tracing, guardrails, FastAPI, Docker, CI, evals, cache)"], {
+    placeHolder: "Enterprise pack?",
+  });
+  let cmd = `${cli()} new --yes --name ${JSON.stringify(name)}`;
+  if (problem) cmd += ` --prompt ${JSON.stringify(problem)}`;
+  if (enterprise && enterprise.startsWith("Yes")) cmd += " --enterprise";
+  runInTerminal("AgentX: new", cmd);
+}
+
+function dashboard() {
+  runInTerminal("AgentX: dashboard", `${cli()} dashboard`);
+}
+
+async function addPrompt() {
+  const agent = await vscode.window.showInputBox({ prompt: "Agent name", value: "assistant" });
+  if (!agent) return;
+  const text = await vscode.window.showInputBox({ prompt: "System prompt" });
+  if (text === undefined) return;
+  runInTerminal("AgentX: prompt", `${cli()} prompt set ${JSON.stringify(agent)} --text ${JSON.stringify(text)} -d`);
+}
+
+function cacheStats() {
+  runInTerminal("AgentX: cache", `${cli()} cache stats`);
+}
+
+// Write .vscode/mcp.json so GitHub Copilot (agent mode) / VS Code can use AgentX-Kit's MCP server.
+async function registerMcp() {
+  const root = workspaceRoot();
+  const dir = path.join(root, ".vscode");
+  const file = path.join(dir, "mcp.json");
+  let config = { servers: {} };
+  try {
+    if (fs.existsSync(file)) config = JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch (e) { /* start fresh on parse error */ }
+  config.servers = config.servers || {};
+  config.servers["agentx-kit"] = { command: cli(), args: ["mcp"] };
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(config, null, 2));
+  vscode.window.showInformationMessage(
+    "AgentX-Kit MCP server registered in .vscode/mcp.json. Open Copilot Chat (Agent mode) and ask it to build an agent from a problem statement."
+  );
+  const doc = await vscode.workspace.openTextDocument(file);
+  vscode.window.showTextDocument(doc);
+}
+
+function activate(context) {
+  const reg = (id, fn) => context.subscriptions.push(vscode.commands.registerCommand(id, fn));
+  reg("agentx.newProject", newProject);
+  reg("agentx.dashboard", dashboard);
+  reg("agentx.addPrompt", addPrompt);
+  reg("agentx.cacheStats", cacheStats);
+  reg("agentx.registerMcp", registerMcp);
+}
+
+function deactivate() {}
+
+module.exports = { activate, deactivate };

agentx_kit-0.5.1/integrations/vscode/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "agentx-kit",
+  "displayName": "AgentX-Kit",
+  "description": "Scaffold provider-agnostic LangChain/CrewAI agent projects, open the prompt dashboard, and wire AgentX-Kit into Copilot — from VS Code.",
+  "version": "0.1.0",
+  "publisher": "agentx",
+  "engines": { "vscode": "^1.85.0" },
+  "categories": ["Machine Learning", "Snippets", "Other"],
+  "keywords": ["ai", "agents", "llm", "langchain", "crewai", "mcp", "scaffold", "copilot"],
+  "icon": "icon.png",
+  "repository": { "type": "git", "url": "https://github.com/muhammadyahiya/agentx-kit" },
+  "license": "MIT",
+  "main": "./extension.js",
+  "activationEvents": [],
+  "contributes": {
+    "commands": [
+      { "command": "agentx.newProject", "title": "AgentX: New Agent Project" },
+      { "command": "agentx.dashboard", "title": "AgentX: Open Prompt Dashboard" },
+      { "command": "agentx.addPrompt", "title": "AgentX: Add Agent Prompt" },
+      { "command": "agentx.cacheStats", "title": "AgentX: Show Response-Cache Stats" },
+      { "command": "agentx.registerMcp", "title": "AgentX: Register MCP Server for Copilot" }
+    ],
+    "configuration": {
+      "title": "AgentX-Kit",
+      "properties": {
+        "agentx.command": {
+          "type": "string",
+          "default": "agentx",
+          "description": "Path to the agentx CLI (from `pip install agentx-kit`)."
+        }
+      }
+    }
+  }
+}

{agentx_kit-0.4.0 → agentx_kit-0.5.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 # PyPI distribution name (import name + CLI stay `agentx`; `agentx` was taken).
 name = "agentx-kit"
-version = "0.4.0"
+version = "0.5.1"
 description = "An open-source, provider-agnostic agentic framework + interactive project scaffolder for LangChain and CrewAI. Pick your LLM provider, agents, RAG, memory, MCP tools and skills — generate a ready-to-run uv project."
 readme = "README.md"
 requires-python = ">=3.10,<3.14"

{agentx_kit-0.4.0 → agentx_kit-0.5.1}/src/agentx/__init__.py

@@ -16,7 +16,7 @@ is enough to get started.
 """
 from __future__ import annotations
 
-__version__ = "0.4.0"
+__version__ = "0.5.1"
 
 from .providers import (  # noqa: E402
     ProviderSpec,
@@ -39,6 +39,7 @@ from .insights import (  # noqa: E402
     estimate_cost,
     optimize_prompt,
 )
+from .cache import cache_stats, clear_cache, disable_caching, enable_caching  # noqa: E402
 
 __all__ = [
     "__version__",
@@ -63,4 +64,9 @@ __all__ = [
     "optimize_prompt",
     "count_tokens",
     "estimate_cost",
+    # response caching
+    "enable_caching",
+    "disable_caching",
+    "cache_stats",
+    "clear_cache",
 ]