@axonpush/wizard 0.0.1

package/README.md

@@ -0,0 +1,49 @@
+# @axonpush/wizard
+
+AI-powered wizard that integrates the [AxonPush](https://github.com/axonpush/axonpush-python) Python SDK into your AI agent project using Claude Code.
+
+## Usage
+
+```bash
+npx @axonpush/wizard
+```
+
+The wizard will:
+1. Detect your project's AI framework (LangChain, OpenAI Agents, Anthropic, CrewAI)
+2. Ask for your AxonPush credentials
+3. Use Claude Code to install the SDK and add integration code to your project
+
+## Options
+
+```
+--integration, -i   Framework (langchain, openai-agents, anthropic, crewai, core)
+--api-key           AxonPush API key
+--tenant-id         AxonPush tenant/organization ID
+--base-url          AxonPush server URL (default: http://localhost:3000)
+--install-dir       Project directory (default: current directory)
+```
+
+## Non-interactive
+
+```bash
+npx @axonpush/wizard \
+  --integration langchain \
+  --api-key ak_your_key \
+  --tenant-id 1
+```
+
+## Supported Frameworks
+
+| Framework | Extra | Integration |
+|-----------|-------|-------------|
+| LangChain / LangGraph | `axonpush[langchain]` | Callback handler for chains and agents |
+| OpenAI Agents SDK | `axonpush[openai-agents]` | Run hooks for agent lifecycle |
+| Anthropic / Claude | `axonpush[anthropic]` | Tracer wrapping messages.create() |
+| CrewAI | `axonpush[crewai]` | Step and task callbacks |
+| Core SDK | `axonpush` | Direct event publishing |
+
+## Requirements
+
+- Node.js 20+
+- Claude Code CLI installed and authenticated
+- A Python project to integrate into

package/dist/bin.js

@@ -0,0 +1,432 @@
+#!/usr/bin/env node
+
+// src/bin.ts
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+// src/run.ts
+import prompts from "prompts";
+import chalk from "chalk";
+import ora from "ora";
+
+// src/lib/constants.ts
+var Integration = /* @__PURE__ */ ((Integration2) => {
+  Integration2["langchain"] = "langchain";
+  Integration2["openaiAgents"] = "openai-agents";
+  Integration2["anthropic"] = "anthropic";
+  Integration2["crewai"] = "crewai";
+  Integration2["core"] = "core";
+  return Integration2;
+})(Integration || {});
+var INTEGRATION_LABELS = {
+  ["langchain" /* langchain */]: "LangChain / LangGraph",
+  ["openai-agents" /* openaiAgents */]: "OpenAI Agents SDK",
+  ["anthropic" /* anthropic */]: "Anthropic / Claude",
+  ["crewai" /* crewai */]: "CrewAI",
+  ["core" /* core */]: "Core SDK (no framework)"
+};
+var DEFAULT_BASE_URL = "http://localhost:3000";
+
+// src/frameworks/langchain.ts
+var LANGCHAIN_CONFIG = {
+  name: "LangChain / LangGraph",
+  integration: "langchain" /* langchain */,
+  packageExtra: "langchain",
+  detection: {
+    packages: ["langchain", "langchain-core", "langchain-openai", "langchain-anthropic", "langgraph"],
+    imports: ["from langchain", "import langchain", "from langgraph"]
+  },
+  prompts: {
+    integrationHint: 'Add AxonPushCallbackHandler to chain.invoke() via config={"callbacks": [handler]}'
+  },
+  skillDir: "skills/langchain"
+};
+
+// src/frameworks/openai-agents.ts
+var OPENAI_AGENTS_CONFIG = {
+  name: "OpenAI Agents SDK",
+  integration: "openai-agents" /* openaiAgents */,
+  packageExtra: "openai-agents",
+  detection: {
+    packages: ["openai-agents", "agents"],
+    imports: ["from agents import", "from agents.", "import agents"]
+  },
+  prompts: {
+    integrationHint: "Add AxonPushRunHooks as the hooks parameter to Runner.run(agent, input, hooks=hooks)"
+  },
+  skillDir: "skills/openai-agents"
+};
+
+// src/frameworks/anthropic.ts
+var ANTHROPIC_CONFIG = {
+  name: "Anthropic / Claude",
+  integration: "anthropic" /* anthropic */,
+  packageExtra: "anthropic",
+  detection: {
+    packages: ["anthropic"],
+    imports: ["import anthropic", "from anthropic"]
+  },
+  prompts: {
+    integrationHint: "Wrap anthropic_client.messages.create() with tracer.create_message() or tracer.acreate_message()"
+  },
+  skillDir: "skills/anthropic"
+};
+
+// src/frameworks/crewai.ts
+var CREWAI_CONFIG = {
+  name: "CrewAI",
+  integration: "crewai" /* crewai */,
+  packageExtra: "crewai",
+  detection: {
+    packages: ["crewai"],
+    imports: ["from crewai", "import crewai"]
+  },
+  prompts: {
+    integrationHint: "Add step_callback=callbacks.on_step and task_callback=callbacks.on_task_complete to Crew(), call on_crew_start() before and on_crew_end() after kickoff()"
+  },
+  skillDir: "skills/crewai"
+};
+
+// src/frameworks/core.ts
+var CORE_CONFIG = {
+  name: "Core SDK (no framework)",
+  integration: "core" /* core */,
+  packageExtra: "",
+  detection: {
+    packages: [],
+    imports: []
+  },
+  prompts: {
+    integrationHint: "Create an AxonPush client and use client.events.publish() to send events from your code"
+  },
+  skillDir: "skills/core"
+};
+
+// src/lib/registry.ts
+var FRAMEWORK_REGISTRY = {
+  ["langchain" /* langchain */]: LANGCHAIN_CONFIG,
+  ["openai-agents" /* openaiAgents */]: OPENAI_AGENTS_CONFIG,
+  ["anthropic" /* anthropic */]: ANTHROPIC_CONFIG,
+  ["crewai" /* crewai */]: CREWAI_CONFIG,
+  ["core" /* core */]: CORE_CONFIG
+};
+
+// src/lib/detection.ts
+import fs from "fs";
+import path from "path";
+function detectPackageManager(dir) {
+  if (fs.existsSync(path.join(dir, "uv.lock"))) return "uv";
+  if (fs.existsSync(path.join(dir, "poetry.lock"))) return "poetry";
+  return "pip";
+}
+function detectFrameworks(dir) {
+  const deps = readDependencies(dir);
+  const detected = [];
+  for (const [integration, config] of Object.entries(FRAMEWORK_REGISTRY)) {
+    if (integration === "core" /* core */) continue;
+    const match = config.detection.packages.some((pkg) => deps.has(pkg));
+    if (match) detected.push(integration);
+  }
+  if (detected.length === 0) {
+    const importMatches = scanImports(dir);
+    detected.push(...importMatches);
+  }
+  return detected;
+}
+function readDependencies(dir) {
+  const deps = /* @__PURE__ */ new Set();
+  const pyproject = path.join(dir, "pyproject.toml");
+  if (fs.existsSync(pyproject)) {
+    const content = fs.readFileSync(pyproject, "utf-8");
+    const depMatches = content.matchAll(/["']([a-zA-Z0-9_-]+)(?:\[.*?\])?(?:[><=!~].*)?\s*["']/g);
+    for (const m of depMatches) deps.add(m[1].toLowerCase());
+  }
+  const reqTxt = path.join(dir, "requirements.txt");
+  if (fs.existsSync(reqTxt)) {
+    const lines = fs.readFileSync(reqTxt, "utf-8").split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const name = trimmed.split(/[><=!~\[;]/)[0].trim().toLowerCase();
+      if (name) deps.add(name);
+    }
+  }
+  return deps;
+}
+function scanImports(dir) {
+  const detected = [];
+  const pyFiles = findPyFiles(dir, 3);
+  for (const file of pyFiles) {
+    const content = fs.readFileSync(file, "utf-8");
+    for (const [integration, config] of Object.entries(FRAMEWORK_REGISTRY)) {
+      if (integration === "core" /* core */) continue;
+      if (config.detection.imports.some((pattern) => content.includes(pattern))) {
+        if (!detected.includes(integration)) {
+          detected.push(integration);
+        }
+      }
+    }
+  }
+  return detected;
+}
+function findPyFiles(dir, maxDepth, depth = 0) {
+  if (depth > maxDepth) return [];
+  const files = [];
+  try {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "__pycache__" || entry.name === ".venv") continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...findPyFiles(full, maxDepth, depth + 1));
+      } else if (entry.name.endsWith(".py")) {
+        files.push(full);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+
+// src/lib/agent-runner.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/lib/commandments.ts
+var COMMANDMENTS = [
+  "Never hardcode API keys or secrets in source files. Always use environment variables loaded from .env.",
+  "Use the set_env_values wizard tool to create/update .env files. Never use the Write tool for .env.",
+  "Use the detect_package_manager wizard tool before installing packages.",
+  "Always read a file before modifying it. Never guess file contents.",
+  "Add axonpush imports at the top of the file alongside other imports.",
+  "Do not remove or modify existing functionality. Only add AxonPush integration code.",
+  "If unsure which file to modify, use Glob and Grep to find the main agent/chain entry point.",
+  "For LangChain: add handler via config={'callbacks': [handler]} in chain.invoke() or agent_executor.invoke().",
+  "For OpenAI Agents: pass hooks=hooks to Runner.run().",
+  "For Anthropic: wrap messages.create() with tracer.create_message() or tracer.acreate_message().",
+  "For CrewAI: add step_callback=callbacks.on_step and task_callback=callbacks.on_task_complete to Crew().",
+  "Always import os at the top if using os.environ for credentials.",
+  "Create the AxonPush client as a module-level singleton, not inside each function call.",
+  "Use channel_id=1 as placeholder if no channel ID is provided.",
+  "When done, briefly summarize what files were changed and what the user should do next."
+];
+function getCommandments() {
+  return COMMANDMENTS.map((c, i) => `${i + 1}. ${c}`).join("\n");
+}
+
+// src/lib/agent-interface.ts
+async function runAgent(prompt, cwd, onStatus) {
+  const { query } = await import("@anthropic-ai/claude-code");
+  const messages = [];
+  const response = query({
+    prompt,
+    options: {
+      cwd,
+      allowedTools: [
+        "Read",
+        "Write",
+        "Edit",
+        "Glob",
+        "Grep",
+        "Bash"
+      ],
+      systemPrompt: `You are an expert Python developer integrating the AxonPush observability SDK into a project. Follow these rules:
+
+${getCommandments()}`
+    }
+  });
+  for await (const message of response) {
+    messages.push(message);
+    if (message.type === "assistant" && message.content) {
+      const content = String(message.content);
+      const lines = content.split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed) {
+          onStatus(trimmed);
+        }
+      }
+    }
+  }
+}
+
+// src/lib/agent-runner.ts
+function buildPrompt(opts) {
+  const skillPath = path2.resolve(__dirname, "..", "..", opts.config.skillDir, "SKILL.md");
+  let skillContent = "";
+  try {
+    skillContent = fs2.readFileSync(skillPath, "utf-8");
+  } catch {
+    const altPath = path2.resolve(process.cwd(), opts.config.skillDir, "SKILL.md");
+    try {
+      skillContent = fs2.readFileSync(altPath, "utf-8");
+    } catch {
+    }
+  }
+  const pkgCmd = opts.packageManager === "uv" ? `uv add "axonpush${opts.config.packageExtra ? `[${opts.config.packageExtra}]` : ""}"` : opts.packageManager === "poetry" ? `poetry add "axonpush${opts.config.packageExtra ? `[${opts.config.packageExtra}]` : ""}"` : `pip install "axonpush${opts.config.packageExtra ? `[${opts.config.packageExtra}]` : ""}"`;
+  return `You are integrating the AxonPush Python SDK into this project.
+
+## Project Info
+- Directory: ${opts.projectDir}
+- Package manager: ${opts.packageManager}
+- Framework: ${opts.config.name}
+- Integration hint: ${opts.config.prompts.integrationHint}
+
+## Credentials (use these in .env)
+- AXONPUSH_API_KEY=${opts.apiKey}
+- AXONPUSH_TENANT_ID=${opts.tenantId}
+- AXONPUSH_BASE_URL=${opts.baseUrl}
+
+## Steps
+
+1. Install the SDK:
+   Run: ${pkgCmd}
+
+2. Create or update .env in the project root with the credentials above.
+   If .env already exists, append the AXONPUSH_ variables (don't overwrite existing vars).
+
+3. Find the main agent/chain entry point in the project. Look for:
+   - Files importing ${opts.config.detection.imports[0] || "the AI framework"}
+   - Files with main() or if __name__ == "__main__"
+   - app.py, main.py, agent.py, or similar
+
+4. Add AxonPush integration code following the reference below.
+
+5. Make sure os is imported if using os.environ.
+
+${skillContent ? `## Skill Reference
+
+${skillContent}` : ""}
+
+When done, summarize what you changed.`;
+}
+async function agentRunner(opts, onStatus) {
+  const prompt = buildPrompt(opts);
+  await runAgent(prompt, opts.projectDir, onStatus);
+}
+
+// src/run.ts
+async function run(args) {
+  const projectDir = args.installDir || process.cwd();
+  console.log();
+  console.log(chalk.bold("  AxonPush Wizard"));
+  console.log(chalk.dim("  AI-powered SDK integration\n"));
+  let integration;
+  if (args.integration && args.integration in Integration) {
+    integration = args.integration;
+    console.log(chalk.green(`  Framework: ${INTEGRATION_LABELS[integration]} (from flag)`));
+  } else {
+    const detected = detectFrameworks(projectDir);
+    const pkgMgr = detectPackageManager(projectDir);
+    console.log(chalk.dim(`  Project: ${projectDir}`));
+    console.log(chalk.dim(`  Package manager: ${pkgMgr}`));
+    if (detected.length === 1) {
+      integration = detected[0];
+      console.log(chalk.green(`  Detected: ${INTEGRATION_LABELS[integration]}
+`));
+    } else if (detected.length > 1) {
+      console.log(chalk.yellow(`  Multiple frameworks detected: ${detected.map((d) => INTEGRATION_LABELS[d]).join(", ")}
+`));
+      const { choice } = await prompts({
+        type: "select",
+        name: "choice",
+        message: "Which framework integration?",
+        choices: detected.map((d) => ({ title: INTEGRATION_LABELS[d], value: d }))
+      });
+      if (!choice) process.exit(0);
+      integration = choice;
+    } else {
+      console.log(chalk.yellow("  No AI framework detected.\n"));
+      const { choice } = await prompts({
+        type: "select",
+        name: "choice",
+        message: "Choose an integration",
+        choices: Object.entries(INTEGRATION_LABELS).map(([value, title]) => ({ title, value }))
+      });
+      if (!choice) process.exit(0);
+      integration = choice;
+    }
+  }
+  const config = FRAMEWORK_REGISTRY[integration];
+  let apiKey = args.apiKey;
+  let tenantId = args.tenantId;
+  let baseUrl = args.baseUrl || DEFAULT_BASE_URL;
+  if (!apiKey) {
+    const res = await prompts({ type: "password", name: "value", message: "AxonPush API Key" });
+    apiKey = res.value;
+    if (!apiKey) process.exit(0);
+  }
+  if (!tenantId) {
+    const res = await prompts({ type: "text", name: "value", message: "Tenant ID", initial: "1" });
+    tenantId = res.value;
+    if (!tenantId) process.exit(0);
+  }
+  if (!args.baseUrl) {
+    const res = await prompts({ type: "text", name: "value", message: "Base URL", initial: DEFAULT_BASE_URL });
+    baseUrl = res.value || DEFAULT_BASE_URL;
+  }
+  console.log();
+  const spinner = ora("Running Claude Code agent...").start();
+  try {
+    await agentRunner(
+      {
+        config,
+        projectDir,
+        packageManager: detectPackageManager(projectDir),
+        apiKey,
+        tenantId,
+        baseUrl
+      },
+      (msg) => {
+        spinner.text = msg;
+      }
+    );
+    spinner.succeed("AxonPush integrated!");
+  } catch (error) {
+    spinner.fail("Agent failed");
+    console.error(chalk.red(`
+  ${error instanceof Error ? error.message : error}`));
+    process.exit(1);
+  }
+  console.log();
+  console.log(chalk.green("  Next steps:"));
+  console.log(chalk.dim("    1. Run your agent and check the AxonPush dashboard"));
+  console.log(chalk.dim(`    2. View traces at ${baseUrl.replace("3000", "5173")}/traces`));
+  console.log();
+}
+
+// src/bin.ts
+yargs(hideBin(process.argv)).scriptName("axonpush-wizard").usage("$0 [options]").option("integration", {
+  alias: "i",
+  type: "string",
+  describe: "Framework integration (langchain, openai-agents, anthropic, crewai, core)"
+}).option("api-key", {
+  type: "string",
+  describe: "AxonPush API key"
+}).option("tenant-id", {
+  type: "string",
+  describe: "AxonPush tenant/organization ID"
+}).option("base-url", {
+  type: "string",
+  describe: "AxonPush server URL"
+}).option("install-dir", {
+  type: "string",
+  describe: "Project directory to integrate into (default: cwd)"
+}).option("debug", {
+  type: "boolean",
+  default: false,
+  describe: "Enable debug output"
+}).command(
+  "$0",
+  "Integrate AxonPush into your AI agent project",
+  () => {
+  },
+  async (argv) => {
+    await run({
+      integration: argv.integration,
+      apiKey: argv["api-key"],
+      tenantId: argv["tenant-id"],
+      baseUrl: argv["base-url"],
+      installDir: argv["install-dir"]
+    });
+  }
+).help().parse();

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@axonpush/wizard",
+  "version": "0.0.1",
+  "description": "AI-powered wizard to integrate AxonPush into your AI agent project",
+  "type": "module",
+  "bin": {
+    "axonpush-wizard": "dist/bin.js"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "skills"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/bin.ts",
+    "start": "node dist/bin.js"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-code": "^0.2.20",
+    "chalk": "^5.4.1",
+    "ora": "^8.2.0",
+    "prompts": "^2.4.2",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@types/prompts": "^2.4.9",
+    "@types/yargs": "^17.0.33",
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}

package/skills/anthropic/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: anthropic
+description: Integrate AxonPush tracing into a project using the Anthropic Python SDK
+---
+
+# AxonPush + Anthropic/Claude Integration
+
+Integrate AxonPush tracing into a project using the Anthropic Python SDK.
+
+## What gets added
+
+- `AxonPushAnthropicTracer` that wraps `messages.create()` to trace conversations, tool use, and responses
+- Events: `conversation.turn`, `tool.*.start`, `agent.response`, `tool.result`
+
+## Reference Code (Sync)
+
+```python
+import os
+from axonpush import AxonPush
+from axonpush.integrations.anthropic import AxonPushAnthropicTracer
+
+axonpush_client = AxonPush(
+    api_key=os.environ["AXONPUSH_API_KEY"],
+    tenant_id=os.environ["AXONPUSH_TENANT_ID"],
+    base_url=os.environ.get("AXONPUSH_BASE_URL", "http://localhost:3000"),
+)
+
+tracer = AxonPushAnthropicTracer(
+    client=axonpush_client,
+    channel_id=1,  # Replace with your channel ID
+    agent_id="claude-agent",
+)
+
+# Instead of: response = anthropic_client.messages.create(model=..., messages=...)
+# Use:        response = tracer.create_message(anthropic_client, model=..., messages=...)
+```
+
+## Reference Code (Async)
+
+```python
+# Use AsyncAxonPush instead:
+# response = await tracer.acreate_message(async_anthropic_client, model=..., messages=...)
+```
+
+## Steps
+
+1. Install `axonpush[anthropic]` using the project's package manager
+2. Add AXONPUSH_API_KEY, AXONPUSH_TENANT_ID, AXONPUSH_BASE_URL to .env
+3. Find files that call `client.messages.create()` (the Anthropic API)
+4. Add imports and create the tracer
+5. Replace `anthropic_client.messages.create(...)` with `tracer.create_message(anthropic_client, ...)`
+6. For tool results, add `tracer.send_tool_result(tool_use_id, result)` calls

package/skills/core/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: core
+description: Integrate AxonPush event publishing directly without framework-specific callbacks
+---
+
+# AxonPush Core SDK Integration
+
+Integrate AxonPush event publishing directly (no framework-specific callbacks).
+
+## What gets added
+
+- `AxonPush` client for publishing custom events
+- Use `client.events.publish()` to send events from anywhere in your code
+
+## Reference Code
+
+```python
+import os
+from axonpush import AxonPush, EventType
+
+axonpush_client = AxonPush(
+    api_key=os.environ["AXONPUSH_API_KEY"],
+    tenant_id=os.environ["AXONPUSH_TENANT_ID"],
+    base_url=os.environ.get("AXONPUSH_BASE_URL", "http://localhost:3000"),
+)
+
+# Publish events from your code:
+# axonpush_client.events.publish(
+#     identifier="my.event",
+#     payload={"key": "value"},
+#     channel_id=1,
+#     agent_id="my-agent",
+#     event_type=EventType.CUSTOM,
+# )
+```
+
+## Steps
+
+1. Install `axonpush` using the project's package manager
+2. Add AXONPUSH_API_KEY, AXONPUSH_TENANT_ID, AXONPUSH_BASE_URL to .env
+3. Find the main entry point of the project
+4. Add imports and create the client as a module-level singleton
+5. Add example publish calls at key points (e.g., start, end, error handling)

package/skills/crewai/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: crewai
+description: Integrate AxonPush tracing into a CrewAI project
+---
+
+# AxonPush + CrewAI Integration
+
+Integrate AxonPush tracing into a CrewAI project.
+
+## What gets added
+
+- `AxonPushCrewCallbacks` with manual callback methods for crew lifecycle
+- Events: `crew.start`, `crew.end`, `agent.step`, `tool.*.start`, `tool.*.end`, `task.complete`
+
+## Reference Code
+
+```python
+import os
+from axonpush import AxonPush
+from axonpush.integrations.crewai import AxonPushCrewCallbacks
+
+axonpush_client = AxonPush(
+    api_key=os.environ["AXONPUSH_API_KEY"],
+    tenant_id=os.environ["AXONPUSH_TENANT_ID"],
+    base_url=os.environ.get("AXONPUSH_BASE_URL", "http://localhost:3000"),
+)
+
+axonpush_callbacks = AxonPushCrewCallbacks(
+    client=axonpush_client,
+    channel_id=1,  # Replace with your channel ID
+    agent_id="crewai",
+)
+
+# Usage:
+# axonpush_callbacks.on_crew_start()
+# crew = Crew(
+#     agents=[...],
+#     tasks=[...],
+#     step_callback=axonpush_callbacks.on_step,
+#     task_callback=axonpush_callbacks.on_task_complete,
+# )
+# result = crew.kickoff()
+# axonpush_callbacks.on_crew_end(result)
+```
+
+## Steps
+
+1. Install `axonpush[crewai]` using the project's package manager
+2. Add AXONPUSH_API_KEY, AXONPUSH_TENANT_ID, AXONPUSH_BASE_URL to .env
+3. Find the file where `Crew(...)` is instantiated
+4. Add imports and create the callbacks object
+5. Add `step_callback=axonpush_callbacks.on_step` and `task_callback=axonpush_callbacks.on_task_complete` to `Crew()`
+6. Add `axonpush_callbacks.on_crew_start()` before `crew.kickoff()`
+7. Add `axonpush_callbacks.on_crew_end(result)` after

package/skills/langchain/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: langchain
+description: Integrate AxonPush tracing into a LangChain or LangGraph project
+---
+
+# AxonPush + LangChain Integration
+
+Integrate AxonPush tracing into a LangChain or LangGraph project.
+
+## What gets added
+
+- `AxonPushCallbackHandler` that auto-traces chain/LLM/tool lifecycle events
+- Events: `chain.start`, `chain.end`, `llm.start`, `llm.end`, `tool.*.start`, `tool.end`
+
+## Reference Code
+
+```python
+import os
+from axonpush import AxonPush
+from axonpush.integrations.langchain import AxonPushCallbackHandler
+
+axonpush_client = AxonPush(
+    api_key=os.environ["AXONPUSH_API_KEY"],
+    tenant_id=os.environ["AXONPUSH_TENANT_ID"],
+    base_url=os.environ.get("AXONPUSH_BASE_URL", "http://localhost:3000"),
+)
+
+axonpush_handler = AxonPushCallbackHandler(
+    client=axonpush_client,
+    channel_id=1,  # Replace with your channel ID
+    agent_id="my-agent",
+)
+
+# For any chain:
+# result = chain.invoke(input, config={"callbacks": [axonpush_handler]})
+
+# For an agent executor:
+# result = agent_executor.invoke(input, config={"callbacks": [axonpush_handler]})
+```
+
+## Steps
+
+1. Install `axonpush[langchain]` using the project's package manager
+2. Add AXONPUSH_API_KEY, AXONPUSH_TENANT_ID, AXONPUSH_BASE_URL to .env
+3. Find the main file where chains/agents are invoked
+4. Add the imports and client initialization (as module-level code)
+5. Add `config={"callbacks": [axonpush_handler]}` to `.invoke()` calls

package/skills/openai-agents/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: openai-agents
+description: Integrate AxonPush tracing into a project using the OpenAI Agents SDK
+---
+
+# AxonPush + OpenAI Agents SDK Integration
+
+Integrate AxonPush tracing into a project using the OpenAI Agents SDK.
+
+## What gets added
+
+- `AxonPushRunHooks` that traces agent runs, tool calls, and handoffs
+- Events: `agent.run.start`, `agent.run.end`, `tool.*.start`, `tool.*.end`, `agent.handoff`
+
+## Reference Code
+
+```python
+import os
+from axonpush import AsyncAxonPush
+from axonpush.integrations.openai_agents import AxonPushRunHooks
+
+axonpush_client = AsyncAxonPush(
+    api_key=os.environ["AXONPUSH_API_KEY"],
+    tenant_id=os.environ["AXONPUSH_TENANT_ID"],
+    base_url=os.environ.get("AXONPUSH_BASE_URL", "http://localhost:3000"),
+)
+
+axonpush_hooks = AxonPushRunHooks(
+    client=axonpush_client,
+    channel_id=1,  # Replace with your channel ID
+)
+
+# Usage:
+# result = await Runner.run(agent, input="...", hooks=axonpush_hooks)
+```
+
+## Steps
+
+1. Install `axonpush[openai-agents]` using the project's package manager
+2. Add AXONPUSH_API_KEY, AXONPUSH_TENANT_ID, AXONPUSH_BASE_URL to .env
+3. Find the main file where Runner.run() is called
+4. Add the imports and AsyncAxonPush client (this SDK is async-only)
+5. Pass `hooks=axonpush_hooks` to `Runner.run()`
+
+## Important
+
+- OpenAI Agents SDK is **async-only**, so use `AsyncAxonPush` (not `AxonPush`)
+- Make sure to close the client when done: `await axonpush_client.close()`
+- Or use `async with AsyncAxonPush(...) as client:` context manager