create-agentmark 0.5.0 → 0.7.0

package/dist/index.js

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import fs4 from "fs-extra";
-import prompts from "prompts";
+import fs8 from "fs-extra";
+import path6 from "path";
+import prompts2 from "prompts";
 
 // src/utils/examples/create-example-app.ts
-import fs3 from "fs-extra";
-import * as path from "path";
+import fs4 from "fs-extra";
+import * as path2 from "path";
 
 // src/utils/providers.ts
 var Providers = {
@@ -22,6 +23,17 @@ var Providers = {
     ],
     imageModels: ["dall-e-3", "dall-e-2"],
     speechModels: ["tts-1", "tts-1-hd"]
+  },
+  anthropic: {
+    label: "Anthropic",
+    languageModels: [
+      "claude-sonnet-4-20250514",
+      "claude-opus-4-20250514",
+      "claude-3-5-sonnet-20241022",
+      "claude-3-5-haiku-20241022"
+    ],
+    imageModels: [],
+    speechModels: []
   }
 };
 
@@ -29,7 +41,7 @@ var Providers = {
 var createAdapterConfig = (provider) => {
   return {
     "ai-sdk": {
-      package: "@agentmark/ai-sdk-v5-adapter",
+      package: "@agentmark-ai/ai-sdk-v5-adapter",
       dependencies: ["ai@^5", `@ai-sdk/${provider}@^2`],
       classes: {
         modelRegistry: "VercelAIModelRegistry",
@@ -38,7 +50,7 @@ var createAdapterConfig = (provider) => {
       }
     },
     mastra: {
-      package: "@agentmark/mastra-v0-adapter",
+      package: "@agentmark-ai/mastra-v0-adapter",
       dependencies: [
         "@mastra/core@<0.20.0",
         "@mastra/mcp@<0.13.4",
@@ -49,6 +61,15 @@ var createAdapterConfig = (provider) => {
         toolRegistry: "MastraToolRegistry",
         webhookHandler: "MastraAdapterWebhookHandler"
       }
+    },
+    "claude-agent-sdk": {
+      package: "@agentmark-ai/claude-agent-sdk-adapter",
+      dependencies: ["@anthropic-ai/claude-agent-sdk@^0.1.0"],
+      classes: {
+        modelRegistry: "ClaudeAgentModelRegistry",
+        toolRegistry: "ClaudeAgentToolRegistry",
+        webhookHandler: "ClaudeAgentWebhookHandler"
+      }
     }
   };
 };
@@ -66,7 +87,61 @@ function getAdapterConfig(adapter, provider) {
 
 // src/utils/examples/templates/app-index.ts
 var getIndexFileContent = (adapter = "ai-sdk") => {
-  if (adapter === "mastra") {
+  if (adapter === "claude-agent-sdk") {
+    return `import "dotenv/config";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { withTracing } from "@agentmark-ai/claude-agent-sdk-adapter";
+import { client } from "./agentmark.client";
+
+const telemetry = {
+  isEnabled: true,
+  metadata: {
+    trace_name: "customer-support",
+    user_id: "user-123",
+    session_id: "session-123",
+    session_name: "my-first-session",
+  },
+};
+
+const runCustomerSupport = async (customer_message: string) => {
+  const prompt = await client.loadTextPrompt("customer-support-agent");
+  const adapted = await prompt.format({
+    props: {
+      customer_question: customer_message,
+    },
+    telemetry,
+  });
+
+  // Execute with Claude Agent SDK using withTracing for telemetry
+  // The adapted object contains { query, telemetry } ready for withTracing()
+  const tracedResult = await withTracing(query, adapted);
+
+  // traceId is available immediately
+  console.log("Trace ID:", tracedResult.traceId);
+
+  let result = "";
+  for await (const message of tracedResult) {
+    if (message.type === "result" && message.subtype === "success") {
+      result = message.result || "";
+    }
+  }
+
+  return result;
+};
+
+const main = async () => {
+  try {
+    const user_message = "How long does shipping take?";
+    const assistant = await runCustomerSupport(user_message);
+    console.log("Customer support response:", assistant);
+  } catch (error) {
+    console.error(error);
+  }
+};
+
+main();
+`;
+  } else if (adapter === "mastra") {
     return `import "dotenv/config";
 import { Agent } from "@mastra/core/agent";
 import { client } from "./agentmark.client";
@@ -74,11 +149,10 @@ import { client } from "./agentmark.client";
 const telemetry = {
   isEnabled: true,
   metadata: {
-    traceId: "trace-123",
-    traceName: "customer-support",
-    userId: "user-123",
-    sessionId: "session-123",
-    sessionName: "my-first-session",
+    trace_name: "customer-support",
+    user_id: "user-123",
+    session_id: "session-123",
+    session_name: "my-first-session",
   },
 };
 
@@ -122,11 +196,10 @@ import { client } from "./agentmark.client";
 const telemetry = {
   isEnabled: true,
   metadata: {
-    traceId: "trace-123",
-    traceName: "customer-support",
-    userId: "user-123",
-    sessionId: "session-123",
-    sessionName: "my-first-session",
+    trace_name: "customer-support",
+    user_id: "user-123",
+    session_id: "session-123",
+    session_name: "my-first-session",
   },
 };
 
@@ -160,70 +233,328 @@ main();
 };
 
 // src/utils/examples/templates/env.ts
-var getEnvFileContent = (_modelProvider, apiKey = "") => {
+var getEnvFileContent = (_modelProvider, apiKey = "", adapter = "ai-sdk") => {
   const apiKeyValue = apiKey || "your_api_key_here";
+  const apiKeyName = adapter === "claude-agent-sdk" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
   return `# Cloud deployment: Set these environment variables
 # AGENTMARK_BASE_URL=https://api.agentmark.co
 # AGENTMARK_API_KEY=your_agentmark_api_key
 # AGENTMARK_APP_ID=your_agentmark_app_id
 # Learn more: https://docs.agentmark.co/platform/getting_started/quickstart
 
-OPENAI_API_KEY=${apiKeyValue}
+${apiKeyName}=${apiKeyValue}
 `;
 };
 
 // src/utils/examples/templates/package-setup.ts
+import fs2 from "fs-extra";
+import { execSync } from "child_process";
+
+// src/utils/file-merge.ts
 import fs from "fs-extra";
-import { execSync, execFileSync } from "child_process";
-var setupPackageJson = (targetPath = ".", deploymentMode = "cloud") => {
+import path from "path";
+function mergePackageJson(targetPath, agentmarkDeps, agentmarkDevDeps, agentmarkScripts) {
+  const packageJsonPath = path.join(targetPath, "package.json");
+  const result = {
+    success: false,
+    warnings: [],
+    added: [],
+    skipped: []
+  };
+  try {
+    if (!fs.existsSync(packageJsonPath)) {
+      result.warnings.push("No existing package.json found");
+      return result;
+    }
+    const existing = fs.readJsonSync(packageJsonPath);
+    if (!existing.dependencies) {
+      existing.dependencies = {};
+    }
+    if (!existing.devDependencies) {
+      existing.devDependencies = {};
+    }
+    if (!existing.scripts) {
+      existing.scripts = {};
+    }
+    const deps = existing.dependencies;
+    const devDeps = existing.devDependencies;
+    const scripts = existing.scripts;
+    for (const [pkg, version] of Object.entries(agentmarkDeps)) {
+      if (deps[pkg]) {
+        result.skipped.push(`dependency: ${pkg} (already exists)`);
+      } else {
+        deps[pkg] = version;
+        result.added.push(`dependency: ${pkg}@${version}`);
+      }
+    }
+    for (const [pkg, version] of Object.entries(agentmarkDevDeps)) {
+      if (devDeps[pkg]) {
+        result.skipped.push(`devDependency: ${pkg} (already exists)`);
+      } else {
+        devDeps[pkg] = version;
+        result.added.push(`devDependency: ${pkg}@${version}`);
+      }
+    }
+    for (const [scriptName, scriptCmd] of Object.entries(agentmarkScripts)) {
+      if (scripts[scriptName]) {
+        const namespacedName = `agentmark:${scriptName}`;
+        if (scripts[namespacedName]) {
+          result.skipped.push(`script: ${scriptName}`);
+          result.warnings.push(
+            `Script "${scriptName}" and "${namespacedName}" both already exist. Skipping.`
+          );
+        } else {
+          scripts[namespacedName] = scriptCmd;
+          result.added.push(`script: ${namespacedName} (namespaced due to conflict)`);
+          result.warnings.push(
+            `Script "${scriptName}" already exists. Added as "${namespacedName}" instead.`
+          );
+        }
+      } else {
+        scripts[scriptName] = scriptCmd;
+        result.added.push(`script: ${scriptName}`);
+      }
+    }
+    fs.writeJsonSync(packageJsonPath, existing, { spaces: 2 });
+    result.success = true;
+    result.content = JSON.stringify(existing, null, 2);
+    return result;
+  } catch (error) {
+    result.warnings.push(`Error merging package.json: ${error}`);
+    return result;
+  }
+}
+function appendGitignore(targetPath, entries) {
+  const gitignorePath = path.join(targetPath, ".gitignore");
+  const result = {
+    success: false,
+    warnings: [],
+    added: [],
+    skipped: []
+  };
+  try {
+    let existingContent = "";
+    if (fs.existsSync(gitignorePath)) {
+      existingContent = fs.readFileSync(gitignorePath, "utf-8");
+    }
+    const existingEntries = new Set(
+      existingContent.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((line) => line.replace(/\/$/, ""))
+      // Remove trailing slashes for comparison
+    );
+    const entriesToAdd = [];
+    for (const entry of entries) {
+      const normalizedEntry = entry.replace(/\/$/, "");
+      if (existingEntries.has(normalizedEntry)) {
+        result.skipped.push(entry);
+      } else {
+        entriesToAdd.push(entry);
+        result.added.push(entry);
+      }
+    }
+    if (entriesToAdd.length > 0) {
+      let newContent = existingContent;
+      if (newContent && !newContent.endsWith("\n")) {
+        newContent += "\n";
+      }
+      if (newContent.trim()) {
+        newContent += "\n";
+      }
+      newContent += "# AgentMark\n";
+      newContent += entriesToAdd.join("\n");
+      newContent += "\n";
+      fs.writeFileSync(gitignorePath, newContent);
+      result.content = newContent;
+    }
+    result.success = true;
+    return result;
+  } catch (error) {
+    result.warnings.push(`Error appending to .gitignore: ${error}`);
+    return result;
+  }
+}
+function appendEnv(targetPath, envVars) {
+  const envPath = path.join(targetPath, ".env");
+  const result = {
+    success: false,
+    warnings: [],
+    added: [],
+    skipped: []
+  };
+  try {
+    let existingContent = "";
+    if (fs.existsSync(envPath)) {
+      existingContent = fs.readFileSync(envPath, "utf-8");
+    }
+    const existingKeys = /* @__PURE__ */ new Set();
+    const lines = existingContent.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("#")) {
+        const match = trimmed.match(/^([^=]+)=/);
+        if (match && match[1]) {
+          existingKeys.add(match[1]);
+        }
+      }
+    }
+    const varsToAdd = [];
+    for (const [key, value] of Object.entries(envVars)) {
+      if (existingKeys.has(key)) {
+        result.skipped.push(key);
+      } else {
+        varsToAdd.push([key, value]);
+        result.added.push(key);
+      }
+    }
+    if (varsToAdd.length > 0) {
+      let newContent = existingContent;
+      if (newContent && !newContent.endsWith("\n")) {
+        newContent += "\n";
+      }
+      if (newContent.trim()) {
+        newContent += "\n";
+      }
+      newContent += "# AgentMark\n";
+      for (const [key, value] of varsToAdd) {
+        newContent += `${key}=${value}
+`;
+      }
+      fs.writeFileSync(envPath, newContent);
+      result.content = newContent;
+    }
+    result.success = true;
+    return result;
+  } catch (error) {
+    result.warnings.push(`Error appending to .env: ${error}`);
+    return result;
+  }
+}
+
+// src/utils/types.ts
+var PACKAGE_MANAGERS = {
+  "yarn.lock": {
+    name: "yarn",
+    lockFile: "yarn.lock",
+    installCmd: "yarn install",
+    addCmd: "yarn add",
+    addDevCmd: "yarn add --dev",
+    runCmd: "yarn"
+  },
+  "pnpm-lock.yaml": {
+    name: "pnpm",
+    lockFile: "pnpm-lock.yaml",
+    installCmd: "pnpm install",
+    addCmd: "pnpm add",
+    addDevCmd: "pnpm add --save-dev",
+    runCmd: "pnpm"
+  },
+  "bun.lockb": {
+    name: "bun",
+    lockFile: "bun.lockb",
+    installCmd: "bun install",
+    addCmd: "bun add",
+    addDevCmd: "bun add --dev",
+    runCmd: "bun run"
+  },
+  "package-lock.json": {
+    name: "npm",
+    lockFile: "package-lock.json",
+    installCmd: "npm install",
+    addCmd: "npm install",
+    addDevCmd: "npm install --save-dev",
+    runCmd: "npm run"
+  }
+};
+var DEFAULT_PACKAGE_MANAGER = PACKAGE_MANAGERS["package-lock.json"];
+var CONFLICT_FILES = [
+  { path: "agentmark.json", type: "config", strategy: "prompt" },
+  { path: "agentmark", type: "directory", strategy: "prompt" },
+  { path: "agentmark.client.ts", type: "source", strategy: "prompt" },
+  { path: "agentmark_client.py", type: "source", strategy: "prompt" },
+  { path: ".gitignore", type: "dotfile", strategy: "append" },
+  { path: ".env", type: "dotfile", strategy: "append" },
+  { path: "package.json", type: "config", strategy: "merge" },
+  { path: "index.ts", type: "source", strategy: "skip" },
+  { path: "main.py", type: "source", strategy: "skip" },
+  { path: "tsconfig.json", type: "config", strategy: "skip" },
+  { path: "pyproject.toml", type: "config", strategy: "skip" }
+];
+
+// src/utils/examples/templates/package-setup.ts
+var setupPackageJson = (targetPath = ".", deploymentMode = "cloud", projectInfo = null) => {
   const packageJsonPath = `${targetPath}/package.json`;
-  if (!fs.existsSync(packageJsonPath)) {
+  const isExistingProject = projectInfo?.isExistingProject ?? false;
+  if (!fs2.existsSync(packageJsonPath)) {
     console.log("Creating package.json...");
     execSync("npm init -y", { cwd: targetPath });
   }
-  const pkgJson = fs.readJsonSync(packageJsonPath);
-  pkgJson.name = pkgJson.name === "test" || !pkgJson.name ? "agentmark-example-app" : pkgJson.name;
-  pkgJson.description = pkgJson.description || "A simple Node.js app using the Agentmark SDK";
-  const devScript = "agentmark dev";
-  const scripts = {
-    ...pkgJson.scripts,
-    "demo": "npx tsx index.ts",
-    "dev": devScript,
-    "prompt": "agentmark run-prompt",
-    "experiment": "agentmark run-experiment"
-  };
-  if (deploymentMode === "static") {
-    scripts["build"] = "agentmark build --out dist/agentmark";
+  if (isExistingProject && fs2.existsSync(packageJsonPath)) {
+    const scriptsToAdd = {
+      "demo": "npx tsx index.ts",
+      "dev": "agentmark dev",
+      "prompt": "agentmark run-prompt",
+      "experiment": "agentmark run-experiment"
+    };
+    if (deploymentMode === "static") {
+      scriptsToAdd["build"] = "agentmark build --out dist/agentmark";
+    }
+    const result = mergePackageJson(targetPath, {}, {}, scriptsToAdd);
+    if (result.added.length > 0) {
+      console.log(`\u2705 Added to package.json: ${result.added.join(", ")}`);
+    }
+    if (result.skipped.length > 0) {
+      console.log(`\u23ED\uFE0F  Skipped existing in package.json: ${result.skipped.join(", ")}`);
+    }
+    if (result.warnings.length > 0) {
+      result.warnings.forEach((w) => console.log(`\u26A0\uFE0F  ${w}`));
+    }
+  } else {
+    const pkgJson = fs2.readJsonSync(packageJsonPath);
+    pkgJson.name = pkgJson.name === "test" || !pkgJson.name ? "agentmark-example-app" : pkgJson.name;
+    pkgJson.description = pkgJson.description || "A simple Node.js app using the Agentmark SDK";
+    const devScript = "agentmark dev";
+    const scripts = {
+      ...pkgJson.scripts,
+      "demo": "npx tsx index.ts",
+      "dev": devScript,
+      "prompt": "agentmark run-prompt",
+      "experiment": "agentmark run-experiment"
+    };
+    if (deploymentMode === "static") {
+      scripts["build"] = "agentmark build --out dist/agentmark";
+    }
+    pkgJson.scripts = scripts;
+    pkgJson.overrides = {
+      ...pkgJson.overrides,
+      "axios": "^1.7.9"
+    };
+    fs2.writeJsonSync(packageJsonPath, pkgJson, { spaces: 2 });
   }
-  pkgJson.scripts = scripts;
-  pkgJson.overrides = {
-    ...pkgJson.overrides,
-    "axios": "^1.7.9"
-  };
-  fs.writeJsonSync(packageJsonPath, pkgJson, { spaces: 2 });
 };
-var installDependencies = (modelProvider, targetPath = ".", adapter = "ai-sdk", deploymentMode = "cloud") => {
+var installDependencies = (modelProvider, targetPath = ".", adapter = "ai-sdk", deploymentMode = "cloud", packageManager = null) => {
   console.log("Installing required packages...");
   console.log("This might take a moment...");
   const adapterConfig = getAdapterConfig(adapter, modelProvider);
+  const pm = packageManager || DEFAULT_PACKAGE_MANAGER;
+  const npmSuffix = pm.name === "npm" ? " --legacy-peer-deps" : "";
   try {
-    const devDepsCmd = "npm install --save-dev typescript ts-node @types/node @agentmark/cli --legacy-peer-deps";
+    const devDeps = ["typescript", "ts-node", "@types/node", "@agentmark-ai/cli"];
+    const devDepsCmd = `${pm.addDevCmd} ${devDeps.join(" ")}${npmSuffix}`;
+    console.log(`Using ${pm.name} to install dependencies...`);
     execSync(devDepsCmd, {
       stdio: "inherit",
       cwd: targetPath
     });
-    const loaderPackages = deploymentMode === "static" ? ["@agentmark/loader-api", "@agentmark/loader-file"] : ["@agentmark/loader-api"];
-    const installArgs = [
-      "install",
+    const loaderPackages = deploymentMode === "static" ? ["@agentmark-ai/loader-api", "@agentmark-ai/loader-file"] : ["@agentmark-ai/loader-api"];
+    const deps = [
       "dotenv",
-      "@agentmark/prompt-core",
-      "@agentmark/sdk",
+      "@agentmark-ai/prompt-core",
+      "@agentmark-ai/sdk",
       adapterConfig.package,
       ...loaderPackages,
-      ...adapterConfig.dependencies,
-      "--legacy-peer-deps"
+      ...adapterConfig.dependencies
     ];
-    execFileSync("npm", installArgs, { stdio: "inherit", cwd: targetPath });
+    const depsCmd = `${pm.addCmd} ${deps.join(" ")}${npmSuffix}`;
+    execSync(depsCmd, { stdio: "inherit", cwd: targetPath });
     console.log("Packages installed successfully!");
   } catch (error) {
     console.error("Error installing packages:", error);
@@ -397,28 +728,32 @@ var getStoryDataset = () => {
 };
 
 // src/utils/examples/templates/example-prompts.ts
-import fs2 from "fs-extra";
+import fs3 from "fs-extra";
 var createExamplePrompts = (model, targetPath = ".", adapter = "ai-sdk") => {
-  fs2.ensureDirSync(`${targetPath}/agentmark`);
-  if (adapter !== "mastra") {
+  fs3.ensureDirSync(`${targetPath}/agentmark`);
+  const noImageSupport = ["mastra", "claude-agent-sdk"];
+  const noSpeechSupport = ["mastra", "claude-agent-sdk"];
+  const skipImagePrompts = noImageSupport.includes(adapter);
+  const skipSpeechPrompts = noSpeechSupport.includes(adapter);
+  if (!skipImagePrompts) {
     const animalDrawingPrompt = getAnimalDrawingPrompt();
-    fs2.writeFileSync(`${targetPath}/agentmark/animal-drawing.prompt.mdx`, animalDrawingPrompt);
+    fs3.writeFileSync(`${targetPath}/agentmark/animal-drawing.prompt.mdx`, animalDrawingPrompt);
     const animalDataset = getAnimalDataset();
-    fs2.writeFileSync(`${targetPath}/agentmark/animal.jsonl`, animalDataset);
+    fs3.writeFileSync(`${targetPath}/agentmark/animal.jsonl`, animalDataset);
   }
   const customerSupportPrompt = getCustomerSupportPrompt(model);
-  fs2.writeFileSync(`${targetPath}/agentmark/customer-support-agent.prompt.mdx`, customerSupportPrompt);
+  fs3.writeFileSync(`${targetPath}/agentmark/customer-support-agent.prompt.mdx`, customerSupportPrompt);
   const customerQueryDataset = getCustomerQueryDataset();
-  fs2.writeFileSync(`${targetPath}/agentmark/customer-query.jsonl`, customerQueryDataset);
+  fs3.writeFileSync(`${targetPath}/agentmark/customer-query.jsonl`, customerQueryDataset);
   const partyPlannerPrompt = getPartyPlannerPrompt(model);
-  fs2.writeFileSync(`${targetPath}/agentmark/party-planner.prompt.mdx`, partyPlannerPrompt);
+  fs3.writeFileSync(`${targetPath}/agentmark/party-planner.prompt.mdx`, partyPlannerPrompt);
   const partyDataset = getPartyDataset();
-  fs2.writeFileSync(`${targetPath}/agentmark/party.jsonl`, partyDataset);
-  if (adapter !== "mastra") {
+  fs3.writeFileSync(`${targetPath}/agentmark/party.jsonl`, partyDataset);
+  if (!skipSpeechPrompts) {
     const storyTellerPrompt = getStoryTellerPrompt();
-    fs2.writeFileSync(`${targetPath}/agentmark/story-teller.prompt.mdx`, storyTellerPrompt);
+    fs3.writeFileSync(`${targetPath}/agentmark/story-teller.prompt.mdx`, storyTellerPrompt);
     const storyDataset = getStoryDataset();
-    fs2.writeFileSync(`${targetPath}/agentmark/story.jsonl`, storyDataset);
+    fs3.writeFileSync(`${targetPath}/agentmark/story.jsonl`, storyDataset);
   }
 };
 
@@ -427,11 +762,12 @@ var getClientConfigContent = (options) => {
   const { provider, languageModels, adapter, deploymentMode = "cloud" } = options;
   const adapterConfig = getAdapterConfig(adapter, provider);
   const { modelRegistry, toolRegistry } = adapterConfig.classes;
-  const providerImport = `import { ${provider} } from '@ai-sdk/${provider}';`;
-  const extraModelRegs = provider === "openai" ? `.registerModels(["dall-e-3"], (name: string) => ${provider}.image(name))
+  const isClaudeAgentSdk = adapter === "claude-agent-sdk";
+  const providerImport = isClaudeAgentSdk ? "" : `import { ${provider} } from '@ai-sdk/${provider}';`;
+  const extraModelRegs = provider === "openai" && !isClaudeAgentSdk ? `.registerModels(["dall-e-3"], (name: string) => ${provider}.image(name))
     .registerModels(["tts-1-hd"], (name: string) => ${provider}.speech(name))` : "";
-  const loaderImport = deploymentMode === "cloud" ? `import { ApiLoader } from "@agentmark/loader-api";` : `import { ApiLoader } from "@agentmark/loader-api";
-import { FileLoader } from "@agentmark/loader-file";`;
+  const loaderImport = deploymentMode === "cloud" ? `import { ApiLoader } from "@agentmark-ai/loader-api";` : `import { ApiLoader } from "@agentmark-ai/loader-api";
+import { FileLoader } from "@agentmark-ai/loader-file";`;
   const loaderSetup = deploymentMode === "cloud" ? `  // ApiLoader works for both development and production
   // - Development: 'agentmark dev' sets AGENTMARK_BASE_URL to localhost
   // - Production: Set AGENTMARK_API_KEY and AGENTMARK_APP_ID for cloud
@@ -443,6 +779,51 @@ import { FileLoader } from "@agentmark/loader-file";`;
       });` : `  const loader = process.env.NODE_ENV === 'development'
     ? ApiLoader.local({ baseUrl: process.env.AGENTMARK_BASE_URL || 'http://localhost:9418' })
     : new FileLoader('./dist/agentmark');`;
+  const modelRegistrySetup = isClaudeAgentSdk ? `function createModelRegistry() {
+  // Claude Agent SDK accepts model names directly.
+  // Use createDefault() for simple pass-through of model names.
+  const modelRegistry = ${modelRegistry}.createDefault();
+
+  // To configure specific models (e.g., extended thinking), use:
+  // const modelRegistry = new ${modelRegistry}()
+  //   .registerModels(/claude-.*-thinking/, (name) => ({
+  //     model: name,
+  //     maxThinkingTokens: 10000,  // Enable extended thinking
+  //   }))
+  //   .registerModels("claude-sonnet-4-20250514", (name) => ({ model: name }));
+
+  return modelRegistry;
+}` : `function createModelRegistry() {
+  const modelRegistry = new ${modelRegistry}()
+    .registerModels(${JSON.stringify(languageModels)}, (name: string) => ${provider}(name))
+    ${extraModelRegs};
+  return modelRegistry;
+}`;
+  const adapterOptionsImport = isClaudeAgentSdk ? `
+// Claude Agent SDK adapter options
+// See: https://github.com/anthropics/claude-agent-sdk
+const adapterOptions = {
+  // Permission mode controls tool access:
+  // - 'default': Requires user approval for each tool use
+  // - 'acceptEdits': Auto-approve file edits only
+  // - 'bypassPermissions': Auto-approve all tools (use for automated pipelines)
+  // - 'plan': Planning mode only, no tool execution
+  permissionMode: 'bypassPermissions' as const,
+
+  // Maximum conversation turns before stopping
+  maxTurns: 20,
+
+  // Optional: Set working directory for file operations
+  // cwd: process.cwd(),
+
+  // Optional: Budget limit in USD
+  // maxBudgetUsd: 10.00,
+
+  // Optional: Restrict which tools the agent can use
+  // allowedTools: ['Read', 'Write', 'Glob'],
+  // disallowedTools: ['Bash'],
+};` : "";
+  const createClientCall = isClaudeAgentSdk ? `return createAgentMarkClient<AgentMarkTypes, typeof toolRegistry>({ loader, modelRegistry, toolRegistry, evalRegistry, adapterOptions });` : `return createAgentMarkClient<AgentMarkTypes, typeof toolRegistry>({ loader, modelRegistry, toolRegistry, evalRegistry });`;
   return `// agentmark.client.ts
 import path from 'node:path';
 import dotenv from 'dotenv';
@@ -451,13 +832,9 @@ import { createAgentMarkClient, ${modelRegistry}, ${toolRegistry}, EvalRegistry
 ${loaderImport}
 import AgentMarkTypes, { Tools } from './agentmark.types';
 ${providerImport}
+${adapterOptionsImport}
 
-function createModelRegistry() {
-  const modelRegistry = new ${modelRegistry}()
-    .registerModels(${JSON.stringify(languageModels)}, (name: string) => ${provider}(name))
-    ${extraModelRegs};
-  return modelRegistry;
-}
+${modelRegistrySetup}
 
 function createToolRegistry() {
   const toolRegistry = new ${toolRegistry}<Tools>()
@@ -504,7 +881,7 @@ ${loaderSetup}
   const modelRegistry = createModelRegistry();
   const toolRegistry = createToolRegistry();
   const evalRegistry = createEvalRegistry();
-  return createAgentMarkClient<AgentMarkTypes, typeof toolRegistry>({ loader, modelRegistry, toolRegistry, evalRegistry });
+  ${createClientCall}
 }
 
 export const client = createClient();
@@ -512,7 +889,100 @@ export const client = createClient();
 };
 
 // src/utils/examples/create-example-app.ts
-import { fetchPromptsFrontmatter, generateTypeDefinitions } from "@agentmark/shared-utils";
+import { fetchPromptsFrontmatter, generateTypeDefinitions } from "@agentmark-ai/shared-utils";
+
+// src/utils/conflict-resolution.ts
+import prompts from "prompts";
+function getPromptableConflicts(conflictingFiles) {
+  return conflictingFiles.filter((file) => file.strategy === "prompt");
+}
+async function promptForSingleConflict(conflict) {
+  const typeLabel = conflict.type === "directory" ? "directory" : "file";
+  const { action } = await prompts({
+    type: "select",
+    name: "action",
+    message: `${conflict.path} already exists. What would you like to do?`,
+    choices: [
+      {
+        title: `Skip (keep existing ${typeLabel})`,
+        value: "skip",
+        description: `Don't modify the existing ${typeLabel}`
+      },
+      {
+        title: "Overwrite",
+        value: "overwrite",
+        description: `Replace with new AgentMark ${typeLabel}`
+      }
+    ],
+    initial: 0
+    // Default to skip for safety
+  });
+  return {
+    path: conflict.path,
+    action: action || "skip"
+  };
+}
+async function promptForResolutions(conflictingFiles) {
+  const promptableConflicts = getPromptableConflicts(conflictingFiles);
+  if (promptableConflicts.length === 0) {
+    return [];
+  }
+  console.log("\n\u26A0\uFE0F  Found existing files that may conflict with AgentMark initialization:\n");
+  const resolutions = [];
+  for (const conflict of promptableConflicts) {
+    const resolution = await promptForSingleConflict(conflict);
+    resolutions.push(resolution);
+  }
+  console.log("");
+  return resolutions;
+}
+function getResolutionAction(filePath, resolutions, conflictingFiles) {
+  const userResolution = resolutions.find((r) => r.path === filePath);
+  if (userResolution) {
+    return userResolution.action;
+  }
+  const conflictFile = conflictingFiles.find((f) => f.path === filePath);
+  if (conflictFile) {
+    switch (conflictFile.strategy) {
+      case "skip":
+        return "skip";
+      case "merge":
+        return "merge";
+      case "append":
+        return "merge";
+      // Append is a form of merge
+      case "prompt":
+        return "skip";
+    }
+  }
+  return "overwrite";
+}
+function shouldMergeFile(filePath, projectInfo, resolutions) {
+  if (!projectInfo || !projectInfo.isExistingProject) {
+    return false;
+  }
+  const action = getResolutionAction(filePath, resolutions, projectInfo.conflictingFiles);
+  return action === "merge";
+}
+function displayProjectDetectionSummary(projectInfo) {
+  if (!projectInfo.isExistingProject) {
+    return;
+  }
+  console.log("\n\u{1F4C1} Detected existing project:");
+  console.log(`   Type: ${projectInfo.type}`);
+  if (projectInfo.type === "typescript") {
+    console.log(`   Package Manager: ${projectInfo.packageManager.name}`);
+  }
+  if (projectInfo.pythonVenv) {
+    console.log(`   Python Venv: ${projectInfo.pythonVenv.name}`);
+  }
+  if (projectInfo.hasAgentmarkDir) {
+    console.log("   \u26A0\uFE0F  AgentMark directory already exists");
+  }
+  console.log("");
+}
+
+// src/utils/examples/create-example-app.ts
 var setupMCPServer = (client, targetPath) => {
   if (client === "skip") {
     console.log("Skipping MCP server setup.");
@@ -522,16 +992,23 @@ var setupMCPServer = (client, targetPath) => {
   if (client === "vscode") {
     try {
       console.log(`Setting up MCP server for VS Code in ${folderName}...`);
-      const vscodeDir = path.join(targetPath, ".vscode");
-      fs3.ensureDirSync(vscodeDir);
+      const vscodeDir = path2.join(targetPath, ".vscode");
+      fs4.ensureDirSync(vscodeDir);
       const mcpConfig = {
         servers: {
           "agentmark-docs": {
             url: "https://docs.agentmark.co/mcp"
+          },
+          "agentmark-traces": {
+            command: "npx",
+            args: ["@agentmark-ai/mcp-server"],
+            env: {
+              AGENTMARK_URL: "http://localhost:9418"
+            }
           }
         }
       };
-      fs3.writeJsonSync(path.join(vscodeDir, "mcp.json"), mcpConfig, { spaces: 2 });
+      fs4.writeJsonSync(path2.join(vscodeDir, "mcp.json"), mcpConfig, { spaces: 2 });
       console.log(`\u2705 MCP server configured for VS Code in ${folderName}/.vscode/mcp.json`);
     } catch (error) {
       console.warn(`Warning: Could not set up MCP server for VS Code:`, error);
@@ -542,16 +1019,23 @@ var setupMCPServer = (client, targetPath) => {
   if (client === "zed") {
     try {
       console.log(`Setting up MCP server for Zed in ${folderName}...`);
-      const zedDir = path.join(targetPath, ".zed");
-      fs3.ensureDirSync(zedDir);
+      const zedDir = path2.join(targetPath, ".zed");
+      fs4.ensureDirSync(zedDir);
       const zedConfig = {
         context_servers: {
           "agentmark-docs": {
             url: "https://docs.agentmark.co/mcp"
+          },
+          "agentmark-traces": {
+            command: "npx",
+            args: ["@agentmark-ai/mcp-server"],
+            env: {
+              AGENTMARK_URL: "http://localhost:9418"
+            }
           }
         }
       };
-      fs3.writeJsonSync(path.join(zedDir, "settings.json"), zedConfig, { spaces: 2 });
+      fs4.writeJsonSync(path2.join(zedDir, "settings.json"), zedConfig, { spaces: 2 });
       console.log(`\u2705 MCP server configured for Zed in ${folderName}/.zed/settings.json`);
     } catch (error) {
       console.warn(`Warning: Could not set up MCP server for Zed:`, error);
@@ -562,16 +1046,23 @@ var setupMCPServer = (client, targetPath) => {
   if (client === "cursor") {
     try {
       console.log(`Setting up MCP server for Cursor in ${folderName}...`);
-      const cursorDir = path.join(targetPath, ".cursor");
-      fs3.ensureDirSync(cursorDir);
+      const cursorDir = path2.join(targetPath, ".cursor");
+      fs4.ensureDirSync(cursorDir);
       const cursorConfig = {
         mcpServers: {
           "agentmark-docs": {
             url: "https://docs.agentmark.co/mcp"
+          },
+          "agentmark-traces": {
+            command: "npx",
+            args: ["@agentmark-ai/mcp-server"],
+            env: {
+              AGENTMARK_URL: "http://localhost:9418"
+            }
           }
         }
       };
-      fs3.writeJsonSync(path.join(cursorDir, "mcp.json"), cursorConfig, { spaces: 2 });
+      fs4.writeJsonSync(path2.join(cursorDir, "mcp.json"), cursorConfig, { spaces: 2 });
       console.log(`\u2705 MCP server configured for Cursor in ${folderName}/.cursor/mcp.json`);
     } catch (error) {
       console.warn(`Warning: Could not set up MCP server for Cursor:`, error);
@@ -587,10 +1078,17 @@ var setupMCPServer = (client, targetPath) => {
           "agentmark-docs": {
             type: "http",
             url: "https://docs.agentmark.co/mcp"
+          },
+          "agentmark-traces": {
+            command: "npx",
+            args: ["@agentmark-ai/mcp-server"],
+            env: {
+              AGENTMARK_URL: "http://localhost:9418"
+            }
           }
         }
       };
-      fs3.writeJsonSync(path.join(targetPath, ".mcp.json"), mcpConfig, { spaces: 2 });
+      fs4.writeJsonSync(path2.join(targetPath, ".mcp.json"), mcpConfig, { spaces: 2 });
       console.log(`\u2705 MCP server configured for Claude Code in ${folderName}/.mcp.json`);
     } catch (error) {
       console.warn(`Warning: Could not set up MCP server for Claude Code:`, error);
@@ -599,70 +1097,112 @@ var setupMCPServer = (client, targetPath) => {
     return;
   }
 };
-var createExampleApp = async (client, targetPath = ".", apiKey = "", adapter = "ai-sdk", deploymentMode = "cloud") => {
+var createExampleApp = async (client, targetPath = ".", apiKey = "", adapter = "ai-sdk", deploymentMode = "cloud", projectInfo = null, resolutions = []) => {
   try {
-    const modelProvider = "openai";
-    const model = "gpt-4o";
-    console.log("Creating Agent Mark example app...");
+    const modelProvider = adapter === "claude-agent-sdk" ? "anthropic" : "openai";
+    const model = adapter === "claude-agent-sdk" ? "claude-sonnet-4-20250514" : "gpt-4o";
+    const isExistingProject = projectInfo?.isExistingProject ?? false;
+    if (isExistingProject) {
+      console.log("Adding AgentMark to existing project...");
+    } else {
+      console.log("Creating AgentMark example app...");
+    }
     const folderName = targetPath;
-    fs3.ensureDirSync(`${targetPath}/agentmark`);
+    fs4.ensureDirSync(`${targetPath}/agentmark`);
     setupMCPServer(client, targetPath);
     createExamplePrompts(model, targetPath, adapter);
     console.log(`\u2705 Example prompts and datasets created in ${folderName}/agentmark/`);
     const langModels = Providers[modelProvider].languageModels.slice(0, 1);
-    fs3.writeFileSync(
+    fs4.writeFileSync(
       `${targetPath}/agentmark.client.ts`,
       getClientConfigContent({ provider: modelProvider, languageModels: langModels, adapter, deploymentMode })
     );
-    fs3.writeFileSync(`${targetPath}/.env`, getEnvFileContent(modelProvider, apiKey));
-    const gitignore = ["node_modules", ".env", "*.agentmark-outputs/", ".agentmark", "dist"].join("\n");
-    fs3.writeFileSync(`${targetPath}/.gitignore`, gitignore);
-    fs3.writeFileSync(
-      `${targetPath}/index.ts`,
-      getIndexFileContent(adapter)
-    );
-    fs3.writeJsonSync(`${targetPath}/tsconfig.json`, getTsConfigContent(), { spaces: 2 });
-    setupPackageJson(targetPath, deploymentMode);
-    installDependencies(modelProvider, targetPath, adapter, deploymentMode);
+    if (shouldMergeFile(".env", projectInfo, resolutions)) {
+      const envVars = {};
+      const apiKeyEnvVar = adapter === "claude-agent-sdk" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
+      if (apiKey) {
+        envVars[apiKeyEnvVar] = apiKey;
+      } else {
+        envVars[apiKeyEnvVar] = adapter === "claude-agent-sdk" ? "your-anthropic-api-key" : "your-openai-api-key";
+      }
+      const result = appendEnv(targetPath, envVars);
+      if (result.added.length > 0) {
+        console.log(`\u2705 Added to .env: ${result.added.join(", ")}`);
+      }
+      if (result.skipped.length > 0) {
+        console.log(`\u23ED\uFE0F  Skipped existing .env vars: ${result.skipped.join(", ")}`);
+      }
+    } else {
+      fs4.writeFileSync(`${targetPath}/.env`, getEnvFileContent(modelProvider, apiKey, adapter));
+    }
+    const gitignoreEntries = ["node_modules/", ".env", "*.agentmark-outputs/", ".agentmark/", "dist/"];
+    if (shouldMergeFile(".gitignore", projectInfo, resolutions)) {
+      const result = appendGitignore(targetPath, gitignoreEntries);
+      if (result.added.length > 0) {
+        console.log(`\u2705 Added to .gitignore: ${result.added.join(", ")}`);
+      }
+      if (result.skipped.length > 0) {
+        console.log(`\u23ED\uFE0F  Already in .gitignore: ${result.skipped.join(", ")}`);
+      }
+    } else {
+      const gitignore = gitignoreEntries.join("\n");
+      fs4.writeFileSync(`${targetPath}/.gitignore`, gitignore);
+    }
+    if (!isExistingProject) {
+      fs4.writeFileSync(
+        `${targetPath}/index.ts`,
+        getIndexFileContent(adapter)
+      );
+    } else {
+      console.log("\u23ED\uFE0F  Skipped index.ts (existing project)");
+    }
+    if (!isExistingProject) {
+      fs4.writeJsonSync(`${targetPath}/tsconfig.json`, getTsConfigContent(), { spaces: 2 });
+    } else {
+      console.log("\u23ED\uFE0F  Skipped tsconfig.json (existing project)");
+    }
+    const packageManager = projectInfo?.packageManager ?? null;
+    setupPackageJson(targetPath, deploymentMode, projectInfo);
+    installDependencies(modelProvider, targetPath, adapter, deploymentMode, packageManager);
     console.log("Generating types from prompts...");
     try {
-      const agentmarkDir = path.join(targetPath, "agentmark");
-      const prompts2 = await fetchPromptsFrontmatter({ rootDir: agentmarkDir });
-      const typeDefinitions = await generateTypeDefinitions(prompts2);
-      fs3.writeFileSync(`${targetPath}/agentmark.types.ts`, typeDefinitions);
+      const agentmarkDir = path2.join(targetPath, "agentmark");
+      const prompts3 = await fetchPromptsFrontmatter({ rootDir: agentmarkDir });
+      const typeDefinitions = await generateTypeDefinitions(prompts3);
+      fs4.writeFileSync(`${targetPath}/agentmark.types.ts`, typeDefinitions);
     } catch (error) {
       console.warn("Warning: Could not generate types automatically:", error);
       console.log("You can generate types later by running: npx agentmark generate-types --root-dir agentmark");
-      fs3.writeFileSync(`${targetPath}/agentmark.types.ts`, `// Auto-generated types from AgentMark
+      fs4.writeFileSync(`${targetPath}/agentmark.types.ts`, `// Auto-generated types from AgentMark
 // Run 'npx agentmark generate-types --root-dir agentmark' to generate types
 export default interface AgentmarkTypes {}
 `);
     }
     console.log("Creating development server entry point...");
-    const agentmarkInternalDir = path.join(targetPath, ".agentmark");
-    fs3.ensureDirSync(agentmarkInternalDir);
-    const adapterConfig = getAdapterConfig(adapter);
+    const agentmarkInternalDir = path2.join(targetPath, ".agentmark");
+    fs4.ensureDirSync(agentmarkInternalDir);
+    const adapterConfig = getAdapterConfig(adapter, modelProvider);
     const { webhookHandler } = adapterConfig.classes;
     const devEntryContent = `// Auto-generated webhook server entry point
 // To customize, create a dev-server.ts file in your project root
 
-import { createWebhookServer } from '@agentmark/cli/runner-server';
+import { createWebhookServer } from '@agentmark-ai/cli/runner-server';
 import { ${webhookHandler} } from '${adapterConfig.package}/runner';
-import { AgentMarkSDK } from '@agentmark/sdk';
+import { AgentMarkSDK } from '@agentmark-ai/sdk';
 import path from 'path';
 
 async function main() {
   const args = process.argv.slice(2);
   const webhookPortArg = args.find(arg => arg.startsWith('--webhook-port='));
-  const fileServerPortArg = args.find(arg => arg.startsWith('--file-server-port='));
+  const apiServerPortArg = args.find(arg => arg.startsWith('--api-server-port='));
 
   const webhookPort = webhookPortArg ? parseInt(webhookPortArg.split('=')[1]) : 9417;
-  const fileServerPort = fileServerPortArg ? parseInt(fileServerPortArg.split('=')[1]) : 9418;
-  const fileServerUrl = \`http://localhost:\${fileServerPort}\`;
+  const apiServerPort = apiServerPortArg ? parseInt(apiServerPortArg.split('=')[1]) : 9418;
+  const apiServerUrl = \`http://localhost:\${apiServerPort}\`;
 
   // Set environment for development mode before importing client
   process.env.NODE_ENV = 'development';
-  process.env.AGENTMARK_BASE_URL = fileServerUrl;
+  process.env.AGENTMARK_BASE_URL = apiServerUrl;
 
   // Now import client - it will pick up the dev environment
   const { client } = await import('../agentmark.client.js');
@@ -671,7 +1211,7 @@ async function main() {
   const sdk = new AgentMarkSDK({
     apiKey: '',
     appId: '',
-    baseUrl: fileServerUrl,
+    baseUrl: apiServerUrl,
   });
   sdk.initTracing({ disableBatch: true });
 
@@ -681,7 +1221,7 @@ async function main() {
   await createWebhookServer({
     port: webhookPort,
     handler,
-    fileServerUrl,
+    apiServerUrl,
     templatesDirectory
   });
 }
@@ -691,7 +1231,7 @@ main().catch((err) => {
   process.exit(1);
 });
 `;
-    fs3.writeFileSync(path.join(agentmarkInternalDir, "dev-entry.ts"), devEntryContent);
+    fs4.writeFileSync(path2.join(agentmarkInternalDir, "dev-entry.ts"), devEntryContent);
     console.log("\n\u2705 Agentmark initialization completed successfully!");
     console.log(
       `
@@ -707,11 +1247,21 @@ main().catch((err) => {
     console.log("\n" + "\u2550".repeat(70));
     console.log("Next Steps");
     console.log("\u2550".repeat(70));
+    const runCmd = packageManager?.runCmd ?? "npm run";
+    const pkgJsonPath = path2.join(targetPath, "package.json");
+    let devScriptName = "dev";
+    if (fs4.existsSync(pkgJsonPath)) {
+      const pkgJson = fs4.readJsonSync(pkgJsonPath);
+      if (pkgJson.scripts?.["agentmark:dev"]) {
+        devScriptName = "agentmark:dev";
+      }
+    }
     console.log("\n Get Started:");
-    if (folderName !== "." && folderName !== "./") {
+    if (folderName !== "." && folderName !== "./" && !isExistingProject) {
       console.log(`  $ cd ${folderName}`);
     }
-    console.log("  $ npm run dev\n");
+    console.log(`  $ ${runCmd} ${devScriptName}
+`);
     console.log("\u2500".repeat(70));
     console.log("Resources");
     console.log("\u2500".repeat(70));
@@ -723,18 +1273,715 @@ main().catch((err) => {
   }
 };
 
+// src/utils/examples/create-python-app.ts
+import fs5 from "fs-extra";
+import * as path3 from "path";
+var setupMCPServer2 = (client, targetPath) => {
+  if (client === "skip") {
+    console.log("Skipping MCP server setup.");
+    return;
+  }
+  const folderName = targetPath;
+  if (client === "vscode") {
+    try {
+      console.log(`Setting up MCP server for VS Code in ${folderName}...`);
+      const vscodeDir = path3.join(targetPath, ".vscode");
+      fs5.ensureDirSync(vscodeDir);
+      const mcpConfig = {
+        servers: {
+          "agentmark-docs": {
+            url: "https://docs.agentmark.co/mcp"
+          },
+          "agentmark-traces": {
+            command: "npx",
+            args: ["@agentmark-ai/mcp-server"],
+            env: {
+              AGENTMARK_URL: "http://localhost:9418"
+            }
+          }
+        }
+      };
+      fs5.writeJsonSync(path3.join(vscodeDir, "mcp.json"), mcpConfig, { spaces: 2 });
+      console.log(`MCP server configured for VS Code in ${folderName}/.vscode/mcp.json`);
+    } catch (error) {
+      console.warn(`Warning: Could not set up MCP server for VS Code:`, error);
+    }
+    return;
+  }
+  if (client === "zed") {
+    try {
+      console.log(`Setting up MCP server for Zed in ${folderName}...`);
+      const zedDir = path3.join(targetPath, ".zed");
+      fs5.ensureDirSync(zedDir);
+      const zedConfig = {
+        context_servers: {
+          "agentmark-docs": {
+            url: "https://docs.agentmark.co/mcp"
+          },
+          "agentmark-traces": {
+            command: "npx",
+            args: ["@agentmark-ai/mcp-server"],
+            env: {
+              AGENTMARK_URL: "http://localhost:9418"
+            }
+          }
+        }
+      };
+      fs5.writeJsonSync(path3.join(zedDir, "settings.json"), zedConfig, { spaces: 2 });
+      console.log(`MCP server configured for Zed in ${folderName}/.zed/settings.json`);
+    } catch (error) {
+      console.warn(`Warning: Could not set up MCP server for Zed:`, error);
+    }
+    return;
+  }
+  if (client === "cursor") {
+    try {
+      console.log(`Setting up MCP server for Cursor in ${folderName}...`);
+      const cursorDir = path3.join(targetPath, ".cursor");
+      fs5.ensureDirSync(cursorDir);
+      const cursorConfig = {
+        mcpServers: {
+          "agentmark-docs": {
+            url: "https://docs.agentmark.co/mcp"
+          },
+          "agentmark-traces": {
+            command: "npx",
+            args: ["@agentmark-ai/mcp-server"],
+            env: {
+              AGENTMARK_URL: "http://localhost:9418"
+            }
+          }
+        }
+      };
+      fs5.writeJsonSync(path3.join(cursorDir, "mcp.json"), cursorConfig, { spaces: 2 });
+      console.log(`MCP server configured for Cursor in ${folderName}/.cursor/mcp.json`);
+    } catch (error) {
+      console.warn(`Warning: Could not set up MCP server for Cursor:`, error);
+    }
+    return;
+  }
+  if (client === "claude-code") {
+    try {
+      console.log(`Setting up MCP server for Claude Code in ${folderName}...`);
+      const mcpConfig = {
+        mcpServers: {
+          "agentmark-docs": {
+            type: "http",
+            url: "https://docs.agentmark.co/mcp"
+          },
+          "agentmark-traces": {
+            command: "npx",
+            args: ["@agentmark-ai/mcp-server"],
+            env: {
+              AGENTMARK_URL: "http://localhost:9418"
+            }
+          }
+        }
+      };
+      fs5.writeJsonSync(path3.join(targetPath, ".mcp.json"), mcpConfig, { spaces: 2 });
+      console.log(`MCP server configured for Claude Code in ${folderName}/.mcp.json`);
+    } catch (error) {
+      console.warn(`Warning: Could not set up MCP server for Claude Code:`, error);
+    }
+    return;
+  }
+};
+var getPyprojectContent = (projectName, adapter) => {
+  if (adapter === "claude-agent-sdk") {
+    return `[project]
+name = "${projectName}"
+version = "0.1.0"
+description = "An AgentMark application using Claude Agent SDK"
+requires-python = ">=3.12"
+dependencies = [
+    "agentmark-claude-agent-sdk>=0.1.0",
+    "agentmark-prompt-core>=0.1.0",
+    "python-dotenv>=1.0.0",
+    "claude-agent-sdk>=0.1.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.21",
+    "mypy>=1.0",
+]
+otel = [
+    "opentelemetry-api>=1.20",
+    "opentelemetry-sdk>=1.20",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.mypy]
+strict = true
+`;
+  }
+  return `[project]
+name = "${projectName}"
+version = "0.1.0"
+description = "An AgentMark application using Pydantic AI"
+requires-python = ">=3.12"
+dependencies = [
+    "agentmark-pydantic-ai>=0.1.0",
+    "agentmark-prompt-core>=0.1.0",
+    "python-dotenv>=1.0.0",
+    "pydantic-ai[openai]>=0.1.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.21",
+    "mypy>=1.0",
+]
+anthropic = ["pydantic-ai[anthropic]"]
+gemini = ["pydantic-ai[gemini]"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.mypy]
+strict = true
+`;
+};
+var getAgentmarkClientContent = (_deploymentMode, adapter) => {
+  if (adapter === "claude-agent-sdk") {
+    return `"""AgentMark client configuration.
+
+This file configures the AgentMark client with Claude Agent SDK adapter.
+Customize the model registry and tool registry as needed.
+"""
+
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+from agentmark.prompt_core import FileLoader
+from agentmark_claude_agent_sdk import (
+    create_claude_agent_client,
+    create_default_model_registry,
+    ClaudeAgentToolRegistry,
+)
+
+# Load environment variables
+load_dotenv()
+
+# Configure model registry with default mappings
+# Supports: claude-* models
+model_registry = create_default_model_registry()
+
+# Configure tool registry for custom tools
+tool_registry = ClaudeAgentToolRegistry()
+
+# Example tool registration:
+# tool_registry.register(
+#     "search",
+#     lambda args, ctx: f"Search results for: {args['query']}",
+#     description="Search the web",
+#     parameters={"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]},
+# )
+
+# Create file loader for local development
+# Uses the project root as base directory for resolving relative paths
+project_root = Path(__file__).parent.resolve()
+loader = FileLoader(base_dir=str(project_root))
+
+# Create the client
+client = create_claude_agent_client(
+    model_registry=model_registry,
+    tool_registry=tool_registry,
+    loader=loader,
+)
+
+__all__ = ["client"]
+`;
+  }
+  return `"""AgentMark client configuration.
+
+This file configures the AgentMark client with Pydantic AI adapter.
+Customize the model registry and tool registry as needed.
+"""
+
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+from agentmark.prompt_core import FileLoader
+from agentmark_pydantic_ai_v0 import (
+    create_pydantic_ai_client,
+    create_default_model_registry,
+    PydanticAIToolRegistry,
+)
+
+# Load environment variables
+load_dotenv()
+
+# Configure model registry with default mappings
+# Supports: gpt-*, claude-*, gemini-*, etc.
+model_registry = create_default_model_registry()
+
+# Configure tool registry for custom tools
+tool_registry = PydanticAIToolRegistry()
+
+# Example tool registration:
+# @tool_registry.register("search")
+# async def search_web(args: dict, ctx: dict | None) -> str:
+#     query = args["query"]
+#     return f"Search results for: {query}"
+
+# Create file loader for local development
+# Uses the project root as base directory for resolving relative paths
+project_root = Path(__file__).parent.resolve()
+loader = FileLoader(base_dir=str(project_root))
+
+# Create the client
+client = create_pydantic_ai_client(
+    model_registry=model_registry,
+    tool_registry=tool_registry,
+    loader=loader,
+)
+
+__all__ = ["client"]
+`;
+};
+var getMainPyContent = (adapter) => {
+  if (adapter === "claude-agent-sdk") {
+    return `"""Example usage of AgentMark with Claude Agent SDK.
+
+Run with: python main.py
+"""
+
+import asyncio
+import json
+from pathlib import Path
+
+from agentmark_claude_agent_sdk import run_text_prompt
+from agentmark_client import client
+
+
+async def main():
+    """Run the party planner prompt."""
+    # Load the prompt AST (in production, use the API loader)
+    prompt_path = Path("agentmark/party-planner.prompt.mdx.json")
+
+    if not prompt_path.exists():
+        print("Prompt file not found. Run 'agentmark build' first.")
+        return
+
+    with open(prompt_path) as f:
+        ast = json.load(f)
+
+    # Load and format the prompt
+    prompt = await client.load_text_prompt(ast)
+    params = await prompt.format(props={
+        "numberOfGuests": 10,
+        "theme": "80s disco",
+        "dietaryRestrictions": ["vegetarian", "gluten-free"],
+    })
+
+    # Execute the prompt
+    print("Running party planner prompt...")
+    result = await run_text_prompt(params)
+
+    print("\\n" + "=" * 50)
+    print("Party Plan:")
+    print("=" * 50)
+    print(result.output)
+    print("\\n" + "-" * 50)
+    print(f"Tokens used: {result.usage}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+`;
+  }
+  return `"""Example usage of AgentMark with Pydantic AI.
+
+Run with: python main.py
+"""
+
+import asyncio
+import json
+from pathlib import Path
+
+from agentmark_pydantic_ai_v0 import run_text_prompt
+from agentmark_client import client
+
+
+async def main():
+    """Run the party planner prompt."""
+    # Load the prompt AST (in production, use the API loader)
+    prompt_path = Path("agentmark/party-planner.prompt.mdx.json")
+
+    if not prompt_path.exists():
+        print("Prompt file not found. Run 'agentmark build' first.")
+        return
+
+    with open(prompt_path) as f:
+        ast = json.load(f)
+
+    # Load and format the prompt
+    prompt = await client.load_text_prompt(ast)
+    params = await prompt.format(props={
+        "numberOfGuests": 10,
+        "theme": "80s disco",
+        "dietaryRestrictions": ["vegetarian", "gluten-free"],
+    })
+
+    # Execute the prompt
+    print("Running party planner prompt...")
+    result = await run_text_prompt(params)
+
+    print("\\n" + "=" * 50)
+    print("Party Plan:")
+    print("=" * 50)
+    print(result.output)
+    print("\\n" + "-" * 50)
+    print(f"Tokens used: {result.usage.total_tokens}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+`;
+};
+var getDevServerContent = (adapter) => {
+  const adapterPackage = adapter === "claude-agent-sdk" ? "agentmark_claude_agent_sdk" : "agentmark_pydantic_ai_v0";
+  return `"""Auto-generated webhook server for AgentMark development.
+
+This server is started by 'npm run dev' (agentmark dev) and handles
+prompt execution requests from the CLI.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from ${adapterPackage} import create_webhook_server
+from agentmark_client import client
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--webhook-port", type=int, default=9417)
+    parser.add_argument("--api-server-port", type=int, default=9418)
+    args = parser.parse_args()
+
+    create_webhook_server(client, args.webhook_port, args.api_server_port)
+`;
+};
+var getEnvContent = (apiKey, adapter) => {
+  if (adapter === "claude-agent-sdk") {
+    return `# Anthropic API Key
+ANTHROPIC_API_KEY=${apiKey}
+`;
+  }
+  return `# OpenAI API Key
+OPENAI_API_KEY=${apiKey}
+
+# For Anthropic models, add:
+# ANTHROPIC_API_KEY=your-key-here
+
+# For Google Gemini models, add:
+# GOOGLE_API_KEY=your-key-here
+`;
+};
+var getGitignoreContent = () => {
+  return `# Python
+__pycache__/
+*.py[cod]
+*$py.class
+.venv/
+venv/
+.env
+
+# AgentMark
+*.agentmark-outputs/
+.agentmark/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+
+# Build
+dist/
+build/
+*.egg-info/
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+`;
+};
+var createPythonApp = async (client, targetPath = ".", apiKey = "", deploymentMode = "cloud", adapter = "pydantic-ai", projectInfo = null, resolutions = []) => {
+  try {
+    const model = adapter === "claude-agent-sdk" ? "claude-sonnet-4-20250514" : "gpt-4o";
+    const adapterDisplayName = adapter === "claude-agent-sdk" ? "Claude Agent SDK" : "Pydantic AI";
+    const isExistingProject = projectInfo?.isExistingProject ?? false;
+    if (isExistingProject) {
+      console.log(`Adding AgentMark to existing Python project with ${adapterDisplayName}...`);
+    } else {
+      console.log(`Creating AgentMark Python app with ${adapterDisplayName}...`);
+    }
+    const folderName = targetPath;
+    fs5.ensureDirSync(`${targetPath}/agentmark`);
+    setupMCPServer2(client, targetPath);
+    createExamplePrompts(model, targetPath, adapter);
+    console.log(`Example prompts and datasets created in ${folderName}/agentmark/`);
+    if (!isExistingProject) {
+      const projectName = path3.basename(targetPath).replace(/[^a-zA-Z0-9_-]/g, "-");
+      fs5.writeFileSync(`${targetPath}/pyproject.toml`, getPyprojectContent(projectName, adapter));
+    } else {
+      console.log("\u23ED\uFE0F  Skipped pyproject.toml (existing project)");
+    }
+    fs5.writeFileSync(`${targetPath}/agentmark_client.py`, getAgentmarkClientContent(deploymentMode, adapter));
+    if (!isExistingProject) {
+      fs5.writeFileSync(`${targetPath}/main.py`, getMainPyContent(adapter));
+    } else {
+      console.log("\u23ED\uFE0F  Skipped main.py (existing project)");
+    }
+    if (shouldMergeFile(".env", projectInfo, resolutions)) {
+      const envVars = {};
+      const apiKeyEnvVar = adapter === "claude-agent-sdk" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
+      if (apiKey) {
+        envVars[apiKeyEnvVar] = apiKey;
+      } else {
+        envVars[apiKeyEnvVar] = adapter === "claude-agent-sdk" ? "your-anthropic-api-key" : "your-openai-api-key";
+      }
+      const result = appendEnv(targetPath, envVars);
+      if (result.added.length > 0) {
+        console.log(`\u2705 Added to .env: ${result.added.join(", ")}`);
+      }
+      if (result.skipped.length > 0) {
+        console.log(`\u23ED\uFE0F  Skipped existing .env vars: ${result.skipped.join(", ")}`);
+      }
+    } else {
+      fs5.writeFileSync(`${targetPath}/.env`, getEnvContent(apiKey, adapter));
+    }
+    const gitignoreEntries = [
+      "__pycache__/",
+      "*.py[cod]",
+      "*$py.class",
+      ".venv/",
+      "venv/",
+      ".env",
+      "*.agentmark-outputs/",
+      ".agentmark/",
+      ".idea/",
+      ".vscode/",
+      "*.swp",
+      "dist/",
+      "build/",
+      "*.egg-info/",
+      ".pytest_cache/",
+      ".coverage",
+      "htmlcov/"
+    ];
+    if (shouldMergeFile(".gitignore", projectInfo, resolutions)) {
+      const result = appendGitignore(targetPath, gitignoreEntries);
+      if (result.added.length > 0) {
+        console.log(`\u2705 Added to .gitignore: ${result.added.join(", ")}`);
+      }
+      if (result.skipped.length > 0) {
+        console.log(`\u23ED\uFE0F  Already in .gitignore: ${result.skipped.join(", ")}`);
+      }
+    } else {
+      fs5.writeFileSync(`${targetPath}/.gitignore`, getGitignoreContent());
+    }
+    const agentmarkInternalDir = path3.join(targetPath, ".agentmark");
+    fs5.ensureDirSync(agentmarkInternalDir);
+    fs5.writeFileSync(path3.join(agentmarkInternalDir, "dev_server.py"), getDevServerContent(adapter));
+    const pythonVenv = projectInfo?.pythonVenv;
+    if (pythonVenv) {
+      console.log(`
+\u{1F4E6} Detected existing Python venv: ${pythonVenv.name}`);
+      console.log("   Remember to activate it before running AgentMark commands.");
+    } else if (!isExistingProject) {
+      console.log("Setting up Python environment...");
+      console.log("Note: You'll need to set up a virtual environment and install dependencies.");
+      console.log("");
+    }
+    console.log("\n\u2705 AgentMark Python initialization completed successfully!");
+    console.log(
+      `
+ \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2557
+ \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551
+ \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u255A\u2588\u2588\u2588\u2588\u2554\u255D    \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551
+ \u2588\u2588\u2554\u2550\u2550\u2550\u255D   \u255A\u2588\u2588\u2554\u255D     \u2588\u2588\u2551   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551
+ \u2588\u2588\u2551        \u2588\u2588\u2551      \u2588\u2588\u2551   \u2588\u2588\u2551  \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551
+ \u255A\u2550\u255D        \u255A\u2550\u255D      \u255A\u2550\u255D   \u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D
+                    + AgentMark
+    `
+    );
+    console.log("\n" + "\u2550".repeat(70));
+    console.log("Next Steps");
+    console.log("\u2550".repeat(70));
+    console.log("\n Get Started:");
+    if (folderName !== "." && folderName !== "./" && !isExistingProject) {
+      console.log(`  $ cd ${folderName}`);
+    }
+    if (pythonVenv) {
+      const activateCmd = process.platform === "win32" ? `${pythonVenv.name}\\Scripts\\activate` : `source ${pythonVenv.name}/bin/activate`;
+      console.log(`  $ ${activateCmd}`);
+      console.log('  $ pip install agentmark-pydantic-ai agentmark-prompt-core python-dotenv "pydantic-ai[openai]"');
+    } else {
+      console.log("  $ python -m venv .venv");
+      console.log("  $ source .venv/bin/activate  # On Windows: .venv\\Scripts\\activate");
+      console.log('  $ pip install -e ".[dev]"');
+    }
+    console.log("  $ npm run dev\n");
+    console.log("\u2500".repeat(70));
+    console.log("Resources");
+    console.log("\u2500".repeat(70));
+    console.log("  Documentation: https://docs.agentmark.co");
+    console.log("\u2550".repeat(70) + "\n");
+  } catch (error) {
+    console.error("Error creating Python app:", error);
+    throw error;
+  }
+};
+
+// src/utils/project-detection.ts
+import fs7 from "fs-extra";
+import path5 from "path";
+
+// src/utils/package-manager.ts
+import fs6 from "fs-extra";
+import path4 from "path";
+function detectPackageManager(targetPath) {
+  const lockFiles = ["yarn.lock", "pnpm-lock.yaml", "bun.lockb", "package-lock.json"];
+  for (const lockFile of lockFiles) {
+    if (fs6.existsSync(path4.join(targetPath, lockFile))) {
+      const config = PACKAGE_MANAGERS[lockFile];
+      if (config) {
+        return config;
+      }
+    }
+  }
+  return DEFAULT_PACKAGE_MANAGER;
+}
+
+// src/utils/project-detection.ts
+var IS_WINDOWS = process.platform === "win32";
+function detectTypeScriptProject(targetPath) {
+  const indicators = ["package.json", "tsconfig.json", "node_modules"];
+  return indicators.some((file) => fs7.existsSync(path5.join(targetPath, file)));
+}
+function detectPythonProject(targetPath) {
+  const indicators = ["pyproject.toml", "requirements.txt", "setup.py", ".venv", "venv"];
+  return indicators.some((file) => fs7.existsSync(path5.join(targetPath, file)));
+}
+function detectPythonVenv(targetPath) {
+  const venvNames = [".venv", "venv"];
+  for (const name of venvNames) {
+    const venvPath = path5.join(targetPath, name);
+    if (fs7.existsSync(venvPath) && fs7.statSync(venvPath).isDirectory()) {
+      const binDir = IS_WINDOWS ? "Scripts" : "bin";
+      const binPath = path5.join(venvPath, binDir);
+      if (fs7.existsSync(binPath)) {
+        const pipExe = IS_WINDOWS ? "pip.exe" : "pip";
+        return {
+          path: venvPath,
+          name,
+          activateCmd: IS_WINDOWS ? `${name}\\Scripts\\activate` : `source ${name}/bin/activate`,
+          pipPath: path5.join(binPath, pipExe)
+        };
+      }
+    }
+  }
+  const envVenv = process.env.VIRTUAL_ENV;
+  if (envVenv && fs7.existsSync(envVenv)) {
+    const resolvedTarget = path5.resolve(targetPath);
+    const resolvedVenv = path5.resolve(envVenv);
+    const isInsideTarget = resolvedVenv.startsWith(resolvedTarget + path5.sep) || resolvedVenv === resolvedTarget;
+    if (!isInsideTarget) {
+      console.warn(
+        `\u26A0\uFE0F  Note: VIRTUAL_ENV (${envVenv}) points outside the target directory. It will not be used for this initialization.`
+      );
+      return null;
+    }
+    const binDir = IS_WINDOWS ? "Scripts" : "bin";
+    const pipExe = IS_WINDOWS ? "pip.exe" : "pip";
+    const name = path5.basename(envVenv);
+    return {
+      path: envVenv,
+      name,
+      activateCmd: IS_WINDOWS ? `${name}\\Scripts\\activate` : `source ${name}/bin/activate`,
+      pipPath: path5.join(envVenv, binDir, pipExe)
+    };
+  }
+  return null;
+}
+function detectConflictingFiles(targetPath) {
+  const existingConflicts = [];
+  for (const conflictFile of CONFLICT_FILES) {
+    const fullPath = path5.join(targetPath, conflictFile.path);
+    if (fs7.existsSync(fullPath)) {
+      existingConflicts.push(conflictFile);
+    }
+  }
+  return existingConflicts;
+}
+function detectProjectInfo(targetPath) {
+  const isTypeScript = detectTypeScriptProject(targetPath);
+  const isPython = detectPythonProject(targetPath);
+  const isExistingProject = isTypeScript || isPython;
+  let type = "unknown";
+  if (isTypeScript && !isPython) {
+    type = "typescript";
+  } else if (isPython && !isTypeScript) {
+    type = "python";
+  } else if (isTypeScript && isPython) {
+    type = "typescript";
+  }
+  const packageManager = detectPackageManager(targetPath);
+  const conflictingFiles = detectConflictingFiles(targetPath);
+  const hasAgentmarkDir = fs7.existsSync(path5.join(targetPath, "agentmark"));
+  const pythonVenv = detectPythonVenv(targetPath);
+  return {
+    isExistingProject,
+    type,
+    packageManager,
+    conflictingFiles,
+    hasAgentmarkDir,
+    pythonVenv
+  };
+}
+function isCurrentDirectory(folderName) {
+  return folderName === "." || folderName === "./" || folderName === ".\\";
+}
+
 // src/index.ts
 var parseArgs = () => {
   const args = process.argv.slice(2);
   let deploymentMode;
+  let language;
   for (const arg of args) {
     if (arg === "--cloud") {
       deploymentMode = "cloud";
     } else if (arg === "--self-host") {
       deploymentMode = "static";
+    } else if (arg === "--python") {
+      language = "python";
+    } else if (arg === "--typescript") {
+      language = "typescript";
     }
   }
-  return { deploymentMode };
+  return { deploymentMode, language };
 };
 var main = async () => {
   const cliArgs = parseArgs();
@@ -745,35 +1992,73 @@ var main = async () => {
     agentmarkPath: "."
   };
   console.log("Initializing project.");
-  const { folderName } = await prompts({
+  const { folderName } = await prompts2({
     name: "folderName",
     type: "text",
     message: "Where would you like to create your AgentMark app?",
     initial: "my-agentmark-app"
   });
-  const targetPath = `./${folderName}`;
-  fs4.ensureDirSync(targetPath);
-  config.builtInModels = ["gpt-4o"];
+  const isCurrentDir = isCurrentDirectory(folderName);
+  const targetPath = isCurrentDir ? process.cwd() : path6.resolve(folderName);
+  if (!isCurrentDir) {
+    fs8.ensureDirSync(targetPath);
+  }
+  const projectInfo = detectProjectInfo(targetPath);
+  if (projectInfo.isExistingProject) {
+    displayProjectDetectionSummary(projectInfo);
+  }
+  const resolutions = await promptForResolutions(projectInfo.conflictingFiles);
+  let language = cliArgs.language;
+  if (!language) {
+    const response = await prompts2({
+      name: "language",
+      type: "select",
+      message: "Which language would you like to use?",
+      choices: [
+        { title: "TypeScript", value: "typescript" },
+        { title: "Python", value: "python" }
+      ]
+    });
+    language = response.language;
+  }
+  let adapter;
+  if (language === "python") {
+    const response = await prompts2({
+      name: "adapter",
+      type: "select",
+      message: "Which adapter would you like to use?",
+      choices: [
+        { title: "Pydantic AI", value: "pydantic-ai" },
+        { title: "Claude Agent SDK", value: "claude-agent-sdk" }
+      ]
+    });
+    adapter = response.adapter;
+  } else {
+    const response = await prompts2({
+      name: "adapter",
+      type: "select",
+      message: "Which adapter would you like to use?",
+      choices: [
+        { title: "AI SDK (Vercel)", value: "ai-sdk" },
+        { title: "Claude Agent SDK", value: "claude-agent-sdk" },
+        { title: "Mastra", value: "mastra" }
+      ]
+    });
+    adapter = response.adapter;
+  }
+  config.builtInModels = adapter === "claude-agent-sdk" ? ["claude-sonnet-4-20250514"] : ["gpt-4o"];
+  const apiKeyName = adapter === "claude-agent-sdk" ? "Anthropic" : "OpenAI";
   let apiKey = "";
-  const { providedApiKey } = await prompts({
+  const { providedApiKey } = await prompts2({
     name: "providedApiKey",
     type: "password",
-    message: `Enter your OpenAI API key (or press Enter to skip):`,
+    message: `Enter your ${apiKeyName} API key (or press Enter to skip):`,
     initial: ""
   });
   apiKey = providedApiKey || "";
-  const { adapter } = await prompts({
-    name: "adapter",
-    type: "select",
-    message: "Which adapter would you like to use?",
-    choices: [
-      { title: "AI SDK (Vercel)", value: "ai-sdk" },
-      { title: "Mastra", value: "mastra" }
-    ]
-  });
   let deploymentMode = cliArgs.deploymentMode;
   if (!deploymentMode) {
-    const response = await prompts({
+    const response = await prompts2({
       name: "deploymentMode",
       type: "select",
       message: "Use AgentMark Cloud or manage yourself?",
@@ -792,7 +2077,7 @@ var main = async () => {
     });
     deploymentMode = response.deploymentMode;
   }
-  const { client } = await prompts({
+  const { client } = await prompts2({
     name: "client",
     type: "select",
     message: "Make your IDE an AgentMark expert",
@@ -804,8 +2089,18 @@ var main = async () => {
       { title: "Skip", value: "skip" }
     ]
   });
-  await createExampleApp(client, targetPath, apiKey, adapter, deploymentMode);
-  fs4.writeJsonSync(`${targetPath}/agentmark.json`, config, { spaces: 2 });
+  if (language === "python") {
+    await createPythonApp(client, targetPath, apiKey, deploymentMode, adapter, projectInfo, resolutions);
+  } else {
+    await createExampleApp(client, targetPath, apiKey, adapter, deploymentMode, projectInfo, resolutions);
+  }
+  const agentmarkJsonPath = path6.join(targetPath, "agentmark.json");
+  const agentmarkJsonResolution = resolutions.find((r) => r.path === "agentmark.json");
+  if (!fs8.existsSync(agentmarkJsonPath) || agentmarkJsonResolution?.action === "overwrite") {
+    fs8.writeJsonSync(agentmarkJsonPath, config, { spaces: 2 });
+  } else if (agentmarkJsonResolution?.action === "skip") {
+    console.log("\u23ED\uFE0F  Skipped agentmark.json (keeping existing file)");
+  }
 };
 main().catch((error) => {
   console.error("Error:", error);